33882 2010-01-19 22:53:45 -0800 The Chromium API should expose EventListeners 2010-01-27 11:52:26 -0800 1 1 1 Unclassified WebKit WebKit API 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 1 jcampan jcampan abarth commit-queue dglazkov eric fishd webkit.review.bot oldest_to_newest 182619 0 jcampan 2010-01-19 22:53:45 -0800 The Chromium API should provide a way to register an EventListener on nodes. 182620 1 46979 jcampan 2010-01-19 22:56:19 -0800 Created attachment 46979 Initial draft of a patch A first shot at providing the event listener API to the Chromium API. 182622 2 46980 jcampan 2010-01-19 23:08:18 -0800 Created attachment 46980 Initial draft of a patch 182629 3 46980 fishd 2010-01-19 23:29:39 -0800 Comment on attachment 46980 Initial draft of a patch > Index: WebKit/chromium/public/WebEvent.h > + virtual bool isUIEvent() const; > + virtual bool isMouseEvent() const; > + virtual bool isMutationEvent() const; On this interface, I think these should be declared as WEBKIT_API bool isFooEvent() const; Note: no need for virtual here since the implementation of these methods is forwarding to m_private->isFooEvent(), and the method call on m_private is virtual. > Index: WebKit/chromium/public/WebEventListener.h ... > +class WebEventListener { > +public: > + // Called when an event is received. > + virtual void handleEvent(const WebEvent&) = 0; > + > + // Called when the listener was detached from the node it was listening > + // to and that no further event will be received. > + // Gives an opportunity to implementation classes to perform necessary > + // clean-up. > + virtual void listenerDetached() {}; > +}; > + > +} // namespace WebKit > + > +#endif > Index: WebKit/chromium/public/WebMutationEvent.h ... > +class WebMutationEvent : public WebEvent { > +public: > + > +#if WEBKIT_IMPLEMENTATION > + WebMutationEvent(const WTF::PassRefPtr<WebCore::Event>&); > +#endif > + > + virtual bool isMutationEvent() const; ^^^ As discussed above, this method can go away. Is the plan to add some accessors to this class? > Index: WebKit/chromium/public/WebNode.h > =================================================================== > --- WebKit/chromium/public/WebNode.h (revision 53524) > +++ WebKit/chromium/public/WebNode.h (working copy) > @@ -34,6 +34,9 @@ > #include "WebCommon.h" > #include "WebString.h" > > +#include <utility> > +#include <wtf/HashMap.h> > + > namespace WebCore { class Node; } > #if WEBKIT_IMPLEMENTATION > namespace WTF { template <typename T> class PassRefPtr; } > @@ -41,6 +44,8 @@ namespace WTF { template <typename T> cl > > namespace WebKit { > class WebDocument; > +class WebEventListener; > +class WebEventListenerPrivate; > class WebFrame; > class WebNodeList; > > @@ -115,6 +120,15 @@ public: > return res; > } > > + virtual void addEventListener( > + const WebString& eventType, > + WebEventListener* listener, > + bool useCapture); > + virtual void removeEventListener( > + const WebString& eventType, > + WebEventListener* listener, > + bool useCapture); > + > protected: > typedef WebCore::Node WebNodePrivate; > void assign(WebNodePrivate*); > @@ -129,6 +143,49 @@ protected: > { > return static_cast<const T*>(m_private); > } > + > +private: > + struct ListenerInfo { > + WebString eventType; > + WebEventListener* listener; > + bool useCapture; > + > + bool operator==(const ListenerInfo& value) const > + { > + return eventType == value.eventType && listener == value.listener && useCapture == value.useCapture; > + } > + > + ListenerInfo(WebString eventType, WebEventListener* listener, bool useCapture) > + : eventType(eventType) > + , listener(listener) > + , useCapture(useCapture) > + { > + } > + }; > + > + struct ListenerInfoHash > + { > + static const bool safeToCompareToEmptyOrDeleted = false; > + static unsigned hash(const ListenerInfo& listenerInfo); > + static bool equal(const ListenerInfo& a, const ListenerInfo& b); > + }; > + > + struct ListenerInfoTraits > + { > + static const bool emptyValueIsZero = false; > + static const bool needsDestruction = false; > + > + typedef ListenerInfo TraitType; > + static void constructDeletedValue(ListenerInfo& slot); > + static bool isDeletedValue(const ListenerInfo& value); > + static ListenerInfo emptyValue(); > + }; > + > + typedef HashMap<ListenerInfo, > + WebEventListenerPrivate*, > + ListenerInfoHash, > + ListenerInfoTraits> WebEventListenerMap; > + WebEventListenerMap m_eventListenerMap; We cannot use HashMap and other WTF classes like this in the public headers. I think I misunderstood our hallway conversation about this approach. > Index: WebKit/chromium/public/WebString.h > =================================================================== > --- WebKit/chromium/public/WebString.h (revision 53524) > +++ WebKit/chromium/public/WebString.h (working copy) > @@ -71,6 +71,7 @@ public: > assign(s); > return *this; > } > + bool operator==(const WebString& s) const; nit: let's instead define a "WEBKIT_API bool equals(const WebString&) const" method. then at global scope, we can define methods like this: inline bool operator==(const WebString& a, const WebString& b) { return a.equals(b); } inline bool operator!=(const WebString& a, const WebString& b) { return !(a == b); } the advantage here is that you can then write expressions like this: WebString x; "foo" == x; as well as std::string y; y == x; this is possible because of the implicit constructors defined on WebString. > + unsigned hash() const; Any public method not implemented inline in the WebKit API needs to be decorated with WEBKIT_API. > Index: WebKit/chromium/src/WebNode.cpp ... > +class WebEventListenerPrivate : public EventListener { > +public: > + WebEventListenerPrivate(WebEventListener* webEventListener) > + : EventListener(EventListener::JSEventListenerType) > + , m_webEventListener(webEventListener) > + { > + } > + virtual ~WebEventListenerPrivate() { > + m_webEventListener->listenerDetached(); > + } > + > + virtual bool operator==(const EventListener& listener) > + { > + return this == &listener; > + } > + > + virtual void handleEvent(ScriptExecutionContext* context, Event* event) > + { > + WebEvent webEvent = WebEvent::createWebEvent(event); > + m_webEventListener->handleEvent(webEvent); > + } > + > +private: > + WebEventListener* m_webEventListener; can we perhaps avoid the map by making WebEventListener hold a private pointer back to the EventListener? 183898 4 47249 jcampan 2010-01-22 17:38:24 -0800 Created attachment 47249 Cleaned-up patch. All needed basic EventListener functionalities implemented. 183900 5 jcampan 2010-01-22 17:43:03 -0800 (In reply to comment #3) > (From update of attachment 46980 [details]) > > Index: WebKit/chromium/public/WebEvent.h > > > + virtual bool isUIEvent() const; > > + virtual bool isMouseEvent() const; > > + virtual bool isMutationEvent() const; > > On this interface, I think these should be declared as WEBKIT_API bool > isFooEvent() const; > > Note: no need for virtual here since the implementation of these methods is > forwarding > to m_private->isFooEvent(), and the method call on m_private is virtual. > > > > Index: WebKit/chromium/public/WebEventListener.h > ... > > +class WebEventListener { > > +public: > > + // Called when an event is received. > > + virtual void handleEvent(const WebEvent&) = 0; > > + > > + // Called when the listener was detached from the node it was listening > > + // to and that no further event will be received. > > + // Gives an opportunity to implementation classes to perform necessary > > + // clean-up. > > + virtual void listenerDetached() {}; > > +}; > > + > > +} // namespace WebKit > > + > > +#endif > > > Index: WebKit/chromium/public/WebMutationEvent.h > ... > > +class WebMutationEvent : public WebEvent { > > +public: > > + > > +#if WEBKIT_IMPLEMENTATION > > + WebMutationEvent(const WTF::PassRefPtr<WebCore::Event>&); > > +#endif > > + > > + virtual bool isMutationEvent() const; > > ^^^ As discussed above, this method can go away. > > Is the plan to add some accessors to this class? Yes, I added the accessors. > > > > Index: WebKit/chromium/public/WebNode.h > > =================================================================== > > --- WebKit/chromium/public/WebNode.h (revision 53524) > > +++ WebKit/chromium/public/WebNode.h (working copy) > > @@ -34,6 +34,9 @@ > > #include "WebCommon.h" > > #include "WebString.h" > > > > +#include <utility> > > +#include <wtf/HashMap.h> > > + > > namespace WebCore { class Node; } > > #if WEBKIT_IMPLEMENTATION > > namespace WTF { template <typename T> class PassRefPtr; } > > @@ -41,6 +44,8 @@ namespace WTF { template <typename T> cl > > > > namespace WebKit { > > class WebDocument; > > +class WebEventListener; > > +class WebEventListenerPrivate; > > class WebFrame; > > class WebNodeList; > > > > @@ -115,6 +120,15 @@ public: > > return res; > > } > > > > + virtual void addEventListener( > > + const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture); > > + virtual void removeEventListener( > > + const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture); > > + > > protected: > > typedef WebCore::Node WebNodePrivate; > > void assign(WebNodePrivate*); > > @@ -129,6 +143,49 @@ protected: > > { > > return static_cast<const T*>(m_private); > > } > > + > > +private: > > + struct ListenerInfo { > > + WebString eventType; > > + WebEventListener* listener; > > + bool useCapture; > > + > > + bool operator==(const ListenerInfo& value) const > > + { > > + return eventType == value.eventType && listener == value.listener && useCapture == value.useCapture; > > + } > > + > > + ListenerInfo(WebString eventType, WebEventListener* listener, bool useCapture) > > + : eventType(eventType) > > + , listener(listener) > > + , useCapture(useCapture) > > + { > > + } > > + }; > > + > > + struct ListenerInfoHash > > + { > > + static const bool safeToCompareToEmptyOrDeleted = false; > > + static unsigned hash(const ListenerInfo& listenerInfo); > > + static bool equal(const ListenerInfo& a, const ListenerInfo& b); > > + }; > > + > > + struct ListenerInfoTraits > > + { > > + static const bool emptyValueIsZero = false; > > + static const bool needsDestruction = false; > > + > > + typedef ListenerInfo TraitType; > > + static void constructDeletedValue(ListenerInfo& slot); > > + static bool isDeletedValue(const ListenerInfo& value); > > + static ListenerInfo emptyValue(); > > + }; > > + > > + typedef HashMap<ListenerInfo, > > + WebEventListenerPrivate*, > > + ListenerInfoHash, > > + ListenerInfoTraits> WebEventListenerMap; > > + WebEventListenerMap m_eventListenerMap; > > We cannot use HashMap and other WTF classes like this in the public headers. > > I think I misunderstood our hallway conversation about this approach. Remove the hash and implemented the WebEventListener keeping a list of the different EventListener as we discussed. > > > > Index: WebKit/chromium/public/WebString.h > > =================================================================== > > --- WebKit/chromium/public/WebString.h (revision 53524) > > +++ WebKit/chromium/public/WebString.h (working copy) > > @@ -71,6 +71,7 @@ public: > > assign(s); > > return *this; > > } > > + bool operator==(const WebString& s) const; > > nit: let's instead define a "WEBKIT_API bool equals(const WebString&) const" > method. > then at global scope, we can define methods like this: > > inline bool operator==(const WebString& a, const WebString& b) > { > return a.equals(b); > } > > inline bool operator!=(const WebString& a, const WebString& b) > { > return !(a == b); > } > > the advantage here is that you can then write expressions like this: > > WebString x; > "foo" == x; > > as well as > > std::string y; > y == x; > > this is possible because of the implicit constructors defined on WebString. > > > > + unsigned hash() const; > > Any public method not implemented inline in the WebKit API needs to be > decorated with WEBKIT_API. > > > > Index: WebKit/chromium/src/WebNode.cpp > ... > > +class WebEventListenerPrivate : public EventListener { > > +public: > > + WebEventListenerPrivate(WebEventListener* webEventListener) > > + : EventListener(EventListener::JSEventListenerType) > > + , m_webEventListener(webEventListener) > > + { > > + } > > + virtual ~WebEventListenerPrivate() { > > + m_webEventListener->listenerDetached(); > > + } > > + > > + virtual bool operator==(const EventListener& listener) > > + { > > + return this == &listener; > > + } > > + > > + virtual void handleEvent(ScriptExecutionContext* context, Event* event) > > + { > > + WebEvent webEvent = WebEvent::createWebEvent(event); > > + m_webEventListener->handleEvent(webEvent); > > + } > > + > > +private: > > + WebEventListener* m_webEventListener; > > can we perhaps avoid the map by making WebEventListener hold a private pointer > back to the EventListener? 184409 6 47249 fishd 2010-01-25 13:28:58 -0800 Comment on attachment 47249 Cleaned-up patch. All needed basic EventListener functionalities implemented. > Index: WebKit/chromium/ChangeLog ... > + Reviewed by NOBODY (OOPS!). > + > + Adding EventListeners to the chromium API. ^^^ Add a bug link here. > + * WebKit.gyp: > + * public/WebEvent.h: Added. > + (WebKit::WebEvent::): > + (WebKit::WebEvent::WebEvent): > + (WebKit::WebEvent::operator=): > + (WebKit::WebEvent::isNull): ^^^ when adding a new file, please remove the lines here that reference the methods contained in that new file. > Index: WebKit/chromium/public/WebEvent.h ... > +#ifndef WebEvent_h > +#define WebEvent_h > + > +#include "WebCommon.h" > +#include "WebNode.h" > +#include "WebString.h" > + > +namespace WebCore { class Event; } > +#if WEBKIT_IMPLEMENTATION > +namespace WTF { template <typename T> class PassRefPtr; } > +#endif > + > +namespace WebKit { > + > +class WebEvent { > +public: > + enum PhaseType { > + CapturingPhase = 1, > + AtTarget = 2, > + BubblingPhase = 3 > + }; > + > + WebEvent() : m_private(0) { } > + WebEvent(const WebEvent& n) : m_private(0) { assign(n); } > + WebEvent& operator=(const WebEvent& n) nit: "n" -> "e" (In WebNode.h, we use "n" as shorthand for node.) > + template<typename T> T toMutationEvent() the point of this being a template is so that it can be used with multiple subclasses. so, calling it toMutationEvent seems wrong. how about just calling it toEvent? WebMutationEvent me = event.toEvent<WebMutationEvent>(); I would even be happy with the method name "to", but then "toConst" looks a little funny. > Index: WebKit/chromium/public/WebEventListener.h ... > +class WebEventListener { > +public: > + WebEventListener(); > + virtual ~WebEventListener(); > + > + // Called when an event is received. > + virtual void handleEvent(const WebEvent&) = 0; > + > +private: > + friend class EventListenerWrapper; > + friend class WebNode; instead of making friends, how about defining public methods wrapped with #if WEBKIT_IMPLEMENTATION? > Index: WebKit/chromium/public/WebMutationEvent.h ... > +namespace WebCore { class Event; } > +#if WEBKIT_IMPLEMENTATION > +namespace WTF { template <typename T> class PassRefPtr; } > +#endif ^^^ this stuff is already declared in WebEvent.h > +namespace WebKit { > + > +class WebMutationEvent : public WebEvent { > +public: > + enum AttrChangeType { > + Modification = 1, > + Addition = 2, > + Removal = 3 > + }; > + > +#if WEBKIT_IMPLEMENTATION > + WebMutationEvent(const WTF::PassRefPtr<WebCore::Event>&); > +#endif nit: convention is to move WEBKIT_IMPLEMENTATION stuff down to the bottom of the class definition. > Index: WebKit/chromium/public/WebNode.h ... > + virtual void addEventListener( > + const WebString& eventType, > + WebEventListener* listener, > + bool useCapture); > + virtual void removeEventListener( > + const WebString& eventType, > + WebEventListener* listener, > + bool useCapture); minor nit: please move these above the toElement and toConstElement methods. they also should not be virtual. please add WEBKIT_API to them. > Index: WebKit/chromium/public/WebString.h ... > assign(s); > return *this; > } > + WEBKIT_API bool equals(const WebString& s) const; nit: butting this up right next to operator= seems to suggest that it is related. instead, how about putting it below assign with a new line separating it from other methods? > Index: WebKit/chromium/src/WebEvent.cpp > +WebString WebEvent::type() const > +{ > + return m_private->type(); in all of the methods that dereference m_private, please add an ASSERT(m_private); > Index: WebKit/chromium/src/WebEventListenerImpl.cpp ... > +#include "WebEventListenerImpl.h" > + > +#include "WebEvent.h" > +#include "WebEventListener.h" > + > +#include "Event.h" > +#include "EventListener.h" webkit api convention is to list the WebCore headers above the WebKit headers. > +WebEventListener::~WebEventListener() > +{ > + // Notifies all WebEventListenerWrappers that we are going away so they can > + // invalidate their pointer to us. > + WTF::Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter; > + for (iter = m_private->m_listenerWrappers.begin(); iter != m_private->m_listenerWrappers.end(); ++iter) { > + iter->eventListenerWrapper->webEventListenerDeleted(); > + } nit: no {}'s around single line statements. > +EventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, > + bool useCapture, > + Node* node) nit: don't wrap these parameters. > +EventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, > + bool useCapture, > + Node* node) ditto > +void EventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event) > +{ > + if (!m_webEventListener) > + return; > + WebEvent webEvent = WebEvent::createWebEvent(event); > + m_webEventListener->handleEvent(webEvent); > +} nit: indent by 4 spaces > +void EventListenerWrapper::webEventListenerDeleted() > +{ > + m_webEventListener = NULL; > +} nit: use 0 instead of NULL > Index: WebKit/chromium/src/WebEventListenerImpl.h ... > +#include "EventListener.h" > + > +#include "WebString.h" > + > +#include <wtf/Vector.h> nit: for consistency with other headers, this should just be: #include "WebString.h" #include "EventListener.h" #include <wtf/Vector.h> > + EventListenerWrapper* createEventListenerWrapper( > + const WebString& eventType, bool useCapture, Node* node); nit: indentation should be 4 spaces > + > + // Gets the ListenerEventWrapper for a specific node. > + // Used by WebNode::removeEventListener(). > + EventListenerWrapper* getEventListenerWrapper( > + const WebString& eventType, bool useCapture, Node* node); ditto > +private: > + friend class WebEventListener; can you just add a public method for WebEventListener to use? not too many people will be using EventListenerWrapper, so it should be OK to expose a public helper method to all, right? > + WTF::Vector<ListenerInfo> m_listenerWrappers; nit: no need for the WTF:: prefix. there is a global "using namespace WTF" > +}; > + > +class EventListenerWrapper : public EventListener there should be separate header files for each class. one for EventListenerWrapper and one for WebEventListenerPrivate. > + virtual bool operator==(const EventListener& listener); > + virtual void handleEvent(ScriptExecutionContext* context, Event* event); nit: in webkit style, you should only mention the parameter name if it adds value. in this case, listener, context, and event are all redundant, so the parameter names should be dropped. > Index: WebKit/chromium/src/WebMutationEvent.cpp ... > +} > + > + nit: remove extra new lines at the bottom of the file > Index: WebKit/chromium/src/WebNode.cpp ... > +void WebNode::addEventListener(const WebString& eventType, > + WebEventListener* listener, > + bool useCapture) nit: either do not wrap the parameters or list them all vertically in a column like so: void Foo(A a, B b, C c) > +void WebNode::removeEventListener(const WebString& eventType, > + WebEventListener* listener, > + bool useCapture) > +{ > + EventListenerWrapper* listenerWrapper = > + listener->m_private->getEventListenerWrapper(eventType, useCapture, m_private); > + m_private->removeEventListener(eventType, listenerWrapper, useCapture); > + // listenerWrapper is now deleted. > +} nit: indent by 4 spaces 184448 7 47377 jcampan 2010-01-25 17:17:54 -0800 Created attachment 47377 Adding event handler to the Chromium API 184449 8 webkit.review.bot 2010-01-25 17:21:28 -0800 Attachment 47377 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebKit/chromium/src/WebEventListenerPrivate.h:50: This { should be at the end of the previous line [whitespace/braces] [4] WebKit/chromium/src/EventListenerWrapper.h:47: This { should be at the end of the previous line [whitespace/braces] [4] WebKit/chromium/src/WebEventListener.cpp:31: Found header this file implements before WebCore config.h. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKit/chromium/src/WebEvent.cpp:31: Found header this file implements before WebCore config.h. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKit/chromium/src/WebEvent.cpp:228: Could not find a newline character at the end of the file. [whitespace/ending_newline] [5] WebKit/chromium/src/EventListenerWrapper.cpp:31: Found header this file implements before WebCore config.h. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKit/chromium/src/WebEventListenerPrivate.cpp:31: Found header this file implements before WebCore config.h. Should be: config.h, primary header, blank line, and then alphabetically sorted. [build/include_order] [4] WebKit/chromium/src/WebEventListenerPrivate.cpp:63: Use 0 instead of NULL. [readability/null] [5] WebKit/chromium/src/WebEventListenerPrivate.cpp:66: Place brace on its own line for function definitions. [whitespace/braces] [4] Total errors found: 9 If any of these errors are false positives, please file a bug against check-webkit-style. 184450 9 webkit.review.bot 2010-01-25 17:24:22 -0800 Attachment 47377 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/210872 184608 10 47415 jcampan 2010-01-26 09:04:30 -0800 Created attachment 47415 Chromium Event Listener API Fixed style issues 184609 11 jcampan 2010-01-26 09:06:28 -0800 (In reply to comment #6) I addressed all the issues you reported. > (From update of attachment 47249 [details]) > > Index: WebKit/chromium/ChangeLog > ... > > + Reviewed by NOBODY (OOPS!). > > + > > + Adding EventListeners to the chromium API. > > ^^^ Add a bug link here. Done. > > > + * WebKit.gyp: > > + * public/WebEvent.h: Added. > > + (WebKit::WebEvent::): > > + (WebKit::WebEvent::WebEvent): > > + (WebKit::WebEvent::operator=): > > + (WebKit::WebEvent::isNull): > > ^^^ when adding a new file, please remove the lines here that > reference the methods contained in that new file. Done. > > > Index: WebKit/chromium/public/WebEvent.h > ... > > +#ifndef WebEvent_h > > +#define WebEvent_h > > + > > +#include "WebCommon.h" > > +#include "WebNode.h" > > +#include "WebString.h" > > + > > +namespace WebCore { class Event; } > > +#if WEBKIT_IMPLEMENTATION > > +namespace WTF { template <typename T> class PassRefPtr; } > > +#endif > > + > > +namespace WebKit { > > + > > +class WebEvent { > > +public: > > + enum PhaseType { > > + CapturingPhase = 1, > > + AtTarget = 2, > > + BubblingPhase = 3 > > + }; > > + > > + WebEvent() : m_private(0) { } > > + WebEvent(const WebEvent& n) : m_private(0) { assign(n); } > > + WebEvent& operator=(const WebEvent& n) > > nit: "n" -> "e" Done. > > + template<typename T> T toMutationEvent() > > the point of this being a template is so that it can be used with > multiple subclasses. so, calling it toMutationEvent seems wrong. > how about just calling it toEvent? > > WebMutationEvent me = event.toEvent<WebMutationEvent>(); > > I would even be happy with the method name "to", but then "toConst" > looks a little funny. Changed to toEvent/toConstEvent. > > > Index: WebKit/chromium/public/WebEventListener.h > ... > > +class WebEventListener { > > +public: > > + WebEventListener(); > > + virtual ~WebEventListener(); > > + > > + // Called when an event is received. > > + virtual void handleEvent(const WebEvent&) = 0; > > + > > +private: > > + friend class EventListenerWrapper; > > + friend class WebNode; > > instead of making friends, how about defining public methods > wrapped with? Done. > > > Index: WebKit/chromium/public/WebMutationEvent.h > ... > > +namespace WebCore { class Event; } > > +#if WEBKIT_IMPLEMENTATION > > +namespace WTF { template <typename T> class PassRefPtr; } > > +#endif > > ^^^ this stuff is already declared in WebEvent.h Removed. > > +namespace WebKit { > > + > > +class WebMutationEvent : public WebEvent { > > +public: > > + enum AttrChangeType { > > + Modification = 1, > > + Addition = 2, > > + Removal = 3 > > + }; > > + > > +#if WEBKIT_IMPLEMENTATION > > + WebMutationEvent(const WTF::PassRefPtr<WebCore::Event>&); > > +#endif > > nit: convention is to move WEBKIT_IMPLEMENTATION stuff down to > the bottom of the class definition. Done. > > Index: WebKit/chromium/public/WebNode.h > ... > > + virtual void addEventListener( > > + const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture); > > + virtual void removeEventListener( > > + const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture); > > minor nit: please move these above the toElement and toConstElement methods. > > they also should not be virtual. please add WEBKIT_API to them. Done. > > Index: WebKit/chromium/public/WebString.h > ... > > assign(s); > > return *this; > > } > > + WEBKIT_API bool equals(const WebString& s) const; > > nit: butting this up right next to operator= seems to suggest that it is > related. instead, how about putting it below assign with a new line separating > it from other methods? Done. > > Index: WebKit/chromium/src/WebEvent.cpp > > > +WebString WebEvent::type() const > > +{ > > + return m_private->type(); > > in all of the methods that dereference m_private, please add an > ASSERT(m_private); Done. > > Index: WebKit/chromium/src/WebEventListenerImpl.cpp > ... > > +#include "WebEventListenerImpl.h" > > + > > +#include "WebEvent.h" > > +#include "WebEventListener.h" > > + > > +#include "Event.h" > > +#include "EventListener.h" > > webkit api convention is to list the WebCore headers > above the WebKit headers. Done. > > +WebEventListener::~WebEventListener() > > +{ > > + // Notifies all WebEventListenerWrappers that we are going away so they can > > + // invalidate their pointer to us. > > + WTF::Vector<WebEventListenerPrivate::ListenerInfo>::const_iterator iter; > > + for (iter = m_private->m_listenerWrappers.begin(); iter != m_private->m_listenerWrappers.end(); ++iter) { > > + iter->eventListenerWrapper->webEventListenerDeleted(); > > + } > > nit: no {}'s around single line statements. Done. > > +EventListenerWrapper* WebEventListenerPrivate::createEventListenerWrapper(const WebString& eventType, > > + bool useCapture, > > + Node* node) > > nit: don't wrap these parameters. Done. > > +EventListenerWrapper* WebEventListenerPrivate::getEventListenerWrapper(const WebString& eventType, > > + bool useCapture, > > + Node* node) > > ditto Done > > +void EventListenerWrapper::handleEvent(ScriptExecutionContext* context, Event* event) > > +{ > > + if (!m_webEventListener) > > + return; > > + WebEvent webEvent = WebEvent::createWebEvent(event); > > + m_webEventListener->handleEvent(webEvent); > > +} > > nit: indent by 4 spaces Done. > > +void EventListenerWrapper::webEventListenerDeleted() > > +{ > > + m_webEventListener = NULL; > > +} > > nit: use 0 instead of NULL Done. > > Index: WebKit/chromium/src/WebEventListenerImpl.h > ... > > +#include "EventListener.h" > > + > > +#include "WebString.h" > > + > > +#include <wtf/Vector.h> > > nit: for consistency with other headers, this should just be: > > #include "WebString.h" > > #include "EventListener.h" > #include <wtf/Vector.h> Done. > > + EventListenerWrapper* createEventListenerWrapper( > > + const WebString& eventType, bool useCapture, Node* node); > > nit: indentation should be 4 spaces Done. > > + > > + // Gets the ListenerEventWrapper for a specific node. > > + // Used by WebNode::removeEventListener(). > > + EventListenerWrapper* getEventListenerWrapper( > > + const WebString& eventType, bool useCapture, Node* node); > > ditto Done > > +private: > > + friend class WebEventListener; > > can you just add a public method for WebEventListener to use? not > too many people will be using EventListenerWrapper, so it should be > OK to expose a public helper method to all, right? Done. > > + WTF::Vector<ListenerInfo> m_listenerWrappers; > > nit: no need for the WTF:: prefix. there is a global "using namespace WTF" Done. > > +}; > > + > > +class EventListenerWrapper : public EventListener > > there should be separate header files for each class. one for > EventListenerWrapper > and one for WebEventListenerPrivate. OK, split each class in its own h/cpp files. > > + virtual bool operator==(const EventListener& listener); > > + virtual void handleEvent(ScriptExecutionContext* context, Event* event); > nit: in webkit style, you should only mention the parameter name if it adds > value. in this case, listener, context, and event are all redundant, so the > parameter names should be dropped. Done. > > Index: WebKit/chromium/src/WebMutationEvent.cpp > ... > > +} > > + > > + > > nit: remove extra new lines at the bottom of the file Done. > > Index: WebKit/chromium/src/WebNode.cpp > ... > > +void WebNode::addEventListener(const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture) > > nit: either do not wrap the parameters or list them all vertically in a column > like so: > > void Foo(A a, > B b, > C c) Done. > > +void WebNode::removeEventListener(const WebString& eventType, > > + WebEventListener* listener, > > + bool useCapture) > > +{ > > + EventListenerWrapper* listenerWrapper = > > + listener->m_private->getEventListenerWrapper(eventType, useCapture, m_private); > > + m_private->removeEventListener(eventType, listenerWrapper, useCapture); > > + // listenerWrapper is now deleted. > > +} > > nit: indent by 4 spaces Done. 184675 12 47415 fishd 2010-01-26 12:32:54 -0800 Comment on attachment 47415 Chromium Event Listener API > Index: WebKit/chromium/public/WebEvent.h ... > + WebEvent(const WebEvent& n) : m_private(0) { assign(n); } same nit as before: "n" -> "e" > Index: WebKit/chromium/public/WebEventListener.h ... > +namespace WebCore { class Node; } nit: please wrap this Node declaration with #if WEBKIT_IMPLEMENTATION > Index: WebKit/chromium/public/WebMutationEvent.h ... > +namespace WebCore { class Event; } nit: please wrap this Event declaration with #if WEBKIT_IMPLEMENTATION > Index: WebKit/chromium/src/EventListenerWrapper.h ... > + EventListenerWrapper(WebEventListener* webEventListener); nit: no need to name this parameter. > Index: WebKit/chromium/src/WebEvent.cpp ... > +WebEvent WebEvent::createWebEvent(const WTF::PassRefPtr<WebCore::Event>& event) nit: this method should just be named "create". also, why do we need this method? since WebMutationEvent and all subclasses of WebEvent should have no member variables, we do not need to allocate a WebMutationEvent here. I think a simple WebEvent constructor would work best. > +{ > + if (event->isMutationEvent()) > + return WebMutationEvent(event); nit: indentation error. looking good otherwise. 184693 13 47438 jcampan 2010-01-26 13:09:26 -0800 Created attachment 47438 Chromium Event Listener API 184696 14 jcampan 2010-01-26 13:11:00 -0800 Addressed all issues you reported. (In reply to comment #12) > (From update of attachment 47415 [details]) > > Index: WebKit/chromium/public/WebEvent.h > ... > > + WebEvent(const WebEvent& n) : m_private(0) { assign(n); } > > same nit as before: "n" -> "e" Oops, fixed. > > Index: WebKit/chromium/public/WebEventListener.h > ... > > +namespace WebCore { class Node; } > > nit: please wrap this Node declaration with #if WEBKIT_IMPLEMENTATION Done > > Index: WebKit/chromium/public/WebMutationEvent.h > ... > > +namespace WebCore { class Event; } > > nit: please wrap this Event declaration with #if WEBKIT_IMPLEMENTATION Done > > Index: WebKit/chromium/src/EventListenerWrapper.h > ... > > + EventListenerWrapper(WebEventListener* webEventListener); > > nit: no need to name this parameter. Removed > > Index: WebKit/chromium/src/WebEvent.cpp > ... > > +WebEvent WebEvent::createWebEvent(const WTF::PassRefPtr<WebCore::Event>& event) > > nit: this method should just be named "create". also, why do we need > this method? since WebMutationEvent and all subclasses of WebEvent > should have no member variables, we do not need to allocate a > WebMutationEvent here. > > I think a simple WebEvent constructor would work best. Ah, good point. Removed the method, now only using the constructor. > > +{ > > + if (event->isMutationEvent()) > > + return WebMutationEvent(event); > > nit: indentation error. This code is now gone. 184699 15 webkit.review.bot 2010-01-26 13:13:18 -0800 Attachment 47438 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 Traceback (most recent call last): File "WebKitTools/Scripts/check-webkit-style", line 94, in <module> main() File "WebKitTools/Scripts/check-webkit-style", line 87, in main style_checker.check_patch(patch) File "/mnt/git/webkit-style-queue/WebKitTools/Scripts/webkitpy/style/checker.py", line 932, in check_patch self.check_file(file_path, handle_patch_style_error) File "/mnt/git/webkit-style-queue/WebKitTools/Scripts/webkitpy/style/checker.py", line 897, in check_file process_file(processor, file_path, handle_style_error) File "/mnt/git/webkit-style-queue/WebKitTools/Scripts/webkitpy/style/checker.py", line 858, in _process_file 'One or more unexpected \\r (^M) found;' TypeError: handle_patch_style_error() takes exactly 4 arguments (5 given) If any of these errors are false positives, please file a bug against check-webkit-style. 184706 16 webkit.review.bot 2010-01-26 13:45:55 -0800 Attachment 47438 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/214483 184718 17 eric 2010-01-26 14:04:25 -0800 Something confused the stylebot. abarth is your man. 184728 18 47438 fishd 2010-01-26 14:16:16 -0800 Comment on attachment 47438 Chromium Event Listener API > Index: WebKit/chromium/public/WebEvent.h ... > + template<typename T> T* unwrap() > + { > + return static_cast<T*>(m_private); > + } > + > + template<typename T> const T* constUnwrap() const > + { > + return static_cast<const T*>(m_private); > + } ^^^ these unwrap methods are not used. everything else LGTM. also, it looks like the it doesn't compile properly under chromium linux. 184788 19 47453 jcampan 2010-01-26 15:27:39 -0800 Created attachment 47453 Chromium Event Listener API Removed the unused unwrap methods in WebEvent.h Fixed some includes to fix the build. 184789 20 jcampan 2010-01-26 15:28:24 -0800 (In reply to comment #18) > (From update of attachment 47438 [details]) > > Index: WebKit/chromium/public/WebEvent.h > ... > > + template<typename T> T* unwrap() > > + { > > + return static_cast<T*>(m_private); > > + } > > + > > + template<typename T> const T* constUnwrap() const > > + { > > + return static_cast<const T*>(m_private); > > + } > > ^^^ these unwrap methods are not used. Removed. > everything else LGTM. > > > also, it looks like the it doesn't compile properly under chromium linux. I'll keep an eye on the try bot. 185085 21 47453 commit-queue 2010-01-27 07:15:28 -0800 Comment on attachment 47453 Chromium Event Listener API Clearing flags on attachment: 47453 Committed r53934: <http://trac.webkit.org/changeset/53934> 185086 22 commit-queue 2010-01-27 07:15:40 -0800 All reviewed patches have been landed. Closing bug. 185132 23 fishd 2010-01-27 09:57:32 -0800 It turns out that WebMutationEvent.cpp was missing from the last patch. I went ahead and checked that in to fix the build bustage. See http://trac.webkit.org/changeset/53939 185169 24 eric 2010-01-27 11:52:26 -0800 Thank you fishd! 46979 2010-01-19 22:56:19 -0800 2010-01-19 23:08:18 -0800 Initial draft of a patch webkit_event2.patch text/plain 28058 jcampan SW5kZXg6IFdlYktpdC5neXANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQuZ3lwCShyZXZpc2lvbiA1 MzUwNikNCisrKyBXZWJLaXQuZ3lwCSh3b3JraW5nIGNvcHkpDQpAQCAtMTA3LDYgKzEwNyw4IEBA DQogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRHJhZ0RhdGEuaCcsCiAgICAgICAgICAgICAg ICAgJ3B1YmxpYy9XZWJFZGl0aW5nQWN0aW9uLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMv V2ViRWxlbWVudC5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dlYkV2ZW50LmgnLAorICAg ICAgICAgICAgICAgICdwdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oJywKICAgICAgICAgICAgICAg ICAncHVibGljL1dlYkZpbGVDaG9vc2VyQ29tcGxldGlvbi5oJywKICAgICAgICAgICAgICAgICAn cHVibGljL1dlYkZpbGVDaG9vc2VyUGFyYW1zLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMv V2ViRmluZE9wdGlvbnMuaCcsCkBAIC0xMzAsNiArMTMyLDcgQEANCiAgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWwuaCcsCiAgICAgICAgICAgICAgICAgJ3B1Ymxp Yy9XZWJNZXNzYWdlUG9ydENoYW5uZWxDbGllbnQuaCcsCiAgICAgICAgICAgICAgICAgJ3B1Ymxp Yy9XZWJNaW1lUmVnaXN0cnkuaCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNdXRhdGlv bkV2ZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTmF2aWdhdGlvblR5cGUuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJOb2RlLmgnLAogICAgICAgICAgICAgICAgICdw dWJsaWMvV2ViTm9kZUNvbGxlY3Rpb24uaCcsCkBAIC0yNTgsNiArMjYxLDcgQEANCiAgICAgICAg ICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJF bnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRpZXMuaCcsCisgICAg ICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2Vi RmlsZUNob29zZXJDb21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2Vi RmlsZUNob29zZXJDb21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZv bnRDYWNoZS5jcHAnLApAQCAtMjc2LDYgKzI4MCw3IEBADQogICAgICAgICAgICAgICAgICdzcmMv V2ViS2l0LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJNZWRpYVBsYXllckNsaWVudElt cGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5o JywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYk11dGF0aW9uRXZlbnQuY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL1dlYk5vZGUuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVD b2xsZWN0aW9uLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJOb2RlTGlzdC5jcHAnLApJ bmRleDogc3JjL1dlYlN0cmluZy5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBzcmMvV2ViU3RyaW5nLmNw cAkocmV2aXNpb24gNTM1MDYpDQorKysgc3JjL1dlYlN0cmluZy5jcHAJKHdvcmtpbmcgY29weSkN CkBAIC04Niw2ICs4NiwyMSBAQA0KICAgICByZXR1cm4gV2ViQ29yZTo6U3RyaW5nOjpmcm9tVVRG OChkYXRhKTsKIH0KIAorYm9vbCBXZWJTdHJpbmc6Om9wZXJhdG9yPT0oY29uc3QgV2ViU3RyaW5n JiBzKSBjb25zdAoreworICAgIGlmIChtX3ByaXZhdGUgJiYgIXMubV9wcml2YXRlIHx8ICFtX3By aXZhdGUgJiYgcy5tX3ByaXZhdGUpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIGlmICgh bV9wcml2YXRlKQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBtX3ByaXZhdGUg PT0gcy5tX3ByaXZhdGU7Cit9CisKK3Vuc2lnbmVkIFdlYlN0cmluZzo6aGFzaCgpIGNvbnN0IHsK KyAgcmV0dXJuIG1fcHJpdmF0ZSA/IG1fcHJpdmF0ZS0+aGFzaCgpIDogMDsKK30KKwogV2ViU3Ry aW5nOjpXZWJTdHJpbmcoY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBzKQogICAgIDogbV9wcml2YXRl KHN0YXRpY19jYXN0PFdlYlN0cmluZ1ByaXZhdGUqPihzLmltcGwoKSkpCiB7CkluZGV4OiBzcmMv V2ViRnJhbWVJbXBsLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIHNyYy9XZWJGcmFtZUltcGwuY3BwCShy ZXZpc2lvbiA1MzUwNikNCisrKyBzcmMvV2ViRnJhbWVJbXBsLmNwcAkod29ya2luZyBjb3B5KQ0K QEAgLTEyNSw2ICsxMjUsOCBAQA0KICNpbmNsdWRlICJXZWJDb25zb2xlTWVzc2FnZS5oIgogI2lu Y2x1ZGUgIldlYkRhdGFTb3VyY2VJbXBsLmgiCiAjaW5jbHVkZSAiV2ViRG9jdW1lbnQuaCIKKyNp bmNsdWRlICJXZWJFdmVudC5oIgorI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXIuaCIKICNpbmNs dWRlICJXZWJGaW5kT3B0aW9ucy5oIgogI2luY2x1ZGUgIldlYkZvcm1FbGVtZW50LmgiCiAjaW5j bHVkZSAiV2ViRnJhbWVDbGllbnQuaCIKQEAgLTE0OTcsNiArMTQ5OSwyOCBAQA0KICAgICByZXR1 cm4gY291bnRlclZhbHVlRm9yRWxlbWVudChlbGVtZW50KTsKIH0KIAordm9pZCBXZWJGcmFtZUlt cGw6OmFkZEV2ZW50TGlzdGVuZXIoY29uc3QgV2ViTm9kZSYgbm9kZSwKKwkJCQkgICAgY29uc3Qg V2ViU3RyaW5nJiBldmVudFR5cGUsCisJCQkJICAgIFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVy LAorCQkJCSAgICBib29sIHVzZUNhcHR1cmUpCit7CisvKgorICAgIFdlYkV2ZW50TGlzdGVuZXJQ cml2YXRlKiBsaXN0ZW5lcldyYXBwZXIgPSBuZXcgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUobGlz dGVuZXIpOworICAgIG5vZGUtPmFkZEV2ZW50TGlzdGVuZXIobm9kZSwgQXRvbWljU3RyaW5nKGV2 ZW50VHlwZS5kYXRhKCksIGV2ZW50VHlwZS5sZW5ndGgoKSksIGxpc3RlbmVyV3JhcHBlciwgdXNl Q2FwdHVyZSk7CisqLworfQorCit2b2lkIFdlYkZyYW1lSW1wbDo6cmVtb3ZlRXZlbnRMaXN0ZW5l cihjb25zdCBXZWJOb2RlJiBub2RlLAorCQkJCSAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2ZW50 VHlwZSwKKwkJCQkgICAgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsCisJCQkJICAgICAg IGJvb2wgdXNlQ2FwdHVyZSkKK3sKKy8qCisgICAgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUgbGlz dGVuZXJXcmFwcGVyKGxpc3RlbmVyKTsKKyAgICBub2RlLT5hZGRFdmVudExpc3RlbmVyKEF0b21p Y1N0cmluZyhldmVudFR5cGUuZGF0YSgpLCBldmVudFR5cGUubGVuZ3RoKCkpLCBsaXN0ZW5lcldy YXBwZXIsIHVzZUNhcHR1cmUpOworKi8KK30KKwogLy8gV2ViRnJhbWVJbXBsIHB1YmxpYyAtLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAog UGFzc1JlZlB0cjxXZWJGcmFtZUltcGw+IFdlYkZyYW1lSW1wbDo6Y3JlYXRlKFdlYkZyYW1lQ2xp ZW50KiBjbGllbnQpCkBAIC0xNjgzLDcgKzE3MDcsNyBAQA0KICAgICAgICAgc3RhdGljX2Nhc3Q8 SFRNTEZyYW1lT3duZXJFbGVtZW50Kj4oZWxlbWVudCk7CiAgICAgcmV0dXJuIGZyb21GcmFtZShm cmFtZUVsZW1lbnQtPmNvbnRlbnRGcmFtZSgpKTsKIH0KLSAgICAKKwogV2ViVmlld0ltcGwqIFdl YkZyYW1lSW1wbDo6dmlld0ltcGwoKSBjb25zdAogewogICAgIGlmICghbV9mcmFtZSkKSW5kZXg6 IHNyYy9XZWJFdmVudC5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBzcmMvV2ViRXZlbnQuY3BwCShyZXZp c2lvbiAwKQ0KKysrIHNyYy9XZWJFdmVudC5jcHAJKHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDIw MiBAQA0KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAq CisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICog aW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2Vk IHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29m dHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENP TlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQK KyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKworI2luY2x1ZGUgIkV2ZW50LmgiCisjaW5jbHVk ZSAiTm9kZS5oIgorI2luY2x1ZGUgIldlYk11dGF0aW9uRXZlbnQuaCIKKyNpbmNsdWRlIDx3dGYv UGFzc1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2ViRXZlbnRQcml2 YXRlIDogcHVibGljIFdlYkNvcmU6OkV2ZW50IHsKK307CisKK3ZvaWQgV2ViRXZlbnQ6OnJlc2V0 KCkKK3sKKyAgICBhc3NpZ24oMCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihjb25zdCBX ZWJFdmVudCYgb3RoZXIpCit7CisgICAgV2ViRXZlbnRQcml2YXRlKiBwID0gY29uc3RfY2FzdDxX ZWJFdmVudFByaXZhdGUqPihvdGhlci5tX3ByaXZhdGUpOworICAgIGlmIChwKQorICAgICAgICBw LT5yZWYoKTsKKyAgICBhc3NpZ24ocCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihXZWJF dmVudFByaXZhdGUqIHApCit7CisgICAgLy8gcCBpcyBhbHJlYWR5IHJlZidkIGZvciB1cyBieSB0 aGUgY2FsbGVyCisgICAgaWYgKG1fcHJpdmF0ZSkKKyAgICAgICAgbV9wcml2YXRlLT5kZXJlZigp OworICAgIG1fcHJpdmF0ZSA9IHA7Cit9CisKK1dlYkV2ZW50OjpXZWJFdmVudChjb25zdCBXVEY6 OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+JiBldmVudCkKKyAgICA6IG1fcHJpdmF0ZShzdGF0 aWNfY2FzdDxXZWJFdmVudFByaXZhdGUqPihldmVudC5yZWxlYXNlUmVmKCkpKQoreworfQorCitX ZWJTdHJpbmcgV2ViRXZlbnQ6OnR5cGUoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUt PnR5cGUoKTsKK30KKworV2ViTm9kZSBXZWJFdmVudDo6dGFyZ2V0KCkgY29uc3QKK3sKKyAgICBy ZXR1cm4gV2ViTm9kZShtX3ByaXZhdGUtPnRhcmdldCgpLT50b05vZGUoKSk7Cit9CisKK1dlYk5v ZGUgV2ViRXZlbnQ6OmN1cnJlbnRUYXJnZXQoKSBjb25zdAoreworICAgIHJldHVybiBXZWJOb2Rl KG1fcHJpdmF0ZS0+Y3VycmVudFRhcmdldCgpLT50b05vZGUoKSk7Cit9CisKK1dlYkV2ZW50OjpQ aGFzZVR5cGUgV2ViRXZlbnQ6OmV2ZW50UGhhc2UoKSBjb25zdAoreworICAgIHJldHVybiBzdGF0 aWNfY2FzdDxXZWJFdmVudDo6UGhhc2VUeXBlPihtX3ByaXZhdGUtPmV2ZW50UGhhc2UoKSk7Cit9 CisKK2Jvb2wgV2ViRXZlbnQ6OmJ1YmJsZXMoKSBjb25zdCB7CisgICAgcmV0dXJuIG1fcHJpdmF0 ZS0+YnViYmxlcygpOworfQorCitib29sIFdlYkV2ZW50OjpjYW5jZWxhYmxlKCkgY29uc3QKK3sK KyAgICByZXR1cm4gbV9wcml2YXRlLT5jYW5jZWxhYmxlKCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6 OmlzVUlFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2 ZW50Ojppc01vdXNlRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9v bCBXZWJFdmVudDo6aXNNdXRhdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc1RleHRFdmVudCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNEcmFn RXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6 aXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29s IFdlYkV2ZW50Ojppc01lc3NhZ2VFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOwor fQorCitib29sIFdlYkV2ZW50Ojppc1doZWVsRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBm YWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudCgpIGNv bnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc092ZXJmbG93 RXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6 aXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K2Jvb2wgV2ViRXZlbnQ6OmlzUG9wU3RhdGVFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZh bHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc1Byb2dyZXNzRXZlbnQoKSBjb25zdAoreworICAg IHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dy ZXNzRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVu dDo6aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOwor fQorCitib29sIFdlYkV2ZW50Ojppc1dlYktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc0JlZm9yZUxvYWRFdmVudCgp IGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitXZWJFdmVudCBXZWJFdmVudDo6Y3Jl YXRlV2ViRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZlbnQp Cit7CisgICAgaWYgKGV2ZW50LT5pc011dGF0aW9uRXZlbnQoKSkKKyAgICAgIHJldHVybiBXZWJN dXRhdGlvbkV2ZW50KGV2ZW50KTsKKworICAgIC8vIFRPRE8oamNhbXBhbik6IGltcGxlbWVudCBv dGhlciBldmVudHMuCisgICAgcmV0dXJuIFdlYkV2ZW50KCk7Cit9CisKK30NClwgTm8gbmV3bGlu ZSBhdCBlbmQgb2YgZmlsZQ0KSW5kZXg6IHNyYy9XZWJGcmFtZUltcGwuaA0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0K LS0tIHNyYy9XZWJGcmFtZUltcGwuaAkocmV2aXNpb24gNTM1MDYpDQorKysgc3JjL1dlYkZyYW1l SW1wbC5oCSh3b3JraW5nIGNvcHkpDQpAQCAtODgsNyArODgsNyBAQA0KICAgICB2aXJ0dWFsIFdl YkZyYW1lKiBmaW5kQ2hpbGRCeUV4cHJlc3Npb24oY29uc3QgV2ViU3RyaW5nJikgY29uc3Q7CiAg ICAgdmlydHVhbCBXZWJEb2N1bWVudCBkb2N1bWVudCgpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9p ZCBmb3JtcyhXZWJWZWN0b3I8V2ViRm9ybUVsZW1lbnQ+JikgY29uc3Q7Ci0gICAgdmlydHVhbCBX ZWJBbmltYXRpb25Db250cm9sbGVyKiBhbmltYXRpb25Db250cm9sbGVyKCk7IAorICAgIHZpcnR1 YWwgV2ViQW5pbWF0aW9uQ29udHJvbGxlciogYW5pbWF0aW9uQ29udHJvbGxlcigpOwogICAgIHZp cnR1YWwgV2ViU2VjdXJpdHlPcmlnaW4gc2VjdXJpdHlPcmlnaW4oKSBjb25zdDsKICAgICB2aXJ0 dWFsIHZvaWQgZ3JhbnRVbml2ZXJzYWxBY2Nlc3MoKTsKICAgICB2aXJ0dWFsIE5QT2JqZWN0KiB3 aW5kb3dPYmplY3QoKSBjb25zdDsKQEAgLTE2Myw2ICsxNjMsMTIgQEANCiAgICAgdmlydHVhbCBX ZWJTdHJpbmcgY29udGVudEFzTWFya3VwKCkgY29uc3Q7CiAgICAgdmlydHVhbCBXZWJTdHJpbmcg cmVuZGVyVHJlZUFzVGV4dCgpIGNvbnN0OwogICAgIHZpcnR1YWwgV2ViU3RyaW5nIGNvdW50ZXJW YWx1ZUZvckVsZW1lbnRCeUlkKGNvbnN0IFdlYlN0cmluZyYgaWQpIGNvbnN0OworICAgIHZpcnR1 YWwgdm9pZCBhZGRFdmVudExpc3RlbmVyKAorICAgICAgICBjb25zdCBXZWJOb2RlJiBub2RlLCBj b25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsCisJ Ym9vbCB1c2VDYXB0dXJlKTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlRXZlbnRMaXN0ZW5lcigK KyAgICAgICAgY29uc3QgV2ViTm9kZSYgbm9kZSwgY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUs IFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLAorCWJvb2wgdXNlQ2FwdHVyZSk7CiAKICAgICBz dGF0aWMgUGFzc1JlZlB0cjxXZWJGcmFtZUltcGw+IGNyZWF0ZShXZWJGcmFtZUNsaWVudCogY2xp ZW50KTsKICAgICB+V2ViRnJhbWVJbXBsKCk7CkluZGV4OiBzcmMvV2ViTXV0YXRpb25FdmVudC5j cHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0NCi0tLSBzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAJKHJldmlzaW9uIDAp DQorKysgc3JjL1dlYk11dGF0aW9uRXZlbnQuY3BwCShyZXZpc2lvbiAwKQ0KQEAgLTAsMCArMSw0 NyBAQA0KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAq CisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICog aW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRo IHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2Vk IHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29m dHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENP TlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQK KyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiV2ViTXV0YXRpb25FdmVudC5oIgorCituYW1lc3BhY2UgV2ViS2l0IHsK KworV2ViTXV0YXRpb25FdmVudDo6V2ViTXV0YXRpb25FdmVudChjb25zdCBXVEY6OlBhc3NSZWZQ dHI8V2ViQ29yZTo6RXZlbnQ+JiBldmVudCkKKyAgICA6IFdlYkV2ZW50KGV2ZW50KQoreworfQor Citib29sIFdlYk11dGF0aW9uRXZlbnQ6OmlzTXV0YXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAg cmV0dXJuIHRydWU7Cit9CisKK30KKworCkluZGV4OiBzcmMvV2ViTm9kZS5jcHANCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0NCi0tLSBzcmMvV2ViTm9kZS5jcHAJKHJldmlzaW9uIDUzNTA2KQ0KKysrIHNyYy9XZWJOb2Rl LmNwcAkod29ya2luZyBjb3B5KQ0KQEAgLTM4LDYgKzM4LDggQEANCiAjaW5jbHVkZSAiTm9kZUxp c3QuaCIKIAogI2luY2x1ZGUgIldlYkRvY3VtZW50LmgiCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIK KyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgi CiAjaW5jbHVkZSAiV2ViTm9kZUxpc3QuaCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKQEAgLTU0 LDYgKzU2LDMyIEBADQogY2xhc3MgV2ViTm9kZVByaXZhdGUgOiBwdWJsaWMgTm9kZSB7CiB9Owog CitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZSA6IHB1YmxpYyBFdmVudExpc3RlbmVyIHsK K3B1YmxpYzoKKyAgICBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZShXZWJFdmVudExpc3RlbmVyKiB3 ZWJFdmVudExpc3RlbmVyKQorICAgICAgICA6IEV2ZW50TGlzdGVuZXIoRXZlbnRMaXN0ZW5lcjo6 SlNFdmVudExpc3RlbmVyVHlwZSkKKyAgICAgICAgLCBtX3dlYkV2ZW50TGlzdGVuZXIod2ViRXZl bnRMaXN0ZW5lcikKKyAgICB7CisgICAgfQorICAgIHZpcnR1YWwgfldlYkV2ZW50TGlzdGVuZXJQ cml2YXRlKCkgeworICAgICAgICBtX3dlYkV2ZW50TGlzdGVuZXItPmxpc3RlbmVyRGV0YWNoZWQo KTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgb3BlcmF0b3I9PShjb25zdCBFdmVudExpc3Rl bmVyJiBsaXN0ZW5lcikKKyAgICB7CisgICAgICAgIHJldHVybiB0aGlzID09ICZsaXN0ZW5lcjsK KyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlRXZlbnQoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KQorICAgIHsKKyAgICAgIFdlYkV2ZW50IHdlYkV2 ZW50ID0gV2ViRXZlbnQ6OmNyZWF0ZVdlYkV2ZW50KGV2ZW50KTsKKyAgICAgIG1fd2ViRXZlbnRM aXN0ZW5lci0+aGFuZGxlRXZlbnQod2ViRXZlbnQpOworICAgIH0KKworcHJpdmF0ZToKKyAgICBX ZWJFdmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7Cit9OworCiB2b2lkIFdlYk5vZGU6 OnJlc2V0KCkKIHsKICAgICBhc3NpZ24oMCk7CkBAIC0xNzMsNCArMjAxLDYyIEBADQogICAgIHJl dHVybiBtX3ByaXZhdGUtPmlzRWxlbWVudE5vZGUoKTsKIH0KIAordm9pZCBXZWJOb2RlOjphZGRF dmVudExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLAorICAgIFdlYkV2ZW50TGlz dGVuZXIqIGxpc3RlbmVyLAorICAgIGJvb2wgdXNlQ2FwdHVyZSkKK3sKKyAgICBXZWJFdmVudExp c3RlbmVyUHJpdmF0ZSogbGlzdGVuZXJQcml2YXRlID0gbmV3IFdlYkV2ZW50TGlzdGVuZXJQcml2 YXRlKGxpc3RlbmVyKTsKKyAgICAvLyBUaGUgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUgaXMgb3du ZWQgYnkgdGhlIG5vZGUuICBXZSBvbmx5IGtlZXAgYSBzb2Z0LXJlZmVyZW5jZQorICAgIC8vIHRv IGl0IHNvIHdlIGNhbiBob25vciBhbnkgcmVtb3ZlRXZlbnRMaXN0ZW5lciBjYWxscy4KKyAgICBM aXN0ZW5lckluZm8gbGlzdGVuZXJJbmZvKGV2ZW50VHlwZSwgbGlzdGVuZXIsIHVzZUNhcHR1cmUp OworICAgIEFTU0VSVCghbV9ldmVudExpc3RlbmVyTWFwLmNvbnRhaW5zKGxpc3RlbmVySW5mbykp OworICAgIG1fZXZlbnRMaXN0ZW5lck1hcC5hZGQobGlzdGVuZXJJbmZvLCBsaXN0ZW5lclByaXZh dGUpOworICAgIG1fcHJpdmF0ZS0+YWRkRXZlbnRMaXN0ZW5lcihldmVudFR5cGUsIGFkb3B0UmVm KGxpc3RlbmVyUHJpdmF0ZSksIGZhbHNlKTsKK30KKwordm9pZCBXZWJOb2RlOjpyZW1vdmVFdmVu dExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLAorICAgIFdlYkV2ZW50TGlzdGVu ZXIqIGxpc3RlbmVyLAorICAgIGJvb2wgdXNlQ2FwdHVyZSkKK3sKKyAgICBMaXN0ZW5lckluZm8g bGlzdGVuZXJJbmZvKGV2ZW50VHlwZSwgbGlzdGVuZXIsIHVzZUNhcHR1cmUpOworICAgIEFTU0VS VChtX2V2ZW50TGlzdGVuZXJNYXAuY29udGFpbnMobGlzdGVuZXJJbmZvKSk7CisgICAgV2ViRXZl bnRMaXN0ZW5lclByaXZhdGUqIGxpc3RlbmVyUHJpdmF0ZSA9IG1fZXZlbnRMaXN0ZW5lck1hcC5n ZXQobGlzdGVuZXJJbmZvKTsKKyAgICBtX3ByaXZhdGUtPnJlbW92ZUV2ZW50TGlzdGVuZXIoZXZl bnRUeXBlLCBsaXN0ZW5lclByaXZhdGUsIGZhbHNlKTsKK30KKworLy8gc3RhdGljCit1bnNpZ25l ZCBXZWJOb2RlOjpMaXN0ZW5lckluZm9IYXNoOjpoYXNoKGNvbnN0IExpc3RlbmVySW5mbyYgbGlz dGVuZXJJbmZvKQoreworICAgIHVuc2lnbmVkIHJlc3VsdCA9IGxpc3RlbmVySW5mby5ldmVudFR5 cGUuaGFzaCgpOworICAgIHJlc3VsdCA9IDM3ICogcmVzdWx0ICsgKGxpc3RlbmVySW5mby51c2VD YXB0dXJlID8gMCA6IDEpOworICAgIHJlc3VsdCA9IDM3ICogcmVpbnRlcnByZXRfY2FzdDx1aW50 cHRyX3Q+KGxpc3RlbmVySW5mby5saXN0ZW5lcik7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKwor Ly8gc3RhdGljCitib29sIFdlYk5vZGU6Okxpc3RlbmVySW5mb0hhc2g6OmVxdWFsKGNvbnN0IExp c3RlbmVySW5mbyYgYSwgY29uc3QgTGlzdGVuZXJJbmZvJiBiKQoreworICByZXR1cm4gYS5ldmVu dFR5cGUgPT0gYi5ldmVudFR5cGUgJiYgYS5saXN0ZW5lciA9PSBiLmxpc3RlbmVyICYmIGEudXNl Q2FwdHVyZSA9PSBiLnVzZUNhcHR1cmU7Cit9CisKKy8vIHN0YXRpYwordm9pZCBXZWJOb2RlOjpM aXN0ZW5lckluZm9UcmFpdHM6OmNvbnN0cnVjdERlbGV0ZWRWYWx1ZShMaXN0ZW5lckluZm8mIHNs b3QpCit7CisgICAgc2xvdC5ldmVudFR5cGUuYXNzaWduKFdlYlN0cmluZygpKTsKKyAgICBzbG90 Lmxpc3RlbmVyID0gTlVMTDsKKyAgICBzbG90LnVzZUNhcHR1cmUgPSBmYWxzZTsKK30KKworLy8g c3RhdGljCitib29sIFdlYk5vZGU6Okxpc3RlbmVySW5mb1RyYWl0czo6aXNEZWxldGVkVmFsdWUo Y29uc3QgTGlzdGVuZXJJbmZvJiB2YWx1ZSkKK3sKKyAgICByZXR1cm4gdmFsdWUuZXZlbnRUeXBl LmlzTnVsbCgpICYmICF2YWx1ZS5saXN0ZW5lciAmJiAhdmFsdWUudXNlQ2FwdHVyZTsKK30KKwor Ly8gc3RhdGljCitXZWJOb2RlOjpMaXN0ZW5lckluZm8gV2ViTm9kZTo6TGlzdGVuZXJJbmZvVHJh aXRzOjplbXB0eVZhbHVlKCkKK3sKKyAgICByZXR1cm4gTGlzdGVuZXJJbmZvKFdlYlN0cmluZygp LCBOVUxMLCBmYWxzZSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApJbmRleDogcHVibGlj L1dlYlN0cmluZy5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gcHVibGljL1dlYlN0cmluZy5oCShyZXZpc2lv biA1MzUwNikNCisrKyBwdWJsaWMvV2ViU3RyaW5nLmgJKHdvcmtpbmcgY29weSkNCkBAIC03MSw2 ICs3MSw3IEBADQogICAgICAgICBhc3NpZ24ocyk7CiAgICAgICAgIHJldHVybiAqdGhpczsKICAg ICB9CisgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdlYlN0cmluZyYgcykgY29uc3Q7CiAKICAg ICBXRUJLSVRfQVBJIHZvaWQgcmVzZXQoKTsKICAgICBXRUJLSVRfQVBJIHZvaWQgYXNzaWduKGNv bnN0IFdlYlN0cmluZyYpOwpAQCAtODcsNiArODgsOCBAQA0KICAgICBXRUJLSVRfQVBJIHN0YXRp YyBXZWJTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hhciogZGF0YSwgc2l6ZV90IGxlbmd0aCk7CiAg ICAgV0VCS0lUX0FQSSBzdGF0aWMgV2ViU3RyaW5nIGZyb21VVEY4KGNvbnN0IGNoYXIqIGRhdGEp OwogCisgICAgdW5zaWduZWQgaGFzaCgpIGNvbnN0OworCiAgICAgdGVtcGxhdGUgPGludCBOPiBX ZWJTdHJpbmcoY29uc3QgY2hhciAoJmRhdGEpW05dKQogICAgICAgICA6IG1fcHJpdmF0ZSgwKQog ICAgIHsKSW5kZXg6IHB1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgNCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBw dWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oCShyZXZpc2lvbiAwKQ0KKysrIHB1YmxpYy9XZWJFdmVu dExpc3RlbmVyLmgJKHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDU1IEBADQorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRp b24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFt ZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9t b3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNp ZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMg SVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJ QlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisg KiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViRXZl bnRMaXN0ZW5lcl9oCisjZGVmaW5lIFdlYkV2ZW50TGlzdGVuZXJfaAorCisjaW5jbHVkZSAiV2Vi Q29tbW9uLmgiCisjaW5jbHVkZSAiV2ViU3RyaW5nLmgiCisKK25hbWVzcGFjZSBXZWJLaXQgewor CitjbGFzcyBXZWJFdmVudDsKKworY2xhc3MgV2ViRXZlbnRMaXN0ZW5lciB7CitwdWJsaWM6Cisg ICAgLy8gQ2FsbGVkIHdoZW4gYW4gZXZlbnQgaXMgcmVjZWl2ZWQuCisgICAgdmlydHVhbCB2b2lk IGhhbmRsZUV2ZW50KGNvbnN0IFdlYkV2ZW50JikgPSAwOworCisgICAgLy8gQ2FsbGVkIHdoZW4g dGhlIGxpc3RlbmVyIHdhcyBkZXRhY2hlZCBmcm9tIHRoZSBub2RlIGl0IHdhcyBsaXN0ZW5pbmcK KyAgICAvLyB0byBhbmQgdGhhdCBubyBmdXJ0aGVyIGV2ZW50IHdpbGwgYmUgcmVjZWl2ZWQuCisg ICAgLy8gR2l2ZXMgYW4gb3Bwb3J0dW5pdHkgdG8gaW1wbGVtZW50YXRpb24gY2xhc3NlcyB0byBw ZXJmb3JtIG5lY2Vzc2FyeQorICAgIC8vIGNsZWFuLXVwLgorICAgIHZpcnR1YWwgdm9pZCBsaXN0 ZW5lckRldGFjaGVkKCkge307Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlm CkluZGV4OiBwdWJsaWMvV2ViTXV0YXRpb25FdmVudC5oDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gcHVibGlj L1dlYk11dGF0aW9uRXZlbnQuaAkocmV2aXNpb24gMCkNCisrKyBwdWJsaWMvV2ViTXV0YXRpb25F dmVudC5oCShyZXZpc2lvbiAwKQ0KQEAgLTAsMCArMSw1NCBAQA0KKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworI2lmbmRlZiBXZWJNdXRhdGlvbkV2 ZW50X2gKKyNkZWZpbmUgV2ViTXV0YXRpb25FdmVudF9oCisKKyNpbmNsdWRlICJXZWJFdmVudC5o IgorCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIEV2ZW50OyB9CisjaWYgV0VCS0lUX0lNUExF TUVOVEFUSU9OCituYW1lc3BhY2UgV1RGIHsgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGNsYXNzIFBh c3NSZWZQdHI7IH0KKyNlbmRpZgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2ViTXV0 YXRpb25FdmVudCA6IHB1YmxpYyBXZWJFdmVudCB7CitwdWJsaWM6CisKKyNpZiBXRUJLSVRfSU1Q TEVNRU5UQVRJT04KKyAgICBXZWJNdXRhdGlvbkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxX ZWJDb3JlOjpFdmVudD4mKTsKKyNlbmRpZgorCisgICAgdmlydHVhbCBib29sIGlzTXV0YXRpb25F dmVudCgpIGNvbnN0OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpJbmRl eDogcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBwdWJsaWMvV2ViRXZlbnQuaAko cmV2aXNpb24gMCkNCisrKyBwdWJsaWMvV2ViRXZlbnQuaAkocmV2aXNpb24gMCkNCkBAIC0wLDAg KzEsMTA3IEBADQorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgV2ViRXZlbnRfaAorI2RlZmluZSBXZWJFdmVudF9oCisKKyNpbmNs dWRlICJXZWJDb21tb24uaCIKKyNpbmNsdWRlICJXZWJOb2RlLmgiCisjaW5jbHVkZSAiV2ViU3Ry aW5nLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3MgRXZlbnQ7IH0KKyNpZiBXRUJLSVRf SU1QTEVNRU5UQVRJT04KK25hbWVzcGFjZSBXVEYgeyB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gY2xh c3MgUGFzc1JlZlB0cjsgfQorI2VuZGlmCisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBX ZWJFdmVudCB7CitwdWJsaWM6CisgICAgZW51bSBQaGFzZVR5cGUgeworICAgICAgICBDYXB0dXJp bmdQaGFzZSAgICAgPSAxLAorICAgICAgICBBdFRhcmdldCAgICAgICAgICAgPSAyLAorICAgICAg ICBCdWJibGluZ1BoYXNlICAgICAgPSAzCisgICAgfTsKKworICAgIFdlYkV2ZW50KCkgOiBtX3By aXZhdGUoMCkgeyB9CisgICAgV2ViRXZlbnQoY29uc3QgV2ViRXZlbnQmIG4pIDogbV9wcml2YXRl KDApIHsgYXNzaWduKG4pOyB9CisgICAgV2ViRXZlbnQmIG9wZXJhdG9yPShjb25zdCBXZWJFdmVu dCYgbikKKyAgICB7CisgICAgICAgIGFzc2lnbihuKTsKKyAgICAgICAgcmV0dXJuICp0aGlzOwor ICAgIH0KKworICAgIFdFQktJVF9BUEkgdm9pZCByZXNldCgpOworICAgIFdFQktJVF9BUEkgdm9p ZCBhc3NpZ24oY29uc3QgV2ViRXZlbnQmKTsKKworICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyBy ZXR1cm4gIW1fcHJpdmF0ZTsgfQorCisgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcgdHlwZSgpIGNv bnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSB0YXJnZXQoKSBjb25zdDsKKyAgICBXRUJLSVRf QVBJIFdlYk5vZGUgY3VycmVudFRhcmdldCgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBQaGFz ZVR5cGUgZXZlbnRQaGFzZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBidWJibGVzKCkg Y29uc3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGNhbmNlbGFibGUoKSBjb25zdDsKKworICAgIHZp cnR1YWwgYm9vbCBpc1VJRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNNb3VzZUV2 ZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzTXV0YXRpb25FdmVudCgpIGNvbnN0Owor ICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJv b2wgaXNUZXh0RXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb21wb3NpdGlvbkV2 ZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzRHJhZ0V2ZW50KCkgY29uc3Q7CisgICAg dmlydHVhbCBib29sIGlzQ2xpcGJvYXJkRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wg aXNNZXNzYWdlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNXaGVlbEV2ZW50KCkg Y29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKSBjb25z dDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNPdmVyZmxvd0V2ZW50KCkgY29uc3Q7CisgICAgdmlydHVh bCBib29sIGlzUGFnZVRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBp c1BvcFN0YXRlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNQcm9ncmVzc0V2ZW50 KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzWE1MSHR0cFJlcXVlc3RQcm9ncmVzc0V2ZW50 KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKSBjb25z dDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNXZWJLaXRUcmFuc2l0aW9uRXZlbnQoKSBjb25zdDsKKyAg ICB2aXJ0dWFsIGJvb2wgaXNCZWZvcmVMb2FkRXZlbnQoKSBjb25zdDsKKworI2lmIFdFQktJVF9J TVBMRU1FTlRBVElPTgorICAgIFdlYkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3Jl OjpFdmVudD4mKTsKKyAgICBzdGF0aWMgV2ViRXZlbnQgY3JlYXRlV2ViRXZlbnQoY29uc3QgV1RG OjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYpOworI2VuZGlmCisKK3Byb3RlY3RlZDoKKyAg ICB0eXBlZGVmIFdlYkNvcmU6OkV2ZW50IFdlYkV2ZW50UHJpdmF0ZTsKKyAgICB2b2lkIGFzc2ln bihXZWJFdmVudFByaXZhdGUqKTsKKyAgICBXZWJFdmVudFByaXZhdGUqIG1fcHJpdmF0ZTsKK307 CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6IHB1YmxpYy9XZWJOb2Rl LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0NCi0tLSBwdWJsaWMvV2ViTm9kZS5oCShyZXZpc2lvbiA1MzUwNikNCisr KyBwdWJsaWMvV2ViTm9kZS5oCSh3b3JraW5nIGNvcHkpDQpAQCAtMzQsNiArMzQsOSBAQA0KICNp bmNsdWRlICJXZWJDb21tb24uaCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKIAorI2luY2x1ZGUg PHV0aWxpdHk+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKwogbmFtZXNwYWNlIFdlYkNvcmUg eyBjbGFzcyBOb2RlOyB9CiAjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCiBuYW1lc3BhY2UgV1RG IHsgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGNsYXNzIFBhc3NSZWZQdHI7IH0KQEAgLTQxLDYgKzQ0 LDggQEANCiAKIG5hbWVzcGFjZSBXZWJLaXQgewogY2xhc3MgV2ViRG9jdW1lbnQ7CitjbGFzcyBX ZWJFdmVudExpc3RlbmVyOworY2xhc3MgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU7CiBjbGFzcyBX ZWJGcmFtZTsKIGNsYXNzIFdlYk5vZGVMaXN0OwogCkBAIC0xMTUsMTEgKzEyMCwyMCBAQA0KICAg ICAgICAgcmV0dXJuIHJlczsKICAgICB9CiAKKyAgICB2aXJ0dWFsIHZvaWQgYWRkRXZlbnRMaXN0 ZW5lcigKKyAgICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsCisgICAgICAgIFdlYkV2 ZW50TGlzdGVuZXIqIGxpc3RlbmVyLAorICAgICAgICBib29sIHVzZUNhcHR1cmUpOworICAgIHZp cnR1YWwgdm9pZCByZW1vdmVFdmVudExpc3RlbmVyKAorICAgICAgICBjb25zdCBXZWJTdHJpbmcm IGV2ZW50VHlwZSwKKwkJICAgIFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLAorCQkgICAgYm9v bCB1c2VDYXB0dXJlKTsKKwogcHJvdGVjdGVkOgogICAgIHR5cGVkZWYgV2ViQ29yZTo6Tm9kZSBX ZWJOb2RlUHJpdmF0ZTsKICAgICB2b2lkIGFzc2lnbihXZWJOb2RlUHJpdmF0ZSopOwogICAgIFdl Yk5vZGVQcml2YXRlKiBtX3ByaXZhdGU7Ci0gICAgCisKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBU PiBUKiB1bndyYXAoKQogICAgIHsKICAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PFQqPihtX3By aXZhdGUpOwpAQCAtMTI5LDYgKzE0Myw0OSBAQA0KICAgICB7CiAgICAgICAgIHJldHVybiBzdGF0 aWNfY2FzdDxjb25zdCBUKj4obV9wcml2YXRlKTsKICAgICB9CisKK3ByaXZhdGU6CisgICAgc3Ry dWN0IExpc3RlbmVySW5mbyB7CisgICAgICAgIFdlYlN0cmluZyBldmVudFR5cGU7CisJCSAgICBX ZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lcjsKKwkJICAgIGJvb2wgdXNlQ2FwdHVyZTsKKworICAg ICAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgTGlzdGVuZXJJbmZvJiB2YWx1ZSkgY29uc3QKKyAg ICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGV2ZW50VHlwZSA9PSB2YWx1ZS5ldmVudFR5cGUg JiYgbGlzdGVuZXIgPT0gdmFsdWUubGlzdGVuZXIgJiYgdXNlQ2FwdHVyZSA9PSB2YWx1ZS51c2VD YXB0dXJlOyAgICAKKyAgICAgICAgfQorCisgICAgICAgIExpc3RlbmVySW5mbyhXZWJTdHJpbmcg ZXZlbnRUeXBlLCBXZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lciwgYm9vbCB1c2VDYXB0dXJlKQor ICAgICAgICAgICAgOiBldmVudFR5cGUoZXZlbnRUeXBlKQorICAgICAgICAgICAgLCBsaXN0ZW5l cihsaXN0ZW5lcikKKyAgICAgICAgICAgICwgdXNlQ2FwdHVyZSh1c2VDYXB0dXJlKQorICAgICAg ICB7CisgICAgICAgIH0KKyAgICB9OworCisgICAgc3RydWN0IExpc3RlbmVySW5mb0hhc2gKKyAg ICB7CisgICAgICAgIHN0YXRpYyBjb25zdCBib29sIHNhZmVUb0NvbXBhcmVUb0VtcHR5T3JEZWxl dGVkID0gZmFsc2U7CisgICAgICAgIHN0YXRpYyB1bnNpZ25lZCBoYXNoKGNvbnN0IExpc3RlbmVy SW5mbyYgbGlzdGVuZXJJbmZvKTsKKyAgICAgICAgc3RhdGljIGJvb2wgZXF1YWwoY29uc3QgTGlz dGVuZXJJbmZvJiBhLCBjb25zdCBMaXN0ZW5lckluZm8mIGIpOworICAgIH07CisKKyAgICBzdHJ1 Y3QgTGlzdGVuZXJJbmZvVHJhaXRzCisgICAgeworICAgICAgICBzdGF0aWMgY29uc3QgYm9vbCBl bXB0eVZhbHVlSXNaZXJvID0gZmFsc2U7CisgICAgICAgIHN0YXRpYyBjb25zdCBib29sIG5lZWRz RGVzdHJ1Y3Rpb24gPSBmYWxzZTsKKworICAgICAgICB0eXBlZGVmIExpc3RlbmVySW5mbyBUcmFp dFR5cGU7CisgICAgICAgIHN0YXRpYyB2b2lkIGNvbnN0cnVjdERlbGV0ZWRWYWx1ZShMaXN0ZW5l ckluZm8mIHNsb3QpOworICAgICAgICBzdGF0aWMgYm9vbCBpc0RlbGV0ZWRWYWx1ZShjb25zdCBM aXN0ZW5lckluZm8mIHZhbHVlKTsKKyAgICAgICAgc3RhdGljIExpc3RlbmVySW5mbyBlbXB0eVZh bHVlKCk7CisgICAgfTsKKworICAgIHR5cGVkZWYgSGFzaE1hcDxMaXN0ZW5lckluZm8sCisgICAg ICAgICAgICAgICAgICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKiwKKyAgICAgICAgICAgICAg ICAgICAgTGlzdGVuZXJJbmZvSGFzaCwKKyAgICAgICAgICAgICAgICAgICAgTGlzdGVuZXJJbmZv VHJhaXRzPiBXZWJFdmVudExpc3RlbmVyTWFwOworICAgIFdlYkV2ZW50TGlzdGVuZXJNYXAgbV9l dmVudExpc3RlbmVyTWFwOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CkluZGV4OiBwdWJs aWMvV2ViRnJhbWUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIHB1YmxpYy9XZWJGcmFtZS5oCShyZXZpc2lv biA1MzUwNikNCisrKyBwdWJsaWMvV2ViRnJhbWUuaAkod29ya2luZyBjb3B5KQ0KQEAgLTUwLDkg KzUwLDExIEBADQogY2xhc3MgV2ViRGF0YVNvdXJjZTsKIGNsYXNzIFdlYkRvY3VtZW50OwogY2xh c3MgV2ViRWxlbWVudDsKK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXI7CiBjbGFzcyBXZWJGb3JtRWxl bWVudDsKIGNsYXNzIFdlYkhpc3RvcnlJdGVtOwogY2xhc3MgV2ViSW5wdXRFbGVtZW50OworY2xh c3MgV2ViTm9kZTsKIGNsYXNzIFdlYlBhc3N3b3JkQXV0b2NvbXBsZXRlTGlzdGVuZXI7CiBjbGFz cyBXZWJSYW5nZTsKIGNsYXNzIFdlYlNlY3VyaXR5T3JpZ2luOwpAQCAtNDc4LDcgKzQ4MCwxOCBA QA0KICAgICAvLyB1c2VkIHRvIHN1cHBvcnQgbGF5b3V0IHRlc3RzLgogICAgIHZpcnR1YWwgV2Vi U3RyaW5nIGNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKGNvbnN0IFdlYlN0cmluZyYgaWQpIGNv bnN0ID0gMDsKIAotcHJvdGVjdGVkOgorICAgIC8vIEV2ZW50IGxpc3RlbmVycyAtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisgICAgLy8gUmVn aXN0ZXJzL3VucmVnaXN0ZXJzIGEgbGlzdGVuZXIgZm9yIGEgc3BlY2lmaWMgSmF2YVNjcmlwdCBl dmVudC4KKyAgICB2aXJ0dWFsIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJOb2RlJiBu b2RlLAorICAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwKKyAgICAgICAgV2ViRXZl bnRMaXN0ZW5lciogbGlzdGVuZXIsCisgICAgICAgIGJvb2wgdXNlQ2FwdHVyZSkgPSAwOworICAg IHZpcnR1YWwgdm9pZCByZW1vdmVFdmVudExpc3RlbmVyKGNvbnN0IFdlYk5vZGUmIG5vZGUsCisg ICAgICAgIGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLAorCQkgICAgV2ViRXZlbnRMaXN0ZW5l ciogbGlzdGVuZXIsCisJCSAgICBib29sIHVzZUNhcHR1cmUpID0gMDsKKwogICAgIH5XZWJGcmFt ZSgpIHsgfQogfTsKIAo= 46980 2010-01-19 23:08:18 -0800 2010-01-22 17:38:24 -0800 Initial draft of a patch events_1.patch text/plain 27866 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzUyNCkKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw3MSBAQAorMjAxMC0wMS0xOSAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRzIGV2ZW50IGxpc3RlbmVyIHJlZ2lzdHJhdGlvbiB0 byB0aGUgQ2hyb21pdW0gQVBJLgorCisgICAgICAgICogV2ViS2l0Lmd5cDoKKyAgICAgICAgKiBw dWJsaWMvV2ViRXZlbnQuaDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjopOgor ICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6V2ViRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpX ZWJFdmVudDo6b3BlcmF0b3I9KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzTnVsbCk6 CisgICAgICAgICogcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaDogQWRkZWQuCisgICAgICAgIChX ZWJLaXQ6OldlYkV2ZW50TGlzdGVuZXI6Omxpc3RlbmVyRGV0YWNoZWQpOgorICAgICAgICAqIHB1 YmxpYy9XZWJNdXRhdGlvbkV2ZW50Lmg6IEFkZGVkLgorICAgICAgICAqIHB1YmxpYy9XZWJOb2Rl Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6Okxpc3RlbmVySW5mbzo6b3BlcmF0b3I9PSk6 CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6Okxpc3RlbmVySW5mbzo6TGlzdGVuZXJJbmZvKToK KyAgICAgICAgKiBwdWJsaWMvV2ViU3RyaW5nLmg6CisgICAgICAgICogc3JjL1dlYkV2ZW50LmNw cDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjpyZXNldCk6CisgICAgICAgIChX ZWJLaXQ6OldlYkV2ZW50Ojphc3NpZ24pOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6V2Vi RXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6dHlwZSk6CisgICAgICAgIChXZWJL aXQ6OldlYkV2ZW50Ojp0YXJnZXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6Y3VycmVu dFRhcmdldCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjpldmVudFBoYXNlKToKKyAgICAg ICAgKFdlYktpdDo6V2ViRXZlbnQ6OmJ1YmJsZXMpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVu dDo6Y2FuY2VsYWJsZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc1VJRXZlbnQpOgor ICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNNb3VzZUV2ZW50KToKKyAgICAgICAgKFdlYktp dDo6V2ViRXZlbnQ6OmlzTXV0YXRpb25FdmVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50 Ojppc0tleWJvYXJkRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNUZXh0RXZl bnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNDb21wb3NpdGlvbkV2ZW50KToKKyAg ICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzRHJhZ0V2ZW50KToKKyAgICAgICAgKFdlYktpdDo6 V2ViRXZlbnQ6OmlzQ2xpcGJvYXJkRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6 aXNNZXNzYWdlRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNXaGVlbEV2ZW50 KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzQmVmb3JlVGV4dEluc2VydGVkRXZlbnQp OgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNPdmVyZmxvd0V2ZW50KToKKyAgICAgICAg KFdlYktpdDo6V2ViRXZlbnQ6OmlzUGFnZVRyYW5zaXRpb25FdmVudCk6CisgICAgICAgIChXZWJL aXQ6OldlYkV2ZW50Ojppc1BvcFN0YXRlRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVu dDo6aXNQcm9ncmVzc0V2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzWE1MSHR0 cFJlcXVlc3RQcm9ncmVzc0V2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzV2Vi S2l0QW5pbWF0aW9uRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNXZWJLaXRU cmFuc2l0aW9uRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNCZWZvcmVMb2Fk RXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6Y3JlYXRlV2ViRXZlbnQpOgorICAg ICAgICAqIHNyYy9XZWJNdXRhdGlvbkV2ZW50LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6 OldlYk11dGF0aW9uRXZlbnQ6OldlYk11dGF0aW9uRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpX ZWJNdXRhdGlvbkV2ZW50Ojppc011dGF0aW9uRXZlbnQpOgorICAgICAgICAqIHNyYy9XZWJOb2Rl LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OldlYkV2ZW50 TGlzdGVuZXJQcml2YXRlKToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnRMaXN0ZW5lclByaXZh dGU6On5XZWJFdmVudExpc3RlbmVyUHJpdmF0ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50 TGlzdGVuZXJQcml2YXRlOjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnRM aXN0ZW5lclByaXZhdGU6OmhhbmRsZUV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6 YWRkRXZlbnRMaXN0ZW5lcik6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6OnJlbW92ZUV2ZW50 TGlzdGVuZXIpOgorICAgICAgICAoV2ViS2l0OjpXZWJOb2RlOjpMaXN0ZW5lckluZm9IYXNoOjpo YXNoKToKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6TGlzdGVuZXJJbmZvSGFzaDo6ZXF1YWwp OgorICAgICAgICAoV2ViS2l0OjpXZWJOb2RlOjpMaXN0ZW5lckluZm9UcmFpdHM6OmNvbnN0cnVj dERlbGV0ZWRWYWx1ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6Okxpc3RlbmVySW5mb1Ry YWl0czo6aXNEZWxldGVkVmFsdWUpOgorICAgICAgICAoV2ViS2l0OjpXZWJOb2RlOjpMaXN0ZW5l ckluZm9UcmFpdHM6OmVtcHR5VmFsdWUpOgorICAgICAgICAqIHNyYy9XZWJTdHJpbmcuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJTdHJpbmc6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2ViS2l0 OjpXZWJTdHJpbmc6Omhhc2gpOgorCiAyMDEwLTAxLTE5ICBKb24gSG9uZXljdXR0ICA8amhvbmV5 Y3V0dEBhcHBsZS5jb20+CiAKICAgICAgICAgQ2hyb21pdW0gYnVpbGQgZml4LgpJbmRleDogV2Vi S2l0L2Nocm9taXVtL1dlYktpdC5neXANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0v V2ViS2l0Lmd5cAkocmV2aXNpb24gNTM1MjQpCisrKyBXZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cAkod29ya2luZyBjb3B5KQpAQCAtMTA3LDYgKzEwNyw4IEBACiAgICAgICAgICAgICAgICAgJ3B1 YmxpYy9XZWJEcmFnRGF0YS5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYkVkaXRpbmdB Y3Rpb24uaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJFbGVtZW50LmgnLAorICAgICAg ICAgICAgICAgICdwdWJsaWMvV2ViRXZlbnQuaCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9X ZWJFdmVudExpc3RlbmVyLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRmlsZUNob29z ZXJDb21wbGV0aW9uLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRmlsZUNob29zZXJQ YXJhbXMuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaW5kT3B0aW9ucy5oJywKQEAg LTEzMCw2ICsxMzIsNyBAQAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTWVzc2FnZVBvcnRD aGFubmVsLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTWVzc2FnZVBvcnRDaGFubmVs Q2xpZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTWltZVJlZ2lzdHJ5LmgnLAor ICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTXV0YXRpb25FdmVudC5oJywKICAgICAgICAgICAg ICAgICAncHVibGljL1dlYk5hdmlnYXRpb25UeXBlLmgnLAogICAgICAgICAgICAgICAgICdwdWJs aWMvV2ViTm9kZS5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYk5vZGVDb2xsZWN0aW9u LmgnLApAQCAtMjU4LDYgKzI2MSw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50 LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAg ICAgICAgICdzcmMvV2ViRW50aXRpZXMuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVu dC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJDb21wbGV0aW9uSW1w bC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJDb21wbGV0aW9uSW1w bC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAnLApAQCAtMjc2LDYg KzI4MCw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywKICAgICAgICAgICAg ICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAgICAgICAgICAgICAg ICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAgICAgICAgICdzcmMv V2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZS5jcHAn LAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50 LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTA3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJFdmVudF9oCisjZGVm aW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYk5v ZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFz cyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNwYWNlIFdURiB7IHRl bXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5kaWYKKworbmFtZXNw YWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAgICBlbnVtIFBoYXNl VHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAgICAgIEF0VGFyZ2V0 ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9IDMKKyAgICB9Owor CisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJFdmVudChjb25zdCBX ZWJFdmVudCYgbikgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24obik7IH0KKyAgICBXZWJFdmVudCYg b3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBuKQorICAgIHsKKyAgICAgICAgYXNzaWduKG4pOwor ICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQSSB2b2lkIHJlc2V0 KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVudCYpOworCisgICAg Ym9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisKKyAgICBXRUJLSVRf QVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBXZWJOb2RlIHRhcmdl dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFyZ2V0KCkgY29uc3Q7 CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29uc3Q7CisgICAgV0VC S0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgY2FuY2Vs YWJsZSgpIGNvbnN0OworCisgICAgdmlydHVhbCBib29sIGlzVUlFdmVudCgpIGNvbnN0OworICAg IHZpcnR1YWwgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNN dXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzS2V5Ym9hcmRFdmVudCgp IGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc1RleHRFdmVudCgpIGNvbnN0OworICAgIHZpcnR1 YWwgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNE cmFnRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNv bnN0OworICAgIHZpcnR1YWwgYm9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIHZpcnR1 YWwgYm9vbCBpc1doZWVsRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNCZWZvcmVU ZXh0SW5zZXJ0ZWRFdmVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc092ZXJmbG93RXZl bnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29u c3Q7CisgICAgdmlydHVhbCBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIHZpcnR1 YWwgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNYTUxI dHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNXZWJL aXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc1dlYktpdFRyYW5z aXRpb25FdmVudCgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBpc0JlZm9yZUxvYWRFdmVudCgp IGNvbnN0OworCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCisgICAgV2ViRXZlbnQoY29uc3Qg V1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYpOworICAgIHN0YXRpYyBXZWJFdmVudCBj cmVhdGVXZWJFdmVudChjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+Jik7Cisj ZW5kaWYKKworcHJvdGVjdGVkOgorICAgIHR5cGVkZWYgV2ViQ29yZTo6RXZlbnQgV2ViRXZlbnRQ cml2YXRlOworICAgIHZvaWQgYXNzaWduKFdlYkV2ZW50UHJpdmF0ZSopOworICAgIFdlYkV2ZW50 UHJpdmF0ZSogbV9wcml2YXRlOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRp ZgpJbmRleDogV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgNCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaAkocmV2 aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdv b2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJj ZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUK KyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5l aXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRl biBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENP UFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVO VCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1Q TEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVU SEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJFdmVudExpc3RlbmVyX2gKKyNk ZWZpbmUgV2ViRXZlbnRMaXN0ZW5lcl9oCisKKyNpbmNsdWRlICJXZWJDb21tb24uaCIKKyNpbmNs dWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50 OworCitjbGFzcyBXZWJFdmVudExpc3RlbmVyIHsKK3B1YmxpYzoKKyAgICAvLyBDYWxsZWQgd2hl biBhbiBldmVudCBpcyByZWNlaXZlZC4KKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlRXZlbnQoY29u c3QgV2ViRXZlbnQmKSA9IDA7CisKKyAgICAvLyBDYWxsZWQgd2hlbiB0aGUgbGlzdGVuZXIgd2Fz IGRldGFjaGVkIGZyb20gdGhlIG5vZGUgaXQgd2FzIGxpc3RlbmluZworICAgIC8vIHRvIGFuZCB0 aGF0IG5vIGZ1cnRoZXIgZXZlbnQgd2lsbCBiZSByZWNlaXZlZC4KKyAgICAvLyBHaXZlcyBhbiBv cHBvcnR1bml0eSB0byBpbXBsZW1lbnRhdGlvbiBjbGFzc2VzIHRvIHBlcmZvcm0gbmVjZXNzYXJ5 CisgICAgLy8gY2xlYW4tdXAuCisgICAgdmlydHVhbCB2b2lkIGxpc3RlbmVyRGV0YWNoZWQoKSB7 fTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6IFdlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViTXV0YXRpb25FdmVudC5oDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYk11dGF0aW9uRXZlbnQuaAkocmV2aXNpb24gMCkKQEAgLTAs MCArMSw1NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisjaWZuZGVmIFdlYk11dGF0aW9uRXZlbnRfaAorI2RlZmluZSBXZWJNdXRhdGlvbkV2 ZW50X2gKKworI2luY2x1ZGUgIldlYkV2ZW50LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsgY2xh c3MgRXZlbnQ7IH0KKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KK25hbWVzcGFjZSBXVEYgeyB0 ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gY2xhc3MgUGFzc1JlZlB0cjsgfQorI2VuZGlmCisKK25hbWVz cGFjZSBXZWJLaXQgeworCitjbGFzcyBXZWJNdXRhdGlvbkV2ZW50IDogcHVibGljIFdlYkV2ZW50 IHsKK3B1YmxpYzoKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYk11dGF0aW9u RXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYpOworI2VuZGlmCisK KyAgICB2aXJ0dWFsIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7Cit9OworCit9IC8vIG5h bWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dl Yk5vZGUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTm9kZS5o CShyZXZpc2lvbiA1MzUyNCkKKysrIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTm9kZS5oCSh3 b3JraW5nIGNvcHkpCkBAIC0zNCw2ICszNCw5IEBACiAjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCiAj aW5jbHVkZSAiV2ViU3RyaW5nLmgiCiAKKyNpbmNsdWRlIDx1dGlsaXR5PgorI2luY2x1ZGUgPHd0 Zi9IYXNoTWFwLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3MgTm9kZTsgfQogI2lmIFdF QktJVF9JTVBMRU1FTlRBVElPTgogbmFtZXNwYWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBU PiBjbGFzcyBQYXNzUmVmUHRyOyB9CkBAIC00MSw2ICs0NCw4IEBAIG5hbWVzcGFjZSBXVEYgeyB0 ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gY2wKIAogbmFtZXNwYWNlIFdlYktpdCB7CiBjbGFzcyBXZWJE b2N1bWVudDsKK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXI7CitjbGFzcyBXZWJFdmVudExpc3RlbmVy UHJpdmF0ZTsKIGNsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm9kZUxpc3Q7CiAKQEAgLTExNSw2 ICsxMjAsMTUgQEAgcHVibGljOgogICAgICAgICByZXR1cm4gcmVzOwogICAgIH0KIAorICAgIHZp cnR1YWwgdm9pZCBhZGRFdmVudExpc3RlbmVyKAorICAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2 ZW50VHlwZSwKKyAgICAgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsCisgICAgICAgIGJv b2wgdXNlQ2FwdHVyZSk7CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZUV2ZW50TGlzdGVuZXIoCisg ICAgICAgIGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLAorICAgICAgICBXZWJFdmVudExpc3Rl bmVyKiBsaXN0ZW5lciwKKyAgICAgICAgYm9vbCB1c2VDYXB0dXJlKTsKKwogcHJvdGVjdGVkOgog ICAgIHR5cGVkZWYgV2ViQ29yZTo6Tm9kZSBXZWJOb2RlUHJpdmF0ZTsKICAgICB2b2lkIGFzc2ln bihXZWJOb2RlUHJpdmF0ZSopOwpAQCAtMTI5LDYgKzE0Myw0OSBAQCBwcm90ZWN0ZWQ6CiAgICAg ewogICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8Y29uc3QgVCo+KG1fcHJpdmF0ZSk7CiAgICAg fQorCitwcml2YXRlOgorICAgIHN0cnVjdCBMaXN0ZW5lckluZm8geworICAgICAgICBXZWJTdHJp bmcgZXZlbnRUeXBlOworCQkgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXI7CisJCSAgICBi b29sIHVzZUNhcHR1cmU7CisKKyAgICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IExpc3RlbmVy SW5mbyYgdmFsdWUpIGNvbnN0CisgICAgICAgIHsKKyAgICAgICAgICAgIHJldHVybiBldmVudFR5 cGUgPT0gdmFsdWUuZXZlbnRUeXBlICYmIGxpc3RlbmVyID09IHZhbHVlLmxpc3RlbmVyICYmIHVz ZUNhcHR1cmUgPT0gdmFsdWUudXNlQ2FwdHVyZTsgICAgCisgICAgICAgIH0KKworICAgICAgICBM aXN0ZW5lckluZm8oV2ViU3RyaW5nIGV2ZW50VHlwZSwgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVu ZXIsIGJvb2wgdXNlQ2FwdHVyZSkKKyAgICAgICAgICAgIDogZXZlbnRUeXBlKGV2ZW50VHlwZSkK KyAgICAgICAgICAgICwgbGlzdGVuZXIobGlzdGVuZXIpCisgICAgICAgICAgICAsIHVzZUNhcHR1 cmUodXNlQ2FwdHVyZSkKKyAgICAgICAgeworICAgICAgICB9CisgICAgfTsKKworICAgIHN0cnVj dCBMaXN0ZW5lckluZm9IYXNoCisgICAgeworICAgICAgICBzdGF0aWMgY29uc3QgYm9vbCBzYWZl VG9Db21wYXJlVG9FbXB0eU9yRGVsZXRlZCA9IGZhbHNlOworICAgICAgICBzdGF0aWMgdW5zaWdu ZWQgaGFzaChjb25zdCBMaXN0ZW5lckluZm8mIGxpc3RlbmVySW5mbyk7CisgICAgICAgIHN0YXRp YyBib29sIGVxdWFsKGNvbnN0IExpc3RlbmVySW5mbyYgYSwgY29uc3QgTGlzdGVuZXJJbmZvJiBi KTsKKyAgICB9OworCisgICAgc3RydWN0IExpc3RlbmVySW5mb1RyYWl0cworICAgIHsKKyAgICAg ICAgc3RhdGljIGNvbnN0IGJvb2wgZW1wdHlWYWx1ZUlzWmVybyA9IGZhbHNlOworICAgICAgICBz dGF0aWMgY29uc3QgYm9vbCBuZWVkc0Rlc3RydWN0aW9uID0gZmFsc2U7CisKKyAgICAgICAgdHlw ZWRlZiBMaXN0ZW5lckluZm8gVHJhaXRUeXBlOworICAgICAgICBzdGF0aWMgdm9pZCBjb25zdHJ1 Y3REZWxldGVkVmFsdWUoTGlzdGVuZXJJbmZvJiBzbG90KTsKKyAgICAgICAgc3RhdGljIGJvb2wg aXNEZWxldGVkVmFsdWUoY29uc3QgTGlzdGVuZXJJbmZvJiB2YWx1ZSk7CisgICAgICAgIHN0YXRp YyBMaXN0ZW5lckluZm8gZW1wdHlWYWx1ZSgpOworICAgIH07CisKKyAgICB0eXBlZGVmIEhhc2hN YXA8TGlzdGVuZXJJbmZvLAorICAgICAgICAgICAgICAgICAgICBXZWJFdmVudExpc3RlbmVyUHJp dmF0ZSosCisgICAgICAgICAgICAgICAgICAgIExpc3RlbmVySW5mb0hhc2gsCisgICAgICAgICAg ICAgICAgICAgIExpc3RlbmVySW5mb1RyYWl0cz4gV2ViRXZlbnRMaXN0ZW5lck1hcDsKKyAgICBX ZWJFdmVudExpc3RlbmVyTWFwIG1fZXZlbnRMaXN0ZW5lck1hcDsKIH07CiAKIH0gLy8gbmFtZXNw YWNlIFdlYktpdApJbmRleDogV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTdHJpbmcuaA0KPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU3RyaW5nLmgJKHJldmlzaW9u IDUzNTI0KQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJTdHJpbmcuaAkod29ya2luZyBj b3B5KQpAQCAtNzEsNiArNzEsNyBAQCBwdWJsaWM6CiAgICAgICAgIGFzc2lnbihzKTsKICAgICAg ICAgcmV0dXJuICp0aGlzOwogICAgIH0KKyAgICBib29sIG9wZXJhdG9yPT0oY29uc3QgV2ViU3Ry aW5nJiBzKSBjb25zdDsKIAogICAgIFdFQktJVF9BUEkgdm9pZCByZXNldCgpOwogICAgIFdFQktJ VF9BUEkgdm9pZCBhc3NpZ24oY29uc3QgV2ViU3RyaW5nJik7CkBAIC04Nyw2ICs4OCw4IEBAIHB1 YmxpYzoKICAgICBXRUJLSVRfQVBJIHN0YXRpYyBXZWJTdHJpbmcgZnJvbVVURjgoY29uc3QgY2hh ciogZGF0YSwgc2l6ZV90IGxlbmd0aCk7CiAgICAgV0VCS0lUX0FQSSBzdGF0aWMgV2ViU3RyaW5n IGZyb21VVEY4KGNvbnN0IGNoYXIqIGRhdGEpOwogCisgICAgdW5zaWduZWQgaGFzaCgpIGNvbnN0 OworCiAgICAgdGVtcGxhdGUgPGludCBOPiBXZWJTdHJpbmcoY29uc3QgY2hhciAoJmRhdGEpW05d KQogICAgICAgICA6IG1fcHJpdmF0ZSgwKQogICAgIHsKSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9z cmMvV2ViRXZlbnQuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJF dmVudC5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50LmNw cAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMDIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog ICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAg ICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cwor ICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3 cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBU SEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJ TUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAor ICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKwor I2luY2x1ZGUgIkV2ZW50LmgiCisjaW5jbHVkZSAiTm9kZS5oIgorI2luY2x1ZGUgIldlYk11dGF0 aW9uRXZlbnQuaCIKKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2Vi S2l0IHsKKworY2xhc3MgV2ViRXZlbnRQcml2YXRlIDogcHVibGljIFdlYkNvcmU6OkV2ZW50IHsK K307CisKK3ZvaWQgV2ViRXZlbnQ6OnJlc2V0KCkKK3sKKyAgICBhc3NpZ24oMCk7Cit9CisKK3Zv aWQgV2ViRXZlbnQ6OmFzc2lnbihjb25zdCBXZWJFdmVudCYgb3RoZXIpCit7CisgICAgV2ViRXZl bnRQcml2YXRlKiBwID0gY29uc3RfY2FzdDxXZWJFdmVudFByaXZhdGUqPihvdGhlci5tX3ByaXZh dGUpOworICAgIGlmIChwKQorICAgICAgICBwLT5yZWYoKTsKKyAgICBhc3NpZ24ocCk7Cit9CisK K3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihXZWJFdmVudFByaXZhdGUqIHApCit7CisgICAgLy8gcCBp cyBhbHJlYWR5IHJlZidkIGZvciB1cyBieSB0aGUgY2FsbGVyCisgICAgaWYgKG1fcHJpdmF0ZSkK KyAgICAgICAgbV9wcml2YXRlLT5kZXJlZigpOworICAgIG1fcHJpdmF0ZSA9IHA7Cit9CisKK1dl YkV2ZW50OjpXZWJFdmVudChjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+JiBl dmVudCkKKyAgICA6IG1fcHJpdmF0ZShzdGF0aWNfY2FzdDxXZWJFdmVudFByaXZhdGUqPihldmVu dC5yZWxlYXNlUmVmKCkpKQoreworfQorCitXZWJTdHJpbmcgV2ViRXZlbnQ6OnR5cGUoKSBjb25z dAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPnR5cGUoKTsKK30KKworV2ViTm9kZSBXZWJFdmVu dDo6dGFyZ2V0KCkgY29uc3QKK3sKKyAgICByZXR1cm4gV2ViTm9kZShtX3ByaXZhdGUtPnRhcmdl dCgpLT50b05vZGUoKSk7Cit9CisKK1dlYk5vZGUgV2ViRXZlbnQ6OmN1cnJlbnRUYXJnZXQoKSBj b25zdAoreworICAgIHJldHVybiBXZWJOb2RlKG1fcHJpdmF0ZS0+Y3VycmVudFRhcmdldCgpLT50 b05vZGUoKSk7Cit9CisKK1dlYkV2ZW50OjpQaGFzZVR5cGUgV2ViRXZlbnQ6OmV2ZW50UGhhc2Uo KSBjb25zdAoreworICAgIHJldHVybiBzdGF0aWNfY2FzdDxXZWJFdmVudDo6UGhhc2VUeXBlPiht X3ByaXZhdGUtPmV2ZW50UGhhc2UoKSk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmJ1YmJsZXMoKSBj b25zdCB7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+YnViYmxlcygpOworfQorCitib29sIFdlYkV2 ZW50OjpjYW5jZWxhYmxlKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5jYW5jZWxh YmxlKCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzVUlFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc01vdXNlRXZlbnQoKSBjb25zdAorewor ICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNNdXRhdGlvbkV2ZW50KCkg Y29uc3QKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzS2V5Ym9h cmRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50 Ojppc1RleHRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdl YkV2ZW50Ojppc0NvbXBvc2l0aW9uRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsK K30KKworYm9vbCBXZWJFdmVudDo6aXNEcmFnRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBm YWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc01lc3NhZ2VFdmVudCgpIGNv bnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc1doZWVsRXZl bnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNC ZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQor Citib29sIFdlYkV2ZW50Ojppc092ZXJmbG93RXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBm YWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3QK K3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzUG9wU3RhdGVFdmVu dCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc1By b2dyZXNzRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBXZWJF dmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdAoreworICAgIHJldHVy biBmYWxzZTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNv bnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdlYkV2ZW50Ojppc1dlYktpdFRy YW5zaXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitib29sIFdl YkV2ZW50Ojppc0JlZm9yZUxvYWRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGZhbHNlOwor fQorCitXZWJFdmVudCBXZWJFdmVudDo6Y3JlYXRlV2ViRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVm UHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZlbnQpCit7CisgICAgaWYgKGV2ZW50LT5pc011dGF0aW9u RXZlbnQoKSkKKyAgICAgIHJldHVybiBXZWJNdXRhdGlvbkV2ZW50KGV2ZW50KTsKKworICAgIC8v IFRPRE8oamNhbXBhbik6IGltcGxlbWVudCBvdGhlciBldmVudHMuCisgICAgcmV0dXJuIFdlYkV2 ZW50KCk7Cit9CisKK30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vc3JjL1dlYk11dGF0aW9uRXZlbnQuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJNdXRhdGlvbkV2ZW50LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktp dC9jaHJvbWl1bS9zcmMvV2ViTXV0YXRpb25FdmVudC5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNDcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiV2ViTXV0YXRpb25FdmVudC5oIgorCituYW1lc3BhY2UgV2ViS2l0 IHsKKworV2ViTXV0YXRpb25FdmVudDo6V2ViTXV0YXRpb25FdmVudChjb25zdCBXVEY6OlBhc3NS ZWZQdHI8V2ViQ29yZTo6RXZlbnQ+JiBldmVudCkKKyAgICA6IFdlYkV2ZW50KGV2ZW50KQorewor fQorCitib29sIFdlYk11dGF0aW9uRXZlbnQ6OmlzTXV0YXRpb25FdmVudCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKK30KKworCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dl Yk5vZGUuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJOb2RlLmNw cAkocmV2aXNpb24gNTM1MjQpCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYk5vZGUuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw4IEBACiAjaW5jbHVkZSAiTm9kZUxpc3QuaCIKIAog I2luY2x1ZGUgIldlYkRvY3VtZW50LmgiCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKyNpbmNsdWRl ICJXZWJFdmVudExpc3RlbmVyLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVk ZSAiV2ViTm9kZUxpc3QuaCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKQEAgLTU0LDYgKzU2LDMy IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogY2xhc3MgV2ViTm9kZVByaXZhdGUgOiBwdWJsaWMgTm9k ZSB7CiB9OwogCitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZSA6IHB1YmxpYyBFdmVudExp c3RlbmVyIHsKK3B1YmxpYzoKKyAgICBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZShXZWJFdmVudExp c3RlbmVyKiB3ZWJFdmVudExpc3RlbmVyKQorICAgICAgICA6IEV2ZW50TGlzdGVuZXIoRXZlbnRM aXN0ZW5lcjo6SlNFdmVudExpc3RlbmVyVHlwZSkKKyAgICAgICAgLCBtX3dlYkV2ZW50TGlzdGVu ZXIod2ViRXZlbnRMaXN0ZW5lcikKKyAgICB7CisgICAgfQorICAgIHZpcnR1YWwgfldlYkV2ZW50 TGlzdGVuZXJQcml2YXRlKCkgeworICAgICAgICBtX3dlYkV2ZW50TGlzdGVuZXItPmxpc3RlbmVy RGV0YWNoZWQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgb3BlcmF0b3I9PShjb25zdCBF dmVudExpc3RlbmVyJiBsaXN0ZW5lcikKKyAgICB7CisgICAgICAgIHJldHVybiB0aGlzID09ICZs aXN0ZW5lcjsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlRXZlbnQoU2NyaXB0RXhl Y3V0aW9uQ29udGV4dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KQorICAgIHsKKyAgICAgIFdlYkV2 ZW50IHdlYkV2ZW50ID0gV2ViRXZlbnQ6OmNyZWF0ZVdlYkV2ZW50KGV2ZW50KTsKKyAgICAgIG1f d2ViRXZlbnRMaXN0ZW5lci0+aGFuZGxlRXZlbnQod2ViRXZlbnQpOworICAgIH0KKworcHJpdmF0 ZToKKyAgICBXZWJFdmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7Cit9OworCiB2b2lk IFdlYk5vZGU6OnJlc2V0KCkKIHsKICAgICBhc3NpZ24oMCk7CkBAIC0xNzMsNCArMjAxLDYyIEBA IGJvb2wgV2ViTm9kZTo6aXNFbGVtZW50Tm9kZSgpIGNvbnN0CiAgICAgcmV0dXJuIG1fcHJpdmF0 ZS0+aXNFbGVtZW50Tm9kZSgpOwogfQogCit2b2lkIFdlYk5vZGU6OmFkZEV2ZW50TGlzdGVuZXIo Y29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsCisgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVu ZXIsCisgICAgYm9vbCB1c2VDYXB0dXJlKQoreworICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRl KiBsaXN0ZW5lclByaXZhdGUgPSBuZXcgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUobGlzdGVuZXIp OworICAgIC8vIFRoZSBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZSBpcyBvd25lZCBieSB0aGUgbm9k ZS4gIFdlIG9ubHkga2VlcCBhIHNvZnQtcmVmZXJlbmNlCisgICAgLy8gdG8gaXQgc28gd2UgY2Fu IGhvbm9yIGFueSByZW1vdmVFdmVudExpc3RlbmVyIGNhbGxzLgorICAgIExpc3RlbmVySW5mbyBs aXN0ZW5lckluZm8oZXZlbnRUeXBlLCBsaXN0ZW5lciwgdXNlQ2FwdHVyZSk7CisgICAgQVNTRVJU KCFtX2V2ZW50TGlzdGVuZXJNYXAuY29udGFpbnMobGlzdGVuZXJJbmZvKSk7CisgICAgbV9ldmVu dExpc3RlbmVyTWFwLmFkZChsaXN0ZW5lckluZm8sIGxpc3RlbmVyUHJpdmF0ZSk7CisgICAgbV9w cml2YXRlLT5hZGRFdmVudExpc3RlbmVyKGV2ZW50VHlwZSwgYWRvcHRSZWYobGlzdGVuZXJQcml2 YXRlKSwgZmFsc2UpOworfQorCit2b2lkIFdlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoY29u c3QgV2ViU3RyaW5nJiBldmVudFR5cGUsCisgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIs CisgICAgYm9vbCB1c2VDYXB0dXJlKQoreworICAgIExpc3RlbmVySW5mbyBsaXN0ZW5lckluZm8o ZXZlbnRUeXBlLCBsaXN0ZW5lciwgdXNlQ2FwdHVyZSk7CisgICAgQVNTRVJUKG1fZXZlbnRMaXN0 ZW5lck1hcC5jb250YWlucyhsaXN0ZW5lckluZm8pKTsKKyAgICBXZWJFdmVudExpc3RlbmVyUHJp dmF0ZSogbGlzdGVuZXJQcml2YXRlID0gbV9ldmVudExpc3RlbmVyTWFwLmdldChsaXN0ZW5lcklu Zm8pOworICAgIG1fcHJpdmF0ZS0+cmVtb3ZlRXZlbnRMaXN0ZW5lcihldmVudFR5cGUsIGxpc3Rl bmVyUHJpdmF0ZSwgZmFsc2UpOworfQorCisvLyBzdGF0aWMKK3Vuc2lnbmVkIFdlYk5vZGU6Okxp c3RlbmVySW5mb0hhc2g6Omhhc2goY29uc3QgTGlzdGVuZXJJbmZvJiBsaXN0ZW5lckluZm8pCit7 CisgICAgdW5zaWduZWQgcmVzdWx0ID0gbGlzdGVuZXJJbmZvLmV2ZW50VHlwZS5oYXNoKCk7Cisg ICAgcmVzdWx0ID0gMzcgKiByZXN1bHQgKyAobGlzdGVuZXJJbmZvLnVzZUNhcHR1cmUgPyAwIDog MSk7CisgICAgcmVzdWx0ID0gMzcgKiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4obGlzdGVu ZXJJbmZvLmxpc3RlbmVyKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCisvLyBzdGF0aWMKK2Jv b2wgV2ViTm9kZTo6TGlzdGVuZXJJbmZvSGFzaDo6ZXF1YWwoY29uc3QgTGlzdGVuZXJJbmZvJiBh LCBjb25zdCBMaXN0ZW5lckluZm8mIGIpCit7CisgIHJldHVybiBhLmV2ZW50VHlwZSA9PSBiLmV2 ZW50VHlwZSAmJiBhLmxpc3RlbmVyID09IGIubGlzdGVuZXIgJiYgYS51c2VDYXB0dXJlID09IGIu dXNlQ2FwdHVyZTsKK30KKworLy8gc3RhdGljCit2b2lkIFdlYk5vZGU6Okxpc3RlbmVySW5mb1Ry YWl0czo6Y29uc3RydWN0RGVsZXRlZFZhbHVlKExpc3RlbmVySW5mbyYgc2xvdCkKK3sKKyAgICBz bG90LmV2ZW50VHlwZS5hc3NpZ24oV2ViU3RyaW5nKCkpOworICAgIHNsb3QubGlzdGVuZXIgPSBO VUxMOworICAgIHNsb3QudXNlQ2FwdHVyZSA9IGZhbHNlOworfQorCisvLyBzdGF0aWMKK2Jvb2wg V2ViTm9kZTo6TGlzdGVuZXJJbmZvVHJhaXRzOjppc0RlbGV0ZWRWYWx1ZShjb25zdCBMaXN0ZW5l ckluZm8mIHZhbHVlKQoreworICAgIHJldHVybiB2YWx1ZS5ldmVudFR5cGUuaXNOdWxsKCkgJiYg IXZhbHVlLmxpc3RlbmVyICYmICF2YWx1ZS51c2VDYXB0dXJlOworfQorCisvLyBzdGF0aWMKK1dl Yk5vZGU6Okxpc3RlbmVySW5mbyBXZWJOb2RlOjpMaXN0ZW5lckluZm9UcmFpdHM6OmVtcHR5VmFs dWUoKQoreworICAgIHJldHVybiBMaXN0ZW5lckluZm8oV2ViU3RyaW5nKCksIE5VTEwsIGZhbHNl KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYlN0cmluZy5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0 cmluZy5jcHAJKHJldmlzaW9uIDUzNTI0KQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTdHJp bmcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04Niw2ICs4NiwyMSBAQCBXZWJTdHJpbmcgV2ViU3Ry aW5nOjpmcm9tVVRGOChjb25zdCBjaGFyCiAgICAgcmV0dXJuIFdlYkNvcmU6OlN0cmluZzo6ZnJv bVVURjgoZGF0YSk7CiB9CiAKK2Jvb2wgV2ViU3RyaW5nOjpvcGVyYXRvcj09KGNvbnN0IFdlYlN0 cmluZyYgcykgY29uc3QKK3sKKyAgICBpZiAobV9wcml2YXRlICYmICFzLm1fcHJpdmF0ZSB8fCAh bV9wcml2YXRlICYmIHMubV9wcml2YXRlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBp ZiAoIW1fcHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1cm4gbV9wcml2 YXRlID09IHMubV9wcml2YXRlOworfQorCit1bnNpZ25lZCBXZWJTdHJpbmc6Omhhc2goKSBjb25z dCB7CisgIHJldHVybiBtX3ByaXZhdGUgPyBtX3ByaXZhdGUtPmhhc2goKSA6IDA7Cit9CisKIFdl YlN0cmluZzo6V2ViU3RyaW5nKGNvbnN0IFdlYkNvcmU6OlN0cmluZyYgcykKICAgICA6IG1fcHJp dmF0ZShzdGF0aWNfY2FzdDxXZWJTdHJpbmdQcml2YXRlKj4ocy5pbXBsKCkpKQogewo= 47249 2010-01-22 17:38:24 -0800 2010-01-25 17:17:54 -0800 Cleaned-up patch. All needed basic EventListener functionalities implemented. events_2.patch text/plain 35470 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1Mzc0MCkKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSw4NSBAQAorMjAxMC0wMS0yMiAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgRXZlbnRMaXN0ZW5lcnMgdG8gdGhlIGNocm9t aXVtIEFQSS4KKworICAgICAgICAqIFdlYktpdC5neXA6CisgICAgICAgICogcHVibGljL1dlYkV2 ZW50Lmg6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6KToKKyAgICAgICAgKFdl YktpdDo6V2ViRXZlbnQ6OldlYkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6Om9w ZXJhdG9yPSk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc051bGwpOgorICAgICAgICAo V2ViS2l0OjpXZWJFdmVudDo6dG9NdXRhdGlvbkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2Vi RXZlbnQ6OnRvQ29uc3RNdXRhdGlvbkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6 OnVud3JhcCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojpjb25zdFVud3JhcCk6CisgICAg ICAgICogcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaDogQWRkZWQuCisgICAgICAgICogcHVibGlj L1dlYk11dGF0aW9uRXZlbnQuaDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OldlYk11dGF0aW9u RXZlbnQ6Oik6CisgICAgICAgICogcHVibGljL1dlYk5vZGUuaDoKKyAgICAgICAgKiBwdWJsaWMv V2ViU3RyaW5nLmg6CisgICAgICAgIChXZWJLaXQ6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2Vi S2l0OjpvcGVyYXRvciE9KToKKyAgICAgICAgKiBzcmMvV2ViRXZlbnQuY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OnJlc2V0KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZl bnQ6OmFzc2lnbik6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjpXZWJFdmVudCk6CisgICAg ICAgIChXZWJLaXQ6OldlYkV2ZW50Ojp0eXBlKToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6 OnRhcmdldCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjpjdXJyZW50VGFyZ2V0KToKKyAg ICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmV2ZW50UGhhc2UpOgorICAgICAgICAoV2ViS2l0OjpX ZWJFdmVudDo6YnViYmxlcyk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50OjpjYW5jZWxhYmxl KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzVUlFdmVudCk6CisgICAgICAgIChXZWJL aXQ6OldlYkV2ZW50Ojppc01vdXNlRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6 aXNNdXRhdGlvbkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6OmlzS2V5Ym9hcmRF dmVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc1RleHRFdmVudCk6CisgICAgICAg IChXZWJLaXQ6OldlYkV2ZW50Ojppc0NvbXBvc2l0aW9uRXZlbnQpOgorICAgICAgICAoV2ViS2l0 OjpXZWJFdmVudDo6aXNEcmFnRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXND bGlwYm9hcmRFdmVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc01lc3NhZ2VFdmVu dCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc1doZWVsRXZlbnQpOgorICAgICAgICAo V2ViS2l0OjpXZWJFdmVudDo6aXNCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudCk6CisgICAgICAgIChX ZWJLaXQ6OldlYkV2ZW50Ojppc092ZXJmbG93RXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJF dmVudDo6aXNQYWdlVHJhbnNpdGlvbkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViRXZlbnQ6 OmlzUG9wU3RhdGVFdmVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc1Byb2dyZXNz RXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dy ZXNzRXZlbnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJFdmVudDo6aXNXZWJLaXRBbmltYXRpb25F dmVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc1dlYktpdFRyYW5zaXRpb25FdmVu dCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50Ojppc0JlZm9yZUxvYWRFdmVudCk6CisgICAg ICAgIChXZWJLaXQ6OldlYkV2ZW50OjpjcmVhdGVXZWJFdmVudCk6CisgICAgICAgICogc3JjL1dl YkV2ZW50TGlzdGVuZXJJbXBsLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OkV2ZW50TGlz dGVuZXJXcmFwcGVyOjpFdmVudExpc3RlbmVyV3JhcHBlcik6CisgICAgICAgIChXZWJLaXQ6OkV2 ZW50TGlzdGVuZXJXcmFwcGVyOjp+RXZlbnRMaXN0ZW5lcldyYXBwZXIpOgorICAgICAgICAoV2Vi S2l0OjpFdmVudExpc3RlbmVyV3JhcHBlcjo6b3BlcmF0b3I9PSk6CisgICAgICAgIChXZWJLaXQ6 OkV2ZW50TGlzdGVuZXJXcmFwcGVyOjpoYW5kbGVFdmVudCk6CisgICAgICAgIChXZWJLaXQ6OkV2 ZW50TGlzdGVuZXJXcmFwcGVyOjp3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCk6CisgICAgICAgIChX ZWJLaXQ6OldlYkV2ZW50TGlzdGVuZXI6OldlYkV2ZW50TGlzdGVuZXIpOgorICAgICAgICAoV2Vi S2l0OjpXZWJFdmVudExpc3RlbmVyOjp+V2ViRXZlbnRMaXN0ZW5lcik6CisgICAgICAgIChXZWJL aXQ6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlOjpjcmVhdGVFdmVudExpc3RlbmVyV3JhcHBlcik6 CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlOjpnZXRFdmVudExpc3Rl bmVyV3JhcHBlcik6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlOjpl dmVudExpc3RlbmVyRGVsZXRlZCk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2ZW50TGlzdGVuZXJQ cml2YXRlOjpXZWJFdmVudExpc3RlbmVyUHJpdmF0ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkV2 ZW50TGlzdGVuZXJQcml2YXRlOjp+V2ViRXZlbnRMaXN0ZW5lclByaXZhdGUpOgorICAgICAgICAq IHNyYy9XZWJFdmVudExpc3RlbmVySW1wbC5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6V2Vi RXZlbnRMaXN0ZW5lclByaXZhdGU6Okxpc3RlbmVySW5mbzo6TGlzdGVuZXJJbmZvKToKKyAgICAg ICAgKiBzcmMvV2ViTXV0YXRpb25FdmVudC5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpX ZWJNdXRhdGlvbkV2ZW50OjpXZWJNdXRhdGlvbkV2ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2Vi TXV0YXRpb25FdmVudDo6cmVsYXRlZE5vZGUpOgorICAgICAgICAoV2ViS2l0OjpXZWJNdXRhdGlv bkV2ZW50OjpwcmV2VmFsdWUpOgorICAgICAgICAoV2ViS2l0OjpXZWJNdXRhdGlvbkV2ZW50Ojpu ZXdWYWx1ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYk11dGF0aW9uRXZlbnQ6OmF0dHJOYW1lKToK KyAgICAgICAgKFdlYktpdDo6V2ViTXV0YXRpb25FdmVudDo6YXR0ckNoYW5nZSk6CisgICAgICAg ICogc3JjL1dlYk5vZGUuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJOb2RlOjphZGRFdmVudExp c3RlbmVyKToKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcik6 CisgICAgICAgICogc3JjL1dlYlN0cmluZy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlN0cmlu Zzo6ZXF1YWxzKToKKyAgICAgICAgKFdlYktpdDo6V2ViU3RyaW5nOjpoYXNoKToKKwogMjAxMC0w MS0yMiAgUGV0ZXIgS2FzdGluZyAgPHBrYXN0aW5nQGdvb2dsZS5jb20+CiAKICAgICAgICAgTm90 IHJldmlld2VkLCBiYWNrb3V0LgpJbmRleDogV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXANCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAkocmV2aXNpb24gNTM3MDMp CisrKyBXZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAkod29ya2luZyBjb3B5KQpAQCAtMTA3LDYg KzEwNyw4IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJEcmFnRGF0YS5oJywKICAgICAg ICAgICAgICAgICAncHVibGljL1dlYkVkaXRpbmdBY3Rpb24uaCcsCiAgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJFbGVtZW50LmgnLAorICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRXZlbnQu aCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgnLAogICAgICAg ICAgICAgICAgICdwdWJsaWMvV2ViRmlsZUNob29zZXJDb21wbGV0aW9uLmgnLAogICAgICAgICAg ICAgICAgICdwdWJsaWMvV2ViRmlsZUNob29zZXJQYXJhbXMuaCcsCiAgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJGaW5kT3B0aW9ucy5oJywKQEAgLTEzMCw2ICsxMzIsNyBAQAogICAgICAgICAg ICAgICAgICdwdWJsaWMvV2ViTWVzc2FnZVBvcnRDaGFubmVsLmgnLAogICAgICAgICAgICAgICAg ICdwdWJsaWMvV2ViTWVzc2FnZVBvcnRDaGFubmVsQ2xpZW50LmgnLAogICAgICAgICAgICAgICAg ICdwdWJsaWMvV2ViTWltZVJlZ2lzdHJ5LmgnLAorICAgICAgICAgICAgICAgICdwdWJsaWMvV2Vi TXV0YXRpb25FdmVudC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYk5hdmlnYXRpb25U eXBlLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTm9kZS5oJywKICAgICAgICAgICAg ICAgICAncHVibGljL1dlYk5vZGVDb2xsZWN0aW9uLmgnLApAQCAtMjU5LDYgKzI2Miw5IEBACiAg ICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3Ny Yy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRpZXMuaCcs CisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAorICAgICAgICAgICAgICAgICdz cmMvV2ViRXZlbnRMaXN0ZW5lckltcGwuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkV2 ZW50TGlzdGVuZXJJbXBsLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAn LApAQCAtMjc3LDYgKzI4Myw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMv V2ViTm9kZS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3Bw JywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJF dmVudF9oCisjZGVmaW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2lu Y2x1ZGUgIldlYk5vZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeyBjbGFzcyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5k aWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAg ICBlbnVtIFBoYXNlVHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAg ICAgIEF0VGFyZ2V0ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9 IDMKKyAgICB9OworCisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJF dmVudChjb25zdCBXZWJFdmVudCYgbikgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24obik7IH0KKyAg ICBXZWJFdmVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBuKQorICAgIHsKKyAgICAgICAg YXNzaWduKG4pOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQ SSB2b2lkIHJlc2V0KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVu dCYpOworCisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisK KyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBX ZWJOb2RlIHRhcmdldCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFy Z2V0KCkgY29uc3Q7CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29u c3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJ IGJvb2wgY2FuY2VsYWJsZSgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBib29sIGlzVUlFdmVu dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAg ICBXRUJLSVRfQVBJIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgV0VCS0lUX0FQ SSBib29sIGlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1Rl eHRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNEcmFnRXZlbnQoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg Ym9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1doZWVs RXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc092ZXJmbG93RXZlbnQoKSBjb25z dDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3Q7Cisg ICAgV0VCS0lUX0FQSSBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNY TUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wg aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1dl YktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0JlZm9y ZUxvYWRFdmVudCgpIGNvbnN0OworCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gVCB0b011dGF0 aW9uRXZlbnQoKQorICAgIHsKKyAgICAgICAgVCByZXM7CisgICAgICAgIHJlcy5XZWJFdmVudDo6 YXNzaWduKCp0aGlzKTsKKyAgICAgICAgcmV0dXJuIHJlczsKKyAgICB9CisKKyAgICB0ZW1wbGF0 ZTx0eXBlbmFtZSBUPiBjb25zdCBUIHRvQ29uc3RNdXRhdGlvbkV2ZW50KCkgY29uc3QKKyAgICB7 CisgICAgICAgIFQgcmVzOworICAgICAgICByZXMuV2ViRXZlbnQ6OmFzc2lnbigqdGhpcyk7Cisg ICAgICAgIHJldHVybiByZXM7CisgICAgfQorCisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04K KyAgICBXZWJFdmVudChjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+Jik7Cisg ICAgc3RhdGljIFdlYkV2ZW50IGNyZWF0ZVdlYkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxX ZWJDb3JlOjpFdmVudD4mKTsKKyNlbmRpZgorCitwcm90ZWN0ZWQ6CisgICAgdHlwZWRlZiBXZWJD b3JlOjpFdmVudCBXZWJFdmVudFByaXZhdGU7CisgICAgdm9pZCBhc3NpZ24oV2ViRXZlbnRQcml2 YXRlKik7CisgICAgV2ViRXZlbnRQcml2YXRlKiBtX3ByaXZhdGU7CisKKyAgICB0ZW1wbGF0ZTx0 eXBlbmFtZSBUPiBUKiB1bndyYXAoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0 PFQqPihtX3ByaXZhdGUpOworICAgIH0KKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNvbnN0 IFQqIGNvbnN0VW53cmFwKCkgY29uc3QKKyAgICB7CisgICAgICAgIHJldHVybiBzdGF0aWNfY2Fz dDxjb25zdCBUKj4obV9wcml2YXRlKTsKKyAgICB9Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJL aXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50TGlzdGVu ZXIuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRXZlbnRMaXN0 ZW5lci5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJFdmVudExp c3RlbmVyLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYkV2ZW50TGlz dGVuZXJfaAorI2RlZmluZSBXZWJFdmVudExpc3RlbmVyX2gKKworbmFtZXNwYWNlIFdlYktpdCB7 CisKK2NsYXNzIEV2ZW50TGlzdGVuZXJXcmFwcGVyOworY2xhc3MgV2ViRXZlbnQ7CitjbGFzcyBX ZWJFdmVudExpc3RlbmVyUHJpdmF0ZTsKK2NsYXNzIFdlYk5vZGU7CisKK2NsYXNzIFdlYkV2ZW50 TGlzdGVuZXIgeworcHVibGljOgorICAgIFdlYkV2ZW50TGlzdGVuZXIoKTsKKyAgICB2aXJ0dWFs IH5XZWJFdmVudExpc3RlbmVyKCk7CisKKyAgICAvLyBDYWxsZWQgd2hlbiBhbiBldmVudCBpcyBy ZWNlaXZlZC4KKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgV2ViRXZlbnQmKSA9 IDA7CisKK3ByaXZhdGU6CisgICAgZnJpZW5kIGNsYXNzIEV2ZW50TGlzdGVuZXJXcmFwcGVyOwor ICAgIGZyaWVuZCBjbGFzcyBXZWJOb2RlOworCisgICAgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUq IG1fcHJpdmF0ZTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6 IFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTXV0YXRpb25FdmVudC5oDQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQot LS0gV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgJKHJldmlzaW9uIDAp CisrKyBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk11dGF0aW9uRXZlbnQuaAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw2MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4g c291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFy ZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5 cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRo ZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRv cnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJv bQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQg SE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisg KiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg VEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRP LCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisjaWZuZGVmIFdlYk11dGF0aW9uRXZlbnRfaAorI2RlZmluZSBXZWJN dXRhdGlvbkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkV2ZW50LmgiCisKK25hbWVzcGFjZSBXZWJD b3JlIHsgY2xhc3MgRXZlbnQ7IH0KKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KK25hbWVzcGFj ZSBXVEYgeyB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gY2xhc3MgUGFzc1JlZlB0cjsgfQorI2VuZGlm CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBXZWJNdXRhdGlvbkV2ZW50IDogcHVibGlj IFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAgICBlbnVtIEF0dHJDaGFuZ2VUeXBlIHsKKyAgICAgICAg TW9kaWZpY2F0aW9uICAgID0gMSwKKyAgICAgICAgQWRkaXRpb24gICAgICAgID0gMiwKKyAgICAg ICAgUmVtb3ZhbCAgICAgICAgID0gMworICAgIH07CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJ T04KKyAgICBXZWJNdXRhdGlvbkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpF dmVudD4mKTsKKyNlbmRpZgorCisgICAgV0VCS0lUX0FQSSBXZWJOb2RlIHJlbGF0ZWROb2RlKCkg Y29uc3Q7CisgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcgcHJldlZhbHVlKCkgY29uc3Q7CisgICAg V0VCS0lUX0FQSSBXZWJTdHJpbmcgbmV3VmFsdWUoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIFdl YlN0cmluZyBhdHRyTmFtZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgQXR0ckNoYW5nZVR5cGUg YXR0ckNoYW5nZSgpIGNvbnN0OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRp ZgpJbmRleDogV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJOb2RlLmgNCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0t LSBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk5vZGUuaAkocmV2aXNpb24gNTM3MDMpCisrKyBX ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk5vZGUuaAkod29ya2luZyBjb3B5KQpAQCAtNDEsNiAr NDEsOCBAQCBuYW1lc3BhY2UgV1RGIHsgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGNsCiAKIG5hbWVz cGFjZSBXZWJLaXQgewogY2xhc3MgV2ViRG9jdW1lbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVy OworY2xhc3MgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU7CiBjbGFzcyBXZWJGcmFtZTsKIGNsYXNz IFdlYk5vZGVMaXN0OwogCkBAIC0xMTUsNiArMTE3LDE1IEBAIHB1YmxpYzoKICAgICAgICAgcmV0 dXJuIHJlczsKICAgICB9CiAKKyAgICB2aXJ0dWFsIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcigKKyAg ICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsCisgICAgICAgIFdlYkV2ZW50TGlzdGVu ZXIqIGxpc3RlbmVyLAorICAgICAgICBib29sIHVzZUNhcHR1cmUpOworICAgIHZpcnR1YWwgdm9p ZCByZW1vdmVFdmVudExpc3RlbmVyKAorICAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlw ZSwKKyAgICAgICAgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsCisgICAgICAgIGJvb2wgdXNl Q2FwdHVyZSk7CisKIHByb3RlY3RlZDoKICAgICB0eXBlZGVmIFdlYkNvcmU6Ok5vZGUgV2ViTm9k ZVByaXZhdGU7CiAgICAgdm9pZCBhc3NpZ24oV2ViTm9kZVByaXZhdGUqKTsKSW5kZXg6IFdlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViU3RyaW5nLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlN0cmluZy5oCShyZXZpc2lvbiA1MzcwMykKKysrIFdlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViU3RyaW5nLmgJKHdvcmtpbmcgY29weSkKQEAgLTcxLDYgKzcxLDcgQEAg cHVibGljOgogICAgICAgICBhc3NpZ24ocyk7CiAgICAgICAgIHJldHVybiAqdGhpczsKICAgICB9 CisgICAgV0VCS0lUX0FQSSBib29sIGVxdWFscyhjb25zdCBXZWJTdHJpbmcmIHMpIGNvbnN0Owog CiAgICAgV0VCS0lUX0FQSSB2b2lkIHJlc2V0KCk7CiAgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2ln bihjb25zdCBXZWJTdHJpbmcmKTsKQEAgLTE2Myw2ICsxNjQsMTYgQEAgcHJpdmF0ZToKICAgICBX ZWJTdHJpbmdQcml2YXRlKiBtX3ByaXZhdGU7CiB9OwogCitpbmxpbmUgYm9vbCBvcGVyYXRvcj09 KGNvbnN0IFdlYlN0cmluZyYgYSwgY29uc3QgV2ViU3RyaW5nJiBiKQoreworICAgIHJldHVybiBh LmVxdWFscyhiKTsKK30KKworaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBXZWJTdHJpbmcm IGEsIGNvbnN0IFdlYlN0cmluZyYgYikKK3sKKyAgICByZXR1cm4gIShhID09IGIpOworfQorCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkV2ZW50LmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZl bnQuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudC5jcHAJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjAyIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgIldlYkV2ZW50LmgiCisKKyNp bmNsdWRlICJFdmVudC5oIgorI2luY2x1ZGUgIk5vZGUuaCIKKyNpbmNsdWRlICJXZWJNdXRhdGlv bkV2ZW50LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKworbmFtZXNwYWNlIFdlYktp dCB7CisKK2NsYXNzIFdlYkV2ZW50UHJpdmF0ZSA6IHB1YmxpYyBXZWJDb3JlOjpFdmVudCB7Cit9 OworCit2b2lkIFdlYkV2ZW50OjpyZXNldCgpCit7CisgICAgYXNzaWduKDApOworfQorCit2b2lk IFdlYkV2ZW50Ojphc3NpZ24oY29uc3QgV2ViRXZlbnQmIG90aGVyKQoreworICAgIFdlYkV2ZW50 UHJpdmF0ZSogcCA9IGNvbnN0X2Nhc3Q8V2ViRXZlbnRQcml2YXRlKj4ob3RoZXIubV9wcml2YXRl KTsKKyAgICBpZiAocCkKKyAgICAgICAgcC0+cmVmKCk7CisgICAgYXNzaWduKHApOworfQorCit2 b2lkIFdlYkV2ZW50Ojphc3NpZ24oV2ViRXZlbnRQcml2YXRlKiBwKQoreworICAgIC8vIHAgaXMg YWxyZWFkeSByZWYnZCBmb3IgdXMgYnkgdGhlIGNhbGxlcgorICAgIGlmIChtX3ByaXZhdGUpCisg ICAgICAgIG1fcHJpdmF0ZS0+ZGVyZWYoKTsKKyAgICBtX3ByaXZhdGUgPSBwOworfQorCitXZWJF dmVudDo6V2ViRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZl bnQpCisgICAgOiBtX3ByaXZhdGUoc3RhdGljX2Nhc3Q8V2ViRXZlbnRQcml2YXRlKj4oZXZlbnQu cmVsZWFzZVJlZigpKSkKK3sKK30KKworV2ViU3RyaW5nIFdlYkV2ZW50Ojp0eXBlKCkgY29uc3QK K3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT50eXBlKCk7Cit9CisKK1dlYk5vZGUgV2ViRXZlbnQ6 OnRhcmdldCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIFdlYk5vZGUobV9wcml2YXRlLT50YXJnZXQo KS0+dG9Ob2RlKCkpOworfQorCitXZWJOb2RlIFdlYkV2ZW50OjpjdXJyZW50VGFyZ2V0KCkgY29u c3QKK3sKKyAgICByZXR1cm4gV2ViTm9kZShtX3ByaXZhdGUtPmN1cnJlbnRUYXJnZXQoKS0+dG9O b2RlKCkpOworfQorCitXZWJFdmVudDo6UGhhc2VUeXBlIFdlYkV2ZW50OjpldmVudFBoYXNlKCkg Y29uc3QKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8V2ViRXZlbnQ6OlBoYXNlVHlwZT4obV9w cml2YXRlLT5ldmVudFBoYXNlKCkpOworfQorCitib29sIFdlYkV2ZW50OjpidWJibGVzKCkgY29u c3QgeworICAgIHJldHVybiBtX3ByaXZhdGUtPmJ1YmJsZXMoKTsKK30KKworYm9vbCBXZWJFdmVu dDo6Y2FuY2VsYWJsZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+Y2FuY2VsYWJs ZSgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1VJRXZlbnQoKSBjb25zdAoreworICAgIHJldHVy biBtX3ByaXZhdGUtPmlzVUlFdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc01vdXNlRXZl bnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTW91c2VFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc011dGF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBt X3ByaXZhdGUtPmlzTXV0YXRpb25FdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc0tleWJv YXJkRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzS2V5Ym9hcmRFdmVu dCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1RleHRFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIG1fcHJpdmF0ZS0+aXNUZXh0RXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNDb21w b3NpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0NvbXBvc2l0 aW9uRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNEcmFnRXZlbnQoKSBjb25zdAorewor ICAgIHJldHVybiBtX3ByaXZhdGUtPmlzRHJhZ0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6 OmlzQ2xpcGJvYXJkRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQ2xp cGJvYXJkRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNNZXNzYWdlRXZlbnQoKSBjb25z dAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTWVzc2FnZUV2ZW50KCk7Cit9CisKK2Jvb2wg V2ViRXZlbnQ6OmlzV2hlZWxFdmVudCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+ aXNXaGVlbEV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQmVmb3JlVGV4dEluc2VydGVk RXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQmVmb3JlVGV4dEluc2Vy dGVkRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNPdmVyZmxvd0V2ZW50KCkgY29uc3QK K3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc092ZXJmbG93RXZlbnQoKTsKK30KKworYm9vbCBX ZWJFdmVudDo6aXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9w cml2YXRlLT5pc1BhZ2VUcmFuc2l0aW9uRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQ b3BTdGF0ZUV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1BvcFN0YXRl RXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQcm9ncmVzc0V2ZW50KCkgY29uc3QKK3sK KyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1Byb2dyZXNzRXZlbnQoKTsKK30KKworYm9vbCBXZWJF dmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdAoreworICAgIHJldHVy biBtX3ByaXZhdGUtPmlzWE1MSHR0cFJlcXVlc3RQcm9ncmVzc0V2ZW50KCk7Cit9CisKK2Jvb2wg V2ViRXZlbnQ6OmlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBt X3ByaXZhdGUtPmlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6 aXNXZWJLaXRUcmFuc2l0aW9uRXZlbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX3ByaXZhdGUt PmlzV2ViS2l0VHJhbnNpdGlvbkV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQmVmb3Jl TG9hZEV2ZW50KCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0JlZm9yZUxvYWRF dmVudCgpOworfQorCitXZWJFdmVudCBXZWJFdmVudDo6Y3JlYXRlV2ViRXZlbnQoY29uc3QgV1RG OjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZlbnQpCit7CisgICAgaWYgKGV2ZW50LT5p c011dGF0aW9uRXZlbnQoKSkKKyAgICAgIHJldHVybiBXZWJNdXRhdGlvbkV2ZW50KGV2ZW50KTsK KworICAgIC8vIFRPRE8oamNhbXBhbik6IGltcGxlbWVudCBvdGhlciBldmVudHMuCisgICAgcmV0 dXJuIFdlYkV2ZW50KCk7Cit9CisKK30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCkluZGV4 OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJJbXBsLmNwcA0KPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lckltcGwuY3BwCShyZXZp c2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVySW1wbC5jcHAJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXJJ bXBsLmgiCisKKyNpbmNsdWRlICJXZWJFdmVudC5oIgorI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVu ZXIuaCIKKworI2luY2x1ZGUgIkV2ZW50LmgiCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIgor CituYW1lc3BhY2UgV2ViS2l0IHsKKworV2ViRXZlbnRMaXN0ZW5lcjo6V2ViRXZlbnRMaXN0ZW5l cigpCisgICAgOiBtX3ByaXZhdGUobmV3IFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKHRoaXMpKQor eworfQorCitXZWJFdmVudExpc3RlbmVyOjp+V2ViRXZlbnRMaXN0ZW5lcigpCit7CisgICAgLy8g Tm90aWZpZXMgYWxsIFdlYkV2ZW50TGlzdGVuZXJXcmFwcGVycyB0aGF0IHdlIGFyZSBnb2luZyBh d2F5IHNvIHRoZXkgY2FuCisgICAgLy8gaW52YWxpZGF0ZSB0aGVpciBwb2ludGVyIHRvIHVzLgor ICAgIFdURjo6VmVjdG9yPFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlOjpMaXN0ZW5lckluZm8+Ojpj b25zdF9pdGVyYXRvciBpdGVyOworICAgIGZvciAoaXRlciA9IG1fcHJpdmF0ZS0+bV9saXN0ZW5l cldyYXBwZXJzLmJlZ2luKCk7IGl0ZXIgIT0gbV9wcml2YXRlLT5tX2xpc3RlbmVyV3JhcHBlcnMu ZW5kKCk7ICsraXRlcikgeworICAgICAgICBpdGVyLT5ldmVudExpc3RlbmVyV3JhcHBlci0+d2Vi RXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsKKyAgICB9CisKKyAgICBkZWxldGUgbV9wcml2YXRlOwor fQorCitXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6V2ViRXZlbnRMaXN0ZW5lclByaXZhdGUoV2Vi RXZlbnRMaXN0ZW5lciogd2ViRXZlbnRMaXN0ZW5lcikKKyAgICA6IG1fd2ViRXZlbnRMaXN0ZW5l cih3ZWJFdmVudExpc3RlbmVyKQoreworfQorCitXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6fldl YkV2ZW50TGlzdGVuZXJQcml2YXRlKCkKK3sKK30KKworRXZlbnRMaXN0ZW5lcldyYXBwZXIqIFdl YkV2ZW50TGlzdGVuZXJQcml2YXRlOjpjcmVhdGVFdmVudExpc3RlbmVyV3JhcHBlcihjb25zdCBX ZWJTdHJpbmcmIGV2ZW50VHlwZSwKKyAgICAgICAgYm9vbCB1c2VDYXB0dXJlLAorICAgICAgICBO b2RlKiBub2RlKQoreworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIg PSBuZXcgRXZlbnRMaXN0ZW5lcldyYXBwZXIobV93ZWJFdmVudExpc3RlbmVyKTsKKyAgICBXZWJF dmVudExpc3RlbmVyUHJpdmF0ZTo6TGlzdGVuZXJJbmZvIGxpc3RlbmVySW5mbyhldmVudFR5cGUs IHVzZUNhcHR1cmUsIGxpc3RlbmVyV3JhcHBlciwgbm9kZSk7CisgICAgbV9saXN0ZW5lcldyYXBw ZXJzLmFwcGVuZChsaXN0ZW5lckluZm8pOworICAgIHJldHVybiBsaXN0ZW5lcldyYXBwZXI7Cit9 CisKK0V2ZW50TGlzdGVuZXJXcmFwcGVyKiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Z2V0RXZl bnRMaXN0ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsCisgICAgICAgIGJv b2wgdXNlQ2FwdHVyZSwKKyAgICAgICAgTm9kZSogbm9kZSkKK3sKKyAgICBXVEY6OlZlY3RvcjxX ZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6TGlzdGVuZXJJbmZvPjo6Y29uc3RfaXRlcmF0b3IgaXRl cjsKKyAgICBmb3IgKGl0ZXIgPSBtX2xpc3RlbmVyV3JhcHBlcnMuYmVnaW4oKTsgaXRlciAhPSBt X2xpc3RlbmVyV3JhcHBlcnMuZW5kKCk7ICsraXRlcikgeworICAgICAgICBpZiAoaXRlci0+bm9k ZSA9PSBub2RlKQorICAgICAgICAgIHJldHVybiBpdGVyLT5ldmVudExpc3RlbmVyV3JhcHBlcjsK KyAgICB9CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIE5VTEw7Cit9CisK K3ZvaWQgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OmV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50 TGlzdGVuZXJXcmFwcGVyKiBldmVudExpc3RlbmVyKQoreworICAgIGZvciAoc2l6ZV90IGkgPSAw OyBpIDwgbV9saXN0ZW5lcldyYXBwZXJzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmIChtX2xp c3RlbmVyV3JhcHBlcnNbaV0uZXZlbnRMaXN0ZW5lcldyYXBwZXIgPT0gZXZlbnRMaXN0ZW5lcikg eworICAgICAgICAgICAgbV9saXN0ZW5lcldyYXBwZXJzLnJlbW92ZShpKTsKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKK30K KworRXZlbnRMaXN0ZW5lcldyYXBwZXI6OkV2ZW50TGlzdGVuZXJXcmFwcGVyKFdlYkV2ZW50TGlz dGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpCisgICAgOiBFdmVudExpc3RlbmVyKEV2ZW50TGlzdGVu ZXI6OkpTRXZlbnRMaXN0ZW5lclR5cGUpCisgICAgLCBtX3dlYkV2ZW50TGlzdGVuZXIod2ViRXZl bnRMaXN0ZW5lcikKK3sKK30KKworRXZlbnRMaXN0ZW5lcldyYXBwZXI6On5FdmVudExpc3RlbmVy V3JhcHBlcigpCit7CisgICAgaWYgKG1fd2ViRXZlbnRMaXN0ZW5lcikKKyAgICAgICAgbV93ZWJF dmVudExpc3RlbmVyLT5tX3ByaXZhdGUtPmV2ZW50TGlzdGVuZXJEZWxldGVkKHRoaXMpOworfQor Citib29sIEV2ZW50TGlzdGVuZXJXcmFwcGVyOjpvcGVyYXRvcj09KGNvbnN0IEV2ZW50TGlzdGVu ZXImIGxpc3RlbmVyKQoreworICAgIHJldHVybiB0aGlzID09ICZsaXN0ZW5lcjsKK30KKwordm9p ZCBFdmVudExpc3RlbmVyV3JhcHBlcjo6aGFuZGxlRXZlbnQoU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KQoreworICBpZiAoIW1fd2ViRXZlbnRMaXN0ZW5lcikK KyAgICAgIHJldHVybjsKKyAgV2ViRXZlbnQgd2ViRXZlbnQgPSBXZWJFdmVudDo6Y3JlYXRlV2Vi RXZlbnQoZXZlbnQpOworICBtX3dlYkV2ZW50TGlzdGVuZXItPmhhbmRsZUV2ZW50KHdlYkV2ZW50 KTsKK30KKwordm9pZCBFdmVudExpc3RlbmVyV3JhcHBlcjo6d2ViRXZlbnRMaXN0ZW5lckRlbGV0 ZWQoKQoreworICAgIG1fd2ViRXZlbnRMaXN0ZW5lciA9IE5VTEw7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYktpdApJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVySW1w bC5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVy SW1wbC5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3Rl bmVySW1wbC5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDExMyBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24u CisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMg b2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3Rl IHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmlj IHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMi IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViRXZlbnRM aXN0ZW5lckltcGxfaAorI2RlZmluZSBXZWJFdmVudExpc3RlbmVySW1wbF9oCisKKyNpbmNsdWRl ICJFdmVudExpc3RlbmVyLmgiCisKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworI2luY2x1ZGUg PHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworY2xhc3MgTm9kZTsKK2NsYXNz IFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ7Cit9CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwor CituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgRXZlbnRMaXN0ZW5lcldyYXBwZXI7CitjbGFz cyBXZWJFdmVudExpc3RlbmVyOworCitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZQorewor cHVibGljOgorICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKFdlYkV2ZW50TGlzdGVuZXIqIHdl YkV2ZW50TGlzdGVuZXIpOworICAgIH5XZWJFdmVudExpc3RlbmVyUHJpdmF0ZSgpOworCisgICAg IEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBjcmVhdGVFdmVudExpc3RlbmVyV3JhcHBlcigKKyAgICAg ICAgIGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsIE5vZGUqIG5v ZGUpOworCisgICAgIC8vIEdldHMgdGhlIExpc3RlbmVyRXZlbnRXcmFwcGVyIGZvciBhIHNwZWNp ZmljIG5vZGUuCisgICAgIC8vIFVzZWQgYnkgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcigp LgorICAgICBFdmVudExpc3RlbmVyV3JhcHBlciogZ2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoCisg ICAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2Rl KiBub2RlKTsKKworICAgIC8vIENhbGxlZCBieSB0aGUgRXZlbnRMaXN0ZW5lcldyYXBwZXIgd2hl biBpdCBpcyBhYm91dCB0byBiZSBkZWxldGVkLgorICAgIHZvaWQgZXZlbnRMaXN0ZW5lckRlbGV0 ZWQoRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXIpOworCitwcml2YXRlOgorICAg IGZyaWVuZCBjbGFzcyBXZWJFdmVudExpc3RlbmVyOworCisgICAgc3RydWN0IExpc3RlbmVySW5m byB7CisgICAgICAgIExpc3RlbmVySW5mbyhjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9v bCB1c2VDYXB0dXJlLAorICAgICAgICAgICAgICAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIq IGV2ZW50TGlzdGVuZXJXcmFwcGVyLAorICAgICAgICAgICAgICAgICAgICAgTm9kZSogbm9kZSkK KyAgICAgICAgICAgIDogZXZlbnRUeXBlKGV2ZW50VHlwZSkKKyAgICAgICAgICAgICwgdXNlQ2Fw dHVyZSh1c2VDYXB0dXJlKQorICAgICAgICAgICAgLCBldmVudExpc3RlbmVyV3JhcHBlcihldmVu dExpc3RlbmVyV3JhcHBlcikKKyAgICAgICAgICAgICwgbm9kZShub2RlKQorICAgICAgICB7Cisg ICAgICAgIH0KKworICAgICAgICBXZWJTdHJpbmcgZXZlbnRUeXBlOworICAgICAgICBib29sIHVz ZUNhcHR1cmU7CisgICAgICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBldmVudExpc3RlbmVyV3Jh cHBlcjsKKyAgICAgICAgTm9kZSogbm9kZTsKKyAgICB9OworCisgICAgV2ViRXZlbnRMaXN0ZW5l ciogbV93ZWJFdmVudExpc3RlbmVyOworCisgICAgLy8gV2Uga2VlcCBhIGxpc3Qgb2YgdGhlIHdy YXBwZXIgZm9yIHRoZSBXZWJLaXQgRXZlbnRMaXN0ZW5lciwgaXQgaXMgbmVlZGVkCisgICAgLy8g dG8gaW1wbGVtZW50IFdlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoKS4KKyAgICBXVEY6OlZl Y3RvcjxMaXN0ZW5lckluZm8+IG1fbGlzdGVuZXJXcmFwcGVyczsKK307CisKK2NsYXNzIEV2ZW50 TGlzdGVuZXJXcmFwcGVyIDogcHVibGljIEV2ZW50TGlzdGVuZXIKK3sKK3B1YmxpYzoKKyAgICBF dmVudExpc3RlbmVyV3JhcHBlcihXZWJFdmVudExpc3RlbmVyKiB3ZWJFdmVudExpc3RlbmVyKTsK KyAgICB+RXZlbnRMaXN0ZW5lcldyYXBwZXIoKTsKKworICAgIHZpcnR1YWwgYm9vbCBvcGVyYXRv cj09KGNvbnN0IEV2ZW50TGlzdGVuZXImIGxpc3RlbmVyKTsKKyAgICB2aXJ0dWFsIHZvaWQgaGFu ZGxlRXZlbnQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KTsK KworICAgIHZvaWQgd2ViRXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsKKworcHJpdmF0ZToKKyAgICBX ZWJFdmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7Cit9OworCit9IC8vIG5hbWVzcGFj ZSBXZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYk11dGF0aW9u RXZlbnQuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJNdXRhdGlv bkV2ZW50LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViTXV0YXRp b25FdmVudC5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzEgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiV2ViTXV0 YXRpb25FdmVudC5oIgorCisjaW5jbHVkZSAiTXV0YXRpb25FdmVudC5oIgorCit1c2luZyBuYW1l c3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK1dlYk11dGF0aW9uRXZlbnQ6 OldlYk11dGF0aW9uRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYg ZXZlbnQpCisgICAgOiBXZWJFdmVudChldmVudCkKK3sKK30KKworV2ViTm9kZSBXZWJNdXRhdGlv bkV2ZW50OjpyZWxhdGVkTm9kZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIFdlYk5vZGUoY29uc3RV bndyYXA8TXV0YXRpb25FdmVudD4oKS0+cmVsYXRlZE5vZGUoKSk7Cit9CisKK1dlYlN0cmluZyBX ZWJNdXRhdGlvbkV2ZW50OjpwcmV2VmFsdWUoKSBjb25zdAoreworICAgIHJldHVybiBXZWJTdHJp bmcoY29uc3RVbndyYXA8TXV0YXRpb25FdmVudD4oKS0+cHJldlZhbHVlKCkpOworfQorCitXZWJT dHJpbmcgV2ViTXV0YXRpb25FdmVudDo6bmV3VmFsdWUoKSBjb25zdAoreworICAgIHJldHVybiBX ZWJTdHJpbmcoY29uc3RVbndyYXA8TXV0YXRpb25FdmVudD4oKS0+bmV3VmFsdWUoKSk7Cit9CisK K1dlYlN0cmluZyBXZWJNdXRhdGlvbkV2ZW50OjphdHRyTmFtZSgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIFdlYlN0cmluZyhjb25zdFVud3JhcDxNdXRhdGlvbkV2ZW50PigpLT5hdHRyTmFtZSgpKTsK K30KKworV2ViTXV0YXRpb25FdmVudDo6QXR0ckNoYW5nZVR5cGUgV2ViTXV0YXRpb25FdmVudDo6 YXR0ckNoYW5nZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEF0dHJDaGFuZ2VU eXBlPihjb25zdFVud3JhcDxNdXRhdGlvbkV2ZW50PigpLT5hdHRyQ2hhbmdlKCkpOworfQorCit9 CisKKwpJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJOb2RlLmNwcA0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0K LS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViTm9kZS5jcHAJKHJldmlzaW9uIDUzNzAzKQorKysg V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJOb2RlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiAr MzgsOSBAQAogI2luY2x1ZGUgIk5vZGVMaXN0LmgiCiAKICNpbmNsdWRlICJXZWJEb2N1bWVudC5o IgorI2luY2x1ZGUgIldlYkV2ZW50LmgiCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lci5oIgor I2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXJJbXBsLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBs LmgiCiAjaW5jbHVkZSAiV2ViTm9kZUxpc3QuaCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKQEAg LTE3Myw0ICsxNzYsMjYgQEAgYm9vbCBXZWJOb2RlOjppc0VsZW1lbnROb2RlKCkgY29uc3QKICAg ICByZXR1cm4gbV9wcml2YXRlLT5pc0VsZW1lbnROb2RlKCk7CiB9CiAKK3ZvaWQgV2ViTm9kZTo6 YWRkRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwKKyAgICBXZWJFdmVu dExpc3RlbmVyKiBsaXN0ZW5lciwKKyAgICBib29sIHVzZUNhcHR1cmUpCit7CisgICAgRXZlbnRM aXN0ZW5lcldyYXBwZXIqIGxpc3RlbmVyV3JhcHBlciA9CisgICAgICAgIGxpc3RlbmVyLT5tX3By aXZhdGUtPmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwg bV9wcml2YXRlKTsKKyAgICAvLyBUaGUgbGlzdGVuZXJXcmFwcGVyIGlzIG9ubHkgcmVmZXJlbmNl ZCBieSB0aGUgYWN0dWFsIE5vZGUuICBPbmNlIGl0IGdvZXMKKyAgICAvLyBhd2F5LCB0aGUgd3Jh cHBlciBub3RpZmllcyB0aGUgV2ViRXZlbnRMaXN0ZW5lciBzbyBpdCBjYW4gY2xlYXIgaXRzCisg ICAgLy8gcG9pbnRlciB0byBpdC4KKyAgICBtX3ByaXZhdGUtPmFkZEV2ZW50TGlzdGVuZXIoZXZl bnRUeXBlLCBhZG9wdFJlZihsaXN0ZW5lcldyYXBwZXIpLCB1c2VDYXB0dXJlKTsKK30KKwordm9p ZCBXZWJOb2RlOjpyZW1vdmVFdmVudExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBl LAorICAgIFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLAorICAgIGJvb2wgdXNlQ2FwdHVyZSkK K3sKKyAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGxpc3RlbmVyV3JhcHBlciA9CisgICAgICBsaXN0 ZW5lci0+bV9wcml2YXRlLT5nZXRFdmVudExpc3RlbmVyV3JhcHBlcihldmVudFR5cGUsIHVzZUNh cHR1cmUsIG1fcHJpdmF0ZSk7CisgIG1fcHJpdmF0ZS0+cmVtb3ZlRXZlbnRMaXN0ZW5lcihldmVu dFR5cGUsIGxpc3RlbmVyV3JhcHBlciwgdXNlQ2FwdHVyZSk7CisgIC8vIGxpc3RlbmVyV3JhcHBl ciBpcyBub3cgZGVsZXRlZC4KK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CkluZGV4OiBXZWJL aXQvY2hyb21pdW0vc3JjL1dlYlN0cmluZy5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hy b21pdW0vc3JjL1dlYlN0cmluZy5jcHAJKHJldmlzaW9uIDUzNzAzKQorKysgV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJTdHJpbmcuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC04Niw2ICs4NiwxMSBAQCBX ZWJTdHJpbmcgV2ViU3RyaW5nOjpmcm9tVVRGOChjb25zdCBjaGFyCiAgICAgcmV0dXJuIFdlYkNv cmU6OlN0cmluZzo6ZnJvbVVURjgoZGF0YSk7CiB9CiAKK2Jvb2wgV2ViU3RyaW5nOjplcXVhbHMo Y29uc3QgV2ViU3RyaW5nJiBzKSBjb25zdAoreworICAgIHJldHVybiBlcXVhbChtX3ByaXZhdGUs IHMubV9wcml2YXRlKTsKK30KKwogV2ViU3RyaW5nOjpXZWJTdHJpbmcoY29uc3QgV2ViQ29yZTo6 U3RyaW5nJiBzKQogICAgIDogbV9wcml2YXRlKHN0YXRpY19jYXN0PFdlYlN0cmluZ1ByaXZhdGUq PihzLmltcGwoKSkpCiB7Cg== 47377 2010-01-25 17:17:54 -0800 2010-01-26 09:04:30 -0800 Adding event handler to the Chromium API event_3.patch text/plain 38438 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzgzMykKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wMS0yNSAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgRXZlbnRMaXN0ZW5lcnMgdG8gdGhlIGNocm9t aXVtIEFQSS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzM4ODIKKworICAgICAgICAqIFdlYktpdC5neXA6CisgICAgICAgICogcHVibGljL1dlYkV2 ZW50Lmg6IEFkZGVkLgorICAgICAgICAqIHB1YmxpYy9XZWJFdmVudExpc3RlbmVyLmg6IEFkZGVk LgorICAgICAgICAqIHB1YmxpYy9XZWJNdXRhdGlvbkV2ZW50Lmg6IEFkZGVkLgorICAgICAgICAq IHB1YmxpYy9XZWJOb2RlLmg6CisgICAgICAgICogcHVibGljL1dlYlN0cmluZy5oOgorICAgICAg ICAoV2ViS2l0OjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6Cisg ICAgICAgICogc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcDogQWRkZWQuCisgICAgICAgICog c3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmg6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVudExpc3RlbmVyLmNwcDogQWRkZWQu CisgICAgICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHNy Yy9XZWJOb2RlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6YWRkRXZlbnRMaXN0ZW5l cik6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIpOgorICAg ICAgICAqIHNyYy9XZWJTdHJpbmcuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTdHJpbmc6OmVx dWFscyk6CisKIDIwMTAtMDEtMjIgIEVsbGlvdCBHbGF5c2hlciAgPGVyZ0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vV2ViS2l0Lmd5cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCSh3b3JraW5n IGNvcHkpCkBAIC0xMDcsNiArMTA3LDggQEAKICAgICAgICAgICAgICAgICAncHVibGljL1dlYkRy YWdEYXRhLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRWRpdGluZ0FjdGlvbi5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkVsZW1lbnQuaCcsCisgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJFdmVudC5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dlYkV2ZW50TGlz dGVuZXIuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlckNvbXBsZXRp b24uaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlclBhcmFtcy5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkZpbmRPcHRpb25zLmgnLApAQCAtMTMwLDYgKzEz Miw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWwuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWxDbGllbnQuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNaW1lUmVnaXN0cnkuaCcsCisgICAgICAgICAg ICAgICAgJ3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJs aWMvV2ViTmF2aWdhdGlvblR5cGUuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJOb2Rl LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTm9kZUNvbGxlY3Rpb24uaCcsCkBAIC0y MTAsNiArMjEzLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL0RyYWdDbGllbnRJbXBsLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5jcHAnLAogICAgICAgICAgICAg ICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3JjL0V2ZW50 TGlzdGVuZXJXcmFwcGVyLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9FdmVudExpc3RlbmVy V3JhcHBlci5oJywKICAgICAgICAgICAgICAgICAnc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5j cHAnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvZ3RrL1dlYkZvbnRJbmZvLmNwcCcsCkBAIC0yNTksNiArMjY0LDEw IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRp ZXMuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAorICAgICAgICAgICAg ICAgICdzcmMvV2ViRXZlbnRMaXN0ZW5lci5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkV2ZW50 TGlzdGVuZXJQcml2YXRlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAn LApAQCAtMjc3LDYgKzI4Niw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMv V2ViTm9kZS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3Bw JywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJF dmVudF9oCisjZGVmaW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2lu Y2x1ZGUgIldlYk5vZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeyBjbGFzcyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5k aWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAg ICBlbnVtIFBoYXNlVHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAg ICAgIEF0VGFyZ2V0ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9 IDMKKyAgICB9OworCisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJF dmVudChjb25zdCBXZWJFdmVudCYgbikgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24obik7IH0KKyAg ICBXZWJFdmVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBlKQorICAgIHsKKyAgICAgICAg YXNzaWduKGUpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQ SSB2b2lkIHJlc2V0KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVu dCYpOworCisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisK KyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBX ZWJOb2RlIHRhcmdldCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFy Z2V0KCkgY29uc3Q7CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29u c3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJ IGJvb2wgY2FuY2VsYWJsZSgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBib29sIGlzVUlFdmVu dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAg ICBXRUJLSVRfQVBJIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgV0VCS0lUX0FQ SSBib29sIGlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1Rl eHRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNEcmFnRXZlbnQoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg Ym9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1doZWVs RXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc092ZXJmbG93RXZlbnQoKSBjb25z dDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3Q7Cisg ICAgV0VCS0lUX0FQSSBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNY TUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wg aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1dl YktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0JlZm9y ZUxvYWRFdmVudCgpIGNvbnN0OworCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gVCB0b0V2ZW50 KCkKKyAgICB7CisgICAgICAgIFQgcmVzOworICAgICAgICByZXMuV2ViRXZlbnQ6OmFzc2lnbigq dGhpcyk7CisgICAgICAgIHJldHVybiByZXM7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5h bWUgVD4gY29uc3QgVCB0b0NvbnN0RXZlbnQoKSBjb25zdAorICAgIHsKKyAgICAgICAgVCByZXM7 CisgICAgICAgIHJlcy5XZWJFdmVudDo6YXNzaWduKCp0aGlzKTsKKyAgICAgICAgcmV0dXJuIHJl czsKKyAgICB9CisKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYkV2ZW50KGNv bnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mKTsKKyAgICBzdGF0aWMgV2ViRXZl bnQgY3JlYXRlV2ViRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYp OworI2VuZGlmCisKK3Byb3RlY3RlZDoKKyAgICB0eXBlZGVmIFdlYkNvcmU6OkV2ZW50IFdlYkV2 ZW50UHJpdmF0ZTsKKyAgICB2b2lkIGFzc2lnbihXZWJFdmVudFByaXZhdGUqKTsKKyAgICBXZWJF dmVudFByaXZhdGUqIG1fcHJpdmF0ZTsKKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IFQqIHVu d3JhcCgpCisgICAgeworICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+KG1fcHJpdmF0ZSk7 CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gY29uc3QgVCogY29uc3RVbndyYXAo KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IFQqPihtX3By aXZhdGUpOworICAgIH0KK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5k ZXg6IFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oDQo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 DQotLS0gV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgJKHJldmlzaW9u IDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw2NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVy IHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmli dXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg ZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViRXZlbnRMaXN0ZW5lcl9oCisjZGVmaW5l IFdlYkV2ZW50TGlzdGVuZXJfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIE5vZGU7IH0K KworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIEV2ZW50TGlzdGVuZXJXcmFwcGVyOworY2xh c3MgV2ViRXZlbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTsKK2NsYXNzIFdlYk5v ZGU7CitjbGFzcyBXZWJTdHJpbmc7CisKK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXIgeworcHVibGlj OgorICAgIFdlYkV2ZW50TGlzdGVuZXIoKTsKKyAgICB2aXJ0dWFsIH5XZWJFdmVudExpc3RlbmVy KCk7CisKKyAgICAvLyBDYWxsZWQgd2hlbiBhbiBldmVudCBpcyByZWNlaXZlZC4KKyAgICB2aXJ0 dWFsIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgV2ViRXZlbnQmKSA9IDA7CisKKyNpZiBXRUJLSVRf SU1QTEVNRU5UQVRJT04KKyAgICB2b2lkIG5vdGlmeUV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50 TGlzdGVuZXJXcmFwcGVyKik7CisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGNyZWF0ZUV2ZW50 TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1 cmUsIFdlYkNvcmU6Ok5vZGUqIG5vZGUpOworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBnZXRF dmVudExpc3RlbmVyV3JhcHBlcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VD YXB0dXJlLCBXZWJDb3JlOjpOb2RlKiBub2RlKTsKKyNlbmRpZgorCitwcml2YXRlOgorICAgIFdl YkV2ZW50TGlzdGVuZXJQcml2YXRlKiBtX3ByaXZhdGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBX ZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk11dGF0aW9u RXZlbnQuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTXV0YXRp b25FdmVudC5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNdXRh dGlvbkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjAgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworI2lmbmRlZiBXZWJNdXRhdGlv bkV2ZW50X2gKKyNkZWZpbmUgV2ViTXV0YXRpb25FdmVudF9oCisKKyNpbmNsdWRlICJXZWJFdmVu dC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIEV2ZW50OyB9CisKK25hbWVzcGFjZSBX ZWJLaXQgeworCitjbGFzcyBXZWJNdXRhdGlvbkV2ZW50IDogcHVibGljIFdlYkV2ZW50IHsKK3B1 YmxpYzoKKyAgICBlbnVtIEF0dHJDaGFuZ2VUeXBlIHsKKyAgICAgICAgTW9kaWZpY2F0aW9uICAg ID0gMSwKKyAgICAgICAgQWRkaXRpb24gICAgICAgID0gMiwKKyAgICAgICAgUmVtb3ZhbCAgICAg ICAgID0gMworICAgIH07CisKKyAgICBXRUJLSVRfQVBJIFdlYk5vZGUgcmVsYXRlZE5vZGUoKSBj b25zdDsKKyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyBwcmV2VmFsdWUoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIFdlYlN0cmluZyBuZXdWYWx1ZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2Vi U3RyaW5nIGF0dHJOYW1lKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBBdHRyQ2hhbmdlVHlwZSBh dHRyQ2hhbmdlKCkgY29uc3Q7CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KKyAgICBXZWJN dXRhdGlvbkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mKTsKKyNl bmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpJbmRleDogV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJOb2RlLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYk5vZGUuaAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYk5vZGUuaAkod29ya2luZyBjb3B5KQpAQCAtNDEsNiArNDEsOCBAQCBuYW1lc3Bh Y2UgV1RGIHsgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGNsCiAKIG5hbWVzcGFjZSBXZWJLaXQgewog Y2xhc3MgV2ViRG9jdW1lbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVyOworY2xhc3MgV2ViRXZl bnRMaXN0ZW5lclByaXZhdGU7CiBjbGFzcyBXZWJGcmFtZTsKIGNsYXNzIFdlYk5vZGVMaXN0Owog CkBAIC0xMDAsNiArMTAyLDggQEAgcHVibGljOgogICAgIFdFQktJVF9BUEkgV2ViU3RyaW5nIGNy ZWF0ZU1hcmt1cCgpIGNvbnN0OwogICAgIFdFQktJVF9BUEkgYm9vbCBpc1RleHROb2RlKCkgY29u c3Q7CiAgICAgV0VCS0lUX0FQSSBib29sIGlzRWxlbWVudE5vZGUoKSBjb25zdDsKKyAgICBXRUJL SVRfQVBJIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwg V2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsIGJvb2wgdXNlQ2FwdHVyZSk7CisgICAgV0VCS0lU X0FQSSB2b2lkIHJlbW92ZUV2ZW50TGlzdGVuZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUs IFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNhcHR1cmUpOwogCiAgICAgdGVt cGxhdGU8dHlwZW5hbWUgVD4gVCB0b0VsZW1lbnQoKQogICAgIHsKSW5kZXg6IFdlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViU3RyaW5nLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYlN0cmluZy5oCShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViU3RyaW5nLmgJKHdvcmtpbmcgY29weSkKQEAgLTc2LDYgKzc2LDggQEAgcHVibGlj OgogICAgIFdFQktJVF9BUEkgdm9pZCBhc3NpZ24oY29uc3QgV2ViU3RyaW5nJik7CiAgICAgV0VC S0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJVQ2hhciogZGF0YSwgc2l6ZV90IGxlbik7CiAK KyAgICBXRUJLSVRfQVBJIGJvb2wgZXF1YWxzKGNvbnN0IFdlYlN0cmluZyYgcykgY29uc3Q7CisK ICAgICBXRUJLSVRfQVBJIHNpemVfdCBsZW5ndGgoKSBjb25zdDsKICAgICBXRUJLSVRfQVBJIGNv bnN0IFdlYlVDaGFyKiBkYXRhKCkgY29uc3Q7CiAKQEAgLTE2Myw2ICsxNjUsMTYgQEAgcHJpdmF0 ZToKICAgICBXZWJTdHJpbmdQcml2YXRlKiBtX3ByaXZhdGU7CiB9OwogCitpbmxpbmUgYm9vbCBv cGVyYXRvcj09KGNvbnN0IFdlYlN0cmluZyYgYSwgY29uc3QgV2ViU3RyaW5nJiBiKQoreworICAg IHJldHVybiBhLmVxdWFscyhiKTsKK30KKworaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBX ZWJTdHJpbmcmIGEsIGNvbnN0IFdlYlN0cmluZyYgYikKK3sKKyAgICByZXR1cm4gIShhID09IGIp OworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hy b21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcA0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktp dC9jaHJvbWl1bS9zcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuY3BwCShyZXZpc2lvbiAwKQorKysg V2ViS2l0L2Nocm9taXVtL3NyYy9FdmVudExpc3RlbmVyV3JhcHBlci5jcHAJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsNzEgQEAKKy8qDQorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQNCisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlDQorICogbWV0Og0KKyAqDQorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuDQorICogICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQ0K KyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXINCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlDQorICogZGlzdHJpYnV0aW9uLg0KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMNCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQ0KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3 cml0dGVuIHBlcm1pc3Npb24uDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTDQorICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QNCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1INCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVA0KKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLA0KKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QNCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwNCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkNCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU DQorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFDQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisjaW5jbHVkZSAi RXZlbnRMaXN0ZW5lcldyYXBwZXIuaCINCisNCisjaW5jbHVkZSAiRXZlbnQuaCINCisjaW5jbHVk ZSAiRXZlbnRMaXN0ZW5lci5oIg0KKw0KKyNpbmNsdWRlICJXZWJFdmVudC5oIg0KKyNpbmNsdWRl ICJXZWJFdmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQorDQorRXZlbnRM aXN0ZW5lcldyYXBwZXI6OkV2ZW50TGlzdGVuZXJXcmFwcGVyKFdlYkV2ZW50TGlzdGVuZXIqIHdl YkV2ZW50TGlzdGVuZXIpDQorICAgIDogRXZlbnRMaXN0ZW5lcihFdmVudExpc3RlbmVyOjpKU0V2 ZW50TGlzdGVuZXJUeXBlKQ0KKyAgICAsIG1fd2ViRXZlbnRMaXN0ZW5lcih3ZWJFdmVudExpc3Rl bmVyKQ0KK3sNCit9DQorDQorRXZlbnRMaXN0ZW5lcldyYXBwZXI6On5FdmVudExpc3RlbmVyV3Jh cHBlcigpDQorew0KKyAgICBpZiAobV93ZWJFdmVudExpc3RlbmVyKQ0KKyAgICAgICAgbV93ZWJF dmVudExpc3RlbmVyLT5ub3RpZnlFdmVudExpc3RlbmVyRGVsZXRlZCh0aGlzKTsNCit9DQorDQor Ym9vbCBFdmVudExpc3RlbmVyV3JhcHBlcjo6b3BlcmF0b3I9PShjb25zdCBFdmVudExpc3RlbmVy JiBsaXN0ZW5lcikNCit7DQorICAgIHJldHVybiB0aGlzID09ICZsaXN0ZW5lcjsNCit9DQorDQor dm9pZCBFdmVudExpc3RlbmVyV3JhcHBlcjo6aGFuZGxlRXZlbnQoU2NyaXB0RXhlY3V0aW9uQ29u dGV4dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KQ0KK3sNCisgICAgaWYgKCFtX3dlYkV2ZW50TGlz dGVuZXIpDQorICAgICAgICByZXR1cm47DQorICAgIFdlYkV2ZW50IHdlYkV2ZW50ID0gV2ViRXZl bnQ6OmNyZWF0ZVdlYkV2ZW50KGV2ZW50KTsNCisgICAgbV93ZWJFdmVudExpc3RlbmVyLT5oYW5k bGVFdmVudCh3ZWJFdmVudCk7DQorfQ0KKw0KK3ZvaWQgRXZlbnRMaXN0ZW5lcldyYXBwZXI6Ondl YkV2ZW50TGlzdGVuZXJEZWxldGVkKCkNCit7DQorICAgIG1fd2ViRXZlbnRMaXN0ZW5lciA9IDA7 DQorfQ0KKw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9z cmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1 bS9zcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuaAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJv bWl1bS9zcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2 MyBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6 DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0 IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9y cyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9t DQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8s IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP Ug0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpZm5kZWYgRXZlbnRMaXN0ZW5lcldy YXBwZXJfaA0KKyNkZWZpbmUgRXZlbnRMaXN0ZW5lcldyYXBwZXJfaA0KKw0KKyNpbmNsdWRlICJF dmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYkNvcmUgew0KK2NsYXNzIFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQ7DQorfQ0KKw0KK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOw0KKw0KK25h bWVzcGFjZSBXZWJLaXQgew0KKw0KK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXI7DQorDQorY2xhc3Mg RXZlbnRMaXN0ZW5lcldyYXBwZXIgOiBwdWJsaWMgRXZlbnRMaXN0ZW5lcg0KK3sNCitwdWJsaWM6 DQorICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKFdlYkV2ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlz dGVuZXIpOw0KKyAgICB+RXZlbnRMaXN0ZW5lcldyYXBwZXIoKTsNCisNCisgICAgdmlydHVhbCBi b29sIG9wZXJhdG9yPT0oY29uc3QgRXZlbnRMaXN0ZW5lciYpOw0KKyAgICB2aXJ0dWFsIHZvaWQg aGFuZGxlRXZlbnQoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIEV2ZW50Kik7DQorDQorICAgIHZv aWQgd2ViRXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsNCisNCitwcml2YXRlOg0KKyAgICBXZWJFdmVu dExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7DQorfTsNCisNCit9IC8vIG5hbWVzcGFjZSBX ZWJLaXQNCisNCisjZW5kaWYNCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50LmNw cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnQuY3BwCShyZXZp c2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudC5jcHAJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMjI4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJl CisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHly aWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMg cHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhl IG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9y cyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9t CisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNz aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBI T0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUg SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1Ig Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9G IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgIldlYkV2ZW50LmgiCisKKyNpbmNsdWRlICJFdmVu dC5oIgorI2luY2x1ZGUgIk5vZGUuaCIKKyNpbmNsdWRlICJXZWJNdXRhdGlvbkV2ZW50LmgiCisj aW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNz IFdlYkV2ZW50UHJpdmF0ZSA6IHB1YmxpYyBXZWJDb3JlOjpFdmVudCB7Cit9OworCit2b2lkIFdl YkV2ZW50OjpyZXNldCgpCit7CisgICAgYXNzaWduKDApOworfQorCit2b2lkIFdlYkV2ZW50Ojph c3NpZ24oY29uc3QgV2ViRXZlbnQmIG90aGVyKQoreworICAgIFdlYkV2ZW50UHJpdmF0ZSogcCA9 IGNvbnN0X2Nhc3Q8V2ViRXZlbnRQcml2YXRlKj4ob3RoZXIubV9wcml2YXRlKTsKKyAgICBpZiAo cCkKKyAgICAgICAgcC0+cmVmKCk7CisgICAgYXNzaWduKHApOworfQorCit2b2lkIFdlYkV2ZW50 Ojphc3NpZ24oV2ViRXZlbnRQcml2YXRlKiBwKQoreworICAgIC8vIHAgaXMgYWxyZWFkeSByZWYn ZCBmb3IgdXMgYnkgdGhlIGNhbGxlcgorICAgIGlmIChtX3ByaXZhdGUpCisgICAgICAgIG1fcHJp dmF0ZS0+ZGVyZWYoKTsKKyAgICBtX3ByaXZhdGUgPSBwOworfQorCitXZWJFdmVudDo6V2ViRXZl bnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZlbnQpCisgICAgOiBt X3ByaXZhdGUoc3RhdGljX2Nhc3Q8V2ViRXZlbnRQcml2YXRlKj4oZXZlbnQucmVsZWFzZVJlZigp KSkKK3sKK30KKworV2ViU3RyaW5nIFdlYkV2ZW50Ojp0eXBlKCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT50eXBlKCk7Cit9CisKK1dlYk5v ZGUgV2ViRXZlbnQ6OnRhcmdldCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7Cisg ICAgcmV0dXJuIFdlYk5vZGUobV9wcml2YXRlLT50YXJnZXQoKS0+dG9Ob2RlKCkpOworfQorCitX ZWJOb2RlIFdlYkV2ZW50OjpjdXJyZW50VGFyZ2V0KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9w cml2YXRlKTsKKyAgICByZXR1cm4gV2ViTm9kZShtX3ByaXZhdGUtPmN1cnJlbnRUYXJnZXQoKS0+ dG9Ob2RlKCkpOworfQorCitXZWJFdmVudDo6UGhhc2VUeXBlIFdlYkV2ZW50OjpldmVudFBoYXNl KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gc3RhdGljX2Nh c3Q8V2ViRXZlbnQ6OlBoYXNlVHlwZT4obV9wcml2YXRlLT5ldmVudFBoYXNlKCkpOworfQorCiti b29sIFdlYkV2ZW50OjpidWJibGVzKCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsK KyAgICByZXR1cm4gbV9wcml2YXRlLT5idWJibGVzKCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmNh bmNlbGFibGUoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBt X3ByaXZhdGUtPmNhbmNlbGFibGUoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNVSUV2ZW50KCkg Y29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5p c1VJRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNNb3VzZUV2ZW50KCkgY29uc3QKK3sK KyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc01vdXNlRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNNdXRhdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc011dGF0aW9uRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNLZXlib2FyZEV2ZW50KCkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0tleWJvYXJkRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNUZXh0RXZlbnQoKSBjb25zdAoreworICAgIEFT U0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzVGV4dEV2ZW50KCk7Cit9 CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQ29tcG9zaXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAgQVNT RVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNDb21wb3NpdGlvbkV2ZW50 KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzRHJhZ0V2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0RyYWdFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc0NsaXBib2FyZEV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQo bV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0NsaXBib2FyZEV2ZW50KCk7Cit9 CisKK2Jvb2wgV2ViRXZlbnQ6OmlzTWVzc2FnZUV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQo bV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc01lc3NhZ2VFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc1doZWVsRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3By aXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzV2hlZWxFdmVudCgpOworfQorCitib29s IFdlYkV2ZW50Ojppc0JlZm9yZVRleHRJbnNlcnRlZEV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0JlZm9yZVRleHRJbnNlcnRl ZEV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzT3ZlcmZsb3dFdmVudCgpIGNvbnN0Cit7 CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNPdmVyZmxv d0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzUGFnZVRyYW5zaXRpb25FdmVudCgpIGNv bnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNQ YWdlVHJhbnNpdGlvbkV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzUG9wU3RhdGVFdmVu dCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0 ZS0+aXNQb3BTdGF0ZUV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzUHJvZ3Jlc3NFdmVu dCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0 ZS0+aXNQcm9ncmVzc0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzWE1MSHR0cFJlcXVl c3RQcm9ncmVzc0V2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICBy ZXR1cm4gbV9wcml2YXRlLT5pc1hNTEh0dHBSZXF1ZXN0UHJvZ3Jlc3NFdmVudCgpOworfQorCiti b29sIFdlYkV2ZW50Ojppc1dlYktpdEFuaW1hdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1dlYktpdEFuaW1hdGlvbkV2 ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzV2ViS2l0VHJhbnNpdGlvbkV2ZW50KCkgY29u c3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1dl YktpdFRyYW5zaXRpb25FdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc0JlZm9yZUxvYWRF dmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJp dmF0ZS0+aXNCZWZvcmVMb2FkRXZlbnQoKTsKK30KKworV2ViRXZlbnQgV2ViRXZlbnQ6OmNyZWF0 ZVdlYkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mIGV2ZW50KQor eworICAgIGlmIChldmVudC0+aXNNdXRhdGlvbkV2ZW50KCkpCisgICAgICByZXR1cm4gV2ViTXV0 YXRpb25FdmVudChldmVudCk7CisKKyAgICAvLyBUT0RPKGpjYW1wYW4pOiBpbXBsZW1lbnQgb3Ro ZXIgZXZlbnRzLgorICAgIHJldHVybiBXZWJFdmVudCgpOworfQorCit9ClwgTm8gbmV3bGluZSBh dCBlbmQgb2YgZmlsZQpJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVy LmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5l ci5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVu ZXIuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDY0IEBACisvKg0KKyAqIENvcHlyaWdodCAo QykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLg0KKyAqDQorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0DQorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQ0KKyAqIG1ldDoNCisgKg0KKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0DQor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUNCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyDQorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQ0KKyAqIGRpc3Ry aWJ1dGlvbi4NCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0 aGUgbmFtZXMgb2YgaXRzDQorICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20NCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLg0KKyAqDQorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S Uw0KKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SDQorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQNCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwNCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsDQorICogREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZDQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVA0KKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQ0KKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuDQor ICovDQorDQorI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXIuaCINCisNCisNCisjaW5jbHVkZSAi V2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaCINCisNCituYW1lc3BhY2UgV2ViS2l0IHsNCisNCitX ZWJFdmVudExpc3RlbmVyOjpXZWJFdmVudExpc3RlbmVyKCkNCisgICAgOiBtX3ByaXZhdGUobmV3 IFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKHRoaXMpKQ0KK3sNCit9DQorDQorV2ViRXZlbnRMaXN0 ZW5lcjo6fldlYkV2ZW50TGlzdGVuZXIoKQ0KK3sNCisgICAgbV9wcml2YXRlLT53ZWJFdmVudExp c3RlbmVyRGVsZXRlZCgpOw0KKyAgICBkZWxldGUgbV9wcml2YXRlOw0KK30NCisNCit2b2lkIFdl YkV2ZW50TGlzdGVuZXI6Om5vdGlmeUV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50TGlzdGVuZXJX cmFwcGVyKiB3cmFwcGVyKQ0KK3sNCisgICAgbV9wcml2YXRlLT5ldmVudExpc3RlbmVyRGVsZXRl ZCh3cmFwcGVyKTsNCit9DQorDQorRXZlbnRMaXN0ZW5lcldyYXBwZXIqIFdlYkV2ZW50TGlzdGVu ZXI6OmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBl LCBib29sIHVzZUNhcHR1cmUsIE5vZGUqIG5vZGUpDQorew0KKyAgICByZXR1cm4gbV9wcml2YXRl LT5jcmVhdGVFdmVudExpc3RlbmVyV3JhcHBlcihldmVudFR5cGUsIHVzZUNhcHR1cmUsIG5vZGUp Ow0KK30NCisNCitFdmVudExpc3RlbmVyV3JhcHBlciogV2ViRXZlbnRMaXN0ZW5lcjo6Z2V0RXZl bnRMaXN0ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2Fw dHVyZSwgTm9kZSogbm9kZSkNCit7DQorICAgIHJldHVybiBtX3ByaXZhdGUtPmdldEV2ZW50TGlz dGVuZXJXcmFwcGVyKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwgbm9kZSk7DQorfQ0KKw0KK30gLy8g bmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0 ZW5lclByaXZhdGUuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJF dmVudExpc3RlbmVyUHJpdmF0ZS5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0v c3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4 NSBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6 DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0 IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9y cyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9t DQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8s IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP Ug0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBT SEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBG T1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJ TUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpbmNsdWRlICJXZWJFdmVudExpc3Rl bmVyUHJpdmF0ZS5oIg0KKw0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVyV3JhcHBlci5oIg0KKyNp bmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQorDQor V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlKFdlYkV2ZW50 TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpDQorICAgIDogbV93ZWJFdmVudExpc3RlbmVyKHdl YkV2ZW50TGlzdGVuZXIpDQorew0KK30NCisNCitXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6fldl YkV2ZW50TGlzdGVuZXJQcml2YXRlKCkNCit7DQorfQ0KKw0KK0V2ZW50TGlzdGVuZXJXcmFwcGVy KiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Y3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIoY29u c3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSkNCit7 DQorICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIgPSBuZXcgRXZlbnRM aXN0ZW5lcldyYXBwZXIobV93ZWJFdmVudExpc3RlbmVyKTsNCisgICAgV2ViRXZlbnRMaXN0ZW5l clByaXZhdGU6Okxpc3RlbmVySW5mbyBsaXN0ZW5lckluZm8oZXZlbnRUeXBlLCB1c2VDYXB0dXJl LCBsaXN0ZW5lcldyYXBwZXIsIG5vZGUpOw0KKyAgICBtX2xpc3RlbmVyV3JhcHBlcnMuYXBwZW5k KGxpc3RlbmVySW5mbyk7DQorICAgIHJldHVybiBsaXN0ZW5lcldyYXBwZXI7DQorfQ0KKw0KK0V2 ZW50TGlzdGVuZXJXcmFwcGVyKiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Z2V0RXZlbnRMaXN0 ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwg Tm9kZSogbm9kZSkNCit7DQorICAgIFZlY3RvcjxXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6TGlz dGVuZXJJbmZvPjo6Y29uc3RfaXRlcmF0b3IgaXRlcjsNCisgICAgZm9yIChpdGVyID0gbV9saXN0 ZW5lcldyYXBwZXJzLmJlZ2luKCk7IGl0ZXIgIT0gbV9saXN0ZW5lcldyYXBwZXJzLmVuZCgpOyAr K2l0ZXIpIHsNCisgICAgICAgIGlmIChpdGVyLT5ub2RlID09IG5vZGUpDQorICAgICAgICAgIHJl dHVybiBpdGVyLT5ldmVudExpc3RlbmVyV3JhcHBlcjsNCisgICAgfQ0KKyAgICBBU1NFUlRfTk9U X1JFQUNIRUQoKTsNCisgICAgcmV0dXJuIE5VTEw7DQorfQ0KKw0KK3ZvaWQgV2ViRXZlbnRMaXN0 ZW5lclByaXZhdGU6OndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCkgew0KKyAgICAvLyBOb3RpZmll cyBhbGwgV2ViRXZlbnRMaXN0ZW5lcldyYXBwZXJzIHRoYXQgd2UgYXJlIGdvaW5nIGF3YXkgc28g dGhleSBjYW4NCisgICAgLy8gaW52YWxpZGF0ZSB0aGVpciBwb2ludGVyIHRvIHVzLg0KKyAgICBW ZWN0b3I8V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6Okxpc3RlbmVySW5mbz46OmNvbnN0X2l0ZXJh dG9yIGl0ZXI7DQorICAgIGZvciAoaXRlciA9IG1fbGlzdGVuZXJXcmFwcGVycy5iZWdpbigpOyBp dGVyICE9IG1fbGlzdGVuZXJXcmFwcGVycy5lbmQoKTsgKytpdGVyKQ0KKyAgICAgICAgaXRlci0+ ZXZlbnRMaXN0ZW5lcldyYXBwZXItPndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCk7DQorfQ0KKw0K K3ZvaWQgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OmV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50 TGlzdGVuZXJXcmFwcGVyKiBldmVudExpc3RlbmVyKQ0KK3sNCisgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBtX2xpc3RlbmVyV3JhcHBlcnMuc2l6ZSgpOyArK2kpIHsNCisgICAgICAgIGlmICht X2xpc3RlbmVyV3JhcHBlcnNbaV0uZXZlbnRMaXN0ZW5lcldyYXBwZXIgPT0gZXZlbnRMaXN0ZW5l cikgew0KKyAgICAgICAgICAgIG1fbGlzdGVuZXJXcmFwcGVycy5yZW1vdmUoaSk7DQorICAgICAg ICAgICAgcmV0dXJuOw0KKyAgICAgICAgfQ0KKyAgICB9DQorICAgIEFTU0VSVF9OT1RfUkVBQ0hF RCgpOw0KK30NCisNCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgJKHJldmlzaW9uIDApCisrKyBX ZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsOTYgQEAKKy8qDQorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQNCisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlDQorICogbWV0Og0KKyAqDQorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuDQorICogICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQ0K KyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXINCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlDQorICogZGlzdHJpYnV0aW9uLg0KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMNCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQ0KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3 cml0dGVuIHBlcm1pc3Npb24uDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTDQorICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QNCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1INCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVA0KKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLA0KKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QNCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwNCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkNCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU DQorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFDQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisjaWZuZGVmIFdl YkV2ZW50TGlzdGVuZXJQcml2YXRlX2gNCisjZGVmaW5lIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRl X2gNCisNCisjaW5jbHVkZSAiV2ViU3RyaW5nLmgiDQorDQorI2luY2x1ZGUgPHd0Zi9WZWN0b3Iu aD4NCisNCituYW1lc3BhY2UgV2ViQ29yZSB7DQorY2xhc3MgTm9kZTsNCit9DQorDQordXNpbmcg bmFtZXNwYWNlIFdlYkNvcmU7DQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQorDQorY2xhc3MgRXZl bnRMaXN0ZW5lcldyYXBwZXI7DQorY2xhc3MgV2ViRXZlbnRMaXN0ZW5lcjsNCisNCitjbGFzcyBX ZWJFdmVudExpc3RlbmVyUHJpdmF0ZQ0KK3sNCitwdWJsaWM6DQorICAgIFdlYkV2ZW50TGlzdGVu ZXJQcml2YXRlKFdlYkV2ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpOw0KKyAgICB+V2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUoKTsNCisNCisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGNy ZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKA0KKyAgICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVu dFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSk7DQorDQorICAgIC8vIEdldHMgdGhl IExpc3RlbmVyRXZlbnRXcmFwcGVyIGZvciBhIHNwZWNpZmljIG5vZGUuDQorICAgIC8vIFVzZWQg YnkgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcigpLg0KKyAgICBFdmVudExpc3RlbmVyV3Jh cHBlciogZ2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoDQorICAgICAgICBjb25zdCBXZWJTdHJpbmcm IGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2RlKiBub2RlKTsNCisNCisgICAgLy8gQ2Fs bGVkIGJ5IHRoZSBXZWJFdmVudExpc3RlbmVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVsZXRl ZC4NCisgICAgdm9pZCB3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0KKw0KKyAgICAvLyBDYWxs ZWQgYnkgdGhlIEV2ZW50TGlzdGVuZXJXcmFwcGVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVs ZXRlZC4NCisgICAgdm9pZCBldmVudExpc3RlbmVyRGVsZXRlZChFdmVudExpc3RlbmVyV3JhcHBl ciogZXZlbnRMaXN0ZW5lcik7DQorDQorICAgIHN0cnVjdCBMaXN0ZW5lckluZm8gew0KKyAgICAg ICAgTGlzdGVuZXJJbmZvKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1 cmUsDQorICAgICAgICAgICAgICAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlz dGVuZXJXcmFwcGVyLA0KKyAgICAgICAgICAgICAgICAgICAgIE5vZGUqIG5vZGUpDQorICAgICAg ICAgICAgOiBldmVudFR5cGUoZXZlbnRUeXBlKQ0KKyAgICAgICAgICAgICwgdXNlQ2FwdHVyZSh1 c2VDYXB0dXJlKQ0KKyAgICAgICAgICAgICwgZXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRMaXN0 ZW5lcldyYXBwZXIpDQorICAgICAgICAgICAgLCBub2RlKG5vZGUpDQorICAgICAgICB7DQorICAg ICAgICB9DQorDQorICAgICAgICBXZWJTdHJpbmcgZXZlbnRUeXBlOw0KKyAgICAgICAgYm9vbCB1 c2VDYXB0dXJlOw0KKyAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXJX cmFwcGVyOw0KKyAgICAgICAgTm9kZSogbm9kZTsNCisgICAgfTsNCisNCitwcml2YXRlOg0KKyAg ICBXZWJFdmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7DQorDQorICAgIC8vIFdlIGtl ZXAgYSBsaXN0IG9mIHRoZSB3cmFwcGVyIGZvciB0aGUgV2ViS2l0IEV2ZW50TGlzdGVuZXIsIGl0 IGlzIG5lZWRlZA0KKyAgICAvLyB0byBpbXBsZW1lbnQgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0 ZW5lcigpLg0KKyAgICBWZWN0b3I8TGlzdGVuZXJJbmZvPiBtX2xpc3RlbmVyV3JhcHBlcnM7DQor fTsNCisNCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCisNCisjZW5kaWYNCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vc3JjL1dlYk5vZGUuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJOb2RlLmNwcAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYk5vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw5IEBACiAjaW5jbHVkZSAi Tm9kZUxpc3QuaCIKIAogI2luY2x1ZGUgIldlYkRvY3VtZW50LmgiCisjaW5jbHVkZSAiV2ViRXZl bnQuaCIKKyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiCisjaW5jbHVkZSAiV2ViRXZlbnRM aXN0ZW5lckltcGwuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJO b2RlTGlzdC5oIgogI2luY2x1ZGUgIldlYlN0cmluZy5oIgpAQCAtMTczLDQgKzE3NiwyMiBAQCBi b29sIFdlYk5vZGU6OmlzRWxlbWVudE5vZGUoKSBjb25zdAogICAgIHJldHVybiBtX3ByaXZhdGUt PmlzRWxlbWVudE5vZGUoKTsKIH0KIAordm9pZCBXZWJOb2RlOjphZGRFdmVudExpc3RlbmVyKGNv bnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBXZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lciwgYm9v bCB1c2VDYXB0dXJlKQoreworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBw ZXIgPQorICAgICAgICBsaXN0ZW5lci0+Y3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRU eXBlLCB1c2VDYXB0dXJlLCBtX3ByaXZhdGUpOworICAgIC8vIFRoZSBsaXN0ZW5lcldyYXBwZXIg aXMgb25seSByZWZlcmVuY2VkIGJ5IHRoZSBhY3R1YWwgTm9kZS4gIE9uY2UgaXQgZ29lcworICAg IC8vIGF3YXksIHRoZSB3cmFwcGVyIG5vdGlmaWVzIHRoZSBXZWJFdmVudExpc3RlbmVyIHNvIGl0 IGNhbiBjbGVhciBpdHMKKyAgICAvLyBwb2ludGVyIHRvIGl0LgorICAgIG1fcHJpdmF0ZS0+YWRk RXZlbnRMaXN0ZW5lcihldmVudFR5cGUsIGFkb3B0UmVmKGxpc3RlbmVyV3JhcHBlciksIHVzZUNh cHR1cmUpOworfQorCit2b2lkIFdlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoY29uc3QgV2Vi U3RyaW5nJiBldmVudFR5cGUsIFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNh cHR1cmUpCit7CisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGxpc3RlbmVyV3JhcHBlciA9Cisg ICAgICAgIGxpc3RlbmVyLT5nZXRFdmVudExpc3RlbmVyV3JhcHBlcihldmVudFR5cGUsIHVzZUNh cHR1cmUsIG1fcHJpdmF0ZSk7CisgICAgbV9wcml2YXRlLT5yZW1vdmVFdmVudExpc3RlbmVyKGV2 ZW50VHlwZSwgbGlzdGVuZXJXcmFwcGVyLCB1c2VDYXB0dXJlKTsKKyAgICAvLyBsaXN0ZW5lcldy YXBwZXIgaXMgbm93IGRlbGV0ZWQuCit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApJbmRleDog V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTdHJpbmcuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJTdHJpbmcuY3BwCShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9j aHJvbWl1bS9zcmMvV2ViU3RyaW5nLmNwcAkod29ya2luZyBjb3B5KQpAQCAtODYsNiArODYsMTEg QEAgV2ViU3RyaW5nIFdlYlN0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhcgogICAgIHJldHVybiBX ZWJDb3JlOjpTdHJpbmc6OmZyb21VVEY4KGRhdGEpOwogfQogCitib29sIFdlYlN0cmluZzo6ZXF1 YWxzKGNvbnN0IFdlYlN0cmluZyYgcykgY29uc3QKK3sKKyAgICByZXR1cm4gZXF1YWwobV9wcml2 YXRlLCBzLm1fcHJpdmF0ZSk7Cit9CisKIFdlYlN0cmluZzo6V2ViU3RyaW5nKGNvbnN0IFdlYkNv cmU6OlN0cmluZyYgcykKICAgICA6IG1fcHJpdmF0ZShzdGF0aWNfY2FzdDxXZWJTdHJpbmdQcml2 YXRlKj4ocy5pbXBsKCkpKQogewo= 47415 2010-01-26 09:04:30 -0800 2010-01-26 13:09:26 -0800 Chromium Event Listener API event_4.patch text/plain 38489 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzgzMykKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wMS0yNSAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgRXZlbnRMaXN0ZW5lcnMgdG8gdGhlIGNocm9t aXVtIEFQSS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzM4ODIKKworICAgICAgICAqIFdlYktpdC5neXA6CisgICAgICAgICogcHVibGljL1dlYkV2 ZW50Lmg6IEFkZGVkLgorICAgICAgICAqIHB1YmxpYy9XZWJFdmVudExpc3RlbmVyLmg6IEFkZGVk LgorICAgICAgICAqIHB1YmxpYy9XZWJNdXRhdGlvbkV2ZW50Lmg6IEFkZGVkLgorICAgICAgICAq IHB1YmxpYy9XZWJOb2RlLmg6CisgICAgICAgICogcHVibGljL1dlYlN0cmluZy5oOgorICAgICAg ICAoV2ViS2l0OjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6Cisg ICAgICAgICogc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcDogQWRkZWQuCisgICAgICAgICog c3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmg6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVudExpc3RlbmVyLmNwcDogQWRkZWQu CisgICAgICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHNy Yy9XZWJOb2RlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6YWRkRXZlbnRMaXN0ZW5l cik6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIpOgorICAg ICAgICAqIHNyYy9XZWJTdHJpbmcuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTdHJpbmc6OmVx dWFscyk6CisKIDIwMTAtMDEtMjIgIEVsbGlvdCBHbGF5c2hlciAgPGVyZ0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vV2ViS2l0Lmd5cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCSh3b3JraW5n IGNvcHkpCkBAIC0xMDcsNiArMTA3LDggQEAKICAgICAgICAgICAgICAgICAncHVibGljL1dlYkRy YWdEYXRhLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRWRpdGluZ0FjdGlvbi5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkVsZW1lbnQuaCcsCisgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJFdmVudC5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dlYkV2ZW50TGlz dGVuZXIuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlckNvbXBsZXRp b24uaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlclBhcmFtcy5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkZpbmRPcHRpb25zLmgnLApAQCAtMTMwLDYgKzEz Miw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWwuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWxDbGllbnQuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNaW1lUmVnaXN0cnkuaCcsCisgICAgICAgICAg ICAgICAgJ3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJs aWMvV2ViTmF2aWdhdGlvblR5cGUuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJOb2Rl LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTm9kZUNvbGxlY3Rpb24uaCcsCkBAIC0y MTAsNiArMjEzLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL0RyYWdDbGllbnRJbXBsLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5jcHAnLAogICAgICAgICAgICAg ICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3JjL0V2ZW50 TGlzdGVuZXJXcmFwcGVyLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9FdmVudExpc3RlbmVy V3JhcHBlci5oJywKICAgICAgICAgICAgICAgICAnc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5j cHAnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvZ3RrL1dlYkZvbnRJbmZvLmNwcCcsCkBAIC0yNTksNiArMjY0LDEw IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRp ZXMuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAorICAgICAgICAgICAg ICAgICdzcmMvV2ViRXZlbnRMaXN0ZW5lci5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkV2ZW50 TGlzdGVuZXJQcml2YXRlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAn LApAQCAtMjc3LDYgKzI4Niw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMv V2ViTm9kZS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3Bw JywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJF dmVudF9oCisjZGVmaW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2lu Y2x1ZGUgIldlYk5vZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeyBjbGFzcyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5k aWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAg ICBlbnVtIFBoYXNlVHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAg ICAgIEF0VGFyZ2V0ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9 IDMKKyAgICB9OworCisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJF dmVudChjb25zdCBXZWJFdmVudCYgbikgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24obik7IH0KKyAg ICBXZWJFdmVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBlKQorICAgIHsKKyAgICAgICAg YXNzaWduKGUpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQ SSB2b2lkIHJlc2V0KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVu dCYpOworCisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisK KyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBX ZWJOb2RlIHRhcmdldCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFy Z2V0KCkgY29uc3Q7CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29u c3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJ IGJvb2wgY2FuY2VsYWJsZSgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBib29sIGlzVUlFdmVu dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAg ICBXRUJLSVRfQVBJIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgV0VCS0lUX0FQ SSBib29sIGlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1Rl eHRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNEcmFnRXZlbnQoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg Ym9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1doZWVs RXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc092ZXJmbG93RXZlbnQoKSBjb25z dDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3Q7Cisg ICAgV0VCS0lUX0FQSSBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNY TUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wg aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1dl YktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0JlZm9y ZUxvYWRFdmVudCgpIGNvbnN0OworCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gVCB0b0V2ZW50 KCkKKyAgICB7CisgICAgICAgIFQgcmVzOworICAgICAgICByZXMuV2ViRXZlbnQ6OmFzc2lnbigq dGhpcyk7CisgICAgICAgIHJldHVybiByZXM7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5h bWUgVD4gY29uc3QgVCB0b0NvbnN0RXZlbnQoKSBjb25zdAorICAgIHsKKyAgICAgICAgVCByZXM7 CisgICAgICAgIHJlcy5XZWJFdmVudDo6YXNzaWduKCp0aGlzKTsKKyAgICAgICAgcmV0dXJuIHJl czsKKyAgICB9CisKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYkV2ZW50KGNv bnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mKTsKKyAgICBzdGF0aWMgV2ViRXZl bnQgY3JlYXRlV2ViRXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYp OworI2VuZGlmCisKK3Byb3RlY3RlZDoKKyAgICB0eXBlZGVmIFdlYkNvcmU6OkV2ZW50IFdlYkV2 ZW50UHJpdmF0ZTsKKyAgICB2b2lkIGFzc2lnbihXZWJFdmVudFByaXZhdGUqKTsKKyAgICBXZWJF dmVudFByaXZhdGUqIG1fcHJpdmF0ZTsKKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IFQqIHVu d3JhcCgpCisgICAgeworICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+KG1fcHJpdmF0ZSk7 CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gY29uc3QgVCogY29uc3RVbndyYXAo KSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IFQqPihtX3By aXZhdGUpOworICAgIH0KK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5k ZXg6IFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oDQo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 DQotLS0gV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgJKHJldmlzaW9u IDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw2NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVy IHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmli dXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQg ZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVy bWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklH SFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S CisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViRXZlbnRMaXN0ZW5lcl9oCisjZGVmaW5l IFdlYkV2ZW50TGlzdGVuZXJfaAorCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIE5vZGU7IH0K KworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIEV2ZW50TGlzdGVuZXJXcmFwcGVyOworY2xh c3MgV2ViRXZlbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTsKK2NsYXNzIFdlYk5v ZGU7CitjbGFzcyBXZWJTdHJpbmc7CisKK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXIgeworcHVibGlj OgorICAgIFdlYkV2ZW50TGlzdGVuZXIoKTsKKyAgICB2aXJ0dWFsIH5XZWJFdmVudExpc3RlbmVy KCk7CisKKyAgICAvLyBDYWxsZWQgd2hlbiBhbiBldmVudCBpcyByZWNlaXZlZC4KKyAgICB2aXJ0 dWFsIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgV2ViRXZlbnQmKSA9IDA7CisKKyNpZiBXRUJLSVRf SU1QTEVNRU5UQVRJT04KKyAgICB2b2lkIG5vdGlmeUV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50 TGlzdGVuZXJXcmFwcGVyKik7CisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGNyZWF0ZUV2ZW50 TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1 cmUsIFdlYkNvcmU6Ok5vZGUqIG5vZGUpOworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBnZXRF dmVudExpc3RlbmVyV3JhcHBlcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VD YXB0dXJlLCBXZWJDb3JlOjpOb2RlKiBub2RlKTsKKyNlbmRpZgorCitwcml2YXRlOgorICAgIFdl YkV2ZW50TGlzdGVuZXJQcml2YXRlKiBtX3ByaXZhdGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBX ZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYk11dGF0aW9u RXZlbnQuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViTXV0YXRp b25FdmVudC5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJNdXRh dGlvbkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjAgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9u LgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVz IG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90 ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworI2lmbmRlZiBXZWJNdXRhdGlv bkV2ZW50X2gKKyNkZWZpbmUgV2ViTXV0YXRpb25FdmVudF9oCisKKyNpbmNsdWRlICJXZWJFdmVu dC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIEV2ZW50OyB9CisKK25hbWVzcGFjZSBX ZWJLaXQgeworCitjbGFzcyBXZWJNdXRhdGlvbkV2ZW50IDogcHVibGljIFdlYkV2ZW50IHsKK3B1 YmxpYzoKKyAgICBlbnVtIEF0dHJDaGFuZ2VUeXBlIHsKKyAgICAgICAgTW9kaWZpY2F0aW9uICAg ID0gMSwKKyAgICAgICAgQWRkaXRpb24gICAgICAgID0gMiwKKyAgICAgICAgUmVtb3ZhbCAgICAg ICAgID0gMworICAgIH07CisKKyAgICBXRUJLSVRfQVBJIFdlYk5vZGUgcmVsYXRlZE5vZGUoKSBj b25zdDsKKyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyBwcmV2VmFsdWUoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIFdlYlN0cmluZyBuZXdWYWx1ZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2Vi U3RyaW5nIGF0dHJOYW1lKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBBdHRyQ2hhbmdlVHlwZSBh dHRyQ2hhbmdlKCkgY29uc3Q7CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KKyAgICBXZWJN dXRhdGlvbkV2ZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mKTsKKyNl bmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpJbmRleDogV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJOb2RlLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYk5vZGUuaAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYk5vZGUuaAkod29ya2luZyBjb3B5KQpAQCAtNDEsNiArNDEsOCBAQCBuYW1lc3Bh Y2UgV1RGIHsgdGVtcGxhdGUgPHR5cGVuYW1lIFQ+IGNsCiAKIG5hbWVzcGFjZSBXZWJLaXQgewog Y2xhc3MgV2ViRG9jdW1lbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVyOworY2xhc3MgV2ViRXZl bnRMaXN0ZW5lclByaXZhdGU7CiBjbGFzcyBXZWJGcmFtZTsKIGNsYXNzIFdlYk5vZGVMaXN0Owog CkBAIC0xMDAsNiArMTAyLDggQEAgcHVibGljOgogICAgIFdFQktJVF9BUEkgV2ViU3RyaW5nIGNy ZWF0ZU1hcmt1cCgpIGNvbnN0OwogICAgIFdFQktJVF9BUEkgYm9vbCBpc1RleHROb2RlKCkgY29u c3Q7CiAgICAgV0VCS0lUX0FQSSBib29sIGlzRWxlbWVudE5vZGUoKSBjb25zdDsKKyAgICBXRUJL SVRfQVBJIHZvaWQgYWRkRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwg V2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsIGJvb2wgdXNlQ2FwdHVyZSk7CisgICAgV0VCS0lU X0FQSSB2b2lkIHJlbW92ZUV2ZW50TGlzdGVuZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUs IFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNhcHR1cmUpOwogCiAgICAgdGVt cGxhdGU8dHlwZW5hbWUgVD4gVCB0b0VsZW1lbnQoKQogICAgIHsKSW5kZXg6IFdlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViU3RyaW5nLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYlN0cmluZy5oCShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViU3RyaW5nLmgJKHdvcmtpbmcgY29weSkKQEAgLTc2LDYgKzc2LDggQEAgcHVibGlj OgogICAgIFdFQktJVF9BUEkgdm9pZCBhc3NpZ24oY29uc3QgV2ViU3RyaW5nJik7CiAgICAgV0VC S0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJVQ2hhciogZGF0YSwgc2l6ZV90IGxlbik7CiAK KyAgICBXRUJLSVRfQVBJIGJvb2wgZXF1YWxzKGNvbnN0IFdlYlN0cmluZyYgcykgY29uc3Q7CisK ICAgICBXRUJLSVRfQVBJIHNpemVfdCBsZW5ndGgoKSBjb25zdDsKICAgICBXRUJLSVRfQVBJIGNv bnN0IFdlYlVDaGFyKiBkYXRhKCkgY29uc3Q7CiAKQEAgLTE2Myw2ICsxNjUsMTYgQEAgcHJpdmF0 ZToKICAgICBXZWJTdHJpbmdQcml2YXRlKiBtX3ByaXZhdGU7CiB9OwogCitpbmxpbmUgYm9vbCBv cGVyYXRvcj09KGNvbnN0IFdlYlN0cmluZyYgYSwgY29uc3QgV2ViU3RyaW5nJiBiKQoreworICAg IHJldHVybiBhLmVxdWFscyhiKTsKK30KKworaW5saW5lIGJvb2wgb3BlcmF0b3IhPShjb25zdCBX ZWJTdHJpbmcmIGEsIGNvbnN0IFdlYlN0cmluZyYgYikKK3sKKyAgICByZXR1cm4gIShhID09IGIp OworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKIAogI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hy b21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcA0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktp dC9jaHJvbWl1bS9zcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuY3BwCShyZXZpc2lvbiAwKQorKysg V2ViS2l0L2Nocm9taXVtL3NyYy9FdmVudExpc3RlbmVyV3JhcHBlci5jcHAJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsNzIgQEAKKy8qDQorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQNCisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlDQorICogbWV0Og0KKyAqDQorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuDQorICogICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQ0K KyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXINCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlDQorICogZGlzdHJpYnV0aW9uLg0KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMNCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQ0KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3 cml0dGVuIHBlcm1pc3Npb24uDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTDQorICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QNCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1INCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVA0KKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLA0KKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QNCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwNCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkNCisgKiBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU DQorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFDQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisjaW5jbHVkZSAi Y29uZmlnLmgiDQorI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXJXcmFwcGVyLmgiDQorDQorI2luY2x1 ZGUgIkV2ZW50LmgiDQorI2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCINCisNCisjaW5jbHVkZSAi V2ViRXZlbnQuaCINCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lci5oIg0KKw0KK25hbWVzcGFj ZSBXZWJLaXQgew0KKw0KK0V2ZW50TGlzdGVuZXJXcmFwcGVyOjpFdmVudExpc3RlbmVyV3JhcHBl cihXZWJFdmVudExpc3RlbmVyKiB3ZWJFdmVudExpc3RlbmVyKQ0KKyAgICA6IEV2ZW50TGlzdGVu ZXIoRXZlbnRMaXN0ZW5lcjo6SlNFdmVudExpc3RlbmVyVHlwZSkNCisgICAgLCBtX3dlYkV2ZW50 TGlzdGVuZXIod2ViRXZlbnRMaXN0ZW5lcikNCit7DQorfQ0KKw0KK0V2ZW50TGlzdGVuZXJXcmFw cGVyOjp+RXZlbnRMaXN0ZW5lcldyYXBwZXIoKQ0KK3sNCisgICAgaWYgKG1fd2ViRXZlbnRMaXN0 ZW5lcikNCisgICAgICAgIG1fd2ViRXZlbnRMaXN0ZW5lci0+bm90aWZ5RXZlbnRMaXN0ZW5lckRl bGV0ZWQodGhpcyk7DQorfQ0KKw0KK2Jvb2wgRXZlbnRMaXN0ZW5lcldyYXBwZXI6Om9wZXJhdG9y PT0oY29uc3QgRXZlbnRMaXN0ZW5lciYgbGlzdGVuZXIpDQorew0KKyAgICByZXR1cm4gdGhpcyA9 PSAmbGlzdGVuZXI7DQorfQ0KKw0KK3ZvaWQgRXZlbnRMaXN0ZW5lcldyYXBwZXI6OmhhbmRsZUV2 ZW50KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIEV2ZW50KiBldmVudCkNCit7DQor ICAgIGlmICghbV93ZWJFdmVudExpc3RlbmVyKQ0KKyAgICAgICAgcmV0dXJuOw0KKyAgICBXZWJF dmVudCB3ZWJFdmVudCA9IFdlYkV2ZW50OjpjcmVhdGVXZWJFdmVudChldmVudCk7DQorICAgIG1f d2ViRXZlbnRMaXN0ZW5lci0+aGFuZGxlRXZlbnQod2ViRXZlbnQpOw0KK30NCisNCit2b2lkIEV2 ZW50TGlzdGVuZXJXcmFwcGVyOjp3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpDQorew0KKyAgICBt X3dlYkV2ZW50TGlzdGVuZXIgPSAwOw0KK30NCisNCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCklu ZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmgNCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmgJKHJldmlz aW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmgJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsNjIgQEAKKy8qDQorICogQ29weXJpZ2h0IChDKSAyMDEwIEdv b2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoNCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQNCisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlDQorICogbWV0Og0KKyAqDQorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuDQor ICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQ0KKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXINCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlDQorICogZGlzdHJpYnV0aW9uLg0K KyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBv ZiBpdHMNCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3Rl IHByb2R1Y3RzIGRlcml2ZWQgZnJvbQ0KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZp YyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElTIFBS T1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTDQorICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QNCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1INCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVA0KKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LA0KKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QNCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwNCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkNCisgKiBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUDQorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFDQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisj aWZuZGVmIEV2ZW50TGlzdGVuZXJXcmFwcGVyX2gNCisjZGVmaW5lIEV2ZW50TGlzdGVuZXJXcmFw cGVyX2gNCisNCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIg0KKw0KK25hbWVzcGFjZSBXZWJD b3JlIHsNCitjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0Ow0KK30NCisNCit1c2luZyBuYW1l c3BhY2UgV2ViQ29yZTsNCisNCituYW1lc3BhY2UgV2ViS2l0IHsNCisNCitjbGFzcyBXZWJFdmVu dExpc3RlbmVyOw0KKw0KK2NsYXNzIEV2ZW50TGlzdGVuZXJXcmFwcGVyIDogcHVibGljIEV2ZW50 TGlzdGVuZXIgew0KK3B1YmxpYzoNCisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIoV2ViRXZlbnRM aXN0ZW5lciogd2ViRXZlbnRMaXN0ZW5lcik7DQorICAgIH5FdmVudExpc3RlbmVyV3JhcHBlcigp Ow0KKw0KKyAgICB2aXJ0dWFsIGJvb2wgb3BlcmF0b3I9PShjb25zdCBFdmVudExpc3RlbmVyJik7 DQorICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudChTY3JpcHRFeGVjdXRpb25Db250ZXh0Kiwg RXZlbnQqKTsNCisNCisgICAgdm9pZCB3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0KKw0KK3By aXZhdGU6DQorICAgIFdlYkV2ZW50TGlzdGVuZXIqIG1fd2ViRXZlbnRMaXN0ZW5lcjsNCit9Ow0K Kw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KKw0KKyNlbmRpZg0KSW5kZXg6IFdlYktpdC9jaHJv bWl1bS9zcmMvV2ViRXZlbnQuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJFdmVudC5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2 ZW50LmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMjkgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKworI2luY2x1ZGUgIkV2ZW50LmgiCisjaW5jbHVkZSAi Tm9kZS5oIgorI2luY2x1ZGUgIldlYk11dGF0aW9uRXZlbnQuaCIKKyNpbmNsdWRlIDx3dGYvUGFz c1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2ViRXZlbnRQcml2YXRl IDogcHVibGljIFdlYkNvcmU6OkV2ZW50IHsKK307CisKK3ZvaWQgV2ViRXZlbnQ6OnJlc2V0KCkK K3sKKyAgICBhc3NpZ24oMCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihjb25zdCBXZWJF dmVudCYgb3RoZXIpCit7CisgICAgV2ViRXZlbnRQcml2YXRlKiBwID0gY29uc3RfY2FzdDxXZWJF dmVudFByaXZhdGUqPihvdGhlci5tX3ByaXZhdGUpOworICAgIGlmIChwKQorICAgICAgICBwLT5y ZWYoKTsKKyAgICBhc3NpZ24ocCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihXZWJFdmVu dFByaXZhdGUqIHApCit7CisgICAgLy8gcCBpcyBhbHJlYWR5IHJlZidkIGZvciB1cyBieSB0aGUg Y2FsbGVyCisgICAgaWYgKG1fcHJpdmF0ZSkKKyAgICAgICAgbV9wcml2YXRlLT5kZXJlZigpOwor ICAgIG1fcHJpdmF0ZSA9IHA7Cit9CisKK1dlYkV2ZW50OjpXZWJFdmVudChjb25zdCBXVEY6OlBh c3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+JiBldmVudCkKKyAgICA6IG1fcHJpdmF0ZShzdGF0aWNf Y2FzdDxXZWJFdmVudFByaXZhdGUqPihldmVudC5yZWxlYXNlUmVmKCkpKQoreworfQorCitXZWJT dHJpbmcgV2ViRXZlbnQ6OnR5cGUoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOwor ICAgIHJldHVybiBtX3ByaXZhdGUtPnR5cGUoKTsKK30KKworV2ViTm9kZSBXZWJFdmVudDo6dGFy Z2V0KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gV2ViTm9k ZShtX3ByaXZhdGUtPnRhcmdldCgpLT50b05vZGUoKSk7Cit9CisKK1dlYk5vZGUgV2ViRXZlbnQ6 OmN1cnJlbnRUYXJnZXQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJl dHVybiBXZWJOb2RlKG1fcHJpdmF0ZS0+Y3VycmVudFRhcmdldCgpLT50b05vZGUoKSk7Cit9CisK K1dlYkV2ZW50OjpQaGFzZVR5cGUgV2ViRXZlbnQ6OmV2ZW50UGhhc2UoKSBjb25zdAoreworICAg IEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxXZWJFdmVudDo6UGhh c2VUeXBlPihtX3ByaXZhdGUtPmV2ZW50UGhhc2UoKSk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmJ1 YmJsZXMoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3By aXZhdGUtPmJ1YmJsZXMoKTsKK30KKworYm9vbCBXZWJFdmVudDo6Y2FuY2VsYWJsZSgpIGNvbnN0 Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+Y2FuY2Vs YWJsZSgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1VJRXZlbnQoKSBjb25zdAoreworICAgIEFT U0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzVUlFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc01vdXNlRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3By aXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTW91c2VFdmVudCgpOworfQorCitib29s IFdlYkV2ZW50Ojppc011dGF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTXV0YXRpb25FdmVudCgpOworfQorCitib29s IFdlYkV2ZW50Ojppc0tleWJvYXJkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzS2V5Ym9hcmRFdmVudCgpOworfQorCitib29s IFdlYkV2ZW50Ojppc1RleHRFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7 CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNUZXh0RXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVu dDo6aXNDb21wb3NpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsK KyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0NvbXBvc2l0aW9uRXZlbnQoKTsKK30KKworYm9vbCBX ZWJFdmVudDo6aXNEcmFnRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOwor ICAgIHJldHVybiBtX3ByaXZhdGUtPmlzRHJhZ0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6 OmlzQ2xpcGJvYXJkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAg IHJldHVybiBtX3ByaXZhdGUtPmlzQ2xpcGJvYXJkRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVu dDo6aXNNZXNzYWdlRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAg IHJldHVybiBtX3ByaXZhdGUtPmlzTWVzc2FnZUV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6 OmlzV2hlZWxFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0 dXJuIG1fcHJpdmF0ZS0+aXNXaGVlbEV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQmVm b3JlVGV4dEluc2VydGVkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOwor ICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKTsKK30KKwor Ym9vbCBXZWJFdmVudDo6aXNPdmVyZmxvd0V2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9w cml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc092ZXJmbG93RXZlbnQoKTsKK30KKwor Ym9vbCBXZWJFdmVudDo6aXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1BhZ2VUcmFuc2l0aW9uRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQb3BTdGF0ZUV2ZW50KCkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1BvcFN0YXRlRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQcm9ncmVzc0V2ZW50KCkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1Byb2dyZXNzRXZl bnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQo KSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUt PmlzWE1MSHR0cFJlcXVlc3RQcm9ncmVzc0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6Omlz V2ViS2l0QW5pbWF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOwor ICAgIHJldHVybiBtX3ByaXZhdGUtPmlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKTsKK30KKworYm9v bCBXZWJFdmVudDo6aXNXZWJLaXRUcmFuc2l0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VS VChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzV2ViS2l0VHJhbnNpdGlvbkV2 ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQmVmb3JlTG9hZEV2ZW50KCkgY29uc3QKK3sK KyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0JlZm9yZUxv YWRFdmVudCgpOworfQorCitXZWJFdmVudCBXZWJFdmVudDo6Y3JlYXRlV2ViRXZlbnQoY29uc3Qg V1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYgZXZlbnQpCit7CisgICAgaWYgKGV2ZW50 LT5pc011dGF0aW9uRXZlbnQoKSkKKyAgICAgIHJldHVybiBXZWJNdXRhdGlvbkV2ZW50KGV2ZW50 KTsKKworICAgIC8vIFRPRE8oamNhbXBhbik6IGltcGxlbWVudCBvdGhlciBldmVudHMuCisgICAg cmV0dXJuIFdlYkV2ZW50KCk7Cit9CisKK30KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9zcmMvV2Vi RXZlbnRMaXN0ZW5lci5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL1dl YkV2ZW50TGlzdGVuZXIuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJFdmVudExpc3RlbmVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2NCBAQAorLyoNCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisg Kg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6DQorICoNCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcg0KKyAqIGlu IHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tDQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4NCisgKg0K KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUg0KKyAqIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09Q WVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLA0K KyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UNCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpbmNsdWRlICJjb25maWcuaCINCisjaW5jbHVkZSAiV2Vi RXZlbnRMaXN0ZW5lci5oIg0KKw0KKyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyUHJpdmF0ZS5o Ig0KKw0KK25hbWVzcGFjZSBXZWJLaXQgew0KKw0KK1dlYkV2ZW50TGlzdGVuZXI6OldlYkV2ZW50 TGlzdGVuZXIoKQ0KKyAgICA6IG1fcHJpdmF0ZShuZXcgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUo dGhpcykpDQorew0KK30NCisNCitXZWJFdmVudExpc3RlbmVyOjp+V2ViRXZlbnRMaXN0ZW5lcigp DQorew0KKyAgICBtX3ByaXZhdGUtPndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCk7DQorICAgIGRl bGV0ZSBtX3ByaXZhdGU7DQorfQ0KKw0KK3ZvaWQgV2ViRXZlbnRMaXN0ZW5lcjo6bm90aWZ5RXZl bnRMaXN0ZW5lckRlbGV0ZWQoRXZlbnRMaXN0ZW5lcldyYXBwZXIqIHdyYXBwZXIpDQorew0KKyAg ICBtX3ByaXZhdGUtPmV2ZW50TGlzdGVuZXJEZWxldGVkKHdyYXBwZXIpOw0KK30NCisNCitFdmVu dExpc3RlbmVyV3JhcHBlciogV2ViRXZlbnRMaXN0ZW5lcjo6Y3JlYXRlRXZlbnRMaXN0ZW5lcldy YXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSog bm9kZSkNCit7DQorICAgIHJldHVybiBtX3ByaXZhdGUtPmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFw cGVyKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwgbm9kZSk7DQorfQ0KKw0KK0V2ZW50TGlzdGVuZXJX cmFwcGVyKiBXZWJFdmVudExpc3RlbmVyOjpnZXRFdmVudExpc3RlbmVyV3JhcHBlcihjb25zdCBX ZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2RlKiBub2RlKQ0KK3sNCisg ICAgcmV0dXJuIG1fcHJpdmF0ZS0+Z2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRUeXBlLCB1 c2VDYXB0dXJlLCBub2RlKTsNCit9DQorDQorfSAvLyBuYW1lc3BhY2UgV2ViS2l0DQpJbmRleDog V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVyUHJpdmF0ZS5jcHANCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcAko cmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZh dGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg3IEBACisvKg0KKyAqIENvcHlyaWdodCAo QykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLg0KKyAqDQorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0DQorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQ0KKyAqIG1ldDoNCisgKg0KKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0DQor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUNCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyDQorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQ0KKyAqIGRpc3Ry aWJ1dGlvbi4NCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0 aGUgbmFtZXMgb2YgaXRzDQorICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20NCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLg0KKyAqDQorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9S Uw0KKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SDQorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQNCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwNCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsDQorICogREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZDQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVA0KKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQ0KKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuDQor ICovDQorDQorI2luY2x1ZGUgImNvbmZpZy5oIg0KKyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVy UHJpdmF0ZS5oIg0KKw0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVyV3JhcHBlci5oIg0KKyNpbmNs dWRlICJXZWJFdmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQorDQorV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGU6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlKFdlYkV2ZW50TGlz dGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpDQorICAgIDogbV93ZWJFdmVudExpc3RlbmVyKHdlYkV2 ZW50TGlzdGVuZXIpDQorew0KK30NCisNCitXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6fldlYkV2 ZW50TGlzdGVuZXJQcml2YXRlKCkNCit7DQorfQ0KKw0KK0V2ZW50TGlzdGVuZXJXcmFwcGVyKiBX ZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Y3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIoY29uc3Qg V2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSkNCit7DQor ICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIgPSBuZXcgRXZlbnRMaXN0 ZW5lcldyYXBwZXIobV93ZWJFdmVudExpc3RlbmVyKTsNCisgICAgV2ViRXZlbnRMaXN0ZW5lclBy aXZhdGU6Okxpc3RlbmVySW5mbyBsaXN0ZW5lckluZm8oZXZlbnRUeXBlLCB1c2VDYXB0dXJlLCBs aXN0ZW5lcldyYXBwZXIsIG5vZGUpOw0KKyAgICBtX2xpc3RlbmVyV3JhcHBlcnMuYXBwZW5kKGxp c3RlbmVySW5mbyk7DQorICAgIHJldHVybiBsaXN0ZW5lcldyYXBwZXI7DQorfQ0KKw0KK0V2ZW50 TGlzdGVuZXJXcmFwcGVyKiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Z2V0RXZlbnRMaXN0ZW5l cldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9k ZSogbm9kZSkNCit7DQorICAgIFZlY3RvcjxXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6TGlzdGVu ZXJJbmZvPjo6Y29uc3RfaXRlcmF0b3IgaXRlcjsNCisgICAgZm9yIChpdGVyID0gbV9saXN0ZW5l cldyYXBwZXJzLmJlZ2luKCk7IGl0ZXIgIT0gbV9saXN0ZW5lcldyYXBwZXJzLmVuZCgpOyArK2l0 ZXIpIHsNCisgICAgICAgIGlmIChpdGVyLT5ub2RlID09IG5vZGUpDQorICAgICAgICAgIHJldHVy biBpdGVyLT5ldmVudExpc3RlbmVyV3JhcHBlcjsNCisgICAgfQ0KKyAgICBBU1NFUlRfTk9UX1JF QUNIRUQoKTsNCisgICAgcmV0dXJuIDA7DQorfQ0KKw0KK3ZvaWQgV2ViRXZlbnRMaXN0ZW5lclBy aXZhdGU6OndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCkNCit7DQorICAgIC8vIE5vdGlmaWVzIGFs bCBXZWJFdmVudExpc3RlbmVyV3JhcHBlcnMgdGhhdCB3ZSBhcmUgZ29pbmcgYXdheSBzbyB0aGV5 IGNhbg0KKyAgICAvLyBpbnZhbGlkYXRlIHRoZWlyIHBvaW50ZXIgdG8gdXMuDQorICAgIFZlY3Rv cjxXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6TGlzdGVuZXJJbmZvPjo6Y29uc3RfaXRlcmF0b3Ig aXRlcjsNCisgICAgZm9yIChpdGVyID0gbV9saXN0ZW5lcldyYXBwZXJzLmJlZ2luKCk7IGl0ZXIg IT0gbV9saXN0ZW5lcldyYXBwZXJzLmVuZCgpOyArK2l0ZXIpDQorICAgICAgICBpdGVyLT5ldmVu dExpc3RlbmVyV3JhcHBlci0+d2ViRXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsNCit9DQorDQordm9p ZCBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6ZXZlbnRMaXN0ZW5lckRlbGV0ZWQoRXZlbnRMaXN0 ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXIpDQorew0KKyAgICBmb3IgKHNpemVfdCBpID0gMDsg aSA8IG1fbGlzdGVuZXJXcmFwcGVycy5zaXplKCk7ICsraSkgew0KKyAgICAgICAgaWYgKG1fbGlz dGVuZXJXcmFwcGVyc1tpXS5ldmVudExpc3RlbmVyV3JhcHBlciA9PSBldmVudExpc3RlbmVyKSB7 DQorICAgICAgICAgICAgbV9saXN0ZW5lcldyYXBwZXJzLnJlbW92ZShpKTsNCisgICAgICAgICAg ICByZXR1cm47DQorICAgICAgICB9DQorICAgIH0NCisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7 DQorfQ0KKw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9z cmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJv bWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaAkocmV2aXNpb24gMCkKKysrIFdlYktp dC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw5NSBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwg YXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUN CisgKiBtZXQ6DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICog Y29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVp dGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNv bnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVy aXZlZCBmcm9tDQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0 ZW4gcGVybWlzc2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJ TUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUg0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VA0KKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpZm5kZWYgV2ViRXZl bnRMaXN0ZW5lclByaXZhdGVfaA0KKyNkZWZpbmUgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGVfaA0K Kw0KKyNpbmNsdWRlICJXZWJTdHJpbmcuaCINCisNCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPg0K Kw0KK25hbWVzcGFjZSBXZWJDb3JlIHsNCitjbGFzcyBOb2RlOw0KK30NCisNCit1c2luZyBuYW1l c3BhY2UgV2ViQ29yZTsNCisNCituYW1lc3BhY2UgV2ViS2l0IHsNCisNCitjbGFzcyBFdmVudExp c3RlbmVyV3JhcHBlcjsNCitjbGFzcyBXZWJFdmVudExpc3RlbmVyOw0KKw0KK2NsYXNzIFdlYkV2 ZW50TGlzdGVuZXJQcml2YXRlIHsNCitwdWJsaWM6DQorICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2 YXRlKFdlYkV2ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpOw0KKyAgICB+V2ViRXZlbnRM aXN0ZW5lclByaXZhdGUoKTsNCisNCisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGNyZWF0ZUV2 ZW50TGlzdGVuZXJXcmFwcGVyKA0KKyAgICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUs IGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSk7DQorDQorICAgIC8vIEdldHMgdGhlIExpc3Rl bmVyRXZlbnRXcmFwcGVyIGZvciBhIHNwZWNpZmljIG5vZGUuDQorICAgIC8vIFVzZWQgYnkgV2Vi Tm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcigpLg0KKyAgICBFdmVudExpc3RlbmVyV3JhcHBlciog Z2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoDQorICAgICAgICBjb25zdCBXZWJTdHJpbmcmIGV2ZW50 VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2RlKiBub2RlKTsNCisNCisgICAgLy8gQ2FsbGVkIGJ5 IHRoZSBXZWJFdmVudExpc3RlbmVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVsZXRlZC4NCisg ICAgdm9pZCB3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0KKw0KKyAgICAvLyBDYWxsZWQgYnkg dGhlIEV2ZW50TGlzdGVuZXJXcmFwcGVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVsZXRlZC4N CisgICAgdm9pZCBldmVudExpc3RlbmVyRGVsZXRlZChFdmVudExpc3RlbmVyV3JhcHBlciogZXZl bnRMaXN0ZW5lcik7DQorDQorICAgIHN0cnVjdCBMaXN0ZW5lckluZm8gew0KKyAgICAgICAgTGlz dGVuZXJJbmZvKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsDQor ICAgICAgICAgICAgICAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXJX cmFwcGVyLA0KKyAgICAgICAgICAgICAgICAgICAgIE5vZGUqIG5vZGUpDQorICAgICAgICAgICAg OiBldmVudFR5cGUoZXZlbnRUeXBlKQ0KKyAgICAgICAgICAgICwgdXNlQ2FwdHVyZSh1c2VDYXB0 dXJlKQ0KKyAgICAgICAgICAgICwgZXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRMaXN0ZW5lcldy YXBwZXIpDQorICAgICAgICAgICAgLCBub2RlKG5vZGUpDQorICAgICAgICB7DQorICAgICAgICB9 DQorDQorICAgICAgICBXZWJTdHJpbmcgZXZlbnRUeXBlOw0KKyAgICAgICAgYm9vbCB1c2VDYXB0 dXJlOw0KKyAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXJXcmFwcGVy Ow0KKyAgICAgICAgTm9kZSogbm9kZTsNCisgICAgfTsNCisNCitwcml2YXRlOg0KKyAgICBXZWJF dmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7DQorDQorICAgIC8vIFdlIGtlZXAgYSBs aXN0IG9mIHRoZSB3cmFwcGVyIGZvciB0aGUgV2ViS2l0IEV2ZW50TGlzdGVuZXIsIGl0IGlzIG5l ZWRlZA0KKyAgICAvLyB0byBpbXBsZW1lbnQgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcigp Lg0KKyAgICBWZWN0b3I8TGlzdGVuZXJJbmZvPiBtX2xpc3RlbmVyV3JhcHBlcnM7DQorfTsNCisN Cit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCisNCisjZW5kaWYNCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vc3JjL1dlYk5vZGUuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJOb2RlLmNwcAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYk5v ZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw5IEBACiAjaW5jbHVkZSAiTm9kZUxp c3QuaCIKIAogI2luY2x1ZGUgIldlYkRvY3VtZW50LmgiCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIK KyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5l ckltcGwuaCIKICNpbmNsdWRlICJXZWJGcmFtZUltcGwuaCIKICNpbmNsdWRlICJXZWJOb2RlTGlz dC5oIgogI2luY2x1ZGUgIldlYlN0cmluZy5oIgpAQCAtMTczLDQgKzE3NiwyMiBAQCBib29sIFdl Yk5vZGU6OmlzRWxlbWVudE5vZGUoKSBjb25zdAogICAgIHJldHVybiBtX3ByaXZhdGUtPmlzRWxl bWVudE5vZGUoKTsKIH0KIAordm9pZCBXZWJOb2RlOjphZGRFdmVudExpc3RlbmVyKGNvbnN0IFdl YlN0cmluZyYgZXZlbnRUeXBlLCBXZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lciwgYm9vbCB1c2VD YXB0dXJlKQoreworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIgPQor ICAgICAgICBsaXN0ZW5lci0+Y3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRUeXBlLCB1 c2VDYXB0dXJlLCBtX3ByaXZhdGUpOworICAgIC8vIFRoZSBsaXN0ZW5lcldyYXBwZXIgaXMgb25s eSByZWZlcmVuY2VkIGJ5IHRoZSBhY3R1YWwgTm9kZS4gIE9uY2UgaXQgZ29lcworICAgIC8vIGF3 YXksIHRoZSB3cmFwcGVyIG5vdGlmaWVzIHRoZSBXZWJFdmVudExpc3RlbmVyIHNvIGl0IGNhbiBj bGVhciBpdHMKKyAgICAvLyBwb2ludGVyIHRvIGl0LgorICAgIG1fcHJpdmF0ZS0+YWRkRXZlbnRM aXN0ZW5lcihldmVudFR5cGUsIGFkb3B0UmVmKGxpc3RlbmVyV3JhcHBlciksIHVzZUNhcHR1cmUp OworfQorCit2b2lkIFdlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoY29uc3QgV2ViU3RyaW5n JiBldmVudFR5cGUsIFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNhcHR1cmUp Cit7CisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGxpc3RlbmVyV3JhcHBlciA9CisgICAgICAg IGxpc3RlbmVyLT5nZXRFdmVudExpc3RlbmVyV3JhcHBlcihldmVudFR5cGUsIHVzZUNhcHR1cmUs IG1fcHJpdmF0ZSk7CisgICAgbV9wcml2YXRlLT5yZW1vdmVFdmVudExpc3RlbmVyKGV2ZW50VHlw ZSwgbGlzdGVuZXJXcmFwcGVyLCB1c2VDYXB0dXJlKTsKKyAgICAvLyBsaXN0ZW5lcldyYXBwZXIg aXMgbm93IGRlbGV0ZWQuCit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApJbmRleDogV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJTdHJpbmcuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJTdHJpbmcuY3BwCShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1 bS9zcmMvV2ViU3RyaW5nLmNwcAkod29ya2luZyBjb3B5KQpAQCAtODYsNiArODYsMTEgQEAgV2Vi U3RyaW5nIFdlYlN0cmluZzo6ZnJvbVVURjgoY29uc3QgY2hhcgogICAgIHJldHVybiBXZWJDb3Jl OjpTdHJpbmc6OmZyb21VVEY4KGRhdGEpOwogfQogCitib29sIFdlYlN0cmluZzo6ZXF1YWxzKGNv bnN0IFdlYlN0cmluZyYgcykgY29uc3QKK3sKKyAgICByZXR1cm4gZXF1YWwobV9wcml2YXRlLCBz Lm1fcHJpdmF0ZSk7Cit9CisKIFdlYlN0cmluZzo6V2ViU3RyaW5nKGNvbnN0IFdlYkNvcmU6OlN0 cmluZyYgcykKICAgICA6IG1fcHJpdmF0ZShzdGF0aWNfY2FzdDxXZWJTdHJpbmdQcml2YXRlKj4o cy5pbXBsKCkpKQogewo= 47438 2010-01-26 13:09:26 -0800 2010-01-26 14:16:15 -0800 Chromium Event Listener API event_5.patch text/plain 38202 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzgzMykKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wMS0yNSAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgRXZlbnRMaXN0ZW5lcnMgdG8gdGhlIGNocm9t aXVtIEFQSS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzM4ODIKKworICAgICAgICAqIFdlYktpdC5neXA6CisgICAgICAgICogcHVibGljL1dlYkV2 ZW50Lmg6IEFkZGVkLgorICAgICAgICAqIHB1YmxpYy9XZWJFdmVudExpc3RlbmVyLmg6IEFkZGVk LgorICAgICAgICAqIHB1YmxpYy9XZWJNdXRhdGlvbkV2ZW50Lmg6IEFkZGVkLgorICAgICAgICAq IHB1YmxpYy9XZWJOb2RlLmg6CisgICAgICAgICogcHVibGljL1dlYlN0cmluZy5oOgorICAgICAg ICAoV2ViS2l0OjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6Cisg ICAgICAgICogc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcDogQWRkZWQuCisgICAgICAgICog c3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmg6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVudExpc3RlbmVyLmNwcDogQWRkZWQu CisgICAgICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHNy Yy9XZWJOb2RlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6YWRkRXZlbnRMaXN0ZW5l cik6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIpOgorICAg ICAgICAqIHNyYy9XZWJTdHJpbmcuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTdHJpbmc6OmVx dWFscyk6CisKIDIwMTAtMDEtMjIgIEVsbGlvdCBHbGF5c2hlciAgPGVyZ0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vV2ViS2l0Lmd5cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCSh3b3JraW5n IGNvcHkpCkBAIC0xMDcsNiArMTA3LDggQEAKICAgICAgICAgICAgICAgICAncHVibGljL1dlYkRy YWdEYXRhLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRWRpdGluZ0FjdGlvbi5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkVsZW1lbnQuaCcsCisgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJFdmVudC5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dlYkV2ZW50TGlz dGVuZXIuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlckNvbXBsZXRp b24uaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlclBhcmFtcy5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkZpbmRPcHRpb25zLmgnLApAQCAtMTMwLDYgKzEz Miw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWwuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWxDbGllbnQuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNaW1lUmVnaXN0cnkuaCcsCisgICAgICAgICAg ICAgICAgJ3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJs aWMvV2ViTmF2aWdhdGlvblR5cGUuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJOb2Rl LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTm9kZUNvbGxlY3Rpb24uaCcsCkBAIC0y MTAsNiArMjEzLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL0RyYWdDbGllbnRJbXBsLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5jcHAnLAogICAgICAgICAgICAg ICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3JjL0V2ZW50 TGlzdGVuZXJXcmFwcGVyLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9FdmVudExpc3RlbmVy V3JhcHBlci5oJywKICAgICAgICAgICAgICAgICAnc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5j cHAnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvZ3RrL1dlYkZvbnRJbmZvLmNwcCcsCkBAIC0yNTksNiArMjY0LDEw IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRp ZXMuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAorICAgICAgICAgICAg ICAgICdzcmMvV2ViRXZlbnRMaXN0ZW5lci5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkV2ZW50 TGlzdGVuZXJQcml2YXRlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAn LApAQCAtMjc3LDYgKzI4Niw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMv V2ViTm9kZS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3Bw JywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMxIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJF dmVudF9oCisjZGVmaW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2lu Y2x1ZGUgIldlYk5vZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeyBjbGFzcyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5k aWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAg ICBlbnVtIFBoYXNlVHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAg ICAgIEF0VGFyZ2V0ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9 IDMKKyAgICB9OworCisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJF dmVudChjb25zdCBXZWJFdmVudCYgZSkgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24oZSk7IH0KKyAg ICBXZWJFdmVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBlKQorICAgIHsKKyAgICAgICAg YXNzaWduKGUpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQ SSB2b2lkIHJlc2V0KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVu dCYpOworCisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisK KyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBX ZWJOb2RlIHRhcmdldCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFy Z2V0KCkgY29uc3Q7CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29u c3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJ IGJvb2wgY2FuY2VsYWJsZSgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBib29sIGlzVUlFdmVu dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAg ICBXRUJLSVRfQVBJIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgV0VCS0lUX0FQ SSBib29sIGlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1Rl eHRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNEcmFnRXZlbnQoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg Ym9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1doZWVs RXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc092ZXJmbG93RXZlbnQoKSBjb25z dDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3Q7Cisg ICAgV0VCS0lUX0FQSSBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNY TUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wg aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1dl YktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0JlZm9y ZUxvYWRFdmVudCgpIGNvbnN0OworCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gVCB0b0V2ZW50 KCkKKyAgICB7CisgICAgICAgIFQgcmVzOworICAgICAgICByZXMuV2ViRXZlbnQ6OmFzc2lnbigq dGhpcyk7CisgICAgICAgIHJldHVybiByZXM7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5h bWUgVD4gY29uc3QgVCB0b0NvbnN0RXZlbnQoKSBjb25zdAorICAgIHsKKyAgICAgICAgVCByZXM7 CisgICAgICAgIHJlcy5XZWJFdmVudDo6YXNzaWduKCp0aGlzKTsKKyAgICAgICAgcmV0dXJuIHJl czsKKyAgICB9CisKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYkV2ZW50KGNv bnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mKTsKKyNlbmRpZgorCitwcm90ZWN0 ZWQ6CisgICAgdHlwZWRlZiBXZWJDb3JlOjpFdmVudCBXZWJFdmVudFByaXZhdGU7CisgICAgdm9p ZCBhc3NpZ24oV2ViRXZlbnRQcml2YXRlKik7CisgICAgV2ViRXZlbnRQcml2YXRlKiBtX3ByaXZh dGU7CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBUKiB1bndyYXAoKQorICAgIHsKKyAgICAg ICAgcmV0dXJuIHN0YXRpY19jYXN0PFQqPihtX3ByaXZhdGUpOworICAgIH0KKworICAgIHRlbXBs YXRlPHR5cGVuYW1lIFQ+IGNvbnN0IFQqIGNvbnN0VW53cmFwKCkgY29uc3QKKyAgICB7CisgICAg ICAgIHJldHVybiBzdGF0aWNfY2FzdDxjb25zdCBUKj4obV9wcml2YXRlKTsKKyAgICB9Cit9Owor Cit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1 bS9wdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFdlYkV2ZW50TGlzdGVuZXJfaAorI2RlZmluZSBXZWJFdmVudExpc3RlbmVyX2gK KworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBO b2RlOyB9CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIEV2ZW50TGlzdGVu ZXJXcmFwcGVyOworY2xhc3MgV2ViRXZlbnQ7CitjbGFzcyBXZWJFdmVudExpc3RlbmVyUHJpdmF0 ZTsKK2NsYXNzIFdlYk5vZGU7CitjbGFzcyBXZWJTdHJpbmc7CisKK2NsYXNzIFdlYkV2ZW50TGlz dGVuZXIgeworcHVibGljOgorICAgIFdlYkV2ZW50TGlzdGVuZXIoKTsKKyAgICB2aXJ0dWFsIH5X ZWJFdmVudExpc3RlbmVyKCk7CisKKyAgICAvLyBDYWxsZWQgd2hlbiBhbiBldmVudCBpcyByZWNl aXZlZC4KKyAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlRXZlbnQoY29uc3QgV2ViRXZlbnQmKSA9IDA7 CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KKyAgICB2b2lkIG5vdGlmeUV2ZW50TGlzdGVu ZXJEZWxldGVkKEV2ZW50TGlzdGVuZXJXcmFwcGVyKik7CisgICAgRXZlbnRMaXN0ZW5lcldyYXBw ZXIqIGNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBl LCBib29sIHVzZUNhcHR1cmUsIFdlYkNvcmU6Ok5vZGUqIG5vZGUpOworICAgIEV2ZW50TGlzdGVu ZXJXcmFwcGVyKiBnZXRFdmVudExpc3RlbmVyV3JhcHBlcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50 VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBXZWJDb3JlOjpOb2RlKiBub2RlKTsKKyNlbmRpZgorCitw cml2YXRlOgorICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKiBtX3ByaXZhdGU7Cit9OworCit9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYk11dGF0aW9uRXZlbnQuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViTXV0YXRpb25FdmVudC5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjIgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor ICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5j LiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUg d2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV VE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9X TkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK KyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworI2lm bmRlZiBXZWJNdXRhdGlvbkV2ZW50X2gKKyNkZWZpbmUgV2ViTXV0YXRpb25FdmVudF9oCisKKyNp bmNsdWRlICJXZWJFdmVudC5oIgorCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCituYW1lc3Bh Y2UgV2ViQ29yZSB7IGNsYXNzIEV2ZW50OyB9CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYktpdCB7 CisKK2NsYXNzIFdlYk11dGF0aW9uRXZlbnQgOiBwdWJsaWMgV2ViRXZlbnQgeworcHVibGljOgor ICAgIGVudW0gQXR0ckNoYW5nZVR5cGUgeworICAgICAgICBNb2RpZmljYXRpb24gICAgPSAxLAor ICAgICAgICBBZGRpdGlvbiAgICAgICAgPSAyLAorICAgICAgICBSZW1vdmFsICAgICAgICAgPSAz CisgICAgfTsKKworICAgIFdFQktJVF9BUEkgV2ViTm9kZSByZWxhdGVkTm9kZSgpIGNvbnN0Owor ICAgIFdFQktJVF9BUEkgV2ViU3RyaW5nIHByZXZWYWx1ZSgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgV2ViU3RyaW5nIG5ld1ZhbHVlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcg YXR0ck5hbWUoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIEF0dHJDaGFuZ2VUeXBlIGF0dHJDaGFu Z2UoKSBjb25zdDsKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYk11dGF0aW9u RXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYpOworI2VuZGlmCit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYk5vZGUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJs aWMvV2ViTm9kZS5oCShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViTm9kZS5oCSh3b3JraW5nIGNvcHkpCkBAIC00MSw2ICs0MSw4IEBAIG5hbWVzcGFjZSBXVEYg eyB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gY2wKIAogbmFtZXNwYWNlIFdlYktpdCB7CiBjbGFzcyBX ZWJEb2N1bWVudDsKK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXI7CitjbGFzcyBXZWJFdmVudExpc3Rl bmVyUHJpdmF0ZTsKIGNsYXNzIFdlYkZyYW1lOwogY2xhc3MgV2ViTm9kZUxpc3Q7CiAKQEAgLTEw MCw2ICsxMDIsOCBAQCBwdWJsaWM6CiAgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcgY3JlYXRlTWFy a3VwKCkgY29uc3Q7CiAgICAgV0VCS0lUX0FQSSBib29sIGlzVGV4dE5vZGUoKSBjb25zdDsKICAg ICBXRUJLSVRfQVBJIGJvb2wgaXNFbGVtZW50Tm9kZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg dm9pZCBhZGRFdmVudExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBXZWJFdmVu dExpc3RlbmVyKiBsaXN0ZW5lciwgYm9vbCB1c2VDYXB0dXJlKTsKKyAgICBXRUJLSVRfQVBJIHZv aWQgcmVtb3ZlRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgV2ViRXZl bnRMaXN0ZW5lciogbGlzdGVuZXIsIGJvb2wgdXNlQ2FwdHVyZSk7CiAKICAgICB0ZW1wbGF0ZTx0 eXBlbmFtZSBUPiBUIHRvRWxlbWVudCgpCiAgICAgewpJbmRleDogV2ViS2l0L2Nocm9taXVtL3B1 YmxpYy9XZWJTdHJpbmcuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViU3RyaW5nLmgJKHJldmlzaW9uIDUzODEzKQorKysgV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9X ZWJTdHJpbmcuaAkod29ya2luZyBjb3B5KQpAQCAtNzYsNiArNzYsOCBAQCBwdWJsaWM6CiAgICAg V0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJTdHJpbmcmKTsKICAgICBXRUJLSVRfQVBJ IHZvaWQgYXNzaWduKGNvbnN0IFdlYlVDaGFyKiBkYXRhLCBzaXplX3QgbGVuKTsKIAorICAgIFdF QktJVF9BUEkgYm9vbCBlcXVhbHMoY29uc3QgV2ViU3RyaW5nJiBzKSBjb25zdDsKKwogICAgIFdF QktJVF9BUEkgc2l6ZV90IGxlbmd0aCgpIGNvbnN0OwogICAgIFdFQktJVF9BUEkgY29uc3QgV2Vi VUNoYXIqIGRhdGEoKSBjb25zdDsKIApAQCAtMTYzLDYgKzE2NSwxNiBAQCBwcml2YXRlOgogICAg IFdlYlN0cmluZ1ByaXZhdGUqIG1fcHJpdmF0ZTsKIH07CiAKK2lubGluZSBib29sIG9wZXJhdG9y PT0oY29uc3QgV2ViU3RyaW5nJiBhLCBjb25zdCBXZWJTdHJpbmcmIGIpCit7CisgICAgcmV0dXJu IGEuZXF1YWxzKGIpOworfQorCitpbmxpbmUgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFdlYlN0cmlu ZyYgYSwgY29uc3QgV2ViU3RyaW5nJiBiKQoreworICAgIHJldHVybiAhKGEgPT0gYik7Cit9CisK IH0gLy8gbmFtZXNwYWNlIFdlYktpdAogCiAjZW5kaWYKSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9z cmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9t aXVtL3NyYy9FdmVudExpc3RlbmVyV3JhcHBlci5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQv Y2hyb21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAs MCArMSw3MiBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisg KiBtZXQ6DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29w eXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhl ciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRy aWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZl ZCBmcm9tDQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4g cGVybWlzc2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENP UFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUg0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0K KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpbmNsdWRlICJjb25maWcu aCINCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lcldyYXBwZXIuaCINCisNCisjaW5jbHVkZSAiRXZl bnQuaCINCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lci5oIg0KKw0KKyNpbmNsdWRlICJXZWJFdmVu dC5oIg0KKyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYktp dCB7DQorDQorRXZlbnRMaXN0ZW5lcldyYXBwZXI6OkV2ZW50TGlzdGVuZXJXcmFwcGVyKFdlYkV2 ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpDQorICAgIDogRXZlbnRMaXN0ZW5lcihFdmVu dExpc3RlbmVyOjpKU0V2ZW50TGlzdGVuZXJUeXBlKQ0KKyAgICAsIG1fd2ViRXZlbnRMaXN0ZW5l cih3ZWJFdmVudExpc3RlbmVyKQ0KK3sNCit9DQorDQorRXZlbnRMaXN0ZW5lcldyYXBwZXI6On5F dmVudExpc3RlbmVyV3JhcHBlcigpDQorew0KKyAgICBpZiAobV93ZWJFdmVudExpc3RlbmVyKQ0K KyAgICAgICAgbV93ZWJFdmVudExpc3RlbmVyLT5ub3RpZnlFdmVudExpc3RlbmVyRGVsZXRlZCh0 aGlzKTsNCit9DQorDQorYm9vbCBFdmVudExpc3RlbmVyV3JhcHBlcjo6b3BlcmF0b3I9PShjb25z dCBFdmVudExpc3RlbmVyJiBsaXN0ZW5lcikNCit7DQorICAgIHJldHVybiB0aGlzID09ICZsaXN0 ZW5lcjsNCit9DQorDQordm9pZCBFdmVudExpc3RlbmVyV3JhcHBlcjo6aGFuZGxlRXZlbnQoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgRXZlbnQqIGV2ZW50KQ0KK3sNCisgICAgaWYg KCFtX3dlYkV2ZW50TGlzdGVuZXIpDQorICAgICAgICByZXR1cm47DQorICAgIFdlYkV2ZW50IHdl YkV2ZW50KGV2ZW50KTsNCisgICAgbV93ZWJFdmVudExpc3RlbmVyLT5oYW5kbGVFdmVudCh3ZWJF dmVudCk7DQorfQ0KKw0KK3ZvaWQgRXZlbnRMaXN0ZW5lcldyYXBwZXI6OndlYkV2ZW50TGlzdGVu ZXJEZWxldGVkKCkNCit7DQorICAgIG1fd2ViRXZlbnRMaXN0ZW5lciA9IDA7DQorfQ0KKw0KK30g Ly8gbmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9zcmMvRXZlbnRMaXN0 ZW5lcldyYXBwZXIuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvRXZlbnRM aXN0ZW5lcldyYXBwZXIuaAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvRXZl bnRMaXN0ZW5lcldyYXBwZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2MiBAQAorLyoNCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisg Kg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6DQorICoNCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcg0KKyAqIGlu IHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tDQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4NCisgKg0K KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUg0KKyAqIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09Q WVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLA0K KyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVESU5HIE5FR0xJR0VO Q0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UNCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpZm5kZWYgRXZlbnRMaXN0ZW5lcldyYXBwZXJfaA0KKyNk ZWZpbmUgRXZlbnRMaXN0ZW5lcldyYXBwZXJfaA0KKw0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVy LmgiDQorDQorbmFtZXNwYWNlIFdlYkNvcmUgew0KK2NsYXNzIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ7DQorfQ0KKw0KK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOw0KKw0KK25hbWVzcGFjZSBXZWJL aXQgew0KKw0KK2NsYXNzIFdlYkV2ZW50TGlzdGVuZXI7DQorDQorY2xhc3MgRXZlbnRMaXN0ZW5l cldyYXBwZXIgOiBwdWJsaWMgRXZlbnRMaXN0ZW5lciB7DQorcHVibGljOg0KKyAgICBFdmVudExp c3RlbmVyV3JhcHBlcihXZWJFdmVudExpc3RlbmVyKik7DQorICAgIH5FdmVudExpc3RlbmVyV3Jh cHBlcigpOw0KKw0KKyAgICB2aXJ0dWFsIGJvb2wgb3BlcmF0b3I9PShjb25zdCBFdmVudExpc3Rl bmVyJik7DQorICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudChTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiwgRXZlbnQqKTsNCisNCisgICAgdm9pZCB3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0K Kw0KK3ByaXZhdGU6DQorICAgIFdlYkV2ZW50TGlzdGVuZXIqIG1fd2ViRXZlbnRMaXN0ZW5lcjsN Cit9Ow0KKw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KKw0KKyNlbmRpZg0KSW5kZXg6IFdlYktp dC9jaHJvbWl1bS9zcmMvV2ViRXZlbnQuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJFdmVudC5jcHAJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkV2ZW50LmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMjAgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKworI2luY2x1ZGUgIkV2ZW50LmgiCisjaW5j bHVkZSAiTm9kZS5oIgorI2luY2x1ZGUgIldlYk11dGF0aW9uRXZlbnQuaCIKKyNpbmNsdWRlIDx3 dGYvUGFzc1JlZlB0ci5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2ViRXZlbnRQ cml2YXRlIDogcHVibGljIFdlYkNvcmU6OkV2ZW50IHsKK307CisKK3ZvaWQgV2ViRXZlbnQ6OnJl c2V0KCkKK3sKKyAgICBhc3NpZ24oMCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihjb25z dCBXZWJFdmVudCYgb3RoZXIpCit7CisgICAgV2ViRXZlbnRQcml2YXRlKiBwID0gY29uc3RfY2Fz dDxXZWJFdmVudFByaXZhdGUqPihvdGhlci5tX3ByaXZhdGUpOworICAgIGlmIChwKQorICAgICAg ICBwLT5yZWYoKTsKKyAgICBhc3NpZ24ocCk7Cit9CisKK3ZvaWQgV2ViRXZlbnQ6OmFzc2lnbihX ZWJFdmVudFByaXZhdGUqIHApCit7CisgICAgLy8gcCBpcyBhbHJlYWR5IHJlZidkIGZvciB1cyBi eSB0aGUgY2FsbGVyCisgICAgaWYgKG1fcHJpdmF0ZSkKKyAgICAgICAgbV9wcml2YXRlLT5kZXJl ZigpOworICAgIG1fcHJpdmF0ZSA9IHA7Cit9CisKK1dlYkV2ZW50OjpXZWJFdmVudChjb25zdCBX VEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+JiBldmVudCkKKyAgICA6IG1fcHJpdmF0ZShz dGF0aWNfY2FzdDxXZWJFdmVudFByaXZhdGUqPihldmVudC5yZWxlYXNlUmVmKCkpKQoreworfQor CitXZWJTdHJpbmcgV2ViRXZlbnQ6OnR5cGUoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPnR5cGUoKTsKK30KKworV2ViTm9kZSBXZWJFdmVu dDo6dGFyZ2V0KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4g V2ViTm9kZShtX3ByaXZhdGUtPnRhcmdldCgpLT50b05vZGUoKSk7Cit9CisKK1dlYk5vZGUgV2Vi RXZlbnQ6OmN1cnJlbnRUYXJnZXQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOwor ICAgIHJldHVybiBXZWJOb2RlKG1fcHJpdmF0ZS0+Y3VycmVudFRhcmdldCgpLT50b05vZGUoKSk7 Cit9CisKK1dlYkV2ZW50OjpQaGFzZVR5cGUgV2ViRXZlbnQ6OmV2ZW50UGhhc2UoKSBjb25zdAor eworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxXZWJFdmVu dDo6UGhhc2VUeXBlPihtX3ByaXZhdGUtPmV2ZW50UGhhc2UoKSk7Cit9CisKK2Jvb2wgV2ViRXZl bnQ6OmJ1YmJsZXMoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVy biBtX3ByaXZhdGUtPmJ1YmJsZXMoKTsKK30KKworYm9vbCBXZWJFdmVudDo6Y2FuY2VsYWJsZSgp IGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+ Y2FuY2VsYWJsZSgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1VJRXZlbnQoKSBjb25zdAorewor ICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzVUlFdmVudCgp OworfQorCitib29sIFdlYkV2ZW50Ojppc01vdXNlRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VS VChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTW91c2VFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc011dGF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVCht X3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTXV0YXRpb25FdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc0tleWJvYXJkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVCht X3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzS2V5Ym9hcmRFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc1RleHRFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJp dmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNUZXh0RXZlbnQoKTsKK30KKworYm9vbCBX ZWJFdmVudDo6aXNDb21wb3NpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2 YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0NvbXBvc2l0aW9uRXZlbnQoKTsKK30KKwor Ym9vbCBXZWJFdmVudDo6aXNEcmFnRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzRHJhZ0V2ZW50KCk7Cit9CisKK2Jvb2wgV2Vi RXZlbnQ6OmlzQ2xpcGJvYXJkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUp OworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQ2xpcGJvYXJkRXZlbnQoKTsKK30KKworYm9vbCBX ZWJFdmVudDo6aXNNZXNzYWdlRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUp OworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzTWVzc2FnZUV2ZW50KCk7Cit9CisKK2Jvb2wgV2Vi RXZlbnQ6OmlzV2hlZWxFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7Cisg ICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNXaGVlbEV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6 OmlzQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQmVmb3JlVGV4dEluc2VydGVkRXZlbnQoKTsK K30KKworYm9vbCBXZWJFdmVudDo6aXNPdmVyZmxvd0V2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc092ZXJmbG93RXZlbnQoKTsK K30KKworYm9vbCBXZWJFdmVudDo6aXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3QKK3sKKyAg ICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1BhZ2VUcmFuc2l0 aW9uRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQb3BTdGF0ZUV2ZW50KCkgY29uc3QK K3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1BvcFN0 YXRlRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNQcm9ncmVzc0V2ZW50KCkgY29uc3QK K3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1Byb2dy ZXNzRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNYTUxIdHRwUmVxdWVzdFByb2dyZXNz RXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3By aXZhdGUtPmlzWE1MSHR0cFJlcXVlc3RQcm9ncmVzc0V2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZl bnQ6OmlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZh dGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzV2ViS2l0QW5pbWF0aW9uRXZlbnQoKTsKK30K KworYm9vbCBXZWJFdmVudDo6aXNXZWJLaXRUcmFuc2l0aW9uRXZlbnQoKSBjb25zdAoreworICAg IEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzV2ViS2l0VHJhbnNp dGlvbkV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzQmVmb3JlTG9hZEV2ZW50KCkgY29u c3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc0Jl Zm9yZUxvYWRFdmVudCgpOworfQorCit9CkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2 ZW50TGlzdGVuZXIuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJF dmVudExpc3RlbmVyLmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvV2Vi RXZlbnRMaXN0ZW5lci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjQgQEAKKy8qDQorICog Q29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuDQorICoN CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQNCisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlDQorICogbWV0Og0KKyAqDQorICogICAg ICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQNCisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuDQorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQ0KKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXINCisgKiBpbiB0 aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl DQorICogZGlzdHJpYnV0aW9uLg0KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xl IEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMNCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQ0KKyAqIHRoaXMgc29m dHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uDQorICoNCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTDQorICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QNCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1INCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVA0KKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLA0KKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QNCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwNCisg KiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkNCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUDQorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFDQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4NCisgKi8NCisNCisjaW5jbHVkZSAiY29uZmlnLmgiDQorI2luY2x1ZGUgIldlYkV2 ZW50TGlzdGVuZXIuaCINCisNCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaCIN CisNCituYW1lc3BhY2UgV2ViS2l0IHsNCisNCitXZWJFdmVudExpc3RlbmVyOjpXZWJFdmVudExp c3RlbmVyKCkNCisgICAgOiBtX3ByaXZhdGUobmV3IFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlKHRo aXMpKQ0KK3sNCit9DQorDQorV2ViRXZlbnRMaXN0ZW5lcjo6fldlYkV2ZW50TGlzdGVuZXIoKQ0K K3sNCisgICAgbV9wcml2YXRlLT53ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0KKyAgICBkZWxl dGUgbV9wcml2YXRlOw0KK30NCisNCit2b2lkIFdlYkV2ZW50TGlzdGVuZXI6Om5vdGlmeUV2ZW50 TGlzdGVuZXJEZWxldGVkKEV2ZW50TGlzdGVuZXJXcmFwcGVyKiB3cmFwcGVyKQ0KK3sNCisgICAg bV9wcml2YXRlLT5ldmVudExpc3RlbmVyRGVsZXRlZCh3cmFwcGVyKTsNCit9DQorDQorRXZlbnRM aXN0ZW5lcldyYXBwZXIqIFdlYkV2ZW50TGlzdGVuZXI6OmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFw cGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsIE5vZGUqIG5v ZGUpDQorew0KKyAgICByZXR1cm4gbV9wcml2YXRlLT5jcmVhdGVFdmVudExpc3RlbmVyV3JhcHBl cihldmVudFR5cGUsIHVzZUNhcHR1cmUsIG5vZGUpOw0KK30NCisNCitFdmVudExpc3RlbmVyV3Jh cHBlciogV2ViRXZlbnRMaXN0ZW5lcjo6Z2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoY29uc3QgV2Vi U3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSkNCit7DQorICAg IHJldHVybiBtX3ByaXZhdGUtPmdldEV2ZW50TGlzdGVuZXJXcmFwcGVyKGV2ZW50VHlwZSwgdXNl Q2FwdHVyZSwgbm9kZSk7DQorfQ0KKw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdl YktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuY3BwDQo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 DQotLS0gV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVyUHJpdmF0ZS5jcHAJKHJl dmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRl LmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4NyBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAq IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmli dXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhl IG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9y IHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tDQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0 IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMN CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUg0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dO RVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFO WQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAq Lw0KKw0KKyNpbmNsdWRlICJjb25maWcuaCINCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lclBy aXZhdGUuaCINCisNCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5lcldyYXBwZXIuaCINCisjaW5jbHVk ZSAiV2ViRXZlbnRMaXN0ZW5lci5oIg0KKw0KK25hbWVzcGFjZSBXZWJLaXQgew0KKw0KK1dlYkV2 ZW50TGlzdGVuZXJQcml2YXRlOjpXZWJFdmVudExpc3RlbmVyUHJpdmF0ZShXZWJFdmVudExpc3Rl bmVyKiB3ZWJFdmVudExpc3RlbmVyKQ0KKyAgICA6IG1fd2ViRXZlbnRMaXN0ZW5lcih3ZWJFdmVu dExpc3RlbmVyKQ0KK3sNCit9DQorDQorV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6On5XZWJFdmVu dExpc3RlbmVyUHJpdmF0ZSgpDQorew0KK30NCisNCitFdmVudExpc3RlbmVyV3JhcHBlciogV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGU6OmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdl YlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsIE5vZGUqIG5vZGUpDQorew0KKyAg ICBFdmVudExpc3RlbmVyV3JhcHBlciogbGlzdGVuZXJXcmFwcGVyID0gbmV3IEV2ZW50TGlzdGVu ZXJXcmFwcGVyKG1fd2ViRXZlbnRMaXN0ZW5lcik7DQorICAgIFdlYkV2ZW50TGlzdGVuZXJQcml2 YXRlOjpMaXN0ZW5lckluZm8gbGlzdGVuZXJJbmZvKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwgbGlz dGVuZXJXcmFwcGVyLCBub2RlKTsNCisgICAgbV9saXN0ZW5lcldyYXBwZXJzLmFwcGVuZChsaXN0 ZW5lckluZm8pOw0KKyAgICByZXR1cm4gbGlzdGVuZXJXcmFwcGVyOw0KK30NCisNCitFdmVudExp c3RlbmVyV3JhcHBlciogV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OmdldEV2ZW50TGlzdGVuZXJX cmFwcGVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsIE5vZGUq IG5vZGUpDQorew0KKyAgICBWZWN0b3I8V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6Okxpc3RlbmVy SW5mbz46OmNvbnN0X2l0ZXJhdG9yIGl0ZXI7DQorICAgIGZvciAoaXRlciA9IG1fbGlzdGVuZXJX cmFwcGVycy5iZWdpbigpOyBpdGVyICE9IG1fbGlzdGVuZXJXcmFwcGVycy5lbmQoKTsgKytpdGVy KSB7DQorICAgICAgICBpZiAoaXRlci0+bm9kZSA9PSBub2RlKQ0KKyAgICAgICAgICByZXR1cm4g aXRlci0+ZXZlbnRMaXN0ZW5lcldyYXBwZXI7DQorICAgIH0NCisgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7DQorICAgIHJldHVybiAwOw0KK30NCisNCit2b2lkIFdlYkV2ZW50TGlzdGVuZXJQcml2 YXRlOjp3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpDQorew0KKyAgICAvLyBOb3RpZmllcyBhbGwg V2ViRXZlbnRMaXN0ZW5lcldyYXBwZXJzIHRoYXQgd2UgYXJlIGdvaW5nIGF3YXkgc28gdGhleSBj YW4NCisgICAgLy8gaW52YWxpZGF0ZSB0aGVpciBwb2ludGVyIHRvIHVzLg0KKyAgICBWZWN0b3I8 V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6Okxpc3RlbmVySW5mbz46OmNvbnN0X2l0ZXJhdG9yIGl0 ZXI7DQorICAgIGZvciAoaXRlciA9IG1fbGlzdGVuZXJXcmFwcGVycy5iZWdpbigpOyBpdGVyICE9 IG1fbGlzdGVuZXJXcmFwcGVycy5lbmQoKTsgKytpdGVyKQ0KKyAgICAgICAgaXRlci0+ZXZlbnRM aXN0ZW5lcldyYXBwZXItPndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCk7DQorfQ0KKw0KK3ZvaWQg V2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OmV2ZW50TGlzdGVuZXJEZWxldGVkKEV2ZW50TGlzdGVu ZXJXcmFwcGVyKiBldmVudExpc3RlbmVyKQ0KK3sNCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkg PCBtX2xpc3RlbmVyV3JhcHBlcnMuc2l6ZSgpOyArK2kpIHsNCisgICAgICAgIGlmIChtX2xpc3Rl bmVyV3JhcHBlcnNbaV0uZXZlbnRMaXN0ZW5lcldyYXBwZXIgPT0gZXZlbnRMaXN0ZW5lcikgew0K KyAgICAgICAgICAgIG1fbGlzdGVuZXJXcmFwcGVycy5yZW1vdmUoaSk7DQorICAgICAgICAgICAg cmV0dXJuOw0KKyAgICAgICAgfQ0KKyAgICB9DQorICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOw0K K30NCisNCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmgJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsOTUgQEAKKy8qDQorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuDQorICoNCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQNCisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlDQor ICogbWV0Og0KKyAqDQorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQNCisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuDQorICogICAgICogUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQ0KKyAqIGNv cHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXINCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlDQorICogZGlzdHJpYnV0aW9uLg0KKyAqICAgICAqIE5laXRo ZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMNCisgKiBjb250 cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2 ZWQgZnJvbQ0KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVu IHBlcm1pc3Npb24uDQorICoNCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBD T1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTDQorICogIkFTIElTIiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QNCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1INCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVA0KKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLA0KKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QN CisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwNCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkNCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUDQorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFDQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4NCisgKi8NCisNCisjaWZuZGVmIFdlYkV2ZW50 TGlzdGVuZXJQcml2YXRlX2gNCisjZGVmaW5lIFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlX2gNCisN CisjaW5jbHVkZSAiV2ViU3RyaW5nLmgiDQorDQorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4NCisN CituYW1lc3BhY2UgV2ViQ29yZSB7DQorY2xhc3MgTm9kZTsNCit9DQorDQordXNpbmcgbmFtZXNw YWNlIFdlYkNvcmU7DQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQorDQorY2xhc3MgRXZlbnRMaXN0 ZW5lcldyYXBwZXI7DQorY2xhc3MgV2ViRXZlbnRMaXN0ZW5lcjsNCisNCitjbGFzcyBXZWJFdmVu dExpc3RlbmVyUHJpdmF0ZSB7DQorcHVibGljOg0KKyAgICBXZWJFdmVudExpc3RlbmVyUHJpdmF0 ZShXZWJFdmVudExpc3RlbmVyKiB3ZWJFdmVudExpc3RlbmVyKTsNCisgICAgfldlYkV2ZW50TGlz dGVuZXJQcml2YXRlKCk7DQorDQorICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBjcmVhdGVFdmVu dExpc3RlbmVyV3JhcHBlcigNCisgICAgICAgIGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBi b29sIHVzZUNhcHR1cmUsIE5vZGUqIG5vZGUpOw0KKw0KKyAgICAvLyBHZXRzIHRoZSBMaXN0ZW5l ckV2ZW50V3JhcHBlciBmb3IgYSBzcGVjaWZpYyBub2RlLg0KKyAgICAvLyBVc2VkIGJ5IFdlYk5v ZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoKS4NCisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGdl dEV2ZW50TGlzdGVuZXJXcmFwcGVyKA0KKyAgICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVudFR5 cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSk7DQorDQorICAgIC8vIENhbGxlZCBieSB0 aGUgV2ViRXZlbnRMaXN0ZW5lciB3aGVuIGl0IGlzIGFib3V0IHRvIGJlIGRlbGV0ZWQuDQorICAg IHZvaWQgd2ViRXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsNCisNCisgICAgLy8gQ2FsbGVkIGJ5IHRo ZSBFdmVudExpc3RlbmVyV3JhcHBlciB3aGVuIGl0IGlzIGFib3V0IHRvIGJlIGRlbGV0ZWQuDQor ICAgIHZvaWQgZXZlbnRMaXN0ZW5lckRlbGV0ZWQoRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50 TGlzdGVuZXIpOw0KKw0KKyAgICBzdHJ1Y3QgTGlzdGVuZXJJbmZvIHsNCisgICAgICAgIExpc3Rl bmVySW5mbyhjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLA0KKyAg ICAgICAgICAgICAgICAgICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBldmVudExpc3RlbmVyV3Jh cHBlciwNCisgICAgICAgICAgICAgICAgICAgICBOb2RlKiBub2RlKQ0KKyAgICAgICAgICAgIDog ZXZlbnRUeXBlKGV2ZW50VHlwZSkNCisgICAgICAgICAgICAsIHVzZUNhcHR1cmUodXNlQ2FwdHVy ZSkNCisgICAgICAgICAgICAsIGV2ZW50TGlzdGVuZXJXcmFwcGVyKGV2ZW50TGlzdGVuZXJXcmFw cGVyKQ0KKyAgICAgICAgICAgICwgbm9kZShub2RlKQ0KKyAgICAgICAgew0KKyAgICAgICAgfQ0K Kw0KKyAgICAgICAgV2ViU3RyaW5nIGV2ZW50VHlwZTsNCisgICAgICAgIGJvb2wgdXNlQ2FwdHVy ZTsNCisgICAgICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBldmVudExpc3RlbmVyV3JhcHBlcjsN CisgICAgICAgIE5vZGUqIG5vZGU7DQorICAgIH07DQorDQorcHJpdmF0ZToNCisgICAgV2ViRXZl bnRMaXN0ZW5lciogbV93ZWJFdmVudExpc3RlbmVyOw0KKw0KKyAgICAvLyBXZSBrZWVwIGEgbGlz dCBvZiB0aGUgd3JhcHBlciBmb3IgdGhlIFdlYktpdCBFdmVudExpc3RlbmVyLCBpdCBpcyBuZWVk ZWQNCisgICAgLy8gdG8gaW1wbGVtZW50IFdlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIoKS4N CisgICAgVmVjdG9yPExpc3RlbmVySW5mbz4gbV9saXN0ZW5lcldyYXBwZXJzOw0KK307DQorDQor fSAvLyBuYW1lc3BhY2UgV2ViS2l0DQorDQorI2VuZGlmDQpJbmRleDogV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJOb2RlLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9zcmMvV2Vi Tm9kZS5jcHAJKHJldmlzaW9uIDUzODEzKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJOb2Rl LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiArMzgsOSBAQAogI2luY2x1ZGUgIk5vZGVMaXN0 LmgiCiAKICNpbmNsdWRlICJXZWJEb2N1bWVudC5oIgorI2luY2x1ZGUgIldlYkV2ZW50LmgiCisj aW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lci5oIgorI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXJJ bXBsLmgiCiAjaW5jbHVkZSAiV2ViRnJhbWVJbXBsLmgiCiAjaW5jbHVkZSAiV2ViTm9kZUxpc3Qu aCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKQEAgLTE3Myw0ICsxNzYsMjIgQEAgYm9vbCBXZWJO b2RlOjppc0VsZW1lbnROb2RlKCkgY29uc3QKICAgICByZXR1cm4gbV9wcml2YXRlLT5pc0VsZW1l bnROb2RlKCk7CiB9CiAKK3ZvaWQgV2ViTm9kZTo6YWRkRXZlbnRMaXN0ZW5lcihjb25zdCBXZWJT dHJpbmcmIGV2ZW50VHlwZSwgV2ViRXZlbnRMaXN0ZW5lciogbGlzdGVuZXIsIGJvb2wgdXNlQ2Fw dHVyZSkKK3sKKyAgICBFdmVudExpc3RlbmVyV3JhcHBlciogbGlzdGVuZXJXcmFwcGVyID0KKyAg ICAgICAgbGlzdGVuZXItPmNyZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKGV2ZW50VHlwZSwgdXNl Q2FwdHVyZSwgbV9wcml2YXRlKTsKKyAgICAvLyBUaGUgbGlzdGVuZXJXcmFwcGVyIGlzIG9ubHkg cmVmZXJlbmNlZCBieSB0aGUgYWN0dWFsIE5vZGUuICBPbmNlIGl0IGdvZXMKKyAgICAvLyBhd2F5 LCB0aGUgd3JhcHBlciBub3RpZmllcyB0aGUgV2ViRXZlbnRMaXN0ZW5lciBzbyBpdCBjYW4gY2xl YXIgaXRzCisgICAgLy8gcG9pbnRlciB0byBpdC4KKyAgICBtX3ByaXZhdGUtPmFkZEV2ZW50TGlz dGVuZXIoZXZlbnRUeXBlLCBhZG9wdFJlZihsaXN0ZW5lcldyYXBwZXIpLCB1c2VDYXB0dXJlKTsK K30KKwordm9pZCBXZWJOb2RlOjpyZW1vdmVFdmVudExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYg ZXZlbnRUeXBlLCBXZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lciwgYm9vbCB1c2VDYXB0dXJlKQor eworICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIgPQorICAgICAgICBs aXN0ZW5lci0+Z2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRUeXBlLCB1c2VDYXB0dXJlLCBt X3ByaXZhdGUpOworICAgIG1fcHJpdmF0ZS0+cmVtb3ZlRXZlbnRMaXN0ZW5lcihldmVudFR5cGUs IGxpc3RlbmVyV3JhcHBlciwgdXNlQ2FwdHVyZSk7CisgICAgLy8gbGlzdGVuZXJXcmFwcGVyIGlz IG5vdyBkZWxldGVkLgorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKSW5kZXg6IFdlYktpdC9j aHJvbWl1bS9zcmMvV2ViU3RyaW5nLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1 bS9zcmMvV2ViU3RyaW5nLmNwcAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0v c3JjL1dlYlN0cmluZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTg2LDYgKzg2LDExIEBAIFdlYlN0 cmluZyBXZWJTdHJpbmc6OmZyb21VVEY4KGNvbnN0IGNoYXIKICAgICByZXR1cm4gV2ViQ29yZTo6 U3RyaW5nOjpmcm9tVVRGOChkYXRhKTsKIH0KIAorYm9vbCBXZWJTdHJpbmc6OmVxdWFscyhjb25z dCBXZWJTdHJpbmcmIHMpIGNvbnN0Cit7CisgICAgcmV0dXJuIGVxdWFsKG1fcHJpdmF0ZSwgcy5t X3ByaXZhdGUpOworfQorCiBXZWJTdHJpbmc6OldlYlN0cmluZyhjb25zdCBXZWJDb3JlOjpTdHJp bmcmIHMpCiAgICAgOiBtX3ByaXZhdGUoc3RhdGljX2Nhc3Q8V2ViU3RyaW5nUHJpdmF0ZSo+KHMu aW1wbCgpKSkKIHsK 47453 2010-01-26 15:27:39 -0800 2010-01-27 07:15:28 -0800 Chromium Event Listener API event_6.patch text/plain 37945 jcampan SW5kZXg6IFdlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQv Y2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiA1MzgzMykKKysrIFdlYktpdC9jaHJvbWl1bS9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMSBAQAorMjAxMC0wMS0yNSAgSmF5 IENhbXBhbiAgPGpjYW1wYW5AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBBZGRpbmcgRXZlbnRMaXN0ZW5lcnMgdG8gdGhlIGNocm9t aXVtIEFQSS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MzM4ODIKKworICAgICAgICAqIFdlYktpdC5neXA6CisgICAgICAgICogcHVibGljL1dlYkV2 ZW50Lmg6IEFkZGVkLgorICAgICAgICAqIHB1YmxpYy9XZWJFdmVudExpc3RlbmVyLmg6IEFkZGVk LgorICAgICAgICAqIHB1YmxpYy9XZWJNdXRhdGlvbkV2ZW50Lmg6IEFkZGVkLgorICAgICAgICAq IHB1YmxpYy9XZWJOb2RlLmg6CisgICAgICAgICogcHVibGljL1dlYlN0cmluZy5oOgorICAgICAg ICAoV2ViS2l0OjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6Cisg ICAgICAgICogc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcDogQWRkZWQuCisgICAgICAgICog c3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmg6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHNyYy9XZWJFdmVudExpc3RlbmVyLmNwcDogQWRkZWQu CisgICAgICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmNwcDogQWRkZWQuCisgICAg ICAgICogc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRlLmg6IEFkZGVkLgorICAgICAgICAqIHNy Yy9XZWJOb2RlLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViTm9kZTo6YWRkRXZlbnRMaXN0ZW5l cik6CisgICAgICAgIChXZWJLaXQ6OldlYk5vZGU6OnJlbW92ZUV2ZW50TGlzdGVuZXIpOgorICAg ICAgICAqIHNyYy9XZWJTdHJpbmcuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJTdHJpbmc6OmVx dWFscyk6CisKIDIwMTAtMDEtMjIgIEVsbGlvdCBHbGF5c2hlciAgPGVyZ0BjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCkluZGV4OiBXZWJLaXQvY2hyb21p dW0vV2ViS2l0Lmd5cA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CShyZXZpc2lvbiA1MzgxMykKKysrIFdlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCSh3b3JraW5n IGNvcHkpCkBAIC0xMDcsNiArMTA3LDggQEAKICAgICAgICAgICAgICAgICAncHVibGljL1dlYkRy YWdEYXRhLmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViRWRpdGluZ0FjdGlvbi5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkVsZW1lbnQuaCcsCisgICAgICAgICAgICAgICAg J3B1YmxpYy9XZWJFdmVudC5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dlYkV2ZW50TGlz dGVuZXIuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlckNvbXBsZXRp b24uaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJGaWxlQ2hvb3NlclBhcmFtcy5oJywK ICAgICAgICAgICAgICAgICAncHVibGljL1dlYkZpbmRPcHRpb25zLmgnLApAQCAtMTMwLDYgKzEz Miw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWwuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNZXNzYWdlUG9ydENoYW5uZWxDbGllbnQuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJNaW1lUmVnaXN0cnkuaCcsCisgICAgICAgICAg ICAgICAgJ3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJs aWMvV2ViTmF2aWdhdGlvblR5cGUuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJOb2Rl LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViTm9kZUNvbGxlY3Rpb24uaCcsCkBAIC0y MTAsNiArMjEzLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL0RyYWdDbGllbnRJbXBsLmgnLAog ICAgICAgICAgICAgICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5jcHAnLAogICAgICAgICAgICAg ICAgICdzcmMvRWRpdG9yQ2xpZW50SW1wbC5oJywKKyAgICAgICAgICAgICAgICAnc3JjL0V2ZW50 TGlzdGVuZXJXcmFwcGVyLmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9FdmVudExpc3RlbmVy V3JhcHBlci5oJywKICAgICAgICAgICAgICAgICAnc3JjL0ZyYW1lTG9hZGVyQ2xpZW50SW1wbC5j cHAnLAogICAgICAgICAgICAgICAgICdzcmMvRnJhbWVMb2FkZXJDbGllbnRJbXBsLmgnLAogICAg ICAgICAgICAgICAgICdzcmMvZ3RrL1dlYkZvbnRJbmZvLmNwcCcsCkBAIC0yNTksNiArMjY0LDEw IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJFbnRpdGllcy5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRW50aXRp ZXMuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJFdmVudC5jcHAnLAorICAgICAgICAgICAg ICAgICdzcmMvV2ViRXZlbnRMaXN0ZW5lci5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkV2ZW50 TGlzdGVuZXJQcml2YXRlLmgnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViRmlsZUNob29zZXJD b21wbGV0aW9uSW1wbC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkZvbnRDYWNoZS5jcHAn LApAQCAtMjc3LDYgKzI4Niw3IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJLaXQuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbC5jcHAnLAogICAg ICAgICAgICAgICAgICdzcmMvV2ViTWVkaWFQbGF5ZXJDbGllbnRJbXBsLmgnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViTXV0YXRpb25FdmVudC5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMv V2ViTm9kZS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViTm9kZUNvbGxlY3Rpb24uY3Bw JywKICAgICAgICAgICAgICAgICAnc3JjL1dlYk5vZGVMaXN0LmNwcCcsCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYkV2ZW50LmgNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQvY2hyb21pdW0vcHVi bGljL1dlYkV2ZW50LmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTE2IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJF dmVudF9oCisjZGVmaW5lIFdlYkV2ZW50X2gKKworI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2lu Y2x1ZGUgIldlYk5vZGUuaCIKKyNpbmNsdWRlICJXZWJTdHJpbmcuaCIKKworbmFtZXNwYWNlIFdl YkNvcmUgeyBjbGFzcyBFdmVudDsgfQorI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBQYXNzUmVmUHRyOyB9CisjZW5k aWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkV2ZW50IHsKK3B1YmxpYzoKKyAg ICBlbnVtIFBoYXNlVHlwZSB7CisgICAgICAgIENhcHR1cmluZ1BoYXNlICAgICA9IDEsCisgICAg ICAgIEF0VGFyZ2V0ICAgICAgICAgICA9IDIsCisgICAgICAgIEJ1YmJsaW5nUGhhc2UgICAgICA9 IDMKKyAgICB9OworCisgICAgV2ViRXZlbnQoKSA6IG1fcHJpdmF0ZSgwKSB7IH0KKyAgICBXZWJF dmVudChjb25zdCBXZWJFdmVudCYgZSkgOiBtX3ByaXZhdGUoMCkgeyBhc3NpZ24oZSk7IH0KKyAg ICBXZWJFdmVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYkV2ZW50JiBlKQorICAgIHsKKyAgICAgICAg YXNzaWduKGUpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCisgICAgV0VCS0lUX0FQ SSB2b2lkIHJlc2V0KCk7CisgICAgV0VCS0lUX0FQSSB2b2lkIGFzc2lnbihjb25zdCBXZWJFdmVu dCYpOworCisgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9wcml2YXRlOyB9CisK KyAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyB0eXBlKCkgY29uc3Q7CisgICAgV0VCS0lUX0FQSSBX ZWJOb2RlIHRhcmdldCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgV2ViTm9kZSBjdXJyZW50VGFy Z2V0KCkgY29uc3Q7CisKKyAgICBXRUJLSVRfQVBJIFBoYXNlVHlwZSBldmVudFBoYXNlKCkgY29u c3Q7CisgICAgV0VCS0lUX0FQSSBib29sIGJ1YmJsZXMoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJ IGJvb2wgY2FuY2VsYWJsZSgpIGNvbnN0OworCisgICAgV0VCS0lUX0FQSSBib29sIGlzVUlFdmVu dCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc01vdXNlRXZlbnQoKSBjb25zdDsKKyAg ICBXRUJLSVRfQVBJIGJvb2wgaXNNdXRhdGlvbkV2ZW50KCkgY29uc3Q7CisgICAgV0VCS0lUX0FQ SSBib29sIGlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1Rl eHRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0NvbXBvc2l0aW9uRXZlbnQo KSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNEcmFnRXZlbnQoKSBjb25zdDsKKyAgICBX RUJLSVRfQVBJIGJvb2wgaXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkg Ym9vbCBpc01lc3NhZ2VFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1doZWVs RXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc092ZXJmbG93RXZlbnQoKSBjb25z dDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNQYWdlVHJhbnNpdGlvbkV2ZW50KCkgY29uc3Q7Cisg ICAgV0VCS0lUX0FQSSBib29sIGlzUG9wU3RhdGVFdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9B UEkgYm9vbCBpc1Byb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wgaXNY TUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIGJvb2wg aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc1dl YktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgYm9vbCBpc0JlZm9y ZUxvYWRFdmVudCgpIGNvbnN0OworCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCisgICAgV2Vi RXZlbnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkV2ZW50PiYpOworI2VuZGlmCisK K3Byb3RlY3RlZDoKKyAgICB0eXBlZGVmIFdlYkNvcmU6OkV2ZW50IFdlYkV2ZW50UHJpdmF0ZTsK KyAgICB2b2lkIGFzc2lnbihXZWJFdmVudFByaXZhdGUqKTsKKyAgICBXZWJFdmVudFByaXZhdGUq IG1fcHJpdmF0ZTsKKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IFQqIHVud3JhcCgpCisgICAg eworICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+KG1fcHJpdmF0ZSk7CisgICAgfQorCisg ICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gY29uc3QgVCogY29uc3RVbndyYXAoKSBjb25zdAorICAg IHsKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IFQqPihtX3ByaXZhdGUpOworICAg IH0KK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6IFdlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViRXZlbnRMaXN0ZW5lci5oDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9XZWJFdmVudExpc3RlbmVyLmgJKHJldmlzaW9uIDApCisrKyBXZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYkV2ZW50TGlzdGVuZXIuaAkocmV2aXNpb24gMCkKQEAgLTAs MCArMSw2NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgV2ViRXZlbnRMaXN0ZW5lcl9oCisjZGVmaW5lIFdlYkV2ZW50TGlz dGVuZXJfaAorCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCituYW1lc3BhY2UgV2ViQ29yZSB7 IGNsYXNzIE5vZGU7IH0KKyNlbmRpZgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgRXZl bnRMaXN0ZW5lcldyYXBwZXI7CitjbGFzcyBXZWJFdmVudDsKK2NsYXNzIFdlYkV2ZW50TGlzdGVu ZXJQcml2YXRlOworY2xhc3MgV2ViTm9kZTsKK2NsYXNzIFdlYlN0cmluZzsKKworY2xhc3MgV2Vi RXZlbnRMaXN0ZW5lciB7CitwdWJsaWM6CisgICAgV2ViRXZlbnRMaXN0ZW5lcigpOworICAgIHZp cnR1YWwgfldlYkV2ZW50TGlzdGVuZXIoKTsKKworICAgIC8vIENhbGxlZCB3aGVuIGFuIGV2ZW50 IGlzIHJlY2VpdmVkLgorICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVFdmVudChjb25zdCBXZWJFdmVu dCYpID0gMDsKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIHZvaWQgbm90aWZ5RXZl bnRMaXN0ZW5lckRlbGV0ZWQoRXZlbnRMaXN0ZW5lcldyYXBwZXIqKTsKKyAgICBFdmVudExpc3Rl bmVyV3JhcHBlciogY3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBl dmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgV2ViQ29yZTo6Tm9kZSogbm9kZSk7CisgICAgRXZl bnRMaXN0ZW5lcldyYXBwZXIqIGdldEV2ZW50TGlzdGVuZXJXcmFwcGVyKGNvbnN0IFdlYlN0cmlu ZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1cmUsIFdlYkNvcmU6Ok5vZGUqIG5vZGUpOworI2Vu ZGlmCisKK3ByaXZhdGU6CisgICAgV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUqIG1fcHJpdmF0ZTsK K307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6IFdlYktpdC9jaHJv bWl1bS9wdWJsaWMvV2ViTXV0YXRpb25FdmVudC5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2No cm9taXVtL3B1YmxpYy9XZWJNdXRhdGlvbkV2ZW50LmgJKHJldmlzaW9uIDApCisrKyBXZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYk11dGF0aW9uRXZlbnQuaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0Ogor ICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisg KiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdv b2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisjaWZuZGVmIFdlYk11dGF0aW9uRXZlbnRfaAorI2RlZmluZSBXZWJNdXRhdGlvbkV2ZW50 X2gKKworI2luY2x1ZGUgIldlYkV2ZW50LmgiCisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04K K25hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3MgRXZlbnQ7IH0KKyNlbmRpZgorCituYW1lc3BhY2Ug V2ViS2l0IHsKKworY2xhc3MgV2ViTXV0YXRpb25FdmVudCA6IHB1YmxpYyBXZWJFdmVudCB7Citw dWJsaWM6CisgICAgZW51bSBBdHRyQ2hhbmdlVHlwZSB7CisgICAgICAgIE1vZGlmaWNhdGlvbiAg ICA9IDEsCisgICAgICAgIEFkZGl0aW9uICAgICAgICA9IDIsCisgICAgICAgIFJlbW92YWwgICAg ICAgICA9IDMKKyAgICB9OworCisgICAgV0VCS0lUX0FQSSBXZWJOb2RlIHJlbGF0ZWROb2RlKCkg Y29uc3Q7CisgICAgV0VCS0lUX0FQSSBXZWJTdHJpbmcgcHJldlZhbHVlKCkgY29uc3Q7CisgICAg V0VCS0lUX0FQSSBXZWJTdHJpbmcgbmV3VmFsdWUoKSBjb25zdDsKKyAgICBXRUJLSVRfQVBJIFdl YlN0cmluZyBhdHRyTmFtZSgpIGNvbnN0OworICAgIFdFQktJVF9BUEkgQXR0ckNoYW5nZVR5cGUg YXR0ckNoYW5nZSgpIGNvbnN0OworCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCisgICAgV2Vi TXV0YXRpb25FdmVudChjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6RXZlbnQ+Jik7Cisj ZW5kaWYKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKSW5kZXg6IFdlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViTm9kZS5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJOb2RlLmgJKHJldmlzaW9uIDUzODEzKQorKysgV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJOb2RlLmgJKHdvcmtpbmcgY29weSkKQEAgLTQxLDYgKzQxLDggQEAgbmFtZXNw YWNlIFdURiB7IHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbAogCiBuYW1lc3BhY2UgV2ViS2l0IHsK IGNsYXNzIFdlYkRvY3VtZW50OworY2xhc3MgV2ViRXZlbnRMaXN0ZW5lcjsKK2NsYXNzIFdlYkV2 ZW50TGlzdGVuZXJQcml2YXRlOwogY2xhc3MgV2ViRnJhbWU7CiBjbGFzcyBXZWJOb2RlTGlzdDsK IApAQCAtMTAwLDYgKzEwMiw4IEBAIHB1YmxpYzoKICAgICBXRUJLSVRfQVBJIFdlYlN0cmluZyBj cmVhdGVNYXJrdXAoKSBjb25zdDsKICAgICBXRUJLSVRfQVBJIGJvb2wgaXNUZXh0Tm9kZSgpIGNv bnN0OwogICAgIFdFQktJVF9BUEkgYm9vbCBpc0VsZW1lbnROb2RlKCkgY29uc3Q7CisgICAgV0VC S0lUX0FQSSB2b2lkIGFkZEV2ZW50TGlzdGVuZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUs IFdlYkV2ZW50TGlzdGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNhcHR1cmUpOworICAgIFdFQktJ VF9BUEkgdm9pZCByZW1vdmVFdmVudExpc3RlbmVyKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBl LCBXZWJFdmVudExpc3RlbmVyKiBsaXN0ZW5lciwgYm9vbCB1c2VDYXB0dXJlKTsKIAogICAgIHRl bXBsYXRlPHR5cGVuYW1lIFQ+IFQgdG9FbGVtZW50KCkKICAgICB7CkluZGV4OiBXZWJLaXQvY2hy b21pdW0vcHVibGljL1dlYlN0cmluZy5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJTdHJpbmcuaAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0v cHVibGljL1dlYlN0cmluZy5oCSh3b3JraW5nIGNvcHkpCkBAIC03Niw2ICs3Niw4IEBAIHB1Ymxp YzoKICAgICBXRUJLSVRfQVBJIHZvaWQgYXNzaWduKGNvbnN0IFdlYlN0cmluZyYpOwogICAgIFdF QktJVF9BUEkgdm9pZCBhc3NpZ24oY29uc3QgV2ViVUNoYXIqIGRhdGEsIHNpemVfdCBsZW4pOwog CisgICAgV0VCS0lUX0FQSSBib29sIGVxdWFscyhjb25zdCBXZWJTdHJpbmcmIHMpIGNvbnN0Owor CiAgICAgV0VCS0lUX0FQSSBzaXplX3QgbGVuZ3RoKCkgY29uc3Q7CiAgICAgV0VCS0lUX0FQSSBj b25zdCBXZWJVQ2hhciogZGF0YSgpIGNvbnN0OwogCkBAIC0xNjMsNiArMTY1LDE2IEBAIHByaXZh dGU6CiAgICAgV2ViU3RyaW5nUHJpdmF0ZSogbV9wcml2YXRlOwogfTsKIAoraW5saW5lIGJvb2wg b3BlcmF0b3I9PShjb25zdCBXZWJTdHJpbmcmIGEsIGNvbnN0IFdlYlN0cmluZyYgYikKK3sKKyAg ICByZXR1cm4gYS5lcXVhbHMoYik7Cit9CisKK2lubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3Qg V2ViU3RyaW5nJiBhLCBjb25zdCBXZWJTdHJpbmcmIGIpCit7CisgICAgcmV0dXJuICEoYSA9PSBi KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CiAKICNlbmRpZgpJbmRleDogV2ViS2l0L2No cm9taXVtL3NyYy9FdmVudExpc3RlbmVyV3JhcHBlci5jcHANCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJL aXQvY2hyb21pdW0vc3JjL0V2ZW50TGlzdGVuZXJXcmFwcGVyLmNwcAkocmV2aXNpb24gMCkKKysr IFdlYktpdC9jaHJvbWl1bS9zcmMvRXZlbnRMaXN0ZW5lcldyYXBwZXIuY3BwCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDcyIEBACisvKg0KKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5j LiBBbGwgcmlnaHRzIHJlc2VydmVkLg0KKyAqDQorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0DQorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z IGFyZQ0KKyAqIG1ldDoNCisgKg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0DQorICogbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLg0KKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUN CisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyDQorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQ0KKyAqIGRpc3RyaWJ1dGlvbi4NCisgKiAgICAg KiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzDQor ICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkIGZyb20NCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLg0KKyAqDQorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUw0KKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UDQor ICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SDQorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQNCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwNCisgKiBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UDQorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsDQorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZDQorICogVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VA0KKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQ0KKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuDQorICovDQorDQorI2luY2x1ZGUg ImNvbmZpZy5oIg0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVyV3JhcHBlci5oIg0KKw0KKyNpbmNs dWRlICJFdmVudC5oIg0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVyLmgiDQorDQorI2luY2x1ZGUg IldlYkV2ZW50LmgiDQorI2luY2x1ZGUgIldlYkV2ZW50TGlzdGVuZXIuaCINCisNCituYW1lc3Bh Y2UgV2ViS2l0IHsNCisNCitFdmVudExpc3RlbmVyV3JhcHBlcjo6RXZlbnRMaXN0ZW5lcldyYXBw ZXIoV2ViRXZlbnRMaXN0ZW5lciogd2ViRXZlbnRMaXN0ZW5lcikNCisgICAgOiBFdmVudExpc3Rl bmVyKEV2ZW50TGlzdGVuZXI6OkpTRXZlbnRMaXN0ZW5lclR5cGUpDQorICAgICwgbV93ZWJFdmVu dExpc3RlbmVyKHdlYkV2ZW50TGlzdGVuZXIpDQorew0KK30NCisNCitFdmVudExpc3RlbmVyV3Jh cHBlcjo6fkV2ZW50TGlzdGVuZXJXcmFwcGVyKCkNCit7DQorICAgIGlmIChtX3dlYkV2ZW50TGlz dGVuZXIpDQorICAgICAgICBtX3dlYkV2ZW50TGlzdGVuZXItPm5vdGlmeUV2ZW50TGlzdGVuZXJE ZWxldGVkKHRoaXMpOw0KK30NCisNCitib29sIEV2ZW50TGlzdGVuZXJXcmFwcGVyOjpvcGVyYXRv cj09KGNvbnN0IEV2ZW50TGlzdGVuZXImIGxpc3RlbmVyKQ0KK3sNCisgICAgcmV0dXJuIHRoaXMg PT0gJmxpc3RlbmVyOw0KK30NCisNCit2b2lkIEV2ZW50TGlzdGVuZXJXcmFwcGVyOjpoYW5kbGVF dmVudChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBFdmVudCogZXZlbnQpDQorew0K KyAgICBpZiAoIW1fd2ViRXZlbnRMaXN0ZW5lcikNCisgICAgICAgIHJldHVybjsNCisgICAgV2Vi RXZlbnQgd2ViRXZlbnQoZXZlbnQpOw0KKyAgICBtX3dlYkV2ZW50TGlzdGVuZXItPmhhbmRsZUV2 ZW50KHdlYkV2ZW50KTsNCit9DQorDQordm9pZCBFdmVudExpc3RlbmVyV3JhcHBlcjo6d2ViRXZl bnRMaXN0ZW5lckRlbGV0ZWQoKQ0KK3sNCisgICAgbV93ZWJFdmVudExpc3RlbmVyID0gMDsNCit9 DQorDQorfSAvLyBuYW1lc3BhY2UgV2ViS2l0DQpJbmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9F dmVudExpc3RlbmVyV3JhcHBlci5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVtL3Ny Yy9FdmVudExpc3RlbmVyV3JhcHBlci5oCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVt L3NyYy9FdmVudExpc3RlbmVyV3JhcHBlci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYyIEBA CisvKg0KKyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2Vy dmVkLg0KKyAqDQorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0DQorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQ0KKyAqIG1ldDoNCisg Kg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0DQorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUNCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy DQorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQ0KKyAqIGRpc3RyaWJ1dGlvbi4NCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1l IG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzDQorICogY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20NCisg KiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9u Lg0KKyAqDQorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUw0KKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SDQor ICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IFRIRSBDT1BZUklHSFQNCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwNCisgKiBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsDQorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZDQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhF UiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVA0KKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RQ0KKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuDQorICovDQorDQorI2lmbmRlZiBFdmVudExpc3RlbmVyV3JhcHBl cl9oDQorI2RlZmluZSBFdmVudExpc3RlbmVyV3JhcHBlcl9oDQorDQorI2luY2x1ZGUgIkV2ZW50 TGlzdGVuZXIuaCINCisNCituYW1lc3BhY2UgV2ViQ29yZSB7DQorY2xhc3MgU2NyaXB0RXhlY3V0 aW9uQ29udGV4dDsNCit9DQorDQordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7DQorDQorbmFtZXNw YWNlIFdlYktpdCB7DQorDQorY2xhc3MgV2ViRXZlbnRMaXN0ZW5lcjsNCisNCitjbGFzcyBFdmVu dExpc3RlbmVyV3JhcHBlciA6IHB1YmxpYyBFdmVudExpc3RlbmVyIHsNCitwdWJsaWM6DQorICAg IEV2ZW50TGlzdGVuZXJXcmFwcGVyKFdlYkV2ZW50TGlzdGVuZXIqKTsNCisgICAgfkV2ZW50TGlz dGVuZXJXcmFwcGVyKCk7DQorDQorICAgIHZpcnR1YWwgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEV2 ZW50TGlzdGVuZXImKTsNCisgICAgdmlydHVhbCB2b2lkIGhhbmRsZUV2ZW50KFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQqLCBFdmVudCopOw0KKw0KKyAgICB2b2lkIHdlYkV2ZW50TGlzdGVuZXJEZWxl dGVkKCk7DQorDQorcHJpdmF0ZToNCisgICAgV2ViRXZlbnRMaXN0ZW5lciogbV93ZWJFdmVudExp c3RlbmVyOw0KK307DQorDQorfSAvLyBuYW1lc3BhY2UgV2ViS2l0DQorDQorI2VuZGlmDQpJbmRl eDogV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudC5jcHANCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJL aXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJv bWl1bS9zcmMvV2ViRXZlbnQuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDIyMCBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBk aXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5v ciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3Jz ZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJXZWJFdmVudC5oIgorCisjaW5jbHVkZSAiRXZlbnQu aCIKKyNpbmNsdWRlICJOb2RlLmgiCisjaW5jbHVkZSAiV2ViTXV0YXRpb25FdmVudC5oIgorI2lu Y2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBX ZWJFdmVudFByaXZhdGUgOiBwdWJsaWMgV2ViQ29yZTo6RXZlbnQgeworfTsKKwordm9pZCBXZWJF dmVudDo6cmVzZXQoKQoreworICAgIGFzc2lnbigwKTsKK30KKwordm9pZCBXZWJFdmVudDo6YXNz aWduKGNvbnN0IFdlYkV2ZW50JiBvdGhlcikKK3sKKyAgICBXZWJFdmVudFByaXZhdGUqIHAgPSBj b25zdF9jYXN0PFdlYkV2ZW50UHJpdmF0ZSo+KG90aGVyLm1fcHJpdmF0ZSk7CisgICAgaWYgKHAp CisgICAgICAgIHAtPnJlZigpOworICAgIGFzc2lnbihwKTsKK30KKwordm9pZCBXZWJFdmVudDo6 YXNzaWduKFdlYkV2ZW50UHJpdmF0ZSogcCkKK3sKKyAgICAvLyBwIGlzIGFscmVhZHkgcmVmJ2Qg Zm9yIHVzIGJ5IHRoZSBjYWxsZXIKKyAgICBpZiAobV9wcml2YXRlKQorICAgICAgICBtX3ByaXZh dGUtPmRlcmVmKCk7CisgICAgbV9wcml2YXRlID0gcDsKK30KKworV2ViRXZlbnQ6OldlYkV2ZW50 KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpFdmVudD4mIGV2ZW50KQorICAgIDogbV9w cml2YXRlKHN0YXRpY19jYXN0PFdlYkV2ZW50UHJpdmF0ZSo+KGV2ZW50LnJlbGVhc2VSZWYoKSkp Cit7Cit9CisKK1dlYlN0cmluZyBXZWJFdmVudDo6dHlwZSgpIGNvbnN0Cit7CisgICAgQVNTRVJU KG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+dHlwZSgpOworfQorCitXZWJOb2Rl IFdlYkV2ZW50Ojp0YXJnZXQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAg IHJldHVybiBXZWJOb2RlKG1fcHJpdmF0ZS0+dGFyZ2V0KCktPnRvTm9kZSgpKTsKK30KKworV2Vi Tm9kZSBXZWJFdmVudDo6Y3VycmVudFRhcmdldCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJp dmF0ZSk7CisgICAgcmV0dXJuIFdlYk5vZGUobV9wcml2YXRlLT5jdXJyZW50VGFyZ2V0KCktPnRv Tm9kZSgpKTsKK30KKworV2ViRXZlbnQ6OlBoYXNlVHlwZSBXZWJFdmVudDo6ZXZlbnRQaGFzZSgp IGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0 PFdlYkV2ZW50OjpQaGFzZVR5cGU+KG1fcHJpdmF0ZS0+ZXZlbnRQaGFzZSgpKTsKK30KKworYm9v bCBXZWJFdmVudDo6YnViYmxlcygpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7Cisg ICAgcmV0dXJuIG1fcHJpdmF0ZS0+YnViYmxlcygpOworfQorCitib29sIFdlYkV2ZW50OjpjYW5j ZWxhYmxlKCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9w cml2YXRlLT5jYW5jZWxhYmxlKCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzVUlFdmVudCgpIGNv bnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNV SUV2ZW50KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzTW91c2VFdmVudCgpIGNvbnN0Cit7Cisg ICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNNb3VzZUV2ZW50 KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzTXV0YXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAg QVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNNdXRhdGlvbkV2ZW50 KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzS2V5Ym9hcmRFdmVudCgpIGNvbnN0Cit7CisgICAg QVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNLZXlib2FyZEV2ZW50 KCk7Cit9CisKK2Jvb2wgV2ViRXZlbnQ6OmlzVGV4dEV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NF UlQobV9wcml2YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1RleHRFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc0NvbXBvc2l0aW9uRXZlbnQoKSBjb25zdAoreworICAgIEFTU0VS VChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzQ29tcG9zaXRpb25FdmVudCgp OworfQorCitib29sIFdlYkV2ZW50Ojppc0RyYWdFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJU KG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNEcmFnRXZlbnQoKTsKK30KKwor Ym9vbCBXZWJFdmVudDo6aXNDbGlwYm9hcmRFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1f cHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNDbGlwYm9hcmRFdmVudCgpOworfQor Citib29sIFdlYkV2ZW50Ojppc01lc3NhZ2VFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1f cHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNNZXNzYWdlRXZlbnQoKTsKK30KKwor Ym9vbCBXZWJFdmVudDo6aXNXaGVlbEV2ZW50KCkgY29uc3QKK3sKKyAgICBBU1NFUlQobV9wcml2 YXRlKTsKKyAgICByZXR1cm4gbV9wcml2YXRlLT5pc1doZWVsRXZlbnQoKTsKK30KKworYm9vbCBX ZWJFdmVudDo6aXNCZWZvcmVUZXh0SW5zZXJ0ZWRFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJU KG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNCZWZvcmVUZXh0SW5zZXJ0ZWRF dmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc092ZXJmbG93RXZlbnQoKSBjb25zdAorewor ICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzT3ZlcmZsb3dF dmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1BhZ2VUcmFuc2l0aW9uRXZlbnQoKSBjb25z dAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUtPmlzUGFn ZVRyYW5zaXRpb25FdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1BvcFN0YXRlRXZlbnQo KSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUt PmlzUG9wU3RhdGVFdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1Byb2dyZXNzRXZlbnQo KSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZhdGUt PmlzUHJvZ3Jlc3NFdmVudCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1hNTEh0dHBSZXF1ZXN0 UHJvZ3Jlc3NFdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0 dXJuIG1fcHJpdmF0ZS0+aXNYTUxIdHRwUmVxdWVzdFByb2dyZXNzRXZlbnQoKTsKK30KKworYm9v bCBXZWJFdmVudDo6aXNXZWJLaXRBbmltYXRpb25FdmVudCgpIGNvbnN0Cit7CisgICAgQVNTRVJU KG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNXZWJLaXRBbmltYXRpb25FdmVu dCgpOworfQorCitib29sIFdlYkV2ZW50Ojppc1dlYktpdFRyYW5zaXRpb25FdmVudCgpIGNvbnN0 Cit7CisgICAgQVNTRVJUKG1fcHJpdmF0ZSk7CisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNXZWJL aXRUcmFuc2l0aW9uRXZlbnQoKTsKK30KKworYm9vbCBXZWJFdmVudDo6aXNCZWZvcmVMb2FkRXZl bnQoKSBjb25zdAoreworICAgIEFTU0VSVChtX3ByaXZhdGUpOworICAgIHJldHVybiBtX3ByaXZh dGUtPmlzQmVmb3JlTG9hZEV2ZW50KCk7Cit9CisKK30KSW5kZXg6IFdlYktpdC9jaHJvbWl1bS9z cmMvV2ViRXZlbnRMaXN0ZW5lci5jcHANCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0v c3JjL1dlYkV2ZW50TGlzdGVuZXIuY3BwCShyZXZpc2lvbiAwKQorKysgV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJFdmVudExpc3RlbmVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw2NCBAQAor LyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUNCisgKiBtZXQ6DQorICoN CisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlDQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcg0K KyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBv ZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0KKyAqIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tDQorICog dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4N CisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xE RVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUg0KKyAq IEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBU SEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVA0KKyAqIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQNCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UN CisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZ IE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpbmNsdWRlICJjb25maWcuaCINCisjaW5jbHVk ZSAiV2ViRXZlbnRMaXN0ZW5lci5oIg0KKw0KKyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyUHJp dmF0ZS5oIg0KKw0KK25hbWVzcGFjZSBXZWJLaXQgew0KKw0KK1dlYkV2ZW50TGlzdGVuZXI6Oldl YkV2ZW50TGlzdGVuZXIoKQ0KKyAgICA6IG1fcHJpdmF0ZShuZXcgV2ViRXZlbnRMaXN0ZW5lclBy aXZhdGUodGhpcykpDQorew0KK30NCisNCitXZWJFdmVudExpc3RlbmVyOjp+V2ViRXZlbnRMaXN0 ZW5lcigpDQorew0KKyAgICBtX3ByaXZhdGUtPndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCk7DQor ICAgIGRlbGV0ZSBtX3ByaXZhdGU7DQorfQ0KKw0KK3ZvaWQgV2ViRXZlbnRMaXN0ZW5lcjo6bm90 aWZ5RXZlbnRMaXN0ZW5lckRlbGV0ZWQoRXZlbnRMaXN0ZW5lcldyYXBwZXIqIHdyYXBwZXIpDQor ew0KKyAgICBtX3ByaXZhdGUtPmV2ZW50TGlzdGVuZXJEZWxldGVkKHdyYXBwZXIpOw0KK30NCisN CitFdmVudExpc3RlbmVyV3JhcHBlciogV2ViRXZlbnRMaXN0ZW5lcjo6Y3JlYXRlRXZlbnRMaXN0 ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwg Tm9kZSogbm9kZSkNCit7DQorICAgIHJldHVybiBtX3ByaXZhdGUtPmNyZWF0ZUV2ZW50TGlzdGVu ZXJXcmFwcGVyKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwgbm9kZSk7DQorfQ0KKw0KK0V2ZW50TGlz dGVuZXJXcmFwcGVyKiBXZWJFdmVudExpc3RlbmVyOjpnZXRFdmVudExpc3RlbmVyV3JhcHBlcihj b25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2RlKiBub2RlKQ0K K3sNCisgICAgcmV0dXJuIG1fcHJpdmF0ZS0+Z2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRU eXBlLCB1c2VDYXB0dXJlLCBub2RlKTsNCit9DQorDQorfSAvLyBuYW1lc3BhY2UgV2ViS2l0DQpJ bmRleDogV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJFdmVudExpc3RlbmVyUHJpdmF0ZS5jcHANCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYkV2ZW50TGlzdGVuZXJQcml2YXRl LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5l clByaXZhdGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg3IEBACisvKg0KKyAqIENvcHly aWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLg0KKyAqDQorICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0DQorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQ0KKyAqIG1ldDoNCisgKg0KKyAqICAgICAqIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0DQorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLg0KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUNCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyDQorICogaW4gdGhlIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQ0KKyAq IGRpc3RyaWJ1dGlvbi4NCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMu IG5vciB0aGUgbmFtZXMgb2YgaXRzDQorICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20NCisgKiB0aGlzIHNvZnR3YXJl IHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLg0KKyAqDQorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUw0KKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SDQorICogQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQN CisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwNCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UDQorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsDQorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZDQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVA0KKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQ0KKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuDQorICovDQorDQorI2luY2x1ZGUgImNvbmZpZy5oIg0KKyNpbmNsdWRlICJXZWJFdmVudExp c3RlbmVyUHJpdmF0ZS5oIg0KKw0KKyNpbmNsdWRlICJFdmVudExpc3RlbmVyV3JhcHBlci5oIg0K KyNpbmNsdWRlICJXZWJFdmVudExpc3RlbmVyLmgiDQorDQorbmFtZXNwYWNlIFdlYktpdCB7DQor DQorV2ViRXZlbnRMaXN0ZW5lclByaXZhdGU6OldlYkV2ZW50TGlzdGVuZXJQcml2YXRlKFdlYkV2 ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpDQorICAgIDogbV93ZWJFdmVudExpc3RlbmVy KHdlYkV2ZW50TGlzdGVuZXIpDQorew0KK30NCisNCitXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6 fldlYkV2ZW50TGlzdGVuZXJQcml2YXRlKCkNCit7DQorfQ0KKw0KK0V2ZW50TGlzdGVuZXJXcmFw cGVyKiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Y3JlYXRlRXZlbnRMaXN0ZW5lcldyYXBwZXIo Y29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSkN Cit7DQorICAgIEV2ZW50TGlzdGVuZXJXcmFwcGVyKiBsaXN0ZW5lcldyYXBwZXIgPSBuZXcgRXZl bnRMaXN0ZW5lcldyYXBwZXIobV93ZWJFdmVudExpc3RlbmVyKTsNCisgICAgV2ViRXZlbnRMaXN0 ZW5lclByaXZhdGU6Okxpc3RlbmVySW5mbyBsaXN0ZW5lckluZm8oZXZlbnRUeXBlLCB1c2VDYXB0 dXJlLCBsaXN0ZW5lcldyYXBwZXIsIG5vZGUpOw0KKyAgICBtX2xpc3RlbmVyV3JhcHBlcnMuYXBw ZW5kKGxpc3RlbmVySW5mbyk7DQorICAgIHJldHVybiBsaXN0ZW5lcldyYXBwZXI7DQorfQ0KKw0K K0V2ZW50TGlzdGVuZXJXcmFwcGVyKiBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6Z2V0RXZlbnRM aXN0ZW5lcldyYXBwZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIGJvb2wgdXNlQ2FwdHVy ZSwgTm9kZSogbm9kZSkNCit7DQorICAgIFZlY3RvcjxXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6 TGlzdGVuZXJJbmZvPjo6Y29uc3RfaXRlcmF0b3IgaXRlcjsNCisgICAgZm9yIChpdGVyID0gbV9s aXN0ZW5lcldyYXBwZXJzLmJlZ2luKCk7IGl0ZXIgIT0gbV9saXN0ZW5lcldyYXBwZXJzLmVuZCgp OyArK2l0ZXIpIHsNCisgICAgICAgIGlmIChpdGVyLT5ub2RlID09IG5vZGUpDQorICAgICAgICAg IHJldHVybiBpdGVyLT5ldmVudExpc3RlbmVyV3JhcHBlcjsNCisgICAgfQ0KKyAgICBBU1NFUlRf Tk9UX1JFQUNIRUQoKTsNCisgICAgcmV0dXJuIDA7DQorfQ0KKw0KK3ZvaWQgV2ViRXZlbnRMaXN0 ZW5lclByaXZhdGU6OndlYkV2ZW50TGlzdGVuZXJEZWxldGVkKCkNCit7DQorICAgIC8vIE5vdGlm aWVzIGFsbCBXZWJFdmVudExpc3RlbmVyV3JhcHBlcnMgdGhhdCB3ZSBhcmUgZ29pbmcgYXdheSBz byB0aGV5IGNhbg0KKyAgICAvLyBpbnZhbGlkYXRlIHRoZWlyIHBvaW50ZXIgdG8gdXMuDQorICAg IFZlY3RvcjxXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6TGlzdGVuZXJJbmZvPjo6Y29uc3RfaXRl cmF0b3IgaXRlcjsNCisgICAgZm9yIChpdGVyID0gbV9saXN0ZW5lcldyYXBwZXJzLmJlZ2luKCk7 IGl0ZXIgIT0gbV9saXN0ZW5lcldyYXBwZXJzLmVuZCgpOyArK2l0ZXIpDQorICAgICAgICBpdGVy LT5ldmVudExpc3RlbmVyV3JhcHBlci0+d2ViRXZlbnRMaXN0ZW5lckRlbGV0ZWQoKTsNCit9DQor DQordm9pZCBXZWJFdmVudExpc3RlbmVyUHJpdmF0ZTo6ZXZlbnRMaXN0ZW5lckRlbGV0ZWQoRXZl bnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXIpDQorew0KKyAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IG1fbGlzdGVuZXJXcmFwcGVycy5zaXplKCk7ICsraSkgew0KKyAgICAgICAgaWYg KG1fbGlzdGVuZXJXcmFwcGVyc1tpXS5ldmVudExpc3RlbmVyV3JhcHBlciA9PSBldmVudExpc3Rl bmVyKSB7DQorICAgICAgICAgICAgbV9saXN0ZW5lcldyYXBwZXJzLnJlbW92ZShpKTsNCisgICAg ICAgICAgICByZXR1cm47DQorICAgICAgICB9DQorICAgIH0NCisgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7DQorfQ0KKw0KK30gLy8gbmFtZXNwYWNlIFdlYktpdA0KSW5kZXg6IFdlYktpdC9jaHJv bWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaA0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktp dC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaAkocmV2aXNpb24gMCkKKysr IFdlYktpdC9jaHJvbWl1bS9zcmMvV2ViRXZlbnRMaXN0ZW5lclByaXZhdGUuaAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw5NSBAQAorLyoNCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4NCisgKg0KKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dA0KKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cyBhcmUNCisgKiBtZXQ6DQorICoNCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodA0KKyAqIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCisgKiAgICAg KiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl DQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lcg0KKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUNCisgKiBkaXN0cmlidXRpb24uDQorICogICAg ICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cw0K KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tDQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9y IHdyaXR0ZW4gcGVybWlzc2lvbi4NCisgKg0KKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMNCisgKiAiQVMgSVMiIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVA0K KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUg0KKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUDQorICogT1dORVIgT1IgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsDQorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVA0KKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLA0KKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQ0KKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQNCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UNCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLg0KKyAqLw0KKw0KKyNpZm5kZWYg V2ViRXZlbnRMaXN0ZW5lclByaXZhdGVfaA0KKyNkZWZpbmUgV2ViRXZlbnRMaXN0ZW5lclByaXZh dGVfaA0KKw0KKyNpbmNsdWRlICJXZWJTdHJpbmcuaCINCisNCisjaW5jbHVkZSA8d3RmL1ZlY3Rv ci5oPg0KKw0KK25hbWVzcGFjZSBXZWJDb3JlIHsNCitjbGFzcyBOb2RlOw0KK30NCisNCit1c2lu ZyBuYW1lc3BhY2UgV2ViQ29yZTsNCisNCituYW1lc3BhY2UgV2ViS2l0IHsNCisNCitjbGFzcyBF dmVudExpc3RlbmVyV3JhcHBlcjsNCitjbGFzcyBXZWJFdmVudExpc3RlbmVyOw0KKw0KK2NsYXNz IFdlYkV2ZW50TGlzdGVuZXJQcml2YXRlIHsNCitwdWJsaWM6DQorICAgIFdlYkV2ZW50TGlzdGVu ZXJQcml2YXRlKFdlYkV2ZW50TGlzdGVuZXIqIHdlYkV2ZW50TGlzdGVuZXIpOw0KKyAgICB+V2Vi RXZlbnRMaXN0ZW5lclByaXZhdGUoKTsNCisNCisgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGNy ZWF0ZUV2ZW50TGlzdGVuZXJXcmFwcGVyKA0KKyAgICAgICAgY29uc3QgV2ViU3RyaW5nJiBldmVu dFR5cGUsIGJvb2wgdXNlQ2FwdHVyZSwgTm9kZSogbm9kZSk7DQorDQorICAgIC8vIEdldHMgdGhl IExpc3RlbmVyRXZlbnRXcmFwcGVyIGZvciBhIHNwZWNpZmljIG5vZGUuDQorICAgIC8vIFVzZWQg YnkgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0ZW5lcigpLg0KKyAgICBFdmVudExpc3RlbmVyV3Jh cHBlciogZ2V0RXZlbnRMaXN0ZW5lcldyYXBwZXIoDQorICAgICAgICBjb25zdCBXZWJTdHJpbmcm IGV2ZW50VHlwZSwgYm9vbCB1c2VDYXB0dXJlLCBOb2RlKiBub2RlKTsNCisNCisgICAgLy8gQ2Fs bGVkIGJ5IHRoZSBXZWJFdmVudExpc3RlbmVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVsZXRl ZC4NCisgICAgdm9pZCB3ZWJFdmVudExpc3RlbmVyRGVsZXRlZCgpOw0KKw0KKyAgICAvLyBDYWxs ZWQgYnkgdGhlIEV2ZW50TGlzdGVuZXJXcmFwcGVyIHdoZW4gaXQgaXMgYWJvdXQgdG8gYmUgZGVs ZXRlZC4NCisgICAgdm9pZCBldmVudExpc3RlbmVyRGVsZXRlZChFdmVudExpc3RlbmVyV3JhcHBl ciogZXZlbnRMaXN0ZW5lcik7DQorDQorICAgIHN0cnVjdCBMaXN0ZW5lckluZm8gew0KKyAgICAg ICAgTGlzdGVuZXJJbmZvKGNvbnN0IFdlYlN0cmluZyYgZXZlbnRUeXBlLCBib29sIHVzZUNhcHR1 cmUsDQorICAgICAgICAgICAgICAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlz dGVuZXJXcmFwcGVyLA0KKyAgICAgICAgICAgICAgICAgICAgIE5vZGUqIG5vZGUpDQorICAgICAg ICAgICAgOiBldmVudFR5cGUoZXZlbnRUeXBlKQ0KKyAgICAgICAgICAgICwgdXNlQ2FwdHVyZSh1 c2VDYXB0dXJlKQ0KKyAgICAgICAgICAgICwgZXZlbnRMaXN0ZW5lcldyYXBwZXIoZXZlbnRMaXN0 ZW5lcldyYXBwZXIpDQorICAgICAgICAgICAgLCBub2RlKG5vZGUpDQorICAgICAgICB7DQorICAg ICAgICB9DQorDQorICAgICAgICBXZWJTdHJpbmcgZXZlbnRUeXBlOw0KKyAgICAgICAgYm9vbCB1 c2VDYXB0dXJlOw0KKyAgICAgICAgRXZlbnRMaXN0ZW5lcldyYXBwZXIqIGV2ZW50TGlzdGVuZXJX cmFwcGVyOw0KKyAgICAgICAgTm9kZSogbm9kZTsNCisgICAgfTsNCisNCitwcml2YXRlOg0KKyAg ICBXZWJFdmVudExpc3RlbmVyKiBtX3dlYkV2ZW50TGlzdGVuZXI7DQorDQorICAgIC8vIFdlIGtl ZXAgYSBsaXN0IG9mIHRoZSB3cmFwcGVyIGZvciB0aGUgV2ViS2l0IEV2ZW50TGlzdGVuZXIsIGl0 IGlzIG5lZWRlZA0KKyAgICAvLyB0byBpbXBsZW1lbnQgV2ViTm9kZTo6cmVtb3ZlRXZlbnRMaXN0 ZW5lcigpLg0KKyAgICBWZWN0b3I8TGlzdGVuZXJJbmZvPiBtX2xpc3RlbmVyV3JhcHBlcnM7DQor fTsNCisNCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQNCisNCisjZW5kaWYNCkluZGV4OiBXZWJLaXQv Y2hyb21pdW0vc3JjL1dlYk5vZGUuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJOb2RlLmNwcAkocmV2aXNpb24gNTM4MTMpCisrKyBXZWJLaXQvY2hyb21pdW0vc3Jj L1dlYk5vZGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zNyw3ICszNywxMCBAQAogI2luY2x1ZGUg Ik5vZGUuaCIKICNpbmNsdWRlICJOb2RlTGlzdC5oIgogCisjaW5jbHVkZSAiRXZlbnRMaXN0ZW5l cldyYXBwZXIuaCIKICNpbmNsdWRlICJXZWJEb2N1bWVudC5oIgorI2luY2x1ZGUgIldlYkV2ZW50 LmgiCisjaW5jbHVkZSAiV2ViRXZlbnRMaXN0ZW5lci5oIgogI2luY2x1ZGUgIldlYkZyYW1lSW1w bC5oIgogI2luY2x1ZGUgIldlYk5vZGVMaXN0LmgiCiAjaW5jbHVkZSAiV2ViU3RyaW5nLmgiCkBA IC0xNzMsNCArMTc2LDIyIEBAIGJvb2wgV2ViTm9kZTo6aXNFbGVtZW50Tm9kZSgpIGNvbnN0CiAg ICAgcmV0dXJuIG1fcHJpdmF0ZS0+aXNFbGVtZW50Tm9kZSgpOwogfQogCit2b2lkIFdlYk5vZGU6 OmFkZEV2ZW50TGlzdGVuZXIoY29uc3QgV2ViU3RyaW5nJiBldmVudFR5cGUsIFdlYkV2ZW50TGlz dGVuZXIqIGxpc3RlbmVyLCBib29sIHVzZUNhcHR1cmUpCit7CisgICAgRXZlbnRMaXN0ZW5lcldy YXBwZXIqIGxpc3RlbmVyV3JhcHBlciA9CisgICAgICAgIGxpc3RlbmVyLT5jcmVhdGVFdmVudExp c3RlbmVyV3JhcHBlcihldmVudFR5cGUsIHVzZUNhcHR1cmUsIG1fcHJpdmF0ZSk7CisgICAgLy8g VGhlIGxpc3RlbmVyV3JhcHBlciBpcyBvbmx5IHJlZmVyZW5jZWQgYnkgdGhlIGFjdHVhbCBOb2Rl LiAgT25jZSBpdCBnb2VzCisgICAgLy8gYXdheSwgdGhlIHdyYXBwZXIgbm90aWZpZXMgdGhlIFdl YkV2ZW50TGlzdGVuZXIgc28gaXQgY2FuIGNsZWFyIGl0cworICAgIC8vIHBvaW50ZXIgdG8gaXQu CisgICAgbV9wcml2YXRlLT5hZGRFdmVudExpc3RlbmVyKGV2ZW50VHlwZSwgYWRvcHRSZWYobGlz dGVuZXJXcmFwcGVyKSwgdXNlQ2FwdHVyZSk7Cit9CisKK3ZvaWQgV2ViTm9kZTo6cmVtb3ZlRXZl bnRMaXN0ZW5lcihjb25zdCBXZWJTdHJpbmcmIGV2ZW50VHlwZSwgV2ViRXZlbnRMaXN0ZW5lciog bGlzdGVuZXIsIGJvb2wgdXNlQ2FwdHVyZSkKK3sKKyAgICBFdmVudExpc3RlbmVyV3JhcHBlciog bGlzdGVuZXJXcmFwcGVyID0KKyAgICAgICAgbGlzdGVuZXItPmdldEV2ZW50TGlzdGVuZXJXcmFw cGVyKGV2ZW50VHlwZSwgdXNlQ2FwdHVyZSwgbV9wcml2YXRlKTsKKyAgICBtX3ByaXZhdGUtPnJl bW92ZUV2ZW50TGlzdGVuZXIoZXZlbnRUeXBlLCBsaXN0ZW5lcldyYXBwZXIsIHVzZUNhcHR1cmUp OworICAgIC8vIGxpc3RlbmVyV3JhcHBlciBpcyBub3cgZGVsZXRlZC4KK30KKwogfSAvLyBuYW1l c3BhY2UgV2ViS2l0CkluZGV4OiBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0cmluZy5jcHANCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBXZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0cmluZy5jcHAJKHJldmlzaW9u IDUzODEzKQorKysgV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJTdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC04Niw2ICs4NiwxMSBAQCBXZWJTdHJpbmcgV2ViU3RyaW5nOjpmcm9tVVRGOChjb25z dCBjaGFyCiAgICAgcmV0dXJuIFdlYkNvcmU6OlN0cmluZzo6ZnJvbVVURjgoZGF0YSk7CiB9CiAK K2Jvb2wgV2ViU3RyaW5nOjplcXVhbHMoY29uc3QgV2ViU3RyaW5nJiBzKSBjb25zdAoreworICAg IHJldHVybiBlcXVhbChtX3ByaXZhdGUsIHMubV9wcml2YXRlKTsKK30KKwogV2ViU3RyaW5nOjpX ZWJTdHJpbmcoY29uc3QgV2ViQ29yZTo6U3RyaW5nJiBzKQogICAgIDogbV9wcml2YXRlKHN0YXRp Y19jYXN0PFdlYlN0cmluZ1ByaXZhdGUqPihzLmltcGwoKSkpCiB7Cg==