34784 2010-02-09 21:10:16 -0800 WebSocketHandshake needs to provide request information 2010-03-03 22:28:34 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) PC All RESOLVED FIXED P2 Normal --- 1 yutak yutak ap pfeldman ukai webkit.review.bot oldest_to_newest 189232 0 yutak 2010-02-09 21:10:16 -0800 WebSocketHandshake needs to return handshake request as a ResourceRequest. This will be necessary to let the Web Inspector show the content of handshake requests. 189235 1 48462 yutak 2010-02-09 21:19:45 -0800 Created attachment 48462 Add a method to WebSocketHandshake that returns the handshake request as 189236 2 48462 yutak 2010-02-09 21:21:29 -0800 Comment on attachment 48462 Add a method to WebSocketHandshake that returns the handshake request as Oops, I forgot to include ChangeLog. Let me try again. 189237 3 48463 yutak 2010-02-09 21:22:47 -0800 Created attachment 48463 Add a method to WebSocketHandshake that returns the handshake request as a ResourceRequest. 189239 4 yutak 2010-02-09 21:27:12 -0800 Ukai-san, can you review this? 189245 5 48463 ukai 2010-02-09 22:36:38 -0800 Comment on attachment 48463 Add a method to WebSocketHandshake that returns the handshake request as a ResourceRequest. > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 730d46c..adbb714 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,26 @@ > +2010-02-09 Yuta Kitamura <yutak@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Add a method to WebSocketHandshake that returns the handshake request as > + a ResourceRequest. > + > + This method will be necessary to let the Web Inspector show the content of > + handshake requests. > + > + No new tests, since the current tests will suffice (LayoutTests/websocket/*). > + > + WebSocketHandshake needs to return handshake request as a ResourceRequest > + https://bugs.webkit.org/show_bug.cgi?id=34784 > + > + * platform/network/HTTPHeaderMap.h: > + (WebCore::HTTPHeaderMap::contains): Added an overloaded method. > + Without this, the one that receives AtomicString is hidden and cannot be called. > + * websockets/WebSocketHandshake.cpp: > + (WebCore::WebSocketHandshake::clientHandshakeRequest): > + (WebCore::WebSocketHandshake::clientHandshakeMessage): > + * websockets/WebSocketHandshake.h: > + > 2010-02-09 Darin Adler <darin@apple.com> > > * rendering/RenderObject.cpp: > diff --git a/WebCore/platform/network/HTTPHeaderMap.h b/WebCore/platform/network/HTTPHeaderMap.h > index dfde974..72a0ce9 100644 > --- a/WebCore/platform/network/HTTPHeaderMap.h > +++ b/WebCore/platform/network/HTTPHeaderMap.h > @@ -46,6 +46,11 @@ namespace WebCore { > > void adopt(std::auto_ptr<CrossThreadHTTPHeaderMapData>); > > + bool contains(const AtomicString& name) const > + { > + return HashMap<AtomicString, String, CaseFoldingHash>::contains(name); > + } > + Can't we use const char* version? > String get(const AtomicString& name) const > { > return HashMap<AtomicString, String, CaseFoldingHash>::get(name); > diff --git a/WebCore/websockets/WebSocketHandshake.cpp b/WebCore/websockets/WebSocketHandshake.cpp > index 883f84b..92aa01b 100644 > --- a/WebCore/websockets/WebSocketHandshake.cpp > +++ b/WebCore/websockets/WebSocketHandshake.cpp > @@ -41,9 +41,11 @@ > #include "HTTPHeaderMap.h" > #include "KURL.h" > #include "Logging.h" > +#include "ResourceRequest.h" > #include "ScriptExecutionContext.h" > #include "SecurityOrigin.h" > #include "StringBuilder.h" > +#include <wtf/OwnPtr.h> > #include <wtf/StringExtras.h> > #include <wtf/Vector.h> > > @@ -155,45 +157,79 @@ String WebSocketHandshake::clientLocation() const > return builder.toString(); > } > > -CString WebSocketHandshake::clientHandshakeMessage() const > +PassOwnPtr<ResourceRequest> WebSocketHandshake::clientHandshakeRequest() const > { > - StringBuilder builder; > - > - builder.append("GET "); > - builder.append(resourceName(m_url)); > - builder.append(" HTTP/1.1\r\n"); > - builder.append("Upgrade: WebSocket\r\n"); > - builder.append("Connection: Upgrade\r\n"); > - builder.append("Host: "); > - builder.append(m_url.host().lower()); > - if (m_url.port()) { > - if ((!m_secure && m_url.port() != 80) || (m_secure && m_url.port() != 443)) { > - builder.append(":"); > - builder.append(String::number(m_url.port())); > - } > - } > - builder.append("\r\n"); > - builder.append("Origin: "); > - builder.append(clientOrigin()); > - builder.append("\r\n"); > - if (!m_clientProtocol.isEmpty()) { > - builder.append("WebSocket-Protocol: "); > - builder.append(m_clientProtocol); > - builder.append("\r\n"); > + OwnPtr<ResourceRequest> request(new ResourceRequest(m_url)); setTargetType? > + request->setHTTPMethod("GET"); > + request->setHTTPHeaderField("Upgrade", "WebSocket"); > + request->setHTTPHeaderField("Connection", "Upgrade"); > + StringBuilder host; > + host.append(m_url.host().lower()); > + if (m_url.port() && ((!m_secure && m_url.port() != 80) || (m_secure && m_url.port() != 443))) { > + host.append(":"); > + host.append(String::number(m_url.port())); > } > + request->setHTTPHeaderField("Host", host.toString()); > + request->setHTTPHeaderField("Origin", clientOrigin()); > + if (!m_clientProtocol.isEmpty()) > + request->setHTTPHeaderField("WebSocket-Protocol", m_clientProtocol); > + > KURL url = httpURLForAuthenticationAndCookies(); > // FIXME: set authentication information or cookies for url. > // Set "Authorization: <credentials>" if authentication information exists for url. > if (m_context->isDocument()) { > Document* document = static_cast<Document*>(m_context); > String cookie = cookies(document, url); > - if (!cookie.isEmpty()) { > - builder.append("Cookie: "); > - builder.append(cookie); > - builder.append("\r\n"); > - } > + if (!cookie.isEmpty()) > + request->setHTTPHeaderField("Cookie", cookie); > // Set "Cookie2: <cookie>" if cookies 2 exists for url? > } > + > + return request.release(); > +} > + > +namespace { > + > +void addHTTPHeaderField(StringBuilder& builder, const AtomicString& name, const String& value) If we use const chat * for headers.get() below, we can use const char* name here? > +{ > + builder.append(name); > + builder.append(": "); > + builder.append(value); > + builder.append("\r\n"); > +} > + > +} // anonymous namespace > + > +CString WebSocketHandshake::clientHandshakeMessage() const > +{ > + OwnPtr<ResourceRequest> request(clientHandshakeRequest()); > + > + StringBuilder builder; > + builder.append(request->httpMethod()); > + builder.append(" "); > + builder.append(resourceName(request->url())); > + builder.append(" HTTP/1.1\r\n"); > + > + // Current Web Socket protocol spec requires the first five (or possibly four) headers should appear in the following order: > + // Upgrade, Connection, Host, Origin, and WebSocket-Protocol (optional). > + const HTTPHeaderMap& headers(request->httpHeaderFields()); > + AtomicString upgrade("Upgrade"); > + addHTTPHeaderField(builder, upgrade, headers.get(upgrade)); > + AtomicString connection("Connection"); > + addHTTPHeaderField(builder, connection, headers.get(connection)); > + AtomicString host("Host"); > + addHTTPHeaderField(builder, host, headers.get(host)); > + AtomicString origin("Origin"); > + addHTTPHeaderField(builder, origin, headers.get(origin)); > + AtomicString webSocketProtocol("WebSocket-Protocol"); > + if (headers.contains(webSocketProtocol)) > + addHTTPHeaderField(builder, webSocketProtocol, headers.get(webSocketProtocol)); > + > + // Print remaining header fields. > + for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it) > + if (it->first != upgrade && it->first != connection && it->first != host && it->first != origin && it->first != webSocketProtocol) > + addHTTPHeaderField(builder, it->first, it->second); > + > builder.append("\r\n"); > return builder.toString().utf8(); > } > diff --git a/WebCore/websockets/WebSocketHandshake.h b/WebCore/websockets/WebSocketHandshake.h > index bda320a..11070bd 100644 > --- a/WebCore/websockets/WebSocketHandshake.h > +++ b/WebCore/websockets/WebSocketHandshake.h > @@ -36,11 +36,13 @@ > #include "KURL.h" > #include "PlatformString.h" > #include <wtf/Noncopyable.h> > +#include <wtf/PassOwnPtr.h> > > namespace WebCore { > > class ScriptExecutionContext; > class HTTPHeaderMap; > + class ResourceRequest; > > class WebSocketHandshake : public Noncopyable { > public: > @@ -63,6 +65,7 @@ namespace WebCore { > String clientOrigin() const; > String clientLocation() const; > > + PassOwnPtr<ResourceRequest> clientHandshakeRequest() const; > CString clientHandshakeMessage() const; > > void reset(); 189250 6 yutak 2010-02-09 23:11:34 -0800 (In reply to comment #5) > Can't we use const char* version? Yes, certainly. (At first I thought AtomicString yields some performance benefits, but I changed my mind; now I think it's not significant anyway.) > > setTargetType? I suppose the default TargetType (TargetIsSubresource) is enough. > > If we use const chat * for headers.get() below, we can use const char* name > here? Yes, I'll fix. 189255 7 48467 yutak 2010-02-09 23:59:49 -0800 Created attachment 48467 Patch v2 (apply ukai's comments) 189257 8 webkit.review.bot 2010-02-10 00:03:32 -0800 Attachment 48467 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/websockets/WebSocketHandshake.cpp:233: Boolean expressions that span multiple lines should have their operators on the left side of the line instead of the right side. [whitespace/operators] [4] WebCore/websockets/WebSocketHandshake.cpp:234: Boolean expressions that span multiple lines should have their operators on the left side of the line instead of the right side. [whitespace/operators] [4] Total errors found: 2 If any of these errors are false positives, please file a bug against check-webkit-style. 189258 9 yutak 2010-02-10 00:06:20 -0800 (In reply to comment #6) > (In reply to comment #5) > > > > If we use const chat * for headers.get() below, we can use const char* name > > here? > > Yes, I'll fix. It turned out to be impossible to remove AtomicString& version, since the following loop requires it. > + // Print remaining header fields. > + for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it) > + if (it->first != upgrade && it->first != connection && it->first != host && it->first != origin && it->first != webSocketProtocol) > + addHTTPHeaderField(builder, it->first, it->second); I also modified the comparisons above so that the headers are compared case-insensitively. 189262 10 48467 yutak 2010-02-10 00:11:15 -0800 Comment on attachment 48467 Patch v2 (apply ukai's comments) Oops, the style bot is angry at my patch. Let me fix it. BTW check-webkit-style does not complain about it in my local environment. I surely ran it locally before submitting my patch, trust me :) 189263 11 48468 yutak 2010-02-10 00:16:22 -0800 Created attachment 48468 Patch v3 (style fix) 189303 12 ukai 2010-02-10 03:04:25 -0800 (In reply to comment #11) > Created an attachment (id=48468) [details] > Patch v3 (style fix) Looks good to me. 189419 13 48468 ap 2010-02-10 11:05:36 -0800 Comment on attachment 48468 Patch v3 (style fix) +namespace { We don't use anonymous namespaces, we use static functions. I'm not entirely sure why, I've been told it somehow makes debugging easier - but please change this, if only for consistency. +void addHTTPHeaderField(StringBuilder& builder, const char* name, const String& value) +{ + builder.append(name); + builder.append(": "); + builder.append(value); Once the code gets abstracted into a function with a generic name, it should become resilient against broken input (such as newlines in header field values). Otherwise, it's too easy to misuse later, introducing security problems. + for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it) + if (!equalIgnoringCase(it->first, "Upgrade") && !equalIgnoringCase(it->first, "Connection") + && !equalIgnoringCase(it->first, "Host") && !equalIgnoringCase(it->first, "Origin") + && !equalIgnoringCase(it->first, "WebSocket-Protocol")) This is an unnecessarily slow way to compare AtomicStrings to constant values. You should use AtomicStrings for the header field name constants, too. I'm not particularly happy with how this code works. It's as if ResourceRequest version were the real thing, and CString one were a debugging aid of some kind, which is obviously not true. With the current ResourceRequest implementation, we get lucky that no other WebSocket peculiar requirements are broken (besides ordering, WebSocket forbids continuations, for example). This also introduces a performance hit just for Web Inspector aid. At the very least, there should be extensive and clear comments about this design problem. But I'd much prefer to see a solution that builds WebSocket handshake without round-tripping it via ResourceRequest. One way to do this is to abstract request builder into a class that can build either a ResourceRequest or a CString. Then you would pass it as a parameter to a function that knows how to build the request (either as a template parameter, or as a pointer to an interface). Just as a point for consideration, it doesn't seem that ResourceRequest is necessarily a good class to use with Web Inspector. Either Web Inspector will have incorrect order of WebSocket headers, which will be confusing to developers, or it will need yet another copy of the code that reorders them. Perhaps there can be a different way to pass the data to Web Inspector. r- for the concrete points I mentioned first, but I also strongly suggest revisiting the design to avoid round-tripping. 189955 14 yutak 2010-02-11 23:36:23 -0800 Thank you for your comment. I'll reconsider the design. 192362 15 49186 yutak 2010-02-21 23:39:43 -0800 Created attachment 49186 Patch v4 (Completely rewritten) 192363 16 webkit.review.bot 2010-02-21 23:42:35 -0800 Attachment 49186 did not pass style-queue: Failed to run "WebKitTools/Scripts/check-webkit-style" exit_code: 1 WebCore/websockets/WebSocketHandshakeRequest.h:40: wtf includes should be <wtf/file.h> instead of "wtf/file.h". [build/include] [4] WebCore/websockets/WebSocketHandshakeRequest.h:41: wtf includes should be <wtf/file.h> instead of "wtf/file.h". [build/include] [4] Total errors found: 2 in 11 files If any of these errors are false positives, please file a bug against check-webkit-style. 192364 17 49187 yutak 2010-02-21 23:51:39 -0800 Created attachment 49187 Patch v5 (Style fix) 192366 18 yutak 2010-02-21 23:54:55 -0800 (In reply to comment #17) > Created an attachment (id=49187) [details] > Patch v5 (Style fix) Now I realize that I've been using check-webkit-style wrongly... (you need to use --git-commit=HEAD^ instead of HEAD) Anyways, let me add some comments. In this patch, I did: - create a class WebSocketHandshakeRequest that stores the request information. - let WebSocketHandshake create and return a request object. - let WebSocketChannel generate the request message using that request object. After this patch is committed, I'm going to add WebSocketHandshakeResponse in the same fashion. ukai: Do you have any comments on this patch? 192373 19 49187 ukai 2010-02-22 00:25:05 -0800 Comment on attachment 49187 Patch v5 (Style fix) looks good to me. > + const String& webSocketProtocol() const; // Empty string means the absence of WebSocket-Protocol field. I think null string means the absence of websocket protocol. 192379 20 yutak 2010-02-22 00:53:23 -0800 (In reply to comment #19) > (From update of attachment 49187 [details]) > looks good to me. > > > + const String& webSocketProtocol() const; // Empty string means the absence of WebSocket-Protocol field. > > I think null string means the absence of websocket protocol. As per current Web Socket protocol draft, field values for WebSocket-Protocol are non-empty. The /resource name/ and /protocol/ strings must be non-empty strings of ASCII characters in the range U+0020 to U+007E. Maybe we should rewrite this comment as "Null string or empty string means...". Another idea is to normalize an empty string to the null string and not to return empty strings here. I think both are okay, and personally I like the latter. 192382 21 ukai 2010-02-22 00:59:02 -0800 (In reply to comment #20) > (In reply to comment #19) > > (From update of attachment 49187 [details] [details]) > > looks good to me. > > > > > + const String& webSocketProtocol() const; // Empty string means the absence of WebSocket-Protocol field. > > > > I think null string means the absence of websocket protocol. > > As per current Web Socket protocol draft, field values for WebSocket-Protocol > are non-empty. > > The /resource name/ and /protocol/ strings must be non-empty strings of > ASCII characters in the range U+0020 to U+007E. > > Maybe we should rewrite this comment as "Null string or empty string means...". > Another idea is to normalize an empty string to the null string and not to > return empty strings here. I think both are okay, and personally I like the > latter. empty string for protocol is not valid in WebSocket API. I think isValidProtocolString() in WebSocket.cpp checks this. 192385 22 yutak 2010-02-22 01:04:59 -0800 (In reply to comment #21) > > empty string for protocol is not valid in WebSocket API. > I think isValidProtocolString() in WebSocket.cpp checks this. Got it. After gathering more input from other reviewers, I'd like to update the patch. It seems like WebCore/WebCore.xcodeproj/project.pbxproj becomes obsolete (failed to patch), so I want to fix this later too. 192508 23 49187 ap 2010-02-22 10:20:43 -0800 Comment on attachment 49187 Patch v5 (Style fix) + ASSERT(!m_request.get()); No need for .get() here and elsewhere. + // If we have a cache, use it. + if (m_request) + return m_request; I wouldn't call it "cache" - it's just a request that has already been created. "Cache" implies a somewhat different set of behaviors - such as having multiple entries, or and ability to be cleared. It seems that m_request does not need to exist for normal operation, it's only needed for Web Inspector? It seems weird to have all this data in both WebSocketHandshake and WebSocketHandshakeRequest if we're not going to use it. + // Once clientHandshakeRequest() is called, you cannot change the client request + // (i.e. you cannot call setURL(), setClientProtocol() or setSecure()) until reset() is called. This limitation would not be necessary if WebSocketHandshakeRequest weren't saved in WebSocketHandshake. And again, if it were a "cache", then it would be just invalidated when setting. +String WebSocketHandshakeRequest::upgrade() const +{ + return "WebSocket"; +} There is no need for this to be a member function, as it doesn't depend on the object. The name is misleading - upgrade is a verb, but this function doesn't upgrade anything. + builder.append("Upgrade: "); + builder.append(upgrade()); + builder.append("\r\n"); I suggest doing builder.append("Upgrade: WebSocket\r\n"). The reason you added these as public accessors is likely that they will be needed in Web Inspector. But I don't think that having these as functions adds much to forward compatibility - for all we know, the names are less likely to change than the whole design of WebSocket handshake. So, I'd just hardcode the values in both handshakeMessage() and Web Inspector, and maybe add a comment in handshakeMessage() saying that changes to handshake generation should also include changes to Web Inspector presentation code. I don't know your plans for using this in Web Inspector - I expected a Vector of headers to be provided to it, rather than a request object such as this. Maybe your approach makes more sense. +const String& WebSocketHandshakeRequest::origin() const +{ + return m_origin; +} This method doesn't seem to be used outside of WebSocketHandshakeRequest, so (1) it should be private, and (2) it's not needed at all, please just use m_origin directly. An accessor can be always added later if it becomes necessary. Ditto for most other one-liners in this class. +class WebSocketHandshakeRequest : public RefCounted<WebSocketHandshakeRequest> { I'm not sure if WebSocketHandshakeRequest needs to be RefCounted - for current code, it would suffice if it could only be stack-allocated (provided that we don't keep it after generating a CString). Maybe it will become necessary for Web Inspector. The approach here looks good to me, this just needs one or two more iterations to polish the details. 193226 24 yutak 2010-02-23 20:32:12 -0800 Thank you for your comment. The design decision was based on my intention to: 1) Minimize construction cost of WebSocketHandshakeRequest objects. 2) Make it clear that at some moment a request should get "frozen" and will no longer change (because changes to the request may confuse Web Inspector). I was not sure if we can accept initial construction and copy-construction cost of request objects (copying a few string and a vector of extra header fields). Since some request object may live after the main WebSocket object is freed (Web Inspector may keep holding it), I decided to make the request object RefCounted. However, after I read your comment, I started to think my approach was unnecessarily complicated. As you suggested, we can allocate request objects in the stack, and let Web Inspector responsible for holding them. I want to rewrite the patch based on this new approach. Response to each comment inline: (In reply to comment #23) > (From update of attachment 49187 [details]) > + ASSERT(!m_request.get()); > > No need for .get() here and elsewhere. Sure. > > + // If we have a cache, use it. > + if (m_request) > + return m_request; > > I wouldn't call it "cache" - it's just a request that has already been created. > "Cache" implies a somewhat different set of behaviors - such as having multiple > entries, or and ability to be cleared. Right, I mistakenly used that word. My original intention was to avoid multiple construction and remember the object in the handshake object. > > It seems that m_request does not need to exist for normal operation, it's only > needed for Web Inspector? It seems weird to have all this data in both > WebSocketHandshake and WebSocketHandshakeRequest if we're not going to use it. > Good point. It does not need to keep it in the handshake object. On-demand generation will suffice. This will be removed in the next patch. > + // Once clientHandshakeRequest() is called, you cannot change the > client request > + // (i.e. you cannot call setURL(), setClientProtocol() or setSecure()) > until reset() is called. > > This limitation would not be necessary if WebSocketHandshakeRequest weren't > saved in WebSocketHandshake. And again, if it were a "cache", then it would be > just invalidated when setting. > > +String WebSocketHandshakeRequest::upgrade() const > +{ > + return "WebSocket"; > +} > > There is no need for this to be a member function, as it doesn't depend on the > object. The name is misleading - upgrade is a verb, but this function doesn't > upgrade anything. > > + builder.append("Upgrade: "); > + builder.append(upgrade()); > + builder.append("\r\n"); > > I suggest doing builder.append("Upgrade: WebSocket\r\n"). > > The reason you added these as public accessors is likely that they will be > needed in Web Inspector. But I don't think that having these as functions adds > much to forward compatibility - for all we know, the names are less likely to > change than the whole design of WebSocket handshake. So, I'd just hardcode the > values in both handshakeMessage() and Web Inspector, and maybe add a comment in > handshakeMessage() saying that changes to handshake generation should also > include changes to Web Inspector presentation code. > > I don't know your plans for using this in Web Inspector - I expected a Vector > of headers to be provided to it, rather than a request object such as this. > Maybe your approach makes more sense. > Your plan sounds better to me, too. A Vector of headers will suffice and I think it's a cleaner interface. I'd be happy to rewrite this in the next patch. > +const String& WebSocketHandshakeRequest::origin() const > +{ > + return m_origin; > +} > > This method doesn't seem to be used outside of WebSocketHandshakeRequest, so > (1) it should be private, and (2) it's not needed at all, please just use > m_origin directly. An accessor can be always added later if it becomes > necessary. > > Ditto for most other one-liners in this class. Certainly. > > +class WebSocketHandshakeRequest : public RefCounted<WebSocketHandshakeRequest> > { > > I'm not sure if WebSocketHandshakeRequest needs to be RefCounted - for current > code, it would suffice if it could only be stack-allocated (provided that we > don't keep it after generating a CString). Maybe it will become necessary for > Web Inspector. > > The approach here looks good to me, this just needs one or two more iterations > to polish the details. As I mentioned above, the class will not be RefCounted. 193267 25 49363 yutak 2010-02-24 00:58:17 -0800 Created attachment 49363 Patch v6 (second try) 193392 26 49363 ap 2010-02-24 09:47:41 -0800 Comment on attachment 49363 Patch v6 (second try) + if (!url.protocolIs("wss") && m_secure) + url.setProtocol("wss"); + else if (!url.protocolIs("ws") && !m_secure) + url.setProtocol("ws"); Can this ever happen? If not, this should be an assertion instead. + const CString& handshakeMessage = m_handshake.clientHandshakeRequest().handshakeMessage(); Returning the handshake request object results in an unnecessary copy; I think that WebSocketHandshake could still have a clientHandshakeMessage() that would produce a CString without copying WebSocketHandshakeRequest around. + KURL cookieUrl = httpURLForAuthenticationAndCookies(); Should be cookieURL per WebKit style. + // FIXME: set authentication information or cookies for cookieUrl. + // Set "Authorization: <credentials>" if authentication information exists for cookieUrl. You didn't change this comment, but it looks strange, I'm not sure what it actually means. We do set cookies right below the comment, and authorization has been dropped from the spec. + fields.insert(fields.size() - 1, m_extraHeaderFields); This should use append(). +#include "CString.h" +#include "HTTPHeaderMap.h" I don't think you need to include CString.h, and you definitely do not need HTTPHeaderMap.h. + struct HeaderField { I'd consider using std::pair instead of this struct - we use it quite frequently in WebCore. + // According to current Web Socket protocol spec, four mandatory headers (Upgrade, Connection, Host, and Origin) and Please spell out "specification", not "spec". + // Build the character sequence for this handshake request. Maybe "serialization"? These comments are very minor. Still an r- to address them, but this is almost done. 193393 27 ap 2010-02-24 09:50:08 -0800 + // According to current Web Socket protocol spec, four mandatory headers (Upgrade, Connection, Host, and Origin) and Oh, and those are "header fields", not "headers". You've got it right elsewhere in the patch. 194652 28 yutak 2010-03-01 02:07:46 -0800 Thanks again! And, sorry for my late replies (I've been off for the last few days and have had no Internet access). (In reply to comment #26) > (From update of attachment 49363 [details]) > + if (!url.protocolIs("wss") && m_secure) > + url.setProtocol("wss"); > + else if (!url.protocolIs("ws") && !m_secure) > + url.setProtocol("ws"); > > Can this ever happen? If not, this should be an assertion instead. When WebSocketHandshake::setSecure(bool) is called, this might be happen. As there's no code that uses this method (as far as I grepped around), probably I can delete this method and simplify the above code. > > + const CString& handshakeMessage = > m_handshake.clientHandshakeRequest().handshakeMessage(); > > Returning the handshake request object results in an unnecessary copy; I think > that WebSocketHandshake could still have a clientHandshakeMessage() that would > produce a CString without copying WebSocketHandshakeRequest around. Agreed. > > + KURL cookieUrl = httpURLForAuthenticationAndCookies(); > > Should be cookieURL per WebKit style. Sure. > > + // FIXME: set authentication information or cookies for cookieUrl. > + // Set "Authorization: <credentials>" if authentication information exists > for cookieUrl. > > You didn't change this comment, but it looks strange, I'm not sure what it > actually means. We do set cookies right below the comment, and authorization > has been dropped from the spec. > As I discussed with Fumitoshi (ukai@chromium) off-line, these lines are simply obsolete as you suggested and safe to erase. > + fields.insert(fields.size() - 1, m_extraHeaderFields); > > This should use append(). Sure. > > +#include "CString.h" > +#include "HTTPHeaderMap.h" > > I don't think you need to include CString.h, and you definitely do not need > HTTPHeaderMap.h. I've forgotten to erase them. Will be removed. > > + struct HeaderField { > > I'd consider using std::pair instead of this struct - we use it quite > frequently in WebCore. Sure. > > + // According to current Web Socket protocol spec, four mandatory headers > (Upgrade, Connection, Host, and Origin) and > > Please spell out "specification", not "spec". Sure. > > + // Build the character sequence for this handshake request. > > Maybe "serialization"? That sounds better. > > These comments are very minor. Still an r- to address them, but this is almost > done. 194714 29 ap 2010-03-01 08:30:25 -0800 > When WebSocketHandshake::setSecure(bool) is called, this might be happen. As > there's no code that uses this method (as far as I grepped around), probably I > can delete this method and simplify the above code. Yes, this sounds good. 194957 30 49782 yutak 2010-03-01 23:16:58 -0800 Created attachment 49782 Patch v7 (Third try) 194974 31 49782 ap 2010-03-02 00:23:23 -0800 Comment on attachment 49782 Patch v7 (Third try) --- a/WebCore/WebCore.pro +++ b/WebCore/WebCore.pro @@ -2678,6 +2678,7 @@ SOURCES += \ websockets/WebSocket.cpp \ websockets/WebSocketChannel.cpp \ websockets/WebSocketHandshake.cpp \ + websockets/WebSocketHandshakeRequest.cpp \ I've noticed that .pro file doesn't list any WebSocket-related headers. It probably should. + Vector<std::pair<AtomicString, String> > fields; In .cpp files, we just do "using namespace std;". At some point during this patch evolution, code paths for generating CString and request object became separate again. Maybe it's OK, since they no longer look that similar, but there is certain unfortunate duplication of logic, which can cause issues later on. That said, I'm fine with this patch as is (please just remove std:: prefixes from .cpp). Is some reviewer working with you on Web Inspector side of the feature? If yes, they could give you a final review, as long as this interface between WebCore and Web Inspector looks good to them. 194979 32 49789 yutak 2010-03-02 00:53:53 -0800 Created attachment 49789 Patch v8 (Fix 'std::' and WebCore.pro) 194980 33 yutak 2010-03-02 00:57:18 -0800 (In reply to comment #32) > Created an attachment (id=49789) [details] > Patch v8 (Fix 'std::' and WebCore.pro) Please note that I blindly made changes to WebCore.pro. I want to see how the QT bot feels about these. 194981 34 yutak 2010-03-02 01:02:59 -0800 (In reply to comment #31) > At some point during this patch evolution, code paths for generating CString > and request object became separate again. Maybe it's OK, since they no longer > look that similar, but there is certain unfortunate duplication of logic, which > can cause issues later on. > > That said, I'm fine with this patch as is (please just remove std:: prefixes > from .cpp). Is some reviewer working with you on Web Inspector side of the > feature? If yes, they could give you a final review, as long as this interface > between WebCore and Web Inspector looks good to them. +pfeldman Pavel, could you please make comments on the patch? This batch is basically adding an interface to WebSocketHandshake so that the inspector can get the WebSocket's request information. After this patch is landed, I'm going to create another patch to address handshake responses. 194999 35 49789 pfeldman 2010-03-02 02:49:46 -0800 Comment on attachment 49789 Patch v8 (Fix 'std::' and WebCore.pro) Overall the patch looks good. Couple of nits: - It shufflest WebCore/WebCore.vcproj/WebCore.vcproj a bit - public typedefs for headers would be nice - is there a reason you use AtomicString and String for header pairs? Do you want me to be a formal reviewer? (need r+?) 195028 36 yutak 2010-03-02 05:17:05 -0800 (In reply to comment #35) > (From update of attachment 49789 [details]) > Overall the patch looks good. Couple of nits: > > - It shufflest WebCore/WebCore.vcproj/WebCore.vcproj a bit I had no idea of why this happened. I just opened the .vcproj file by VS2005, added couple of files, and saved. Maybe I can try again? > - public typedefs for headers would be nice That sounds nice. I'll update the patch. > - is there a reason you use AtomicString and String for header pairs? I did this because HTTPHeaderMap did the same thing. The names of the header fields are limited and not arbitrary, so I think it's reasonable to use AtomicString here. > > Do you want me to be a formal reviewer? (need r+?) I don't care very much about who r+'s my patch, but probably Alexey (ap) is a better person to mark r+ (or r-). Anyway thank you for your proposal. I'll address the typedef issue tomorrow (because I don't have developing environment right now). Dropping r? flag for now. Thank you for reviewing my patch! 195389 37 49879 yutak 2010-03-02 22:31:44 -0800 Created attachment 49879 Patch v9 (Add typedef) 195390 38 yutak 2010-03-02 22:36:02 -0800 (In reply to comment #37) > Created an attachment (id=49879) [details] > Patch v9 (Add typedef) I tried to correct .vcproj file, but my VS2005 randomly changed some files in that .vcproj file. Hand-editing such a file sounded like a bad idea, so I decided to leave it as-is. Alexey: Could you make a (hopefully) final review on this patch? 195649 39 49879 ap 2010-03-03 09:56:16 -0800 Comment on attachment 49879 Patch v9 (Add typedef) Ok, r=me 195838 40 49879 yutak 2010-03-03 18:12:58 -0800 Comment on attachment 49879 Patch v9 (Add typedef) Thank you! Setting cq?. 195891 41 ukai 2010-03-03 22:10:32 -0800 Committed r55505: <http://trac.webkit.org/changeset/55505> 48462 2010-02-09 21:19:45 -0800 2010-02-09 21:22:43 -0800 Add a method to WebSocketHandshake that returns the handshake request as bug-34784-20100210141943.patch text/plain 6324 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmggYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oCmluZGV4IGRmZGU5NzQuLjcy YTBjZTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFw LmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJNYXAuaApAQCAtNDYs NiArNDYsMTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZvaWQgYWRvcHQoc3Rk OjphdXRvX3B0cjxDcm9zc1RocmVhZEhUVFBIZWFkZXJNYXBEYXRhPik7CiAgICAgICAgIAorICAg ICAgICBib29sIGNvbnRhaW5zKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkgY29uc3QKKyAgICAg ICAgeworICAgICAgICAgICAgcmV0dXJuIEhhc2hNYXA8QXRvbWljU3RyaW5nLCBTdHJpbmcsIENh c2VGb2xkaW5nSGFzaD46OmNvbnRhaW5zKG5hbWUpOworICAgICAgICB9CisKICAgICAgICAgU3Ry aW5nIGdldChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUpIGNvbnN0CiAgICAgICAgIHsKICAgICAg ICAgICAgIHJldHVybiBIYXNoTWFwPEF0b21pY1N0cmluZywgU3RyaW5nLCBDYXNlRm9sZGluZ0hh c2g+OjpnZXQobmFtZSk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3Bw CmluZGV4IDg4M2Y4NGIuLjkyYWEwMWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9X ZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2UuY3BwCkBAIC00MSw5ICs0MSwxMSBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAu aCIKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIlJl c291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCIKICNp bmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKKyNp bmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0cmluZ0V4dHJhcy5oPgogI2lu Y2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIApAQCAtMTU1LDQ1ICsxNTcsNzkgQEAgU3RyaW5nIFdlYlNv Y2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAogICAgIHJldHVybiBidWlsZGVy LnRvU3RyaW5nKCk7CiB9CiAKLUNTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5k c2hha2VNZXNzYWdlKCkgY29uc3QKK1Bhc3NPd25QdHI8UmVzb3VyY2VSZXF1ZXN0PiBXZWJTb2Nr ZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKSBjb25zdAogewotICAgIFN0cmlu Z0J1aWxkZXIgYnVpbGRlcjsKLQotICAgIGJ1aWxkZXIuYXBwZW5kKCJHRVQgIik7Ci0gICAgYnVp bGRlci5hcHBlbmQocmVzb3VyY2VOYW1lKG1fdXJsKSk7Ci0gICAgYnVpbGRlci5hcHBlbmQoIiBI VFRQLzEuMVxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiVXBncmFkZTogV2ViU29ja2V0XHJc biIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJDb25uZWN0aW9uOiBVcGdyYWRlXHJcbiIpOwotICAg IGJ1aWxkZXIuYXBwZW5kKCJIb3N0OiAiKTsKLSAgICBidWlsZGVyLmFwcGVuZChtX3VybC5ob3N0 KCkubG93ZXIoKSk7Ci0gICAgaWYgKG1fdXJsLnBvcnQoKSkgewotICAgICAgICBpZiAoKCFtX3Nl Y3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkg IT0gNDQzKSkgewotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIjoiKTsKLSAgICAgICAgICAg IGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwotICAgICAgICB9 Ci0gICAgfQotICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgYnVpbGRlci5hcHBlbmQo Ik9yaWdpbjogIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoY2xpZW50T3JpZ2luKCkpOwotICAgIGJ1 aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgaWYgKCFtX2NsaWVudFByb3RvY29sLmlzRW1wdHko KSkgewotICAgICAgICBidWlsZGVyLmFwcGVuZCgiV2ViU29ja2V0LVByb3RvY29sOiAiKTsKLSAg ICAgICAgYnVpbGRlci5hcHBlbmQobV9jbGllbnRQcm90b2NvbCk7Ci0gICAgICAgIGJ1aWxkZXIu YXBwZW5kKCJcclxuIik7CisgICAgT3duUHRyPFJlc291cmNlUmVxdWVzdD4gcmVxdWVzdChuZXcg UmVzb3VyY2VSZXF1ZXN0KG1fdXJsKSk7CisgICAgcmVxdWVzdC0+c2V0SFRUUE1ldGhvZCgiR0VU Iik7CisgICAgcmVxdWVzdC0+c2V0SFRUUEhlYWRlckZpZWxkKCJVcGdyYWRlIiwgIldlYlNvY2tl dCIpOworICAgIHJlcXVlc3QtPnNldEhUVFBIZWFkZXJGaWVsZCgiQ29ubmVjdGlvbiIsICJVcGdy YWRlIik7CisgICAgU3RyaW5nQnVpbGRlciBob3N0OworICAgIGhvc3QuYXBwZW5kKG1fdXJsLmhv c3QoKS5sb3dlcigpKTsKKyAgICBpZiAobV91cmwucG9ydCgpICYmICgoIW1fc2VjdXJlICYmIG1f dXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA0NDMpKSkg eworICAgICAgICBob3N0LmFwcGVuZCgiOiIpOworICAgICAgICBob3N0LmFwcGVuZChTdHJpbmc6 Om51bWJlcihtX3VybC5wb3J0KCkpKTsKICAgICB9CisgICAgcmVxdWVzdC0+c2V0SFRUUEhlYWRl ckZpZWxkKCJIb3N0IiwgaG9zdC50b1N0cmluZygpKTsKKyAgICByZXF1ZXN0LT5zZXRIVFRQSGVh ZGVyRmllbGQoIk9yaWdpbiIsIGNsaWVudE9yaWdpbigpKTsKKyAgICBpZiAoIW1fY2xpZW50UHJv dG9jb2wuaXNFbXB0eSgpKQorICAgICAgICByZXF1ZXN0LT5zZXRIVFRQSGVhZGVyRmllbGQoIldl YlNvY2tldC1Qcm90b2NvbCIsIG1fY2xpZW50UHJvdG9jb2wpOworCiAgICAgS1VSTCB1cmwgPSBo dHRwVVJMRm9yQXV0aGVudGljYXRpb25BbmRDb29raWVzKCk7CiAgICAgLy8gRklYTUU6IHNldCBh dXRoZW50aWNhdGlvbiBpbmZvcm1hdGlvbiBvciBjb29raWVzIGZvciB1cmwuCiAgICAgLy8gU2V0 ICJBdXRob3JpemF0aW9uOiA8Y3JlZGVudGlhbHM+IiBpZiBhdXRoZW50aWNhdGlvbiBpbmZvcm1h dGlvbiBleGlzdHMgZm9yIHVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpIHsK ICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihtX2Nv bnRleHQpOwogICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llcyhkb2N1bWVudCwgdXJsKTsK LSAgICAgICAgaWYgKCFjb29raWUuaXNFbXB0eSgpKSB7Ci0gICAgICAgICAgICBidWlsZGVyLmFw cGVuZCgiQ29va2llOiAiKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKGNvb2tpZSk7Ci0g ICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgICAgICB9CisgICAgICAgIGlm ICghY29va2llLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlcXVlc3QtPnNldEhUVFBIZWFkZXJG aWVsZCgiQ29va2llIiwgY29va2llKTsKICAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8Y29va2ll PiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgdXJsPwogICAgIH0KKworICAgIHJldHVybiByZXF1 ZXN0LnJlbGVhc2UoKTsKK30KKworbmFtZXNwYWNlIHsKKwordm9pZCBhZGRIVFRQSGVhZGVyRmll bGQoU3RyaW5nQnVpbGRlciYgYnVpbGRlciwgY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25z dCBTdHJpbmcmIHZhbHVlKQoreworICAgIGJ1aWxkZXIuYXBwZW5kKG5hbWUpOworICAgIGJ1aWxk ZXIuYXBwZW5kKCI6ICIpOworICAgIGJ1aWxkZXIuYXBwZW5kKHZhbHVlKTsKKyAgICBidWlsZGVy LmFwcGVuZCgiXHJcbiIpOworfQorCit9IC8vIGFub255bW91cyBuYW1lc3BhY2UKKworQ1N0cmlu ZyBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAorewor ICAgIE93blB0cjxSZXNvdXJjZVJlcXVlc3Q+IHJlcXVlc3QoY2xpZW50SGFuZHNoYWtlUmVxdWVz dCgpKTsKKworICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKKyAgICBidWlsZGVyLmFwcGVuZChy ZXF1ZXN0LT5odHRwTWV0aG9kKCkpOworICAgIGJ1aWxkZXIuYXBwZW5kKCIgIik7CisgICAgYnVp bGRlci5hcHBlbmQocmVzb3VyY2VOYW1lKHJlcXVlc3QtPnVybCgpKSk7CisgICAgYnVpbGRlci5h cHBlbmQoIiBIVFRQLzEuMVxyXG4iKTsKKworICAgIC8vIEN1cnJlbnQgV2ViIFNvY2tldCBwcm90 b2NvbCBzcGVjIHJlcXVpcmVzIHRoZSBmaXJzdCBmaXZlIChvciBwb3NzaWJseSBmb3VyKSBoZWFk ZXJzIHNob3VsZCBhcHBlYXIgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKKyAgICAvLyBVcGdyYWRl LCBDb25uZWN0aW9uLCBIb3N0LCBPcmlnaW4sIGFuZCBXZWJTb2NrZXQtUHJvdG9jb2wgKG9wdGlv bmFsKS4KKyAgICBjb25zdCBIVFRQSGVhZGVyTWFwJiBoZWFkZXJzKHJlcXVlc3QtPmh0dHBIZWFk ZXJGaWVsZHMoKSk7CisgICAgQXRvbWljU3RyaW5nIHVwZ3JhZGUoIlVwZ3JhZGUiKTsKKyAgICBh ZGRIVFRQSGVhZGVyRmllbGQoYnVpbGRlciwgdXBncmFkZSwgaGVhZGVycy5nZXQodXBncmFkZSkp OworICAgIEF0b21pY1N0cmluZyBjb25uZWN0aW9uKCJDb25uZWN0aW9uIik7CisgICAgYWRkSFRU UEhlYWRlckZpZWxkKGJ1aWxkZXIsIGNvbm5lY3Rpb24sIGhlYWRlcnMuZ2V0KGNvbm5lY3Rpb24p KTsKKyAgICBBdG9taWNTdHJpbmcgaG9zdCgiSG9zdCIpOworICAgIGFkZEhUVFBIZWFkZXJGaWVs ZChidWlsZGVyLCBob3N0LCBoZWFkZXJzLmdldChob3N0KSk7CisgICAgQXRvbWljU3RyaW5nIG9y aWdpbigiT3JpZ2luIik7CisgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsIG9yaWdpbiwg aGVhZGVycy5nZXQob3JpZ2luKSk7CisgICAgQXRvbWljU3RyaW5nIHdlYlNvY2tldFByb3RvY29s KCJXZWJTb2NrZXQtUHJvdG9jb2wiKTsKKyAgICBpZiAoaGVhZGVycy5jb250YWlucyh3ZWJTb2Nr ZXRQcm90b2NvbCkpCisgICAgICAgIGFkZEhUVFBIZWFkZXJGaWVsZChidWlsZGVyLCB3ZWJTb2Nr ZXRQcm90b2NvbCwgaGVhZGVycy5nZXQod2ViU29ja2V0UHJvdG9jb2wpKTsKKworICAgIC8vIFBy aW50IHJlbWFpbmluZyBoZWFkZXIgZmllbGRzLgorICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29u c3RfaXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCksIGVuZCA9IGhlYWRlcnMuZW5kKCk7IGl0 ICE9IGVuZDsgKytpdCkKKyAgICAgICAgaWYgKGl0LT5maXJzdCAhPSB1cGdyYWRlICYmIGl0LT5m aXJzdCAhPSBjb25uZWN0aW9uICYmIGl0LT5maXJzdCAhPSBob3N0ICYmIGl0LT5maXJzdCAhPSBv cmlnaW4gJiYgaXQtPmZpcnN0ICE9IHdlYlNvY2tldFByb3RvY29sKQorICAgICAgICAgICAgYWRk SFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsIGl0LT5maXJzdCwgaXQtPnNlY29uZCk7CisKICAgICBi dWlsZGVyLmFwcGVuZCgiXHJcbiIpOwogICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCkudXRm OCgpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFr ZS5oIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCmluZGV4IGJkYTMy MGEuLjExMDcwYmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5k c2hha2UuaAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKQEAg LTM2LDExICszNiwxMyBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9QYXNz T3duUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgIGNsYXNzIFNjcmlwdEV4ZWN1 dGlvbkNvbnRleHQ7CiAgICAgY2xhc3MgSFRUUEhlYWRlck1hcDsKKyAgICBjbGFzcyBSZXNvdXJj ZVJlcXVlc3Q7CiAKICAgICBjbGFzcyBXZWJTb2NrZXRIYW5kc2hha2UgOiBwdWJsaWMgTm9uY29w eWFibGUgewogICAgIHB1YmxpYzoKQEAgLTYzLDYgKzY1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICBTdHJpbmcgY2xpZW50T3JpZ2luKCkgY29uc3Q7CiAgICAgICAgIFN0cmluZyBj bGllbnRMb2NhdGlvbigpIGNvbnN0OwogCisgICAgICAgIFBhc3NPd25QdHI8UmVzb3VyY2VSZXF1 ZXN0PiBjbGllbnRIYW5kc2hha2VSZXF1ZXN0KCkgY29uc3Q7CiAgICAgICAgIENTdHJpbmcgY2xp ZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0OwogCiAgICAgICAgIHZvaWQgcmVzZXQoKTsK 48463 2010-02-09 21:22:47 -0800 2010-02-09 23:59:44 -0800 Add a method to WebSocketHandshake that returns the handshake request as a ResourceRequest. bug-34784-20100210142246.patch text/plain 7529 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NzMwZDQ2Yy4uYWRiYjcxNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAxMC0wMi0wOSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBtZXRob2QgdG8gV2ViU29ja2V0SGFuZHNoYWtlIHRoYXQg cmV0dXJucyB0aGUgaGFuZHNoYWtlIHJlcXVlc3QgYXMKKyAgICAgICAgYSBSZXNvdXJjZVJlcXVl c3QuCisKKyAgICAgICAgVGhpcyBtZXRob2Qgd2lsbCBiZSBuZWNlc3NhcnkgdG8gbGV0IHRoZSBX ZWIgSW5zcGVjdG9yIHNob3cgdGhlIGNvbnRlbnQgb2YKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVl c3RzLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgc2luY2UgdGhlIGN1cnJlbnQgdGVzdHMgd2ls bCBzdWZmaWNlIChMYXlvdXRUZXN0cy93ZWJzb2NrZXQvKikuCisKKyAgICAgICAgV2ViU29ja2V0 SGFuZHNoYWtlIG5lZWRzIHRvIHJldHVybiBoYW5kc2hha2UgcmVxdWVzdCBhcyBhIFJlc291cmNl UmVxdWVzdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzQ3ODQKKworICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5oOgorICAg ICAgICAoV2ViQ29yZTo6SFRUUEhlYWRlck1hcDo6Y29udGFpbnMpOiBBZGRlZCBhbiBvdmVybG9h ZGVkIG1ldGhvZC4KKyAgICAgICAgV2l0aG91dCB0aGlzLCB0aGUgb25lIHRoYXQgcmVjZWl2ZXMg QXRvbWljU3RyaW5nIGlzIGhpZGRlbiBhbmQgY2Fubm90IGJlIGNhbGxlZC4KKyAgICAgICAgKiB3 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXZWJT b2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29y ZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VNZXNzYWdlKToKKyAgICAgICAg KiB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oOgorCiAyMDEwLTAyLTA5ICBEYXJpbiBB ZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmpl Y3QuY3BwOgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBIZWFkZXJN YXAuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9IVFRQSGVhZGVyTWFwLmgKaW5kZXggZGZk ZTk3NC4uNzJhMGNlOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL0hUVFBI ZWFkZXJNYXAuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvSFRUUEhlYWRlck1hcC5o CkBAIC00Niw2ICs0NiwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBh ZG9wdChzdGQ6OmF1dG9fcHRyPENyb3NzVGhyZWFkSFRUUEhlYWRlck1hcERhdGE+KTsKICAgICAg ICAgCisgICAgICAgIGJvb2wgY29udGFpbnMoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lKSBjb25z dAorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gSGFzaE1hcDxBdG9taWNTdHJpbmcsIFN0 cmluZywgQ2FzZUZvbGRpbmdIYXNoPjo6Y29udGFpbnMobmFtZSk7CisgICAgICAgIH0KKwogICAg ICAgICBTdHJpbmcgZ2V0KGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSkgY29uc3QKICAgICAgICAg ewogICAgICAgICAgICAgcmV0dXJuIEhhc2hNYXA8QXRvbWljU3RyaW5nLCBTdHJpbmcsIENhc2VG b2xkaW5nSGFzaD46OmdldChuYW1lKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9X ZWJTb2NrZXRIYW5kc2hha2UuY3BwIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZS5jcHAKaW5kZXggODgzZjg0Yi4uOTJhYTAxYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS93ZWJz b2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dl YlNvY2tldEhhbmRzaGFrZS5jcHAKQEAgLTQxLDkgKzQxLDExIEBACiAjaW5jbHVkZSAiSFRUUEhl YWRlck1hcC5oIgogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5j bHVkZSAiUmVzb3VyY2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4 dC5oIgogI2luY2x1ZGUgIlNlY3VyaXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU3RyaW5nQnVpbGRl ci5oIgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFz Lmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCkBAIC0xNTUsNDUgKzE1Nyw3OSBAQCBTdHJp bmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRMb2NhdGlvbigpIGNvbnN0CiAgICAgcmV0dXJu IGJ1aWxkZXIudG9TdHJpbmcoKTsKIH0KIAotQ1N0cmluZyBXZWJTb2NrZXRIYW5kc2hha2U6OmNs aWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAorUGFzc093blB0cjxSZXNvdXJjZVJlcXVlc3Q+ IFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpIGNvbnN0CiB7Ci0g ICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOwotCi0gICAgYnVpbGRlci5hcHBlbmQoIkdFVCAiKTsK LSAgICBidWlsZGVyLmFwcGVuZChyZXNvdXJjZU5hbWUobV91cmwpKTsKLSAgICBidWlsZGVyLmFw cGVuZCgiIEhUVFAvMS4xXHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJVcGdyYWRlOiBXZWJT b2NrZXRcclxuIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoIkNvbm5lY3Rpb246IFVwZ3JhZGVcclxu Iik7Ci0gICAgYnVpbGRlci5hcHBlbmQoIkhvc3Q6ICIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKG1f dXJsLmhvc3QoKS5sb3dlcigpKTsKLSAgICBpZiAobV91cmwucG9ydCgpKSB7Ci0gICAgICAgIGlm ICgoIW1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJs LnBvcnQoKSAhPSA0NDMpKSB7Ci0gICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiIpOwotICAg ICAgICAgICAgYnVpbGRlci5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV91cmwucG9ydCgpKSk7Ci0g ICAgICAgIH0KLSAgICB9Ci0gICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKLSAgICBidWlsZGVy LmFwcGVuZCgiT3JpZ2luOiAiKTsKLSAgICBidWlsZGVyLmFwcGVuZChjbGllbnRPcmlnaW4oKSk7 Ci0gICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKLSAgICBpZiAoIW1fY2xpZW50UHJvdG9jb2wu aXNFbXB0eSgpKSB7Ci0gICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJXZWJTb2NrZXQtUHJvdG9jb2w6 ICIpOwotICAgICAgICBidWlsZGVyLmFwcGVuZChtX2NsaWVudFByb3RvY29sKTsKLSAgICAgICAg YnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKKyAgICBPd25QdHI8UmVzb3VyY2VSZXF1ZXN0PiByZXF1 ZXN0KG5ldyBSZXNvdXJjZVJlcXVlc3QobV91cmwpKTsKKyAgICByZXF1ZXN0LT5zZXRIVFRQTWV0 aG9kKCJHRVQiKTsKKyAgICByZXF1ZXN0LT5zZXRIVFRQSGVhZGVyRmllbGQoIlVwZ3JhZGUiLCAi V2ViU29ja2V0Iik7CisgICAgcmVxdWVzdC0+c2V0SFRUUEhlYWRlckZpZWxkKCJDb25uZWN0aW9u IiwgIlVwZ3JhZGUiKTsKKyAgICBTdHJpbmdCdWlsZGVyIGhvc3Q7CisgICAgaG9zdC5hcHBlbmQo bV91cmwuaG9zdCgpLmxvd2VyKCkpOworICAgIGlmIChtX3VybC5wb3J0KCkgJiYgKCghbV9zZWN1 cmUgJiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9 IDQ0MykpKSB7CisgICAgICAgIGhvc3QuYXBwZW5kKCI6Iik7CisgICAgICAgIGhvc3QuYXBwZW5k KFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwogICAgIH0KKyAgICByZXF1ZXN0LT5zZXRI VFRQSGVhZGVyRmllbGQoIkhvc3QiLCBob3N0LnRvU3RyaW5nKCkpOworICAgIHJlcXVlc3QtPnNl dEhUVFBIZWFkZXJGaWVsZCgiT3JpZ2luIiwgY2xpZW50T3JpZ2luKCkpOworICAgIGlmICghbV9j bGllbnRQcm90b2NvbC5pc0VtcHR5KCkpCisgICAgICAgIHJlcXVlc3QtPnNldEhUVFBIZWFkZXJG aWVsZCgiV2ViU29ja2V0LVByb3RvY29sIiwgbV9jbGllbnRQcm90b2NvbCk7CisKICAgICBLVVJM IHVybCA9IGh0dHBVUkxGb3JBdXRoZW50aWNhdGlvbkFuZENvb2tpZXMoKTsKICAgICAvLyBGSVhN RTogc2V0IGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIG9yIGNvb2tpZXMgZm9yIHVybC4KICAg ICAvLyBTZXQgIkF1dGhvcml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1dGhlbnRpY2F0aW9u IGluZm9ybWF0aW9uIGV4aXN0cyBmb3IgdXJsLgogICAgIGlmIChtX2NvbnRleHQtPmlzRG9jdW1l bnQoKSkgewogICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2FzdDxEb2N1bWVu dCo+KG1fY29udGV4dCk7CiAgICAgICAgIFN0cmluZyBjb29raWUgPSBjb29raWVzKGRvY3VtZW50 LCB1cmwpOwotICAgICAgICBpZiAoIWNvb2tpZS5pc0VtcHR5KCkpIHsKLSAgICAgICAgICAgIGJ1 aWxkZXIuYXBwZW5kKCJDb29raWU6ICIpOwotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoY29v a2llKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgICAgIH0KKyAg ICAgICAgaWYgKCFjb29raWUuaXNFbXB0eSgpKQorICAgICAgICAgICAgcmVxdWVzdC0+c2V0SFRU UEhlYWRlckZpZWxkKCJDb29raWUiLCBjb29raWUpOwogICAgICAgICAvLyBTZXQgIkNvb2tpZTI6 IDxjb29raWU+IiBpZiBjb29raWVzIDIgZXhpc3RzIGZvciB1cmw/CiAgICAgfQorCisgICAgcmV0 dXJuIHJlcXVlc3QucmVsZWFzZSgpOworfQorCituYW1lc3BhY2UgeworCit2b2lkIGFkZEhUVFBI ZWFkZXJGaWVsZChTdHJpbmdCdWlsZGVyJiBidWlsZGVyLCBjb25zdCBBdG9taWNTdHJpbmcmIG5h bWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpCit7CisgICAgYnVpbGRlci5hcHBlbmQobmFtZSk7Cisg ICAgYnVpbGRlci5hcHBlbmQoIjogIik7CisgICAgYnVpbGRlci5hcHBlbmQodmFsdWUpOworICAg IGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Cit9CisKK30gLy8gYW5vbnltb3VzIG5hbWVzcGFjZQor CitDU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNv bnN0Cit7CisgICAgT3duUHRyPFJlc291cmNlUmVxdWVzdD4gcmVxdWVzdChjbGllbnRIYW5kc2hh a2VSZXF1ZXN0KCkpOworCisgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOworICAgIGJ1aWxkZXIu YXBwZW5kKHJlcXVlc3QtPmh0dHBNZXRob2QoKSk7CisgICAgYnVpbGRlci5hcHBlbmQoIiAiKTsK KyAgICBidWlsZGVyLmFwcGVuZChyZXNvdXJjZU5hbWUocmVxdWVzdC0+dXJsKCkpKTsKKyAgICBi dWlsZGVyLmFwcGVuZCgiIEhUVFAvMS4xXHJcbiIpOworCisgICAgLy8gQ3VycmVudCBXZWIgU29j a2V0IHByb3RvY29sIHNwZWMgcmVxdWlyZXMgdGhlIGZpcnN0IGZpdmUgKG9yIHBvc3NpYmx5IGZv dXIpIGhlYWRlcnMgc2hvdWxkIGFwcGVhciBpbiB0aGUgZm9sbG93aW5nIG9yZGVyOgorICAgIC8v IFVwZ3JhZGUsIENvbm5lY3Rpb24sIEhvc3QsIE9yaWdpbiwgYW5kIFdlYlNvY2tldC1Qcm90b2Nv bCAob3B0aW9uYWwpLgorICAgIGNvbnN0IEhUVFBIZWFkZXJNYXAmIGhlYWRlcnMocmVxdWVzdC0+ aHR0cEhlYWRlckZpZWxkcygpKTsKKyAgICBBdG9taWNTdHJpbmcgdXBncmFkZSgiVXBncmFkZSIp OworICAgIGFkZEhUVFBIZWFkZXJGaWVsZChidWlsZGVyLCB1cGdyYWRlLCBoZWFkZXJzLmdldCh1 cGdyYWRlKSk7CisgICAgQXRvbWljU3RyaW5nIGNvbm5lY3Rpb24oIkNvbm5lY3Rpb24iKTsKKyAg ICBhZGRIVFRQSGVhZGVyRmllbGQoYnVpbGRlciwgY29ubmVjdGlvbiwgaGVhZGVycy5nZXQoY29u bmVjdGlvbikpOworICAgIEF0b21pY1N0cmluZyBob3N0KCJIb3N0Iik7CisgICAgYWRkSFRUUEhl YWRlckZpZWxkKGJ1aWxkZXIsIGhvc3QsIGhlYWRlcnMuZ2V0KGhvc3QpKTsKKyAgICBBdG9taWNT dHJpbmcgb3JpZ2luKCJPcmlnaW4iKTsKKyAgICBhZGRIVFRQSGVhZGVyRmllbGQoYnVpbGRlciwg b3JpZ2luLCBoZWFkZXJzLmdldChvcmlnaW4pKTsKKyAgICBBdG9taWNTdHJpbmcgd2ViU29ja2V0 UHJvdG9jb2woIldlYlNvY2tldC1Qcm90b2NvbCIpOworICAgIGlmIChoZWFkZXJzLmNvbnRhaW5z KHdlYlNvY2tldFByb3RvY29sKSkKKyAgICAgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIs IHdlYlNvY2tldFByb3RvY29sLCBoZWFkZXJzLmdldCh3ZWJTb2NrZXRQcm90b2NvbCkpOworCisg ICAgLy8gUHJpbnQgcmVtYWluaW5nIGhlYWRlciBmaWVsZHMuCisgICAgZm9yIChIVFRQSGVhZGVy TWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRlcnMuYmVnaW4oKSwgZW5kID0gaGVhZGVycy5l bmQoKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICBpZiAoaXQtPmZpcnN0ICE9IHVwZ3JhZGUg JiYgaXQtPmZpcnN0ICE9IGNvbm5lY3Rpb24gJiYgaXQtPmZpcnN0ICE9IGhvc3QgJiYgaXQtPmZp cnN0ICE9IG9yaWdpbiAmJiBpdC0+Zmlyc3QgIT0gd2ViU29ja2V0UHJvdG9jb2wpCisgICAgICAg ICAgICBhZGRIVFRQSGVhZGVyRmllbGQoYnVpbGRlciwgaXQtPmZpcnN0LCBpdC0+c2Vjb25kKTsK KwogICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CiAgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJp bmcoKS51dGY4KCk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlLmggYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKaW5k ZXggYmRhMzIwYS4uMTEwNzBiZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNv Y2tldEhhbmRzaGFrZS5oCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hh a2UuaApAQCAtMzYsMTEgKzM2LDEzIEBACiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBs YXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8 d3RmL1Bhc3NPd25QdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgY2xhc3MgU2Ny aXB0RXhlY3V0aW9uQ29udGV4dDsKICAgICBjbGFzcyBIVFRQSGVhZGVyTWFwOworICAgIGNsYXNz IFJlc291cmNlUmVxdWVzdDsKIAogICAgIGNsYXNzIFdlYlNvY2tldEhhbmRzaGFrZSA6IHB1Ymxp YyBOb25jb3B5YWJsZSB7CiAgICAgcHVibGljOgpAQCAtNjMsNiArNjUsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgIFN0cmluZyBjbGllbnRPcmlnaW4oKSBjb25zdDsKICAgICAgICAg U3RyaW5nIGNsaWVudExvY2F0aW9uKCkgY29uc3Q7CiAKKyAgICAgICAgUGFzc093blB0cjxSZXNv dXJjZVJlcXVlc3Q+IGNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKSBjb25zdDsKICAgICAgICAgQ1N0 cmluZyBjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3Q7CiAKICAgICAgICAgdm9pZCByZXNl dCgpOwo= 48467 2010-02-09 23:59:49 -0800 2010-02-10 00:16:16 -0800 Patch v2 (apply ukai's comments) bug-34784-20100210165947.patch text/plain 6832 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NzMwZDQ2Yy4uYTA0NjBjNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wMi0wOSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBtZXRob2QgdG8gV2ViU29ja2V0SGFuZHNoYWtlIHRoYXQg cmV0dXJucyB0aGUgaGFuZHNoYWtlIHJlcXVlc3QgYXMKKyAgICAgICAgYSBSZXNvdXJjZVJlcXVl c3QuCisKKyAgICAgICAgVGhpcyBtZXRob2Qgd2lsbCBiZSBuZWNlc3NhcnkgdG8gbGV0IHRoZSBX ZWIgSW5zcGVjdG9yIHNob3cgdGhlIGNvbnRlbnQgb2YKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVl c3RzLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgc2luY2UgdGhlIGN1cnJlbnQgdGVzdHMgd2ls bCBzdWZmaWNlIChMYXlvdXRUZXN0cy93ZWJzb2NrZXQvKikuCisKKyAgICAgICAgV2ViU29ja2V0 SGFuZHNoYWtlIG5lZWRzIHRvIHJldHVybiBoYW5kc2hha2UgcmVxdWVzdCBhcyBhIFJlc291cmNl UmVxdWVzdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzQ3ODQKKworICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlUmVxdWVz dCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFr ZU1lc3NhZ2UpOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmg6CisK IDIwMTAtMDItMDkgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgICog cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHA6CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2UuY3BwCmluZGV4IDg4M2Y4NGIuLjBiMDFiZWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv d2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0 cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCkBAIC00MSw5ICs0MSwxMSBAQAogI2luY2x1ZGUgIkhU VFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgor I2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlN0cmluZ0J1 aWxkZXIuaCIKKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0cmluZ0V4 dHJhcy5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIApAQCAtMTU1LDQ1ICsxNTcsODQgQEAg U3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAogICAgIHJl dHVybiBidWlsZGVyLnRvU3RyaW5nKCk7CiB9CiAKLUNTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtl OjpjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3QKK1Bhc3NPd25QdHI8UmVzb3VyY2VSZXF1 ZXN0PiBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKSBjb25zdAog ewotICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKLQotICAgIGJ1aWxkZXIuYXBwZW5kKCJHRVQg Iik7Ci0gICAgYnVpbGRlci5hcHBlbmQocmVzb3VyY2VOYW1lKG1fdXJsKSk7Ci0gICAgYnVpbGRl ci5hcHBlbmQoIiBIVFRQLzEuMVxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiVXBncmFkZTog V2ViU29ja2V0XHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJDb25uZWN0aW9uOiBVcGdyYWRl XHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJIb3N0OiAiKTsKLSAgICBidWlsZGVyLmFwcGVu ZChtX3VybC5ob3N0KCkubG93ZXIoKSk7Ci0gICAgaWYgKG1fdXJsLnBvcnQoKSkgewotICAgICAg ICBpZiAoKCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAmJiBt X3VybC5wb3J0KCkgIT0gNDQzKSkgewotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIjoiKTsK LSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkp OwotICAgICAgICB9Ci0gICAgfQotICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgYnVp bGRlci5hcHBlbmQoIk9yaWdpbjogIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoY2xpZW50T3JpZ2lu KCkpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgaWYgKCFtX2NsaWVudFByb3Rv Y29sLmlzRW1wdHkoKSkgewotICAgICAgICBidWlsZGVyLmFwcGVuZCgiV2ViU29ja2V0LVByb3Rv Y29sOiAiKTsKLSAgICAgICAgYnVpbGRlci5hcHBlbmQobV9jbGllbnRQcm90b2NvbCk7Ci0gICAg ICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisgICAgT3duUHRyPFJlc291cmNlUmVxdWVzdD4g cmVxdWVzdChuZXcgUmVzb3VyY2VSZXF1ZXN0KG1fdXJsKSk7CisgICAgcmVxdWVzdC0+c2V0SFRU UE1ldGhvZCgiR0VUIik7CisgICAgcmVxdWVzdC0+c2V0SFRUUEhlYWRlckZpZWxkKCJVcGdyYWRl IiwgIldlYlNvY2tldCIpOworICAgIHJlcXVlc3QtPnNldEhUVFBIZWFkZXJGaWVsZCgiQ29ubmVj dGlvbiIsICJVcGdyYWRlIik7CisgICAgU3RyaW5nQnVpbGRlciBob3N0OworICAgIGhvc3QuYXBw ZW5kKG1fdXJsLmhvc3QoKS5sb3dlcigpKTsKKyAgICBpZiAobV91cmwucG9ydCgpICYmICgoIW1f c2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJsLnBvcnQo KSAhPSA0NDMpKSkgeworICAgICAgICBob3N0LmFwcGVuZCgiOiIpOworICAgICAgICBob3N0LmFw cGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsKICAgICB9CisgICAgcmVxdWVzdC0+ c2V0SFRUUEhlYWRlckZpZWxkKCJIb3N0IiwgaG9zdC50b1N0cmluZygpKTsKKyAgICByZXF1ZXN0 LT5zZXRIVFRQSGVhZGVyRmllbGQoIk9yaWdpbiIsIGNsaWVudE9yaWdpbigpKTsKKyAgICBpZiAo IW1fY2xpZW50UHJvdG9jb2wuaXNFbXB0eSgpKQorICAgICAgICByZXF1ZXN0LT5zZXRIVFRQSGVh ZGVyRmllbGQoIldlYlNvY2tldC1Qcm90b2NvbCIsIG1fY2xpZW50UHJvdG9jb2wpOworCiAgICAg S1VSTCB1cmwgPSBodHRwVVJMRm9yQXV0aGVudGljYXRpb25BbmRDb29raWVzKCk7CiAgICAgLy8g RklYTUU6IHNldCBhdXRoZW50aWNhdGlvbiBpbmZvcm1hdGlvbiBvciBjb29raWVzIGZvciB1cmwu CiAgICAgLy8gU2V0ICJBdXRob3JpemF0aW9uOiA8Y3JlZGVudGlhbHM+IiBpZiBhdXRoZW50aWNh dGlvbiBpbmZvcm1hdGlvbiBleGlzdHMgZm9yIHVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0Rv Y3VtZW50KCkpIHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9j dW1lbnQqPihtX2NvbnRleHQpOwogICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llcyhkb2N1 bWVudCwgdXJsKTsKLSAgICAgICAgaWYgKCFjb29raWUuaXNFbXB0eSgpKSB7Ci0gICAgICAgICAg ICBidWlsZGVyLmFwcGVuZCgiQ29va2llOiAiKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5k KGNvb2tpZSk7Ci0gICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgICAgICB9 CisgICAgICAgIGlmICghY29va2llLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlcXVlc3QtPnNl dEhUVFBIZWFkZXJGaWVsZCgiQ29va2llIiwgY29va2llKTsKICAgICAgICAgLy8gU2V0ICJDb29r aWUyOiA8Y29va2llPiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgdXJsPwogICAgIH0KKworICAg IHJldHVybiByZXF1ZXN0LnJlbGVhc2UoKTsKK30KKworbmFtZXNwYWNlIHsKKwordm9pZCBhZGRI VFRQSGVhZGVyRmllbGQoU3RyaW5nQnVpbGRlciYgYnVpbGRlciwgY29uc3QgY2hhciogbmFtZSwg Y29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBidWlsZGVyLmFwcGVuZChuYW1lKTsKKyAgICBi dWlsZGVyLmFwcGVuZCgiOiAiKTsKKyAgICBidWlsZGVyLmFwcGVuZCh2YWx1ZSk7CisgICAgYnVp bGRlci5hcHBlbmQoIlxyXG4iKTsKK30KKwordm9pZCBhZGRIVFRQSGVhZGVyRmllbGQoU3RyaW5n QnVpbGRlciYgYnVpbGRlciwgY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcm IHZhbHVlKQoreworICAgIGJ1aWxkZXIuYXBwZW5kKG5hbWUpOworICAgIGJ1aWxkZXIuYXBwZW5k KCI6ICIpOworICAgIGJ1aWxkZXIuYXBwZW5kKHZhbHVlKTsKKyAgICBidWlsZGVyLmFwcGVuZCgi XHJcbiIpOworfQorCit9IC8vIGFub255bW91cyBuYW1lc3BhY2UKKworQ1N0cmluZyBXZWJTb2Nr ZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAoreworICAgIE93blB0 cjxSZXNvdXJjZVJlcXVlc3Q+IHJlcXVlc3QoY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpKTsKKwor ICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKKyAgICBidWlsZGVyLmFwcGVuZChyZXF1ZXN0LT5o dHRwTWV0aG9kKCkpOworICAgIGJ1aWxkZXIuYXBwZW5kKCIgIik7CisgICAgYnVpbGRlci5hcHBl bmQocmVzb3VyY2VOYW1lKHJlcXVlc3QtPnVybCgpKSk7CisgICAgYnVpbGRlci5hcHBlbmQoIiBI VFRQLzEuMVxyXG4iKTsKKworICAgIC8vIEN1cnJlbnQgV2ViIFNvY2tldCBwcm90b2NvbCBzcGVj IHJlcXVpcmVzIHRoZSBmaXJzdCBmaXZlIChvciBwb3NzaWJseSBmb3VyKSBoZWFkZXJzIHNob3Vs ZCBhcHBlYXIgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKKyAgICAvLyBVcGdyYWRlLCBDb25uZWN0 aW9uLCBIb3N0LCBPcmlnaW4sIGFuZCBXZWJTb2NrZXQtUHJvdG9jb2wgKG9wdGlvbmFsKS4KKyAg ICBjb25zdCBIVFRQSGVhZGVyTWFwJiBoZWFkZXJzKHJlcXVlc3QtPmh0dHBIZWFkZXJGaWVsZHMo KSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsICJVcGdyYWRlIiwgaGVhZGVycy5n ZXQoIlVwZ3JhZGUiKSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsICJDb25uZWN0 aW9uIiwgaGVhZGVycy5nZXQoIkNvbm5lY3Rpb24iKSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxk KGJ1aWxkZXIsICJIb3N0IiwgaGVhZGVycy5nZXQoIkhvc3QiKSk7CisgICAgYWRkSFRUUEhlYWRl ckZpZWxkKGJ1aWxkZXIsICJPcmlnaW4iLCBoZWFkZXJzLmdldCgiT3JpZ2luIikpOworICAgIGlm IChoZWFkZXJzLmNvbnRhaW5zKCJXZWJTb2NrZXQtUHJvdG9jb2wiKSkKKyAgICAgICAgYWRkSFRU UEhlYWRlckZpZWxkKGJ1aWxkZXIsICJXZWJTb2NrZXQtUHJvdG9jb2wiLCBoZWFkZXJzLmdldCgi V2ViU29ja2V0LVByb3RvY29sIikpOworCisgICAgLy8gUHJpbnQgdGhlIHJlbWFpbmluZyBoZWFk ZXIgZmllbGRzLgorICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBo ZWFkZXJzLmJlZ2luKCksIGVuZCA9IGhlYWRlcnMuZW5kKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAg ICAgICAgaWYgKCFlcXVhbElnbm9yaW5nQ2FzZShpdC0+Zmlyc3QsICJVcGdyYWRlIikgJiYgIWVx dWFsSWdub3JpbmdDYXNlKGl0LT5maXJzdCwgIkNvbm5lY3Rpb24iKSAmJgorICAgICAgICAgICAg IWVxdWFsSWdub3JpbmdDYXNlKGl0LT5maXJzdCwgIkhvc3QiKSAmJiAhZXF1YWxJZ25vcmluZ0Nh c2UoaXQtPmZpcnN0LCAiT3JpZ2luIikgJiYKKyAgICAgICAgICAgICFlcXVhbElnbm9yaW5nQ2Fz ZShpdC0+Zmlyc3QsICJXZWJTb2NrZXQtUHJvdG9jb2wiKSkKKyAgICAgICAgICAgIGFkZEhUVFBI ZWFkZXJGaWVsZChidWlsZGVyLCBpdC0+Zmlyc3QsIGl0LT5zZWNvbmQpOworCiAgICAgYnVpbGRl ci5hcHBlbmQoIlxyXG4iKTsKICAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpLnV0ZjgoKTsK IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaCBi L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaAppbmRleCBiZGEzMjBhLi4x MTA3MGJkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtl LmgKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCkBAIC0zNiwx MSArMzYsMTMgQEAKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcu aCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0 ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICBjbGFzcyBTY3JpcHRFeGVjdXRpb25D b250ZXh0OwogICAgIGNsYXNzIEhUVFBIZWFkZXJNYXA7CisgICAgY2xhc3MgUmVzb3VyY2VSZXF1 ZXN0OwogCiAgICAgY2xhc3MgV2ViU29ja2V0SGFuZHNoYWtlIDogcHVibGljIE5vbmNvcHlhYmxl IHsKICAgICBwdWJsaWM6CkBAIC02Myw2ICs2NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgU3RyaW5nIGNsaWVudE9yaWdpbigpIGNvbnN0OwogICAgICAgICBTdHJpbmcgY2xpZW50 TG9jYXRpb24oKSBjb25zdDsKIAorICAgICAgICBQYXNzT3duUHRyPFJlc291cmNlUmVxdWVzdD4g Y2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpIGNvbnN0OwogICAgICAgICBDU3RyaW5nIGNsaWVudEhh bmRzaGFrZU1lc3NhZ2UoKSBjb25zdDsKIAogICAgICAgICB2b2lkIHJlc2V0KCk7Cg== 48468 2010-02-10 00:16:22 -0800 2010-02-21 23:39:38 -0800 Patch v3 (style fix) bug-34784-20100210171620.patch text/plain 6832 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg NzMwZDQ2Yy4uYTA0NjBjNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMC0wMi0wOSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBtZXRob2QgdG8gV2ViU29ja2V0SGFuZHNoYWtlIHRoYXQg cmV0dXJucyB0aGUgaGFuZHNoYWtlIHJlcXVlc3QgYXMKKyAgICAgICAgYSBSZXNvdXJjZVJlcXVl c3QuCisKKyAgICAgICAgVGhpcyBtZXRob2Qgd2lsbCBiZSBuZWNlc3NhcnkgdG8gbGV0IHRoZSBX ZWIgSW5zcGVjdG9yIHNob3cgdGhlIGNvbnRlbnQgb2YKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVl c3RzLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgc2luY2UgdGhlIGN1cnJlbnQgdGVzdHMgd2ls bCBzdWZmaWNlIChMYXlvdXRUZXN0cy93ZWJzb2NrZXQvKikuCisKKyAgICAgICAgV2ViU29ja2V0 SGFuZHNoYWtlIG5lZWRzIHRvIHJldHVybiBoYW5kc2hha2UgcmVxdWVzdCBhcyBhIFJlc291cmNl UmVxdWVzdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzQ3ODQKKworICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlUmVxdWVz dCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFr ZU1lc3NhZ2UpOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmg6CisK IDIwMTAtMDItMDkgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgICog cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHA6CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2UuY3BwCmluZGV4IDg4M2Y4NGIuLmRhZWUxODcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv d2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0 cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCkBAIC00MSw5ICs0MSwxMSBAQAogI2luY2x1ZGUgIkhU VFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgor I2luY2x1ZGUgIlJlc291cmNlUmVxdWVzdC5oIgogI2luY2x1ZGUgIlNjcmlwdEV4ZWN1dGlvbkNv bnRleHQuaCIKICNpbmNsdWRlICJTZWN1cml0eU9yaWdpbi5oIgogI2luY2x1ZGUgIlN0cmluZ0J1 aWxkZXIuaCIKKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1N0cmluZ0V4 dHJhcy5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIApAQCAtMTU1LDQ1ICsxNTcsODQgQEAg U3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAogICAgIHJl dHVybiBidWlsZGVyLnRvU3RyaW5nKCk7CiB9CiAKLUNTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtl OjpjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3QKK1Bhc3NPd25QdHI8UmVzb3VyY2VSZXF1 ZXN0PiBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKSBjb25zdAog ewotICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKLQotICAgIGJ1aWxkZXIuYXBwZW5kKCJHRVQg Iik7Ci0gICAgYnVpbGRlci5hcHBlbmQocmVzb3VyY2VOYW1lKG1fdXJsKSk7Ci0gICAgYnVpbGRl ci5hcHBlbmQoIiBIVFRQLzEuMVxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiVXBncmFkZTog V2ViU29ja2V0XHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJDb25uZWN0aW9uOiBVcGdyYWRl XHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJIb3N0OiAiKTsKLSAgICBidWlsZGVyLmFwcGVu ZChtX3VybC5ob3N0KCkubG93ZXIoKSk7Ci0gICAgaWYgKG1fdXJsLnBvcnQoKSkgewotICAgICAg ICBpZiAoKCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAmJiBt X3VybC5wb3J0KCkgIT0gNDQzKSkgewotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIjoiKTsK LSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkp OwotICAgICAgICB9Ci0gICAgfQotICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgYnVp bGRlci5hcHBlbmQoIk9yaWdpbjogIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoY2xpZW50T3JpZ2lu KCkpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7Ci0gICAgaWYgKCFtX2NsaWVudFByb3Rv Y29sLmlzRW1wdHkoKSkgewotICAgICAgICBidWlsZGVyLmFwcGVuZCgiV2ViU29ja2V0LVByb3Rv Y29sOiAiKTsKLSAgICAgICAgYnVpbGRlci5hcHBlbmQobV9jbGllbnRQcm90b2NvbCk7Ci0gICAg ICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisgICAgT3duUHRyPFJlc291cmNlUmVxdWVzdD4g cmVxdWVzdChuZXcgUmVzb3VyY2VSZXF1ZXN0KG1fdXJsKSk7CisgICAgcmVxdWVzdC0+c2V0SFRU UE1ldGhvZCgiR0VUIik7CisgICAgcmVxdWVzdC0+c2V0SFRUUEhlYWRlckZpZWxkKCJVcGdyYWRl IiwgIldlYlNvY2tldCIpOworICAgIHJlcXVlc3QtPnNldEhUVFBIZWFkZXJGaWVsZCgiQ29ubmVj dGlvbiIsICJVcGdyYWRlIik7CisgICAgU3RyaW5nQnVpbGRlciBob3N0OworICAgIGhvc3QuYXBw ZW5kKG1fdXJsLmhvc3QoKS5sb3dlcigpKTsKKyAgICBpZiAobV91cmwucG9ydCgpICYmICgoIW1f c2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJsLnBvcnQo KSAhPSA0NDMpKSkgeworICAgICAgICBob3N0LmFwcGVuZCgiOiIpOworICAgICAgICBob3N0LmFw cGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsKICAgICB9CisgICAgcmVxdWVzdC0+ c2V0SFRUUEhlYWRlckZpZWxkKCJIb3N0IiwgaG9zdC50b1N0cmluZygpKTsKKyAgICByZXF1ZXN0 LT5zZXRIVFRQSGVhZGVyRmllbGQoIk9yaWdpbiIsIGNsaWVudE9yaWdpbigpKTsKKyAgICBpZiAo IW1fY2xpZW50UHJvdG9jb2wuaXNFbXB0eSgpKQorICAgICAgICByZXF1ZXN0LT5zZXRIVFRQSGVh ZGVyRmllbGQoIldlYlNvY2tldC1Qcm90b2NvbCIsIG1fY2xpZW50UHJvdG9jb2wpOworCiAgICAg S1VSTCB1cmwgPSBodHRwVVJMRm9yQXV0aGVudGljYXRpb25BbmRDb29raWVzKCk7CiAgICAgLy8g RklYTUU6IHNldCBhdXRoZW50aWNhdGlvbiBpbmZvcm1hdGlvbiBvciBjb29raWVzIGZvciB1cmwu CiAgICAgLy8gU2V0ICJBdXRob3JpemF0aW9uOiA8Y3JlZGVudGlhbHM+IiBpZiBhdXRoZW50aWNh dGlvbiBpbmZvcm1hdGlvbiBleGlzdHMgZm9yIHVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0Rv Y3VtZW50KCkpIHsKICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9j dW1lbnQqPihtX2NvbnRleHQpOwogICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llcyhkb2N1 bWVudCwgdXJsKTsKLSAgICAgICAgaWYgKCFjb29raWUuaXNFbXB0eSgpKSB7Ci0gICAgICAgICAg ICBidWlsZGVyLmFwcGVuZCgiQ29va2llOiAiKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5k KGNvb2tpZSk7Ci0gICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgICAgICB9 CisgICAgICAgIGlmICghY29va2llLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlcXVlc3QtPnNl dEhUVFBIZWFkZXJGaWVsZCgiQ29va2llIiwgY29va2llKTsKICAgICAgICAgLy8gU2V0ICJDb29r aWUyOiA8Y29va2llPiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgdXJsPwogICAgIH0KKworICAg IHJldHVybiByZXF1ZXN0LnJlbGVhc2UoKTsKK30KKworbmFtZXNwYWNlIHsKKwordm9pZCBhZGRI VFRQSGVhZGVyRmllbGQoU3RyaW5nQnVpbGRlciYgYnVpbGRlciwgY29uc3QgY2hhciogbmFtZSwg Y29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBidWlsZGVyLmFwcGVuZChuYW1lKTsKKyAgICBi dWlsZGVyLmFwcGVuZCgiOiAiKTsKKyAgICBidWlsZGVyLmFwcGVuZCh2YWx1ZSk7CisgICAgYnVp bGRlci5hcHBlbmQoIlxyXG4iKTsKK30KKwordm9pZCBhZGRIVFRQSGVhZGVyRmllbGQoU3RyaW5n QnVpbGRlciYgYnVpbGRlciwgY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcm IHZhbHVlKQoreworICAgIGJ1aWxkZXIuYXBwZW5kKG5hbWUpOworICAgIGJ1aWxkZXIuYXBwZW5k KCI6ICIpOworICAgIGJ1aWxkZXIuYXBwZW5kKHZhbHVlKTsKKyAgICBidWlsZGVyLmFwcGVuZCgi XHJcbiIpOworfQorCit9IC8vIGFub255bW91cyBuYW1lc3BhY2UKKworQ1N0cmluZyBXZWJTb2Nr ZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAoreworICAgIE93blB0 cjxSZXNvdXJjZVJlcXVlc3Q+IHJlcXVlc3QoY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpKTsKKwor ICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKKyAgICBidWlsZGVyLmFwcGVuZChyZXF1ZXN0LT5o dHRwTWV0aG9kKCkpOworICAgIGJ1aWxkZXIuYXBwZW5kKCIgIik7CisgICAgYnVpbGRlci5hcHBl bmQocmVzb3VyY2VOYW1lKHJlcXVlc3QtPnVybCgpKSk7CisgICAgYnVpbGRlci5hcHBlbmQoIiBI VFRQLzEuMVxyXG4iKTsKKworICAgIC8vIEN1cnJlbnQgV2ViIFNvY2tldCBwcm90b2NvbCBzcGVj IHJlcXVpcmVzIHRoZSBmaXJzdCBmaXZlIChvciBwb3NzaWJseSBmb3VyKSBoZWFkZXJzIHNob3Vs ZCBhcHBlYXIgaW4gdGhlIGZvbGxvd2luZyBvcmRlcjoKKyAgICAvLyBVcGdyYWRlLCBDb25uZWN0 aW9uLCBIb3N0LCBPcmlnaW4sIGFuZCBXZWJTb2NrZXQtUHJvdG9jb2wgKG9wdGlvbmFsKS4KKyAg ICBjb25zdCBIVFRQSGVhZGVyTWFwJiBoZWFkZXJzKHJlcXVlc3QtPmh0dHBIZWFkZXJGaWVsZHMo KSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsICJVcGdyYWRlIiwgaGVhZGVycy5n ZXQoIlVwZ3JhZGUiKSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxkKGJ1aWxkZXIsICJDb25uZWN0 aW9uIiwgaGVhZGVycy5nZXQoIkNvbm5lY3Rpb24iKSk7CisgICAgYWRkSFRUUEhlYWRlckZpZWxk KGJ1aWxkZXIsICJIb3N0IiwgaGVhZGVycy5nZXQoIkhvc3QiKSk7CisgICAgYWRkSFRUUEhlYWRl ckZpZWxkKGJ1aWxkZXIsICJPcmlnaW4iLCBoZWFkZXJzLmdldCgiT3JpZ2luIikpOworICAgIGlm IChoZWFkZXJzLmNvbnRhaW5zKCJXZWJTb2NrZXQtUHJvdG9jb2wiKSkKKyAgICAgICAgYWRkSFRU UEhlYWRlckZpZWxkKGJ1aWxkZXIsICJXZWJTb2NrZXQtUHJvdG9jb2wiLCBoZWFkZXJzLmdldCgi V2ViU29ja2V0LVByb3RvY29sIikpOworCisgICAgLy8gUHJpbnQgdGhlIHJlbWFpbmluZyBoZWFk ZXIgZmllbGRzLgorICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBo ZWFkZXJzLmJlZ2luKCksIGVuZCA9IGhlYWRlcnMuZW5kKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAg ICAgICAgaWYgKCFlcXVhbElnbm9yaW5nQ2FzZShpdC0+Zmlyc3QsICJVcGdyYWRlIikgJiYgIWVx dWFsSWdub3JpbmdDYXNlKGl0LT5maXJzdCwgIkNvbm5lY3Rpb24iKQorICAgICAgICAgICAgJiYg IWVxdWFsSWdub3JpbmdDYXNlKGl0LT5maXJzdCwgIkhvc3QiKSAmJiAhZXF1YWxJZ25vcmluZ0Nh c2UoaXQtPmZpcnN0LCAiT3JpZ2luIikKKyAgICAgICAgICAgICYmICFlcXVhbElnbm9yaW5nQ2Fz ZShpdC0+Zmlyc3QsICJXZWJTb2NrZXQtUHJvdG9jb2wiKSkKKyAgICAgICAgICAgIGFkZEhUVFBI ZWFkZXJGaWVsZChidWlsZGVyLCBpdC0+Zmlyc3QsIGl0LT5zZWNvbmQpOworCiAgICAgYnVpbGRl ci5hcHBlbmQoIlxyXG4iKTsKICAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpLnV0ZjgoKTsK IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaCBi L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaAppbmRleCBiZGEzMjBhLi4x MTA3MGJkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtl LmgKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCkBAIC0zNiwx MSArMzYsMTMgQEAKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcu aCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0 ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICBjbGFzcyBTY3JpcHRFeGVjdXRpb25D b250ZXh0OwogICAgIGNsYXNzIEhUVFBIZWFkZXJNYXA7CisgICAgY2xhc3MgUmVzb3VyY2VSZXF1 ZXN0OwogCiAgICAgY2xhc3MgV2ViU29ja2V0SGFuZHNoYWtlIDogcHVibGljIE5vbmNvcHlhYmxl IHsKICAgICBwdWJsaWM6CkBAIC02Myw2ICs2NSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgU3RyaW5nIGNsaWVudE9yaWdpbigpIGNvbnN0OwogICAgICAgICBTdHJpbmcgY2xpZW50 TG9jYXRpb24oKSBjb25zdDsKIAorICAgICAgICBQYXNzT3duUHRyPFJlc291cmNlUmVxdWVzdD4g Y2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpIGNvbnN0OwogICAgICAgICBDU3RyaW5nIGNsaWVudEhh bmRzaGFrZU1lc3NhZ2UoKSBjb25zdDsKIAogICAgICAgICB2b2lkIHJlc2V0KCk7Cg== 49186 2010-02-21 23:39:43 -0800 2010-02-21 23:51:34 -0800 Patch v4 (Completely rewritten) bug-34784-20100222163941.patch text/plain 26673 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MDFkMWE1NC4uZDYxMDI2YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MCBAQAorMjAxMC0wMi0yMSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V2ViU29ja2V0Q2hhbm5lbDo6ZGlkT3Blbik6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpz ZXRVUkwpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpzZXRDbGllbnRQ cm90b2NvbCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OnNldFNlY3Vy ZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFr ZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpyZXNldCk6 CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaDoKKyAgICAgICAgKiB3 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6fldl YlNvY2tldEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFu ZHNoYWtlUmVxdWVzdDo6dXJsKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFr ZVJlcXVlc3Q6OnNlY3VyZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0Ojp1cGdyYWRlKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3Q6OmNvbm5lY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6aG9zdCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0OjpvcmlnaW4pOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6d2ViU29ja2V0UHJvdG9jb2wpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZHMpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZCk6CisgICAgICAgIChXZWJDb3Jl OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjphZGRFeHRyYUhlYWRlckZpZWxkKToKKyAgICAg ICAgKFdlYkNvcmU6OnJlc291cmNlTmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0OjpoYW5kc2hha2VNZXNzYWdlKToKKyAgICAgICAgKiB3ZWJzb2NrZXRz L1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpX ZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpjcmVhdGUpOgorCiAyMDEwLTAyLTE5ICBEaXJrIFNj aHVsemUgIDxrcml0QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTmlrb2xhcyBa aW1tZXJtYW5uLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUv R05VbWFrZWZpbGUuYW0KaW5kZXggMTdmZTMzZi4uMzc2Yjk2NCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0zNDQ3LDcg KzM0NDcsOSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRDaGFubmVsLmggXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xp ZW50LmggXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIFwKLQlX ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKKwlXZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmggXAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmNwcCBcCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3QuaAogCiBpZiBFTkFCTEVfV09SS0VSUwogd2ViY29yZV9zb3VyY2VzICs9IFwK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkK aW5kZXggYjgzMTZjZi4uZTJiOTJjMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkK KysrIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTM2MTksNiArMzYxOSw4IEBACiAgICAgICAg ICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmgnLAogICAgICAgICAgICAg J3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV29ya2Vy VGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRz L1dvcmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmgnLAogICAgICAgICAgICAgJ3dvcmtl cnMvQWJzdHJhY3RXb3JrZXIuY3BwJywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8g Yi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IDRjYjQ3OTQuLjQ2MWFlNjEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMjY1Myw2 ICsyNjUzLDcgQEAgU09VUkNFUyArPSBcCiAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXQuY3BwIFwK ICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIFwKICAgICB3ZWJzb2NrZXRzL1dl YlNvY2tldEhhbmRzaGFrZS5jcHAgXAorICAgIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdC5jcHAgXAogICAgIHdlYnNvY2tldHMvVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwu Y3BwIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUVycm9yQmFzZS5jcHAgXAog ICAgIHBsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFuZGxlQmFzZS5jcHAgXApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXggYzc3YzRhNS4uOWE1ZmJhNiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9XZWJDb3Jl L1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0yNzAzNywxOSArMjcwMzcsMTkgQEAK IAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXGJyZWFrX2xpbmVzLmNwcCINCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdc QmlkaVJ1bi5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0JCQkJUmVsYXRp dmVQYXRoPSIuLlxyZW5kZXJpbmdcYnJlYWtfbGluZXMuaCINCisJCQkJUmVsYXRpdmVQYXRoPSIu LlxyZW5kZXJpbmdcQmlkaVJ1bi5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAg ICAgICAgICAgICAgIDxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlS dW4uY3BwIg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFr X2xpbmVzLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KLQkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXHJlbmRlcmluZ1xCaWRpUnVuLmgiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXGJyZWFrX2xpbmVzLmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCkBA IC0yNzEwOCw3ICsyNzEwOCw3IEBACiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5s aW5lRmxvd0JveC5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAgICAgICAgICAg ICAgIDxGaWxlDQorCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5s aW5lSXRlcmF0b3IuaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCkBAIC0zNDIyOCw2ICszNDIyOCwy MiBAQAogCQkJCQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0 aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGUuY3BwIg0KKwkJCQkJPg0KKwkJCQk8 L0ZpbGU+DQorCQkJCTxGaWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEph dmFTY3JpcHRQcm9maWxlLmgiDQorCQkJCQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJ CQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNw cCINCisJCQkJCT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8RmlsZQ0KKwkJCQkJUmVsYXRpdmVQYXRo PSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuaCINCisJCQkJCT4NCisJCQkJ PC9GaWxlPg0KKwkJCQk8RmlsZQ0KIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xK U0Fic3RyYWN0V29ya2VyQ3VzdG9tLmNwcCINCiAJCQkJCT4NCiAJCQkJCTxGaWxlQ29uZmlndXJh dGlvbg0KQEAgLTM5OTA4LDIyICszOTkyNCw2IEBACiAJCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+ DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGlu Z3NcanNcSmF2YVNjcmlwdFByb2ZpbGUuY3BwIg0KLQkJCQkJPg0KLQkJCQk8L0ZpbGU+DQotCQkJ CTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9m aWxlLmgiDQotCQkJCQk+DQotCQkJCTwvRmlsZT4NCi0JCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZl UGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNwcCINCi0JCQkJCT4N Ci0JCQkJPC9GaWxlPg0KLQkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5n c1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuaCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0KLQkJ CQk8RmlsZQ0KIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xTY2hlZHVsZWRBY3Rp b24uY3BwIg0KIAkJCQkJPg0KIAkJCQkJPEZpbGVDb25maWd1cmF0aW9uDQpAQCAtNDMwMjAsMTEg KzQzMDIwLDExIEBACiAJCQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KLQkJCQkJUmVs YXRpdmVQYXRoPSIuLlxpbnNwZWN0b3JcZnJvbnQtZW5kXFRleHRWaWV3ZXIuanMiDQorCQkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRcdGV4dFZpZXdlci5jc3MiDQogCQkJ CQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5z cGVjdG9yXGZyb250LWVuZFx0ZXh0Vmlld2VyLmNzcyINCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5c aW5zcGVjdG9yXGZyb250LWVuZFxUZXh0Vmlld2VyLmpzIg0KIAkJCQkJPg0KIAkJCQk8L0ZpbGU+ DQogCQkJCTxGaWxlDQpAQCAtNDM0NTMsNiArNDM0NTMsMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxl Pg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cd2Vic29ja2V0c1xXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmNwcCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHdlYnNvY2tldHNcV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5o Ig0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5c d2Vic29ja2V0c1xXb3JrZXJUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAiDQogCQkJCT4N CiAJCQk8L0ZpbGU+DQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2ogYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpp bmRleCAzZGFhYzFmLi41MDliN2NlIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagpAQCAtMTI2Miw2ICsxMjYyLDggQEAKIAkJNzU3OTNFRDMwRDBDRTg1QjAwN0ZD MEFDIC8qIERPTU1lc3NhZ2VFdmVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNzU3OTNFRDAwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVu dC5oICovOyB9OwogCQk3NTc5M0VENDBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50 Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzU3OTNF RDEwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLzsgfTsKIAkJNzU3OTNF RDUwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudEludGVybmFsLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NTc5M0VEMjBEMENFODVCMDA3 RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50SW50ZXJuYWwuaCAqLzsgfTsKKwkJNzYzN0M1NDExMTJF N0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDAxMTJFN0I3NDAwM0Q2 Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovOyB9OworCQk3NjM3QzU0MzEx MkU3QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDIxMTJFN0I3RTAwM0Q2 Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCAqLzsgfTsKIAkJNzY5M0JBRDIxMDZD MkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjkzQkFDRTEwNkMyRENBMDA3QjA4MjMgLyogSGFsdGFi bGVQbHVnaW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQk3NjkzQkFEMzEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2OTNCQUNGMTA2QzJEQ0Ew MDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuY3BwICovOyB9OwogCQk3NjkzQkFENDEwNkMyRENBMDA3 QjA4MjMgLyogUGx1Z2luSGFsdGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA3NjkzQkFEMDEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmgg Ki87IH07CkBAIC02NjgwLDYgKzY2ODIsOCBAQAogCQk3NTc5M0VEMDBEMENFODVCMDA3RkMwQUMg LyogRE9NTWVzc2FnZUV2ZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBE T01NZXNzYWdlRXZlbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzU3OTNFRDEw RDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5vYmpjcHA7IHBhdGggPSBET01NZXNzYWdlRXZlbnQubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTc1NzkzRUQyMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZl bnRJbnRlcm5hbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NTWVzc2Fn ZUV2ZW50SW50ZXJuYWwuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzYzN0M1NDAx MTJFN0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTc2MzdDNTQyMTEyRTdCN0UwMDNENkNE QyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNzY5M0JBQ0UxMDZDMkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEhhbHRhYmxlUGx1Z2luLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNCQUNGMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVn aW5IYWx0ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGx1Z2lu SGFsdGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzY5M0JBRDAxMDZDMkRD QTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBQbHVnaW5IYWx0ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTExMTQ0 LDYgKzExMTQ4LDggQEAKIAkJNTE4QTM0QkQxMDI2QzgzMTAwMUI2ODk2IC8qIHdlYnNvY2tldHMg Ki8gPSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTc2MzdDNTQy MTEyRTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi8sCisJCQkJ NzYzN0M1NDAxMTJFN0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3Bw ICovLAogCQkJCTUxMTIyNDcxMTBDRkI4QzYwMDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29ja2V0 Q2hhbm5lbC5jcHAgKi8sCiAJCQkJNTExMjI0NzMxMENGQjhEODAwODA5OUQ3IC8qIFRocmVhZGFi bGVXZWJTb2NrZXRDaGFubmVsLmggKi8sCiAJCQkJNTExMjI0NzUxMENGQjhFODAwODA5OUQ3IC8q IFRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsQ2xpZW50V3JhcHBlci5oICovLApAQCAtMTg1NDAs NiArMTg1NDYsNyBAQAogCQkJCTkzMUJDQzYxMTEyNERGQ0IwMEJFNzBERCAvKiBNZWRpYUNhblN0 YXJ0TGlzdGVuZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTlGMkEzMjJDMTEyNUEwQTIwMDNDMzA1 NiAvKiBKYXZhU2NyaXB0UHJvZmlsZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOUYyQTMyMkUxMTI1 QTBBMjAwM0MzMDU2IC8qIEphdmFTY3JpcHRQcm9maWxlTm9kZS5oIGluIEhlYWRlcnMgKi8sCisJ CQkJNzYzN0M1NDMxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qu aCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nl c3NpbmcgPSAwOwogCQl9OwpAQCAtMjA3MjMsNiArMjA3MzAsNyBAQAogCQkJCTlGMkEzMjJEMTEy NUEwQTIwMDNDMzA1NiAvKiBKYXZhU2NyaXB0UHJvZmlsZU5vZGUuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJNkUyMUM2QzAxMTI2MzM4NTAwQTdCRTAyIC8qIEdyYXBoaWNzQ29udGV4dDNELmNwcCBp biBTb3VyY2VzICovLAogCQkJCTZFMjFDNkMyMTEyNjMzOTkwMEE3QkUwMiAvKiBHcmFwaGljc0Nv bnRleHQzRENHLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTc2MzdDNTQxMTEyRTdCNzQwMDNENkNE QyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsK IAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIGIvV2ViQ29yZS93 ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwCmluZGV4IDdiODdiZjMuLjYxMzQ1NWIgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcAorKysgYi9X ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAKQEAgLTQ0LDYgKzQ0LDggQEAK ICNpbmNsdWRlICJTb2NrZXRTdHJlYW1IYW5kbGUuaCIKICNpbmNsdWRlICJTdHJpbmdIYXNoLmgi CiAjaW5jbHVkZSAiV2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIgorI2luY2x1ZGUgIldlYlNvY2tl dEhhbmRzaGFrZS5oIgorI2luY2x1ZGUgIldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCIKIAog I2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9GYXN0TWFsbG9jLmg+CkBAIC0x MTEsNyArMTEzLDggQEAgdm9pZCBXZWJTb2NrZXRDaGFubmVsOjpkaWRPcGVuKFNvY2tldFN0cmVh bUhhbmRsZSogaGFuZGxlKQogewogICAgIExPRyhOZXR3b3JrLCAiV2ViU29ja2V0Q2hhbm5lbCAl cCBkaWRPcGVuIiwgdGhpcyk7CiAgICAgQVNTRVJUKGhhbmRsZSA9PSBtX2hhbmRsZSk7Ci0gICAg Y29uc3QgQ1N0cmluZyYgaGFuZHNoYWtlTWVzc2FnZSA9IG1faGFuZHNoYWtlLmNsaWVudEhhbmRz aGFrZU1lc3NhZ2UoKTsKKyAgICBSZWZQdHI8V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdD4gcmVx dWVzdCA9IG1faGFuZHNoYWtlLmNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKTsKKyAgICBjb25zdCBD U3RyaW5nJiBoYW5kc2hha2VNZXNzYWdlID0gcmVxdWVzdC0+aGFuZHNoYWtlTWVzc2FnZSgpOwog ICAgIGlmICghaGFuZGxlLT5zZW5kKGhhbmRzaGFrZU1lc3NhZ2UuZGF0YSgpLCBoYW5kc2hha2VN ZXNzYWdlLmxlbmd0aCgpKSkgewogICAgICAgICBtX2NvbnRleHQtPmFkZE1lc3NhZ2UoQ29uc29s ZURlc3RpbmF0aW9uLCBKU01lc3NhZ2VTb3VyY2UsIExvZ01lc3NhZ2VUeXBlLCBFcnJvck1lc3Nh Z2VMZXZlbCwgIkVycm9yIHNlbmRpbmcgaGFuZHNoYWtlIG1lc3NhZ2UuIiwgMCwgbV9oYW5kc2hh a2UuY2xpZW50T3JpZ2luKCkpOwogICAgICAgICBoYW5kbGUtPmNsb3NlKCk7CmRpZmYgLS1naXQg YS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vi c29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCmluZGV4IDQ0NzEwOTYuLjNmMTlmMGUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBi L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCkBAIC00NSw2ICs0NSw3 IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2luY2x1ZGUgIlNlY3Vy aXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2luY2x1ZGUgIldlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3QuaCIKICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CiAj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCkBAIC0xMDcsNiArMTA4LDcgQEAgY29uc3QgS1VSTCYg V2ViU29ja2V0SGFuZHNoYWtlOjp1cmwoKSBjb25zdAogCiB2b2lkIFdlYlNvY2tldEhhbmRzaGFr ZTo6c2V0VVJMKGNvbnN0IEtVUkwmIHVybCkKIHsKKyAgICBBU1NFUlQoIW1fcmVxdWVzdC5nZXQo KSk7CiAgICAgbV91cmwgPSB1cmwuY29weSgpOwogfQogCkBAIC0xMjIsNiArMTI0LDcgQEAgY29u c3QgU3RyaW5nJiBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudFByb3RvY29sKCkgY29uc3QKIAog dm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnNldENsaWVudFByb3RvY29sKGNvbnN0IFN0cmluZyYg cHJvdG9jb2wpCiB7CisgICAgQVNTRVJUKCFtX3JlcXVlc3QuZ2V0KCkpOwogICAgIG1fY2xpZW50 UHJvdG9jb2wgPSBwcm90b2NvbDsKIH0KIApAQCAtMTMyLDYgKzEzNSw3IEBAIGJvb2wgV2ViU29j a2V0SGFuZHNoYWtlOjpzZWN1cmUoKSBjb25zdAogCiB2b2lkIFdlYlNvY2tldEhhbmRzaGFrZTo6 c2V0U2VjdXJlKGJvb2wgc2VjdXJlKQogeworICAgIEFTU0VSVCghbV9yZXF1ZXN0LmdldCgpKTsK ICAgICBtX3NlY3VyZSA9IHNlY3VyZTsKIH0KIApAQCAtMTU2LDQ3ICsxNjAsMzIgQEAgU3RyaW5n IFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAogICAgIHJldHVybiBi dWlsZGVyLnRvU3RyaW5nKCk7CiB9CiAKLUNTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGll bnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3QKK1Bhc3NSZWZQdHI8V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdD4gV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VSZXF1ZXN0KCkKIHsK LSAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7Ci0KLSAgICBidWlsZGVyLmFwcGVuZCgiR0VUICIp OwotICAgIGJ1aWxkZXIuYXBwZW5kKHJlc291cmNlTmFtZShtX3VybCkpOwotICAgIGJ1aWxkZXIu YXBwZW5kKCIgSFRUUC8xLjFcclxuIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoIlVwZ3JhZGU6IFdl YlNvY2tldFxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiQ29ubmVjdGlvbjogVXBncmFkZVxy XG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiSG9zdDogIik7Ci0gICAgYnVpbGRlci5hcHBlbmQo bV91cmwuaG9zdCgpLmxvd2VyKCkpOwotICAgIGlmIChtX3VybC5wb3J0KCkpIHsKLSAgICAgICAg aWYgKCghbV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1cmUgJiYgbV91 cmwucG9ydCgpICE9IDQ0MykpIHsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7Ci0g ICAgICAgICAgICBidWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsK LSAgICAgICAgfQotICAgIH0KLSAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIGJ1aWxk ZXIuYXBwZW5kKCJPcmlnaW46ICIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKGNsaWVudE9yaWdpbigp KTsKLSAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIGlmICghbV9jbGllbnRQcm90b2Nv bC5pc0VtcHR5KCkpIHsKLSAgICAgICAgYnVpbGRlci5hcHBlbmQoIldlYlNvY2tldC1Qcm90b2Nv bDogIik7Ci0gICAgICAgIGJ1aWxkZXIuYXBwZW5kKG1fY2xpZW50UHJvdG9jb2wpOwotICAgICAg ICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIH0KLSAgICBLVVJMIHVybCA9IGh0dHBVUkxG b3JBdXRoZW50aWNhdGlvbkFuZENvb2tpZXMoKTsKLSAgICAvLyBGSVhNRTogc2V0IGF1dGhlbnRp Y2F0aW9uIGluZm9ybWF0aW9uIG9yIGNvb2tpZXMgZm9yIHVybC4KLSAgICAvLyBTZXQgIkF1dGhv cml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIGV4 aXN0cyBmb3IgdXJsLgorICAgIC8vIElmIHdlIGhhdmUgYSBjYWNoZSwgdXNlIGl0LgorICAgIGlm IChtX3JlcXVlc3QpCisgICAgICAgIHJldHVybiBtX3JlcXVlc3Q7CisKKyAgICAvLyBPdGhlcndp c2UsIGxldCdzIGNyZWF0ZSBhIHJlcXVlc3Qgb2JqZWN0LgorICAgIEtVUkwgdXJsKG1fdXJsKTsK KyAgICBpZiAoIXVybC5wcm90b2NvbElzKCJ3c3MiKSAmJiBtX3NlY3VyZSkKKyAgICAgICAgdXJs LnNldFByb3RvY29sKCJ3c3MiKTsKKyAgICBlbHNlIGlmICghdXJsLnByb3RvY29sSXMoIndzIikg JiYgIW1fc2VjdXJlKQorICAgICAgICB1cmwuc2V0UHJvdG9jb2woIndzIik7CisgICAgbV9yZXF1 ZXN0ID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6Y3JlYXRlKHVybCwgY2xpZW50T3JpZ2lu KCksIG1fY2xpZW50UHJvdG9jb2wpOworCisgICAgS1VSTCBodHRwVXJsID0gaHR0cFVSTEZvckF1 dGhlbnRpY2F0aW9uQW5kQ29va2llcygpOworICAgIC8vIEZJWE1FOiBzZXQgYXV0aGVudGljYXRp b24gaW5mb3JtYXRpb24gb3IgY29va2llcyBmb3IgaHR0cFVybC4KKyAgICAvLyBTZXQgIkF1dGhv cml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIGV4 aXN0cyBmb3IgaHR0cFVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAg ICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihtX2NvbnRl eHQpOwotICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llUmVxdWVzdEhlYWRlckZpZWxkVmFs dWUoZG9jdW1lbnQsIHVybCk7Ci0gICAgICAgIGlmICghY29va2llLmlzRW1wdHkoKSkgewotICAg ICAgICAgICAgYnVpbGRlci5hcHBlbmQoIkNvb2tpZTogIik7Ci0gICAgICAgICAgICBidWlsZGVy LmFwcGVuZChjb29raWUpOwotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKLSAg ICAgICAgfQotICAgICAgICAvLyBTZXQgIkNvb2tpZTI6IDxjb29raWU+IiBpZiBjb29raWVzIDIg ZXhpc3RzIGZvciB1cmw/CisgICAgICAgIFN0cmluZyBjb29raWUgPSBjb29raWVSZXF1ZXN0SGVh ZGVyRmllbGRWYWx1ZShkb2N1bWVudCwgaHR0cFVybCk7CisgICAgICAgIGlmICghY29va2llLmlz RW1wdHkoKSkKKyAgICAgICAgICAgIG1fcmVxdWVzdC0+YWRkRXh0cmFIZWFkZXJGaWVsZCgiQ29v a2llIiwgY29va2llKTsKKyAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8Y29va2llPiIgaWYgY29v a2llcyAyIGV4aXN0cyBmb3IgaHR0cFVybD8KICAgICB9Ci0gICAgYnVpbGRlci5hcHBlbmQoIlxy XG4iKTsKLSAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpLnV0ZjgoKTsKKworICAgIHJldHVy biBtX3JlcXVlc3Q7CiB9CiAKIHZvaWQgV2ViU29ja2V0SGFuZHNoYWtlOjpyZXNldCgpCkBAIC0y MDgsNiArMTk3LDggQEAgdm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnJlc2V0KCkKICAgICBtX3dz UHJvdG9jb2wgPSBTdHJpbmcoKTsKICAgICBtX3NldENvb2tpZSA9IFN0cmluZygpOwogICAgIG1f c2V0Q29va2llMiA9IFN0cmluZygpOworCisgICAgbV9yZXF1ZXN0LmNsZWFyKCk7CiB9CiAKIGlu dCBXZWJTb2NrZXRIYW5kc2hha2U6OnJlYWRTZXJ2ZXJIYW5kc2hha2UoY29uc3QgY2hhciogaGVh ZGVyLCBzaXplX3QgbGVuKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tl dEhhbmRzaGFrZS5oIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCmlu ZGV4IGJkYTMyMGEuLjhjYmNlOTMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2UuaAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlLmgKQEAgLTM2LDExICszNiwxNCBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQ bGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKICAgICBjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogICAgIGNsYXNz IEhUVFBIZWFkZXJNYXA7CisgICAgY2xhc3MgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDsKIAog ICAgIGNsYXNzIFdlYlNvY2tldEhhbmRzaGFrZSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiAgICAg cHVibGljOgpAQCAtNjMsNyArNjYsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0 cmluZyBjbGllbnRPcmlnaW4oKSBjb25zdDsKICAgICAgICAgU3RyaW5nIGNsaWVudExvY2F0aW9u KCkgY29uc3Q7CiAKLSAgICAgICAgQ1N0cmluZyBjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29u c3Q7CisgICAgICAgIC8vIE9uY2UgY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpIGlzIGNhbGxlZCwg eW91IGNhbm5vdCBjaGFuZ2UgdGhlIGNsaWVudCByZXF1ZXN0CisgICAgICAgIC8vIChpLmUuIHlv dSBjYW5ub3QgY2FsbCBzZXRVUkwoKSwgc2V0Q2xpZW50UHJvdG9jb2woKSBvciBzZXRTZWN1cmUo KSkgdW50aWwgcmVzZXQoKSBpcyBjYWxsZWQuCisgICAgICAgIFBhc3NSZWZQdHI8V2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdD4gY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpOwogCiAgICAgICAgIHZv aWQgcmVzZXQoKTsKIApAQCAtMTA0LDYgKzEwOSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgU3RyaW5nIG1fd3NQcm90b2NvbDsKICAgICAgICAgU3RyaW5nIG1fc2V0Q29va2llOwog ICAgICAgICBTdHJpbmcgbV9zZXRDb29raWUyOworCisgICAgICAgIFJlZlB0cjxXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0PiBtX3JlcXVlc3Q7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QuY3BwIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM0NzY0NmEKLS0tIC9kZXYv bnVsbAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAKQEAgLTAsMCArMSwxNzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIElu Yy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNv cHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIg dGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1 dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBm cm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJt aXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IK KyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdF Ql9TT0NLRVRTKQorCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIgorCisj aW5jbHVkZSAiQXRvbWljU3RyaW5nLmgiCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2lu Y2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdDo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdChjb25zdCBLVVJM JiB1cmwsIGNvbnN0IFN0cmluZyYgb3JpZ2luLCBjb25zdCBTdHJpbmcmIHdlYlNvY2tldFByb3Rv Y29sKQorICAgIDogbV91cmwodXJsKQorICAgICwgbV9zZWN1cmUobV91cmwucHJvdG9jb2xJcygi d3NzIikpCisgICAgLCBtX29yaWdpbihvcmlnaW4pCisgICAgLCBtX3dlYlNvY2tldFByb3RvY29s KHdlYlNvY2tldFByb3RvY29sKQoreworICAgIEFTU0VSVCghb3JpZ2luLmlzTnVsbCgpKTsKK30K KworV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6fldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qo KQoreworfQorCitjb25zdCBLVVJMJiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Ojp1cmwoKSBj b25zdAoreworICAgIHJldHVybiBtX3VybDsKK30KKworYm9vbCBXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0OjpzZWN1cmUoKSBjb25zdAoreworICAgIHJldHVybiBtX3NlY3VyZTsKK30KKworU3Ry aW5nIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OnVwZ3JhZGUoKSBjb25zdAoreworICAgIHJl dHVybiAiV2ViU29ja2V0IjsKK30KKworU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6 OmNvbm5lY3Rpb24oKSBjb25zdAoreworICAgIHJldHVybiAiVXBncmFkZSI7Cit9CisKK1N0cmlu ZyBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Ojpob3N0KCkgY29uc3QKK3sKKyAgICBTdHJpbmdC dWlsZGVyIGJ1aWxkZXI7CisgICAgYnVpbGRlci5hcHBlbmQobV91cmwuaG9zdCgpLmxvd2VyKCkp OworICAgIGlmICgoIW1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJl ICYmIG1fdXJsLnBvcnQoKSAhPSA0NDMpKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7 CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwor ICAgIH0KKyAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpOworfQorCitjb25zdCBTdHJpbmcm IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6Om9yaWdpbigpIGNvbnN0Cit7CisgICAgcmV0dXJu IG1fb3JpZ2luOworfQorCitjb25zdCBTdHJpbmcmIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6 OndlYlNvY2tldFByb3RvY29sKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV93ZWJTb2NrZXRQcm90 b2NvbDsKK30KKworY29uc3QgSFRUUEhlYWRlck1hcCYgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6ZXh0cmFIZWFkZXJGaWVsZHMoKSBjb25zdAoreworICAgIHJldHVybiBtX2V4dHJhSGVhZGVy RmllbGRzOworfQorCitTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6ZXh0cmFIZWFk ZXJGaWVsZChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1f ZXh0cmFIZWFkZXJGaWVsZHMuZ2V0KG5hbWUpOworfQorCitTdHJpbmcgV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lKSBjb25zdAorewor ICAgIHJldHVybiBtX2V4dHJhSGVhZGVyRmllbGRzLmdldChuYW1lKTsKK30KKwordm9pZCBXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0OjphZGRFeHRyYUhlYWRlckZpZWxkKGNvbnN0IEF0b21pY1N0 cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBtX2V4dHJhSGVhZGVyRmll bGRzLmFkZChuYW1lLCB2YWx1ZSk7Cit9CisKK3ZvaWQgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6YWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBTdHJpbmcmIHZh bHVlKQoreworICAgIG1fZXh0cmFIZWFkZXJGaWVsZHMuYWRkKG5hbWUsIHZhbHVlKTsKK30KKwor c3RhdGljIFN0cmluZyByZXNvdXJjZU5hbWUoY29uc3QgS1VSTCYgdXJsKQoreworICAgIFN0cmlu ZyBuYW1lID0gdXJsLnBhdGgoKTsKKyAgICBpZiAobmFtZS5pc0VtcHR5KCkpCisgICAgICAgIG5h bWUgPSAiLyI7CisgICAgaWYgKCF1cmwucXVlcnkoKS5pc051bGwoKSkKKyAgICAgICAgbmFtZSAr PSAiPyIgKyB1cmwucXVlcnkoKTsKKyAgICBBU1NFUlQoIW5hbWUuaXNFbXB0eSgpKTsKKyAgICBB U1NFUlQoIW5hbWUuY29udGFpbnMoJyAnKSk7CisgICAgcmV0dXJuIG5hbWU7Cit9CisKK0NTdHJp bmcgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6aGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0Cit7 CisgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOworCisgICAgYnVpbGRlci5hcHBlbmQoIkdFVCAi KTsKKyAgICBidWlsZGVyLmFwcGVuZChyZXNvdXJjZU5hbWUobV91cmwpKTsKKyAgICBidWlsZGVy LmFwcGVuZCgiIEhUVFAvMS4xXHJcbiIpOworCisgICAgYnVpbGRlci5hcHBlbmQoIlVwZ3JhZGU6 ICIpOworICAgIGJ1aWxkZXIuYXBwZW5kKHVwZ3JhZGUoKSk7CisgICAgYnVpbGRlci5hcHBlbmQo IlxyXG4iKTsKKworICAgIGJ1aWxkZXIuYXBwZW5kKCJDb25uZWN0aW9uOiAiKTsKKyAgICBidWls ZGVyLmFwcGVuZChjb25uZWN0aW9uKCkpOworICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisK KyAgICBidWlsZGVyLmFwcGVuZCgiSG9zdDogIik7CisgICAgYnVpbGRlci5hcHBlbmQoaG9zdCgp KTsKKyAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOworCisgICAgYnVpbGRlci5hcHBlbmQoIk9y aWdpbjogIik7CisgICAgYnVpbGRlci5hcHBlbmQob3JpZ2luKCkpOworICAgIGJ1aWxkZXIuYXBw ZW5kKCJcclxuIik7CisKKyAgICBpZiAoIXdlYlNvY2tldFByb3RvY29sKCkuaXNFbXB0eSgpKSB7 CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJXZWJTb2NrZXQtUHJvdG9jb2w6ICIpOworICAgICAg ICBidWlsZGVyLmFwcGVuZCh3ZWJTb2NrZXRQcm90b2NvbCgpKTsKKyAgICAgICAgYnVpbGRlci5h cHBlbmQoIlxyXG4iKTsKKyAgICB9CisKKyAgICBmb3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0 ZXJhdG9yIGl0ID0gbV9leHRyYUhlYWRlckZpZWxkcy5iZWdpbigpLCBlbmQgPSBtX2V4dHJhSGVh ZGVyRmllbGRzLmVuZCgpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgYnVpbGRlci5hcHBl bmQoaXQtPmZpcnN0KTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoIjogIik7CisgICAgICAgIGJ1 aWxkZXIuYXBwZW5kKGl0LT5zZWNvbmQpOworICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIp OworICAgIH0KKworICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisgICAgcmV0dXJuIGJ1aWxk ZXIudG9TdHJpbmcoKS51dGY4KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShXRUJfU09DS0VUUykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0 cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LjU2N2Q3YTUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdC5oCkBAIC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAq ICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBp dHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJTb2NrZXRIYW5k c2hha2VSZXF1ZXN0X2gKKyNkZWZpbmUgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdF9oCisKKyNp ZiBFTkFCTEUoV0VCX1NPQ0tFVFMpCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAi SFRUUEhlYWRlck1hcC5oIgorI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgorI2luY2x1ZGUgInd0Zi9QYXNzUmVmUHRyLmgiCisjaW5jbHVkZSAid3RmL1JlZkNv dW50ZWQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBdG9taWNTdHJpbmc7CisK K2NsYXNzIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0PiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8 V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdD4gY3JlYXRlKGNvbnN0IEtVUkwmIHVybCwgY29uc3Qg U3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29ja2V0UHJvdG9jb2wgPSBTdHJpbmco KSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgV2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdCh1cmwsIG9yaWdpbiwgd2ViU29ja2V0UHJvdG9jb2wpKTsKKyAgICB9CisKKyAgICB+ V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdCgpOworCisgICAgY29uc3QgS1VSTCYgdXJsKCkgY29u c3Q7CisgICAgYm9vbCBzZWN1cmUoKSBjb25zdDsKKworICAgIC8vIEdldCB2YWx1ZXMgZm9yIFVw Z3JhZGUsIENvbm5lY3Rpb24sIEhvc3QsIE9yaWdpbiwgYW5kIFdlYlNvY2tldC1Qcm90b2NvbCBo ZWFkZXIgZmllbGRzLgorICAgIFN0cmluZyB1cGdyYWRlKCkgY29uc3Q7CisgICAgU3RyaW5nIGNv bm5lY3Rpb24oKSBjb25zdDsKKyAgICBTdHJpbmcgaG9zdCgpIGNvbnN0OworICAgIGNvbnN0IFN0 cmluZyYgb3JpZ2luKCkgY29uc3Q7CisgICAgY29uc3QgU3RyaW5nJiB3ZWJTb2NrZXRQcm90b2Nv bCgpIGNvbnN0OyAvLyBFbXB0eSBzdHJpbmcgbWVhbnMgdGhlIGFic2VuY2Ugb2YgV2ViU29ja2V0 LVByb3RvY29sIGZpZWxkLgorCisgICAgLy8gR2V0IGFuZCBzZXQgdmFsdWVzIGZvciB0aGUgcmVt YWluaW5nIGhlYWRlciBmaWVsZHMuCisgICAgY29uc3QgSFRUUEhlYWRlck1hcCYgZXh0cmFIZWFk ZXJGaWVsZHMoKSBjb25zdDsKKyAgICBTdHJpbmcgZXh0cmFIZWFkZXJGaWVsZChjb25zdCBBdG9t aWNTdHJpbmcmIG5hbWUpIGNvbnN0OworICAgIFN0cmluZyBleHRyYUhlYWRlckZpZWxkKGNvbnN0 IGNoYXIqIG5hbWUpIGNvbnN0OworICAgIHZvaWQgYWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBB dG9taWNTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpOworICAgIHZvaWQgYWRkRXh0 cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKKwor ICAgIC8vIEJ1aWxkIHRoZSBjaGFyYWN0ZXIgc2VxdWVuY2UgZm9yIHRoaXMgaGFuZHNoYWtlIHJl cXVlc3QuCisgICAgQ1N0cmluZyBoYW5kc2hha2VNZXNzYWdlKCkgY29uc3Q7CisKK3ByaXZhdGU6 CisgICAgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5n JiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29ja2V0UHJvdG9jb2wpOworCisgICAgS1VSTCBt X3VybDsKKyAgICBib29sIG1fc2VjdXJlOworICAgIFN0cmluZyBtX29yaWdpbjsKKyAgICBTdHJp bmcgbV93ZWJTb2NrZXRQcm90b2NvbDsKKyAgICBIVFRQSGVhZGVyTWFwIG1fZXh0cmFIZWFkZXJG aWVsZHM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo V0VCX1NPQ0tFVFMpCisKKyNlbmRpZiAvLyBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0X2gK 49187 2010-02-21 23:51:39 -0800 2010-02-24 00:58:12 -0800 Patch v5 (Style fix) bug-34784-20100222165137.patch text/plain 26673 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MDFkMWE1NC4uZDYxMDI2YiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw1MCBAQAorMjAxMC0wMi0yMSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V2ViU29ja2V0Q2hhbm5lbDo6ZGlkT3Blbik6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpz ZXRVUkwpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpzZXRDbGllbnRQ cm90b2NvbCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OnNldFNlY3Vy ZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFr ZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpyZXNldCk6 CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaDoKKyAgICAgICAgKiB3 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwOiBBZGRlZC4KKyAgICAgICAg KFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6fldl YlNvY2tldEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFu ZHNoYWtlUmVxdWVzdDo6dXJsKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFr ZVJlcXVlc3Q6OnNlY3VyZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0Ojp1cGdyYWRlKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3Q6OmNvbm5lY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6aG9zdCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0OjpvcmlnaW4pOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6d2ViU29ja2V0UHJvdG9jb2wpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZHMpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZCk6CisgICAgICAgIChXZWJDb3Jl OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjphZGRFeHRyYUhlYWRlckZpZWxkKToKKyAgICAg ICAgKFdlYkNvcmU6OnJlc291cmNlTmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0OjpoYW5kc2hha2VNZXNzYWdlKToKKyAgICAgICAgKiB3ZWJzb2NrZXRz L1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpX ZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpjcmVhdGUpOgorCiAyMDEwLTAyLTE5ICBEaXJrIFNj aHVsemUgIDxrcml0QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTmlrb2xhcyBa aW1tZXJtYW5uLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUv R05VbWFrZWZpbGUuYW0KaW5kZXggMTdmZTMzZi4uMzc2Yjk2NCAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0zNDQ3LDcg KzM0NDcsOSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRDaGFubmVsLmggXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xp ZW50LmggXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIFwKLQlX ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKKwlXZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmggXAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmNwcCBcCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3QuaAogCiBpZiBFTkFCTEVfV09SS0VSUwogd2ViY29yZV9zb3VyY2VzICs9IFwK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkK aW5kZXggYjgzMTZjZi4uZTJiOTJjMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkK KysrIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTM2MTksNiArMzYxOSw4IEBACiAgICAgICAg ICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmgnLAogICAgICAgICAgICAg J3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV29ya2Vy VGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRz L1dvcmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmgnLAogICAgICAgICAgICAgJ3dvcmtl cnMvQWJzdHJhY3RXb3JrZXIuY3BwJywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8g Yi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IDRjYjQ3OTQuLjQ2MWFlNjEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMjY1Myw2 ICsyNjUzLDcgQEAgU09VUkNFUyArPSBcCiAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXQuY3BwIFwK ICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIFwKICAgICB3ZWJzb2NrZXRzL1dl YlNvY2tldEhhbmRzaGFrZS5jcHAgXAorICAgIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdC5jcHAgXAogICAgIHdlYnNvY2tldHMvVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwu Y3BwIFwKICAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUVycm9yQmFzZS5jcHAgXAog ICAgIHBsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFuZGxlQmFzZS5jcHAgXApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXggYzc3YzRhNS4uOWE1ZmJhNiAxMDA2NDQK LS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9XZWJDb3Jl L1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0yNzAzNywxOSArMjcwMzcsMTkgQEAK IAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXGJyZWFrX2xpbmVzLmNwcCINCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdc QmlkaVJ1bi5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0JCQkJUmVsYXRp dmVQYXRoPSIuLlxyZW5kZXJpbmdcYnJlYWtfbGluZXMuaCINCisJCQkJUmVsYXRpdmVQYXRoPSIu LlxyZW5kZXJpbmdcQmlkaVJ1bi5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAg ICAgICAgICAgICAgIDxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlS dW4uY3BwIg0KKwkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFr X2xpbmVzLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KLQkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXHJlbmRlcmluZ1xCaWRpUnVuLmgiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXGJyZWFrX2xpbmVzLmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCkBA IC0yNzEwOCw3ICsyNzEwOCw3IEBACiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5s aW5lRmxvd0JveC5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAgICAgICAgICAg ICAgIDxGaWxlDQorCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5s aW5lSXRlcmF0b3IuaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCkBAIC0zNDIyOCw2ICszNDIyOCwy MiBAQAogCQkJCQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0 aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGUuY3BwIg0KKwkJCQkJPg0KKwkJCQk8 L0ZpbGU+DQorCQkJCTxGaWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEph dmFTY3JpcHRQcm9maWxlLmgiDQorCQkJCQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJ CQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNw cCINCisJCQkJCT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8RmlsZQ0KKwkJCQkJUmVsYXRpdmVQYXRo PSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuaCINCisJCQkJCT4NCisJCQkJ PC9GaWxlPg0KKwkJCQk8RmlsZQ0KIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xK U0Fic3RyYWN0V29ya2VyQ3VzdG9tLmNwcCINCiAJCQkJCT4NCiAJCQkJCTxGaWxlQ29uZmlndXJh dGlvbg0KQEAgLTM5OTA4LDIyICszOTkyNCw2IEBACiAJCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+ DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGlu Z3NcanNcSmF2YVNjcmlwdFByb2ZpbGUuY3BwIg0KLQkJCQkJPg0KLQkJCQk8L0ZpbGU+DQotCQkJ CTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9m aWxlLmgiDQotCQkJCQk+DQotCQkJCTwvRmlsZT4NCi0JCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZl UGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNwcCINCi0JCQkJCT4N Ci0JCQkJPC9GaWxlPg0KLQkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5n c1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuaCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0KLQkJ CQk8RmlsZQ0KIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xTY2hlZHVsZWRBY3Rp b24uY3BwIg0KIAkJCQkJPg0KIAkJCQkJPEZpbGVDb25maWd1cmF0aW9uDQpAQCAtNDMwMjAsMTEg KzQzMDIwLDExIEBACiAJCQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KLQkJCQkJUmVs YXRpdmVQYXRoPSIuLlxpbnNwZWN0b3JcZnJvbnQtZW5kXFRleHRWaWV3ZXIuanMiDQorCQkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRcdGV4dFZpZXdlci5jc3MiDQogCQkJ CQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5z cGVjdG9yXGZyb250LWVuZFx0ZXh0Vmlld2VyLmNzcyINCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5c aW5zcGVjdG9yXGZyb250LWVuZFxUZXh0Vmlld2VyLmpzIg0KIAkJCQkJPg0KIAkJCQk8L0ZpbGU+ DQogCQkJCTxGaWxlDQpAQCAtNDM0NTMsNiArNDM0NTMsMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxl Pg0KIAkJCTxGaWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cd2Vic29ja2V0c1xXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmNwcCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHdlYnNvY2tldHNcV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5o Ig0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5c d2Vic29ja2V0c1xXb3JrZXJUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAiDQogCQkJCT4N CiAJCQk8L0ZpbGU+DQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9q ZWN0LnBieHByb2ogYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpp bmRleCAzZGFhYzFmLi41MDliN2NlIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagpAQCAtMTI2Miw2ICsxMjYyLDggQEAKIAkJNzU3OTNFRDMwRDBDRTg1QjAwN0ZD MEFDIC8qIERPTU1lc3NhZ2VFdmVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gNzU3OTNFRDAwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVu dC5oICovOyB9OwogCQk3NTc5M0VENDBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50 Lm1tIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzU3OTNF RDEwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLzsgfTsKIAkJNzU3OTNF RDUwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudEludGVybmFsLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NTc5M0VEMjBEMENFODVCMDA3 RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50SW50ZXJuYWwuaCAqLzsgfTsKKwkJNzYzN0M1NDExMTJF N0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDAxMTJFN0I3NDAwM0Q2 Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovOyB9OworCQk3NjM3QzU0MzEx MkU3QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDIxMTJFN0I3RTAwM0Q2 Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCAqLzsgfTsKIAkJNzY5M0JBRDIxMDZD MkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjkzQkFDRTEwNkMyRENBMDA3QjA4MjMgLyogSGFsdGFi bGVQbHVnaW4uaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQk3NjkzQkFEMzEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2OTNCQUNGMTA2QzJEQ0Ew MDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuY3BwICovOyB9OwogCQk3NjkzQkFENDEwNkMyRENBMDA3 QjA4MjMgLyogUGx1Z2luSGFsdGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA3NjkzQkFEMDEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmgg Ki87IH07CkBAIC02NjgwLDYgKzY2ODIsOCBAQAogCQk3NTc5M0VEMDBEMENFODVCMDA3RkMwQUMg LyogRE9NTWVzc2FnZUV2ZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBE T01NZXNzYWdlRXZlbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzU3OTNFRDEw RDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5vYmpjcHA7IHBhdGggPSBET01NZXNzYWdlRXZlbnQubW07IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCTc1NzkzRUQyMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZl bnRJbnRlcm5hbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NTWVzc2Fn ZUV2ZW50SW50ZXJuYWwuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzYzN0M1NDAx MTJFN0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTc2MzdDNTQyMTEyRTdCN0UwMDNENkNE QyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNzY5M0JBQ0UxMDZDMkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEhhbHRhYmxlUGx1Z2luLmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNCQUNGMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVn aW5IYWx0ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGx1Z2lu SGFsdGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzY5M0JBRDAxMDZDMkRD QTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBQbHVnaW5IYWx0ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTExMTQ0 LDYgKzExMTQ4LDggQEAKIAkJNTE4QTM0QkQxMDI2QzgzMTAwMUI2ODk2IC8qIHdlYnNvY2tldHMg Ki8gPSB7CiAJCQlpc2EgPSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTc2MzdDNTQy MTEyRTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi8sCisJCQkJ NzYzN0M1NDAxMTJFN0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3Bw ICovLAogCQkJCTUxMTIyNDcxMTBDRkI4QzYwMDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29ja2V0 Q2hhbm5lbC5jcHAgKi8sCiAJCQkJNTExMjI0NzMxMENGQjhEODAwODA5OUQ3IC8qIFRocmVhZGFi bGVXZWJTb2NrZXRDaGFubmVsLmggKi8sCiAJCQkJNTExMjI0NzUxMENGQjhFODAwODA5OUQ3IC8q IFRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsQ2xpZW50V3JhcHBlci5oICovLApAQCAtMTg1NDAs NiArMTg1NDYsNyBAQAogCQkJCTkzMUJDQzYxMTEyNERGQ0IwMEJFNzBERCAvKiBNZWRpYUNhblN0 YXJ0TGlzdGVuZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTlGMkEzMjJDMTEyNUEwQTIwMDNDMzA1 NiAvKiBKYXZhU2NyaXB0UHJvZmlsZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOUYyQTMyMkUxMTI1 QTBBMjAwM0MzMDU2IC8qIEphdmFTY3JpcHRQcm9maWxlTm9kZS5oIGluIEhlYWRlcnMgKi8sCisJ CQkJNzYzN0M1NDMxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qu aCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nl c3NpbmcgPSAwOwogCQl9OwpAQCAtMjA3MjMsNiArMjA3MzAsNyBAQAogCQkJCTlGMkEzMjJEMTEy NUEwQTIwMDNDMzA1NiAvKiBKYXZhU2NyaXB0UHJvZmlsZU5vZGUuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkJNkUyMUM2QzAxMTI2MzM4NTAwQTdCRTAyIC8qIEdyYXBoaWNzQ29udGV4dDNELmNwcCBp biBTb3VyY2VzICovLAogCQkJCTZFMjFDNkMyMTEyNjMzOTkwMEE3QkUwMiAvKiBHcmFwaGljc0Nv bnRleHQzRENHLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTc2MzdDNTQxMTEyRTdCNzQwMDNENkNE QyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsK IAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIGIvV2ViQ29yZS93 ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwCmluZGV4IDdiODdiZjMuLjYxMzQ1NWIgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcAorKysgYi9X ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAKQEAgLTQ0LDYgKzQ0LDggQEAK ICNpbmNsdWRlICJTb2NrZXRTdHJlYW1IYW5kbGUuaCIKICNpbmNsdWRlICJTdHJpbmdIYXNoLmgi CiAjaW5jbHVkZSAiV2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIgorI2luY2x1ZGUgIldlYlNvY2tl dEhhbmRzaGFrZS5oIgorI2luY2x1ZGUgIldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCIKIAog I2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9GYXN0TWFsbG9jLmg+CkBAIC0x MTEsNyArMTEzLDggQEAgdm9pZCBXZWJTb2NrZXRDaGFubmVsOjpkaWRPcGVuKFNvY2tldFN0cmVh bUhhbmRsZSogaGFuZGxlKQogewogICAgIExPRyhOZXR3b3JrLCAiV2ViU29ja2V0Q2hhbm5lbCAl cCBkaWRPcGVuIiwgdGhpcyk7CiAgICAgQVNTRVJUKGhhbmRsZSA9PSBtX2hhbmRsZSk7Ci0gICAg Y29uc3QgQ1N0cmluZyYgaGFuZHNoYWtlTWVzc2FnZSA9IG1faGFuZHNoYWtlLmNsaWVudEhhbmRz aGFrZU1lc3NhZ2UoKTsKKyAgICBSZWZQdHI8V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdD4gcmVx dWVzdCA9IG1faGFuZHNoYWtlLmNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKTsKKyAgICBjb25zdCBD U3RyaW5nJiBoYW5kc2hha2VNZXNzYWdlID0gcmVxdWVzdC0+aGFuZHNoYWtlTWVzc2FnZSgpOwog ICAgIGlmICghaGFuZGxlLT5zZW5kKGhhbmRzaGFrZU1lc3NhZ2UuZGF0YSgpLCBoYW5kc2hha2VN ZXNzYWdlLmxlbmd0aCgpKSkgewogICAgICAgICBtX2NvbnRleHQtPmFkZE1lc3NhZ2UoQ29uc29s ZURlc3RpbmF0aW9uLCBKU01lc3NhZ2VTb3VyY2UsIExvZ01lc3NhZ2VUeXBlLCBFcnJvck1lc3Nh Z2VMZXZlbCwgIkVycm9yIHNlbmRpbmcgaGFuZHNoYWtlIG1lc3NhZ2UuIiwgMCwgbV9oYW5kc2hh a2UuY2xpZW50T3JpZ2luKCkpOwogICAgICAgICBoYW5kbGUtPmNsb3NlKCk7CmRpZmYgLS1naXQg YS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vi c29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCmluZGV4IDQ0NzEwOTYuLjNmMTlmMGUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBi L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCkBAIC00NSw2ICs0NSw3 IEBACiAjaW5jbHVkZSAiU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5oIgogI2luY2x1ZGUgIlNlY3Vy aXR5T3JpZ2luLmgiCiAjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2luY2x1ZGUgIldlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3QuaCIKICNpbmNsdWRlIDx3dGYvU3RyaW5nRXh0cmFzLmg+CiAj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCkBAIC0xMDcsNiArMTA4LDcgQEAgY29uc3QgS1VSTCYg V2ViU29ja2V0SGFuZHNoYWtlOjp1cmwoKSBjb25zdAogCiB2b2lkIFdlYlNvY2tldEhhbmRzaGFr ZTo6c2V0VVJMKGNvbnN0IEtVUkwmIHVybCkKIHsKKyAgICBBU1NFUlQoIW1fcmVxdWVzdC5nZXQo KSk7CiAgICAgbV91cmwgPSB1cmwuY29weSgpOwogfQogCkBAIC0xMjIsNiArMTI0LDcgQEAgY29u c3QgU3RyaW5nJiBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudFByb3RvY29sKCkgY29uc3QKIAog dm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnNldENsaWVudFByb3RvY29sKGNvbnN0IFN0cmluZyYg cHJvdG9jb2wpCiB7CisgICAgQVNTRVJUKCFtX3JlcXVlc3QuZ2V0KCkpOwogICAgIG1fY2xpZW50 UHJvdG9jb2wgPSBwcm90b2NvbDsKIH0KIApAQCAtMTMyLDYgKzEzNSw3IEBAIGJvb2wgV2ViU29j a2V0SGFuZHNoYWtlOjpzZWN1cmUoKSBjb25zdAogCiB2b2lkIFdlYlNvY2tldEhhbmRzaGFrZTo6 c2V0U2VjdXJlKGJvb2wgc2VjdXJlKQogeworICAgIEFTU0VSVCghbV9yZXF1ZXN0LmdldCgpKTsK ICAgICBtX3NlY3VyZSA9IHNlY3VyZTsKIH0KIApAQCAtMTU2LDQ3ICsxNjAsMzIgQEAgU3RyaW5n IFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAogICAgIHJldHVybiBi dWlsZGVyLnRvU3RyaW5nKCk7CiB9CiAKLUNTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGll bnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3QKK1Bhc3NSZWZQdHI8V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdD4gV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VSZXF1ZXN0KCkKIHsK LSAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7Ci0KLSAgICBidWlsZGVyLmFwcGVuZCgiR0VUICIp OwotICAgIGJ1aWxkZXIuYXBwZW5kKHJlc291cmNlTmFtZShtX3VybCkpOwotICAgIGJ1aWxkZXIu YXBwZW5kKCIgSFRUUC8xLjFcclxuIik7Ci0gICAgYnVpbGRlci5hcHBlbmQoIlVwZ3JhZGU6IFdl YlNvY2tldFxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiQ29ubmVjdGlvbjogVXBncmFkZVxy XG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiSG9zdDogIik7Ci0gICAgYnVpbGRlci5hcHBlbmQo bV91cmwuaG9zdCgpLmxvd2VyKCkpOwotICAgIGlmIChtX3VybC5wb3J0KCkpIHsKLSAgICAgICAg aWYgKCghbV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1cmUgJiYgbV91 cmwucG9ydCgpICE9IDQ0MykpIHsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7Ci0g ICAgICAgICAgICBidWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsK LSAgICAgICAgfQotICAgIH0KLSAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIGJ1aWxk ZXIuYXBwZW5kKCJPcmlnaW46ICIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKGNsaWVudE9yaWdpbigp KTsKLSAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIGlmICghbV9jbGllbnRQcm90b2Nv bC5pc0VtcHR5KCkpIHsKLSAgICAgICAgYnVpbGRlci5hcHBlbmQoIldlYlNvY2tldC1Qcm90b2Nv bDogIik7Ci0gICAgICAgIGJ1aWxkZXIuYXBwZW5kKG1fY2xpZW50UHJvdG9jb2wpOwotICAgICAg ICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIH0KLSAgICBLVVJMIHVybCA9IGh0dHBVUkxG b3JBdXRoZW50aWNhdGlvbkFuZENvb2tpZXMoKTsKLSAgICAvLyBGSVhNRTogc2V0IGF1dGhlbnRp Y2F0aW9uIGluZm9ybWF0aW9uIG9yIGNvb2tpZXMgZm9yIHVybC4KLSAgICAvLyBTZXQgIkF1dGhv cml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIGV4 aXN0cyBmb3IgdXJsLgorICAgIC8vIElmIHdlIGhhdmUgYSBjYWNoZSwgdXNlIGl0LgorICAgIGlm IChtX3JlcXVlc3QpCisgICAgICAgIHJldHVybiBtX3JlcXVlc3Q7CisKKyAgICAvLyBPdGhlcndp c2UsIGxldCdzIGNyZWF0ZSBhIHJlcXVlc3Qgb2JqZWN0LgorICAgIEtVUkwgdXJsKG1fdXJsKTsK KyAgICBpZiAoIXVybC5wcm90b2NvbElzKCJ3c3MiKSAmJiBtX3NlY3VyZSkKKyAgICAgICAgdXJs LnNldFByb3RvY29sKCJ3c3MiKTsKKyAgICBlbHNlIGlmICghdXJsLnByb3RvY29sSXMoIndzIikg JiYgIW1fc2VjdXJlKQorICAgICAgICB1cmwuc2V0UHJvdG9jb2woIndzIik7CisgICAgbV9yZXF1 ZXN0ID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6Y3JlYXRlKHVybCwgY2xpZW50T3JpZ2lu KCksIG1fY2xpZW50UHJvdG9jb2wpOworCisgICAgS1VSTCBodHRwVXJsID0gaHR0cFVSTEZvckF1 dGhlbnRpY2F0aW9uQW5kQ29va2llcygpOworICAgIC8vIEZJWE1FOiBzZXQgYXV0aGVudGljYXRp b24gaW5mb3JtYXRpb24gb3IgY29va2llcyBmb3IgaHR0cFVybC4KKyAgICAvLyBTZXQgIkF1dGhv cml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIGV4 aXN0cyBmb3IgaHR0cFVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpIHsKICAg ICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihtX2NvbnRl eHQpOwotICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llUmVxdWVzdEhlYWRlckZpZWxkVmFs dWUoZG9jdW1lbnQsIHVybCk7Ci0gICAgICAgIGlmICghY29va2llLmlzRW1wdHkoKSkgewotICAg ICAgICAgICAgYnVpbGRlci5hcHBlbmQoIkNvb2tpZTogIik7Ci0gICAgICAgICAgICBidWlsZGVy LmFwcGVuZChjb29raWUpOwotICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKLSAg ICAgICAgfQotICAgICAgICAvLyBTZXQgIkNvb2tpZTI6IDxjb29raWU+IiBpZiBjb29raWVzIDIg ZXhpc3RzIGZvciB1cmw/CisgICAgICAgIFN0cmluZyBjb29raWUgPSBjb29raWVSZXF1ZXN0SGVh ZGVyRmllbGRWYWx1ZShkb2N1bWVudCwgaHR0cFVybCk7CisgICAgICAgIGlmICghY29va2llLmlz RW1wdHkoKSkKKyAgICAgICAgICAgIG1fcmVxdWVzdC0+YWRkRXh0cmFIZWFkZXJGaWVsZCgiQ29v a2llIiwgY29va2llKTsKKyAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8Y29va2llPiIgaWYgY29v a2llcyAyIGV4aXN0cyBmb3IgaHR0cFVybD8KICAgICB9Ci0gICAgYnVpbGRlci5hcHBlbmQoIlxy XG4iKTsKLSAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpLnV0ZjgoKTsKKworICAgIHJldHVy biBtX3JlcXVlc3Q7CiB9CiAKIHZvaWQgV2ViU29ja2V0SGFuZHNoYWtlOjpyZXNldCgpCkBAIC0y MDgsNiArMTk3LDggQEAgdm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnJlc2V0KCkKICAgICBtX3dz UHJvdG9jb2wgPSBTdHJpbmcoKTsKICAgICBtX3NldENvb2tpZSA9IFN0cmluZygpOwogICAgIG1f c2V0Q29va2llMiA9IFN0cmluZygpOworCisgICAgbV9yZXF1ZXN0LmNsZWFyKCk7CiB9CiAKIGlu dCBXZWJTb2NrZXRIYW5kc2hha2U6OnJlYWRTZXJ2ZXJIYW5kc2hha2UoY29uc3QgY2hhciogaGVh ZGVyLCBzaXplX3QgbGVuKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tl dEhhbmRzaGFrZS5oIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCmlu ZGV4IGJkYTMyMGEuLjhjYmNlOTMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2UuaAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlLmgKQEAgLTM2LDExICszNiwxNCBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQ bGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKICAgICBjbGFzcyBTY3JpcHRFeGVjdXRpb25Db250ZXh0OwogICAgIGNsYXNz IEhUVFBIZWFkZXJNYXA7CisgICAgY2xhc3MgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDsKIAog ICAgIGNsYXNzIFdlYlNvY2tldEhhbmRzaGFrZSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiAgICAg cHVibGljOgpAQCAtNjMsNyArNjYsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFN0 cmluZyBjbGllbnRPcmlnaW4oKSBjb25zdDsKICAgICAgICAgU3RyaW5nIGNsaWVudExvY2F0aW9u KCkgY29uc3Q7CiAKLSAgICAgICAgQ1N0cmluZyBjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29u c3Q7CisgICAgICAgIC8vIE9uY2UgY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpIGlzIGNhbGxlZCwg eW91IGNhbm5vdCBjaGFuZ2UgdGhlIGNsaWVudCByZXF1ZXN0CisgICAgICAgIC8vIChpLmUuIHlv dSBjYW5ub3QgY2FsbCBzZXRVUkwoKSwgc2V0Q2xpZW50UHJvdG9jb2woKSBvciBzZXRTZWN1cmUo KSkgdW50aWwgcmVzZXQoKSBpcyBjYWxsZWQuCisgICAgICAgIFBhc3NSZWZQdHI8V2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdD4gY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpOwogCiAgICAgICAgIHZv aWQgcmVzZXQoKTsKIApAQCAtMTA0LDYgKzEwOSw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAgICAgU3RyaW5nIG1fd3NQcm90b2NvbDsKICAgICAgICAgU3RyaW5nIG1fc2V0Q29va2llOwog ICAgICAgICBTdHJpbmcgbV9zZXRDb29raWUyOworCisgICAgICAgIFJlZlB0cjxXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0PiBtX3JlcXVlc3Q7CiAgICAgfTsKIAogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QuY3BwIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM0NzY0NmEKLS0tIC9kZXYv bnVsbAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAKQEAgLTAsMCArMSwxNzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIElu Yy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMg YXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNv cHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIg dGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1 dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBm cm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJt aXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdI VCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IK KyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdF Ql9TT0NLRVRTKQorCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIgorCisj aW5jbHVkZSAiQXRvbWljU3RyaW5nLmgiCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2lu Y2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdDo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdChjb25zdCBLVVJM JiB1cmwsIGNvbnN0IFN0cmluZyYgb3JpZ2luLCBjb25zdCBTdHJpbmcmIHdlYlNvY2tldFByb3Rv Y29sKQorICAgIDogbV91cmwodXJsKQorICAgICwgbV9zZWN1cmUobV91cmwucHJvdG9jb2xJcygi d3NzIikpCisgICAgLCBtX29yaWdpbihvcmlnaW4pCisgICAgLCBtX3dlYlNvY2tldFByb3RvY29s KHdlYlNvY2tldFByb3RvY29sKQoreworICAgIEFTU0VSVCghb3JpZ2luLmlzTnVsbCgpKTsKK30K KworV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6fldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Qo KQoreworfQorCitjb25zdCBLVVJMJiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Ojp1cmwoKSBj b25zdAoreworICAgIHJldHVybiBtX3VybDsKK30KKworYm9vbCBXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0OjpzZWN1cmUoKSBjb25zdAoreworICAgIHJldHVybiBtX3NlY3VyZTsKK30KKworU3Ry aW5nIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OnVwZ3JhZGUoKSBjb25zdAoreworICAgIHJl dHVybiAiV2ViU29ja2V0IjsKK30KKworU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6 OmNvbm5lY3Rpb24oKSBjb25zdAoreworICAgIHJldHVybiAiVXBncmFkZSI7Cit9CisKK1N0cmlu ZyBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Ojpob3N0KCkgY29uc3QKK3sKKyAgICBTdHJpbmdC dWlsZGVyIGJ1aWxkZXI7CisgICAgYnVpbGRlci5hcHBlbmQobV91cmwuaG9zdCgpLmxvd2VyKCkp OworICAgIGlmICgoIW1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJl ICYmIG1fdXJsLnBvcnQoKSAhPSA0NDMpKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7 CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwor ICAgIH0KKyAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpOworfQorCitjb25zdCBTdHJpbmcm IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6Om9yaWdpbigpIGNvbnN0Cit7CisgICAgcmV0dXJu IG1fb3JpZ2luOworfQorCitjb25zdCBTdHJpbmcmIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6 OndlYlNvY2tldFByb3RvY29sKCkgY29uc3QKK3sKKyAgICByZXR1cm4gbV93ZWJTb2NrZXRQcm90 b2NvbDsKK30KKworY29uc3QgSFRUUEhlYWRlck1hcCYgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6ZXh0cmFIZWFkZXJGaWVsZHMoKSBjb25zdAoreworICAgIHJldHVybiBtX2V4dHJhSGVhZGVy RmllbGRzOworfQorCitTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6ZXh0cmFIZWFk ZXJGaWVsZChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUpIGNvbnN0Cit7CisgICAgcmV0dXJuIG1f ZXh0cmFIZWFkZXJGaWVsZHMuZ2V0KG5hbWUpOworfQorCitTdHJpbmcgV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdDo6ZXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lKSBjb25zdAorewor ICAgIHJldHVybiBtX2V4dHJhSGVhZGVyRmllbGRzLmdldChuYW1lKTsKK30KKwordm9pZCBXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0OjphZGRFeHRyYUhlYWRlckZpZWxkKGNvbnN0IEF0b21pY1N0 cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBtX2V4dHJhSGVhZGVyRmll bGRzLmFkZChuYW1lLCB2YWx1ZSk7Cit9CisKK3ZvaWQgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6YWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBTdHJpbmcmIHZh bHVlKQoreworICAgIG1fZXh0cmFIZWFkZXJGaWVsZHMuYWRkKG5hbWUsIHZhbHVlKTsKK30KKwor c3RhdGljIFN0cmluZyByZXNvdXJjZU5hbWUoY29uc3QgS1VSTCYgdXJsKQoreworICAgIFN0cmlu ZyBuYW1lID0gdXJsLnBhdGgoKTsKKyAgICBpZiAobmFtZS5pc0VtcHR5KCkpCisgICAgICAgIG5h bWUgPSAiLyI7CisgICAgaWYgKCF1cmwucXVlcnkoKS5pc051bGwoKSkKKyAgICAgICAgbmFtZSAr PSAiPyIgKyB1cmwucXVlcnkoKTsKKyAgICBBU1NFUlQoIW5hbWUuaXNFbXB0eSgpKTsKKyAgICBB U1NFUlQoIW5hbWUuY29udGFpbnMoJyAnKSk7CisgICAgcmV0dXJuIG5hbWU7Cit9CisKK0NTdHJp bmcgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6aGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0Cit7 CisgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOworCisgICAgYnVpbGRlci5hcHBlbmQoIkdFVCAi KTsKKyAgICBidWlsZGVyLmFwcGVuZChyZXNvdXJjZU5hbWUobV91cmwpKTsKKyAgICBidWlsZGVy LmFwcGVuZCgiIEhUVFAvMS4xXHJcbiIpOworCisgICAgYnVpbGRlci5hcHBlbmQoIlVwZ3JhZGU6 ICIpOworICAgIGJ1aWxkZXIuYXBwZW5kKHVwZ3JhZGUoKSk7CisgICAgYnVpbGRlci5hcHBlbmQo IlxyXG4iKTsKKworICAgIGJ1aWxkZXIuYXBwZW5kKCJDb25uZWN0aW9uOiAiKTsKKyAgICBidWls ZGVyLmFwcGVuZChjb25uZWN0aW9uKCkpOworICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisK KyAgICBidWlsZGVyLmFwcGVuZCgiSG9zdDogIik7CisgICAgYnVpbGRlci5hcHBlbmQoaG9zdCgp KTsKKyAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOworCisgICAgYnVpbGRlci5hcHBlbmQoIk9y aWdpbjogIik7CisgICAgYnVpbGRlci5hcHBlbmQob3JpZ2luKCkpOworICAgIGJ1aWxkZXIuYXBw ZW5kKCJcclxuIik7CisKKyAgICBpZiAoIXdlYlNvY2tldFByb3RvY29sKCkuaXNFbXB0eSgpKSB7 CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJXZWJTb2NrZXQtUHJvdG9jb2w6ICIpOworICAgICAg ICBidWlsZGVyLmFwcGVuZCh3ZWJTb2NrZXRQcm90b2NvbCgpKTsKKyAgICAgICAgYnVpbGRlci5h cHBlbmQoIlxyXG4iKTsKKyAgICB9CisKKyAgICBmb3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0 ZXJhdG9yIGl0ID0gbV9leHRyYUhlYWRlckZpZWxkcy5iZWdpbigpLCBlbmQgPSBtX2V4dHJhSGVh ZGVyRmllbGRzLmVuZCgpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgYnVpbGRlci5hcHBl bmQoaXQtPmZpcnN0KTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoIjogIik7CisgICAgICAgIGJ1 aWxkZXIuYXBwZW5kKGl0LT5zZWNvbmQpOworICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIp OworICAgIH0KKworICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CisgICAgcmV0dXJuIGJ1aWxk ZXIudG9TdHJpbmcoKS51dGY4KCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIEVOQUJMRShXRUJfU09DS0VUUykKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0 cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAu LmZkYzkyOWIKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdC5oCkBAIC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTAgR29vZ2xlIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAq ICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBp dHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJTb2NrZXRIYW5k c2hha2VSZXF1ZXN0X2gKKyNkZWZpbmUgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdF9oCisKKyNp ZiBFTkFCTEUoV0VCX1NPQ0tFVFMpCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAi SFRUUEhlYWRlck1hcC5oIgorI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0 cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNv dW50ZWQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBdG9taWNTdHJpbmc7CisK K2NsYXNzIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QgOiBwdWJsaWMgUmVmQ291bnRlZDxXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0PiB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NSZWZQdHI8 V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdD4gY3JlYXRlKGNvbnN0IEtVUkwmIHVybCwgY29uc3Qg U3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29ja2V0UHJvdG9jb2wgPSBTdHJpbmco KSkKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgV2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdCh1cmwsIG9yaWdpbiwgd2ViU29ja2V0UHJvdG9jb2wpKTsKKyAgICB9CisKKyAgICB+ V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdCgpOworCisgICAgY29uc3QgS1VSTCYgdXJsKCkgY29u c3Q7CisgICAgYm9vbCBzZWN1cmUoKSBjb25zdDsKKworICAgIC8vIEdldCB2YWx1ZXMgZm9yIFVw Z3JhZGUsIENvbm5lY3Rpb24sIEhvc3QsIE9yaWdpbiwgYW5kIFdlYlNvY2tldC1Qcm90b2NvbCBo ZWFkZXIgZmllbGRzLgorICAgIFN0cmluZyB1cGdyYWRlKCkgY29uc3Q7CisgICAgU3RyaW5nIGNv bm5lY3Rpb24oKSBjb25zdDsKKyAgICBTdHJpbmcgaG9zdCgpIGNvbnN0OworICAgIGNvbnN0IFN0 cmluZyYgb3JpZ2luKCkgY29uc3Q7CisgICAgY29uc3QgU3RyaW5nJiB3ZWJTb2NrZXRQcm90b2Nv bCgpIGNvbnN0OyAvLyBFbXB0eSBzdHJpbmcgbWVhbnMgdGhlIGFic2VuY2Ugb2YgV2ViU29ja2V0 LVByb3RvY29sIGZpZWxkLgorCisgICAgLy8gR2V0IGFuZCBzZXQgdmFsdWVzIGZvciB0aGUgcmVt YWluaW5nIGhlYWRlciBmaWVsZHMuCisgICAgY29uc3QgSFRUUEhlYWRlck1hcCYgZXh0cmFIZWFk ZXJGaWVsZHMoKSBjb25zdDsKKyAgICBTdHJpbmcgZXh0cmFIZWFkZXJGaWVsZChjb25zdCBBdG9t aWNTdHJpbmcmIG5hbWUpIGNvbnN0OworICAgIFN0cmluZyBleHRyYUhlYWRlckZpZWxkKGNvbnN0 IGNoYXIqIG5hbWUpIGNvbnN0OworICAgIHZvaWQgYWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBB dG9taWNTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpOworICAgIHZvaWQgYWRkRXh0 cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKKwor ICAgIC8vIEJ1aWxkIHRoZSBjaGFyYWN0ZXIgc2VxdWVuY2UgZm9yIHRoaXMgaGFuZHNoYWtlIHJl cXVlc3QuCisgICAgQ1N0cmluZyBoYW5kc2hha2VNZXNzYWdlKCkgY29uc3Q7CisKK3ByaXZhdGU6 CisgICAgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5n JiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29ja2V0UHJvdG9jb2wpOworCisgICAgS1VSTCBt X3VybDsKKyAgICBib29sIG1fc2VjdXJlOworICAgIFN0cmluZyBtX29yaWdpbjsKKyAgICBTdHJp bmcgbV93ZWJTb2NrZXRQcm90b2NvbDsKKyAgICBIVFRQSGVhZGVyTWFwIG1fZXh0cmFIZWFkZXJG aWVsZHM7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUo V0VCX1NPQ0tFVFMpCisKKyNlbmRpZiAvLyBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0X2gK 49363 2010-02-24 00:58:17 -0800 2010-03-01 23:16:53 -0800 Patch v6 (second try) bug-34784-20100224175815.patch text/plain 24056 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg Y2U0OWM3MC4uNTM1MzhjMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzOSBAQAorMjAxMC0wMi0yNCAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 V2ViU29ja2V0Q2hhbm5lbDo6ZGlkT3Blbik6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlOjpj bGllbnRIYW5kc2hha2VSZXF1ZXN0KToKKyAgICAgICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldEhh bmRzaGFrZS5oOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dC5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dDo6SGVhZGVyRmllbGQ6OkhlYWRlckZpZWxkKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tl dEhhbmRzaGFrZVJlcXVlc3Q6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAo V2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6fldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6YWRk RXh0cmFIZWFkZXJGaWVsZCk6CisgICAgICAgIChXZWJDb3JlOjpXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0OjpoZWFkZXJGaWVsZHMpOgorICAgICAgICAoV2ViQ29yZTo6cmVzb3VyY2VOYW1lKToK KyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmhhbmRzaGFrZU1l c3NhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6aG9z dCk6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Lmg6IEFk ZGVkLgorCiAyMDEwLTAyLTIzICBMZWFuZHJvIFBlcmVpcmEgIDxsZWFuZHJvQHByb2Z1c2lvbi5t b2JpPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YS4KZGlmZiAt LWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmlu ZGV4IDI5NzVmZmUuLjUxZGFkYzEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K KysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMzQ1OSw3ICszNDU5LDkgQEAgd2ViY29y ZV9zb3VyY2VzICs9IFwKIAlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5oIFwK IAlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIFwKIAlXZWJDb3Jl L3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBcCi0JV2ViQ29yZS93ZWJzb2NrZXRz L1dlYlNvY2tldEhhbmRzaGFrZS5oCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZS5oIFwKKwlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAgXAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKIAog aWYgRU5BQkxFX1dPUktFUlMKIHdlYmNvcmVfc291cmNlcyArPSBcCmRpZmYgLS1naXQgYS9XZWJD b3JlL1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDllNmE5YTcuLjY4 M2M4MzMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2Vi Q29yZS5neXBpCkBAIC0zNjE2LDYgKzM2MTYsOCBAQAogICAgICAgICAgICAgJ3dlYnNvY2tldHMv V2ViU29ja2V0Q2hhbm5lbENsaWVudC5oJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dlYlNv Y2tldEhhbmRzaGFrZS5jcHAnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFu ZHNoYWtlLmgnLAorICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVx dWVzdC5jcHAnLAorICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVx dWVzdC5oJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dvcmtlclRocmVhZGFibGVXZWJTb2Nr ZXRDaGFubmVsLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29ja2V0cy9Xb3JrZXJUaHJlYWRhYmxl V2ViU29ja2V0Q2hhbm5lbC5oJywKICAgICAgICAgICAgICd3b3JrZXJzL0Fic3RyYWN0V29ya2Vy LmNwcCcsCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3Jl LnBybwppbmRleCBjNjI1MjI0Li44MWQ5YWYxIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUu cHJvCisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTI2NzIsNiArMjY3Miw3IEBAIFNPVVJD RVMgKz0gXAogICAgIHdlYnNvY2tldHMvV2ViU29ja2V0LmNwcCBcCiAgICAgd2Vic29ja2V0cy9X ZWJTb2NrZXRDaGFubmVsLmNwcCBcCiAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2Uu Y3BwIFwKKyAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIFwKICAg ICB3ZWJzb2NrZXRzL1RocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmNwcCBcCiAgICAgcGxhdGZv cm0vbmV0d29yay9Tb2NrZXRTdHJlYW1FcnJvckJhc2UuY3BwIFwKICAgICBwbGF0Zm9ybS9uZXR3 b3JrL1NvY2tldFN0cmVhbUhhbmRsZUJhc2UuY3BwIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNv cmUudmNwcm9qCmluZGV4IDhkNmI1NTcuLmRiNDA3NWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9X ZWJDb3JlLnZjcHJvagpAQCAtMjcwNDUsMTkgKzI3MDQ1LDE5IEBACiAJCQkJPg0KIAkJCTwvRmls ZT4NCiAJCQk8RmlsZQ0KLQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5l cy5jcHAiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlSdW4uY3BwIg0KIAkJ CQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVy aW5nXGJyZWFrX2xpbmVzLmgiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlS dW4uaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCi0gICAgICAgICAgICAgICAgICAgICAgICA8Rmls ZQ0KLQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmluZ1xCaWRpUnVuLmNwcCINCisJCQk8Rmls ZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5lcy5jcHAiDQogCQkJ CT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0JCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJp bmdcQmlkaVJ1bi5oIg0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5l cy5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQpAQCAtMjcxMTYsNyArMjcxMTYs NyBAQAogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXElubGluZUZsb3dCb3guaCINCiAJ CQkJPg0KIAkJCTwvRmlsZT4NCi0gICAgICAgICAgICAgICAgICAgICAgICA8RmlsZQ0KKwkJCTxG aWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXElubGluZUl0ZXJhdG9yLmgiDQog CQkJCT4NCiAJCQk8L0ZpbGU+DQpAQCAtMzQyMzYsNiArMzQyMzYsMjIgQEAKIAkJCQkJPg0KIAkJ CQk8L0ZpbGU+DQogCQkJCTxGaWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpz XEphdmFTY3JpcHRQcm9maWxlLmNwcCINCisJCQkJCT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8Rmls ZQ0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZS5o Ig0KKwkJCQkJPg0KKwkJCQk8L0ZpbGU+DQorCQkJCTxGaWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9 Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlTm9kZS5jcHAiDQorCQkJCQk+DQorCQkJ CTwvRmlsZT4NCisJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNc SmF2YVNjcmlwdFByb2ZpbGVOb2RlLmgiDQorCQkJCQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZp bGUNCiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSlNBYnN0cmFjdFdvcmtlckN1 c3RvbS5jcHAiDQogCQkJCQk+DQogCQkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCkBAIC0zOTkxNiwy MiArMzk5MzIsNiBAQAogCQkJCQk8L0ZpbGVDb25maWd1cmF0aW9uPg0KIAkJCQk8L0ZpbGU+DQog CQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQ cm9maWxlLmNwcCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0KLQkJCQk8RmlsZQ0KLQkJCQkJUmVs YXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZS5oIg0KLQkJCQkJPg0K LQkJCQk8L0ZpbGU+DQotCQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdz XGpzXEphdmFTY3JpcHRQcm9maWxlTm9kZS5jcHAiDQotCQkJCQk+DQotCQkJCTwvRmlsZT4NCi0J CQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFBy b2ZpbGVOb2RlLmgiDQotCQkJCQk+DQotCQkJCTwvRmlsZT4NCi0JCQkJPEZpbGUNCiAJCQkJCVJl bGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcU2NoZWR1bGVkQWN0aW9uLmNwcCINCiAJCQkJCT4N CiAJCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KQEAgLTQzMDI0LDExICs0MzAyNCwxMSBAQAogCQkJ CQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5z cGVjdG9yXGZyb250LWVuZFxUZXh0Vmlld2VyLmpzIg0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxp bnNwZWN0b3JcZnJvbnQtZW5kXHRleHRWaWV3ZXIuY3NzIg0KIAkJCQkJPg0KIAkJCQk8L0ZpbGU+ DQogCQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRc dGV4dFZpZXdlci5jc3MiDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1l bmRcVGV4dFZpZXdlci5qcyINCiAJCQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KQEAg LTQzNDU3LDYgKzQzNDU3LDE0IEBACiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KKwkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXHdlYnNvY2tldHNcV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIu Llx3ZWJzb2NrZXRzXFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCINCisJCQkJPg0KKwkJCTwv RmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHdlYnNvY2tldHNcV29ya2Vy VGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KZGlm ZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZWFmOWE1Yy4uYzY0 ODBjNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTEy NjEsNiArMTI2MSw4IEBACiAJCTc1NzkzRUQzMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdl RXZlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc1 NzkzRUQwMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnQuaCAqLzsgfTsKIAkJNzU3 OTNFRDQwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc1NzkzRUQxMEQwQ0U4NUIwMDdGQzBB QyAvKiBET01NZXNzYWdlRXZlbnQubW0gKi87IH07CiAJCTc1NzkzRUQ1MEQwQ0U4NUIwMDdGQzBB QyAvKiBET01NZXNzYWdlRXZlbnRJbnRlcm5hbC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNzU3OTNFRDIwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3Nh Z2VFdmVudEludGVybmFsLmggKi87IH07CisJCTc2MzdDNTQxMTEyRTdCNzQwMDNENkNEQyAvKiBX ZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDc2MzdDNTQwMTEyRTdCNzQwMDNENkNEQyAvKiBXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmNwcCAqLzsgfTsKKwkJNzYzN0M1NDMxMTJFN0I3RTAwM0Q2Q0RDIC8q IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDc2MzdDNTQyMTEyRTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmggKi87IH07CiAJCTc2OTNCQUQyMTA2QzJEQ0EwMDdCMDgyMyAvKiBI YWx0YWJsZVBsdWdpbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNzY5M0JBQ0UxMDZDMkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJNzY5M0JBRDMxMDZD MkRDQTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjkzQkFDRjEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2lu SGFsdGVyLmNwcCAqLzsgfTsKIAkJNzY5M0JBRDQxMDZDMkRDQTAwN0IwODIzIC8qIFBsdWdpbkhh bHRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzY5 M0JBRDAxMDZDMkRDQTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5oICovOyB9OwpAQCAtNjY4MCw2 ICs2NjgyLDggQEAKIAkJNzU3OTNFRDAwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVu dC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NTWVzc2FnZUV2ZW50Lmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc1NzkzRUQxMEQwQ0U4NUIwMDdGQzBBQyAv KiBET01NZXNzYWdlRXZlbnQubW0gKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBw YXRoID0gRE9NTWVzc2FnZUV2ZW50Lm1tOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3 NTc5M0VEMjBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50SW50ZXJuYWwuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IERPTU1lc3NhZ2VFdmVudEludGVybmFsLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTc2MzdDNTQwMTEyRTdCNzQwMDNENkNEQyAv KiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQk3NjM3QzU0MjExMkU3QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFu ZHNoYWtlUmVxdWVzdC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNC QUNFMTA2QzJEQ0EwMDdCMDgyMyAvKiBIYWx0YWJsZVBsdWdpbi5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBIYWx0YWJsZVBsdWdpbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk3NjkzQkFDRjEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFBsdWdpbkhhbHRlci5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNCQUQwMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVn aW5IYWx0ZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGx1Z2luSGFsdGVy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0xMTE0NSw2ICsxMTE0OSw4IEBACiAJ CTUxOEEzNEJEMTAyNkM4MzEwMDFCNjg5NiAvKiB3ZWJzb2NrZXRzICovID0gewogCQkJaXNhID0g UEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJCQk3NjM3QzU0MjExMkU3QjdFMDAzRDZDREMg LyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oICovLAorCQkJCTc2MzdDNTQwMTEyRTdCNzQw MDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCAqLywKIAkJCQk1MTEyMjQ3 MTEwQ0ZCOEM2MDA4MDk5RDcgLyogVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwICovLAog CQkJCTUxMTIyNDczMTBDRkI4RDgwMDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5l bC5oICovLAogCQkJCTUxMTIyNDc1MTBDRkI4RTgwMDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29j a2V0Q2hhbm5lbENsaWVudFdyYXBwZXIuaCAqLywKQEAgLTE4NTQ0LDYgKzE4NTUwLDcgQEAKIAkJ CQk3QUZENEE4QjExMzFDMjc2MDAzNUI4ODMgLyogU2NyaXB0QnJlYWtwb2ludC5oIGluIEhlYWRl cnMgKi8sCiAJCQkJN0FGRDRGRjQxMTMyNzdCNjAwMzVCODgzIC8qIFNjcmlwdERlYnVnTGlzdGVu ZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTU5NjIyOTdBMTEzM0VGRTIwMERDNENCQiAvKiBHZW9s b2NhdGlvblBvc2l0aW9uQ2FjaGUuaCBpbiBIZWFkZXJzICovLAorCQkJCTc2MzdDNTQzMTEyRTdC N0UwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggaW4gSGVhZGVycyAqLywK IAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsK QEAgLTIwNzI3LDYgKzIwNzM0LDcgQEAKIAkJCQk2RTIxQzZDMDExMjYzMzg1MDBBN0JFMDIgLyog R3JhcGhpY3NDb250ZXh0M0QuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNkUyMUM2QzIxMTI2MzM5 OTAwQTdCRTAyIC8qIEdyYXBoaWNzQ29udGV4dDNEQ0cuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ NTk2MjI5NzgxMTMzRUZENzAwREM0Q0JCIC8qIEdlb2xvY2F0aW9uUG9zaXRpb25DYWNoZS5jcHAg aW4gU291cmNlcyAqLywKKwkJCQk3NjM3QzU0MTExMkU3Qjc0MDAzRDZDREMgLyogV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9y RGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv d2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRDaGFubmVsLmNwcAppbmRleCA3Yjg3YmYzLi40ZDMwYzE1IDEwMDY0NAotLS0gYS9XZWJD b3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAKKysrIGIvV2ViQ29yZS93ZWJzb2Nr ZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwCkBAIC00NCw2ICs0NCw4IEBACiAjaW5jbHVkZSAiU29j a2V0U3RyZWFtSGFuZGxlLmgiCiAjaW5jbHVkZSAiU3RyaW5nSGFzaC5oIgogI2luY2x1ZGUgIldl YlNvY2tldENoYW5uZWxDbGllbnQuaCIKKyNpbmNsdWRlICJXZWJTb2NrZXRIYW5kc2hha2UuaCIK KyNpbmNsdWRlICJXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgiCiAKICNpbmNsdWRlIDx3dGYv RGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvRmFzdE1hbGxvYy5oPgpAQCAtMTExLDcgKzExMyw3IEBA IHZvaWQgV2ViU29ja2V0Q2hhbm5lbDo6ZGlkT3BlbihTb2NrZXRTdHJlYW1IYW5kbGUqIGhhbmRs ZSkKIHsKICAgICBMT0coTmV0d29yaywgIldlYlNvY2tldENoYW5uZWwgJXAgZGlkT3BlbiIsIHRo aXMpOwogICAgIEFTU0VSVChoYW5kbGUgPT0gbV9oYW5kbGUpOwotICAgIGNvbnN0IENTdHJpbmcm IGhhbmRzaGFrZU1lc3NhZ2UgPSBtX2hhbmRzaGFrZS5jbGllbnRIYW5kc2hha2VNZXNzYWdlKCk7 CisgICAgY29uc3QgQ1N0cmluZyYgaGFuZHNoYWtlTWVzc2FnZSA9IG1faGFuZHNoYWtlLmNsaWVu dEhhbmRzaGFrZVJlcXVlc3QoKS5oYW5kc2hha2VNZXNzYWdlKCk7CiAgICAgaWYgKCFoYW5kbGUt PnNlbmQoaGFuZHNoYWtlTWVzc2FnZS5kYXRhKCksIGhhbmRzaGFrZU1lc3NhZ2UubGVuZ3RoKCkp KSB7CiAgICAgICAgIG1fY29udGV4dC0+YWRkTWVzc2FnZShDb25zb2xlRGVzdGluYXRpb24sIEpT TWVzc2FnZVNvdXJjZSwgTG9nTWVzc2FnZVR5cGUsIEVycm9yTWVzc2FnZUxldmVsLCAiRXJyb3Ig c2VuZGluZyBoYW5kc2hha2UgbWVzc2FnZS4iLCAwLCBtX2hhbmRzaGFrZS5jbGllbnRPcmlnaW4o KSk7CiAgICAgICAgIGhhbmRsZS0+Y2xvc2UoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tl dEhhbmRzaGFrZS5jcHAKaW5kZXggNDQ3MTA5Ni4uZGFjNDgwMiAxMDA2NDQKLS0tIGEvV2ViQ29y ZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAKKysrIGIvV2ViQ29yZS93ZWJzb2Nr ZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAKQEAgLTE1Niw0NyArMTU2LDI3IEBAIFN0cmluZyBX ZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudExvY2F0aW9uKCkgY29uc3QKICAgICByZXR1cm4gYnVp bGRlci50b1N0cmluZygpOwogfQogCi1DU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50 SGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0CitXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0IFdlYlNv Y2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpCiB7Ci0gICAgU3RyaW5nQnVp bGRlciBidWlsZGVyOwotCi0gICAgYnVpbGRlci5hcHBlbmQoIkdFVCAiKTsKLSAgICBidWlsZGVy LmFwcGVuZChyZXNvdXJjZU5hbWUobV91cmwpKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiIEhUVFAv MS4xXHJcbiIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKCJVcGdyYWRlOiBXZWJTb2NrZXRcclxuIik7 Ci0gICAgYnVpbGRlci5hcHBlbmQoIkNvbm5lY3Rpb246IFVwZ3JhZGVcclxuIik7Ci0gICAgYnVp bGRlci5hcHBlbmQoIkhvc3Q6ICIpOwotICAgIGJ1aWxkZXIuYXBwZW5kKG1fdXJsLmhvc3QoKS5s b3dlcigpKTsKLSAgICBpZiAobV91cmwucG9ydCgpKSB7Ci0gICAgICAgIGlmICgoIW1fc2VjdXJl ICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA0 NDMpKSB7Ci0gICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiIpOwotICAgICAgICAgICAgYnVp bGRlci5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV91cmwucG9ydCgpKSk7Ci0gICAgICAgIH0KLSAg ICB9Ci0gICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKLSAgICBidWlsZGVyLmFwcGVuZCgiT3Jp Z2luOiAiKTsKLSAgICBidWlsZGVyLmFwcGVuZChjbGllbnRPcmlnaW4oKSk7Ci0gICAgYnVpbGRl ci5hcHBlbmQoIlxyXG4iKTsKLSAgICBpZiAoIW1fY2xpZW50UHJvdG9jb2wuaXNFbXB0eSgpKSB7 Ci0gICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJXZWJTb2NrZXQtUHJvdG9jb2w6ICIpOwotICAgICAg ICBidWlsZGVyLmFwcGVuZChtX2NsaWVudFByb3RvY29sKTsKLSAgICAgICAgYnVpbGRlci5hcHBl bmQoIlxyXG4iKTsKLSAgICB9Ci0gICAgS1VSTCB1cmwgPSBodHRwVVJMRm9yQXV0aGVudGljYXRp b25BbmRDb29raWVzKCk7Ci0gICAgLy8gRklYTUU6IHNldCBhdXRoZW50aWNhdGlvbiBpbmZvcm1h dGlvbiBvciBjb29raWVzIGZvciB1cmwuCi0gICAgLy8gU2V0ICJBdXRob3JpemF0aW9uOiA8Y3Jl ZGVudGlhbHM+IiBpZiBhdXRoZW50aWNhdGlvbiBpbmZvcm1hdGlvbiBleGlzdHMgZm9yIHVybC4K KyAgICBLVVJMIHVybChtX3VybCk7CisgICAgaWYgKCF1cmwucHJvdG9jb2xJcygid3NzIikgJiYg bV9zZWN1cmUpCisgICAgICAgIHVybC5zZXRQcm90b2NvbCgid3NzIik7CisgICAgZWxzZSBpZiAo IXVybC5wcm90b2NvbElzKCJ3cyIpICYmICFtX3NlY3VyZSkKKyAgICAgICAgdXJsLnNldFByb3Rv Y29sKCJ3cyIpOworICAgIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QgcmVxdWVzdCh1cmwsIGNs aWVudE9yaWdpbigpLCBtX2NsaWVudFByb3RvY29sKTsKKworICAgIEtVUkwgY29va2llVXJsID0g aHR0cFVSTEZvckF1dGhlbnRpY2F0aW9uQW5kQ29va2llcygpOworICAgIC8vIEZJWE1FOiBzZXQg YXV0aGVudGljYXRpb24gaW5mb3JtYXRpb24gb3IgY29va2llcyBmb3IgY29va2llVXJsLgorICAg IC8vIFNldCAiQXV0aG9yaXphdGlvbjogPGNyZWRlbnRpYWxzPiIgaWYgYXV0aGVudGljYXRpb24g aW5mb3JtYXRpb24gZXhpc3RzIGZvciBjb29raWVVcmwuCiAgICAgaWYgKG1fY29udGV4dC0+aXNE b2N1bWVudCgpKSB7CiAgICAgICAgIERvY3VtZW50KiBkb2N1bWVudCA9IHN0YXRpY19jYXN0PERv Y3VtZW50Kj4obV9jb250ZXh0KTsKLSAgICAgICAgU3RyaW5nIGNvb2tpZSA9IGNvb2tpZVJlcXVl c3RIZWFkZXJGaWVsZFZhbHVlKGRvY3VtZW50LCB1cmwpOwotICAgICAgICBpZiAoIWNvb2tpZS5p c0VtcHR5KCkpIHsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJDb29raWU6ICIpOwotICAg ICAgICAgICAgYnVpbGRlci5hcHBlbmQoY29va2llKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBw ZW5kKCJcclxuIik7Ci0gICAgICAgIH0KLSAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8Y29va2ll PiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgdXJsPworICAgICAgICBTdHJpbmcgY29va2llID0g Y29va2llUmVxdWVzdEhlYWRlckZpZWxkVmFsdWUoZG9jdW1lbnQsIGNvb2tpZVVybCk7CisgICAg ICAgIGlmICghY29va2llLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlcXVlc3QuYWRkRXh0cmFI ZWFkZXJGaWVsZCgiQ29va2llIiwgY29va2llKTsKKyAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8 Y29va2llPiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgY29va2llVXJsPwogICAgIH0KLSAgICBi dWlsZGVyLmFwcGVuZCgiXHJcbiIpOwotICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCkudXRm OCgpOworCisgICAgcmV0dXJuIHJlcXVlc3Q7CiB9CiAKIHZvaWQgV2ViU29ja2V0SGFuZHNoYWtl OjpyZXNldCgpCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlLmggYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKaW5kZXggYmRh MzIwYS4uMzVlNzA1YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhh bmRzaGFrZS5oCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaApA QCAtMzUsNiArMzUsNyBAQAogCiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRmb3Jt U3RyaW5nLmgiCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIgogI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC02Myw3ICs2 NCw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgU3RyaW5nIGNsaWVudE9yaWdpbigp IGNvbnN0OwogICAgICAgICBTdHJpbmcgY2xpZW50TG9jYXRpb24oKSBjb25zdDsKIAotICAgICAg ICBDU3RyaW5nIGNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdDsKKyAgICAgICAgV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdCBjbGllbnRIYW5kc2hha2VSZXF1ZXN0KCk7CiAKICAgICAgICAg dm9pZCByZXNldCgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdC5jcHAgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGUzMTY3 NwotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hh a2VSZXF1ZXN0LmNwcApAQCAtMCwwICsxLDE1NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv 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 SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNp ZiBFTkFCTEUoV0VCX1NPQ0tFVFMpCisKKyNpbmNsdWRlICJXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0LmgiCisKKyNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNpbmNsdWRlICJTdHJpbmdCdWls ZGVyLmgiCisjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpIZWFkZXJGaWVsZDo6SGVhZGVyRmllbGQo KQoreworfQorCitXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpIZWFkZXJGaWVsZDo6SGVhZGVy RmllbGQoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKQorICAg IDogbmFtZShuYW1lKQorICAgICwgdmFsdWUodmFsdWUpCit7Cit9CisKK1dlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3Q6OkhlYWRlckZpZWxkOjpIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBj b25zdCBTdHJpbmcmIHZhbHVlKQorICAgIDogbmFtZShuYW1lKQorICAgICwgdmFsdWUodmFsdWUp Cit7Cit9CisKK1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QoY29uc3QgS1VSTCYgdXJsLCBjb25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3RyaW5n JiB3ZWJTb2NrZXRQcm90b2NvbCkKKyAgICA6IG1fdXJsKHVybCkKKyAgICAsIG1fc2VjdXJlKG1f dXJsLnByb3RvY29sSXMoIndzcyIpKQorICAgICwgbV9vcmlnaW4ob3JpZ2luKQorICAgICwgbV93 ZWJTb2NrZXRQcm90b2NvbCh3ZWJTb2NrZXRQcm90b2NvbCkKK3sKKyAgICBBU1NFUlQoIW9yaWdp bi5pc051bGwoKSk7Cit9CisKK1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6On5XZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0KCkKK3sKK30KKwordm9pZCBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0 OjphZGRFeHRyYUhlYWRlckZpZWxkKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSwgY29uc3QgU3Ry aW5nJiB2YWx1ZSkKK3sKKyAgICBtX2V4dHJhSGVhZGVyRmllbGRzLmFwcGVuZChIZWFkZXJGaWVs ZChuYW1lLCB2YWx1ZSkpOworfQorCit2b2lkIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFk ZEV4dHJhSGVhZGVyRmllbGQoY29uc3QgY2hhciogbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSkK K3sKKyAgICBtX2V4dHJhSGVhZGVyRmllbGRzLmFwcGVuZChIZWFkZXJGaWVsZChuYW1lLCB2YWx1 ZSkpOworfQorCitWZWN0b3I8V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6SGVhZGVyRmllbGQ+ IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmhlYWRlckZpZWxkcygpIGNvbnN0Cit7CisgICAg Ly8gS2VlcCB0aGUgZm9sbG93aW5nIGNvbnNpc3RlbnQgd2l0aCBoYW5kc2hha2VNZXNzYWdlKCku CisgICAgVmVjdG9yPEhlYWRlckZpZWxkPiBmaWVsZHM7CisgICAgZmllbGRzLmFwcGVuZChIZWFk ZXJGaWVsZCgiVXBncmFkZSIsICJXZWJTb2NrZXQiKSk7CisgICAgZmllbGRzLmFwcGVuZChIZWFk ZXJGaWVsZCgiQ29ubmVjdGlvbiIsICJVcGdyYWRlIikpOworICAgIGZpZWxkcy5hcHBlbmQoSGVh ZGVyRmllbGQoIkhvc3QiLCBob3N0KCkpKTsKKyAgICBmaWVsZHMuYXBwZW5kKEhlYWRlckZpZWxk KCJPcmlnaW4iLCBtX29yaWdpbikpOworICAgIGlmICghbV93ZWJTb2NrZXRQcm90b2NvbC5pc0Vt cHR5KCkpCisgICAgICAgIGZpZWxkcy5hcHBlbmQoSGVhZGVyRmllbGQoIldlYlNvY2tldC1Qcm90 b2NvbCIsIG1fd2ViU29ja2V0UHJvdG9jb2wpKTsKKyAgICBmaWVsZHMuaW5zZXJ0KGZpZWxkcy5z aXplKCkgLSAxLCBtX2V4dHJhSGVhZGVyRmllbGRzKTsKKyAgICByZXR1cm4gZmllbGRzOworfQor CitzdGF0aWMgU3RyaW5nIHJlc291cmNlTmFtZShjb25zdCBLVVJMJiB1cmwpCit7CisgICAgU3Ry aW5nIG5hbWUgPSB1cmwucGF0aCgpOworICAgIGlmIChuYW1lLmlzRW1wdHkoKSkKKyAgICAgICAg bmFtZSA9ICIvIjsKKyAgICBpZiAoIXVybC5xdWVyeSgpLmlzTnVsbCgpKQorICAgICAgICBuYW1l ICs9ICI/IiArIHVybC5xdWVyeSgpOworICAgIEFTU0VSVCghbmFtZS5pc0VtcHR5KCkpOworICAg IEFTU0VSVCghbmFtZS5jb250YWlucygnICcpKTsKKyAgICByZXR1cm4gbmFtZTsKK30KKworQ1N0 cmluZyBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpoYW5kc2hha2VNZXNzYWdlKCkgY29uc3QK K3sKKyAgICAvLyBLZWVwIHRoZSBmb2xsb3dpbmcgY29uc2lzdGVudCB3aXRoIGhlYWRlckZpZWxk cygpLgorICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKKworICAgIGJ1aWxkZXIuYXBwZW5kKCJH RVQgIik7CisgICAgYnVpbGRlci5hcHBlbmQocmVzb3VyY2VOYW1lKG1fdXJsKSk7CisgICAgYnVp bGRlci5hcHBlbmQoIiBIVFRQLzEuMVxyXG4iKTsKKworICAgIGJ1aWxkZXIuYXBwZW5kKCJVcGdy YWRlOiBXZWJTb2NrZXRcclxuIik7CisgICAgYnVpbGRlci5hcHBlbmQoIkNvbm5lY3Rpb246IFVw Z3JhZGVcclxuIik7CisgICAgYnVpbGRlci5hcHBlbmQoIkhvc3Q6ICIpOworICAgIGJ1aWxkZXIu YXBwZW5kKGhvc3QoKSk7CisgICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKKyAgICBidWlsZGVy LmFwcGVuZCgiT3JpZ2luOiAiKTsKKyAgICBidWlsZGVyLmFwcGVuZChtX29yaWdpbik7CisgICAg YnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKKyAgICBpZiAoIW1fd2ViU29ja2V0UHJvdG9jb2wuaXNF bXB0eSgpKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJXZWJTb2NrZXQtUHJvdG9jb2w6ICIp OworICAgICAgICBidWlsZGVyLmFwcGVuZChtX3dlYlNvY2tldFByb3RvY29sKTsKKyAgICAgICAg YnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKKyAgICB9CisKKyAgICBmb3IgKFZlY3RvcjxIZWFkZXJG aWVsZD46OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbV9leHRyYUhlYWRlckZpZWxkcy5iZWdpbigpLCBl bmQgPSBtX2V4dHJhSGVhZGVyRmllbGRzLmVuZCgpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAg ICAgYnVpbGRlci5hcHBlbmQoaXQtPm5hbWUpOworICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiAi KTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoaXQtPnZhbHVlKTsKKyAgICAgICAgYnVpbGRlci5h cHBlbmQoIlxyXG4iKTsKKyAgICB9CisKKyAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOworICAg IHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCkudXRmOCgpOworfQorCitTdHJpbmcgV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdDo6aG9zdCgpIGNvbnN0Cit7CisgICAgU3RyaW5nQnVpbGRlciBidWls ZGVyOworICAgIGJ1aWxkZXIuYXBwZW5kKG1fdXJsLmhvc3QoKS5sb3dlcigpKTsKKyAgICBpZiAo KCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAmJiBtX3VybC5w b3J0KCkgIT0gNDQzKSkgeworICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiIpOworICAgICAgICBi dWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsKKyAgICB9CisgICAg cmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gRU5BQkxFKFdFQl9TT0NLRVRTKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJz b2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCBiL1dlYkNvcmUvd2Vic29ja2V0cy9X ZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uYjdkNmQzYQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKQEAgLTAsMCArMSw4NiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp 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 IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYlNvY2tl dEhhbmRzaGFrZVJlcXVlc3RfaAorI2RlZmluZSBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0X2gK KworI2lmIEVOQUJMRShXRUJfU09DS0VUUykKKworI2luY2x1ZGUgIkNTdHJpbmcuaCIKKyNpbmNs dWRlICJIVFRQSGVhZGVyTWFwLmgiCisjaW5jbHVkZSAiS1VSTC5oIgorI2luY2x1ZGUgIlBsYXRm b3JtU3RyaW5nLmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK2NsYXNzIEF0b21pY1N0cmluZzsKKworY2xhc3MgV2ViU29ja2V0SGFuZHNoYWtlUmVx dWVzdCB7CitwdWJsaWM6CisgICAgc3RydWN0IEhlYWRlckZpZWxkIHsKKyAgICAgICAgSGVhZGVy RmllbGQoKTsKKyAgICAgICAgSGVhZGVyRmllbGQoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBj b25zdCBTdHJpbmcmIHZhbHVlKTsKKyAgICAgICAgSGVhZGVyRmllbGQoY29uc3QgY2hhciogbmFt ZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSk7CisKKyAgICAgICAgQXRvbWljU3RyaW5nIG5hbWU7Cisg ICAgICAgIFN0cmluZyB2YWx1ZTsKKyAgICB9OworCisgICAgV2ViU29ja2V0SGFuZHNoYWtlUmVx dWVzdChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2Vi U29ja2V0UHJvdG9jb2wpOworICAgIH5XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KCk7CisKKyAg ICAvLyBBY2NvcmRpbmcgdG8gY3VycmVudCBXZWIgU29ja2V0IHByb3RvY29sIHNwZWMsIGZvdXIg bWFuZGF0b3J5IGhlYWRlcnMgKFVwZ3JhZGUsIENvbm5lY3Rpb24sIEhvc3QsIGFuZCBPcmlnaW4p IGFuZAorICAgIC8vIG9uZSBvcHRpb25hbCBoZWFkZXIgKFdlYlNvY2tldC1Qcm90b2NvbCkgc2hv dWxkIGJlIHNlbnQgaW4gdGhpcyBvcmRlciwgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUgaGFuZHNo YWtlIHJlcXVlc3QuCisgICAgLy8gVGhlIHJlbWFpbmluZyBoZWFkZXJzIGNhbiBiZSBzZXQgYnkg dXNpbmcgdGhlIGZvbGxvd2luZyBmdW5jdGlvbi4KKyAgICB2b2lkIGFkZEV4dHJhSGVhZGVyRmll bGQoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKTsKKyAgICB2 b2lkIGFkZEV4dHJhSGVhZGVyRmllbGQoY29uc3QgY2hhciogbmFtZSwgY29uc3QgU3RyaW5nJiB2 YWx1ZSk7CisKKyAgICAvLyBSZXR1cm5zIHRoZSBsaXN0IG9mIGhlYWRlciBmaWVsZHMgaW5jbHVk aW5nIGZpdmUgc3BlY2lhbCBvbmVzLgorICAgIFZlY3RvcjxIZWFkZXJGaWVsZD4gaGVhZGVyRmll bGRzKCkgY29uc3Q7CisKKyAgICAvLyBCdWlsZCB0aGUgY2hhcmFjdGVyIHNlcXVlbmNlIGZvciB0 aGlzIGhhbmRzaGFrZSByZXF1ZXN0LgorICAgIENTdHJpbmcgaGFuZHNoYWtlTWVzc2FnZSgpIGNv bnN0OworCitwcml2YXRlOgorICAgIFN0cmluZyBob3N0KCkgY29uc3Q7CisKKyAgICBLVVJMIG1f dXJsOworICAgIGJvb2wgbV9zZWN1cmU7CisgICAgU3RyaW5nIG1fb3JpZ2luOworICAgIFN0cmlu ZyBtX3dlYlNvY2tldFByb3RvY29sOworICAgIFZlY3RvcjxIZWFkZXJGaWVsZD4gbV9leHRyYUhl YWRlckZpZWxkczsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVO QUJMRShXRUJfU09DS0VUUykKKworI2VuZGlmIC8vIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Rf aAo= 49782 2010-03-01 23:16:58 -0800 2010-03-02 00:53:45 -0800 Patch v7 (Third try) bug-34784-20100302161656.patch text/plain 21433 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MzUwYmJlZC4uZmMzYmY3YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAxMC0wMy0wMSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAqIHdlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhh bmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJT b2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAqIHdlYnNv Y2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmg6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpXZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KToKKyAgICAgICAg KFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6On5XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFk ZEV4dHJhSGVhZGVyRmllbGQpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6aGVhZGVyRmllbGRzKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3Q6Omhvc3QpOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdC5oOiBBZGRlZC4KKwogMjAxMC0wMy0wMSAgQ2hyaXMgRmxlaXphY2ggIDxjZmxl aXphY2hAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K aW5kZXggMWI0M2YzZi4uYjY0NDk1NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0zNDY4LDcgKzM0NjgsOSBAQCB3ZWJj b3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmgg XAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmggXAogCVdlYkNv cmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIFwKLQlXZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKKwlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFu ZHNoYWtlLmggXAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0 LmNwcCBcCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaAog CiBpZiBFTkFCTEVfV09SS0VSUwogd2ViY29yZV9zb3VyY2VzICs9IFwKZGlmZiAtLWdpdCBhL1dl YkNvcmUvV2ViQ29yZS5neXBpIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggYzRjOTIxMC4u NWE5YTUyYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvV2ViQ29yZS9X ZWJDb3JlLmd5cGkKQEAgLTM2MjEsNiArMzYyMSw4IEBACiAgICAgICAgICAgICAnd2Vic29ja2V0 cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2Vi U29ja2V0SGFuZHNoYWtlLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2UuaCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0LmNwcCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV29ya2VyVGhyZWFkYWJsZVdlYlNv Y2tldENoYW5uZWwuY3BwJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dvcmtlclRocmVhZGFi bGVXZWJTb2NrZXRDaGFubmVsLmgnLAogICAgICAgICAgICAgJ3dvcmtlcnMvQWJzdHJhY3RXb3Jr ZXIuY3BwJywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNv cmUucHJvCmluZGV4IGQ2NDA2ZTMuLjRjMjIwNzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29y ZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMjY3OCw2ICsyNjc4LDcgQEAgU09V UkNFUyArPSBcCiAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXQuY3BwIFwKICAgICB3ZWJzb2NrZXRz L1dlYlNvY2tldENoYW5uZWwuY3BwIFwKICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFr ZS5jcHAgXAorICAgIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAgXAog ICAgIHdlYnNvY2tldHMvVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwIFwKICAgICBwbGF0 Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUVycm9yQmFzZS5jcHAgXAogICAgIHBsYXRmb3JtL25l dHdvcmsvU29ja2V0U3RyZWFtSGFuZGxlQmFzZS5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2Vi Q29yZS52Y3Byb2oKaW5kZXggMDlhYmE2MS4uMmFkODA5MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9X ZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUudmNwcm9q L1dlYkNvcmUudmNwcm9qCkBAIC0yNzA0OSwxOSArMjcwNDksMTkgQEAKIAkJCQk+DQogCQkJPC9G aWxlPg0KIAkJCTxGaWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFrX2xp bmVzLmNwcCINCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcQmlkaVJ1bi5jcHAiDQog CQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0JCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5k ZXJpbmdcYnJlYWtfbGluZXMuaCINCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcQmlk aVJ1bi5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAgICAgICAgICAgICAgIDxG aWxlDQotCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlSdW4uY3BwIg0KKwkJCTxG aWxlDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFrX2xpbmVzLmNwcCINCiAJ CQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KLQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRl cmluZ1xCaWRpUnVuLmgiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFrX2xp bmVzLmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCkBAIC0yNzEyMCw3ICsyNzEy MCw3IEBACiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5saW5lRmxvd0JveC5oIg0K IAkJCQk+DQogCQkJPC9GaWxlPg0KLSAgICAgICAgICAgICAgICAgICAgICAgIDxGaWxlDQorCQkJ PEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcSW5saW5lSXRlcmF0b3IuaCIN CiAJCQkJPg0KIAkJCTwvRmlsZT4NCkBAIC0zNDI1Niw2ICszNDI1NiwyMiBAQAogCQkJCQk+DQog CQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3Nc anNcSmF2YVNjcmlwdFByb2ZpbGUuY3BwIg0KKwkJCQkJPg0KKwkJCQk8L0ZpbGU+DQorCQkJCTxG aWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxl LmgiDQorCQkJCQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0 aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNwcCINCisJCQkJCT4NCisJ CQkJPC9GaWxlPg0KKwkJCQk8RmlsZQ0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xq c1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuaCINCisJCQkJCT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8 RmlsZQ0KIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKU0Fic3RyYWN0V29ya2Vy Q3VzdG9tLmNwcCINCiAJCQkJCT4NCiAJCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KQEAgLTM5OTQ0 LDIyICszOTk2MCw2IEBACiAJCQkJCTwvRmlsZUNvbmZpZ3VyYXRpb24+DQogCQkJCTwvRmlsZT4N CiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlw dFByb2ZpbGUuY3BwIg0KLQkJCQkJPg0KLQkJCQk8L0ZpbGU+DQotCQkJCTxGaWxlDQotCQkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlLmgiDQotCQkJCQk+ DQotCQkJCTwvRmlsZT4NCi0JCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGlu Z3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmNwcCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0K LQkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0 UHJvZmlsZU5vZGUuaCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0KLQkJCQk8RmlsZQ0KIAkJCQkJ UmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xTY2hlZHVsZWRBY3Rpb24uY3BwIg0KIAkJCQkJ Pg0KIAkJCQkJPEZpbGVDb25maWd1cmF0aW9uDQpAQCAtNDMwNTYsMTEgKzQzMDU2LDExIEBACiAJ CQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxp bnNwZWN0b3JcZnJvbnQtZW5kXFRleHRWaWV3ZXIuanMiDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4u XGluc3BlY3Rvclxmcm9udC1lbmRcdGV4dFZpZXdlci5jc3MiDQogCQkJCQk+DQogCQkJCTwvRmls ZT4NCiAJCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5zcGVjdG9yXGZyb250LWVu ZFx0ZXh0Vmlld2VyLmNzcyINCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5zcGVjdG9yXGZyb250 LWVuZFxUZXh0Vmlld2VyLmpzIg0KIAkJCQkJPg0KIAkJCQk8L0ZpbGU+DQogCQkJCTxGaWxlDQpA QCAtNDM0ODksNiArNDM0ODksMTQgQEAKIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQor CQkJCVJlbGF0aXZlUGF0aD0iLi5cd2Vic29ja2V0c1xXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0 LmNwcCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9 Ii4uXHdlYnNvY2tldHNcV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIg0KKwkJCQk+DQorCQkJ PC9GaWxlPg0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5cd2Vic29ja2V0c1xXb3Jr ZXJUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9X ZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBlMzlhMGIzLi5i ZDhmNzA5IDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAt MTI2NCw2ICsxMjY0LDggQEAKIAkJNzU3OTNFRDMwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3Nh Z2VFdmVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NzU3OTNFRDAwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5oICovOyB9OwogCQk3 NTc5M0VENDBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50Lm1tIGluIFNvdXJjZXMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzU3OTNFRDEwRDBDRTg1QjAwN0ZD MEFDIC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLzsgfTsKIAkJNzU3OTNFRDUwRDBDRTg1QjAwN0ZD MEFDIC8qIERPTU1lc3NhZ2VFdmVudEludGVybmFsLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NTc5M0VEMjBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVz c2FnZUV2ZW50SW50ZXJuYWwuaCAqLzsgfTsKKwkJNzYzN0M1NDExMTJFN0I3NDAwM0Q2Q0RDIC8q IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDAxMTJFN0I3NDAwM0Q2Q0RDIC8qIFdlYlNvY2tl dEhhbmRzaGFrZVJlcXVlc3QuY3BwICovOyB9OworCQk3NjM3QzU0MzExMkU3QjdFMDAzRDZDREMg LyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gNzYzN0M1NDIxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tl dEhhbmRzaGFrZVJlcXVlc3QuaCAqLzsgfTsKIAkJNzY5M0JBRDIxMDZDMkRDQTAwN0IwODIzIC8q IEhhbHRhYmxlUGx1Z2luLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA3NjkzQkFDRTEwNkMyRENBMDA3QjA4MjMgLyogSGFsdGFibGVQbHVnaW4uaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk3NjkzQkFEMzEw NkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2OTNCQUNGMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVn aW5IYWx0ZXIuY3BwICovOyB9OwogCQk3NjkzQkFENDEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2lu SGFsdGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 NjkzQkFEMDEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmggKi87IH07CkBAIC02Njk3 LDYgKzY2OTksOCBAQAogCQk3NTc5M0VEMDBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2 ZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBET01NZXNzYWdlRXZlbnQu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzU3OTNFRDEwRDBDRTg1QjAwN0ZDMEFD IC8qIERPTU1lc3NhZ2VFdmVudC5tbSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5vYmpjcHA7 IHBhdGggPSBET01NZXNzYWdlRXZlbnQubW07IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTc1NzkzRUQyMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnRJbnRlcm5hbC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NTWVzc2FnZUV2ZW50SW50ZXJuYWwu aDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzYzN0M1NDAxMTJFN0I3NDAwM0Q2Q0RD IC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCTc2MzdDNTQyMTEyRTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRI YW5kc2hha2VSZXF1ZXN0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3QuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzY5 M0JBQ0UxMDZDMkRDQTAwN0IwODIzIC8qIEhhbHRhYmxlUGx1Z2luLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IEhhbHRhYmxlUGx1Z2luLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTc2OTNCQUNGMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUGx1Z2luSGFsdGVyLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzY5M0JBRDAxMDZDMkRDQTAwN0IwODIzIC8qIFBs dWdpbkhhbHRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBQbHVnaW5IYWx0 ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTExMTc3LDYgKzExMTgxLDggQEAK IAkJNTE4QTM0QkQxMDI2QzgzMTAwMUI2ODk2IC8qIHdlYnNvY2tldHMgKi8gPSB7CiAJCQlpc2Eg PSBQQlhHcm91cDsKIAkJCWNoaWxkcmVuID0gKAorCQkJCTc2MzdDNTQyMTEyRTdCN0UwMDNENkNE QyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi8sCisJCQkJNzYzN0M1NDAxMTJFN0I3 NDAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwICovLAogCQkJCTUxMTIy NDcxMTBDRkI4QzYwMDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAgKi8s CiAJCQkJNTExMjI0NzMxMENGQjhEODAwODA5OUQ3IC8qIFRocmVhZGFibGVXZWJTb2NrZXRDaGFu bmVsLmggKi8sCiAJCQkJNTExMjI0NzUxMENGQjhFODAwODA5OUQ3IC8qIFRocmVhZGFibGVXZWJT b2NrZXRDaGFubmVsQ2xpZW50V3JhcHBlci5oICovLApAQCAtMTg1OTQsNiArMTg2MDAsNyBAQAog CQkJCTU5NjIyOTdBMTEzM0VGRTIwMERDNENCQiAvKiBHZW9sb2NhdGlvblBvc2l0aW9uQ2FjaGUu aCBpbiBIZWFkZXJzICovLAogCQkJCTBCQzJDNzc4MTEzNEE4RkMwMDBCMkY2MSAvKiBDYW52YXNT dXJmYWNlLmggaW4gSGVhZGVycyAqLywKIAkJCQlDRTE3MkUwMTExMzZFOENFMDA2MkE1MzMgLyog Wm9vbU1vZGUuaCBpbiBIZWFkZXJzICovLAorCQkJCTc2MzdDNTQzMTEyRTdCN0UwMDNENkNEQyAv KiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQly dW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTIwNzgzLDYg KzIwNzkwLDcgQEAKIAkJCQlFMTY5ODI2NDExMzQ2N0YzMDA4OTQxMTUgLyogSmF2YVJ1bnRpbWVP YmplY3QuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNTk2MjI5NzgxMTMzRUZENzAwREM0Q0JCIC8q IEdlb2xvY2F0aW9uUG9zaXRpb25DYWNoZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkwQkMyQzc3 NzExMzRBOEZDMDAwQjJGNjEgLyogQ2FudmFzU3VyZmFjZS5jcHAgaW4gU291cmNlcyAqLywKKwkJ CQk3NjM3QzU0MTExMkU3Qjc0MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9j ZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2Nr ZXRDaGFubmVsLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcApp bmRleCA3Yjg3YmYzLi45NmU5ODM4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dlYnNvY2tldHMvV2Vi U29ja2V0Q2hhbm5lbC5jcHAKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5u ZWwuY3BwCkBAIC00NCw2ICs0NCw3IEBACiAjaW5jbHVkZSAiU29ja2V0U3RyZWFtSGFuZGxlLmgi CiAjaW5jbHVkZSAiU3RyaW5nSGFzaC5oIgogI2luY2x1ZGUgIldlYlNvY2tldENoYW5uZWxDbGll bnQuaCIKKyNpbmNsdWRlICJXZWJTb2NrZXRIYW5kc2hha2UuaCIKIAogI2luY2x1ZGUgPHd0Zi9E ZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9GYXN0TWFsbG9jLmg+CmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9X ZWJTb2NrZXRIYW5kc2hha2UuY3BwCmluZGV4IDQ0NzEwOTYuLjAzN2RhNzggMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCisrKyBiL1dlYkNvcmUv d2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwCkBAIC0xMzAsMTEgKzEzMCw2IEBAIGJv b2wgV2ViU29ja2V0SGFuZHNoYWtlOjpzZWN1cmUoKSBjb25zdAogICAgIHJldHVybiBtX3NlY3Vy ZTsKIH0KIAotdm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnNldFNlY3VyZShib29sIHNlY3VyZSkK LXsKLSAgICBtX3NlY3VyZSA9IHNlY3VyZTsKLX0KLQogU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFr ZTo6Y2xpZW50T3JpZ2luKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9jb250ZXh0LT5zZWN1cml0 eU9yaWdpbigpLT50b1N0cmluZygpOwpAQCAtMTU4LDYgKzE1Myw3IEBAIFN0cmluZyBXZWJTb2Nr ZXRIYW5kc2hha2U6OmNsaWVudExvY2F0aW9uKCkgY29uc3QKIAogQ1N0cmluZyBXZWJTb2NrZXRI YW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAogeworICAgIC8vIEtlZXAg dGhlIGZvbGxvd2luZyBjb25zaXN0ZW50IHdpdGggY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgpLgog ICAgIFN0cmluZ0J1aWxkZXIgYnVpbGRlcjsKIAogICAgIGJ1aWxkZXIuYXBwZW5kKCJHRVQgIik7 CkBAIC0xNjcsMTEgKzE2Myw5IEBAIENTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRI YW5kc2hha2VNZXNzYWdlKCkgY29uc3QKICAgICBidWlsZGVyLmFwcGVuZCgiQ29ubmVjdGlvbjog VXBncmFkZVxyXG4iKTsKICAgICBidWlsZGVyLmFwcGVuZCgiSG9zdDogIik7CiAgICAgYnVpbGRl ci5hcHBlbmQobV91cmwuaG9zdCgpLmxvd2VyKCkpOwotICAgIGlmIChtX3VybC5wb3J0KCkpIHsK LSAgICAgICAgaWYgKCghbV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1 cmUgJiYgbV91cmwucG9ydCgpICE9IDQ0MykpIHsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5k KCI6Iik7Ci0gICAgICAgICAgICBidWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5w b3J0KCkpKTsKLSAgICAgICAgfQorICAgIGlmIChtX3VybC5wb3J0KCkgJiYgKCghbV9zZWN1cmUg JiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9IDQ0 MykpKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7CisgICAgICAgIGJ1aWxkZXIuYXBw ZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwogICAgIH0KICAgICBidWlsZGVyLmFw cGVuZCgiXHJcbiIpOwogICAgIGJ1aWxkZXIuYXBwZW5kKCJPcmlnaW46ICIpOwpAQCAtMTgyLDkg KzE3Niw4IEBAIENTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VNZXNz YWdlKCkgY29uc3QKICAgICAgICAgYnVpbGRlci5hcHBlbmQobV9jbGllbnRQcm90b2NvbCk7CiAg ICAgICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CiAgICAgfQorCiAgICAgS1VSTCB1cmwgPSBo dHRwVVJMRm9yQXV0aGVudGljYXRpb25BbmRDb29raWVzKCk7Ci0gICAgLy8gRklYTUU6IHNldCBh dXRoZW50aWNhdGlvbiBpbmZvcm1hdGlvbiBvciBjb29raWVzIGZvciB1cmwuCi0gICAgLy8gU2V0 ICJBdXRob3JpemF0aW9uOiA8Y3JlZGVudGlhbHM+IiBpZiBhdXRoZW50aWNhdGlvbiBpbmZvcm1h dGlvbiBleGlzdHMgZm9yIHVybC4KICAgICBpZiAobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpIHsK ICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihtX2Nv bnRleHQpOwogICAgICAgICBTdHJpbmcgY29va2llID0gY29va2llUmVxdWVzdEhlYWRlckZpZWxk VmFsdWUoZG9jdW1lbnQsIHVybCk7CkBAIC0xOTUsMTAgKzE4OCwyOCBAQCBDU3RyaW5nIFdlYlNv Y2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0CiAgICAgICAgIH0K ICAgICAgICAgLy8gU2V0ICJDb29raWUyOiA8Y29va2llPiIgaWYgY29va2llcyAyIGV4aXN0cyBm b3IgdXJsPwogICAgIH0KKwogICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CiAgICAgcmV0dXJu IGJ1aWxkZXIudG9TdHJpbmcoKS51dGY4KCk7CiB9CiAKK1dlYlNvY2tldEhhbmRzaGFrZVJlcXVl c3QgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VSZXF1ZXN0KCkgY29uc3QKK3sK KyAgICAvLyBLZWVwIHRoZSBmb2xsb3dpbmcgY29uc2lzdGVudCB3aXRoIGNsaWVudEhhbmRzaGFr ZU1lc3NhZ2UoKS4KKyAgICBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0IHJlcXVlc3QobV91cmws IGNsaWVudE9yaWdpbigpLCBtX2NsaWVudFByb3RvY29sKTsKKworICAgIEtVUkwgdXJsID0gaHR0 cFVSTEZvckF1dGhlbnRpY2F0aW9uQW5kQ29va2llcygpOworICAgIGlmIChtX2NvbnRleHQtPmlz RG9jdW1lbnQoKSkgeworICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNfY2FzdDxE b2N1bWVudCo+KG1fY29udGV4dCk7CisgICAgICAgIFN0cmluZyBjb29raWUgPSBjb29raWVSZXF1 ZXN0SGVhZGVyRmllbGRWYWx1ZShkb2N1bWVudCwgdXJsKTsKKyAgICAgICAgaWYgKCFjb29raWUu aXNFbXB0eSgpKQorICAgICAgICAgICAgcmVxdWVzdC5hZGRFeHRyYUhlYWRlckZpZWxkKCJDb29r aWUiLCBjb29raWUpOworICAgICAgICAvLyBTZXQgIkNvb2tpZTI6IDxjb29raWU+IiBpZiBjb29r aWVzIDIgZXhpc3RzIGZvciB1cmw/CisgICAgfQorCisgICAgcmV0dXJuIHJlcXVlc3Q7Cit9CisK IHZvaWQgV2ViU29ja2V0SGFuZHNoYWtlOjpyZXNldCgpCiB7CiAgICAgbV9tb2RlID0gSW5jb21w bGV0ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2Uu aCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaAppbmRleCBiZGEzMjBh Li5hMjIzOTljIDEwMDY0NAotLS0gYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlLmgKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCkBAIC0z NSw2ICszNSw3IEBACiAKICNpbmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJp bmcuaCIKKyNpbmNsdWRlICJXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgiCiAjaW5jbHVkZSA8 d3RmL05vbmNvcHlhYmxlLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTU4LDEyICs1OSwx MiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIHZvaWQgc2V0Q2xpZW50UHJvdG9jb2wo Y29uc3QgU3RyaW5nJiBwcm90b2NvbCk7CiAKICAgICAgICAgYm9vbCBzZWN1cmUoKSBjb25zdDsK LSAgICAgICAgdm9pZCBzZXRTZWN1cmUoYm9vbCBzZWN1cmUpOwogCiAgICAgICAgIFN0cmluZyBj bGllbnRPcmlnaW4oKSBjb25zdDsKICAgICAgICAgU3RyaW5nIGNsaWVudExvY2F0aW9uKCkgY29u c3Q7CiAKICAgICAgICAgQ1N0cmluZyBjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkgY29uc3Q7Cisg ICAgICAgIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QgY2xpZW50SGFuZHNoYWtlUmVxdWVzdCgp IGNvbnN0OwogCiAgICAgICAgIHZvaWQgcmVzZXQoKTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS93 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIGIvV2ViQ29yZS93ZWJzb2Nr ZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmIzYjIwNGQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAKQEAgLTAsMCArMSw5MyBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlz dHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVk ZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoV0VCX1NPQ0tFVFMpCisKKyNpbmNsdWRlICJXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgiCisKKyNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKKyNp bmNsdWRlICJTdHJpbmdCdWlsZGVyLmgiCisjaW5jbHVkZSA8dXRpbGl0eT4KKyNpbmNsdWRlIDx3 dGYvQXNzZXJ0aW9ucy5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1dlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3Q6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QoY29uc3QgS1VSTCYgdXJsLCBj b25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3RyaW5nJiB3ZWJTb2NrZXRQcm90b2NvbCkKKyAg ICA6IG1fdXJsKHVybCkKKyAgICAsIG1fc2VjdXJlKG1fdXJsLnByb3RvY29sSXMoIndzcyIpKQor ICAgICwgbV9vcmlnaW4ob3JpZ2luKQorICAgICwgbV93ZWJTb2NrZXRQcm90b2NvbCh3ZWJTb2Nr ZXRQcm90b2NvbCkKK3sKKyAgICBBU1NFUlQoIW9yaWdpbi5pc051bGwoKSk7Cit9CisKK1dlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3Q6On5XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KCkKK3sKK30K Kwordm9pZCBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjphZGRFeHRyYUhlYWRlckZpZWxkKGNv bnN0IEF0b21pY1N0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBtX2V4 dHJhSGVhZGVyRmllbGRzLmFwcGVuZChzdGQ6Om1ha2VfcGFpcihuYW1lLCB2YWx1ZSkpOworfQor Cit2b2lkIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFkZEV4dHJhSGVhZGVyRmllbGQoY29u c3QgY2hhciogbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBtX2V4dHJhSGVhZGVy RmllbGRzLmFwcGVuZChzdGQ6Om1ha2VfcGFpcihuYW1lLCB2YWx1ZSkpOworfQorCitWZWN0b3I8 c3RkOjpwYWlyPEF0b21pY1N0cmluZywgU3RyaW5nPiA+IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVl c3Q6OmhlYWRlckZpZWxkcygpIGNvbnN0Cit7CisgICAgVmVjdG9yPHN0ZDo6cGFpcjxBdG9taWNT dHJpbmcsIFN0cmluZz4gPiBmaWVsZHM7CisgICAgZmllbGRzLmFwcGVuZChzdGQ6Om1ha2VfcGFp cigiVXBncmFkZSIsICJXZWJTb2NrZXQiKSk7CisgICAgZmllbGRzLmFwcGVuZChzdGQ6Om1ha2Vf cGFpcigiQ29ubmVjdGlvbiIsICJVcGdyYWRlIikpOworICAgIGZpZWxkcy5hcHBlbmQoc3RkOjpt YWtlX3BhaXIoIkhvc3QiLCBob3N0KCkpKTsKKyAgICBmaWVsZHMuYXBwZW5kKHN0ZDo6bWFrZV9w YWlyKCJPcmlnaW4iLCBtX29yaWdpbikpOworICAgIGlmICghbV93ZWJTb2NrZXRQcm90b2NvbC5p c0VtcHR5KCkpCisgICAgICAgIGZpZWxkcy5hcHBlbmQoc3RkOjptYWtlX3BhaXIoIldlYlNvY2tl dC1Qcm90b2NvbCIsIG1fd2ViU29ja2V0UHJvdG9jb2wpKTsKKyAgICBmaWVsZHMuYXBwZW5kKG1f ZXh0cmFIZWFkZXJGaWVsZHMpOworICAgIHJldHVybiBmaWVsZHM7Cit9CisKK1N0cmluZyBXZWJT b2NrZXRIYW5kc2hha2VSZXF1ZXN0Ojpob3N0KCkgY29uc3QKK3sKKyAgICBTdHJpbmdCdWlsZGVy IGJ1aWxkZXI7CisgICAgYnVpbGRlci5hcHBlbmQobV91cmwuaG9zdCgpLmxvd2VyKCkpOworICAg IGlmICgoIW1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1f dXJsLnBvcnQoKSAhPSA0NDMpKSB7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCI6Iik7CisgICAg ICAgIGJ1aWxkZXIuYXBwZW5kKFN0cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOworICAgIH0K KyAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoV0VCX1NPQ0tFVFMpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIGIvV2ViQ29yZS93ZWJzb2Nr ZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi5mNmRlYWYxCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRz L1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaApAQCAtMCwwICsxLDcyIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmli dXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUg bmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBw cm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2Vi U29ja2V0SGFuZHNoYWtlUmVxdWVzdF9oCisjZGVmaW5lIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVl c3RfaAorCisjaWYgRU5BQkxFKFdFQl9TT0NLRVRTKQorCisjaW5jbHVkZSAiS1VSTC5oIgorI2lu Y2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEF0b21pY1N0cmluZzsKKworY2xhc3MgV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdCB7CitwdWJsaWM6CisgICAgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dChjb25zdCBLVVJMJiwgY29uc3QgU3RyaW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29j a2V0UHJvdG9jb2wpOworICAgIH5XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KCk7CisKKyAgICAv LyBBY2NvcmRpbmcgdG8gY3VycmVudCBXZWIgU29ja2V0IHByb3RvY29sIHNwZWNpZmljYXRpb24s IGZvdXIgbWFuZGF0b3J5IGhlYWRlcnMgKFVwZ3JhZGUsIENvbm5lY3Rpb24sIEhvc3QsIGFuZCBP cmlnaW4pIGFuZAorICAgIC8vIG9uZSBvcHRpb25hbCBoZWFkZXIgKFdlYlNvY2tldC1Qcm90b2Nv bCkgc2hvdWxkIGJlIHNlbnQgaW4gdGhpcyBvcmRlciwgYXQgdGhlIGJlZ2lubmluZyBvZiB0aGUg aGFuZHNoYWtlIHJlcXVlc3QuCisgICAgLy8gVGhlIHJlbWFpbmluZyBoZWFkZXJzIGNhbiBiZSBz ZXQgYnkgdXNpbmcgdGhlIGZvbGxvd2luZyBmdW5jdGlvbi4KKyAgICB2b2lkIGFkZEV4dHJhSGVh ZGVyRmllbGQoY29uc3QgQXRvbWljU3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKTsK KyAgICB2b2lkIGFkZEV4dHJhSGVhZGVyRmllbGQoY29uc3QgY2hhciogbmFtZSwgY29uc3QgU3Ry aW5nJiB2YWx1ZSk7CisKKyAgICAvLyBSZXR1cm5zIHRoZSBsaXN0IG9mIGhlYWRlciBmaWVsZHMg aW5jbHVkaW5nIGZpdmUgc3BlY2lhbCBvbmVzLgorICAgIFZlY3RvcjxzdGQ6OnBhaXI8QXRvbWlj U3RyaW5nLCBTdHJpbmc+ID4gaGVhZGVyRmllbGRzKCkgY29uc3Q7CisKK3ByaXZhdGU6CisgICAg U3RyaW5nIGhvc3QoKSBjb25zdDsKKworICAgIEtVUkwgbV91cmw7CisgICAgYm9vbCBtX3NlY3Vy ZTsKKyAgICBTdHJpbmcgbV9vcmlnaW47CisgICAgU3RyaW5nIG1fd2ViU29ja2V0UHJvdG9jb2w7 CisgICAgVmVjdG9yPHN0ZDo6cGFpcjxBdG9taWNTdHJpbmcsIFN0cmluZz4gPiBtX2V4dHJhSGVh ZGVyRmllbGRzOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5B QkxFKFdFQl9TT0NLRVRTKQorCisjZW5kaWYgLy8gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdF9o Cg== 49789 2010-03-02 00:53:53 -0800 2010-03-02 22:31:38 -0800 Patch v8 (Fix 'std::' and WebCore.pro) bug-34784-20100302175351.patch text/plain 22919 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MzUwYmJlZC4uZmMzYmY3YSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAxMC0wMy0wMSAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAqIHdlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhh bmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJT b2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAqIHdlYnNv Y2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmg6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpXZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KToKKyAgICAgICAg KFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6On5XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFk ZEV4dHJhSGVhZGVyRmllbGQpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6aGVhZGVyRmllbGRzKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3Q6Omhvc3QpOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdC5oOiBBZGRlZC4KKwogMjAxMC0wMy0wMSAgQ2hyaXMgRmxlaXphY2ggIDxjZmxl aXphY2hAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K aW5kZXggMWI0M2YzZi4uYjY0NDk1NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0zNDY4LDcgKzM0NjgsOSBAQCB3ZWJj b3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmgg XAogCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmggXAogCVdlYkNv cmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIFwKLQlXZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmgKKwlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFu ZHNoYWtlLmggXAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0 LmNwcCBcCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaAog CiBpZiBFTkFCTEVfV09SS0VSUwogd2ViY29yZV9zb3VyY2VzICs9IFwKZGlmZiAtLWdpdCBhL1dl YkNvcmUvV2ViQ29yZS5neXBpIGIvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggYzRjOTIxMC4u NWE5YTUyYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvV2ViQ29yZS9X ZWJDb3JlLmd5cGkKQEAgLTM2MjEsNiArMzYyMSw4IEBACiAgICAgICAgICAgICAnd2Vic29ja2V0 cy9XZWJTb2NrZXRDaGFubmVsQ2xpZW50LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2Vi U29ja2V0SGFuZHNoYWtlLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRI YW5kc2hha2UuaCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0LmNwcCcsCisgICAgICAgICAgICAnd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0LmgnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV29ya2VyVGhyZWFkYWJsZVdlYlNv Y2tldENoYW5uZWwuY3BwJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dvcmtlclRocmVhZGFi bGVXZWJTb2NrZXRDaGFubmVsLmgnLAogICAgICAgICAgICAgJ3dvcmtlcnMvQWJzdHJhY3RXb3Jr ZXIuY3BwJywKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNv cmUucHJvCmluZGV4IGQ2NDA2ZTMuLjQwMDAwZjEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29y ZS5wcm8KKysrIGIvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtMjY3MSwyNCArMjY3MSwzNSBAQCBT T1VSQ0VTICs9IFwKIH0KIAogY29udGFpbnMoREVGSU5FUywgRU5BQkxFX1dFQl9TT0NLRVRTPTEp IHsKLUhFQURFUlMgKz0gXAotICAgIHBsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFu ZGxlUHJpdmF0ZS5oIFwKKyAgICBIRUFERVJTICs9IFwKKyAgICAgICAgd2Vic29ja2V0cy9UaHJl YWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5oIFwKKyAgICAgICAgd2Vic29ja2V0cy9UaHJlYWRhYmxl V2ViU29ja2V0Q2hhbm5lbENsaWVudFdyYXBwZXIuaCBcCisgICAgICAgIHdlYnNvY2tldHMvV2Vi U29ja2V0LmggXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuaCBcCisgICAg ICAgIHdlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIFwKKyAgICAgICAgd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaCBcCisgICAgICAgIHdlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdC5oIFwKKyAgICAgICAgcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRT dHJlYW1IYW5kbGVQcml2YXRlLmgKIAotU09VUkNFUyArPSBcCi0gICAgd2Vic29ja2V0cy9XZWJT b2NrZXQuY3BwIFwKLSAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIFwKLSAgICB3 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAgXAotICAgIHdlYnNvY2tldHMvVGhyZWFk YWJsZVdlYlNvY2tldENoYW5uZWwuY3BwIFwKLSAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0 cmVhbUVycm9yQmFzZS5jcHAgXAotICAgIHBsYXRmb3JtL25ldHdvcmsvU29ja2V0U3RyZWFtSGFu ZGxlQmFzZS5jcHAgXAotICAgIHBsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxl UXQuY3BwIFwKLSAgICBiaW5kaW5ncy9qcy9KU1dlYlNvY2tldEN1c3RvbS5jcHAgXAotICAgIGJp bmRpbmdzL2pzL0pTV2ViU29ja2V0Q29uc3RydWN0b3IuY3BwCisgICAgU09VUkNFUyArPSBcCisg ICAgICAgIHdlYnNvY2tldHMvV2ViU29ja2V0LmNwcCBcCisgICAgICAgIHdlYnNvY2tldHMvV2Vi U29ja2V0Q2hhbm5lbC5jcHAgXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFr ZS5jcHAgXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3Bw IFwKKyAgICAgICAgd2Vic29ja2V0cy9UaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAgXAor ICAgICAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUVycm9yQmFzZS5jcHAgXAorICAg ICAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUhhbmRsZUJhc2UuY3BwIFwKKyAgICAg ICAgcGxhdGZvcm0vbmV0d29yay9xdC9Tb2NrZXRTdHJlYW1IYW5kbGVRdC5jcHAgXAorICAgICAg ICBiaW5kaW5ncy9qcy9KU1dlYlNvY2tldEN1c3RvbS5jcHAgXAorICAgICAgICBiaW5kaW5ncy9q cy9KU1dlYlNvY2tldENvbnN0cnVjdG9yLmNwcAorCisgICAgY29udGFpbnMoREVGSU5FUywgRU5B QkxFX1dPUktFUlM9MSkgeworICAgICAgICBIRUFERVJTICs9IFwKKyAgICAgICAgICAgIHdlYnNv Y2tldHMvV29ya2VyVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuaAogCi1jb250YWlucyhERUZJ TkVTLCBFTkFCTEVfV09SS0VSUz0xKSB7Ci1TT1VSQ0VTICs9IFwKLSAgICB3ZWJzb2NrZXRzL1dv cmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmNwcAotfQorICAgICAgICBTT1VSQ0VTICs9 IFwKKyAgICAgICAgICAgIHdlYnNvY2tldHMvV29ya2VyVGhyZWFkYWJsZVdlYlNvY2tldENoYW5u ZWwuY3BwCisgICAgfQogfQogCiBjb250YWlucyhERUZJTkVTLCBFTkFCTEVfM0RfQ0FOVkFTPTEp IHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2ogYi9X ZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCmluZGV4IDA5YWJhNjEuLjJhZDgw OTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKKysr IGIvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagpAQCAtMjcwNDksMTkgKzI3 MDQ5LDE5IEBACiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KLQkJCQlSZWxhdGl2ZVBh dGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5lcy5jcHAiDQorCQkJCVJlbGF0aXZlUGF0aD0iLi5c cmVuZGVyaW5nXEJpZGlSdW4uY3BwIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQot CQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXGJyZWFrX2xpbmVzLmgiDQorCQkJCVJlbGF0 aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlSdW4uaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCi0g ICAgICAgICAgICAgICAgICAgICAgICA8RmlsZQ0KLQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRl cmluZ1xCaWRpUnVuLmNwcCINCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRl cmluZ1xicmVha19saW5lcy5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0J CQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdcQmlkaVJ1bi5oIg0KKwkJCQlSZWxhdGl2ZVBh dGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5lcy5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJ CTxGaWxlDQpAQCAtMjcxMjAsNyArMjcxMjAsNyBAQAogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXElubGluZUZsb3dCb3guaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCi0gICAgICAgICAg ICAgICAgICAgICAgICA8RmlsZQ0KKwkJCTxGaWxlDQogCQkJCVJlbGF0aXZlUGF0aD0iLi5ccmVu ZGVyaW5nXElubGluZUl0ZXJhdG9yLmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpAQCAtMzQyNTYs NiArMzQyNTYsMjIgQEAKIAkJCQkJPg0KIAkJCQk8L0ZpbGU+DQogCQkJCTxGaWxlDQorCQkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlLmNwcCINCisJCQkJ CT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8RmlsZQ0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5k aW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZS5oIg0KKwkJCQkJPg0KKwkJCQk8L0ZpbGU+DQorCQkJ CTxGaWxlDQorCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9m aWxlTm9kZS5jcHAiDQorCQkJCQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJCQkJCVJl bGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmgiDQorCQkJ CQk+DQorCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmlu ZGluZ3NcanNcSlNBYnN0cmFjdFdvcmtlckN1c3RvbS5jcHAiDQogCQkJCQk+DQogCQkJCQk8Rmls ZUNvbmZpZ3VyYXRpb24NCkBAIC0zOTk0NCwyMiArMzk5NjAsNiBAQAogCQkJCQk8L0ZpbGVDb25m aWd1cmF0aW9uPg0KIAkJCQk8L0ZpbGU+DQogCQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9 Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlLmNwcCINCi0JCQkJCT4NCi0JCQkJPC9G aWxlPg0KLQkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZh U2NyaXB0UHJvZmlsZS5oIg0KLQkJCQkJPg0KLQkJCQk8L0ZpbGU+DQotCQkJCTxGaWxlDQotCQkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlTm9kZS5jcHAi DQotCQkJCQk+DQotCQkJCTwvRmlsZT4NCi0JCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0i Li5cYmluZGluZ3NcanNcSmF2YVNjcmlwdFByb2ZpbGVOb2RlLmgiDQotCQkJCQk+DQotCQkJCTwv RmlsZT4NCi0JCQkJPEZpbGUNCiAJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcU2No ZWR1bGVkQWN0aW9uLmNwcCINCiAJCQkJCT4NCiAJCQkJCTxGaWxlQ29uZmlndXJhdGlvbg0KQEAg LTQzMDU2LDExICs0MzA1NiwxMSBAQAogCQkJCQk+DQogCQkJCTwvRmlsZT4NCiAJCQkJPEZpbGUN Ci0JCQkJCVJlbGF0aXZlUGF0aD0iLi5caW5zcGVjdG9yXGZyb250LWVuZFxUZXh0Vmlld2VyLmpz Ig0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxpbnNwZWN0b3JcZnJvbnQtZW5kXHRleHRWaWV3ZXIu Y3NzIg0KIAkJCQkJPg0KIAkJCQk8L0ZpbGU+DQogCQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBh dGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRcdGV4dFZpZXdlci5jc3MiDQorCQkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRcVGV4dFZpZXdlci5qcyINCiAJCQkJCT4NCiAJ CQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KQEAgLTQzNDg5LDYgKzQzNDg5LDE0IEBACiAJCQkJPg0K IAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHdlYnNvY2tldHNc V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJ PEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlx3ZWJzb2NrZXRzXFdlYlNvY2tldEhhbmRzaGFr ZVJlcXVlc3QuaCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXHdlYnNvY2tldHNcV29ya2VyVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3Bw Ig0KIAkJCQk+DQogCQkJPC9GaWxlPg0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0 LnBieHByb2oKaW5kZXggZTM5YTBiMy4uYmQ4ZjcwOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTEyNjQsNiArMTI2NCw4IEBACiAJCTc1NzkzRUQzMEQw Q0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc1NzkzRUQwMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01N ZXNzYWdlRXZlbnQuaCAqLzsgfTsKIAkJNzU3OTNFRDQwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1l c3NhZ2VFdmVudC5tbSBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDc1NzkzRUQxMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnQubW0gKi87IH07 CiAJCTc1NzkzRUQ1MEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnRJbnRlcm5hbC5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzU3OTNFRDIw RDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudEludGVybmFsLmggKi87IH07CisJCTc2 MzdDNTQxMTEyRTdCNzQwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2MzdDNTQwMTEy RTdCNzQwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCAqLzsgfTsKKwkJ NzYzN0M1NDMxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2MzdDNTQyMTEy RTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggKi87IH07CiAJCTc2 OTNCQUQyMTA2QzJEQ0EwMDdCMDgyMyAvKiBIYWx0YWJsZVBsdWdpbi5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzY5M0JBQ0UxMDZDMkRDQTAwN0IwODIz IC8qIEhhbHRhYmxlUGx1Z2luLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKIAkJNzY5M0JBRDMxMDZDMkRDQTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjkzQkFD RjEwNkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmNwcCAqLzsgfTsKIAkJNzY5M0JBRDQx MDZDMkRDQTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzY5M0JBRDAxMDZDMkRDQTAwN0IwODIzIC8qIFBsdWdp bkhhbHRlci5oICovOyB9OwpAQCAtNjY5Nyw2ICs2Njk5LDggQEAKIAkJNzU3OTNFRDAwRDBDRTg1 QjAwN0ZDMEFDIC8qIERPTU1lc3NhZ2VFdmVudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gRE9NTWVzc2FnZUV2ZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTc1NzkzRUQxMEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnQubW0gKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gRE9NTWVzc2FnZUV2ZW50Lm1tOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NTc5M0VEMjBEMENFODVCMDA3RkMwQUMgLyogRE9N TWVzc2FnZUV2ZW50SW50ZXJuYWwuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IERPTU1lc3NhZ2VFdmVudEludGVybmFsLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CTc2MzdDNTQwMTEyRTdCNzQwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNw cCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdlYlNvY2tldEhhbmRzaGFr ZVJlcXVlc3QuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk3NjM3QzU0MjExMkU3 QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0Lmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNCQUNFMTA2QzJEQ0EwMDdCMDgyMyAvKiBIYWx0YWJs ZVBsdWdpbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBIYWx0YWJsZVBsdWdp bi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NjkzQkFDRjEwNkMyRENBMDA3QjA4 MjMgLyogUGx1Z2luSGFsdGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0 aCA9IFBsdWdpbkhhbHRlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2OTNC QUQwMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gUGx1Z2luSGFsdGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CkBAIC0xMTE3Nyw2ICsxMTE4MSw4IEBACiAJCTUxOEEzNEJEMTAyNkM4MzEwMDFCNjg5NiAvKiB3 ZWJzb2NrZXRzICovID0gewogCQkJaXNhID0gUEJYR3JvdXA7CiAJCQljaGlsZHJlbiA9ICgKKwkJ CQk3NjM3QzU0MjExMkU3QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5o ICovLAorCQkJCTc2MzdDNTQwMTEyRTdCNzQwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0LmNwcCAqLywKIAkJCQk1MTEyMjQ3MTEwQ0ZCOEM2MDA4MDk5RDcgLyogVGhyZWFkYWJs ZVdlYlNvY2tldENoYW5uZWwuY3BwICovLAogCQkJCTUxMTIyNDczMTBDRkI4RDgwMDgwOTlENyAv KiBUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5oICovLAogCQkJCTUxMTIyNDc1MTBDRkI4RTgw MDgwOTlENyAvKiBUaHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbENsaWVudFdyYXBwZXIuaCAqLywK QEAgLTE4NTk0LDYgKzE4NjAwLDcgQEAKIAkJCQk1OTYyMjk3QTExMzNFRkUyMDBEQzRDQkIgLyog R2VvbG9jYXRpb25Qb3NpdGlvbkNhY2hlLmggaW4gSGVhZGVycyAqLywKIAkJCQkwQkMyQzc3ODEx MzRBOEZDMDAwQjJGNjEgLyogQ2FudmFzU3VyZmFjZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQ0Ux NzJFMDExMTM2RThDRTAwNjJBNTMzIC8qIFpvb21Nb2RlLmggaW4gSGVhZGVycyAqLywKKwkJCQk3 NjM3QzU0MzExMkU3QjdFMDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIGlu IEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2lu ZyA9IDA7CiAJCX07CkBAIC0yMDc4Myw2ICsyMDc5MCw3IEBACiAJCQkJRTE2OTgyNjQxMTM0NjdG MzAwODk0MTE1IC8qIEphdmFSdW50aW1lT2JqZWN0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTU5 NjIyOTc4MTEzM0VGRDcwMERDNENCQiAvKiBHZW9sb2NhdGlvblBvc2l0aW9uQ2FjaGUuY3BwIGlu IFNvdXJjZXMgKi8sCiAJCQkJMEJDMkM3NzcxMTM0QThGQzAwMEIyRjYxIC8qIENhbnZhc1N1cmZh Y2UuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNzYzN0M1NDExMTJFN0I3NDAwM0Q2Q0RDIC8qIFdl YlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVu T25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9X ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAgYi9XZWJDb3JlL3dlYnNvY2tl dHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAKaW5kZXggN2I4N2JmMy4uOTZlOTgzOCAxMDA2NDQKLS0t IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwCisrKyBiL1dlYkNvcmUv d2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcApAQCAtNDQsNiArNDQsNyBAQAogI2luY2x1 ZGUgIlNvY2tldFN0cmVhbUhhbmRsZS5oIgogI2luY2x1ZGUgIlN0cmluZ0hhc2guaCIKICNpbmNs dWRlICJXZWJTb2NrZXRDaGFubmVsQ2xpZW50LmgiCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNo YWtlLmgiCiAKICNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KICNpbmNsdWRlIDx3dGYvRmFzdE1hbGxv Yy5oPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5j cHAgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcAppbmRleCA0NDcx MDk2Li4wMzdkYTc4IDEwMDY0NAotLS0gYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFu ZHNoYWtlLmNwcAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNw cApAQCAtMTMwLDExICsxMzAsNiBAQCBib29sIFdlYlNvY2tldEhhbmRzaGFrZTo6c2VjdXJlKCkg Y29uc3QKICAgICByZXR1cm4gbV9zZWN1cmU7CiB9CiAKLXZvaWQgV2ViU29ja2V0SGFuZHNoYWtl OjpzZXRTZWN1cmUoYm9vbCBzZWN1cmUpCi17Ci0gICAgbV9zZWN1cmUgPSBzZWN1cmU7Ci19Ci0K IFN0cmluZyBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudE9yaWdpbigpIGNvbnN0CiB7CiAgICAg cmV0dXJuIG1fY29udGV4dC0+c2VjdXJpdHlPcmlnaW4oKS0+dG9TdHJpbmcoKTsKQEAgLTE1OCw2 ICsxNTMsNyBAQCBTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRMb2NhdGlvbigpIGNv bnN0CiAKIENTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VNZXNzYWdl KCkgY29uc3QKIHsKKyAgICAvLyBLZWVwIHRoZSBmb2xsb3dpbmcgY29uc2lzdGVudCB3aXRoIGNs aWVudEhhbmRzaGFrZVJlcXVlc3QoKS4KICAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7CiAKICAg ICBidWlsZGVyLmFwcGVuZCgiR0VUICIpOwpAQCAtMTY3LDExICsxNjMsOSBAQCBDU3RyaW5nIFdl YlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0CiAgICAgYnVp bGRlci5hcHBlbmQoIkNvbm5lY3Rpb246IFVwZ3JhZGVcclxuIik7CiAgICAgYnVpbGRlci5hcHBl bmQoIkhvc3Q6ICIpOwogICAgIGJ1aWxkZXIuYXBwZW5kKG1fdXJsLmhvc3QoKS5sb3dlcigpKTsK LSAgICBpZiAobV91cmwucG9ydCgpKSB7Ci0gICAgICAgIGlmICgoIW1fc2VjdXJlICYmIG1fdXJs LnBvcnQoKSAhPSA4MCkgfHwgKG1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA0NDMpKSB7Ci0g ICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiIpOwotICAgICAgICAgICAgYnVpbGRlci5hcHBl bmQoU3RyaW5nOjpudW1iZXIobV91cmwucG9ydCgpKSk7Ci0gICAgICAgIH0KKyAgICBpZiAobV91 cmwucG9ydCgpICYmICgoIW1fc2VjdXJlICYmIG1fdXJsLnBvcnQoKSAhPSA4MCkgfHwgKG1fc2Vj dXJlICYmIG1fdXJsLnBvcnQoKSAhPSA0NDMpKSkgeworICAgICAgICBidWlsZGVyLmFwcGVuZCgi OiIpOworICAgICAgICBidWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkp KTsKICAgICB9CiAgICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKICAgICBidWlsZGVyLmFwcGVu ZCgiT3JpZ2luOiAiKTsKQEAgLTE4Miw5ICsxNzYsOCBAQCBDU3RyaW5nIFdlYlNvY2tldEhhbmRz aGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNvbnN0CiAgICAgICAgIGJ1aWxkZXIuYXBw ZW5kKG1fY2xpZW50UHJvdG9jb2wpOwogICAgICAgICBidWlsZGVyLmFwcGVuZCgiXHJcbiIpOwog ICAgIH0KKwogICAgIEtVUkwgdXJsID0gaHR0cFVSTEZvckF1dGhlbnRpY2F0aW9uQW5kQ29va2ll cygpOwotICAgIC8vIEZJWE1FOiBzZXQgYXV0aGVudGljYXRpb24gaW5mb3JtYXRpb24gb3IgY29v a2llcyBmb3IgdXJsLgotICAgIC8vIFNldCAiQXV0aG9yaXphdGlvbjogPGNyZWRlbnRpYWxzPiIg aWYgYXV0aGVudGljYXRpb24gaW5mb3JtYXRpb24gZXhpc3RzIGZvciB1cmwuCiAgICAgaWYgKG1f Y29udGV4dC0+aXNEb2N1bWVudCgpKSB7CiAgICAgICAgIERvY3VtZW50KiBkb2N1bWVudCA9IHN0 YXRpY19jYXN0PERvY3VtZW50Kj4obV9jb250ZXh0KTsKICAgICAgICAgU3RyaW5nIGNvb2tpZSA9 IGNvb2tpZVJlcXVlc3RIZWFkZXJGaWVsZFZhbHVlKGRvY3VtZW50LCB1cmwpOwpAQCAtMTk1LDEw ICsxODgsMjggQEAgQ1N0cmluZyBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1l c3NhZ2UoKSBjb25zdAogICAgICAgICB9CiAgICAgICAgIC8vIFNldCAiQ29va2llMjogPGNvb2tp ZT4iIGlmIGNvb2tpZXMgMiBleGlzdHMgZm9yIHVybD8KICAgICB9CisKICAgICBidWlsZGVyLmFw cGVuZCgiXHJcbiIpOwogICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCkudXRmOCgpOwogfQog CitXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0IFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFu ZHNoYWtlUmVxdWVzdCgpIGNvbnN0Cit7CisgICAgLy8gS2VlcCB0aGUgZm9sbG93aW5nIGNvbnNp c3RlbnQgd2l0aCBjbGllbnRIYW5kc2hha2VNZXNzYWdlKCkuCisgICAgV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdCByZXF1ZXN0KG1fdXJsLCBjbGllbnRPcmlnaW4oKSwgbV9jbGllbnRQcm90b2Nv bCk7CisKKyAgICBLVVJMIHVybCA9IGh0dHBVUkxGb3JBdXRoZW50aWNhdGlvbkFuZENvb2tpZXMo KTsKKyAgICBpZiAobV9jb250ZXh0LT5pc0RvY3VtZW50KCkpIHsKKyAgICAgICAgRG9jdW1lbnQq IGRvY3VtZW50ID0gc3RhdGljX2Nhc3Q8RG9jdW1lbnQqPihtX2NvbnRleHQpOworICAgICAgICBT dHJpbmcgY29va2llID0gY29va2llUmVxdWVzdEhlYWRlckZpZWxkVmFsdWUoZG9jdW1lbnQsIHVy bCk7CisgICAgICAgIGlmICghY29va2llLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIHJlcXVlc3Qu YWRkRXh0cmFIZWFkZXJGaWVsZCgiQ29va2llIiwgY29va2llKTsKKyAgICAgICAgLy8gU2V0ICJD b29raWUyOiA8Y29va2llPiIgaWYgY29va2llcyAyIGV4aXN0cyBmb3IgdXJsPworICAgIH0KKwor ICAgIHJldHVybiByZXF1ZXN0OworfQorCiB2b2lkIFdlYlNvY2tldEhhbmRzaGFrZTo6cmVzZXQo KQogewogICAgIG1fbW9kZSA9IEluY29tcGxldGU7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNv Y2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmggYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0 SGFuZHNoYWtlLmgKaW5kZXggYmRhMzIwYS4uYTIyMzk5YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS93 ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5oCisrKyBiL1dlYkNvcmUvd2Vic29ja2V0cy9X ZWJTb2NrZXRIYW5kc2hha2UuaApAQCAtMzUsNiArMzUsNyBAQAogCiAjaW5jbHVkZSAiS1VSTC5o IgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdC5oIgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CkBAIC01OCwxMiArNTksMTIgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgICAg ICB2b2lkIHNldENsaWVudFByb3RvY29sKGNvbnN0IFN0cmluZyYgcHJvdG9jb2wpOwogCiAgICAg ICAgIGJvb2wgc2VjdXJlKCkgY29uc3Q7Ci0gICAgICAgIHZvaWQgc2V0U2VjdXJlKGJvb2wgc2Vj dXJlKTsKIAogICAgICAgICBTdHJpbmcgY2xpZW50T3JpZ2luKCkgY29uc3Q7CiAgICAgICAgIFN0 cmluZyBjbGllbnRMb2NhdGlvbigpIGNvbnN0OwogCiAgICAgICAgIENTdHJpbmcgY2xpZW50SGFu ZHNoYWtlTWVzc2FnZSgpIGNvbnN0OworICAgICAgICBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0 IGNsaWVudEhhbmRzaGFrZVJlcXVlc3QoKSBjb25zdDsKIAogICAgICAgICB2b2lkIHJlc2V0KCk7 CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0LmNwcCBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNw cApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MGRmYzc0Ci0tLSAvZGV2L251 bGwKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuY3Bw CkBAIC0wLDAgKzEsOTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g 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 SCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdFQl9T T0NLRVRTKQorCisjaW5jbHVkZSAiV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oIgorCisjaW5j bHVkZSAiQXRvbWljU3RyaW5nLmgiCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2luY2x1 ZGUgPHV0aWxpdHk+CisjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKwordXNpbmcgbmFtZXNw YWNlIHN0ZDsKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KGNvbnN0IEtVUkwmIHVybCwgY29uc3QgU3Ry aW5nJiBvcmlnaW4sIGNvbnN0IFN0cmluZyYgd2ViU29ja2V0UHJvdG9jb2wpCisgICAgOiBtX3Vy bCh1cmwpCisgICAgLCBtX3NlY3VyZShtX3VybC5wcm90b2NvbElzKCJ3c3MiKSkKKyAgICAsIG1f b3JpZ2luKG9yaWdpbikKKyAgICAsIG1fd2ViU29ja2V0UHJvdG9jb2wod2ViU29ja2V0UHJvdG9j b2wpCit7CisgICAgQVNTRVJUKCFvcmlnaW4uaXNOdWxsKCkpOworfQorCitXZWJTb2NrZXRIYW5k c2hha2VSZXF1ZXN0Ojp+V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdCgpCit7Cit9CisKK3ZvaWQg V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6YWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBBdG9t aWNTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYgdmFsdWUpCit7CisgICAgbV9leHRyYUhlYWRl ckZpZWxkcy5hcHBlbmQobWFrZV9wYWlyKG5hbWUsIHZhbHVlKSk7Cit9CisKK3ZvaWQgV2ViU29j a2V0SGFuZHNoYWtlUmVxdWVzdDo6YWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1l LCBjb25zdCBTdHJpbmcmIHZhbHVlKQoreworICAgIG1fZXh0cmFIZWFkZXJGaWVsZHMuYXBwZW5k KG1ha2VfcGFpcihuYW1lLCB2YWx1ZSkpOworfQorCitWZWN0b3I8cGFpcjxBdG9taWNTdHJpbmcs IFN0cmluZz4gPiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0OjpoZWFkZXJGaWVsZHMoKSBjb25z dAoreworICAgIFZlY3RvcjxwYWlyPEF0b21pY1N0cmluZywgU3RyaW5nPiA+IGZpZWxkczsKKyAg ICBmaWVsZHMuYXBwZW5kKG1ha2VfcGFpcigiVXBncmFkZSIsICJXZWJTb2NrZXQiKSk7CisgICAg ZmllbGRzLmFwcGVuZChtYWtlX3BhaXIoIkNvbm5lY3Rpb24iLCAiVXBncmFkZSIpKTsKKyAgICBm aWVsZHMuYXBwZW5kKG1ha2VfcGFpcigiSG9zdCIsIGhvc3QoKSkpOworICAgIGZpZWxkcy5hcHBl bmQobWFrZV9wYWlyKCJPcmlnaW4iLCBtX29yaWdpbikpOworICAgIGlmICghbV93ZWJTb2NrZXRQ cm90b2NvbC5pc0VtcHR5KCkpCisgICAgICAgIGZpZWxkcy5hcHBlbmQobWFrZV9wYWlyKCJXZWJT b2NrZXQtUHJvdG9jb2wiLCBtX3dlYlNvY2tldFByb3RvY29sKSk7CisgICAgZmllbGRzLmFwcGVu ZChtX2V4dHJhSGVhZGVyRmllbGRzKTsKKyAgICByZXR1cm4gZmllbGRzOworfQorCitTdHJpbmcg V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6aG9zdCgpIGNvbnN0Cit7CisgICAgU3RyaW5nQnVp bGRlciBidWlsZGVyOworICAgIGJ1aWxkZXIuYXBwZW5kKG1fdXJsLmhvc3QoKS5sb3dlcigpKTsK KyAgICBpZiAoKCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAm JiBtX3VybC5wb3J0KCkgIT0gNDQzKSkgeworICAgICAgICBidWlsZGVyLmFwcGVuZCgiOiIpOwor ICAgICAgICBidWlsZGVyLmFwcGVuZChTdHJpbmc6Om51bWJlcihtX3VybC5wb3J0KCkpKTsKKyAg ICB9CisgICAgcmV0dXJuIGJ1aWxkZXIudG9TdHJpbmcoKTsKK30KKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFdFQl9TT0NLRVRTKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCBiL1dlYkNvcmUvd2Vi c29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uZjZkZWFmMQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKQEAgLTAsMCArMSw3MiBAQAorLyoKKyAq IENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlz dHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3Ig dGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ug b3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91 dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor ICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9S IENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVU RSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBP UiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcg SU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBB RFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVm IFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3RfaAorI2RlZmluZSBXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0X2gKKworI2lmIEVOQUJMRShXRUJfU09DS0VUUykKKworI2luY2x1ZGUgIktVUkwuaCIK KyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBBdG9taWNTdHJpbmc7CisKK2NsYXNzIFdlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3QgeworcHVibGljOgorICAgIFdlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QoY29uc3QgS1VSTCYsIGNvbnN0IFN0cmluZyYgb3JpZ2luLCBjb25zdCBTdHJpbmcmIHdl YlNvY2tldFByb3RvY29sKTsKKyAgICB+V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdCgpOworCisg ICAgLy8gQWNjb3JkaW5nIHRvIGN1cnJlbnQgV2ViIFNvY2tldCBwcm90b2NvbCBzcGVjaWZpY2F0 aW9uLCBmb3VyIG1hbmRhdG9yeSBoZWFkZXJzIChVcGdyYWRlLCBDb25uZWN0aW9uLCBIb3N0LCBh bmQgT3JpZ2luKSBhbmQKKyAgICAvLyBvbmUgb3B0aW9uYWwgaGVhZGVyIChXZWJTb2NrZXQtUHJv dG9jb2wpIHNob3VsZCBiZSBzZW50IGluIHRoaXMgb3JkZXIsIGF0IHRoZSBiZWdpbm5pbmcgb2Yg dGhlIGhhbmRzaGFrZSByZXF1ZXN0LgorICAgIC8vIFRoZSByZW1haW5pbmcgaGVhZGVycyBjYW4g YmUgc2V0IGJ5IHVzaW5nIHRoZSBmb2xsb3dpbmcgZnVuY3Rpb24uCisgICAgdm9pZCBhZGRFeHRy YUhlYWRlckZpZWxkKGNvbnN0IEF0b21pY1N0cmluZyYgbmFtZSwgY29uc3QgU3RyaW5nJiB2YWx1 ZSk7CisgICAgdm9pZCBhZGRFeHRyYUhlYWRlckZpZWxkKGNvbnN0IGNoYXIqIG5hbWUsIGNvbnN0 IFN0cmluZyYgdmFsdWUpOworCisgICAgLy8gUmV0dXJucyB0aGUgbGlzdCBvZiBoZWFkZXIgZmll bGRzIGluY2x1ZGluZyBmaXZlIHNwZWNpYWwgb25lcy4KKyAgICBWZWN0b3I8c3RkOjpwYWlyPEF0 b21pY1N0cmluZywgU3RyaW5nPiA+IGhlYWRlckZpZWxkcygpIGNvbnN0OworCitwcml2YXRlOgor ICAgIFN0cmluZyBob3N0KCkgY29uc3Q7CisKKyAgICBLVVJMIG1fdXJsOworICAgIGJvb2wgbV9z ZWN1cmU7CisgICAgU3RyaW5nIG1fb3JpZ2luOworICAgIFN0cmluZyBtX3dlYlNvY2tldFByb3Rv Y29sOworICAgIFZlY3RvcjxzdGQ6OnBhaXI8QXRvbWljU3RyaW5nLCBTdHJpbmc+ID4gbV9leHRy YUhlYWRlckZpZWxkczsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IEVOQUJMRShXRUJfU09DS0VUUykKKworI2VuZGlmIC8vIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVl c3RfaAo= 49879 2010-03-02 22:31:44 -0800 2010-03-03 22:28:34 -0800 Patch v9 (Add typedef) bug-34784-20100303153142.patch text/plain 22939 yutak ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg MDUyOGQ4Ny4uZGNhOTQyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAxMC0wMy0wMiAgWXV0YSBLaXRhbXVy YSAgPHl1dGFrQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgY2xhc3MgdGhhdCBzdG9yZXMgaW5mb3JtYXRpb24g YWJvdXQgV2ViIFNvY2tldCBoYW5kc2hha2UgcmVxdWVzdC4KKworICAgICAgICBJbnN0YW5jZXMg b2YgdGhpcyBjbGFzcyBjb250YWluIHRoZSBuZWNlc3NhcnkgaW5mb3JtYXRpb24gdG8gc2VuZCBh IFdlYiBTb2NrZXQKKyAgICAgICAgaGFuZHNoYWtlIHJlcXVlc3QuIEluIHRoZSBmdXR1cmUsIHRo aXMgY2xhc3Mgd2lsbCBwcm92aWRlIHJlcXVlc3QgaW5mb3JtYXRpb24KKyAgICAgICAgdG8gdGhl IFdlYiBJbnNwZWN0b3IuCisKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlIG5lZWRzIHRvIHBy b3ZpZGUgcmVxdWVzdCBpbmZvcm1hdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MzQ3ODQKKworICAgICAgICBObyBuZXcgdGVzdHMsIHNpbmNlIHRo ZSBjdXJyZW50IHRlc3RzIHdpbGwgc3VmZmljZSAoTGF5b3V0VGVzdHMvd2Vic29ja2V0LyopLgor CisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAg ICAgICAqIFdlYkNvcmUucHJvOgorICAgICAgICAqIFdlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNw cm9qOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAg ICAgKiB3ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwOgorICAgICAgICAqIHdlYnNvY2tl dHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhh bmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSk6CisgICAgICAgIChXZWJDb3JlOjpXZWJT b2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZVJlcXVlc3QpOgorICAgICAgICAqIHdlYnNv Y2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmg6CisgICAgICAgICogd2Vic29ja2V0cy9XZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpXZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0OjpXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0KToKKyAgICAgICAg KFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6On5XZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0KToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFk ZEV4dHJhSGVhZGVyRmllbGQpOgorICAgICAgICAoV2ViQ29yZTo6V2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6aGVhZGVyRmllbGRzKToKKyAgICAgICAgKFdlYkNvcmU6OldlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3Q6Omhvc3QpOgorICAgICAgICAqIHdlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdC5oOiBBZGRlZC4KKwogMjAxMC0wMy0wMiAgQnJhZHkgRWlkc29uICA8YmVpZHNv bkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdp dCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4 IDgzMDg5MTcuLjBmMzE5YjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysr IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMzQ2OSw3ICszNDY5LDkgQEAgd2ViY29yZV9z b3VyY2VzICs9IFwKIAlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbC5oIFwKIAlX ZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIFwKIAlXZWJDb3JlL3dl YnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlLmNwcCBcCi0JV2ViQ29yZS93ZWJzb2NrZXRzL1dl YlNvY2tldEhhbmRzaGFrZS5oCisJV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFr ZS5oIFwKKwlXZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAg XAorCVdlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmgKIAogaWYg RU5BQkxFX1dPUktFUlMKIHdlYmNvcmVfc291cmNlcyArPSBcCmRpZmYgLS1naXQgYS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaSBiL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IGM0YzkyMTAuLjVhOWE1 MmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1dlYkNvcmUvV2ViQ29y ZS5neXBpCkBAIC0zNjIxLDYgKzM2MjEsOCBAQAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2Vi U29ja2V0Q2hhbm5lbENsaWVudC5oJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dlYlNvY2tl dEhhbmRzaGFrZS5jcHAnLAogICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNo YWtlLmgnLAorICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dC5jcHAnLAorICAgICAgICAgICAgJ3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dC5oJywKICAgICAgICAgICAgICd3ZWJzb2NrZXRzL1dvcmtlclRocmVhZGFibGVXZWJTb2NrZXRD aGFubmVsLmNwcCcsCiAgICAgICAgICAgICAnd2Vic29ja2V0cy9Xb3JrZXJUaHJlYWRhYmxlV2Vi U29ja2V0Q2hhbm5lbC5oJywKICAgICAgICAgICAgICd3b3JrZXJzL0Fic3RyYWN0V29ya2VyLmNw cCcsCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvV2ViQ29yZS9XZWJDb3JlLnBy bwppbmRleCBkNjQwNmUzLi40MDAwMGYxIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUucHJv CisrKyBiL1dlYkNvcmUvV2ViQ29yZS5wcm8KQEAgLTI2NzEsMjQgKzI2NzEsMzUgQEAgU09VUkNF UyArPSBcCiB9CiAKIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9XRUJfU09DS0VUUz0xKSB7Ci1I RUFERVJTICs9IFwKLSAgICBwbGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVBy aXZhdGUuaCBcCisgICAgSEVBREVSUyArPSBcCisgICAgICAgIHdlYnNvY2tldHMvVGhyZWFkYWJs ZVdlYlNvY2tldENoYW5uZWwuaCBcCisgICAgICAgIHdlYnNvY2tldHMvVGhyZWFkYWJsZVdlYlNv Y2tldENoYW5uZWxDbGllbnRXcmFwcGVyLmggXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tl dC5oIFwKKyAgICAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmggXAorICAgICAgICB3 ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWxDbGllbnQuaCBcCisgICAgICAgIHdlYnNvY2tldHMv V2ViU29ja2V0SGFuZHNoYWtlLmggXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZVJlcXVlc3QuaCBcCisgICAgICAgIHBsYXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFt SGFuZGxlUHJpdmF0ZS5oCiAKLVNPVVJDRVMgKz0gXAotICAgIHdlYnNvY2tldHMvV2ViU29ja2V0 LmNwcCBcCi0gICAgd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcCBcCi0gICAgd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIFwKLSAgICB3ZWJzb2NrZXRzL1RocmVhZGFibGVX ZWJTb2NrZXRDaGFubmVsLmNwcCBcCi0gICAgcGxhdGZvcm0vbmV0d29yay9Tb2NrZXRTdHJlYW1F cnJvckJhc2UuY3BwIFwKLSAgICBwbGF0Zm9ybS9uZXR3b3JrL1NvY2tldFN0cmVhbUhhbmRsZUJh c2UuY3BwIFwKLSAgICBwbGF0Zm9ybS9uZXR3b3JrL3F0L1NvY2tldFN0cmVhbUhhbmRsZVF0LmNw cCBcCi0gICAgYmluZGluZ3MvanMvSlNXZWJTb2NrZXRDdXN0b20uY3BwIFwKLSAgICBiaW5kaW5n cy9qcy9KU1dlYlNvY2tldENvbnN0cnVjdG9yLmNwcAorICAgIFNPVVJDRVMgKz0gXAorICAgICAg ICB3ZWJzb2NrZXRzL1dlYlNvY2tldC5jcHAgXAorICAgICAgICB3ZWJzb2NrZXRzL1dlYlNvY2tl dENoYW5uZWwuY3BwIFwKKyAgICAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3Bw IFwKKyAgICAgICAgd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBcCisg ICAgICAgIHdlYnNvY2tldHMvVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuY3BwIFwKKyAgICAg ICAgcGxhdGZvcm0vbmV0d29yay9Tb2NrZXRTdHJlYW1FcnJvckJhc2UuY3BwIFwKKyAgICAgICAg cGxhdGZvcm0vbmV0d29yay9Tb2NrZXRTdHJlYW1IYW5kbGVCYXNlLmNwcCBcCisgICAgICAgIHBs YXRmb3JtL25ldHdvcmsvcXQvU29ja2V0U3RyZWFtSGFuZGxlUXQuY3BwIFwKKyAgICAgICAgYmlu ZGluZ3MvanMvSlNXZWJTb2NrZXRDdXN0b20uY3BwIFwKKyAgICAgICAgYmluZGluZ3MvanMvSlNX ZWJTb2NrZXRDb25zdHJ1Y3Rvci5jcHAKKworICAgIGNvbnRhaW5zKERFRklORVMsIEVOQUJMRV9X T1JLRVJTPTEpIHsKKyAgICAgICAgSEVBREVSUyArPSBcCisgICAgICAgICAgICB3ZWJzb2NrZXRz L1dvcmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmgKIAotY29udGFpbnMoREVGSU5FUywg RU5BQkxFX1dPUktFUlM9MSkgewotU09VUkNFUyArPSBcCi0gICAgd2Vic29ja2V0cy9Xb3JrZXJU aHJlYWRhYmxlV2ViU29ja2V0Q2hhbm5lbC5jcHAKLX0KKyAgICAgICAgU09VUkNFUyArPSBcCisg ICAgICAgICAgICB3ZWJzb2NrZXRzL1dvcmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmNw cAorICAgIH0KIH0KIAogY29udGFpbnMoREVGSU5FUywgRU5BQkxFXzNEX0NBTlZBUz0xKSB7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qIGIvV2ViQ29y ZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagppbmRleCAwOWFiYTYxLi4yYWQ4MDkwIDEw MDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCisrKyBiL1dl YkNvcmUvV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKQEAgLTI3MDQ5LDE5ICsyNzA0OSwx OSBAQAogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCi0JCQkJUmVsYXRpdmVQYXRoPSIu LlxyZW5kZXJpbmdcYnJlYWtfbGluZXMuY3BwIg0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRl cmluZ1xCaWRpUnVuLmNwcCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8RmlsZQ0KLQkJCQlS ZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmluZ1xicmVha19saW5lcy5oIg0KKwkJCQlSZWxhdGl2ZVBh dGg9Ii4uXHJlbmRlcmluZ1xCaWRpUnVuLmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQotICAgICAg ICAgICAgICAgICAgICAgICAgPEZpbGUNCi0JCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdc QmlkaVJ1bi5jcHAiDQorCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlxyZW5kZXJpbmdc YnJlYWtfbGluZXMuY3BwIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KIAkJCTxGaWxlDQotCQkJCVJl bGF0aXZlUGF0aD0iLi5ccmVuZGVyaW5nXEJpZGlSdW4uaCINCisJCQkJUmVsYXRpdmVQYXRoPSIu LlxyZW5kZXJpbmdcYnJlYWtfbGluZXMuaCINCiAJCQkJPg0KIAkJCTwvRmlsZT4NCiAJCQk8Rmls ZQ0KQEAgLTI3MTIwLDcgKzI3MTIwLDcgQEAKIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmlu Z1xJbmxpbmVGbG93Qm94LmgiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQotICAgICAgICAgICAgICAg ICAgICAgICAgPEZpbGUNCisJCQk8RmlsZQ0KIAkJCQlSZWxhdGl2ZVBhdGg9Ii4uXHJlbmRlcmlu Z1xJbmxpbmVJdGVyYXRvci5oIg0KIAkJCQk+DQogCQkJPC9GaWxlPg0KQEAgLTM0MjU2LDYgKzM0 MjU2LDIyIEBACiAJCQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KKwkJCQkJUmVsYXRp dmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZS5jcHAiDQorCQkJCQk+DQor CQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3Nc anNcSmF2YVNjcmlwdFByb2ZpbGUuaCINCisJCQkJCT4NCisJCQkJPC9GaWxlPg0KKwkJCQk8Rmls ZQ0KKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5v ZGUuY3BwIg0KKwkJCQkJPg0KKwkJCQk8L0ZpbGU+DQorCQkJCTxGaWxlDQorCQkJCQlSZWxhdGl2 ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlTm9kZS5oIg0KKwkJCQkJPg0K KwkJCQk8L0ZpbGU+DQorCQkJCTxGaWxlDQogCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdz XGpzXEpTQWJzdHJhY3RXb3JrZXJDdXN0b20uY3BwIg0KIAkJCQkJPg0KIAkJCQkJPEZpbGVDb25m aWd1cmF0aW9uDQpAQCAtMzk5NDQsMjIgKzM5OTYwLDYgQEAKIAkJCQkJPC9GaWxlQ29uZmlndXJh dGlvbj4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxi aW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZS5jcHAiDQotCQkJCQk+DQotCQkJCTwvRmlsZT4N Ci0JCQkJPEZpbGUNCi0JCQkJCVJlbGF0aXZlUGF0aD0iLi5cYmluZGluZ3NcanNcSmF2YVNjcmlw dFByb2ZpbGUuaCINCi0JCQkJCT4NCi0JCQkJPC9GaWxlPg0KLQkJCQk8RmlsZQ0KLQkJCQkJUmVs YXRpdmVQYXRoPSIuLlxiaW5kaW5nc1xqc1xKYXZhU2NyaXB0UHJvZmlsZU5vZGUuY3BwIg0KLQkJ CQkJPg0KLQkJCQk8L0ZpbGU+DQotCQkJCTxGaWxlDQotCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJp bmRpbmdzXGpzXEphdmFTY3JpcHRQcm9maWxlTm9kZS5oIg0KLQkJCQkJPg0KLQkJCQk8L0ZpbGU+ DQotCQkJCTxGaWxlDQogCQkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGJpbmRpbmdzXGpzXFNjaGVkdWxl ZEFjdGlvbi5jcHAiDQogCQkJCQk+DQogCQkJCQk8RmlsZUNvbmZpZ3VyYXRpb24NCkBAIC00MzA1 NiwxMSArNDMwNTYsMTEgQEAKIAkJCQkJPg0KIAkJCQk8L0ZpbGU+DQogCQkJCTxGaWxlDQotCQkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXGluc3BlY3Rvclxmcm9udC1lbmRcVGV4dFZpZXdlci5qcyINCisJ CQkJCVJlbGF0aXZlUGF0aD0iLi5caW5zcGVjdG9yXGZyb250LWVuZFx0ZXh0Vmlld2VyLmNzcyIN CiAJCQkJCT4NCiAJCQkJPC9GaWxlPg0KIAkJCQk8RmlsZQ0KLQkJCQkJUmVsYXRpdmVQYXRoPSIu LlxpbnNwZWN0b3JcZnJvbnQtZW5kXHRleHRWaWV3ZXIuY3NzIg0KKwkJCQkJUmVsYXRpdmVQYXRo PSIuLlxpbnNwZWN0b3JcZnJvbnQtZW5kXFRleHRWaWV3ZXIuanMiDQogCQkJCQk+DQogCQkJCTwv RmlsZT4NCiAJCQkJPEZpbGUNCkBAIC00MzQ4OSw2ICs0MzQ4OSwxNCBAQAogCQkJCT4NCiAJCQk8 L0ZpbGU+DQogCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRoPSIuLlx3ZWJzb2NrZXRzXFdlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3QuY3BwIg0KKwkJCQk+DQorCQkJPC9GaWxlPg0KKwkJCTxGaWxl DQorCQkJCVJlbGF0aXZlUGF0aD0iLi5cd2Vic29ja2V0c1xXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0LmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQYXRo PSIuLlx3ZWJzb2NrZXRzXFdvcmtlclRocmVhZGFibGVXZWJTb2NrZXRDaGFubmVsLmNwcCINCiAJ CQkJPg0KIAkJCTwvRmlsZT4NCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvaiBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhw cm9qCmluZGV4IGUzOWEwYjMuLmJkOGY3MDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCkBAIC0xMjY0LDYgKzEyNjQsOCBAQAogCQk3NTc5M0VEMzBEMENFODVC MDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA3NTc5M0VEMDBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2Fn ZUV2ZW50LmggKi87IH07CiAJCTc1NzkzRUQ0MEQwQ0U4NUIwMDdGQzBBQyAvKiBET01NZXNzYWdl RXZlbnQubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 NTc5M0VEMTBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50Lm1tICovOyB9OwogCQk3 NTc5M0VENTBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50SW50ZXJuYWwuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc1NzkzRUQyMEQwQ0U4 NUIwMDdGQzBBQyAvKiBET01NZXNzYWdlRXZlbnRJbnRlcm5hbC5oICovOyB9OworCQk3NjM3QzU0 MTExMkU3Qjc0MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAgaW4gU291 cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjM3QzU0MDExMkU3Qjc0 MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAgKi87IH07CisJCTc2MzdD NTQzMTEyRTdCN0UwMDNENkNEQyAvKiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NjM3QzU0MjExMkU3QjdF MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oICovOyB9OwogCQk3NjkzQkFE MjEwNkMyRENBMDA3QjA4MjMgLyogSGFsdGFibGVQbHVnaW4uaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2OTNCQUNFMTA2QzJEQ0EwMDdCMDgyMyAvKiBI YWx0YWJsZVBsdWdpbi5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7 IH07IH07CiAJCTc2OTNCQUQzMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzY5M0JBQ0YxMDZD MkRDQTAwN0IwODIzIC8qIFBsdWdpbkhhbHRlci5jcHAgKi87IH07CiAJCTc2OTNCQUQ0MTA2QzJE Q0EwMDdCMDgyMyAvKiBQbHVnaW5IYWx0ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDc2OTNCQUQwMTA2QzJEQ0EwMDdCMDgyMyAvKiBQbHVnaW5IYWx0 ZXIuaCAqLzsgfTsKQEAgLTY2OTcsNiArNjY5OSw4IEBACiAJCTc1NzkzRUQwMEQwQ0U4NUIwMDdG QzBBQyAvKiBET01NZXNzYWdlRXZlbnQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IERPTU1lc3NhZ2VFdmVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NTc5 M0VEMTBEMENFODVCMDA3RkMwQUMgLyogRE9NTWVzc2FnZUV2ZW50Lm1tICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLm9iamNwcDsgcGF0aCA9IERPTU1lc3NhZ2VFdmVudC5tbTsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzU3OTNFRDIwRDBDRTg1QjAwN0ZDMEFDIC8qIERPTU1lc3Nh Z2VFdmVudEludGVybmFsLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBET01N ZXNzYWdlRXZlbnRJbnRlcm5hbC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk3NjM3 QzU0MDExMkU3Qjc0MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXZWJTb2NrZXRIYW5kc2hha2VSZXF1 ZXN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzYzN0M1NDIxMTJFN0I3RTAw M0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQk3NjkzQkFDRTEwNkMyRENBMDA3QjA4MjMgLyogSGFsdGFibGVQbHVn aW4uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSGFsdGFibGVQbHVnaW4uaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzY5M0JBQ0YxMDZDMkRDQTAwN0IwODIzIC8q IFBsdWdpbkhhbHRlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQ bHVnaW5IYWx0ZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NjkzQkFEMDEw NkMyRENBMDA3QjA4MjMgLyogUGx1Z2luSGFsdGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMu aDsgcGF0aCA9IFBsdWdpbkhhbHRlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt MTExNzcsNiArMTExODEsOCBAQAogCQk1MThBMzRCRDEwMjZDODMxMDAxQjY4OTYgLyogd2Vic29j a2V0cyAqLyA9IHsKIAkJCWlzYSA9IFBCWEdyb3VwOwogCQkJY2hpbGRyZW4gPSAoCisJCQkJNzYz N0M1NDIxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCAqLywK KwkJCQk3NjM3QzU0MDExMkU3Qjc0MDAzRDZDREMgLyogV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVz dC5jcHAgKi8sCiAJCQkJNTExMjI0NzExMENGQjhDNjAwODA5OUQ3IC8qIFRocmVhZGFibGVXZWJT b2NrZXRDaGFubmVsLmNwcCAqLywKIAkJCQk1MTEyMjQ3MzEwQ0ZCOEQ4MDA4MDk5RDcgLyogVGhy ZWFkYWJsZVdlYlNvY2tldENoYW5uZWwuaCAqLywKIAkJCQk1MTEyMjQ3NTEwQ0ZCOEU4MDA4MDk5 RDcgLyogVGhyZWFkYWJsZVdlYlNvY2tldENoYW5uZWxDbGllbnRXcmFwcGVyLmggKi8sCkBAIC0x ODU5NCw2ICsxODYwMCw3IEBACiAJCQkJNTk2MjI5N0ExMTMzRUZFMjAwREM0Q0JCIC8qIEdlb2xv Y2F0aW9uUG9zaXRpb25DYWNoZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEJDMkM3NzgxMTM0QThG QzAwMEIyRjYxIC8qIENhbnZhc1N1cmZhY2UuaCBpbiBIZWFkZXJzICovLAogCQkJCUNFMTcyRTAx MTEzNkU4Q0UwMDYyQTUzMyAvKiBab29tTW9kZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJNzYzN0M1 NDMxMTJFN0I3RTAwM0Q2Q0RDIC8qIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCBpbiBIZWFk ZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAw OwogCQl9OwpAQCAtMjA3ODMsNiArMjA3OTAsNyBAQAogCQkJCUUxNjk4MjY0MTEzNDY3RjMwMDg5 NDExNSAvKiBKYXZhUnVudGltZU9iamVjdC5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk1OTYyMjk3 ODExMzNFRkQ3MDBEQzRDQkIgLyogR2VvbG9jYXRpb25Qb3NpdGlvbkNhY2hlLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCTBCQzJDNzc3MTEzNEE4RkMwMDBCMkY2MSAvKiBDYW52YXNTdXJmYWNlLmNw cCBpbiBTb3VyY2VzICovLAorCQkJCTc2MzdDNTQxMTEyRTdCNzQwMDNENkNEQyAvKiBXZWJTb2Nr ZXRIYW5kc2hha2VSZXF1ZXN0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS93ZWJzb2NrZXRzL1dlYlNvY2tldENoYW5uZWwuY3BwIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dl YlNvY2tldENoYW5uZWwuY3BwCmluZGV4IDdiODdiZjMuLjk2ZTk4MzggMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRDaGFubmVsLmNwcAorKysgYi9XZWJDb3JlL3dlYnNv Y2tldHMvV2ViU29ja2V0Q2hhbm5lbC5jcHAKQEAgLTQ0LDYgKzQ0LDcgQEAKICNpbmNsdWRlICJT b2NrZXRTdHJlYW1IYW5kbGUuaCIKICNpbmNsdWRlICJTdHJpbmdIYXNoLmgiCiAjaW5jbHVkZSAi V2ViU29ja2V0Q2hhbm5lbENsaWVudC5oIgorI2luY2x1ZGUgIldlYlNvY2tldEhhbmRzaGFrZS5o IgogCiAjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuY3BwIGIv V2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAKaW5kZXggNDQ3MTA5Ni4u MDM3ZGE3OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFr ZS5jcHAKKysrIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRzaGFrZS5jcHAKQEAg LTEzMCwxMSArMTMwLDYgQEAgYm9vbCBXZWJTb2NrZXRIYW5kc2hha2U6OnNlY3VyZSgpIGNvbnN0 CiAgICAgcmV0dXJuIG1fc2VjdXJlOwogfQogCi12b2lkIFdlYlNvY2tldEhhbmRzaGFrZTo6c2V0 U2VjdXJlKGJvb2wgc2VjdXJlKQotewotICAgIG1fc2VjdXJlID0gc2VjdXJlOwotfQotCiBTdHJp bmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRPcmlnaW4oKSBjb25zdAogewogICAgIHJldHVy biBtX2NvbnRleHQtPnNlY3VyaXR5T3JpZ2luKCktPnRvU3RyaW5nKCk7CkBAIC0xNTgsNiArMTUz LDcgQEAgU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50TG9jYXRpb24oKSBjb25zdAog CiBDU3RyaW5nIFdlYlNvY2tldEhhbmRzaGFrZTo6Y2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpIGNv bnN0CiB7CisgICAgLy8gS2VlcCB0aGUgZm9sbG93aW5nIGNvbnNpc3RlbnQgd2l0aCBjbGllbnRI YW5kc2hha2VSZXF1ZXN0KCkuCiAgICAgU3RyaW5nQnVpbGRlciBidWlsZGVyOwogCiAgICAgYnVp bGRlci5hcHBlbmQoIkdFVCAiKTsKQEAgLTE2NywxMSArMTYzLDkgQEAgQ1N0cmluZyBXZWJTb2Nr ZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAogICAgIGJ1aWxkZXIu YXBwZW5kKCJDb25uZWN0aW9uOiBVcGdyYWRlXHJcbiIpOwogICAgIGJ1aWxkZXIuYXBwZW5kKCJI b3N0OiAiKTsKICAgICBidWlsZGVyLmFwcGVuZChtX3VybC5ob3N0KCkubG93ZXIoKSk7Ci0gICAg aWYgKG1fdXJsLnBvcnQoKSkgewotICAgICAgICBpZiAoKCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0 KCkgIT0gODApIHx8IChtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gNDQzKSkgewotICAgICAg ICAgICAgYnVpbGRlci5hcHBlbmQoIjoiKTsKLSAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKFN0 cmluZzo6bnVtYmVyKG1fdXJsLnBvcnQoKSkpOwotICAgICAgICB9CisgICAgaWYgKG1fdXJsLnBv cnQoKSAmJiAoKCFtX3NlY3VyZSAmJiBtX3VybC5wb3J0KCkgIT0gODApIHx8IChtX3NlY3VyZSAm JiBtX3VybC5wb3J0KCkgIT0gNDQzKSkpIHsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoIjoiKTsK KyAgICAgICAgYnVpbGRlci5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV91cmwucG9ydCgpKSk7CiAg ICAgfQogICAgIGJ1aWxkZXIuYXBwZW5kKCJcclxuIik7CiAgICAgYnVpbGRlci5hcHBlbmQoIk9y aWdpbjogIik7CkBAIC0xODIsOSArMTc2LDggQEAgQ1N0cmluZyBXZWJTb2NrZXRIYW5kc2hha2U6 OmNsaWVudEhhbmRzaGFrZU1lc3NhZ2UoKSBjb25zdAogICAgICAgICBidWlsZGVyLmFwcGVuZCht X2NsaWVudFByb3RvY29sKTsKICAgICAgICAgYnVpbGRlci5hcHBlbmQoIlxyXG4iKTsKICAgICB9 CisKICAgICBLVVJMIHVybCA9IGh0dHBVUkxGb3JBdXRoZW50aWNhdGlvbkFuZENvb2tpZXMoKTsK LSAgICAvLyBGSVhNRTogc2V0IGF1dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIG9yIGNvb2tpZXMg Zm9yIHVybC4KLSAgICAvLyBTZXQgIkF1dGhvcml6YXRpb246IDxjcmVkZW50aWFscz4iIGlmIGF1 dGhlbnRpY2F0aW9uIGluZm9ybWF0aW9uIGV4aXN0cyBmb3IgdXJsLgogICAgIGlmIChtX2NvbnRl eHQtPmlzRG9jdW1lbnQoKSkgewogICAgICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBzdGF0aWNf Y2FzdDxEb2N1bWVudCo+KG1fY29udGV4dCk7CiAgICAgICAgIFN0cmluZyBjb29raWUgPSBjb29r aWVSZXF1ZXN0SGVhZGVyRmllbGRWYWx1ZShkb2N1bWVudCwgdXJsKTsKQEAgLTE5NSwxMCArMTg4 LDI4IEBAIENTdHJpbmcgV2ViU29ja2V0SGFuZHNoYWtlOjpjbGllbnRIYW5kc2hha2VNZXNzYWdl KCkgY29uc3QKICAgICAgICAgfQogICAgICAgICAvLyBTZXQgIkNvb2tpZTI6IDxjb29raWU+IiBp ZiBjb29raWVzIDIgZXhpc3RzIGZvciB1cmw/CiAgICAgfQorCiAgICAgYnVpbGRlci5hcHBlbmQo IlxyXG4iKTsKICAgICByZXR1cm4gYnVpbGRlci50b1N0cmluZygpLnV0ZjgoKTsKIH0KIAorV2Vi U29ja2V0SGFuZHNoYWtlUmVxdWVzdCBXZWJTb2NrZXRIYW5kc2hha2U6OmNsaWVudEhhbmRzaGFr ZVJlcXVlc3QoKSBjb25zdAoreworICAgIC8vIEtlZXAgdGhlIGZvbGxvd2luZyBjb25zaXN0ZW50 IHdpdGggY2xpZW50SGFuZHNoYWtlTWVzc2FnZSgpLgorICAgIFdlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QgcmVxdWVzdChtX3VybCwgY2xpZW50T3JpZ2luKCksIG1fY2xpZW50UHJvdG9jb2wpOwor CisgICAgS1VSTCB1cmwgPSBodHRwVVJMRm9yQXV0aGVudGljYXRpb25BbmRDb29raWVzKCk7Cisg ICAgaWYgKG1fY29udGV4dC0+aXNEb2N1bWVudCgpKSB7CisgICAgICAgIERvY3VtZW50KiBkb2N1 bWVudCA9IHN0YXRpY19jYXN0PERvY3VtZW50Kj4obV9jb250ZXh0KTsKKyAgICAgICAgU3RyaW5n IGNvb2tpZSA9IGNvb2tpZVJlcXVlc3RIZWFkZXJGaWVsZFZhbHVlKGRvY3VtZW50LCB1cmwpOwor ICAgICAgICBpZiAoIWNvb2tpZS5pc0VtcHR5KCkpCisgICAgICAgICAgICByZXF1ZXN0LmFkZEV4 dHJhSGVhZGVyRmllbGQoIkNvb2tpZSIsIGNvb2tpZSk7CisgICAgICAgIC8vIFNldCAiQ29va2ll MjogPGNvb2tpZT4iIGlmIGNvb2tpZXMgMiBleGlzdHMgZm9yIHVybD8KKyAgICB9CisKKyAgICBy ZXR1cm4gcmVxdWVzdDsKK30KKwogdm9pZCBXZWJTb2NrZXRIYW5kc2hha2U6OnJlc2V0KCkKIHsK ICAgICBtX21vZGUgPSBJbmNvbXBsZXRlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS93ZWJzb2NrZXRz L1dlYlNvY2tldEhhbmRzaGFrZS5oIGIvV2ViQ29yZS93ZWJzb2NrZXRzL1dlYlNvY2tldEhhbmRz aGFrZS5oCmluZGV4IGJkYTMyMGEuLmEyMjM5OWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvd2Vic29j a2V0cy9XZWJTb2NrZXRIYW5kc2hha2UuaAorKysgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29j a2V0SGFuZHNoYWtlLmgKQEAgLTM1LDYgKzM1LDcgQEAKIAogI2luY2x1ZGUgIktVUkwuaCIKICNp bmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIldlYlNvY2tldEhhbmRzaGFrZVJl cXVlc3QuaCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtNTgsMTIgKzU5LDEyIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgdm9p ZCBzZXRDbGllbnRQcm90b2NvbChjb25zdCBTdHJpbmcmIHByb3RvY29sKTsKIAogICAgICAgICBi b29sIHNlY3VyZSgpIGNvbnN0OwotICAgICAgICB2b2lkIHNldFNlY3VyZShib29sIHNlY3VyZSk7 CiAKICAgICAgICAgU3RyaW5nIGNsaWVudE9yaWdpbigpIGNvbnN0OwogICAgICAgICBTdHJpbmcg Y2xpZW50TG9jYXRpb24oKSBjb25zdDsKIAogICAgICAgICBDU3RyaW5nIGNsaWVudEhhbmRzaGFr ZU1lc3NhZ2UoKSBjb25zdDsKKyAgICAgICAgV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdCBjbGll bnRIYW5kc2hha2VSZXF1ZXN0KCkgY29uc3Q7CiAKICAgICAgICAgdm9pZCByZXNldCgpOwogCmRp ZmYgLS1naXQgYS9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5j cHAgYi9XZWJDb3JlL3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWE0MTE2NwotLS0gL2Rldi9udWxsCisr KyBiL1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmNwcApAQCAt MCwwICsxLDk1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuICBBbGwg cmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNl IGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUg cGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICog bWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1l IG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5 IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICog dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAq IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfU09DS0VU UykKKworI2luY2x1ZGUgIldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QuaCIKKworI2luY2x1ZGUg IkF0b21pY1N0cmluZy5oIgorI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIuaCIKKyNpbmNsdWRlIDx1 dGlsaXR5PgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBz dGQ7CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6 V2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdChjb25zdCBLVVJMJiB1cmwsIGNvbnN0IFN0cmluZyYg b3JpZ2luLCBjb25zdCBTdHJpbmcmIHdlYlNvY2tldFByb3RvY29sKQorICAgIDogbV91cmwodXJs KQorICAgICwgbV9zZWN1cmUobV91cmwucHJvdG9jb2xJcygid3NzIikpCisgICAgLCBtX29yaWdp bihvcmlnaW4pCisgICAgLCBtX3dlYlNvY2tldFByb3RvY29sKHdlYlNvY2tldFByb3RvY29sKQor eworICAgIEFTU0VSVCghb3JpZ2luLmlzTnVsbCgpKTsKK30KKworV2ViU29ja2V0SGFuZHNoYWtl UmVxdWVzdDo6fldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QoKQoreworfQorCit2b2lkIFdlYlNv Y2tldEhhbmRzaGFrZVJlcXVlc3Q6OmFkZEV4dHJhSGVhZGVyRmllbGQoY29uc3QgQXRvbWljU3Ry aW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIHZhbHVlKQoreworICAgIG1fZXh0cmFIZWFkZXJGaWVs ZHMuYXBwZW5kKEhlYWRlckZpZWxkKG5hbWUsIHZhbHVlKSk7Cit9CisKK3ZvaWQgV2ViU29ja2V0 SGFuZHNoYWtlUmVxdWVzdDo6YWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBj b25zdCBTdHJpbmcmIHZhbHVlKQoreworICAgIG1fZXh0cmFIZWFkZXJGaWVsZHMuYXBwZW5kKEhl YWRlckZpZWxkKG5hbWUsIHZhbHVlKSk7Cit9CisKK1ZlY3RvcjxXZWJTb2NrZXRIYW5kc2hha2VS ZXF1ZXN0OjpIZWFkZXJGaWVsZD4gV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdDo6aGVhZGVyRmll bGRzKCkgY29uc3QKK3sKKyAgICBWZWN0b3I8SGVhZGVyRmllbGQ+IGZpZWxkczsKKyAgICBmaWVs ZHMuYXBwZW5kKEhlYWRlckZpZWxkKCJVcGdyYWRlIiwgIldlYlNvY2tldCIpKTsKKyAgICBmaWVs ZHMuYXBwZW5kKEhlYWRlckZpZWxkKCJDb25uZWN0aW9uIiwgIlVwZ3JhZGUiKSk7CisgICAgZmll bGRzLmFwcGVuZChIZWFkZXJGaWVsZCgiSG9zdCIsIGhvc3QoKSkpOworICAgIGZpZWxkcy5hcHBl bmQoSGVhZGVyRmllbGQoIk9yaWdpbiIsIG1fb3JpZ2luKSk7CisgICAgaWYgKCFtX3dlYlNvY2tl dFByb3RvY29sLmlzRW1wdHkoKSkKKyAgICAgICAgZmllbGRzLmFwcGVuZChIZWFkZXJGaWVsZCgi V2ViU29ja2V0LVByb3RvY29sIiwgbV93ZWJTb2NrZXRQcm90b2NvbCkpOworICAgIGZpZWxkcy5h cHBlbmQobV9leHRyYUhlYWRlckZpZWxkcyk7CisgICAgcmV0dXJuIGZpZWxkczsKK30KKworU3Ry aW5nIFdlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3Q6Omhvc3QoKSBjb25zdAoreworICAgIFN0cmlu Z0J1aWxkZXIgYnVpbGRlcjsKKyAgICBidWlsZGVyLmFwcGVuZChtX3VybC5ob3N0KCkubG93ZXIo KSk7CisgICAgaWYgKCghbV9zZWN1cmUgJiYgbV91cmwucG9ydCgpICE9IDgwKSB8fCAobV9zZWN1 cmUgJiYgbV91cmwucG9ydCgpICE9IDQ0MykpIHsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoIjoi KTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQoU3RyaW5nOjpudW1iZXIobV91cmwucG9ydCgpKSk7 CisgICAgfQorICAgIHJldHVybiBidWlsZGVyLnRvU3RyaW5nKCk7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShXRUJfU09DS0VUUykKZGlmZiAtLWdpdCBh L1dlYkNvcmUvd2Vic29ja2V0cy9XZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0LmggYi9XZWJDb3Jl L3dlYnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmQ0ODgxMzUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL3dl YnNvY2tldHMvV2ViU29ja2V0SGFuZHNoYWtlUmVxdWVzdC5oCkBAIC0wLDAgKzEsNzMgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gIEFsbCByaWdodHMgcmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAg ICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAq IGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4g bm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdp dGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRP UlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNU SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklU UzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisg KiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklM SVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lm bmRlZiBXZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0X2gKKyNkZWZpbmUgV2ViU29ja2V0SGFuZHNo YWtlUmVxdWVzdF9oCisKKyNpZiBFTkFCTEUoV0VCX1NPQ0tFVFMpCisKKyNpbmNsdWRlICJLVVJM LmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXRvbWljU3RyaW5nOworCitjbGFzcyBX ZWJTb2NrZXRIYW5kc2hha2VSZXF1ZXN0IHsKK3B1YmxpYzoKKyAgICBXZWJTb2NrZXRIYW5kc2hh a2VSZXF1ZXN0KGNvbnN0IEtVUkwmLCBjb25zdCBTdHJpbmcmIG9yaWdpbiwgY29uc3QgU3RyaW5n JiB3ZWJTb2NrZXRQcm90b2NvbCk7CisgICAgfldlYlNvY2tldEhhbmRzaGFrZVJlcXVlc3QoKTsK KworICAgIC8vIEFjY29yZGluZyB0byBjdXJyZW50IFdlYiBTb2NrZXQgcHJvdG9jb2wgc3BlY2lm aWNhdGlvbiwgZm91ciBtYW5kYXRvcnkgaGVhZGVycyAoVXBncmFkZSwgQ29ubmVjdGlvbiwgSG9z dCwgYW5kIE9yaWdpbikgYW5kCisgICAgLy8gb25lIG9wdGlvbmFsIGhlYWRlciAoV2ViU29ja2V0 LVByb3RvY29sKSBzaG91bGQgYmUgc2VudCBpbiB0aGlzIG9yZGVyLCBhdCB0aGUgYmVnaW5uaW5n IG9mIHRoZSBoYW5kc2hha2UgcmVxdWVzdC4KKyAgICAvLyBUaGUgcmVtYWluaW5nIGhlYWRlcnMg Y2FuIGJlIHNldCBieSB1c2luZyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uLgorICAgIHZvaWQgYWRk RXh0cmFIZWFkZXJGaWVsZChjb25zdCBBdG9taWNTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmluZyYg dmFsdWUpOworICAgIHZvaWQgYWRkRXh0cmFIZWFkZXJGaWVsZChjb25zdCBjaGFyKiBuYW1lLCBj b25zdCBTdHJpbmcmIHZhbHVlKTsKKworICAgIC8vIFJldHVybnMgdGhlIGxpc3Qgb2YgaGVhZGVy IGZpZWxkcyBpbmNsdWRpbmcgZml2ZSBzcGVjaWFsIG9uZXMuCisgICAgdHlwZWRlZiBzdGQ6OnBh aXI8QXRvbWljU3RyaW5nLCBTdHJpbmc+IEhlYWRlckZpZWxkOworICAgIFZlY3RvcjxIZWFkZXJG aWVsZD4gaGVhZGVyRmllbGRzKCkgY29uc3Q7CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIGhvc3Qo KSBjb25zdDsKKworICAgIEtVUkwgbV91cmw7CisgICAgYm9vbCBtX3NlY3VyZTsKKyAgICBTdHJp bmcgbV9vcmlnaW47CisgICAgU3RyaW5nIG1fd2ViU29ja2V0UHJvdG9jb2w7CisgICAgVmVjdG9y PEhlYWRlckZpZWxkPiBtX2V4dHJhSGVhZGVyRmllbGRzOworfTsKKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFdFQl9TT0NLRVRTKQorCisjZW5kaWYgLy8gV2Vi U29ja2V0SGFuZHNoYWtlUmVxdWVzdF9oCg==