26854 2009-06-30 12:19:51 -0700 [GTK] Needs API to allow more control over outgoing requests 2009-09-08 14:44:37 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC All RESOLVED FIXED Gtk P2 Normal --- 1 gustavo webkit-unassigned christian jmalonzo xan.lopez oldest_to_newest 129134 0 gustavo 2009-06-30 12:19:51 -0700 Currently we lack ways of controlling the outgoing requests. We cannot modify headers, or other properties of the request, because none of the signals we currently provide in our API allow that. We specially need to implement the dispatchWillSendRequest delegate. 129136 1 32084 gustavo 2009-06-30 12:24:29 -0700 Created attachment 32084 Map the willSendRequest delegate to the 'outgoing-request' signal WebKit/gtk/ChangeLog | 16 +++++++++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 11 ++++++- WebKit/gtk/webkit/webkitwebview.cpp | 28 ++++++++++++++++++++ WebKit/gtk/webkitmarshal.list | 1 + 4 files changed, 54 insertions(+), 2 deletions(-) 129137 2 32084 gustavo 2009-06-30 12:27:25 -0700 Comment on attachment 32084 Map the willSendRequest delegate to the 'outgoing-request' signal A first try. 129138 3 32085 gustavo 2009-06-30 12:30:43 -0700 Created attachment 32085 Basic adblocking embed/ephy-embed.c | 17 +++++++++++++++++ 1 files changed, 17 insertions(+), 0 deletions(-) 129139 4 32085 gustavo 2009-06-30 12:31:50 -0700 Comment on attachment 32085 Basic adblocking This demonstrates how the new API could be used to implement adblocking in Epiphany. It's far from finished, but serves as a good example, and should allow us to improve the proposed API. 129193 5 32084 jmalonzo 2009-06-30 15:22:55 -0700 Comment on attachment 32084 Map the willSendRequest delegate to the 'outgoing-request' signal > -void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) > +void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest& request, const ResourceResponse&) > { > - notImplemented(); > + WebKitWebView* webView = getViewFromFrame(m_frame); > + WebKitNetworkRequest* networkRequest = webkit_network_request_new_with_core_request(request); > + > + g_signal_emit_by_name(webView, "outgoing-request", m_frame, identifier, networkRequest); We probably need to send the data source object as well and possibly make identifier an attribute of that object. As for naming, I'm not sure what outgoing-request means. I think it needs to be more meaningful. > + * Emitted when a request is about to be sent. You can modify the > + * request, by adding/removing/replacing headers, or changing the > + * URI, using the #SoupMessage object it carries, if it is Will changing the URI have any effect on security? > + webkit_web_view_signals[OUTGOING_REQUEST] = g_signal_new("outgoing-request", > + G_TYPE_FROM_CLASS(webViewClass), > + (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION), > + 0, > + NULL, NULL, > + webkit_marshal_VOID__OBJECT_OBJECT_ULONG, > + G_TYPE_NONE, 3, > + WEBKIT_TYPE_WEB_FRAME, > + G_TYPE_ULONG, > + WEBKIT_TYPE_NETWORK_REQUEST); The marshaller seems to be off here. Also, the DRT support for this is missing + the layout tests that will be enabled by this feature. r- for now because of this. 129230 6 gustavo 2009-06-30 18:55:19 -0700 (In reply to comment #5) > > + WebKitWebView* webView = getViewFromFrame(m_frame); > > + WebKitNetworkRequest* networkRequest = webkit_network_request_new_with_core_request(request); > > + > > + g_signal_emit_by_name(webView, "outgoing-request", m_frame, identifier, networkRequest); > > We probably need to send the data source object as well and possibly make > identifier an attribute of that object. I don't think there's a data source object here yet, is there? I think we may want to keep the identifier out of any objects. > As for naming, I'm not sure what outgoing-request means. I think it needs to be > more meaningful. We need a way of expressing 'a request is going to be sent', outgoing-request was the first thing I could think of. > > + * Emitted when a request is about to be sent. You can modify the > > + * request, by adding/removing/replacing headers, or changing the > > + * URI, using the #SoupMessage object it carries, if it is > > Will changing the URI have any effect on security? It could, so it's best that the application know what it is doing =). > The marshaller seems to be off here. danw pointed that out, thanks =) > Also, the DRT support for this is missing + the layout tests that will be > enabled by this feature. What kind of DRT support, do you mean? I don't think we will have layout tests enabled by this feature, too. This is purely API-related, AFAIK. > > r- for now because of this. > 129339 7 32134 gustavo 2009-07-01 12:51:49 -0700 Created attachment 32134 Map the willSendRequest delegate to the 'outgoing-request' signal LayoutTests/ChangeLog | 12 +++++ LayoutTests/platform/gtk/Skipped | 2 - WebKit/gtk/ChangeLog | 17 ++++++ WebKit/gtk/WebCoreSupport/FrameLoaderClientGtk.cpp | 15 +++++- WebKit/gtk/webkit/webkitwebview.cpp | 52 ++++++++++++++++++++ WebKit/gtk/webkitmarshal.list | 2 + WebKitTools/ChangeLog | 15 ++++++ WebKitTools/DumpRenderTree/gtk/DumpRenderTree.cpp | 40 +++++++++++++++ 8 files changed, 150 insertions(+), 5 deletions(-) 129340 8 32134 gustavo 2009-07-01 12:56:58 -0700 Comment on attachment 32134 Map the willSendRequest delegate to the 'outgoing-request' signal After Jan pointed out that Mac used willSendRequest in its DRT implementation I went and investigated. I now believe we need to look at this problem with a wider perspective, and with the DataSource API in mind. Delegates such as willSendRequest, didFinishLoading, and other (I believe all that get a DocumentLoader and an identifier, in FrameLoaderClient) are used together for tracking the loading of the resources. Mac provides as part of its API objects representing the resources, and maps the identifier to said objects in these delegates. We may want to adopt a similar approach. 136384 9 32134 jmalonzo 2009-07-31 21:26:17 -0700 Comment on attachment 32134 Map the willSendRequest delegate to the 'outgoing-request' signal > -void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long, ResourceRequest&, const ResourceResponse&) > +void FrameLoaderClient::dispatchWillSendRequest(DocumentLoader*, unsigned long identifier, ResourceRequest& request, const ResourceResponse&) > { > - notImplemented(); > + WebKitWebView* webView = getViewFromFrame(m_frame); > + WebKitNetworkRequest* networkRequest = webkit_network_request_new_with_core_request(request); > + > + g_signal_emit_by_name(webView, "outgoing-request", m_frame, identifier, networkRequest); I think instead of sending the identifier, we can do a WebResource lookup by identifier and send the resource instead. Thoughts? > void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, DocumentLoader*, const ResourceRequest&) > @@ -860,7 +867,9 @@ void FrameLoaderClient::dispatchDidReceiveContentLength(DocumentLoader*, unsigne > > void FrameLoaderClient::dispatchDidFinishLoading(DocumentLoader*, unsigned long identifier) > { > - notImplemented(); > + WebKitWebView* webView = getViewFromFrame(m_frame); > + > + g_signal_emit_by_name(webView, "finished-request", m_frame, identifier); I think we might need to prefix these resource-related signal names with resource- to avoid confusion with frame load events. So for example resource-will-send-request, resource-load-finished, etc.. > + * WebKitWebView::outgoing-request: > + * @web_view: the object which received the signal > + * @web_frame: the #WebKitWebFrame whose load dispatched this request > + * @identifier: a numeric identifier for the resource that is > + * being loaded; in the future you will be able to use it with the > + * DataSource API, to track resource loading I think the DS API is nearly there so instead of identifier, we can send the webresource instead as well as the datasource? Thoughts? > + /** > + * WebKitWebView::finished-request: > + * @web_view: the object which received the signal > + * @web_frame: the #WebKitWebFrame whose load dispatched this request > + * @identifier: a numeric identifier for the resource that is > + * being loaded; in the future you will be able to use it with the > + * DataSource API, to track resource loading Ditto. Patch looks good. Would be nice if we can agree on the identifier -> webresource approach soon. 138298 10 32134 xan.lopez 2009-08-08 00:33:35 -0700 Comment on attachment 32134 Map the willSendRequest delegate to the 'outgoing-request' signal I'm r- this for now since I think it's clear we'll want to use the DS stuff in one way or the other when it's done. 139208 11 gustavo 2009-08-11 19:21:59 -0700 (In reply to comment #9) > I think instead of sending the identifier, we can do a WebResource lookup by > identifier and send the resource instead. Thoughts? That sounds good to me, yeah =D 144805 12 39055 gustavo 2009-09-04 07:15:10 -0700 Created attachment 39055 first draft post-DS I'm setting the review flag just to get comments on the patch, and on the API. The patch still needs work, and we are probably going to add a WebKitNetworkResponse object to forward the response parameter willSendRequest gets. 144815 13 39061 gustavo 2009-09-04 08:51:53 -0700 Created attachment 39061 second draft post-DS; hah, now with response I didn't think I'd be able to add response before going for lunch, but here it is. The Launcher patch is just for playing with the API, of course; I think it is good to enlighten how it is supposed to work. Comments, please! =) 144867 14 39076 gustavo 2009-09-04 10:48:34 -0700 Created attachment 39076 the traditional Epiphany implementation as an example 144888 15 39081 gustavo 2009-09-04 12:11:28 -0700 Created attachment 39081 third draft, with some comments by Xan addressed, and no load-status/load-error for resources 144889 16 39082 gustavo 2009-09-04 12:15:36 -0700 Created attachment 39082 load-status and load-error implementation for resource loading This is the second part of the patch, split out so they can be reviewed and get in at separate times. 145016 17 39081 xan.lopez 2009-09-05 12:28:38 -0700 Comment on attachment 39081 third draft, with some comments by Xan addressed, and no load-status/load-error for resources > +#include "config.h" > +#include "ResourceResponse.h" > + > +#include "CString.h" > +#include "GOwnPtr.h" > +#include "PlatformString.h" I'd say some of these are unused here? > + > +#include <libsoup/soup.h> And this one is included in ResourceResponse.h already? > + > +using namespace std; > + > +namespace WebCore { > + > +SoupMessage* ResourceResponse::toSoupMessage() const > +{ > + // This GET here is just because SoupMessage wants it, we dn't really know. > + SoupMessage* soupMessage = soup_message_new("GET", url().string().utf8().data()); > + if (!soupMessage) > + return 0; > + > + soupMessage->status_code = httpStatusCode(); > + > + HTTPHeaderMap headers = httpHeaderFields(); > + SoupMessageHeaders* soupHeaders = soupMessage->response_headers; > + if (!headers.isEmpty()) { > + HTTPHeaderMap::const_iterator end = headers.end(); > + for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) > + soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data()); > + } > + > + // Body data is not in the message. > + return soupMessage; > +} As mentioned on IRC it would we good to share this function with ResourceRequest, since it's identical to what's there but for one line. > +// We convert this to string because it's easier to use strings as > +// keys in a GHashTable. > +static char* identifierToString(unsigned long identifier) > +{ > + return g_strdup_printf("%ld", identifier); > +} > + > void FrameLoaderClient::dispatchWillSendRequest(WebCore::DocumentLoader* loader, unsigned long identifier, ResourceRequest& request, const ResourceResponse& redirectResponse) > { > - if (redirectResponse.isNull()) > + WebKitWebView* webView = getViewFromFrame(m_frame); > + > + GOwnPtr<gchar> identifierString(identifierToString(identifier)); > + WebKitWebResource* webResource = webkit_web_view_get_resource(webView, identifierString.get()); > + > + WebKitNetworkRequest* networkRequest = webkit_network_request_new_with_core_request(request); > + WebKitNetworkResponse* networkResponse; > + > + // We are adding one more resource to the load, or maybe we are > + // just redirecting a load, in which case we need to update our > + // WebKitWebResource's knowledge of the URI. > + if (redirectResponse.isNull()) { > static_cast<WebKit::DocumentLoader*>(loader)->increaseLoadCount(identifier); > + > + networkResponse = WEBKIT_NETWORK_RESPONSE(g_object_new(WEBKIT_TYPE_NETWORK_RESPONSE, 0)); I think we should just pass NULL instead of a dummy object here? Since the point is to inform the user of whether this is a redirect and such, I think that makes it much more clear. > + } else { > + g_free(webResource->priv->uri); > + webResource->priv->uri = g_strdup(request.url().string().utf8().data()); > + > + networkResponse = webkit_network_response_new_with_core_response(redirectResponse); > + } > + > + g_signal_emit_by_name(webView, "resource-request-starting", m_frame, webResource, networkRequest, networkResponse); > + > + // Feed any changes back into the ResourceRequest object. > + request = core(networkRequest); > + g_object_unref(networkRequest); Also you are leaking the networkResponse object AFAICT. > } > > -void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const ResourceRequest&) > +void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const ResourceRequest& request) > { > - notImplemented(); > + WebKitWebResource* webResource = WEBKIT_WEB_RESOURCE(g_object_new(WEBKIT_TYPE_WEB_RESOURCE, 0)); > + > + // The URI is important to have in the resource because that is what we use > + // to fetch the WebCore object, later on. We use the private structure > + // directly here to avoid changing the property mode from READABLE to > + // READWRITE. > + webResource->priv->uri = g_strdup(request.url().string().utf8().data()); I don't understand the comment. You are creating the object now, so you certainly pass the URI you want in the parameters. > + > + webkit_web_view_add_resource(getViewFromFrame(m_frame), identifierToString(identifier), webResource); > } > > @@ -800,13 +842,22 @@ void FrameLoaderClient::dispatchDidReceiveContentLength(WebCore::DocumentLoader* > void FrameLoaderClient::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long identifier) > { > static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier); > + > + GOwnPtr<gchar> identifierString(identifierToString(identifier)); > + WebKitWebResource* webResource = webkit_web_view_get_resource(getViewFromFrame(m_frame), identifierString.get()); > + > + const char* uri = webkit_web_resource_get_uri(webResource); > + RefPtr<ArchiveResource> coreResource(loader->subresource(KURL(KURL(), uri))); > + webkit_web_resource_init_with_core_resource(webResource, coreResource.get()); I don't understand why are you init again the resource if you are about the remove it from the view? > + > + webkit_web_view_remove_resource(getViewFromFrame(m_frame), identifierString.get()); > } > > void FrameLoaderClient::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long identifier, const ResourceError& error) > { > - // FIXME: when does this occur and what should happen? > - > static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier); > + > + notImplemented(); notImplemented()? The function does something. Do you know now what should it do that it's not doing? If so add a comment. > } > > + */ > + > +#include "config.h" > +#include "webkitnetworkresponse.h" > + > +#include "CString.h" > +#include "GOwnPtr.h" > +#include "ResourceResponse.h" > +#include "webkitprivate.h" > + > +static void webkit_network_response_init(WebKitNetworkResponse* response) > +{ > + WebKitNetworkResponsePrivate* priv = WEBKIT_NETWORK_RESPONSE_GET_PRIVATE(response); > + response->priv = priv; No need for the variable here. > diff --git a/WebKit/gtk/webkit/webkitwebresource.cpp b/WebKit/gtk/webkit/webkitwebresource.cpp > index c162578..fd4abb7 100644 > --- a/WebKit/gtk/webkit/webkitwebresource.cpp > +++ b/WebKit/gtk/webkit/webkitwebresource.cpp > @@ -27,6 +27,8 @@ > #include "KURL.h" > #include "PlatformString.h" > #include "SharedBuffer.h" > +#include "webkitenumtypes.h" > +#include "webkitmarshal.h" > #include "wtf/Assertions.h" > > #include <glib.h> > @@ -50,13 +52,34 @@ enum { > PROP_URI, > PROP_MIME_TYPE, > PROP_ENCODING, > - PROP_FRAME_NAME > + PROP_FRAME_NAME, > }; Uh? :) > +void webkit_web_resource_init_with_core_resource(WebKitWebResource* webResource, PassRefPtr<ArchiveResource> resource) > +{ > + WebKitWebResourcePrivate* priv = webResource->priv; > + > + if (priv->resource) > + priv->resource->deref(); > + > + webkit_web_resource_cleanup(webResource); > + > + priv->resource = resource.releaseRef(); > +} Since this function is only used before removing a resource now I'm really curious about what's its point. > + > /** > * webkit_web_resource_new: > * @data: the data to initialize the #WebKitWebResource > @@ -270,11 +298,14 @@ G_CONST_RETURN gchar* webkit_web_resource_get_uri(WebKitWebResource* webResource > g_return_val_if_fail(WEBKIT_IS_WEB_RESOURCE(webResource), NULL); > > WebKitWebResourcePrivate* priv = webResource->priv; > + > + if (priv->uri) > + return priv->uri; > + > if (!priv->resource) > return NULL; > > - if (!priv->uri) > - priv->uri = g_strdup(priv->resource->url().string().utf8().data()); > + priv->uri = g_strdup(priv->resource->url().string().utf8().data()); > > return priv->uri; This seems subtle enough to warrant a comment. Was it broken before? > } > @@ -344,3 +375,4 @@ G_CONST_RETURN gchar* webkit_web_resource_get_frame_name(WebKitWebResource* webR > > return priv->frameName; > } > + > + /** > + * WebKitWebView::resource-request-starting: > + * @web_view: the object which received the signal > + * @web_frame: the #WebKitWebFrame whose load dispatched this request > + * @web_resource: an empty #WebKitWebResource object > + * @request: the #WebKitNetworkRequest that will be dispatched > + * @response: the #WebKitNetworkResponse representing the redirect > + * response, if any > + * > + * Emitted when a request is about to be sent. You can modify the > + * request, by adding/removing/replacing headers, or changing the > + * URI, using the #SoupMessage object it carries, if it is > + * present. See webkit_network_request_get_message(). Setting the > + * request URI to "about:blank" will effectively cause the request > + * to load nothing, and can be used to disable the loading of > + * specific resources. > + * > + * Notice that information about an eventual redirect are > + * available in @response's #SoupMessage, not in the #SoupMessage > + * carried by the @request. If @response doesn't have a > + * #SoupMessage (i.e. if webkit_network_response_get_message() > + * returns %NULL), then this is not a redirected request. As mentioned, I think it's better to either have NULL or a full response. > + * > + * The #WebKitWebResource object will be the same throughout all > + * the lifetime of the resource, but the contents may change from > + * inbetween signal emissions. > + * > + * Since: 1.1.14 > + */ > + webkit_web_view_signals[RESOURCE_REQUEST_STARTING] = g_signal_new("resource-request-starting", > + G_TYPE_FROM_CLASS(webViewClass), > + (GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION), > + 0, > + NULL, NULL, > + webkit_marshal_VOID__OBJECT_OBJECT_OBJECT_OBJECT, > + G_TYPE_NONE, 4, > + WEBKIT_TYPE_WEB_FRAME, > + WEBKIT_TYPE_WEB_RESOURCE, > + WEBKIT_TYPE_NETWORK_REQUEST, > + WEBKIT_TYPE_NETWORK_RESPONSE); > + > + > diff --git a/WebKit/gtk/webkitmarshal.list b/WebKit/gtk/webkitmarshal.list > index aa0d40c..cff8018 100644 > --- a/WebKit/gtk/webkitmarshal.list > +++ b/WebKit/gtk/webkitmarshal.list > @@ -13,7 +13,11 @@ OBJECT:OBJECT > OBJECT:STRING,STRING,POINTER > OBJECT:VOID > VOID:OBJECT,OBJECT > +VOID:OBJECT,OBJECT,OBJECT,OBJECT > +VOID:OBJECT,POINTER > VOID:OBJECT,POINTER,POINTER > VOID:OBJECT,STRING > +VOID:OBJECT,ULONG > VOID:STRING > VOID:STRING,STRING > +VOID:STRING,POINTER I don't think you need all these now, just the first one. > -- > 1.6.3.3 > Marking as r- since I think there's some things to clarify/polish still, but I think the new APIs are good. 145140 18 gustavo 2009-09-07 07:07:37 -0700 New Note 30 (In reply to comment #17) > > +#include "CString.h" > > +#include "GOwnPtr.h" > > +#include "PlatformString.h" > > I'd say some of these are unused here? Only GOwnPtr.h =) > > +#include <libsoup/soup.h> > > And this one is included in ResourceResponse.h already? Right =) > As mentioned on IRC it would we good to share this function with > ResourceRequest, since it's identical to what's there but for one line. I am not sure where I would add a single function that both call, and I think the only thing that makes sense sharing is the copying of headers, for now, so I decided to not mess with this right now. > I think we should just pass NULL instead of a dummy object here? Since the > point is to inform the user of whether this is a redirect and such, I think > that makes it much more clear. OK, I for some reason have in my mind that passing NULL as the value of an object might blow up the signal emission, but I agree. > Also you are leaking the networkResponse object AFAICT. Yeah! Turned all of them into GOwnPtr's. > > + // The URI is important to have in the resource because that is what we use > > + // to fetch the WebCore object, later on. We use the private structure > > + // directly here to avoid changing the property mode from READABLE to > > + // READWRITE. > > + webResource->priv->uri = g_strdup(request.url().string().utf8().data()); > > I don't understand the comment. You are creating the object now, so you > certainly pass the URI you want in the parameters. Only explaining why I am setting the URI directly instead of initing with the core resource object, really, but this is gone - this part of the code is also only needed for the other signals. I removed all the identifier handling, and the hashtable. > > + const char* uri = webkit_web_resource_get_uri(webResource); > > + RefPtr<ArchiveResource> coreResource(loader->subresource(KURL(KURL(), uri))); > > + webkit_web_resource_init_with_core_resource(webResource, coreResource.get()); > > I don't understand why are you init again the resource if you are about the > remove it from the view? Yeah, this only makes sense with the load-status thing; this is the time when WebCore already has its ArchivedResource object, so I was depending on load-status to inform the user that the WebResource object just turned more useful than just containing the URI, so this is for the next patch. > > + notImplemented(); > > notImplemented()? The function does something. Do you know now what should it > do that it's not doing? If so add a comment. Yeah, this is load-error. > > PROP_ENCODING, > > - PROP_FRAME_NAME > > + PROP_FRAME_NAME, > > }; > > Uh? :) More debris from removing load-status =/ > Since this function is only used before removing a resource now I'm really > curious about what's its point. Yeah, next patch material. > This seems subtle enough to warrant a comment. Was it broken before? Not really, but now we want to be able to have an URI even with no ArchivedResource available, because we're creating the object before we have an ArchivedResource, and the URI is the only useful thing we have. > I don't think you need all these now, just the first one. okidoki 145150 19 39146 gustavo 2009-09-07 07:45:23 -0700 Created attachment 39146 one more draft, with Xan's comments addressed 145164 20 39146 xan.lopez 2009-09-07 08:37:39 -0700 Comment on attachment 39146 one more draft, with Xan's comments addressed > + GOwnPtr<WebKitWebResource> webResource(WEBKIT_WEB_RESOURCE(g_object_new(WEBKIT_TYPE_WEB_RESOURCE, 0))); > + webResource->priv->uri = g_strdup(request.url().string().utf8().data()); As discussed on IRC, set the property as CONSTRUCT_ONLY and pass as parameter to g_object_new > + > + GOwnPtr<WebKitNetworkRequest> networkRequest(webkit_network_request_new_with_core_request(request)); > + > + g_signal_emit_by_name(webView, "resource-request-starting", m_frame, webResource.get(), networkRequest.get(), networkResponse.get()); > + > + // Feed any changes back into the ResourceRequest object. > + request = core(networkRequest.get()); > } > > -void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long identifier, WebCore::DocumentLoader*, const ResourceRequest&) > +void FrameLoaderClient::assignIdentifierToInitialRequest(unsigned long, WebCore::DocumentLoader*, const ResourceRequest&) > { > notImplemented(); > } > @@ -792,7 +812,7 @@ void FrameLoaderClient::setTitle(const String& title, const KURL& url) > frameData->title = g_strdup(title.utf8().data()); > } > > -void FrameLoaderClient::dispatchDidReceiveContentLength(WebCore::DocumentLoader*, unsigned long identifier, int lengthReceived) > +void FrameLoaderClient::dispatchDidReceiveContentLength(WebCore::DocumentLoader* loader, unsigned long identifier, int lengthReceived) > { > notImplemented(); > } No need to add the name here... > @@ -800,13 +820,17 @@ void FrameLoaderClient::dispatchDidReceiveContentLength(WebCore::DocumentLoader* > void FrameLoaderClient::dispatchDidFinishLoading(WebCore::DocumentLoader* loader, unsigned long identifier) > { > static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier); > + > + notImplemented(); > } > As discussed on IRC, add a comment on this one too. > void FrameLoaderClient::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long identifier, const ResourceError& error) > { > - // FIXME: when does this occur and what should happen? > - > static_cast<WebKit::DocumentLoader*>(loader)->decreaseLoadCount(identifier); > + > + // This function should notify the application that a resource failed > + // loading (maybe a 'load-error' signal in the WebKitWebResource object > + notImplemented(); > } > > @@ -1975,6 +1978,46 @@ static void webkit_web_view_class_init(WebKitWebViewClass* webViewClass) > G_TYPE_NONE, 2, > G_TYPE_OBJECT, G_TYPE_OBJECT); > > + /** > + * WebKitWebView::resource-request-starting: > + * @web_view: the object which received the signal > + * @web_frame: the #WebKitWebFrame whose load dispatched this request > + * @web_resource: an empty #WebKitWebResource object > + * @request: the #WebKitNetworkRequest that will be dispatched > + * @response: the #WebKitNetworkResponse representing the redirect > + * response, if any > + * > + * Emitted when a request is about to be sent. You can modify the > + * request, by adding/removing/replacing headers, or changing the > + * URI, using the #SoupMessage object it carries, if it is > + * present. See webkit_network_request_get_message(). Setting the > + * request URI to "about:blank" will effectively cause the request > + * to load nothing, and can be used to disable the loading of > + * specific resources. I read this like you have to modify the request through the SoupMessage if it's there, but you don't need to get the message to, for example, set the URI. Maybe reword it a bit? r=me with those changes wooo! 145173 21 39151 gustavo 2009-09-07 09:15:08 -0700 Created attachment 39151 latest comments by Xan addressed 145176 22 39151 xan.lopez 2009-09-07 09:21:02 -0700 Comment on attachment 39151 latest comments by Xan addressed r=me changing the g_warning with a g_return_if_fail as discussed on IRC. 145179 23 gustavo 2009-09-07 09:27:54 -0700 Landed as r48118. 145546 24 39082 eric 2009-09-08 14:44:37 -0700 Comment on attachment 39082 load-status and load-error implementation for resource loading Clearing r=? since this bug is closed. 32084 2009-06-30 12:24:29 -0700 2009-09-04 07:15:10 -0700 Map the willSendRequest delegate to the 'outgoing-request' signal Map-the-willSendRequest-delegate-to-the-outgoing-request-signal.patch text/plain 4209 gustavo ZmVmN2ZkMGJlM2YwYzkxYzYxYzM2NzI3MDNhZjc1YWJlZjQ4YjA2YQpkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCBmZDQzZWQ2Li4x NDYyOThhIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5LTA2LTMwICBHdXN0YXZvIE5vcm9uaGEg U2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cg bW9yZSBjb250cm9sIG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAgICAgICBNYXAgdGhlIHdp bGxTZW5kUmVxdWVzdCBkZWxlZ2F0ZSB0byB0aGUgJ291dGdvaW5nLXJlcXVlc3QnIHNpZ25hbCwK KyAgICAgICAgYWxsb3dpbmcgbW9yZSBjb250cm9sIG9mIHRoZSBmZXRjaGluZyBvZiByZXNvdXJj ZXMuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHA6 CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVx dWVzdCk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAod2Vi a2l0X3dlYl92aWV3X2NsYXNzX2luaXQpOgorICAgICAgICAqIHdlYmtpdG1hcnNoYWwubGlzdDoK KwogMjAwOS0wNi0yOSAgWGFuIExvcGV6ICA8eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAg UmV2aWV3ZWQgYnkgSmFuIEFsb256by4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1 cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggZjA3NzZmOS4uNzM4ZWQwMiAxMDA2NDQK LS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAK KysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAK QEAgLTI1NCw5ICsyNTQsMTYgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRD YW5jZWxBdXRoZW50aWNhdGlvbkNoYWxsZW5nZShEb2N1bWVudExvYWRlcioKICAgICBub3RJbXBs ZW1lbnRlZCgpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5k UmVxdWVzdChEb2N1bWVudExvYWRlciosIHVuc2lnbmVkIGxvbmcsIFJlc291cmNlUmVxdWVzdCYs IGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0 Y2hXaWxsU2VuZFJlcXVlc3QoRG9jdW1lbnRMb2FkZXIqLCB1bnNpZ25lZCBsb25nIGlkZW50aWZp ZXIsIFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYpCiB7 Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0 Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29y a1JlcXVlc3QgPSB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChy ZXF1ZXN0KTsKKworICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAib3V0Z29pbmct cmVxdWVzdCIsIG1fZnJhbWUsIGlkZW50aWZpZXIsIG5ldHdvcmtSZXF1ZXN0KTsKKworICAgIC8v IEZlZWQgYW55IGNoYW5nZXMgYmFjayBpbnRvIHRoZSBSZXNvdXJjZVJlcXVlc3Qgb2JqZWN0Lgor ICAgIHJlcXVlc3QgPSBjb3JlKG5ldHdvcmtSZXF1ZXN0KTsKKyAgICBnX29iamVjdF91bnJlZihu ZXR3b3JrUmVxdWVzdCk7CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmFzc2lnbklkZW50 aWZpZXJUb0luaXRpYWxSZXF1ZXN0KHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgRG9jdW1lbnRM b2FkZXIqLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcAppbmRleCA1YjE5ODU2Li43NjBhYmQzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmNwcApAQCAtMTQxLDYgKzE0MSw3IEBAIGVudW0gewogICAgIE1PVkVfQ1VSU09SLAogICAgIFBS SU5UX1JFUVVFU1RFRCwKICAgICBQTFVHSU5fV0lER0VULAorICAgIE9VVEdPSU5HX1JFUVVFU1Qs CiAgICAgTEFTVF9TSUdOQUwKIH07CiAKQEAgLTE3MTUsNiArMTcxNiwzMyBAQCBzdGF0aWMgdm9p ZCB3ZWJraXRfd2ViX3ZpZXdfY2xhc3NfaW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdlYlZpZXdD bGFzcykKICAgICAgICAgICAgIEdUS19UWVBFX1dJREdFVCwgMywKICAgICAgICAgICAgIEdfVFlQ RV9TVFJJTkcsIEdfVFlQRV9TVFJJTkcsIEdfVFlQRV9IQVNIX1RBQkxFKTsKIAorICAgIC8qKgor ICAgICAqIFdlYktpdFdlYlZpZXc6Om91dGdvaW5nLXJlcXVlc3Q6CisgICAgICogQHdlYl92aWV3 OiB0aGUgb2JqZWN0IHdoaWNoIHJlY2VpdmVkIHRoZSBzaWduYWwKKyAgICAgKiBAd2ViX2ZyYW1l OiB0aGUgI1dlYktpdFdlYkZyYW1lIHdob3NlIGxvYWQgZGlzcGF0Y2hlZCB0aGlzIHJlcXVlc3QK KyAgICAgKiBAaWRlbnRpZmllcjogYSBudW1lcmljIGlkZW50aWZpZXIgZm9yIHRoZSByZXNvdXJj ZSB0aGF0IGlzCisgICAgICogYmVpbmcgbG9hZGVkOyBpbiB0aGUgZnV0dXJlIHlvdSB3aWxsIGJl IGFibGUgdG8gdXNlIGl0IHdpdGggdGhlCisgICAgICogRGF0YVNvdXJjZSBBUEksIHRvIHRyYWNr IHJlc291cmNlIGxvYWRpbmcKKyAgICAgKiBAcmVxdWVzdDogdGhlICNXZWJLaXROZXR3b3JrUmVx dWVzdCB0aGF0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAqCisgICAgICogRW1pdHRlZCB3aGVu IGEgcmVxdWVzdCBpcyBhYm91dCB0byBiZSBzZW50LiBZb3UgY2FuIG1vZGlmeSB0aGUKKyAgICAg KiByZXF1ZXN0LCBieSBhZGRpbmcvcmVtb3ZpbmcvcmVwbGFjaW5nIGhlYWRlcnMsIG9yIGNoYW5n aW5nIHRoZQorICAgICAqIFVSSSwgdXNpbmcgdGhlICNTb3VwTWVzc2FnZSBvYmplY3QgaXQgY2Fy cmllcywgaWYgaXQgaXMKKyAgICAgKiBwcmVzZW50LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVz dF9nZXRfbWVzc2FnZSgpLgorICAgICAqCisgICAgICogU2luY2U6IDEuMS4xMQorICAgICAqLwor ICAgIHdlYmtpdF93ZWJfdmlld19zaWduYWxzW09VVEdPSU5HX1JFUVVFU1RdID0gZ19zaWduYWxf bmV3KCJvdXRnb2luZy1yZXF1ZXN0IiwKKyAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdl YlZpZXdDbGFzcyksCisgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFT VCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAgICAgICAgICAwLAorICAgICAgICAgICAgTlVMTCwg TlVMTCwKKyAgICAgICAgICAgIHdlYmtpdF9tYXJzaGFsX1ZPSURfX09CSkVDVF9PQkpFQ1RfVUxP TkcsCisgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMywKKyAgICAgICAgICAgIFdFQktJVF9UWVBF X1dFQl9GUkFNRSwKKyAgICAgICAgICAgIEdfVFlQRV9VTE9ORywKKyAgICAgICAgICAgIFdFQktJ VF9UWVBFX05FVFdPUktfUkVRVUVTVCk7CisKICAgICAvKgogICAgICAqIGltcGxlbWVudGF0aW9u cyBvZiB2aXJ0dWFsIG1ldGhvZHMKICAgICAgKi8KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Vi a2l0bWFyc2hhbC5saXN0IGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKaW5kZXggYWEw ZDQwYy4uYTBkMzRlZiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QK KysrIGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKQEAgLTEzLDYgKzEzLDcgQEAgT0JK RUNUOk9CSkVDVAogT0JKRUNUOlNUUklORyxTVFJJTkcsUE9JTlRFUgogT0JKRUNUOlZPSUQKIFZP SUQ6T0JKRUNULE9CSkVDVAorVk9JRDpPQkpFQ1QsT0JKRUNULFVMT05HCiBWT0lEOk9CSkVDVCxQ T0lOVEVSLFBPSU5URVIKIFZPSUQ6T0JKRUNULFNUUklORwogVk9JRDpTVFJJTkcK 32085 2009-06-30 12:30:43 -0700 2009-09-04 10:48:34 -0700 Basic adblocking Basic-adblocking.patch text/plain 1828 gustavo YjhjYjA3ZTFmMjg1MDM4YTZlNTg2YTgwMGMyZWFhYzc0NmZiNTFhMwpkaWZmIC0tZ2l0IGEvZW1i ZWQvZXBoeS1lbWJlZC5jIGIvZW1iZWQvZXBoeS1lbWJlZC5jCmluZGV4IDE4Yzk0M2YuLjdkMzlk MzQgMTAwNjQ0Ci0tLSBhL2VtYmVkL2VwaHktZW1iZWQuYworKysgYi9lbWJlZC9lcGh5LWVtYmVk LmMKQEAgLTI3LDYgKzI3LDcgQEAKIAogI2luY2x1ZGUgImRvd25sb2FkZXItdmlldy5oIgogI2lu Y2x1ZGUgImVlbC1nY29uZi1leHRlbnNpb25zLmgiCisjaW5jbHVkZSAiZXBoeS1hZGJsb2NrLW1h bmFnZXIuaCIKICNpbmNsdWRlICJlcGh5LWNvbW1hbmQtbWFuYWdlci5oIgogI2luY2x1ZGUgImVw aHktZGVidWcuaCIKICNpbmNsdWRlICJlcGh5LWZpbGUtY2hvb3Nlci5oIgpAQCAtMTY4LDYgKzE2 OSwyMSBAQCByZXN0b3JlX3pvb21fbGV2ZWwgKEVwaHlFbWJlZCAqZW1iZWQsCiB9CiAKIHN0YXRp YyB2b2lkCitvdXRnb2luZ19yZXF1ZXN0X2NiIChXZWJLaXRXZWJWaWV3ICp3ZWJfdmlldywKKyAg ICAgICAgICAgICAgICAgICAgIFdlYktpdFdlYkZyYW1lICp3ZWJfZnJhbWUsCisgICAgICAgICAg ICAgICAgICAgICBndWxvbmcgaWRlbnRpZmllciwKKyAgICAgICAgICAgICAgICAgICAgIFdlYktp dE5ldHdvcmtSZXF1ZXN0ICpyZXF1ZXN0LAorICAgICAgICAgICAgICAgICAgICAgRXBoeUVtYmVk ICplbWJlZCkKK3sKKyAgRXBoeUFkQmxvY2tNYW5hZ2VyICphZGJsb2NrX21hbmFnZXIgPSBFUEhZ X0FEQkxPQ0tfTUFOQUdFUihlcGh5X2VtYmVkX3NoZWxsX2dldF9hZGJsb2NrX21hbmFnZXIgKGVt YmVkX3NoZWxsKSk7CisKKyAgaWYoIWVwaHlfYWRibG9ja19tYW5hZ2VyX3Nob3VsZF9sb2FkKGFk YmxvY2tfbWFuYWdlciwgZW1iZWQsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShyZXF1 ZXN0KSwgQURfVVJJX0NIRUNLX1RZUEVfT1RIRVIpKSB7CisgICAgZ19kZWJ1ZygiQmxvY2tlZDog JXMiLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkocmVxdWVzdCkpOworICAgIHdlYmtp dF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShyZXF1ZXN0LCAiYWJvdXQ6YmxhbmsiKTsKKyAgfQor fQorCitzdGF0aWMgdm9pZAogbG9hZF9zdGF0dXNfY2hhbmdlZF9jYiAoV2ViS2l0V2ViVmlldyAq dmlldywKICAgICAgICAgICAgICAgICAgICAgICAgIEdQYXJhbVNwZWMgKnNwZWMsCiAgICAgICAg ICAgICAgICAgICAgICAgICBFcGh5RW1iZWQgKmVtYmVkKQpAQCAtNjc0LDYgKzY5MCw3IEBAIGVw aHlfZW1iZWRfY29uc3RydWN0ZWQgKEdPYmplY3QgKm9iamVjdCkKIAogICBnX29iamVjdF9jb25u ZWN0ICh3ZWJfdmlldywKICAgICAgICAgICAgICAgICAgICAgInNpZ25hbDo6bm90aWZ5Ojpsb2Fk LXN0YXR1cyIsIEdfQ0FMTEJBQ0sgKGxvYWRfc3RhdHVzX2NoYW5nZWRfY2IpLCBlbWJlZCwKKyAg ICAgICAgICAgICAgICAgICAgInNpZ25hbDo6b3V0Z29pbmctcmVxdWVzdCIsIEdfQ0FMTEJBQ0sg KG91dGdvaW5nX3JlcXVlc3RfY2IpLCBlbWJlZCwKICAgICAgICAgICAgICAgICAgICAgInNpZ25h bDo6aG92ZXJpbmctb3Zlci1saW5rIiwgR19DQUxMQkFDSyAoaG92ZXJpbmdfb3Zlcl9saW5rX2Ni KSwgZW1iZWQsCiAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6Om1pbWUtdHlwZS1wb2xpY3kt ZGVjaXNpb24tcmVxdWVzdGVkIiwgR19DQUxMQkFDSyAobWltZV90eXBlX3BvbGljeV9kZWNpc2lv bl9yZXF1ZXN0ZWRfY2IpLCBlbWJlZCwKICAgICAgICAgICAgICAgICAgICAgInNpZ25hbDo6ZG93 bmxvYWQtcmVxdWVzdGVkIiwgR19DQUxMQkFDSyAoZG93bmxvYWRfcmVxdWVzdGVkX2NiKSwgZW1i ZWQsCg== 32134 2009-07-01 12:51:49 -0700 2009-09-04 07:15:10 -0700 Map the willSendRequest delegate to the 'outgoing-request' signal Map-the-willSendRequest-delegate-to-the-outgoing-request-signal.patch text/plain 10826 gustavo ZjI0ZjE0MGY1MzIwNzg0NzE5YTI4NDhjMTU4NGY0YjBkYjRhYzAyNApkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGMzNTYwMjgu LjA4YTk2MzQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wNy0wMSAgR3VzdGF2byBOb3Jv bmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjY4NTQKKyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFs bG93IG1vcmUgY29udHJvbCBvdmVyIG91dGdvaW5nIHJlcXVlc3RzCisKKyAgICAgICAgRW5hYmxl IHR3byB0ZXN0cyB0aGF0IHByb2R1Y2UgdGhlIGV4cGVjdGVkIHJlc3VsdHMgd2l0aCB0aGUKKyAg ICAgICAgY2hhbmdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2d0ay9Ta2lwcGVkOgorCiAyMDA5 LTA2LTMwICBYYW4gTG9wZXogIDx4bG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBTa2lwIG5l dyBlZGl0aW5nIHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1Nr aXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRleCAzODJlNmJmLi41 N2Q4ZmQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAorKysg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAtMzg0OCw5ICszODQ4LDcgQEAg aHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1l dGEtdGFnLWluLWJvZHkuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gt ZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLXBhcmVudC1zYW1lLW9yaWdpbi1hbGxvdy5odG1s CiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLWRlbnkt bWV0YS10YWctcGFyZW50LXNhbWUtb3JpZ2luLWRlbnkuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0 eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLmh0bWwKLWh0dHAv dGVzdHMvc2VjdXJpdHkvWEZyYW1lT3B0aW9ucy94LWZyYW1lLW9wdGlvbnMtZGVueS5odG1sCiBo dHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLXBhcmVudC1z YW1lLW9yaWdpbi1hbGxvdy5odG1sCi1odHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMv eC1mcmFtZS1vcHRpb25zLXBhcmVudC1zYW1lLW9yaWdpbi1kZW55Lmh0bWwKIGh0dHAvdGVzdHMv c2VjdXJpdHkvYWJvdXRCbGFuay9zZWN1cml0eS1jb250ZXh0LWdyYW5kY2hpbGRyZW4uaHRtbAog aHR0cC90ZXN0cy9zZWN1cml0eS9hYm91dEJsYW5rL3NlY3VyaXR5LWNvbnRleHQtd2luZG93LW9w ZW4uaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9hYm91dEJsYW5rL3dpbmRvdy1vcGVuLXNlbGYt YWJvdXQtYmxhbmsuaHRtbApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJL aXQvZ3RrL0NoYW5nZUxvZwppbmRleCBmZDQzZWQ2Li40YjE3YTdlIDEwMDY0NAotLS0gYS9XZWJL aXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIw IEBACisyMDA5LTA3LTAxICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFA Y29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAor ICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29p bmcgcmVxdWVzdHMKKworICAgICAgICBNYXAgdGhlIHdpbGxTZW5kUmVxdWVzdCBkZWxlZ2F0ZSB0 byB0aGUgJ291dGdvaW5nLXJlcXVlc3QnIHNpZ25hbCwKKyAgICAgICAgYWxsb3dpbmcgbW9yZSBj b250cm9sIG9mIHRoZSBmZXRjaGluZyBvZiByZXNvdXJjZXMuCisKKyAgICAgICAgKiBXZWJDb3Jl U3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OkZyYW1l TG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExvYWRpbmcpOgorICAgICAgICAoV2ViS2l0 OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVlc3QpOgorICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19jbGFz c19pbml0KToKKyAgICAgICAgKiB3ZWJraXRtYXJzaGFsLmxpc3Q6CisKIDIwMDktMDYtMjkgIFhh biBMb3BleiAgPHhsb3BlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEphbiBB bG9uem8uCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCmluZGV4IGYwNzc2ZjkuLmMxNjc0OTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC0yNTQsOSArMjU0LDE2 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkQ2FuY2VsQXV0aGVudGljYXRp b25DaGFsbGVuZ2UoRG9jdW1lbnRMb2FkZXIqCiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAot dm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVlc3QoRG9jdW1lbnRM b2FkZXIqLCB1bnNpZ25lZCBsb25nLCBSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBSZXNvdXJjZVJl c3BvbnNlJikKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNlbmRSZXF1ZXN0 KERvY3VtZW50TG9hZGVyKiwgdW5zaWduZWQgbG9uZyBpZGVudGlmaWVyLCBSZXNvdXJjZVJlcXVl c3QmIHJlcXVlc3QsIGNvbnN0IFJlc291cmNlUmVzcG9uc2UmKQogewotICAgIG5vdEltcGxlbWVu dGVkKCk7CisgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdGcm9tRnJhbWUobV9m cmFtZSk7CisgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0gd2Via2l0 X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVxdWVzdCk7CisKKyAgICBn X3NpZ25hbF9lbWl0X2J5X25hbWUod2ViVmlldywgIm91dGdvaW5nLXJlcXVlc3QiLCBtX2ZyYW1l LCBpZGVudGlmaWVyLCBuZXR3b3JrUmVxdWVzdCk7CisKKyAgICAvLyBGZWVkIGFueSBjaGFuZ2Vz IGJhY2sgaW50byB0aGUgUmVzb3VyY2VSZXF1ZXN0IG9iamVjdC4KKyAgICByZXF1ZXN0ID0gY29y ZShuZXR3b3JrUmVxdWVzdCk7CisgICAgZ19vYmplY3RfdW5yZWYobmV0d29ya1JlcXVlc3QpOwog fQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojphc3NpZ25JZGVudGlmaWVyVG9Jbml0aWFsUmVx dWVzdCh1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIERvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVz b3VyY2VSZXF1ZXN0JikKQEAgLTg2MCw3ICs4NjcsOSBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 OjpkaXNwYXRjaERpZFJlY2VpdmVDb250ZW50TGVuZ3RoKERvY3VtZW50TG9hZGVyKiwgdW5zaWdu ZQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExvYWRpbmcoRG9j dW1lbnRMb2FkZXIqLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIpCiB7Ci0gICAgbm90SW1wbGVt ZW50ZWQoKTsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZSht X2ZyYW1lKTsKKworICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAiZmluaXNoZWQt cmVxdWVzdCIsIG1fZnJhbWUsIGlkZW50aWZpZXIpOwogfQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50OjpkaXNwYXRjaERpZEZhaWxMb2FkaW5nKERvY3VtZW50TG9hZGVyKiwgdW5zaWduZWQgbG9u ZyBpZGVudGlmaWVyLCBjb25zdCBSZXNvdXJjZUVycm9yJiBlcnJvcikKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAKaW5kZXggNWIxOTg1Ni4uNGU5Y2U2YSAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAKQEAgLTE0MSw2ICsxNDEsOCBAQCBlbnVtIHsKICAgICBNT1ZFX0NVUlNP UiwKICAgICBQUklOVF9SRVFVRVNURUQsCiAgICAgUExVR0lOX1dJREdFVCwKKyAgICBPVVRHT0lO R19SRVFVRVNULAorICAgIEZJTklTSEVEX1JFUVVFU1QsCiAgICAgTEFTVF9TSUdOQUwKIH07CiAK QEAgLTE3MTUsNiArMTcxNyw1NiBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfY2xhc3Nf aW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdlYlZpZXdDbGFzcykKICAgICAgICAgICAgIEdUS19U WVBFX1dJREdFVCwgMywKICAgICAgICAgICAgIEdfVFlQRV9TVFJJTkcsIEdfVFlQRV9TVFJJTkcs IEdfVFlQRV9IQVNIX1RBQkxFKTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdlYlZpZXc6Om91 dGdvaW5nLXJlcXVlc3Q6CisgICAgICogQHdlYl92aWV3OiB0aGUgb2JqZWN0IHdoaWNoIHJlY2Vp dmVkIHRoZSBzaWduYWwKKyAgICAgKiBAd2ViX2ZyYW1lOiB0aGUgI1dlYktpdFdlYkZyYW1lIHdo b3NlIGxvYWQgZGlzcGF0Y2hlZCB0aGlzIHJlcXVlc3QKKyAgICAgKiBAaWRlbnRpZmllcjogYSBu dW1lcmljIGlkZW50aWZpZXIgZm9yIHRoZSByZXNvdXJjZSB0aGF0IGlzCisgICAgICogYmVpbmcg bG9hZGVkOyBpbiB0aGUgZnV0dXJlIHlvdSB3aWxsIGJlIGFibGUgdG8gdXNlIGl0IHdpdGggdGhl CisgICAgICogRGF0YVNvdXJjZSBBUEksIHRvIHRyYWNrIHJlc291cmNlIGxvYWRpbmcKKyAgICAg KiBAcmVxdWVzdDogdGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdCB0aGF0IHdpbGwgYmUgZGlzcGF0 Y2hlZAorICAgICAqCisgICAgICogRW1pdHRlZCB3aGVuIGEgcmVxdWVzdCBpcyBhYm91dCB0byBi ZSBzZW50LiBZb3UgY2FuIG1vZGlmeSB0aGUKKyAgICAgKiByZXF1ZXN0LCBieSBhZGRpbmcvcmVt b3ZpbmcvcmVwbGFjaW5nIGhlYWRlcnMsIG9yIGNoYW5naW5nIHRoZQorICAgICAqIFVSSSwgdXNp bmcgdGhlICNTb3VwTWVzc2FnZSBvYmplY3QgaXQgY2FycmllcywgaWYgaXQgaXMKKyAgICAgKiBw cmVzZW50LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZSgpLgorICAgICAq CisgICAgICogU2luY2U6IDEuMS4xMQorICAgICAqLworICAgIHdlYmtpdF93ZWJfdmlld19zaWdu YWxzW09VVEdPSU5HX1JFUVVFU1RdID0gZ19zaWduYWxfbmV3KCJvdXRnb2luZy1yZXF1ZXN0IiwK KyAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCisgICAgICAgICAg ICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisg ICAgICAgICAgICAwLAorICAgICAgICAgICAgTlVMTCwgTlVMTCwKKyAgICAgICAgICAgIHdlYmtp dF9tYXJzaGFsX1ZPSURfX09CSkVDVF9VTE9OR19PQkpFQ1QsCisgICAgICAgICAgICBHX1RZUEVf Tk9ORSwgMywKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9GUkFNRSwKKyAgICAgICAgICAg IEdfVFlQRV9VTE9ORywKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX05FVFdPUktfUkVRVUVTVCk7 CisKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJWaWV3OjpmaW5pc2hlZC1yZXF1ZXN0OgorICAg ICAqIEB3ZWJfdmlldzogdGhlIG9iamVjdCB3aGljaCByZWNlaXZlZCB0aGUgc2lnbmFsCisgICAg ICogQHdlYl9mcmFtZTogdGhlICNXZWJLaXRXZWJGcmFtZSB3aG9zZSBsb2FkIGRpc3BhdGNoZWQg dGhpcyByZXF1ZXN0CisgICAgICogQGlkZW50aWZpZXI6IGEgbnVtZXJpYyBpZGVudGlmaWVyIGZv ciB0aGUgcmVzb3VyY2UgdGhhdCBpcworICAgICAqIGJlaW5nIGxvYWRlZDsgaW4gdGhlIGZ1dHVy ZSB5b3Ugd2lsbCBiZSBhYmxlIHRvIHVzZSBpdCB3aXRoIHRoZQorICAgICAqIERhdGFTb3VyY2Ug QVBJLCB0byB0cmFjayByZXNvdXJjZSBsb2FkaW5nCisgICAgICoKKyAgICAgKiBUaGlzIGlzIGVt aXR0ZWQgd2hlbiBhIHJlcXVlc3QgZm9yIGEgcmVzb3VyY2UgaGFzIGJlZW4KKyAgICAgKiBmaW5p c2hlZCwgbWVhbmluZyB0aGF0IHRoZSByZXNvdXJjZSBoYXMgYmVlbiBsb2FkZWQuCisgICAgICoK KyAgICAgKiBTaW5jZTogMS4xLjExCisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25h bHNbRklOSVNIRURfUkVRVUVTVF0gPSBnX3NpZ25hbF9uZXcoImZpbmlzaGVkLXJlcXVlc3QiLAor ICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNzKSwKKyAgICAgICAgICAg IChHU2lnbmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdOQUxfQUNUSU9OKSwKKyAg ICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLCBOVUxMLAorICAgICAgICAgICAgd2Via2l0 X21hcnNoYWxfVk9JRF9fT0JKRUNUX1VMT05HLAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDIs CisgICAgICAgICAgICBXRUJLSVRfVFlQRV9XRUJfRlJBTUUsCisgICAgICAgICAgICBHX1RZUEVf VUxPTkcpOworCiAgICAgLyoKICAgICAgKiBpbXBsZW1lbnRhdGlvbnMgb2YgdmlydHVhbCBtZXRo b2RzCiAgICAgICovCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdCBi L1dlYktpdC9ndGsvd2Via2l0bWFyc2hhbC5saXN0CmluZGV4IGFhMGQ0MGMuLmU0Mjc3YjQgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0bWFyc2hhbC5saXN0CisrKyBiL1dlYktpdC9ndGsv d2Via2l0bWFyc2hhbC5saXN0CkBAIC0xNSw1ICsxNSw3IEBAIE9CSkVDVDpWT0lECiBWT0lEOk9C SkVDVCxPQkpFQ1QKIFZPSUQ6T0JKRUNULFBPSU5URVIsUE9JTlRFUgogVk9JRDpPQkpFQ1QsU1RS SU5HCitWT0lEOk9CSkVDVCxVTE9ORworVk9JRDpPQkpFQ1QsVUxPTkcsT0JKRUNUCiBWT0lEOlNU UklORwogVk9JRDpTVFJJTkcsU1RSSU5HCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VM b2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5kZXggNGNlMWVmNC4uYmFkN2Q4NyAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpA QCAtMSwzICsxLDE4IEBACisyMDA5LTA3LTAxICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0 YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9s IG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAgICAgICBBZGQgYSB2ZXJ5IGJhc2ljIGltcGxl bWVudGF0aW9uIG9mIHRoZSByZXNvdXJjZSBsb2FkaW5nIGRlbGVnYXRlcworICAgICAgICBkdW1w aW5nLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcDoK KyAgICAgICAgKHdlYlZpZXdPdXRnb2luZ1JlcXVlc3QpOgorICAgICAgICAod2ViVmlld0Zpbmlz aGVkUmVxdWVzdCk6CisgICAgICAgIChtYWluKToKKwogMjAwOS0wNi0zMCAgRXJpYyBTZWlkZWwg IDxlcmljQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFjaWVqIFN0YWNob3dp YWsuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRl clRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVl LmNwcAppbmRleCBhYmRlY2Y2Li5lNjBlNzMwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTUyOSw2ICs1MjksNDQgQEAgc3Rh dGljIHZvaWQgd2ViVmlld1N0YXR1c0JhclRleHRDaGFuZ2VkKFdlYktpdFdlYlZpZXcqIHZpZXcs IGNvbnN0IGdjaGFyKiBtZXNzYWcKICAgICB9CiB9CiAKKy8vIEZJWE1FOiB0ZXN0cyB0aGF0IHVz ZSB3aWxsU2VuZFJlcXVlc3QgYXJlIHRvbyBDRk5ldHdvcmstY2VudHJpYzsgd2UKKy8vIHNob3Vs ZCBtYWtlIHRoZW0gbW9yZSBnZW5lcmljCitzdGF0aWMgdm9pZCB3ZWJWaWV3T3V0Z29pbmdSZXF1 ZXN0KFdlYktpdFdlYlZpZXcqIHZpZXcsIFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgZ3Vsb25nIGlk ZW50aWZpZXIsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBncG9pbnRlciBkYXRhKQor eworICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdlID0gd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRf bWVzc2FnZShyZXF1ZXN0KTsKKyAgICBjaGFyKiB1cmkgPSBtZXNzYWdlID8gc291cF91cmlfdG9f c3RyaW5nKHNvdXBfbWVzc2FnZV9nZXRfdXJpKG1lc3NhZ2UpLCBGQUxTRSkgOiBnX3N0cmR1cCh3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF91cmkocmVxdWVzdCkpOworICAgIGNvbnN0IGNoYXIq IHJlZmVyZXIgPSBOVUxMOworCisgICAgaWYgKG1lc3NhZ2UpCisgICAgICAgIHJlZmVyZXIgPSBz b3VwX21lc3NhZ2VfaGVhZGVyc19nZXRfb25lIChtZXNzYWdlLT5yZXF1ZXN0X2hlYWRlcnMsICJS ZWZlcmVyIik7CisKKyAgICBpZiAoIWRvbmUgJiYgZ0xheW91dFRlc3RDb250cm9sbGVyLT5kdW1w UmVzb3VyY2VMb2FkQ2FsbGJhY2tzKCkpIHsKKyAgICAgICAgLy8gRklYTUU6IGhhbmRsZSByZXNw b25zZSBjb3JyZWN0bHkgaGVyZSEKKyAgICAgICAgcHJpbnRmICgiJXMgLSB3aWxsU2VuZFJlcXVl c3QgPE5TVVJMUmVxdWVzdCBVUkwgJXMsIG1haW4gZG9jdW1lbnQgVVJMICVzPiByZWRpcmVjdFJl c3BvbnNlIChudWxsKVxuIiwgdXJpLCB1cmksIHJlZmVyZXIpOworICAgIH0KKworICAgIFNvdXBV UkkqIHNvdXBVUkkgPSBzb3VwX3VyaV9uZXcodXJpKTsKKworICAgIGlmICgoIWdfYXNjaWlfc3Ry Y2FzZWNtcCgiaHR0cCIsIHNvdXBVUkktPnNjaGVtZSkgfHwgIWdfYXNjaWlfc3RyY2FzZWNtcCgi aHR0cHMiLCBzb3VwVVJJLT5zY2hlbWUpKQorICAgICAgICAmJiBnX2FzY2lpX3N0cmNhc2VjbXAo IjEyNy4wLjAuMSIsIHNvdXBVUkktPmhvc3QpCisgICAgICAgICYmIGdfYXNjaWlfc3RyY2FzZWNt cCgiMjU1LjI1NS4yNTUuMjU1Iiwgc291cFVSSS0+aG9zdCkKKyAgICAgICAgJiYgZ19hc2NpaV9z dHJjYXNlY21wKCJsb2NhbGhvc3QiLCBzb3VwVVJJLT5ob3N0KSkgeworICAgICAgICBwcmludGYo IkJsb2NrZWQgYWNjZXNzIHRvIGV4dGVybmFsIFVSTCAlc1xuIiwgdXJpKTsKKyAgICAgICAgd2Vi a2l0X25ldHdvcmtfcmVxdWVzdF9zZXRfdXJpKHJlcXVlc3QsICJhYm91dDpibGFuayIpOworICAg IH0KKworICAgIGdfZnJlZSh1cmkpOworICAgIHNvdXBfdXJpX2ZyZWUoc291cFVSSSk7Cit9CisK K3N0YXRpYyB2b2lkIHdlYlZpZXdGaW5pc2hlZFJlcXVlc3QoV2ViS2l0V2ViVmlldyogdmlldywg V2ViS2l0V2ViRnJhbWUqIGZyYW1lLCBndWxvbmcgaWRlbnRpZmllciwgZ3BvaW50ZXIgZGF0YSkK K3sKKyAgICAvLyBGSVhNRTogPHVua25vd24+IGhlcmUgaXMsIG9uIE1hYywgdGhlIHN0cmluZyBy ZXByZXNlbnRhdGlvbiBvZgorICAgIC8vIHRoZSBvYmplY3QgdGhlIGlkZW50aWZpZXIgbWFwcyB0 bworICAgIGlmICghZG9uZSAmJiBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBSZXNvdXJjZUxv YWRDYWxsYmFja3MoKSkKKyAgICAgICAgcHJpbnRmICgiPHVua25vd24+IC0gZGlkRmluaXNoTG9h ZGluZ1xuIik7Cit9CisKIGludCBtYWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiB7CiAgICAg Z190aHJlYWRfaW5pdChOVUxMKTsKQEAgLTU3Miw2ICs2MTAsOCBAQCBpbnQgbWFpbihpbnQgYXJn YywgY2hhciogYXJndltdKQogICAgIGdfc2lnbmFsX2Nvbm5lY3QoR19PQkpFQ1Qod2ViVmlldyks ICJ0aXRsZS1jaGFuZ2VkIiwgR19DQUxMQkFDSyh3ZWJWaWV3VGl0bGVDaGFuZ2VkKSwgMCk7CiAg ICAgZ19zaWduYWxfY29ubmVjdChHX09CSkVDVCh3ZWJWaWV3KSwgIm5hdmlnYXRpb24tcG9saWN5 LWRlY2lzaW9uLXJlcXVlc3RlZCIsIEdfQ0FMTEJBQ0sod2ViVmlld05hdmlnYXRpb25Qb2xpY3lE ZWNpc2lvblJlcXVlc3RlZCksIDApOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QoR19PQkpFQ1Qod2Vi VmlldyksICJzdGF0dXMtYmFyLXRleHQtY2hhbmdlZCIsIEdfQ0FMTEJBQ0sod2ViVmlld1N0YXR1 c0JhclRleHRDaGFuZ2VkKSwgMCk7CisgICAgZ19zaWduYWxfY29ubmVjdChHX09CSkVDVCh3ZWJW aWV3KSwgIm91dGdvaW5nLXJlcXVlc3QiLCBHX0NBTExCQUNLKHdlYlZpZXdPdXRnb2luZ1JlcXVl c3QpLCAwKTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KEdfT0JKRUNUKHdlYlZpZXcpLCAiZmluaXNo ZWQtcmVxdWVzdCIsIEdfQ0FMTEJBQ0sod2ViVmlld0ZpbmlzaGVkUmVxdWVzdCksIDApOwogCiAg ICAgc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRTdGF0ZVZhbHVlc0ZvclRlc3RpbmcoKTsKIAo= 39055 2009-09-04 07:15:10 -0700 2009-09-04 08:51:53 -0700 first draft post-DS 0001-New-signals-to-better-handle-resource-loading.patch text/plain 29503 gustavo RnJvbSA5ZjhlNjZiM2FlNDA4ZGEyOWM4ZjAzN2UyZTZkOGQzMWE1OGFhZDc5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFdlZCwgMiBTZXAgMjAwOSAxNTo1NDoxMSAtMDMwMApT dWJqZWN0OiBbUEFUQ0hdIE5ldyBzaWduYWxzIHRvIGJldHRlciBoYW5kbGUgcmVzb3VyY2UgbG9h ZGluZwoKLS0tCiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgMTIgKysKIExheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkICAgICAgICAg ICAgICAgICAgIHwgICAgMiAtCiBXZWJLaXQvZ3RrL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTcgKysrCiBXZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcCB8ICAgNzEgKysrKysrKysrLQogV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKwogV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwICAgICAgICAgICAgfCAgMTM4ICsrKysrKysrKysr KysrKysrKy0tCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5oICAgICAgICAg ICAgICB8ICAgMjEgKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCAgICAg ICAgICAgICAgICB8ICAgNjMgKysrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlz dCAgICAgICAgICAgICAgICAgICAgICB8ICAgIDQgKwogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE1ICsrCiBXZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwICB8ICAgNDMgKysrKysrCiBXZWJLaXRUb29s cy9HdGtMYXVuY2hlci9tYWluLmMgICAgICAgICAgICAgICAgICAgICB8ICAgMzMgKysrKysKIDEy IGZpbGVzIGNoYW5nZWQsIDQxNiBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5k ZXggZDkyOTBmMi4uMTFhMDE5MCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisr KyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA5LTAyICBH dXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVk cyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAg ICAgICBFbmFibGUgdHdvIHRlc3RzIHRoYXQgcHJvZHVjZSB0aGUgZXhwZWN0ZWQgcmVzdWx0cyB3 aXRoIHRoZQorICAgICAgICBjaGFuZ2VzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBw ZWQ6CisKIDIwMDktMDktMDMgIERyZXcgV2lsc29uICA8YXR3aWxzb25AZ29vZ2xlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBEYXZlIExldmluLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv cGxhdGZvcm0vZ3RrL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApp bmRleCA4NDdmNDEwLi5kYmMzMjgyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9n dGsvU2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAtMzc1 MCw5ICszNzUwLDcgQEAgaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUt b3B0aW9ucy1kZW55LW1ldGEtdGFnLWluLWJvZHkuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9Y RnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLXBhcmVudC1zYW1lLW9y aWdpbi1hbGxvdy5odG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFt ZS1vcHRpb25zLWRlbnktbWV0YS10YWctcGFyZW50LXNhbWUtb3JpZ2luLWRlbnkuaHRtbAogaHR0 cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEt dGFnLmh0bWwKLWh0dHAvdGVzdHMvc2VjdXJpdHkvWEZyYW1lT3B0aW9ucy94LWZyYW1lLW9wdGlv bnMtZGVueS5odG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1v cHRpb25zLXBhcmVudC1zYW1lLW9yaWdpbi1hbGxvdy5odG1sCi1odHRwL3Rlc3RzL3NlY3VyaXR5 L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLXBhcmVudC1zYW1lLW9yaWdpbi1kZW55Lmh0 bWwKIGh0dHAvdGVzdHMvc2VjdXJpdHkvbGlzdGVuZXIveHNzLXdpbmRvdy1vbmNsaWNrLWFkZEV2 ZW50TGlzdGVuZXIuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9saXN0ZW5lci94c3Mtd2luZG93 LW9uY2xpY2stc2hvcnRjdXQuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS94c3NBdWRpdG9yL2xp bmstb3BlbnMtbmV3LXdpbmRvdy5odG1sCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxv ZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IGY3Mjg4ZWEuLjRkYTZlOWIgMTAwNjQ0Ci0t LSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMjAgQEAKKzIwMDktMDktMDIgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8u bm9yb25oYUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI2ODU0CisgICAgICAgIFtHVEtdIE5lZWRzIEFQSSB0byBhbGxvdyBtb3JlIGNvbnRyb2wgb3Zl ciBvdXRnb2luZyByZXF1ZXN0cworCisgICAgICAgIE1hcCB0aGUgd2lsbFNlbmRSZXF1ZXN0IGRl bGVnYXRlIHRvIHRoZSAnb3V0Z29pbmctcmVxdWVzdCcgc2lnbmFsLAorICAgICAgICBhbGxvd2lu ZyBtb3JlIGNvbnRyb2wgb2YgdGhlIGZldGNoaW5nIG9mIHJlc291cmNlcy4KKworICAgICAgICAq IFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktp dDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkRmluaXNoTG9hZGluZyk6CisgICAgICAg IChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVzdCk6Cisg ICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAod2Via2l0X3dlYl92 aWV3X2NsYXNzX2luaXQpOgorICAgICAgICAqIHdlYmtpdG1hcnNoYWwubGlzdDoKKwogMjAwOS0w OS0wMyAgWGFuIExvcGV6ICA8eGxvcGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgR3VzdGF2byBOb3JvbmhhLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCA5MmFmYTJhLi4zOTA3MzQ0IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysg Yi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAt MjMsNiArMjMsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVy Q2xpZW50R3RrLmgiCiAKKyNpbmNsdWRlICJBcmNoaXZlUmVzb3VyY2UuaCIKICNpbmNsdWRlICJD b2xvci5oIgogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRM b2FkZXJHdGsuaCIKQEAgLTE4MSwxNSArMTgyLDUwIEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6 OmRpc3BhdGNoRGlkQ2FuY2VsQXV0aGVudGljYXRpb25DaGFsbGVuZ2UoV2ViQ29yZTo6RG9jdW1l CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KIAorLy8gV2UgY29udmVydCB0aGlzIHRvIHN0cmlu ZyBiZWNhdXNlIGl0J3MgZWFzaWVyIHRvIHVzZSBzdHJpbmdzIGFzCisvLyBrZXlzIGluIGEgR0hh c2hUYWJsZS4KK3N0YXRpYyBjaGFyKiBpZGVudGlmaWVyVG9TdHJpbmcodW5zaWduZWQgbG9uZyBp ZGVudGlmaWVyKQoreworICAgIHJldHVybiBnX3N0cmR1cF9wcmludGYoIiVsZCIsIGlkZW50aWZp ZXIpOworfQorCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVz dChXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9hZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZp ZXIsIFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVk aXJlY3RSZXNwb25zZSkKIHsKKyAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zy b21GcmFtZShtX2ZyYW1lKTsKKworICAgIEdPd25QdHI8Z2NoYXI+IGlkZW50aWZpZXJTdHJpbmco aWRlbnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBXZWJLaXRXZWJSZXNvdXJjZSog d2ViUmVzb3VyY2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291cmNlKHdlYlZpZXcsIGlkZW50 aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAgLy8gV2UgYXJlIGFkZGluZyBvbmUgbW9yZSByZXNv dXJjZSB0byB0aGUgbG9hZCwgb3IgbWF5YmUgd2UgYXJlCisgICAgLy8ganVzdCByZWRpcmVjdGlu ZyBhIGxvYWQsIGluIHdoaWNoIGNhc2Ugd2UgbmVlZCB0byB1cGRhdGUgb3VyCisgICAgLy8gV2Vi S2l0V2ViUmVzb3VyY2UncyBrbm93bGVkZ2Ugb2YgdGhlIFVSSS4KICAgICBpZiAocmVkaXJlY3RS ZXNwb25zZS5pc051bGwoKSkKICAgICAgICAgc3RhdGljX2Nhc3Q8V2ViS2l0OjpEb2N1bWVudExv YWRlcio+KGxvYWRlciktPmluY3JlYXNlTG9hZENvdW50KGlkZW50aWZpZXIpOworICAgIGVsc2Ug eworICAgICAgICBnX2ZyZWUod2ViUmVzb3VyY2UtPnByaXYtPnVyaSk7CisgICAgICAgIHdlYlJl c291cmNlLT5wcml2LT51cmkgPSBnX3N0cmR1cChyZXF1ZXN0LnVybCgpLnN0cmluZygpLnV0Zjgo KS5kYXRhKCkpOworICAgIH0KKworICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBuZXR3b3JrUmVx dWVzdCA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVl c3QpOworCisgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlZpZXcsICJyZXNvdXJjZS1yZXF1 ZXN0LXN0YXJ0aW5nIiwgbV9mcmFtZSwgd2ViUmVzb3VyY2UsIG5ldHdvcmtSZXF1ZXN0KTsKKwor ICAgIC8vIEZlZWQgYW55IGNoYW5nZXMgYmFjayBpbnRvIHRoZSBSZXNvdXJjZVJlcXVlc3Qgb2Jq ZWN0LgorICAgIHJlcXVlc3QgPSBjb3JlKG5ldHdvcmtSZXF1ZXN0KTsKKyAgICBnX29iamVjdF91 bnJlZihuZXR3b3JrUmVxdWVzdCk7CiB9CiAKLXZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmFzc2ln bklkZW50aWZpZXJUb0luaXRpYWxSZXF1ZXN0KHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgV2Vi Q29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXNvdXJjZVJlcXVlc3QmKQordm9pZCBGcmFt ZUxvYWRlckNsaWVudDo6YXNzaWduSWRlbnRpZmllclRvSW5pdGlhbFJlcXVlc3QodW5zaWduZWQg bG9uZyBpZGVudGlmaWVyLCBXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNl UmVxdWVzdCYgcmVxdWVzdCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIFdlYktpdFdl YlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IFdFQktJVF9XRUJfUkVTT1VSQ0UoZ19vYmplY3RfbmV3 KFdFQktJVF9UWVBFX1dFQl9SRVNPVVJDRSwgMCkpOworCisgICAgLy8gVGhlIFVSSSBpcyBpbXBv cnRhbnQgdG8gaGF2ZSBpbiB0aGUgcmVzb3VyY2UgYmVjYXVzZSB0aGF0IGlzIHdoYXQgd2UgdXNl CisgICAgLy8gdG8gZmV0Y2ggdGhlIFdlYkNvcmUgb2JqZWN0LCBsYXRlciBvbi4gV2UgdXNlIHRo ZSBwcml2YXRlIHN0cnVjdHVyZQorICAgIC8vIGRpcmVjdGx5IGhlcmUgdG8gYXZvaWQgY2hhbmdp bmcgdGhlIHByb3BlcnR5IG1vZGUgZnJvbSBSRUFEQUJMRSB0bworICAgIC8vIFJFQURXUklURS4K KyAgICB3ZWJSZXNvdXJjZS0+cHJpdi0+dXJpID0gZ19zdHJkdXAocmVxdWVzdC51cmwoKS5zdHJp bmcoKS51dGY4KCkuZGF0YSgpKTsKKworICAgIHdlYmtpdF93ZWJfdmlld19hZGRfcmVzb3VyY2Uo Z2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKSwgaWRlbnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIp LCB3ZWJSZXNvdXJjZSk7CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnBvc3RQcm9ncmVz c1N0YXJ0ZWROb3RpZmljYXRpb24oKQpAQCAtNzgyLDIxICs4MTgsNDQgQEAgdm9pZCBGcmFtZUxv YWRlckNsaWVudDo6c2V0VGl0bGUoY29uc3QgU3RyaW5nJiB0aXRsZSwgY29uc3QgS1VSTCYgdXJs KQogICAgIGZyYW1lRGF0YS0+dGl0bGUgPSBnX3N0cmR1cCh0aXRsZS51dGY4KCkuZGF0YSgpKTsK IH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRSZWNlaXZlQ29udGVudExl bmd0aChXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwg aW50IGxlbmd0aFJlY2VpdmVkKQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRS ZWNlaXZlQ29udGVudExlbmd0aChXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9hZGVyLCB1bnNp Z25lZCBsb25nIGlkZW50aWZpZXIsIGludCBsZW5ndGhSZWNlaXZlZCkKIHsKLSAgICBub3RJbXBs ZW1lbnRlZCgpOworICAgIEdPd25QdHI8Z2NoYXI+IGlkZW50aWZpZXJTdHJpbmcoaWRlbnRpZmll clRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3Vy Y2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291cmNlKGdldFZpZXdGcm9tRnJhbWUobV9mcmFt ZSksIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAgd2ViUmVzb3VyY2UtPnByaXYtPmxv YWRTdGF0dXMgPSBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9MT0FESU5HOworICAgIGdfb2JqZWN0X25v dGlmeShHX09CSkVDVCh3ZWJSZXNvdXJjZSksICJsb2FkLXN0YXR1cyIpOwogfQogCiB2b2lkIEZy YW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExvYWRpbmcoV2ViQ29yZTo6RG9jdW1l bnRMb2FkZXIqIGxvYWRlciwgdW5zaWduZWQgbG9uZyBpZGVudGlmaWVyKQogewogICAgIHN0YXRp Y19jYXN0PFdlYktpdDo6RG9jdW1lbnRMb2FkZXIqPihsb2FkZXIpLT5kZWNyZWFzZUxvYWRDb3Vu dChpZGVudGlmaWVyKTsKKworICAgIEdPd25QdHI8Z2NoYXI+IGlkZW50aWZpZXJTdHJpbmcoaWRl bnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2Vi UmVzb3VyY2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291cmNlKGdldFZpZXdGcm9tRnJhbWUo bV9mcmFtZSksIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAgY29uc3QgY2hhciogdXJp ID0gd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKHdlYlJlc291cmNlKTsKKyAgICBSZWZQdHI8 QXJjaGl2ZVJlc291cmNlPiBjb3JlUmVzb3VyY2UobG9hZGVyLT5zdWJyZXNvdXJjZShLVVJMKEtV UkwoKSwgdXJpKSkpOworICAgIHdlYmtpdF93ZWJfcmVzb3VyY2VfaW5pdF93aXRoX2NvcmVfcmVz b3VyY2Uod2ViUmVzb3VyY2UsIGNvcmVSZXNvdXJjZS5nZXQoKSk7CisKKyAgICB3ZWJSZXNvdXJj ZS0+cHJpdi0+bG9hZFN0YXR1cyA9IFdFQktJVF9SRVNPVVJDRV9MT0FEX0ZJTklTSEVEOworICAg IGdfb2JqZWN0X25vdGlmeShHX09CSkVDVCh3ZWJSZXNvdXJjZSksICJsb2FkLXN0YXR1cyIpOwor CisgICAgd2Via2l0X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJjZShnZXRWaWV3RnJvbUZyYW1lKG1f ZnJhbWUpLCBpZGVudGlmaWVyU3RyaW5nLmdldCgpKTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6ZGlzcGF0Y2hEaWRGYWlsTG9hZGluZyhXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9h ZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9y KQogewotICAgIC8vIEZJWE1FOiB3aGVuIGRvZXMgdGhpcyBvY2N1ciBhbmQgd2hhdCBzaG91bGQg aGFwcGVuPwotCiAgICAgc3RhdGljX2Nhc3Q8V2ViS2l0OjpEb2N1bWVudExvYWRlcio+KGxvYWRl ciktPmRlY3JlYXNlTG9hZENvdW50KGlkZW50aWZpZXIpOworCisgICAgR093blB0cjxnY2hhcj4g aWRlbnRpZmllclN0cmluZyhpZGVudGlmaWVyVG9TdHJpbmcoaWRlbnRpZmllcikpOworICAgIFdl YktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IHdlYmtpdF93ZWJfdmlld19nZXRfcmVzb3Vy Y2UoZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKSwgaWRlbnRpZmllclN0cmluZy5nZXQoKSk7CisK KyAgICBHRXJyb3IqIHdlYkVycm9yID0gZ19lcnJvcl9uZXdfbGl0ZXJhbChnX3F1YXJrX2Zyb21f c3RyaW5nKGVycm9yLmRvbWFpbigpLnV0ZjgoKS5kYXRhKCkpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yLmVycm9yQ29kZSgpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yLmxvY2FsaXplZERlc2NyaXB0aW9u KCkudXRmOCgpLmRhdGEoKSk7CisgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlJlc291cmNl LCAibG9hZC1lcnJvciIsIGVycm9yLmZhaWxpbmdVUkwoKS51dGY4KCkuZGF0YSgpLCB3ZWJFcnJv cik7CisgICAgZ19lcnJvcl9mcmVlKHdlYkVycm9yKTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6ZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VCeVhNTEh0dHBSZXF1ZXN0KHVuc2lnbmVkIGxv bmcsIGNvbnN0IFNjcmlwdFN0cmluZyYpCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXgg YmQyYTBiOS4uMmY1MTQzNSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMTMyLDYg KzEzMiw4IEBAIGV4dGVybiAiQyIgewogCiAgICAgICAgIGdib29sZWFuIGRpc3Bvc2luZzsKICAg ICAgICAgZ2Jvb2xlYW4gdXNlUHJpbWFyeUZvclBhc3RlOworCisgICAgICAgIEdIYXNoVGFibGUq IHN1YlJlc291cmNlczsKICAgICB9OwogCiAgICAgI2RlZmluZSBXRUJLSVRfV0VCX0ZSQU1FX0dF VF9QUklWQVRFKG9iaikgICAgKEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgob2JqKSwgV0VC S0lUX1RZUEVfV0VCX0ZSQU1FLCBXZWJLaXRXZWJGcmFtZVByaXZhdGUpKQpAQCAtMTc3LDkgKzE3 OSwxNCBAQCBleHRlcm4gIkMiIHsKICAgICAgICAgZ2NoYXIqIGZyYW1lTmFtZTsKIAogICAgICAg ICBHU3RyaW5nKiBkYXRhOworCisgICAgICAgIFdlYktpdFJlc291cmNlTG9hZFN0YXR1cyBsb2Fk U3RhdHVzOwogICAgIH07CiAgICAgV2ViS2l0V2ViUmVzb3VyY2UqCiAgICAgd2Via2l0X3dlYl9y ZXNvdXJjZV9uZXdfd2l0aF9jb3JlX3Jlc291cmNlKFBhc3NSZWZQdHI8V2ViQ29yZTo6QXJjaGl2 ZVJlc291cmNlPik7CisKKyAgICB2b2lkCisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9pbml0X3dp dGhfY29yZV9yZXNvdXJjZShXZWJLaXRXZWJSZXNvdXJjZSosIFBhc3NSZWZQdHI8V2ViQ29yZTo6 QXJjaGl2ZVJlc291cmNlPik7CiAgICAgLy8gZW5kIFdlYktpdFdlYlJlc291cmNlIHByaXZhdGUK IAogICAgIHZvaWQKQEAgLTIwMCw2ICsyMDcsMTUgQEAgZXh0ZXJuICJDIiB7CiAgICAgdm9pZAog ICAgIHdlYmtpdF93ZWJfdmlld19yZXF1ZXN0X2Rvd25sb2FkKFdlYktpdFdlYlZpZXcqIHdlYl92 aWV3LCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXNwb25zZSYgcmVzcG9uc2UgPSBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlKCksIFdlYkNv cmU6OlJlc291cmNlSGFuZGxlKiBoYW5kbGUgPSAwKTsKIAorICAgIHZvaWQKKyAgICB3ZWJraXRf d2ViX3ZpZXdfYWRkX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqLCBjaGFyKiwgV2ViS2l0V2ViUmVz b3VyY2UqKTsKKworICAgIFdlYktpdFdlYlJlc291cmNlKgorICAgIHdlYmtpdF93ZWJfdmlld19n ZXRfcmVzb3VyY2UoV2ViS2l0V2ViVmlldyosIGNoYXIqKTsKKworICAgIHZvaWQKKyAgICB3ZWJr aXRfd2ViX3ZpZXdfcmVtb3ZlX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqLCBjaGFyKik7CisKICAg ICBXZWJLaXREb3dubG9hZCoKICAgICB3ZWJraXRfZG93bmxvYWRfbmV3X3dpdGhfaGFuZGxlKFdl YktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZSogaGFu ZGxlLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSk7CiAKZGlmZiAt LWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAppbmRleCBjMTYyNTc4Li43NzRlNjNlIDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAKKysrIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwCkBAIC0yNyw2ICsyNyw4IEBA CiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVk ZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgiCisjaW5jbHVk ZSAid2Via2l0bWFyc2hhbC5oIgogI2luY2x1ZGUgInd0Zi9Bc3NlcnRpb25zLmgiCiAKICNpbmNs dWRlIDxnbGliLmg+CkBAIC00NSwxNyArNDcsNDcgQEAgdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7 CiB1c2luZyBuYW1lc3BhY2UgV2ViS2l0OwogCiBlbnVtIHsKKyAgICBMT0FEX0VSUk9SLAorICAg IExBU1RfU0lHTkFMCit9OworCitlbnVtIHsKICAgICBQUk9QXzAsCiAKICAgICBQUk9QX1VSSSwK ICAgICBQUk9QX01JTUVfVFlQRSwKICAgICBQUk9QX0VOQ09ESU5HLAotICAgIFBST1BfRlJBTUVf TkFNRQorICAgIFBST1BfRlJBTUVfTkFNRSwKKyAgICBQUk9QX0xPQURfU1RBVFVTCiB9OwogCitz dGF0aWMgZ3VpbnQgd2Via2l0X3dlYl9yZXNvdXJjZV9zaWduYWxzW0xBU1RfU0lHTkFMXSA9IHsg MCwgfTsKKwogR19ERUZJTkVfVFlQRShXZWJLaXRXZWJSZXNvdXJjZSwgd2Via2l0X3dlYl9yZXNv dXJjZSwgR19UWVBFX09CSkVDVCk7CiAKIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2Vf Z2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVlKiB2YWx1 ZSwgR1BhcmFtU3BlYyogcHNwZWMpOworc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9z ZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBjb25zdCBHVmFsdWUq IHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYyk7CisKK3N0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVz b3VyY2VfY2xlYW51cChXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UpCit7CisgICAgV2Vi S2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7CisKKyAgICBn X2ZyZWUocHJpdi0+dXJpKTsKKyAgICBwcml2LT51cmkgPSBOVUxMOworCisgICAgZ19mcmVlKHBy aXYtPm1pbWVUeXBlKTsKKyAgICBwcml2LT5taW1lVHlwZSA9IE5VTEw7CisKKyAgICBnX2ZyZWUo cHJpdi0+dGV4dEVuY29kaW5nKTsKKyAgICBwcml2LT50ZXh0RW5jb2RpbmcgPSBOVUxMOworCisg ICAgZ19mcmVlKHByaXYtPmZyYW1lTmFtZSk7CisgICAgcHJpdi0+ZnJhbWVOYW1lID0gTlVMTDsK KworICAgIGlmIChwcml2LT5kYXRhKQorICAgICAgICBnX3N0cmluZ19mcmVlKHByaXYtPmRhdGEs IFRSVUUpOworICAgIHByaXYtPmRhdGEgPSBOVUxMOworfQogCiBzdGF0aWMgdm9pZCB3ZWJraXRf d2ViX3Jlc291cmNlX2Rpc3Bvc2UoR09iamVjdCogb2JqZWN0KQogewpAQCAtNzMsMTUgKzEwNSw4 IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfZGlzcG9zZShHT2JqZWN0KiBvYmpl Y3QpCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2ZpbmFsaXplKEdPYmplY3QqIG9i amVjdCkKIHsKICAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VC X1JFU09VUkNFKG9iamVjdCk7Ci0gICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0g d2ViUmVzb3VyY2UtPnByaXY7CiAKLSAgICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAgICBnX2ZyZWUo cHJpdi0+bWltZVR5cGUpOwotICAgIGdfZnJlZShwcml2LT50ZXh0RW5jb2RpbmcpOwotICAgIGdf ZnJlZShwcml2LT5mcmFtZU5hbWUpOwotCi0gICAgaWYgKHByaXYtPmRhdGEpCi0gICAgICAgIGdf c3RyaW5nX2ZyZWUocHJpdi0+ZGF0YSwgVFJVRSk7CisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9j bGVhbnVwKHdlYlJlc291cmNlKTsKIAogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF93ZWJfcmVz b3VyY2VfcGFyZW50X2NsYXNzKS0+ZmluYWxpemUob2JqZWN0KTsKIH0KQEAgLTkzLDYgKzExOCwy OCBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2NsYXNzX2luaXQoV2ViS2l0V2Vi UmVzb3VyY2VDbGFzcyoga2xhc3MpCiAgICAgZ29iamVjdF9jbGFzcy0+ZGlzcG9zZSA9IHdlYmtp dF93ZWJfcmVzb3VyY2VfZGlzcG9zZTsKICAgICBnb2JqZWN0X2NsYXNzLT5maW5hbGl6ZSA9IHdl YmtpdF93ZWJfcmVzb3VyY2VfZmluYWxpemU7CiAgICAgZ29iamVjdF9jbGFzcy0+Z2V0X3Byb3Bl cnR5ID0gd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfcHJvcGVydHk7CisgICAgZ29iamVjdF9jbGFz cy0+c2V0X3Byb3BlcnR5ID0gd2Via2l0X3dlYl9yZXNvdXJjZV9zZXRfcHJvcGVydHk7CisKKyAg ICAvKioKKyAgICAgKiBXZWJLaXRXZWJSZXNvdXJjZTo6bG9hZC1lcnJvcgorICAgICAqIEB3ZWJf cmVzb3VyY2U6IHRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ugd2hpY2ggZmFpbGVkIHRvIGxvYWQKKyAg ICAgKiBAdXJpOiB0aGUgVVJJIGZyb20gd2hpY2ggdGhlIHJlc291cmNlIHdhcyBiZWluZyBsb2Fk ZWQKKyAgICAgKiBAd2ViX2Vycm9yOiB0aGUgI0dFcnJvciB0aGF0IHdhcyB0cmlnZ2VyZWQKKyAg ICAgKgorICAgICAqIEFuIGVycm9yIG9jY3VycmVkIHdoaWxlIGxvYWRpbmcgdGhpcyByZXNvdXJj ZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICB3ZWJraXRfd2Vi X3Jlc291cmNlX3NpZ25hbHNbTE9BRF9FUlJPUl0gPSBnX3NpZ25hbF9uZXcoImxvYWQtZXJyb3Ii LAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Moa2xhc3MpLAorICAgICAgICAgICAgKEdT aWduYWxGbGFncylHX1NJR05BTF9SVU5fTEFTVCwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAg ICBOVUxMLAorICAgICAgICAgICAgTlVMTCwKKyAgICAgICAgICAgIHdlYmtpdF9tYXJzaGFsX1ZP SURfX1NUUklOR19QT0lOVEVSLAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDIsCisgICAgICAg ICAgICBHX1RZUEVfU1RSSU5HLAorICAgICAgICAgICAgR19UWVBFX1BPSU5URVIpOwogCiAgICAg LyoqCiAgICAgICogV2ViS2l0V2ViUmVzb3VyY2U6dXJpOgpAQCAtMTU2LDkgKzIwMyw0MCBAQCBz dGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2NsYXNzX2luaXQoV2ViS2l0V2ViUmVzb3Vy Y2VDbGFzcyoga2xhc3MpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxM LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURB QkxFKSk7CiAKKyAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJSZXNvdXJjZTpsb2FkLXN0YXR1czoK KyAgICAgKgorICAgICAqIERldGVybWluZXMgdGhlIGN1cnJlbnQgc3RhdHVzIG9mIHRoZSBsb2Fk IGZvciB0aGlzIHJlc291cmNlLgorICAgICAqCisgICAgICogU2luY2U6IDEuMS4xNAorICAgICAq LworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVydHkoZ29iamVjdF9jbGFzcywgUFJP UF9MT0FEX1NUQVRVUywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFy YW1fc3BlY19lbnVtKCJsb2FkLXN0YXR1cyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiTG9hZCBTdGF0dXMiLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIkRldGVybWluZXMgdGhlIGN1 cnJlbnQgc3RhdHVzIG9mIHRoZSBsb2FkIGZvciB0aGlzIHJlc291cmNlIiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9UWVBFX1JF U09VUkNFX0xPQURfU1RBVFVTLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgV0VCS0lUX1JFU09VUkNFX0xPQURfTk9UX1NUQVJURUQsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRf UEFSQU1fUkVBREFCTEUpKTsKKwogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShnb2JqZWN0 X2NsYXNzLCBzaXplb2YoV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKSk7CiB9CiAKK3N0YXRpYyB2 b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2Vfc2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3Vp bnQgcHJvcF9pZCwgY29uc3QgR1ZhbHVlKiB2YWx1ZSwgR1BhcmFtU3BlYyogcHNwZWMpCit7Cisg ICAgV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlID0gV0VCS0lUX1dFQl9SRVNPVVJDRShv YmplY3QpOworICAgIFdlYktpdFdlYlJlc291cmNlUHJpdmF0ZSogcHJpdiA9IHdlYlJlc291cmNl LT5wcml2OworCisgICAgc3dpdGNoIChwcm9wX2lkKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAg ICAgICAgLy8gU2hvdWxkIGJlIGdvb2Qgc2luY2UgdGhlIHByb3BlcnR5IGlzIENPTlNUUlVDVF9P TkxZCisgICAgICAgIHByaXYtPnVyaSA9IGdfdmFsdWVfZHVwX3N0cmluZyh2YWx1ZSk7CisgICAg ICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5WQUxJRF9Q Uk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKKyAgICAgICAgYnJlYWs7CisgICAg fQorfQorCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9wcm9wZXJ0eShHT2Jq ZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBz cGVjKQogewogICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IFdFQktJVF9XRUJf UkVTT1VSQ0Uob2JqZWN0KTsKQEAgLTE3Niw2ICsyNTQsOSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRf d2ViX3Jlc291cmNlX2dldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQs IEdWYQogICAgIGNhc2UgUFJPUF9GUkFNRV9OQU1FOgogICAgICAgICBnX3ZhbHVlX3NldF9zdHJp bmcodmFsdWUsIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2ZyYW1lX25hbWUod2ViUmVzb3VyY2Up KTsKICAgICAgICAgYnJlYWs7CisgICAgY2FzZSBQUk9QX0xPQURfU1RBVFVTOgorICAgICAgICBn X3ZhbHVlX3NldF9lbnVtKHZhbHVlLCB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1 cyh3ZWJSZXNvdXJjZSkpOworICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBH X09CSkVDVF9XQVJOX0lOVkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7 CiAgICAgICAgIGJyZWFrOwpAQCAtMTk3LDYgKzI3OCwxOCBAQCBXZWJLaXRXZWJSZXNvdXJjZSog d2Via2l0X3dlYl9yZXNvdXJjZV9uZXdfd2l0aF9jb3JlX3Jlc291cmNlKFBhc3NSZWZQdHI8QXJj aGl2ZQogICAgIHJldHVybiB3ZWJSZXNvdXJjZTsKIH0KIAordm9pZCB3ZWJraXRfd2ViX3Jlc291 cmNlX2luaXRfd2l0aF9jb3JlX3Jlc291cmNlKFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJj ZSwgUGFzc1JlZlB0cjxBcmNoaXZlUmVzb3VyY2U+IHJlc291cmNlKQoreworICAgIFdlYktpdFdl YlJlc291cmNlUHJpdmF0ZSogcHJpdiA9IHdlYlJlc291cmNlLT5wcml2OworCisgICAgaWYgKHBy aXYtPnJlc291cmNlKQorICAgICAgICBwcml2LT5yZXNvdXJjZS0+ZGVyZWYoKTsKKworICAgIHdl YmtpdF93ZWJfcmVzb3VyY2VfY2xlYW51cCh3ZWJSZXNvdXJjZSk7CisKKyAgICBwcml2LT5yZXNv dXJjZSA9IHJlc291cmNlLnJlbGVhc2VSZWYoKTsKK30KKwogLyoqCiAgKiB3ZWJraXRfd2ViX3Jl c291cmNlX25ldzoKICAqIEBkYXRhOiB0aGUgZGF0YSB0byBpbml0aWFsaXplIHRoZSAjV2ViS2l0 V2ViUmVzb3VyY2UKQEAgLTI3MCwxMSArMzYzLDE0IEBAIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3 ZWJraXRfd2ViX3Jlc291cmNlX2dldF91cmkoV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNl CiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9SRVNPVVJDRSh3ZWJSZXNv dXJjZSksIE5VTEwpOwogCiAgICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2Vi UmVzb3VyY2UtPnByaXY7CisKKyAgICBpZiAocHJpdi0+dXJpKQorICAgICAgICByZXR1cm4gcHJp di0+dXJpOworCiAgICAgaWYgKCFwcml2LT5yZXNvdXJjZSkKICAgICAgICAgcmV0dXJuIE5VTEw7 CiAKLSAgICBpZiAoIXByaXYtPnVyaSkKLSAgICAgICAgcHJpdi0+dXJpID0gZ19zdHJkdXAocHJp di0+cmVzb3VyY2UtPnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIHByaXYtPnVy aSA9IGdfc3RyZHVwKHByaXYtPnJlc291cmNlLT51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKIAogICAgIHJldHVybiBwcml2LT51cmk7CiB9CkBAIC0yOTEsMTAgKzM4NywxMiBAQCBHX0NP TlNUX1JFVFVSTiBnY2hhciogd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfbWltZV90eXBlKFdlYktp dFdlYlJlc291cmNlKiB3ZWJSZQogewogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9J U19XRUJfUkVTT1VSQ0Uod2ViUmVzb3VyY2UpLCBOVUxMKTsKIAorICAgIGdfZGVidWcoImdldF9t aW1lX3R5cGUiKTsKICAgICBXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUqIHByaXYgPSB3ZWJSZXNv dXJjZS0+cHJpdjsKICAgICBpZiAoIXByaXYtPnJlc291cmNlKQogICAgICAgICByZXR1cm4gTlVM TDsKIAorICAgIGdfZGVidWcoInJlc291cmNlISIpOwogICAgIGlmICghcHJpdi0+bWltZVR5cGUp CiAgICAgICAgIHByaXYtPm1pbWVUeXBlID0gZ19zdHJkdXAocHJpdi0+cmVzb3VyY2UtPm1pbWVU eXBlKCkudXRmOCgpLmRhdGEoKSk7CiAKQEAgLTM0NCwzICs0NDIsMjEgQEAgR19DT05TVF9SRVRV Uk4gZ2NoYXIqIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2ZyYW1lX25hbWUoV2ViS2l0V2ViUmVz b3VyY2UqIHdlYlIKIAogICAgIHJldHVybiBwcml2LT5mcmFtZU5hbWU7CiB9CisKKy8qKgorICog d2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfbG9hZF9zdGF0dXM6CisgKiBAd2ViX3Jlc291cmNlOiBh ICNXZWJLaXRXZWJSZXNvdXJjZQorICoKKyAqIERldGVybWluZXMgdGhlIGN1cnJlbnQgc3RhdHVz IG9mIHRoZSBsb2FkIGZvciB0aGlzIHJlc291cmNlCisgKgorICogUmV0dXJuIHZhbHVlOiBhICNX ZWJLaXRSZXNvdXJjZUxvYWRTdGF0dXMKKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KK1dlYktp dFJlc291cmNlTG9hZFN0YXR1cyB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1cyhX ZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2Zh aWwoV0VCS0lUX0lTX1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSksIFdFQktJVF9SRVNPVVJDRV9M T0FEX05PVF9TVEFSVEVEKTsKKworICAgIFdlYktpdFdlYlJlc291cmNlUHJpdmF0ZSogcHJpdiA9 IHdlYlJlc291cmNlLT5wcml2OworICAgIHJldHVybiBwcml2LT5sb2FkU3RhdHVzOworfQpkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuaCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmgKaW5kZXggMjZhMDQ1OC4uMjkxMDdkZSAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuaAorKysgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5oCkBAIC0zNiw2ICszNiwyNCBAQCBHX0JF R0lOX0RFQ0xTCiAKIHR5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUgV2Vi S2l0V2ViUmVzb3VyY2VQcml2YXRlOwogCisvKioKKyAqIFdlYktpdFJlc291cmNlTG9hZFN0YXR1 cworICogQFdFQktJVF9SRVNPVVJDRV9MT0FEX05PVF9TVEFSVEVEOiB0aGUgcmVzb3VyY2UgaXMg anVzdCBhIHN0dWIsCisgKiBub3RoaW5nIGhhcyBhcnJpdmVkIGZyb20gdGhlIG5ldHdvcmsgeWV0 CisgKiBAV0VCS0lUX1JFU09VUkNFX0xPQURfTE9BRElORzogdGhlIHJlc291cmNlIGFscmVhZHkg aGFzIHNvbWUgZGF0YSwKKyAqIGFuZCB3aWxsIHN0aWxsIHJlY2VpdmUgc29tZSBtb3JlOyB0aGUg YWN0dWFsIGRhdGEgb25seSBiZWNvbWVzCisgKiBhdmFpbGFibGUgd2hlbiB0aGUgbG9hZCBpcyBm aW5pc2hlZAorICogQFdFQktJVF9SRVNPVVJDRV9MT0FEX0ZJTklTSEVEOiB0aGUgcmVzb3VyY2Ug aXMgZG9uZSBsb2FkaW5nLCB0aGUKKyAqIGRhdGEsIGFuZCB0aGUgbWV0YWRhdGEgYXJlIG5vdyBh dmFpbGFibGUgdG8gYmUgZmV0Y2hlZCBmcm9tIHRoZQorICogb2JqZWN0LCBpZiBhbiBlcnJvciBo YXMgbm90IGhhcHBlbmVkLCBhbmQgV2ViS2l0IHdpbGwgbm8gbG9uZ2VyCisgKiBoYXZlIGEgcmVm ZXJlbmNlIHRvIHRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ugb2JqZWN0CisgKi8KK3R5cGVkZWYgZW51 bSB7CisgICAgV0VCS0lUX1JFU09VUkNFX0xPQURfTk9UX1NUQVJURUQsCisgICAgV0VCS0lUX1JF U09VUkNFX0xPQURfTE9BRElORywKKyAgICBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9GSU5JU0hFRCwK K30gV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzOworCiBzdHJ1Y3QgX1dlYktpdFdlYlJlc291cmNl IHsKICAgICBHT2JqZWN0IHBhcmVudF9pbnN0YW5jZTsKIApAQCAtNzksNiArOTcsOSBAQCB3ZWJr aXRfd2ViX3Jlc291cmNlX2dldF9lbmNvZGluZyAgICAgICAgICAgKFdlYktpdFdlYlJlc291cmNl ICAqd2ViX3Jlc291cmNlKTsKIFdFQktJVF9BUEkgR19DT05TVF9SRVRVUk4gZ2NoYXIgKgogd2Vi a2l0X3dlYl9yZXNvdXJjZV9nZXRfZnJhbWVfbmFtZSAgICAgICAgIChXZWJLaXRXZWJSZXNvdXJj ZSAgKndlYl9yZXNvdXJjZSk7CiAKK1dFQktJVF9BUEkgV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVz Cit3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1cyAgICAgICAgKFdlYktpdFdlYlJl c291cmNlICAqd2ViX3Jlc291cmNlKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmIC8qIFdFQktJ VF9XRUJfUkVTT1VSQ0VfSCAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCA0 YzhmY2ExLi4xOWEzMGFkIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtMTQ0 LDYgKzE0NCw3IEBAIGVudW0gewogICAgIENMT1NFX1dFQl9WSUVXLAogICAgIFVORE8sCiAgICAg UkVETywKKyAgICBSRVNPVVJDRV9SRVFVRVNUX1NUQVJUSU5HLAogICAgIExBU1RfU0lHTkFMCiB9 OwogCkBAIC05OTAsNiArOTkxLDExIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19kaXNw b3NlKEdPYmplY3QqIG9iamVjdCkKICAgICAgICAgcHJpdi0+cGFzdGVfdGFyZ2V0X2xpc3QgPSBO VUxMOwogICAgIH0KIAorICAgIGlmIChwcml2LT5zdWJSZXNvdXJjZXMpIHsKKyAgICAgICAgZ19o YXNoX3RhYmxlX3VucmVmKHByaXYtPnN1YlJlc291cmNlcyk7CisgICAgICAgIHByaXYtPnN1YlJl c291cmNlcyA9IE5VTEw7CisgICAgfQorCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X3dlYl92 aWV3X3BhcmVudF9jbGFzcyktPmRpc3Bvc2Uob2JqZWN0KTsKIH0KIApAQCAtMTk1Miw2ICsxOTU4 LDM1IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktpdFdlYlZp ZXdDbGFzcyogd2ViVmlld0NsYXNzKQogICAgICAgICAgICAgR1RLX1RZUEVfV0lER0VULCAzLAog ICAgICAgICAgICAgR19UWVBFX1NUUklORywgR19UWVBFX1NUUklORywgR19UWVBFX0hBU0hfVEFC TEUpOwogCisgICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6cmVzb3VyY2UtcmVxdWVzdC1z dGFydGluZzoKKyAgICAgKiBAd2ViX3ZpZXc6IHRoZSBvYmplY3Qgd2hpY2ggcmVjZWl2ZWQgdGhl IHNpZ25hbAorICAgICAqIEB3ZWJfZnJhbWU6IHRoZSAjV2ViS2l0V2ViRnJhbWUgd2hvc2UgbG9h ZCBkaXNwYXRjaGVkIHRoaXMgcmVxdWVzdAorICAgICAqIEB3ZWJfcmVzb3VyY2U6IGFuIGVtcHR5 ICNXZWJLaXRXZWJSZXNvdXJjZSBvYmplY3QKKyAgICAgKiBAcmVxdWVzdDogdGhlICNXZWJLaXRO ZXR3b3JrUmVxdWVzdCB0aGF0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAqCisgICAgICogRW1p dHRlZCB3aGVuIGEgcmVxdWVzdCBpcyBhYm91dCB0byBiZSBzZW50LiBZb3UgY2FuIG1vZGlmeSB0 aGUKKyAgICAgKiByZXF1ZXN0LCBieSBhZGRpbmcvcmVtb3ZpbmcvcmVwbGFjaW5nIGhlYWRlcnMs IG9yIGNoYW5naW5nIHRoZQorICAgICAqIFVSSSwgdXNpbmcgdGhlICNTb3VwTWVzc2FnZSBvYmpl Y3QgaXQgY2FycmllcywgaWYgaXQgaXMKKyAgICAgKiBwcmVzZW50LiBTZWUgd2Via2l0X25ldHdv cmtfcmVxdWVzdF9nZXRfbWVzc2FnZSgpLgorICAgICAqCisgICAgICogVGhlICNXZWJLaXRXZWJS ZXNvdXJjZSBvYmplY3Qgd2lsbCBiZSB0aGUgc2FtZSB0aHJvdWdob3V0IGFsbAorICAgICAqIHRo ZSBsaWZldGltZSBvZiB0aGUgcmVzb3VyY2UsIGJ1dCB0aGUgY29udGVudHMgbWF5IGNoYW5nZSBm cm9tCisgICAgICogaW5iZXR3ZWVuIHNpZ25hbCBlbWlzc2lvbnMuCisgICAgICoKKyAgICAgKiBT aW5jZTogMS4xLjE0CisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNbUkVTT1VS Q0VfUkVRVUVTVF9TVEFSVElOR10gPSBnX3NpZ25hbF9uZXcoInJlc291cmNlLXJlcXVlc3Qtc3Rh cnRpbmciLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNzKSwKKyAg ICAgICAgICAgIChHU2lnbmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdOQUxfQUNU SU9OKSwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLCBOVUxMLAorICAgICAgICAg ICAgd2Via2l0X21hcnNoYWxfVk9JRF9fT0JKRUNUX09CSkVDVF9PQkpFQ1QsCisgICAgICAgICAg ICBHX1RZUEVfTk9ORSwgMywKKyAgICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9GUkFNRSwKKyAg ICAgICAgICAgIFdFQktJVF9UWVBFX1dFQl9SRVNPVVJDRSwKKyAgICAgICAgICAgIFdFQktJVF9U WVBFX05FVFdPUktfUkVRVUVTVCk7CisKICAgICAvKgogICAgICAqIGltcGxlbWVudGF0aW9ucyBv ZiB2aXJ0dWFsIG1ldGhvZHMKICAgICAgKi8KQEAgLTI0OTEsNiArMjUyNiw4IEBAIHN0YXRpYyB2 b2lkIHdlYmtpdF93ZWJfdmlld19pbml0KFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCiAgICAgZ19z aWduYWxfY29ubmVjdChwcml2LT53ZWJTZXR0aW5ncywgIm5vdGlmeSIsIEdfQ0FMTEJBQ0sod2Vi a2l0X3dlYl92aWV3X3NldHRpbmdzX25vdGlmeSksIHdlYlZpZXcpOwogCiAgICAgcHJpdi0+d2Vi V2luZG93RmVhdHVyZXMgPSB3ZWJraXRfd2ViX3dpbmRvd19mZWF0dXJlc19uZXcoKTsKKworICAg IHByaXYtPnN1YlJlc291cmNlcyA9IGdfaGFzaF90YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBn X3N0cl9lcXVhbCwgZ19mcmVlLCBnX29iamVjdF91bnJlZik7CiB9CiAKIEd0a1dpZGdldCogd2Vi a2l0X3dlYl92aWV3X25ldyh2b2lkKQpAQCAtMzc3NiwzICszODEzLDI5IEBAIGdib29sZWFuIHdl YmtpdF93ZWJfdmlld19nZXRfdmlld19zb3VyY2VfbW9kZSAoV2ViS2l0V2ViVmlldyogd2ViVmll dykKIAogICAgIHJldHVybiBGQUxTRTsKIH0KKworLy8gSW50ZXJuYWwgc3VicmVzb3VyY2UgbWFu YWdlbWVudAordm9pZCB3ZWJraXRfd2ViX3ZpZXdfYWRkX3Jlc291cmNlKFdlYktpdFdlYlZpZXcq IHdlYldlYlZpZXcsIGNoYXIqIGlkZW50aWZpZXIsIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNv dXJjZSkKK3sKKyAgICBXZWJLaXRXZWJWaWV3UHJpdmF0ZSogcHJpdiA9IHdlYldlYlZpZXctPnBy aXY7CisgICAgZ19oYXNoX3RhYmxlX2luc2VydChwcml2LT5zdWJSZXNvdXJjZXMsIGlkZW50aWZp ZXIsIHdlYlJlc291cmNlKTsKK30KKworV2ViS2l0V2ViUmVzb3VyY2UqIHdlYmtpdF93ZWJfdmll d19nZXRfcmVzb3VyY2UoV2ViS2l0V2ViVmlldyogd2ViV2ViVmlldywgY2hhciogaWRlbnRpZmll cikKK3sKKyAgICBXZWJLaXRXZWJWaWV3UHJpdmF0ZSogcHJpdiA9IHdlYldlYlZpZXctPnByaXY7 CisgICAgV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlID0gTlVMTDsKKworICAgIGdib29s ZWFuIHJlc291cmNlRm91bmQgPSBnX2hhc2hfdGFibGVfbG9va3VwX2V4dGVuZGVkKHByaXYtPnN1 YlJlc291cmNlcywgaWRlbnRpZmllciwgTlVMTCwgcmVpbnRlcnByZXRfY2FzdDxncG9pbnRlcio+ KCZ3ZWJSZXNvdXJjZSkpOworCisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwocmVzb3VyY2VGb3Vu ZCwgTlVMTCk7CisKKyAgICByZXR1cm4gV0VCS0lUX1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSk7 Cit9CisKK3ZvaWQgd2Via2l0X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJjZShXZWJLaXRXZWJWaWV3 KiB3ZWJXZWJWaWV3LCBjaGFyKiBpZGVudGlmaWVyKQoreworICAgIFdlYktpdFdlYlZpZXdQcml2 YXRlKiBwcml2ID0gd2ViV2ViVmlldy0+cHJpdjsKKyAgICBnX2hhc2hfdGFibGVfcmVtb3ZlKHBy aXYtPnN1YlJlc291cmNlcywgaWRlbnRpZmllcik7Cit9CisKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0bWFyc2hhbC5saXN0IGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKaW5k ZXggYWEwZDQwYy4uZTVjMTg0NyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFs Lmxpc3QKKysrIGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKQEAgLTEzLDcgKzEzLDEx IEBAIE9CSkVDVDpPQkpFQ1QKIE9CSkVDVDpTVFJJTkcsU1RSSU5HLFBPSU5URVIKIE9CSkVDVDpW T0lECiBWT0lEOk9CSkVDVCxPQkpFQ1QKK1ZPSUQ6T0JKRUNULE9CSkVDVCxPQkpFQ1QKK1ZPSUQ6 T0JKRUNULFBPSU5URVIKIFZPSUQ6T0JKRUNULFBPSU5URVIsUE9JTlRFUgogVk9JRDpPQkpFQ1Qs U1RSSU5HCitWT0lEOk9CSkVDVCxVTE9ORwogVk9JRDpTVFJJTkcKIFZPSUQ6U1RSSU5HLFNUUklO RworVk9JRDpTVFJJTkcsUE9JTlRFUgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9n IGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDE4Y2RjYmUuLjIwMzgwOGEgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxOCBAQAorMjAwOS0wOS0wMiAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2 by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjY4NTQKKyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFsbG93IG1vcmUgY29udHJvbCBv dmVyIG91dGdvaW5nIHJlcXVlc3RzCisKKyAgICAgICAgQWRkIGEgdmVyeSBiYXNpYyBpbXBsZW1l bnRhdGlvbiBvZiB0aGUgcmVzb3VyY2UgbG9hZGluZyBkZWxlZ2F0ZXMKKyAgICAgICAgZHVtcGlu Zy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHA6Cisg ICAgICAgICh3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0KToKKyAgICAgICAgKHdlYlZpZXdGaW5pc2hl ZFJlcXVlc3QpOgorICAgICAgICAobWFpbik6CisKIDIwMDktMDktMDMgIEtldmluIFdhdHRlcnMg IDxrZXZpbndhdHRlcnNAZ21haWwuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtldmluIE9s bGl2aWVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBS ZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVy VHJlZS5jcHAKaW5kZXggYWY0NTM1OS4uMmQ3MjVmNSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC02MDAsNiArNjAwLDQ4IEBA IHN0YXRpYyBnYm9vbGVhbiB3ZWJWaWV3Q2xvc2UoV2ViS2l0V2ViVmlldyogdmlldykKIAogc3Rh dGljIFdlYktpdFdlYlZpZXcqIHdlYlZpZXdDcmVhdGUoV2ViS2l0V2ViVmlldyosIFdlYktpdFdl YkZyYW1lKik7CiAKK3N0YXRpYyB2b2lkIHdlYlJlc291cmNlTG9hZFN0YXR1c0NoYW5nZWQoR09i amVjdCogb2JqZWN0LCBHUGFyYW1TcGVjKiBwc3BlYywgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICAv LyBGSVhNRTogPHVua25vd24+IGhlcmUgaXMsIG9uIE1hYywgdGhlIHN0cmluZyByZXByZXNlbnRh dGlvbiBvZgorICAgIC8vIHRoZSBvYmplY3QgdGhlIGlkZW50aWZpZXIgbWFwcyB0bworICAgIGlm ICghZG9uZSAmJiBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBSZXNvdXJjZUxvYWRDYWxsYmFj a3MoKSkKKyAgICAgICAgcHJpbnRmICgiPHVua25vd24+IC0gZGlkRmluaXNoTG9hZGluZ1xuIik7 Cit9CisKKy8vIEZJWE1FOiB0ZXN0cyB0aGF0IHVzZSB3aWxsU2VuZFJlcXVlc3QgYXJlIHRvbyBD Rk5ldHdvcmstY2VudHJpYzsgd2UKKy8vIHNob3VsZCBtYWtlIHRoZW0gbW9yZSBnZW5lcmljCitz dGF0aWMgdm9pZCB3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0KFdlYktpdFdlYlZpZXcqIHZpZXcsIFdl YktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0V2ViUmVzb3VyY2UqIHJlc291cmNlLCBXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBTb3VwTWVzc2Fn ZSogbWVzc2FnZSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UocmVxdWVzdCk7 CisgICAgY2hhciogdXJpID0gbWVzc2FnZSA/IHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwX21lc3Nh Z2VfZ2V0X3VyaShtZXNzYWdlKSwgRkFMU0UpIDogZ19zdHJkdXAod2Via2l0X25ldHdvcmtfcmVx dWVzdF9nZXRfdXJpKHJlcXVlc3QpKTsKKyAgICBjb25zdCBjaGFyKiByZWZlcmVyID0gTlVMTDsK KworICAgIGlmIChtZXNzYWdlKQorICAgICAgICByZWZlcmVyID0gc291cF9tZXNzYWdlX2hlYWRl cnNfZ2V0X29uZSAobWVzc2FnZS0+cmVxdWVzdF9oZWFkZXJzLCAiUmVmZXJlciIpOworCisgICAg aWYgKCFkb25lICYmIGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcFJlc291cmNlTG9hZENhbGxi YWNrcygpKSB7CisgICAgICAgIC8vIEZJWE1FOiBoYW5kbGUgcmVzcG9uc2UgY29ycmVjdGx5IGhl cmUhCisgICAgICAgIHByaW50ZiAoIiVzIC0gd2lsbFNlbmRSZXF1ZXN0IDxOU1VSTFJlcXVlc3Qg VVJMICVzLCBtYWluIGRvY3VtZW50IFVSTCAlcywgaHR0cCBtZXRob2QgJXM+IHJlZGlyZWN0UmVz cG9uc2UgKG51bGwpXG4iLCB1cmksIHVyaSwgcmVmZXJlciwgbWVzc2FnZS0+bWV0aG9kKTsKKyAg ICB9CisKKyAgICBTb3VwVVJJKiBzb3VwVVJJID0gc291cF91cmlfbmV3KHVyaSk7CisKKyAgICBp ZiAoKCFnX2FzY2lpX3N0cmNhc2VjbXAoImh0dHAiLCBzb3VwVVJJLT5zY2hlbWUpIHx8ICFnX2Fz Y2lpX3N0cmNhc2VjbXAoImh0dHBzIiwgc291cFVSSS0+c2NoZW1lKSkKKyAgICAgICAgJiYgZ19h c2NpaV9zdHJjYXNlY21wKCIxMjcuMC4wLjEiLCBzb3VwVVJJLT5ob3N0KQorICAgICAgICAmJiBn X2FzY2lpX3N0cmNhc2VjbXAoIjI1NS4yNTUuMjU1LjI1NSIsIHNvdXBVUkktPmhvc3QpCisgICAg ICAgICYmIGdfYXNjaWlfc3RyY2FzZWNtcCgibG9jYWxob3N0Iiwgc291cFVSSS0+aG9zdCkpIHsK KyAgICAgICAgcHJpbnRmKCJCbG9ja2VkIGFjY2VzcyB0byBleHRlcm5hbCBVUkwgJXNcbiIsIHVy aSk7CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShyZXF1ZXN0LCAiYWJv dXQ6YmxhbmsiKTsKKyAgICB9CisKKyAgICBnX2ZyZWUodXJpKTsKKyAgICBzb3VwX3VyaV9mcmVl KHNvdXBVUkkpOworCisgICAgZ19zaWduYWxfY29ubmVjdChyZXNvdXJjZSwgIm5vdGlmeTo6bG9h ZC1zdGF0dXMiLAorICAgICAgICAgICAgICAgICAgICAgR19DQUxMQkFDSyh3ZWJSZXNvdXJjZUxv YWRTdGF0dXNDaGFuZ2VkKSwgMCk7CisKK30KKwogc3RhdGljIFdlYktpdFdlYlZpZXcqIGNyZWF0 ZVdlYlZpZXcoKQogewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVco d2Via2l0X3dlYl92aWV3X25ldygpKTsKQEAgLTYyMSw2ICs2NjMsNyBAQCBzdGF0aWMgV2ViS2l0 V2ViVmlldyogY3JlYXRlV2ViVmlldygpCiAgICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpz dGF0dXMtYmFyLXRleHQtY2hhbmdlZCIsIHdlYlZpZXdTdGF0dXNCYXJUZXh0Q2hhbmdlZCwgMCwK ICAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6OmNyZWF0ZS13ZWItdmlldyIsIHdlYlZpZXdD cmVhdGUsIDAsCiAgICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpjbG9zZS13ZWItdmlldyIs IHdlYlZpZXdDbG9zZSwgMCwKKyAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6OnJlc291cmNl LXJlcXVlc3Qtc3RhcnRpbmciLCB3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0LCAwLAogICAgICAgICAg ICAgICAgICAgICAgTlVMTCk7CiAKICAgICByZXR1cm4gdmlldzsKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4u YwppbmRleCA2OTk0Njc0Li43YjMxZWFhIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9HdGtMYXVu Y2hlci9tYWluLmMKKysrIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCkBAIC0xMDks NiArMTA5LDM4IEBAIGdvX2ZvcndhcmRfY2IgKEd0a1dpZGdldCogd2lkZ2V0LCBncG9pbnRlciBk YXRhKQogICAgIHdlYmtpdF93ZWJfdmlld19nb19mb3J3YXJkICh3ZWJfdmlldyk7CiB9CiAKK3N0 YXRpYyB2b2lkCitsb2FkX3N0YXR1c19jaGFuZ2VkX2NiKEdPYmplY3QqIG9iamVjdCwgR1BhcmFt U3BlYyogcHNwZWMsIGdwb2ludGVyIGRhdGEpCit7CisgICAgV2ViS2l0V2ViUmVzb3VyY2UqIHdl Yl9yZXNvdXJjZSA9IFdFQktJVF9XRUJfUkVTT1VSQ0UgKG9iamVjdCk7CisgICAgY29uc3QgY2hh ciogbWltZV90eXBlOworCisgICAgZ19kZWJ1ZyAoIm9iamVjdDogJXAgfCBuZXcgc3RhdHVzOiAl ZCIsIHdlYl9yZXNvdXJjZSwgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfbG9hZF9zdGF0dXMgKHdl Yl9yZXNvdXJjZSkpOworCisgICAgbWltZV90eXBlID0gd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRf bWltZV90eXBlKHdlYl9yZXNvdXJjZSk7CisgICAgZ19kZWJ1ZyAoIm1pbWU6ICVzIiwgbWltZV90 eXBlKTsKKworICAgIGlmIChtaW1lX3R5cGUgJiYgKGdfc3RyX2VxdWFsKCJ0ZXh0L2h0bWwiLCBt aW1lX3R5cGUpIHx8IGdfc3RyX2hhc19wcmVmaXgobWltZV90eXBlLCAidGV4dC8iKSkpCisgICAg ICAgIGdfZGVidWcgKCJmcmFtZSBuYW1lOiAlc1xuZGF0YTogJXMiLAorICAgICAgICAgICAgICAg ICB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9mcmFtZV9uYW1lKHdlYl9yZXNvdXJjZSksCisgICAg ICAgICAgICAgICAgIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2RhdGEod2ViX3Jlc291cmNlKS0+ c3RyKTsKK30KKworc3RhdGljIHZvaWQKK2xvYWRfZXJyb3JfY2IoV2ViS2l0V2ViUmVzb3VyY2Uq IHdlYl9yZXNvdXJjZSwgY29uc3QgY2hhciogdXJpLCBHRXJyb3IqIHdlYl9lcnJvcikKK3sKKyAg ICBnX2RlYnVnICgiRVJST1I6ICVzIHwgJXMiLCB1cmksIHdlYl9lcnJvci0+bWVzc2FnZSk7Cit9 CisKK3N0YXRpYyB2b2lkIG91dGdvaW5nX3JlcXVlc3RfY2IoV2ViS2l0V2ViVmlldyogd2ViX3Zp ZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJfZnJhbWUsIFdlYktpdFdlYlJlc291cmNlKiB3ZWJfcmVz b3VyY2UsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGdfZGVidWcgKCJc bk9VVEdPSU5HOiAlcCAvICVzIiwgd2ViX3Jlc291cmNlLCB3ZWJraXRfbmV0d29ya19yZXF1ZXN0 X2dldF91cmkgKHJlcXVlc3QpKTsKKyAgICBnX29iamVjdF9yZWYgKHdlYl9yZXNvdXJjZSk7CisK KyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYl9yZXNvdXJjZSwgIm5vdGlmeTo6bG9hZC1zdGF0dXMi LCBHX0NBTExCQUNLKGxvYWRfc3RhdHVzX2NoYW5nZWRfY2IpLCBOVUxMKTsKKyAgICBnX3NpZ25h bF9jb25uZWN0KHdlYl9yZXNvdXJjZSwgImxvYWQtZXJyb3IiLCBHX0NBTExCQUNLKGxvYWRfZXJy b3JfY2IpLCBOVUxMKTsKK30KKwogc3RhdGljIEd0a1dpZGdldCoKIGNyZWF0ZV9icm93c2VyICgp CiB7CkBAIC0xMjIsNiArMTU0LDcgQEAgY3JlYXRlX2Jyb3dzZXIgKCkKICAgICBnX3NpZ25hbF9j b25uZWN0ICh3ZWJfdmlldywgIm5vdGlmeTo6bG9hZC1zdGF0dXMiLCBHX0NBTExCQUNLIChub3Rp ZnlfbG9hZF9zdGF0dXNfY2IpLCB3ZWJfdmlldyk7CiAgICAgZ19zaWduYWxfY29ubmVjdCAod2Vi X3ZpZXcsICJub3RpZnk6OnByb2dyZXNzIiwgR19DQUxMQkFDSyAobm90aWZ5X3Byb2dyZXNzX2Ni KSwgd2ViX3ZpZXcpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKHdlYl92aWV3LCAiaG92ZXJpbmct b3Zlci1saW5rIiwgR19DQUxMQkFDSyAobGlua19ob3Zlcl9jYiksIHdlYl92aWV3KTsKKyAgICBn X3NpZ25hbF9jb25uZWN0ICh3ZWJfdmlldywgInJlc291cmNlLXJlcXVlc3Qtc3RhcnRpbmciLCBH X0NBTExCQUNLIChvdXRnb2luZ19yZXF1ZXN0X2NiKSwgd2ViX3ZpZXcpOwogCiAgICAgcmV0dXJu IHNjcm9sbGVkX3dpbmRvdzsKIH0KLS0gCjEuNi4zLjMKCg== 39061 2009-09-04 08:51:53 -0700 2009-09-04 12:11:28 -0700 second draft post-DS; hah, now with response 0001-New-signals-to-better-handle-resource-loading.patch text/plain 56362 gustavo RnJvbSAwNmFlMDZmZDNiMjg3ZmY3MWNmN2FiYzg4ZGYwMWM1MTEzNGE2ZDYwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFdlZCwgMiBTZXAgMjAwOSAxNTo1NDoxMSAtMDMwMApT dWJqZWN0OiBbUEFUQ0hdIE5ldyBzaWduYWxzIHRvIGJldHRlciBoYW5kbGUgcmVzb3VyY2UgbG9h ZGluZwoKLS0tCiBHTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgIDggKwogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDEyICsKIExheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkICAgICAg ICAgICAgICAgICAgIHwgICAgMiAtCiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXNwb25zZS5oICAgfCAgICA0ICsKIC4uLi9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXNwb25zZVNvdXAuY3BwIHwgICA1NSArKysrKwogV2ViS2l0L2d0ay9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE3ICsrCiBXZWJLaXQvZ3RrL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCB8ICAgNzkgKysrKysrLQogV2Vi S2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMgICAgICAgICAgICAgfCAgMTA4ICsr KysrKysrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmggICAgICAgICAgICAgICAgICAgICAg ICAgfCAgICAxICsKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaCAgICAgICAgICAg ICAgICAgIHwgICAgMyArCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5j cHAgICAgICAgICB8ICAgMTAgLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3Bv bnNlLmNwcCAgICAgICAgfCAgMjUzICsrKysrKysrKysrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCAgICAgICAgICB8ICAgNzQgKysrKysrCiBXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCAgICAgICAgICAgICAgICB8ICAgIDkgKwog V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oICAgICAgICAgICAgICAgICAgfCAgIDI2 ICsrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAgICAgICAgICAgICB8 ICAxMzYgKysrKysrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmgg ICAgICAgICAgICAgIHwgICAyMSArKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5j cHAgICAgICAgICAgICAgICAgfCAgIDc2ICsrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0bWFyc2hh bC5saXN0ICAgICAgICAgICAgICAgICAgICAgIHwgICAgNCArCiBXZWJLaXRUb29scy9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTUgKysKIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHAgIHwgICA0MyArKysrCiBXZWJLaXRU b29scy9HdGtMYXVuY2hlci9tYWluLmMgICAgICAgICAgICAgICAgICAgICB8ICAgNDEgKysrKwog MjMgZmlsZXMgY2hhbmdlZCwgOTY3IGluc2VydGlvbnMoKyksIDMxIGRlbGV0aW9ucygtKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVz cG9uc2VTb3VwLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9ndGsvdGVzdHMvdGVzdG5l dHdvcmtyZXNwb25zZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0bmV0d29ya3Jlc3BvbnNlLmNwcAogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCgpkaWZmIC0tZ2l0IGEvR05VbWFrZWZpbGUuYW0g Yi9HTlVtYWtlZmlsZS5hbQppbmRleCA1M2EwNGNkLi40N2RkZmI0IDEwMDY0NAotLS0gYS9HTlVt YWtlZmlsZS5hbQorKysgYi9HTlVtYWtlZmlsZS5hbQpAQCAtMzE5LDYgKzMxOSw3IEBAIHdlYmtp dGd0a19oX2FwaSArPSBcCiAJJChzcmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25s b2FkLmggXAogCSQoc3JjZGlyKS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRlcnJvci5oIFwKIAkk KHNyY2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaCBcCisJJChz cmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oIFwKIAkkKHNy Y2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuaCBcCiAJJChzcmNk aXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIFwKIAkkKHNy Y2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZGF0YXNvdXJjZS5oIFwKQEAgLTM2MCw2 ICszNjEsNyBAQCB3ZWJraXRndGtfc291cmNlcyArPSBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0ZG93bmxvYWQuY3BwIFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRlcnJvci5jcHAgXAog CVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBcCisJV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5jcHAgXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBc CiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuYyBcCkBAIC01MjcsNiAr NTI5LDcgQEAgd2Via2l0X3Rlc3RzX2xkZmxhZ3MgPSBcCiBURVNUX1BST0dTICs9IFByb2dyYW1z L3VuaXR0ZXN0cy90ZXN0aHR0cGJhY2tlbmQgXAogCVByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0bG9h ZGluZyBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3RuZXR3b3JrcmVxdWVzdCBcCisJUHJvZ3Jh bXMvdW5pdHRlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UgXAogCVByb2dyYW1zL3VuaXR0ZXN0cy90 ZXN0d2ViZnJhbWUgXAogCVByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0d2ViYmFja2ZvcndhcmRsaXN0 IFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdlYmhpc3RvcnlpdGVtIFwKQEAgLTU1Myw2ICs1 NTYsMTEgQEAgUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RuZXR3b3JrcmVxdWVzdF9DRkxBR1MgPSAk KHdlYmtpdF90ZXN0c19jZmxhZ3MpCiBQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXF1 ZXN0X0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCiBQcm9ncmFtc191bml0dGVzdHNfdGVz dG5ldHdvcmtyZXF1ZXN0X0xERkxBR1MgPSAkKHdlYmtpdF90ZXN0c19sZGZsYWdzKQogCitQcm9n cmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXNwb25zZV9TT1VSQ0VTID0gV2ViS2l0L2d0ay90 ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMKK1Byb2dyYW1zX3VuaXR0ZXN0c190ZXN0bmV0d29y a3Jlc3BvbnNlX0NGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2NmbGFncykKK1Byb2dyYW1zX3VuaXR0 ZXN0c190ZXN0bmV0d29ya3Jlc3BvbnNlX0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCitQ cm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXNwb25zZV9MREZMQUdTID0gJCh3ZWJraXRf dGVzdHNfbGRmbGFncykKKwogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3ZWJmcmFtZV9TT1VSQ0VT ID0gV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJhbWUuYwogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rl c3R3ZWJmcmFtZV9DRkxBR1MgPSAkKHdlYmtpdF90ZXN0c19jZmxhZ3MpCiBQcm9ncmFtc191bml0 dGVzdHNfdGVzdHdlYmZyYW1lX0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg ZDkyOTBmMi4uMTFhMDE5MCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBi L0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTA5LTAyICBHdXN0 YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVkcyBB UEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAgICAg ICBFbmFibGUgdHdvIHRlc3RzIHRoYXQgcHJvZHVjZSB0aGUgZXhwZWN0ZWQgcmVzdWx0cyB3aXRo IHRoZQorICAgICAgICBjaGFuZ2VzLgorCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1NraXBwZWQ6 CisKIDIwMDktMDktMDMgIERyZXcgV2lsc29uICA8YXR3aWxzb25AZ29vZ2xlLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBEYXZlIExldmluLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vZ3RrL1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRl eCA4NDdmNDEwLi5kYmMzMjgyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsv U2tpcHBlZAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAtMzc1MCw5 ICszNzUwLDcgQEAgaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0 aW9ucy1kZW55LW1ldGEtdGFnLWluLWJvZHkuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJh bWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLXBhcmVudC1zYW1lLW9yaWdp bi1hbGxvdy5odG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1v cHRpb25zLWRlbnktbWV0YS10YWctcGFyZW50LXNhbWUtb3JpZ2luLWRlbnkuaHRtbAogaHR0cC90 ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFn Lmh0bWwKLWh0dHAvdGVzdHMvc2VjdXJpdHkvWEZyYW1lT3B0aW9ucy94LWZyYW1lLW9wdGlvbnMt ZGVueS5odG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRp b25zLXBhcmVudC1zYW1lLW9yaWdpbi1hbGxvdy5odG1sCi1odHRwL3Rlc3RzL3NlY3VyaXR5L1hG cmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLXBhcmVudC1zYW1lLW9yaWdpbi1kZW55Lmh0bWwK IGh0dHAvdGVzdHMvc2VjdXJpdHkvbGlzdGVuZXIveHNzLXdpbmRvdy1vbmNsaWNrLWFkZEV2ZW50 TGlzdGVuZXIuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9saXN0ZW5lci94c3Mtd2luZG93LW9u Y2xpY2stc2hvcnRjdXQuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS94c3NBdWRpdG9yL2xpbmst b3BlbnMtbmV3LXdpbmRvdy5odG1sCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCA4YmI4ZDNiLi4wNjk1NTMwIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE5NjEsNiArMTk2MSw3IEBAIHdlYmNvcmVndGtfc291cmNlcyArPSBcCiAJV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VFcnJvci5oIFwKIAlXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIFwKIAlXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcCBcCisJV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZVNvdXAuY3BwIFwKIAlXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3QuaCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZS5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL3RleHQv Z3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmggYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgKaW5kZXggYjhjYjU4Ni4uNWZh MzFhMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VS ZXNwb25zZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVz cG9uc2UuaApAQCAtMjgsNiArMjgsOCBAQAogCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZUJh c2UuaCIKIAorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKIGNsYXNzIFJlc291cmNlUmVzcG9uc2UgOiBwdWJsaWMgUmVzb3VyY2VSZXNwb25zZUJhc2Ug ewpAQCAtNDIsNiArNDQsOCBAQCBwdWJsaWM6CiAgICAgewogICAgIH0KIAorICAgIFNvdXBNZXNz YWdlKiB0b1NvdXBNZXNzYWdlKCkgY29uc3Q7CisKIHByaXZhdGU6CiAgICAgZnJpZW5kIGNsYXNz IFJlc291cmNlUmVzcG9uc2VCYXNlOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlU291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uN2Q3ZmQxNgotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2VTb3VwLmNwcApAQCAtMCwwICsxLDU1IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICogQ29w eXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExl c3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJSZXNvdXJjZVJlc3BvbnNlLmgiCisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAi R093blB0ci5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKKyNpbmNsdWRlIDxsaWJz b3VwL3NvdXAuaD4KKwordXNpbmcgbmFtZXNwYWNlIHN0ZDsKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitTb3VwTWVzc2FnZSogUmVzb3VyY2VSZXNwb25zZTo6dG9Tb3VwTWVzc2FnZSgpIGNvbnN0 Cit7CisgICAgLy8gVGhpcyBHRVQgaGVyZSBpcyBqdXN0IGJlY2F1c2UgU291cE1lc3NhZ2Ugd2Fu dHMgaXQsIHdlIGRuJ3QgcmVhbGx5IGtub3cuCisgICAgU291cE1lc3NhZ2UqIHNvdXBNZXNzYWdl ID0gc291cF9tZXNzYWdlX25ldygiR0VUIiwgdXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7 CisgICAgaWYgKCFzb3VwTWVzc2FnZSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBzb3VwTWVz c2FnZS0+c3RhdHVzX2NvZGUgPSBodHRwU3RhdHVzQ29kZSgpOworCisgICAgSFRUUEhlYWRlck1h cCBoZWFkZXJzID0gaHR0cEhlYWRlckZpZWxkcygpOworICAgIFNvdXBNZXNzYWdlSGVhZGVycyog c291cEhlYWRlcnMgPSBzb3VwTWVzc2FnZS0+cmVzcG9uc2VfaGVhZGVyczsKKyAgICBpZiAoIWhl YWRlcnMuaXNFbXB0eSgpKSB7CisgICAgICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9y IGVuZCA9IGhlYWRlcnMuZW5kKCk7CisgICAgICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3Rf aXRlcmF0b3IgaXQgPSBoZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAg ICAgIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2FwcGVuZChzb3VwSGVhZGVycywgaXQtPmZpcnN0LnN0 cmluZygpLnV0ZjgoKS5kYXRhKCksIGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSk7CisgICAgfQor CisgICAgLy8gQm9keSBkYXRhIGlzIG5vdCBpbiB0aGUgbWVzc2FnZS4KKyAgICByZXR1cm4gc291 cE1lc3NhZ2U7Cit9CisKK30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKaW5kZXggZjcyODhlYS4uNGRhNmU5YiAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsMyArMSwy MCBAQAorMjAwOS0wOS0wMiAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3Jvbmhh QGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjY4NTQK KyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFsbG93IG1vcmUgY29udHJvbCBvdmVyIG91dGdv aW5nIHJlcXVlc3RzCisKKyAgICAgICAgTWFwIHRoZSB3aWxsU2VuZFJlcXVlc3QgZGVsZWdhdGUg dG8gdGhlICdvdXRnb2luZy1yZXF1ZXN0JyBzaWduYWwsCisgICAgICAgIGFsbG93aW5nIG1vcmUg Y29udHJvbCBvZiB0aGUgZmV0Y2hpbmcgb2YgcmVzb3VyY2VzLgorCisgICAgICAgICogV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjpGcmFt ZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdlYktp dDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNlbmRSZXF1ZXN0KToKKyAgICAgICAg KiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfY2xh c3NfaW5pdCk6CisgICAgICAgICogd2Via2l0bWFyc2hhbC5saXN0OgorCiAyMDA5LTA5LTAzICBY YW4gTG9wZXogIDx4bG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBHdXN0 YXZvIE5vcm9uaGEuCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuY3BwCmluZGV4IDkyYWZhMmEuLmNhZjkyMWQgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC0yMyw2ICsy Myw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2FkZXJDbGllbnRH dGsuaCIKIAorI2luY2x1ZGUgIkFyY2hpdmVSZXNvdXJjZS5oIgogI2luY2x1ZGUgIkNvbG9yLmgi CiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIuaCIKICNpbmNsdWRlICJEb2N1bWVudExvYWRlckd0 ay5oIgpAQCAtNTQsNiArNTUsNyBAQAogI2luY2x1ZGUgIlNjcmlwdENvbnRyb2xsZXIuaCIKICNp bmNsdWRlICJ3ZWJraXRlcnJvci5oIgogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0Lmgi CisjaW5jbHVkZSAid2Via2l0bmV0d29ya3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAid2Via2l0cHJp dmF0ZS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmZyYW1lLmgiCiAjaW5jbHVkZSAid2Via2l0d2Vi bmF2aWdhdGlvbmFjdGlvbi5oIgpAQCAtMTgxLDE1ICsxODMsNTUgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudDo6ZGlzcGF0Y2hEaWRDYW5jZWxBdXRoZW50aWNhdGlvbkNoYWxsZW5nZShXZWJDb3Jl OjpEb2N1bWUKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQogCisvLyBXZSBjb252ZXJ0IHRoaXMg dG8gc3RyaW5nIGJlY2F1c2UgaXQncyBlYXNpZXIgdG8gdXNlIHN0cmluZ3MgYXMKKy8vIGtleXMg aW4gYSBHSGFzaFRhYmxlLgorc3RhdGljIGNoYXIqIGlkZW50aWZpZXJUb1N0cmluZyh1bnNpZ25l ZCBsb25nIGlkZW50aWZpZXIpCit7CisgICAgcmV0dXJuIGdfc3RyZHVwX3ByaW50ZigiJWxkIiwg aWRlbnRpZmllcik7Cit9CisKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNl bmRSZXF1ZXN0KFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIsIHVuc2lnbmVkIGxvbmcg aWRlbnRpZmllciwgUmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBSZXNvdXJjZVJlc3Bv bnNlJiByZWRpcmVjdFJlc3BvbnNlKQogewotICAgIGlmIChyZWRpcmVjdFJlc3BvbnNlLmlzTnVs bCgpKQorICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcgPSBnZXRWaWV3RnJvbUZyYW1lKG1fZnJh bWUpOworCisgICAgR093blB0cjxnY2hhcj4gaWRlbnRpZmllclN0cmluZyhpZGVudGlmaWVyVG9T dHJpbmcoaWRlbnRpZmllcikpOworICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9 IHdlYmtpdF93ZWJfdmlld19nZXRfcmVzb3VyY2Uod2ViVmlldywgaWRlbnRpZmllclN0cmluZy5n ZXQoKSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCogbmV0d29ya1JlcXVlc3QgPSB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChyZXF1ZXN0KTsKKyAgICBX ZWJLaXROZXR3b3JrUmVzcG9uc2UqIG5ldHdvcmtSZXNwb25zZTsKKworICAgIC8vIFdlIGFyZSBh ZGRpbmcgb25lIG1vcmUgcmVzb3VyY2UgdG8gdGhlIGxvYWQsIG9yIG1heWJlIHdlIGFyZQorICAg IC8vIGp1c3QgcmVkaXJlY3RpbmcgYSBsb2FkLCBpbiB3aGljaCBjYXNlIHdlIG5lZWQgdG8gdXBk YXRlIG91cgorICAgIC8vIFdlYktpdFdlYlJlc291cmNlJ3Mga25vd2xlZGdlIG9mIHRoZSBVUkku CisgICAgaWYgKHJlZGlyZWN0UmVzcG9uc2UuaXNOdWxsKCkpIHsKICAgICAgICAgc3RhdGljX2Nh c3Q8V2ViS2l0OjpEb2N1bWVudExvYWRlcio+KGxvYWRlciktPmluY3JlYXNlTG9hZENvdW50KGlk ZW50aWZpZXIpOworCisgICAgICAgIG5ldHdvcmtSZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JF U1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAwKSk7Cisg ICAgfSBlbHNlIHsKKyAgICAgICAgZ19mcmVlKHdlYlJlc291cmNlLT5wcml2LT51cmkpOworICAg ICAgICB3ZWJSZXNvdXJjZS0+cHJpdi0+dXJpID0gZ19zdHJkdXAocmVxdWVzdC51cmwoKS5zdHJp bmcoKS51dGY4KCkuZGF0YSgpKTsKKworICAgICAgICBuZXR3b3JrUmVzcG9uc2UgPSB3ZWJraXRf bmV0d29ya19yZXNwb25zZV9uZXdfd2l0aF9jb3JlX3Jlc3BvbnNlKHJlZGlyZWN0UmVzcG9uc2Up OworICAgIH0KKworICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAicmVzb3VyY2Ut cmVxdWVzdC1zdGFydGluZyIsIG1fZnJhbWUsIHdlYlJlc291cmNlLCBuZXR3b3JrUmVxdWVzdCwg bmV0d29ya1Jlc3BvbnNlKTsKKworICAgIC8vIEZlZWQgYW55IGNoYW5nZXMgYmFjayBpbnRvIHRo ZSBSZXNvdXJjZVJlcXVlc3Qgb2JqZWN0LgorICAgIHJlcXVlc3QgPSBjb3JlKG5ldHdvcmtSZXF1 ZXN0KTsKKyAgICBnX29iamVjdF91bnJlZihuZXR3b3JrUmVxdWVzdCk7CiB9CiAKLXZvaWQgRnJh bWVMb2FkZXJDbGllbnQ6OmFzc2lnbklkZW50aWZpZXJUb0luaXRpYWxSZXF1ZXN0KHVuc2lnbmVk IGxvbmcgaWRlbnRpZmllciwgV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBSZXNvdXJj ZVJlcXVlc3QmKQordm9pZCBGcmFtZUxvYWRlckNsaWVudDo6YXNzaWduSWRlbnRpZmllclRvSW5p dGlhbFJlcXVlc3QodW5zaWduZWQgbG9uZyBpZGVudGlmaWVyLCBXZWJDb3JlOjpEb2N1bWVudExv YWRlciosIGNvbnN0IFJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKIHsKLSAgICBub3RJbXBsZW1l bnRlZCgpOworICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IFdFQktJVF9XRUJf UkVTT1VSQ0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9SRVNPVVJDRSwgMCkpOworCisg ICAgLy8gVGhlIFVSSSBpcyBpbXBvcnRhbnQgdG8gaGF2ZSBpbiB0aGUgcmVzb3VyY2UgYmVjYXVz ZSB0aGF0IGlzIHdoYXQgd2UgdXNlCisgICAgLy8gdG8gZmV0Y2ggdGhlIFdlYkNvcmUgb2JqZWN0 LCBsYXRlciBvbi4gV2UgdXNlIHRoZSBwcml2YXRlIHN0cnVjdHVyZQorICAgIC8vIGRpcmVjdGx5 IGhlcmUgdG8gYXZvaWQgY2hhbmdpbmcgdGhlIHByb3BlcnR5IG1vZGUgZnJvbSBSRUFEQUJMRSB0 bworICAgIC8vIFJFQURXUklURS4KKyAgICB3ZWJSZXNvdXJjZS0+cHJpdi0+dXJpID0gZ19zdHJk dXAocmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKworICAgIHdlYmtpdF93 ZWJfdmlld19hZGRfcmVzb3VyY2UoZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKSwgaWRlbnRpZmll clRvU3RyaW5nKGlkZW50aWZpZXIpLCB3ZWJSZXNvdXJjZSk7CiB9CiAKIHZvaWQgRnJhbWVMb2Fk ZXJDbGllbnQ6OnBvc3RQcm9ncmVzc1N0YXJ0ZWROb3RpZmljYXRpb24oKQpAQCAtNzgyLDIxICs4 MjQsNDQgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6c2V0VGl0bGUoY29uc3QgU3RyaW5nJiB0 aXRsZSwgY29uc3QgS1VSTCYgdXJsKQogICAgIGZyYW1lRGF0YS0+dGl0bGUgPSBnX3N0cmR1cCh0 aXRsZS51dGY4KCkuZGF0YSgpKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0 Y2hEaWRSZWNlaXZlQ29udGVudExlbmd0aChXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIHVuc2ln bmVkIGxvbmcgaWRlbnRpZmllciwgaW50IGxlbmd0aFJlY2VpdmVkKQordm9pZCBGcmFtZUxvYWRl ckNsaWVudDo6ZGlzcGF0Y2hEaWRSZWNlaXZlQ29udGVudExlbmd0aChXZWJDb3JlOjpEb2N1bWVu dExvYWRlciogbG9hZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIGludCBsZW5ndGhSZWNl aXZlZCkKIHsKLSAgICBub3RJbXBsZW1lbnRlZCgpOworICAgIEdPd25QdHI8Z2NoYXI+IGlkZW50 aWZpZXJTdHJpbmcoaWRlbnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBXZWJLaXRX ZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291cmNlKGdl dFZpZXdGcm9tRnJhbWUobV9mcmFtZSksIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAg d2ViUmVzb3VyY2UtPnByaXYtPmxvYWRTdGF0dXMgPSBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9MT0FE SU5HOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVCh3ZWJSZXNvdXJjZSksICJsb2FkLXN0 YXR1cyIpOwogfQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExv YWRpbmcoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgdW5zaWduZWQgbG9uZyBpZGVu dGlmaWVyKQogewogICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9jdW1lbnRMb2FkZXIqPihsb2Fk ZXIpLT5kZWNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKKworICAgIEdPd25QdHI8Z2NoYXI+ IGlkZW50aWZpZXJTdHJpbmcoaWRlbnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBX ZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291 cmNlKGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSksIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOwor CisgICAgY29uc3QgY2hhciogdXJpID0gd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKHdlYlJl c291cmNlKTsKKyAgICBSZWZQdHI8QXJjaGl2ZVJlc291cmNlPiBjb3JlUmVzb3VyY2UobG9hZGVy LT5zdWJyZXNvdXJjZShLVVJMKEtVUkwoKSwgdXJpKSkpOworICAgIHdlYmtpdF93ZWJfcmVzb3Vy Y2VfaW5pdF93aXRoX2NvcmVfcmVzb3VyY2Uod2ViUmVzb3VyY2UsIGNvcmVSZXNvdXJjZS5nZXQo KSk7CisKKyAgICB3ZWJSZXNvdXJjZS0+cHJpdi0+bG9hZFN0YXR1cyA9IFdFQktJVF9SRVNPVVJD RV9MT0FEX0ZJTklTSEVEOworICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVCh3ZWJSZXNvdXJj ZSksICJsb2FkLXN0YXR1cyIpOworCisgICAgd2Via2l0X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJj ZShnZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpLCBpZGVudGlmaWVyU3RyaW5nLmdldCgpKTsKIH0K IAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGYWlsTG9hZGluZyhXZWJDb3Jl OjpEb2N1bWVudExvYWRlciogbG9hZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIGNvbnN0 IFJlc291cmNlRXJyb3ImIGVycm9yKQogewotICAgIC8vIEZJWE1FOiB3aGVuIGRvZXMgdGhpcyBv Y2N1ciBhbmQgd2hhdCBzaG91bGQgaGFwcGVuPwotCiAgICAgc3RhdGljX2Nhc3Q8V2ViS2l0OjpE b2N1bWVudExvYWRlcio+KGxvYWRlciktPmRlY3JlYXNlTG9hZENvdW50KGlkZW50aWZpZXIpOwor CisgICAgR093blB0cjxnY2hhcj4gaWRlbnRpZmllclN0cmluZyhpZGVudGlmaWVyVG9TdHJpbmco aWRlbnRpZmllcikpOworICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IHdlYmtp dF93ZWJfdmlld19nZXRfcmVzb3VyY2UoZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKSwgaWRlbnRp ZmllclN0cmluZy5nZXQoKSk7CisKKyAgICBHRXJyb3IqIHdlYkVycm9yID0gZ19lcnJvcl9uZXdf bGl0ZXJhbChnX3F1YXJrX2Zyb21fc3RyaW5nKGVycm9yLmRvbWFpbigpLnV0ZjgoKS5kYXRhKCkp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yLmVycm9y Q29kZSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVycm9y LmxvY2FsaXplZERlc2NyaXB0aW9uKCkudXRmOCgpLmRhdGEoKSk7CisgICAgZ19zaWduYWxfZW1p dF9ieV9uYW1lKHdlYlJlc291cmNlLCAibG9hZC1lcnJvciIsIGVycm9yLmZhaWxpbmdVUkwoKS51 dGY4KCkuZGF0YSgpLCB3ZWJFcnJvcik7CisgICAgZ19lcnJvcl9mcmVlKHdlYkVycm9yKTsKIH0K IAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VCeVhNTEh0 dHBSZXF1ZXN0KHVuc2lnbmVkIGxvbmcsIGNvbnN0IFNjcmlwdFN0cmluZyYpCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UuYyBiL1dlYktpdC9ndGsvdGVz dHMvdGVzdG5ldHdvcmtyZXNwb25zZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAuLjkwNTBjMDQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RuZXR3 b3JrcmVzcG9uc2UuYwpAQCAtMCwwICsxLDEwOCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAw OSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAqIENvcHlyaWdodCAoQykgMjAwOSBDb2xsYWJvcmEg THRkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAq LworCisjaW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDxn bGliLmg+CisjaW5jbHVkZSA8Z2xpYi9nc3RkaW8uaD4KKyNpbmNsdWRlIDxndGsvZ3RrLmg+Cisj aW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5oPgorCisjaWYgR0xJ Ql9DSEVDS19WRVJTSU9OKDIsIDE2LCAwKSAmJiBHVEtfQ0hFQ0tfVkVSU0lPTigyLCAxNCwgMCkK Kworc3RhdGljIHZvaWQgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX2NyZWF0ZV9kZXN0cm95KCkKK3sK KyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlOworICAgIFNvdXBNZXNzYWdlKiBt ZXNzYWdlOworCisgICAgLyogVGVzdCBjcmVhdGlvbiB3aXRoIFVSSSAqLworICAgIHJlc3BvbnNl ID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdP UktfUkVTUE9OU0UsICJ1cmkiLCAiaHR0cDovL2RlYmlhbi5vcmcvIiwgTlVMTCkpOworICAgIGdf YXNzZXJ0KFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSk7CisgICAgbWVzc2Fn ZSA9IHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKTsKKyAgICBn X2Fzc2VydCghbWVzc2FnZSk7CisgICAgZ19vYmplY3RfdW5yZWYocmVzcG9uc2UpOworCisgICAg LyogVGVzdCBjcmVhdGlvbiB3aXRoIFNvdXBNZXNzYWdlICovCisgICAgbWVzc2FnZSA9IHNvdXBf bWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICByZXNwb25zZSA9 IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JL X1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsIE5VTEwpKTsKKyAgICBnX2Fzc2VydChXRUJL SVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIGdfYXNzZXJ0X2NtcGludChH X09CSkVDVChtZXNzYWdlKS0+cmVmX2NvdW50LCA9PSwgMik7CisgICAgZ19vYmplY3RfdW5yZWYo cmVzcG9uc2UpOworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVChtZXNzYWdlKS0+cmVmX2Nv dW50LCA9PSwgMSk7CisgICAgZ19vYmplY3RfdW5yZWYobWVzc2FnZSk7CisKKyAgICAvKiBUZXN0 IGNyZWF0aW9uIHdpdGggYm90aCBTb3VwTWVzc2FnZSBhbmQgVVJJICovCisgICAgbWVzc2FnZSA9 IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICByZXNw b25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9O RVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsICJ1cmkiLCAiaHR0cDovL2dub21l Lm9yZy8iLCBOVUxMKSk7CisgICAgZ19hc3NlcnQoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0Uo cmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1QobWVzc2FnZSktPnJlZl9j b3VudCwgPT0sIDIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9nZXRfdXJpKHJlc3BvbnNlKSwgPT0sICJodHRwOi8vZ25vbWUub3JnLyIpOworICAgIGdfb2Jq ZWN0X3VucmVmKHJlc3BvbnNlKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1QobWVzc2Fn ZSktPnJlZl9jb3VudCwgPT0sIDEpOworICAgIGdfb2JqZWN0X3VucmVmKG1lc3NhZ2UpOworfQor CitzdGF0aWMgdm9pZCB0ZXN0X25ldHdvcmtfcmVzcG9uc2VfcHJvcGVydGllcygpCit7CisgICAg V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZTsKKyAgICBTb3VwTWVzc2FnZSogbWVzc2Fn ZTsKKyAgICBnY2hhciogc291cFVSSTsKKworICAgIC8qIFRlc3QgVVJJIGlzIHNldCBjb3JyZWN0 bHkgd2hlbiBjcmVhdGluZyB3aXRoIFVSSSAqLworICAgIHJlc3BvbnNlID0gd2Via2l0X25ldHdv cmtfcmVzcG9uc2VfbmV3KCJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICBnX2Fzc2VydChXRUJL SVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3 ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpKHJlc3BvbnNlKSwgPT0sICJodHRwOi8vZGVi aWFuLm9yZy8iKTsKKyAgICBnX29iamVjdF91bnJlZihyZXNwb25zZSk7CisKKyAgICAvKiBUZXN0 IFVSSSBpcyBzZXQgY29ycmVjdGx5IHdoZW4gY3JlYXRpbmcgd2l0aCBNZXNzYWdlICovCisgICAg bWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9yZy8iKTsK KyAgICByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJL SVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsIE5VTEwpKTsKKyAg ICBnX2Fzc2VydChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIGdf b2JqZWN0X3VucmVmKG1lc3NhZ2UpOworCisgICAgbWVzc2FnZSA9IHdlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKTsKKyAgICBzb3VwVVJJID0gc291cF91cmlfdG9f c3RyaW5nKHNvdXBfbWVzc2FnZV9nZXRfdXJpKG1lc3NhZ2UpLCBGQUxTRSk7CisgICAgZ19hc3Nl cnRfY21wc3RyKHNvdXBVUkksID09LCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgZ19mcmVl KHNvdXBVUkkpOworCisgICAgZ19hc3NlcnRfY21wc3RyKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNl X2dldF91cmkocmVzcG9uc2UpLCA9PSwgImh0dHA6Ly9kZWJpYW4ub3JnLyIpOworICAgIGdfb2Jq ZWN0X3VucmVmKHJlc3BvbnNlKTsKK30KKworaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqKiBhcmd2 KQoreworICAgIGdfdGhyZWFkX2luaXQoTlVMTCk7CisgICAgZ3RrX3Rlc3RfaW5pdCgmYXJnYywg JmFyZ3YsIE5VTEwpOworCisgICAgZ190ZXN0X2J1Z19iYXNlKCJodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy8iKTsKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvbmV0d29ya3Jlc3BvbnNlL2Ny ZWF0ZWRlc3Ryb3kiLCB0ZXN0X25ldHdvcmtfcmVzcG9uc2VfY3JlYXRlX2Rlc3Ryb3kpOworICAg IGdfdGVzdF9hZGRfZnVuYygiL3dlYmtpdC9uZXR3b3JrcmVzcG9uc2UvcHJvcGVydGllcyIsIHRl c3RfbmV0d29ya19yZXNwb25zZV9wcm9wZXJ0aWVzKTsKKyAgICByZXR1cm4gZ190ZXN0X3J1biAo KTsKK30KKworI2Vsc2UKK2ludCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJndikKK3sKKyAgICBn X2NyaXRpY2FsKCJZb3Ugd2lsbCBuZWVkIGF0IGxlYXN0IGdsaWItMi4xNi4wIGFuZCBndGstMi4x NC4wIHRvIHJ1biB0aGUgdW5pdCB0ZXN0cy4gRG9pbmcgbm90aGluZyBub3cuIik7CisgICAgcmV0 dXJuIDA7Cit9CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAppbmRleCA4ZGU3NWUwLi4xODIwMTk4IDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAorKysgYi9XZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXQuaApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRk ZWZpbmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRvd25sb2FkLmg+CiAjaW5jbHVkZSA8 d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdG5l dHdvcmtyZXNwb25zZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRzb3VwYXV0aGRpYWxvZy5o PgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJkYXRhc291cmNlLmg+CiAjaW5jbHVkZSA8d2Vi a2l0L3dlYmtpdHdlYmZyYW1lLmg+CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRkZWZpbmVzLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKaW5kZXggZWE5 MDBhMC4uNmRkZGY4NCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5l cy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaApAQCAtNDQsNiArNDQs OSBAQCBHX0JFR0lOX0RFQ0xTCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVlc3Qg V2ViS2l0TmV0d29ya1JlcXVlc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1JlcXVl c3RDbGFzcyBXZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzOwogCit0eXBlZGVmIHN0cnVjdCBfV2Vi S2l0TmV0d29ya1Jlc3BvbnNlIFdlYktpdE5ldHdvcmtSZXNwb25zZTsKK3R5cGVkZWYgc3RydWN0 IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcyBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzczsK KwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdCBXZWJLaXRXZWJCYWNr Rm9yd2FyZExpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xh c3MgV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3M7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAppbmRleCBlOGEyMjVjLi41ZGU1N2JiIDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0yOCwxNiArMjgsNiBAQAog CiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KIAotbmFtZXNwYWNlIFdURiB7Ci0KLXRlbXBs YXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxTb3VwTWVzc2FnZT4oU291cE1lc3NhZ2UqIHNvdXBN ZXNzYWdlKQotewotICAgIGlmIChzb3VwTWVzc2FnZSkKLSAgICAgICAgZ19vYmplY3RfdW5yZWYo c291cE1lc3NhZ2UpOwotfQotCi19Ci0KIC8qKgogICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVx dWVzdAogICogQHNob3J0X2Rlc2NyaXB0aW9uOiBUaGUgdGFyZ2V0IG9mIGEgbmF2aWdhdGlvbiBy ZXF1ZXN0CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9u c2UuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZjQzMTFjCi0tLSAvZGV2L251bGwKKysr IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcApAQCAtMCwwICsx LDI1MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRl ciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQor ICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V CisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRo ZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAq IEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIKKworI2luY2x1ZGUgIkNTdHJpbmcu aCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgor I2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKKworI2luY2x1ZGUgPGdsaWIvZ2kxOG4tbGliLmg+ CisKKy8qKgorICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVzcG9uc2UKKyAqIEBzaG9ydF9kZXNj cmlwdGlvbjogdGhlIHJlc3BvbnNlIGdpdmVuIHRvIGEgbmV0d29yayByZXF1ZXN0CisgKiBAc2Vl X2Fsc286ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAqIFRoaXMgY2xhc3MgcmVwcmVzZW50 cyB0aGUgbmV0d29yayByZWxhdGVkIGFzcGVjdHMgb2YgYSBuYXZpZ2F0aW9uCisgKiByZXNwb25z ZS4KKyAqCisgKi8KKworR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVzcG9uc2UsIHdlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlLCBHX1RZUEVfT0JKRUNUKTsKKworc3RydWN0IF9XZWJLaXROZXR3 b3JrUmVzcG9uc2VQcml2YXRlIHsKKyAgICBnY2hhciogdXJpOworICAgIFNvdXBNZXNzYWdlKiBt ZXNzYWdlOworfTsKKworI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFU RShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05F VFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUpKQorCitlbnVtIHsK KyAgICBQUk9QXzAsCisKKyAgICBQUk9QX1VSSSwKKyAgICBQUk9QX01FU1NBR0UsCit9OworCitz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6ZShHT2JqZWN0KiBvYmpl Y3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRX T1JLX1JFU1BPTlNFKG9iamVjdCk7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSog cHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7CisKKyAgICBp ZiAocHJpdi0+bWVzc2FnZSkgeworICAgICAgICBnX29iamVjdF91bnJlZihwcml2LT5tZXNzYWdl KTsKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IE5VTEw7CisgICAgfQorCisgICAgR19PQkpFQ1Rf Q0xBU1Mod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfcGFyZW50X2NsYXNzKS0+ZmluYWxpemUob2Jq ZWN0KTsKK30KKworc3RhdGljIHZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Byb3Bl cnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcGVydHlJRCwgR1ZhbHVlKiB2YWx1ZSwgR1Bh cmFtU3BlYyogcHNwZWMpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9 IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iamVjdCk7CisKKyAgICBzd2l0Y2gocHJvcGVydHlJ RCkgeworICAgIGNhc2UgUFJPUF9VUkk6CisgICAgICAgIGdfdmFsdWVfc2V0X3N0cmluZyh2YWx1 ZSwgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaShyZXNwb25zZSkpOworICAgICAgICBi cmVhazsKKyAgICBjYXNlIFBST1BfTUVTU0FHRToKKyAgICAgICAgZ192YWx1ZV9zZXRfb2JqZWN0 KHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZShyZXNwb25zZSkpOwor ICAgICAgICBicmVhazsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFM SURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wZXJ0eUlELCBwc3BlYyk7CisgICAgfQorfQorCitz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfcHJvcGVydHkoR09iamVjdCog b2JqZWN0LCBndWludCBwcm9wZXJ0eUlELCBjb25zdCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVj KiBwc3BlYykKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lU X05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2 YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBzd2l0Y2gocHJvcGVydHlJRCkgewor ICAgIGNhc2UgUFJPUF9VUkk6CisgICAgICAgIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91 cmkocmVzcG9uc2UsIGdfdmFsdWVfZ2V0X3N0cmluZyh2YWx1ZSkpOworICAgICAgICBicmVhazsK KyAgICBjYXNlIFBST1BfTUVTU0FHRToKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IFNPVVBfTUVT U0FHRShnX3ZhbHVlX2R1cF9vYmplY3QodmFsdWUpKTsKKyAgICAgICAgYnJlYWs7CisgICAgZGVm YXVsdDoKKyAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwg cHJvcGVydHlJRCwgcHNwZWMpOworICAgIH0KK30KKworc3RhdGljIHZvaWQgd2Via2l0X25ldHdv cmtfcmVzcG9uc2VfY2xhc3NfaW5pdChXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcyogcmVzcG9u c2VDbGFzcykKK3sKKyAgICBHT2JqZWN0Q2xhc3MqIG9iamVjdENsYXNzID0gR19PQkpFQ1RfQ0xB U1MocmVzcG9uc2VDbGFzcyk7CisKKyAgICBvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3ZWJraXRf bmV0d29ya19yZXNwb25zZV9maW5hbGl6ZTsKKyAgICBvYmplY3RDbGFzcy0+Z2V0X3Byb3BlcnR5 ID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Byb3BlcnR5OworICAgIG9iamVjdENsYXNz LT5zZXRfcHJvcGVydHkgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfcHJvcGVydHk7CisK KyAgICB3ZWJraXRfaW5pdCgpOworCisgICAgLyoqCisgICAgICogV2ViS2l0TmV0d29ya1Jlc3Bv bnNlOnVyaToKKyAgICAgKgorICAgICAqIFRoZSBVUkkgdG8gd2hpY2ggdGhlIHJlc3BvbnNlIHdp bGwgYmUgbWFkZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBn X29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX1VSSSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19zdHJpbmcoInVy aSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIF8oIlVSSSIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBfKCJUaGUgVVJJIHRvIHdoaWNoIHRoZSByZXNwb25zZSB3aWxsIGJlIG1h ZGUuIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIE5VTEwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIChHUGFyYW1GbGFncykoV0VCS0lUX1BBUkFNX1JFQURXUklURSkpKTsKKwor ICAgIC8qKgorICAgICAqIFdlYktpdE5ldHdvcmtSZXNwb25zZTptZXNzYWdlOgorICAgICAqCisg ICAgICogVGhlICNTb3VwTWVzc2FnZSB0aGF0IGJhY2tzIHRoZSByZXNwb25zZS4KKyAgICAgKgor ICAgICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxs X3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX01FU1NBR0UsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfb2JqZWN0KCJtZXNzYWdlIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiTWVzc2Fn ZSIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBfKCJUaGUgU291cE1lc3NhZ2UgdGhhdCBiYWNrcyB0aGUgcmVzcG9uc2UuIiksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNPVVBf VFlQRV9NRVNTQUdFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAoR1BhcmFtRmxhZ3MpKFdFQktJVF9QQVJBTV9SRUFEV1JJVEV8R19QQVJB TV9DT05TVFJVQ1RfT05MWSkpKTsKKworICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShyZXNw b25zZUNsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSkpOworfQorCitz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9pbml0KFdlYktpdE5ldHdvcmtSZXNw b25zZSogcmVzcG9uc2UpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJp diA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9QUklWQVRFKHJlc3BvbnNlKTsKKyAgICBy ZXNwb25zZS0+cHJpdiA9IHByaXY7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2Vi S2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXdfd2l0aF9jb3Jl X3Jlc3BvbnNlKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmIHJlc291cmNlUmVzcG9u c2UpCit7CisgICAgR093blB0cjxTb3VwTWVzc2FnZT4gc291cE1lc3NhZ2UocmVzb3VyY2VSZXNw b25zZS50b1NvdXBNZXNzYWdlKCkpOworICAgIGlmIChzb3VwTWVzc2FnZSkKKyAgICAgICAgcmV0 dXJuIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRX T1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIHNvdXBNZXNzYWdlLmdldCgpLCBOVUxMKSk7CisKKyAg ICByZXR1cm4gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBF X05FVFdPUktfUkVTUE9OU0UsICJ1cmkiLCByZXNvdXJjZVJlc3BvbnNlLnVybCgpLnN0cmluZygp LnV0ZjgoKS5kYXRhKCksIE5VTEwpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9uZXc6CisgKiBAdXJpOiBhbiBVUkkKKyAqCisgKiBDcmVhdGVzIGEgbmV3ICNXZWJLaXRO ZXR3b3JrUmVzcG9uc2UgaW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJuczog YSBuZXcgI1dlYktpdE5ldHdvcmtSZXNwb25zZSwgb3IgJU5VTEwgaWYgdGhlIFVSSSBpcworICog aW52YWxpZC4KKyAqLworV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9uZXcoY29uc3QgZ2NoYXIqIHVyaSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbCh1 cmksIE5VTEwpOworCisgICAgcmV0dXJuIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0 X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAidXJpIiwgdXJpLCBOVUxMKSk7Cit9 CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaToKKyAqIEByZXNwb25z ZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKiBAdXJpOiBhbiBVUkkKKyAqCisgKiBTZXRz IHRoZSBVUkkgaGVsZCBhbmQgdXNlZCBieSB0aGUgZ2l2ZW4gcmVzcG9uc2UuIFdoZW4gdGhlIHJl c3BvbnNlCisgKiBoYXMgYW4gYXNzb2NpYXRlZCAjU291cE1lc3NhZ2UsIGl0cyBVUkkgd2lsbCBh bHNvIGJlIHNldCBieSB0aGlzCisgKiBjYWxsLgorICoKKyAqLwordm9pZCB3ZWJraXRfbmV0d29y a19yZXNwb25zZV9zZXRfdXJpKFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UsIGNvbnN0 IGdjaGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19S RVNQT05TRShyZXNwb25zZSkpOworICAgIGdfcmV0dXJuX2lmX2ZhaWwodXJpKTsKKworICAgIFdl YktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsKKworICAg IGlmIChwcml2LT51cmkpCisgICAgICAgIGdfZnJlZShwcml2LT51cmkpOworICAgIHByaXYtPnVy aSA9IGdfc3RyZHVwKHVyaSk7CisKKyAgICBpZiAoIXByaXYtPm1lc3NhZ2UpCisgICAgICAgIHJl dHVybjsKKworICAgIFNvdXBVUkkqIHNvdXBVUkkgPSBzb3VwX3VyaV9uZXcodXJpKTsKKyAgICBp ZiAoIXNvdXBVUkkpIHsKKyAgICAgICAgZ193YXJuaW5nKCJJbnZhbGlkIFVSSTogJXMiLCB1cmkp OworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgc291cF9tZXNzYWdlX3NldF91cmkocHJp di0+bWVzc2FnZSwgc291cFVSSSk7CisgICAgc291cF91cmlfZnJlZShzb3VwVVJJKTsKK30KKwor LyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpOgorICogQHJlc3BvbnNlOiBh ICNXZWJLaXROZXR3b3JrUmVzcG9uc2UKKyAqCisgKiBSZXR1cm5zOiB0aGUgdXJpIG9mIHRoZSAj V2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogU2luY2U6IDEuMS4xNAorICovCitHX0NPTlNU X1JFVFVSTiBnY2hhciogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaShXZWJLaXROZXR3 b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJ VF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3 b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBpZiAocHJp di0+dXJpKQorICAgICAgICByZXR1cm4gcHJpdi0+dXJpOworCisgICAgU291cFVSSSogc291cFVS SSA9IHNvdXBfbWVzc2FnZV9nZXRfdXJpKHByaXYtPm1lc3NhZ2UpOworICAgIHByaXYtPnVyaSA9 IHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwVVJJLCBGQUxTRSk7CisgICAgcmV0dXJuIHByaXYtPnVy aTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfc291cF9tZXNzYWdl OgorICogQHJlc3BvbnNlOiBhICNXZWJLaXROZXR3b3JrUmVzcG9uc2UKKyAqCisgKiBPYnRhaW5z IHRoZSAjU291cE1lc3NhZ2UgdGhhdCByZXByZXNlbnRzIHRoZSBnaXZlbiByZXNwb25zZS4gTm90 aWNlCisgKiB0aGF0IG9ubHkgdGhlIHJlc3BvbnNlIHNpZGUgb2YgdGhlIEhUVFAgY29udmVyc2F0 aW9uIGlzCisgKiByZXByZXNlbnRlZC4KKyAqCisgKiBSZXR1cm5zOiB0aGUgI1NvdXBNZXNzYWdl CisgKiBTaW5jZTogMS4xLjE0CisgKi8KK1NvdXBNZXNzYWdlKiB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9nZXRfbWVzc2FnZShXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlKQoreworICAg IGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNl KSwgTlVMTCk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVz cG9uc2UtPnByaXY7CisKKyAgICByZXR1cm4gcHJpdi0+bWVzc2FnZTsKK30KZGlmZiAtLWdpdCBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uZWIyMzNiNQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdG5ldHdvcmtyZXNwb25zZS5oCkBAIC0wLDAgKzEsNzQgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMDkgQ29sbGFib3JhIEx0ZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlO Ry5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAw MjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lmbmRlZiBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9I CisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0gKKworI2luY2x1ZGUgPGdsaWItb2Jq ZWN0Lmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CisKKyNpbmNsdWRlIDx3ZWJraXQvd2Vi a2l0ZGVmaW5lcy5oPgorCitHX0JFR0lOX0RFQ0xTCisKKyNkZWZpbmUgV0VCS0lUX1RZUEVfTkVU V09SS19SRVNQT05TRSAgICAgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdHlw ZSgpKQorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShvYmopICAgICAgICAgICAgKEdf VFlQRV9DSEVDS19JTlNUQU5DRV9DQVNUKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BP TlNFLCBXZWJLaXROZXR3b3JrUmVzcG9uc2UpKQorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQ T05TRV9DTEFTUyhrbGFzcykgICAgKEdfVFlQRV9DSEVDS19DTEFTU19DQVNUKChrbGFzcyksICBX RUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCBXZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcykp CisjZGVmaW5lIFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKG9iaikgICAgICAgICAoR19UWVBF X0NIRUNLX0lOU1RBTkNFX1RZUEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0Up KQorI2RlZmluZSBXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRV9DTEFTUyhrbGFzcykgKEdfVFlQ RV9DSEVDS19DTEFTU19UWVBFKChrbGFzcyksICBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNF KSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfR0VUX0NMQVNTKG9iaikgIChHX1RZ UEVfSU5TVEFOQ0VfR0VUX0NMQVNTKChvYmopLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05T RSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MpKQorCit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0 TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlOworCitz dHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZSB7CisgICAgR09iamVjdCBwYXJlbnRfaW5zdGFu Y2U7CisKKyAgICAvKjwgcHJpdmF0ZSA+Ki8KKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2 YXRlICpwcml2OworfTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcyB7Cisg ICAgR09iamVjdENsYXNzIHBhcmVudF9jbGFzczsKKworICAgIC8qIFBhZGRpbmcgZm9yIGZ1dHVy ZSBleHBhbnNpb24gKi8KKyAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDApICh2b2lkKTsKKyAg ICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDEpICh2b2lkKTsKKyAgICB2b2lkICgqX3dlYmtpdF9y ZXNlcnZlZDIpICh2b2lkKTsKKyAgICB2b2lkICgqX3dlYmtpdF9yZXNlcnZlZDMpICh2b2lkKTsK K307CisKK1dFQktJVF9BUEkgR1R5cGUKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF90eXBl ICh2b2lkKTsKKworV0VCS0lUX0FQSSBXZWJLaXROZXR3b3JrUmVzcG9uc2UgKgord2Via2l0X25l dHdvcmtfcmVzcG9uc2VfbmV3ICAgICAgKGNvbnN0IGdjaGFyICAgICAgICAgICp1cmkpOworCitX RUJLSVRfQVBJIHZvaWQKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmkgIChXZWJLaXRO ZXR3b3JrUmVzcG9uc2UgKnJlc3BvbnNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnN0IGdjaGFyKiAgICAgICAgICB1cmkpOworCitXRUJLSVRfQVBJIEdfQ09OU1RfUkVU VVJOIGdjaGFyICoKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkgIChXZWJLaXROZXR3 b3JrUmVzcG9uc2UgKnJlc3BvbnNlKTsKKworV0VCS0lUX0FQSSBTb3VwTWVzc2FnZSAqCit3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZShXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJl c3BvbnNlKTsKKworR19FTkRfREVDTFMKKworI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuY3BwCmluZGV4IDRlNDg2MTMuLjhlOTM0OGUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuY3BwCkBAIC0xMTgsNiArMTE4LDE1IEBAIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3Jl KFdlYktpdEVkaXRpbmdCZWhhdmlvciB0eXBlKQogCiB9IC8qKiBlbmQgbmFtZXNwYWNlIFdlYktp dCAqLwogCituYW1lc3BhY2UgV1RGIHsKK3RlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxT b3VwTWVzc2FnZT4oU291cE1lc3NhZ2UqIHNvdXBNZXNzYWdlKQoreworICAgIGlmIChzb3VwTWVz c2FnZSkKKyAgICAgICAgZ19vYmplY3RfdW5yZWYoc291cE1lc3NhZ2UpOworfQorCit9CisKIHN0 YXRpYyBHdGtXaWRnZXQqIGN1cnJlbnRUb3BsZXZlbENhbGxiYWNrKFdlYktpdFNvdXBBdXRoRGlh bG9nKiBmZWF0dXJlLCBTb3VwTWVzc2FnZSogbWVzc2FnZSwgZ3BvaW50ZXIgdXNlckRhdGEpCiB7 CiAgICAgZ3BvaW50ZXIgbWVzc2FnZURhdGEgPSBnX29iamVjdF9nZXRfZGF0YShHX09CSkVDVCht ZXNzYWdlKSwgInJlc291cmNlSGFuZGxlIik7CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5k ZXggYmQyYTBiOS4uNzZlZWUyOSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtNDYs NiArNDYsNyBAQAogI2luY2x1ZGUgIkJhY2tGb3J3YXJkTGlzdC5oIgogI2luY2x1ZGUgIkNTdHJp bmcuaCIKICNpbmNsdWRlIDxlbmNoYW50Lmg+CisjaW5jbHVkZSAiR093blB0ci5oIgogI2luY2x1 ZGUgIkhpc3RvcnlJdGVtLmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKICNpbmNsdWRlICJQYWdl LmgiCkBAIC04NSw2ICs4Niw4IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgV2ViQ29yZTo6 UmVzb3VyY2VSZXF1ZXN0IGNvcmUoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOwogCisg ICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBjb3JlKFdlYktpdE5ldHdvcmtSZXNwb25zZSog cmVzcG9uc2UpOworCiAgICAgV2ViQ29yZTo6RWRpdGluZ0JlaGF2aW9yIGNvcmUoV2ViS2l0RWRp dGluZ0JlaGF2aW9yIHR5cGUpOwogfQogCkBAIC0xMzIsNiArMTM1LDggQEAgZXh0ZXJuICJDIiB7 CiAKICAgICAgICAgZ2Jvb2xlYW4gZGlzcG9zaW5nOwogICAgICAgICBnYm9vbGVhbiB1c2VQcmlt YXJ5Rm9yUGFzdGU7CisKKyAgICAgICAgR0hhc2hUYWJsZSogc3ViUmVzb3VyY2VzOwogICAgIH07 CiAKICAgICAjZGVmaW5lIFdFQktJVF9XRUJfRlJBTUVfR0VUX1BSSVZBVEUob2JqKSAgICAoR19U WVBFX0lOU1RBTkNFX0dFVF9QUklWQVRFKChvYmopLCBXRUJLSVRfVFlQRV9XRUJfRlJBTUUsIFdl YktpdFdlYkZyYW1lUHJpdmF0ZSkpCkBAIC0xNzcsOSArMTgyLDE0IEBAIGV4dGVybiAiQyIgewog ICAgICAgICBnY2hhciogZnJhbWVOYW1lOwogCiAgICAgICAgIEdTdHJpbmcqIGRhdGE7CisKKyAg ICAgICAgV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzIGxvYWRTdGF0dXM7CiAgICAgfTsKICAgICBX ZWJLaXRXZWJSZXNvdXJjZSoKICAgICB3ZWJraXRfd2ViX3Jlc291cmNlX25ld193aXRoX2NvcmVf cmVzb3VyY2UoUGFzc1JlZlB0cjxXZWJDb3JlOjpBcmNoaXZlUmVzb3VyY2U+KTsKKworICAgIHZv aWQKKyAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2luaXRfd2l0aF9jb3JlX3Jlc291cmNlKFdlYktp dFdlYlJlc291cmNlKiwgUGFzc1JlZlB0cjxXZWJDb3JlOjpBcmNoaXZlUmVzb3VyY2U+KTsKICAg ICAvLyBlbmQgV2ViS2l0V2ViUmVzb3VyY2UgcHJpdmF0ZQogCiAgICAgdm9pZApAQCAtMjAwLDYg KzIxMCwxNSBAQCBleHRlcm4gIkMiIHsKICAgICB2b2lkCiAgICAgd2Via2l0X3dlYl92aWV3X3Jl cXVlc3RfZG93bmxvYWQoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0LCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSA9 IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UoKSwgV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGUqIGhh bmRsZSA9IDApOwogCisgICAgdm9pZAorICAgIHdlYmtpdF93ZWJfdmlld19hZGRfcmVzb3VyY2Uo V2ViS2l0V2ViVmlldyosIGNoYXIqLCBXZWJLaXRXZWJSZXNvdXJjZSopOworCisgICAgV2ViS2l0 V2ViUmVzb3VyY2UqCisgICAgd2Via2l0X3dlYl92aWV3X2dldF9yZXNvdXJjZShXZWJLaXRXZWJW aWV3KiwgY2hhciopOworCisgICAgdm9pZAorICAgIHdlYmtpdF93ZWJfdmlld19yZW1vdmVfcmVz b3VyY2UoV2ViS2l0V2ViVmlldyosIGNoYXIqKTsKKwogICAgIFdlYktpdERvd25sb2FkKgogICAg IHdlYmtpdF9kb3dubG9hZF9uZXdfd2l0aF9oYW5kbGUoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJl cXVlc3QsIFdlYkNvcmU6OlJlc291cmNlSGFuZGxlKiBoYW5kbGUsIGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVzcG9uc2UmIHJlc3BvbnNlKTsKIApAQCAtMjE1LDYgKzIzNCw5IEBAIGV4dGVybiAi QyIgewogICAgIFdlYktpdE5ldHdvcmtSZXF1ZXN0KgogICAgIHdlYmtpdF9uZXR3b3JrX3JlcXVl c3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYg cmVzb3VyY2VSZXF1ZXN0KTsKIAorICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSoKKyAgICB3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9uZXdfd2l0aF9jb3JlX3Jlc3BvbnNlKGNvbnN0IFdlYkNvcmU6 OlJlc291cmNlUmVzcG9uc2UmIHJlc291cmNlUmVzcG9uc2UpOworCiAgICAgLy8gRklYTUU6IG1v dmUgdGhpcyB0byB3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIG9uY2UgdGhlIEFQSSBpcyBhZ3JlZWQg dXBvbi4KICAgICBXRUJLSVRfQVBJIFNvdXBNZXNzYWdlKgogICAgIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1JlcXVlc3QqIHJlcXVlc3QpOwpAQCAtMjkz LDQgKzMxNSw4IEBAIGV4dGVybiAiQyIgewogICAgIHdlYmtpdF93ZWJfZGF0YV9zb3VyY2VfbmV3 X3dpdGhfbG9hZGVyKFBhc3NSZWZQdHI8V2ViS2l0OjpEb2N1bWVudExvYWRlcj4pOwogfQogCitu YW1lc3BhY2UgV1RGIHsKKyAgICB0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8U291cE1l c3NhZ2U+KFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSk7Cit9CisKICNlbmRpZgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwCmluZGV4IGMxNjI1NzguLmQyOTVjMWMgMTAwNjQ0 Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAorKysgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAKQEAgLTI3LDYgKzI3LDggQEAKICNp bmNsdWRlICJLVVJMLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKICNpbmNsdWRlICJT aGFyZWRCdWZmZXIuaCIKKyNpbmNsdWRlICJ3ZWJraXRlbnVtdHlwZXMuaCIKKyNpbmNsdWRlICJ3 ZWJraXRtYXJzaGFsLmgiCiAjaW5jbHVkZSAid3RmL0Fzc2VydGlvbnMuaCIKIAogI2luY2x1ZGUg PGdsaWIuaD4KQEAgLTQ1LDE3ICs0Nyw0NyBAQCB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIHVz aW5nIG5hbWVzcGFjZSBXZWJLaXQ7CiAKIGVudW0geworICAgIExPQURfRVJST1IsCisgICAgTEFT VF9TSUdOQUwKK307CisKK2VudW0gewogICAgIFBST1BfMCwKIAogICAgIFBST1BfVVJJLAogICAg IFBST1BfTUlNRV9UWVBFLAogICAgIFBST1BfRU5DT0RJTkcsCi0gICAgUFJPUF9GUkFNRV9OQU1F CisgICAgUFJPUF9GUkFNRV9OQU1FLAorICAgIFBST1BfTE9BRF9TVEFUVVMKIH07CiAKK3N0YXRp YyBndWludCB3ZWJraXRfd2ViX3Jlc291cmNlX3NpZ25hbHNbTEFTVF9TSUdOQUxdID0geyAwLCB9 OworCiBHX0RFRklORV9UWVBFKFdlYktpdFdlYlJlc291cmNlLCB3ZWJraXRfd2ViX3Jlc291cmNl LCBHX1RZUEVfT0JKRUNUKTsKIAogc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRf cHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqIHZhbHVlLCBH UGFyYW1TcGVjKiBwc3BlYyk7CitzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX3NldF9w cm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIGNvbnN0IEdWYWx1ZSogdmFs dWUsIEdQYXJhbVNwZWMqIHBzcGVjKTsKKworc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJj ZV9jbGVhbnVwKFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSkKK3sKKyAgICBXZWJLaXRX ZWJSZXNvdXJjZVByaXZhdGUqIHByaXYgPSB3ZWJSZXNvdXJjZS0+cHJpdjsKKworICAgIGdfZnJl ZShwcml2LT51cmkpOworICAgIHByaXYtPnVyaSA9IE5VTEw7CisKKyAgICBnX2ZyZWUocHJpdi0+ bWltZVR5cGUpOworICAgIHByaXYtPm1pbWVUeXBlID0gTlVMTDsKKworICAgIGdfZnJlZShwcml2 LT50ZXh0RW5jb2RpbmcpOworICAgIHByaXYtPnRleHRFbmNvZGluZyA9IE5VTEw7CisKKyAgICBn X2ZyZWUocHJpdi0+ZnJhbWVOYW1lKTsKKyAgICBwcml2LT5mcmFtZU5hbWUgPSBOVUxMOworCisg ICAgaWYgKHByaXYtPmRhdGEpCisgICAgICAgIGdfc3RyaW5nX2ZyZWUocHJpdi0+ZGF0YSwgVFJV RSk7CisgICAgcHJpdi0+ZGF0YSA9IE5VTEw7Cit9CiAKIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf cmVzb3VyY2VfZGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCiB7CkBAIC03MywxNSArMTA1LDggQEAg c3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9kaXNwb3NlKEdPYmplY3QqIG9iamVjdCkK IHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfZmluYWxpemUoR09iamVjdCogb2JqZWN0 KQogewogICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IFdFQktJVF9XRUJfUkVT T1VSQ0Uob2JqZWN0KTsKLSAgICBXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUqIHByaXYgPSB3ZWJS ZXNvdXJjZS0+cHJpdjsKIAotICAgIGdfZnJlZShwcml2LT51cmkpOwotICAgIGdfZnJlZShwcml2 LT5taW1lVHlwZSk7Ci0gICAgZ19mcmVlKHByaXYtPnRleHRFbmNvZGluZyk7Ci0gICAgZ19mcmVl KHByaXYtPmZyYW1lTmFtZSk7Ci0KLSAgICBpZiAocHJpdi0+ZGF0YSkKLSAgICAgICAgZ19zdHJp bmdfZnJlZShwcml2LT5kYXRhLCBUUlVFKTsKKyAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2NsZWFu dXAod2ViUmVzb3VyY2UpOwogCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X3dlYl9yZXNvdXJj ZV9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOwogfQpAQCAtOTMsNiArMTE4LDI4IEBA IHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xhc3NfaW5pdChXZWJLaXRXZWJSZXNv dXJjZUNsYXNzKiBrbGFzcykKICAgICBnb2JqZWN0X2NsYXNzLT5kaXNwb3NlID0gd2Via2l0X3dl Yl9yZXNvdXJjZV9kaXNwb3NlOwogICAgIGdvYmplY3RfY2xhc3MtPmZpbmFsaXplID0gd2Via2l0 X3dlYl9yZXNvdXJjZV9maW5hbGl6ZTsKICAgICBnb2JqZWN0X2NsYXNzLT5nZXRfcHJvcGVydHkg PSB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9wcm9wZXJ0eTsKKyAgICBnb2JqZWN0X2NsYXNzLT5z ZXRfcHJvcGVydHkgPSB3ZWJraXRfd2ViX3Jlc291cmNlX3NldF9wcm9wZXJ0eTsKKworICAgIC8q KgorICAgICAqIFdlYktpdFdlYlJlc291cmNlOjpsb2FkLWVycm9yCisgICAgICogQHdlYl9yZXNv dXJjZTogdGhlICNXZWJLaXRXZWJSZXNvdXJjZSB3aGljaCBmYWlsZWQgdG8gbG9hZAorICAgICAq IEB1cmk6IHRoZSBVUkkgZnJvbSB3aGljaCB0aGUgcmVzb3VyY2Ugd2FzIGJlaW5nIGxvYWRlZAor ICAgICAqIEB3ZWJfZXJyb3I6IHRoZSAjR0Vycm9yIHRoYXQgd2FzIHRyaWdnZXJlZAorICAgICAq CisgICAgICogQW4gZXJyb3Igb2NjdXJyZWQgd2hpbGUgbG9hZGluZyB0aGlzIHJlc291cmNlLgor ICAgICAqCisgICAgICogU2luY2U6IDEuMS4xNAorICAgICAqLworICAgIHdlYmtpdF93ZWJfcmVz b3VyY2Vfc2lnbmFsc1tMT0FEX0VSUk9SXSA9IGdfc2lnbmFsX25ldygibG9hZC1lcnJvciIsCisg ICAgICAgICAgICBHX1RZUEVfRlJPTV9DTEFTUyhrbGFzcyksCisgICAgICAgICAgICAoR1NpZ25h bEZsYWdzKUdfU0lHTkFMX1JVTl9MQVNULAorICAgICAgICAgICAgMCwKKyAgICAgICAgICAgIE5V TEwsCisgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgd2Via2l0X21hcnNoYWxfVk9JRF9f U1RSSU5HX1BPSU5URVIsCisgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMiwKKyAgICAgICAgICAg IEdfVFlQRV9TVFJJTkcsCisgICAgICAgICAgICBHX1RZUEVfUE9JTlRFUik7CiAKICAgICAvKioK ICAgICAgKiBXZWJLaXRXZWJSZXNvdXJjZTp1cmk6CkBAIC0xNTYsOSArMjAzLDQwIEBAIHN0YXRp YyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xhc3NfaW5pdChXZWJLaXRXZWJSZXNvdXJjZUNs YXNzKiBrbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBREFCTEUp KTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdlYlJlc291cmNlOmxvYWQtc3RhdHVzOgorICAg ICAqCisgICAgICogRGV0ZXJtaW5lcyB0aGUgY3VycmVudCBzdGF0dXMgb2YgdGhlIGxvYWQgZm9y IHRoaXMgcmVzb3VyY2UuCisgICAgICoKKyAgICAgKiBTaW5jZTogMS4xLjE0CisgICAgICovCisg ICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShnb2JqZWN0X2NsYXNzLCBQUk9QX0xP QURfU1RBVFVTLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9z cGVjX2VudW0oImxvYWQtc3RhdHVzIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICJMb2FkIFN0YXR1cyIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiRGV0ZXJtaW5lcyB0aGUgY3VycmVu dCBzdGF0dXMgb2YgdGhlIGxvYWQgZm9yIHRoaXMgcmVzb3VyY2UiLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1RZUEVfUkVTT1VS Q0VfTE9BRF9TVEFUVVMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9OT1RfU1RBUlRFRCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJB TV9SRUFEQUJMRSkpOworCiAgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKGdvYmplY3RfY2xh c3MsIHNpemVvZihXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUpKTsKIH0KIAorc3RhdGljIHZvaWQg d2Via2l0X3dlYl9yZXNvdXJjZV9zZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBw cm9wX2lkLCBjb25zdCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYykKK3sKKyAgICBX ZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VCX1JFU09VUkNFKG9iamVj dCk7CisgICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnBy aXY7CisKKyAgICBzd2l0Y2ggKHByb3BfaWQpIHsKKyAgICBjYXNlIFBST1BfVVJJOgorICAgICAg ICAvLyBTaG91bGQgYmUgZ29vZCBzaW5jZSB0aGUgcHJvcGVydHkgaXMgQ09OU1RSVUNUX09OTFkK KyAgICAgICAgcHJpdi0+dXJpID0gZ192YWx1ZV9kdXBfc3RyaW5nKHZhbHVlKTsKKyAgICAgICAg YnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BF UlRZX0lEKG9iamVjdCwgcHJvcF9pZCwgcHNwZWMpOworICAgICAgICBicmVhazsKKyAgICB9Cit9 CisKIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X3Byb3BlcnR5KEdPYmplY3Qq IG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVlKiB2YWx1ZSwgR1BhcmFtU3BlYyogcHNwZWMp CiB7CiAgICAgV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlID0gV0VCS0lUX1dFQl9SRVNP VVJDRShvYmplY3QpOwpAQCAtMTc2LDYgKzI1NCw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf cmVzb3VyY2VfZ2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1Zh CiAgICAgY2FzZSBQUk9QX0ZSQU1FX05BTUU6CiAgICAgICAgIGdfdmFsdWVfc2V0X3N0cmluZyh2 YWx1ZSwgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfZnJhbWVfbmFtZSh3ZWJSZXNvdXJjZSkpOwog ICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfTE9BRF9TVEFUVVM6CisgICAgICAgIGdfdmFs dWVfc2V0X2VudW0odmFsdWUsIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2xvYWRfc3RhdHVzKHdl YlJlc291cmNlKSk7CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JK RUNUX1dBUk5fSU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAg ICAgICAgYnJlYWs7CkBAIC0xOTcsNiArMjc4LDE4IEBAIFdlYktpdFdlYlJlc291cmNlKiB3ZWJr aXRfd2ViX3Jlc291cmNlX25ld193aXRoX2NvcmVfcmVzb3VyY2UoUGFzc1JlZlB0cjxBcmNoaXZl CiAgICAgcmV0dXJuIHdlYlJlc291cmNlOwogfQogCit2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2Vf aW5pdF93aXRoX2NvcmVfcmVzb3VyY2UoV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlLCBQ YXNzUmVmUHRyPEFyY2hpdmVSZXNvdXJjZT4gcmVzb3VyY2UpCit7CisgICAgV2ViS2l0V2ViUmVz b3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7CisKKyAgICBpZiAocHJpdi0+ cmVzb3VyY2UpCisgICAgICAgIHByaXYtPnJlc291cmNlLT5kZXJlZigpOworCisgICAgd2Via2l0 X3dlYl9yZXNvdXJjZV9jbGVhbnVwKHdlYlJlc291cmNlKTsKKworICAgIHByaXYtPnJlc291cmNl ID0gcmVzb3VyY2UucmVsZWFzZVJlZigpOworfQorCiAvKioKICAqIHdlYmtpdF93ZWJfcmVzb3Vy Y2VfbmV3OgogICogQGRhdGE6IHRoZSBkYXRhIHRvIGluaXRpYWxpemUgdGhlICNXZWJLaXRXZWJS ZXNvdXJjZQpAQCAtMjcwLDExICszNjMsMTQgQEAgR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtp dF93ZWJfcmVzb3VyY2VfZ2V0X3VyaShXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UKICAg ICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX1JFU09VUkNFKHdlYlJlc291cmNl KSwgTlVMTCk7CiAKICAgICBXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUqIHByaXYgPSB3ZWJSZXNv dXJjZS0+cHJpdjsKKworICAgIGlmIChwcml2LT51cmkpCisgICAgICAgIHJldHVybiBwcml2LT51 cmk7CisKICAgICBpZiAoIXByaXYtPnJlc291cmNlKQogICAgICAgICByZXR1cm4gTlVMTDsKIAot ICAgIGlmICghcHJpdi0+dXJpKQotICAgICAgICBwcml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5y ZXNvdXJjZS0+dXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgcHJpdi0+dXJpID0g Z19zdHJkdXAocHJpdi0+cmVzb3VyY2UtPnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOwog CiAgICAgcmV0dXJuIHByaXYtPnVyaTsKIH0KQEAgLTM0NCwzICs0NDAsMjEgQEAgR19DT05TVF9S RVRVUk4gZ2NoYXIqIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2ZyYW1lX25hbWUoV2ViS2l0V2Vi UmVzb3VyY2UqIHdlYlIKIAogICAgIHJldHVybiBwcml2LT5mcmFtZU5hbWU7CiB9CisKKy8qKgor ICogd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfbG9hZF9zdGF0dXM6CisgKiBAd2ViX3Jlc291cmNl OiBhICNXZWJLaXRXZWJSZXNvdXJjZQorICoKKyAqIERldGVybWluZXMgdGhlIGN1cnJlbnQgc3Rh dHVzIG9mIHRoZSBsb2FkIGZvciB0aGlzIHJlc291cmNlCisgKgorICogUmV0dXJuIHZhbHVlOiBh ICNXZWJLaXRSZXNvdXJjZUxvYWRTdGF0dXMKKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KK1dl YktpdFJlc291cmNlTG9hZFN0YXR1cyB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1 cyhXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UpCit7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwoV0VCS0lUX0lTX1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSksIFdFQktJVF9SRVNPVVJD RV9MT0FEX05PVF9TVEFSVEVEKTsKKworICAgIFdlYktpdFdlYlJlc291cmNlUHJpdmF0ZSogcHJp diA9IHdlYlJlc291cmNlLT5wcml2OworICAgIHJldHVybiBwcml2LT5sb2FkU3RhdHVzOworfQpk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuaCBiL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmgKaW5kZXggMjZhMDQ1OC4uMjkxMDdkZSAx MDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuaAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5oCkBAIC0zNiw2ICszNiwyNCBAQCBH X0JFR0lOX0RFQ0xTCiAKIHR5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUg V2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlOwogCisvKioKKyAqIFdlYktpdFJlc291cmNlTG9hZFN0 YXR1cworICogQFdFQktJVF9SRVNPVVJDRV9MT0FEX05PVF9TVEFSVEVEOiB0aGUgcmVzb3VyY2Ug aXMganVzdCBhIHN0dWIsCisgKiBub3RoaW5nIGhhcyBhcnJpdmVkIGZyb20gdGhlIG5ldHdvcmsg eWV0CisgKiBAV0VCS0lUX1JFU09VUkNFX0xPQURfTE9BRElORzogdGhlIHJlc291cmNlIGFscmVh ZHkgaGFzIHNvbWUgZGF0YSwKKyAqIGFuZCB3aWxsIHN0aWxsIHJlY2VpdmUgc29tZSBtb3JlOyB0 aGUgYWN0dWFsIGRhdGEgb25seSBiZWNvbWVzCisgKiBhdmFpbGFibGUgd2hlbiB0aGUgbG9hZCBp cyBmaW5pc2hlZAorICogQFdFQktJVF9SRVNPVVJDRV9MT0FEX0ZJTklTSEVEOiB0aGUgcmVzb3Vy Y2UgaXMgZG9uZSBsb2FkaW5nLCB0aGUKKyAqIGRhdGEsIGFuZCB0aGUgbWV0YWRhdGEgYXJlIG5v dyBhdmFpbGFibGUgdG8gYmUgZmV0Y2hlZCBmcm9tIHRoZQorICogb2JqZWN0LCBpZiBhbiBlcnJv ciBoYXMgbm90IGhhcHBlbmVkLCBhbmQgV2ViS2l0IHdpbGwgbm8gbG9uZ2VyCisgKiBoYXZlIGEg cmVmZXJlbmNlIHRvIHRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ugb2JqZWN0CisgKi8KK3R5cGVkZWYg ZW51bSB7CisgICAgV0VCS0lUX1JFU09VUkNFX0xPQURfTk9UX1NUQVJURUQsCisgICAgV0VCS0lU X1JFU09VUkNFX0xPQURfTE9BRElORywKKyAgICBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9GSU5JU0hF RCwKK30gV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzOworCiBzdHJ1Y3QgX1dlYktpdFdlYlJlc291 cmNlIHsKICAgICBHT2JqZWN0IHBhcmVudF9pbnN0YW5jZTsKIApAQCAtNzksNiArOTcsOSBAQCB3 ZWJraXRfd2ViX3Jlc291cmNlX2dldF9lbmNvZGluZyAgICAgICAgICAgKFdlYktpdFdlYlJlc291 cmNlICAqd2ViX3Jlc291cmNlKTsKIFdFQktJVF9BUEkgR19DT05TVF9SRVRVUk4gZ2NoYXIgKgog d2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfZnJhbWVfbmFtZSAgICAgICAgIChXZWJLaXRXZWJSZXNv dXJjZSAgKndlYl9yZXNvdXJjZSk7CiAKK1dFQktJVF9BUEkgV2ViS2l0UmVzb3VyY2VMb2FkU3Rh dHVzCit3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1cyAgICAgICAgKFdlYktpdFdl YlJlc291cmNlICAqd2ViX3Jlc291cmNlKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmIC8qIFdF QktJVF9XRUJfUkVTT1VSQ0VfSCAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRl eCA0YzhmY2ExLi5mNTZkYjNhIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAt MjUsMTEgKzI1LDEzIEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIndl YmtpdHdlYnZpZXcuaCIKIAogI2luY2x1ZGUgIndlYmtpdGRvd25sb2FkLmgiCi0jaW5jbHVkZSAi d2Via2l0d2Vidmlldy5oIgogI2luY2x1ZGUgIndlYmtpdGVudW10eXBlcy5oIgogI2luY2x1ZGUg IndlYmtpdG1hcnNoYWwuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2lu Y2x1ZGUgIndlYmtpdG5ldHdvcmtyZXNwb25zZS5oIgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUu aCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJpbnNwZWN0b3IuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJi YWNrZm9yd2FyZGxpc3QuaCIKQEAgLTE0NCw2ICsxNDYsNyBAQCBlbnVtIHsKICAgICBDTE9TRV9X RUJfVklFVywKICAgICBVTkRPLAogICAgIFJFRE8sCisgICAgUkVTT1VSQ0VfUkVRVUVTVF9TVEFS VElORywKICAgICBMQVNUX1NJR05BTAogfTsKIApAQCAtOTkwLDYgKzk5MywxMSBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfd2ViX3ZpZXdfZGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCiAgICAgICAgIHBy aXYtPnBhc3RlX3RhcmdldF9saXN0ID0gTlVMTDsKICAgICB9CiAKKyAgICBpZiAocHJpdi0+c3Vi UmVzb3VyY2VzKSB7CisgICAgICAgIGdfaGFzaF90YWJsZV91bnJlZihwcml2LT5zdWJSZXNvdXJj ZXMpOworICAgICAgICBwcml2LT5zdWJSZXNvdXJjZXMgPSBOVUxMOworICAgIH0KKwogICAgIEdf T0JKRUNUX0NMQVNTKHdlYmtpdF93ZWJfdmlld19wYXJlbnRfY2xhc3MpLT5kaXNwb3NlKG9iamVj dCk7CiB9CiAKQEAgLTE5NTIsNiArMTk2MCw0NCBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Zp ZXdfY2xhc3NfaW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdlYlZpZXdDbGFzcykKICAgICAgICAg ICAgIEdUS19UWVBFX1dJREdFVCwgMywKICAgICAgICAgICAgIEdfVFlQRV9TVFJJTkcsIEdfVFlQ RV9TVFJJTkcsIEdfVFlQRV9IQVNIX1RBQkxFKTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdl YlZpZXc6OnJlc291cmNlLXJlcXVlc3Qtc3RhcnRpbmc6CisgICAgICogQHdlYl92aWV3OiB0aGUg b2JqZWN0IHdoaWNoIHJlY2VpdmVkIHRoZSBzaWduYWwKKyAgICAgKiBAd2ViX2ZyYW1lOiB0aGUg I1dlYktpdFdlYkZyYW1lIHdob3NlIGxvYWQgZGlzcGF0Y2hlZCB0aGlzIHJlcXVlc3QKKyAgICAg KiBAd2ViX3Jlc291cmNlOiBhbiBlbXB0eSAjV2ViS2l0V2ViUmVzb3VyY2Ugb2JqZWN0CisgICAg ICogQHJlcXVlc3Q6IHRoZSAjV2ViS2l0TmV0d29ya1JlcXVlc3QgdGhhdCB3aWxsIGJlIGRpc3Bh dGNoZWQKKyAgICAgKiBAcmVzcG9uc2U6IHRoZSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlIHJlcHJl c2VudGluZyB0aGUgcmVkaXJlY3QKKyAgICAgKiByZXNwb25zZSwgaWYgYW55CisgICAgICoKKyAg ICAgKiBFbWl0dGVkIHdoZW4gYSByZXF1ZXN0IGlzIGFib3V0IHRvIGJlIHNlbnQuIFlvdSBjYW4g bW9kaWZ5IHRoZQorICAgICAqIHJlcXVlc3QsIGJ5IGFkZGluZy9yZW1vdmluZy9yZXBsYWNpbmcg aGVhZGVycywgb3IgY2hhbmdpbmcgdGhlCisgICAgICogVVJJLCB1c2luZyB0aGUgI1NvdXBNZXNz YWdlIG9iamVjdCBpdCBjYXJyaWVzLCBpZiBpdCBpcworICAgICAqIHByZXNlbnQuIFNlZSB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X2dldF9tZXNzYWdlKCkuCisgICAgICoKKyAgICAgKiBOb3RpY2Ug dGhhdCBpbmZvcm1hdGlvbiBhYm91dCBhbiBldmVudHVhbCByZWRpcmVjdCBhcmUKKyAgICAgKiBh dmFpbGFibGUgaW4gQHJlc3BvbnNlJ3MgI1NvdXBNZXNzYWdlLCBub3QgaW4gdGhlICNTb3VwTWVz c2FnZQorICAgICAqIGNhcnJpZWQgYnkgdGhlIEByZXF1ZXN0LiBJZiBAcmVzcG9uc2UgZG9lc24n dCBoYXZlIGEKKyAgICAgKiAjU291cE1lc3NhZ2UgKGkuZS4gaWYgd2Via2l0X25ldHdvcmtfcmVz cG9uc2VfZ2V0X21lc3NhZ2UoKQorICAgICAqIHJldHVybnMgJU5VTEwpLCB0aGVuIHRoaXMgaXMg bm90IGEgcmVkaXJlY3RlZCByZXF1ZXN0LgorICAgICAqCisgICAgICogVGhlICNXZWJLaXRXZWJS ZXNvdXJjZSBvYmplY3Qgd2lsbCBiZSB0aGUgc2FtZSB0aHJvdWdob3V0IGFsbAorICAgICAqIHRo ZSBsaWZldGltZSBvZiB0aGUgcmVzb3VyY2UsIGJ1dCB0aGUgY29udGVudHMgbWF5IGNoYW5nZSBm cm9tCisgICAgICogaW5iZXR3ZWVuIHNpZ25hbCBlbWlzc2lvbnMuCisgICAgICoKKyAgICAgKiBT aW5jZTogMS4xLjE0CisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNbUkVTT1VS Q0VfUkVRVUVTVF9TVEFSVElOR10gPSBnX3NpZ25hbF9uZXcoInJlc291cmNlLXJlcXVlc3Qtc3Rh cnRpbmciLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNzKSwKKyAg ICAgICAgICAgIChHU2lnbmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdOQUxfQUNU SU9OKSwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLCBOVUxMLAorICAgICAgICAg ICAgd2Via2l0X21hcnNoYWxfVk9JRF9fT0JKRUNUX09CSkVDVF9PQkpFQ1RfT0JKRUNULAorICAg ICAgICAgICAgR19UWVBFX05PTkUsIDQsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9XRUJfRlJB TUUsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9XRUJfUkVTT1VSQ0UsCisgICAgICAgICAgICBX RUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9ORVRX T1JLX1JFU1BPTlNFKTsKKwogICAgIC8qCiAgICAgICogaW1wbGVtZW50YXRpb25zIG9mIHZpcnR1 YWwgbWV0aG9kcwogICAgICAqLwpAQCAtMjQ5MSw2ICsyNTM3LDggQEAgc3RhdGljIHZvaWQgd2Vi a2l0X3dlYl92aWV3X2luaXQoV2ViS2l0V2ViVmlldyogd2ViVmlldykKICAgICBnX3NpZ25hbF9j b25uZWN0KHByaXYtPndlYlNldHRpbmdzLCAibm90aWZ5IiwgR19DQUxMQkFDSyh3ZWJraXRfd2Vi X3ZpZXdfc2V0dGluZ3Nfbm90aWZ5KSwgd2ViVmlldyk7CiAKICAgICBwcml2LT53ZWJXaW5kb3dG ZWF0dXJlcyA9IHdlYmtpdF93ZWJfd2luZG93X2ZlYXR1cmVzX25ldygpOworCisgICAgcHJpdi0+ c3ViUmVzb3VyY2VzID0gZ19oYXNoX3RhYmxlX25ld19mdWxsKGdfc3RyX2hhc2gsIGdfc3RyX2Vx dWFsLCBnX2ZyZWUsIGdfb2JqZWN0X3VucmVmKTsKIH0KIAogR3RrV2lkZ2V0KiB3ZWJraXRfd2Vi X3ZpZXdfbmV3KHZvaWQpCkBAIC0zNzc2LDMgKzM4MjQsMjkgQEAgZ2Jvb2xlYW4gd2Via2l0X3dl Yl92aWV3X2dldF92aWV3X3NvdXJjZV9tb2RlIChXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQogCiAg ICAgcmV0dXJuIEZBTFNFOwogfQorCisvLyBJbnRlcm5hbCBzdWJyZXNvdXJjZSBtYW5hZ2VtZW50 Cit2b2lkIHdlYmtpdF93ZWJfdmlld19hZGRfcmVzb3VyY2UoV2ViS2l0V2ViVmlldyogd2ViV2Vi VmlldywgY2hhciogaWRlbnRpZmllciwgV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlKQor eworICAgIFdlYktpdFdlYlZpZXdQcml2YXRlKiBwcml2ID0gd2ViV2ViVmlldy0+cHJpdjsKKyAg ICBnX2hhc2hfdGFibGVfaW5zZXJ0KHByaXYtPnN1YlJlc291cmNlcywgaWRlbnRpZmllciwgd2Vi UmVzb3VyY2UpOworfQorCitXZWJLaXRXZWJSZXNvdXJjZSogd2Via2l0X3dlYl92aWV3X2dldF9y ZXNvdXJjZShXZWJLaXRXZWJWaWV3KiB3ZWJXZWJWaWV3LCBjaGFyKiBpZGVudGlmaWVyKQorewor ICAgIFdlYktpdFdlYlZpZXdQcml2YXRlKiBwcml2ID0gd2ViV2ViVmlldy0+cHJpdjsKKyAgICBX ZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBOVUxMOworCisgICAgZ2Jvb2xlYW4gcmVz b3VyY2VGb3VuZCA9IGdfaGFzaF90YWJsZV9sb29rdXBfZXh0ZW5kZWQocHJpdi0+c3ViUmVzb3Vy Y2VzLCBpZGVudGlmaWVyLCBOVUxMLCByZWludGVycHJldF9jYXN0PGdwb2ludGVyKj4oJndlYlJl c291cmNlKSk7CisKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChyZXNvdXJjZUZvdW5kLCBOVUxM KTsKKworICAgIHJldHVybiBXRUJLSVRfV0VCX1JFU09VUkNFKHdlYlJlc291cmNlKTsKK30KKwor dm9pZCB3ZWJraXRfd2ViX3ZpZXdfcmVtb3ZlX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqIHdlYldl YlZpZXcsIGNoYXIqIGlkZW50aWZpZXIpCit7CisgICAgV2ViS2l0V2ViVmlld1ByaXZhdGUqIHBy aXYgPSB3ZWJXZWJWaWV3LT5wcml2OworICAgIGdfaGFzaF90YWJsZV9yZW1vdmUocHJpdi0+c3Vi UmVzb3VyY2VzLCBpZGVudGlmaWVyKTsKK30KKwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXRtYXJzaGFsLmxpc3QgYi9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdAppbmRleCBhYTBk NDBjLi5jZmY4MDE4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdAor KysgYi9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdApAQCAtMTMsNyArMTMsMTEgQEAgT0JK RUNUOk9CSkVDVAogT0JKRUNUOlNUUklORyxTVFJJTkcsUE9JTlRFUgogT0JKRUNUOlZPSUQKIFZP SUQ6T0JKRUNULE9CSkVDVAorVk9JRDpPQkpFQ1QsT0JKRUNULE9CSkVDVCxPQkpFQ1QKK1ZPSUQ6 T0JKRUNULFBPSU5URVIKIFZPSUQ6T0JKRUNULFBPSU5URVIsUE9JTlRFUgogVk9JRDpPQkpFQ1Qs U1RSSU5HCitWT0lEOk9CSkVDVCxVTE9ORwogVk9JRDpTVFJJTkcKIFZPSUQ6U1RSSU5HLFNUUklO RworVk9JRDpTVFJJTkcsUE9JTlRFUgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9n IGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4IDE4Y2RjYmUuLjIwMzgwOGEgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxOCBAQAorMjAwOS0wOS0wMiAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2 by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjY4NTQKKyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFsbG93IG1vcmUgY29udHJvbCBv dmVyIG91dGdvaW5nIHJlcXVlc3RzCisKKyAgICAgICAgQWRkIGEgdmVyeSBiYXNpYyBpbXBsZW1l bnRhdGlvbiBvZiB0aGUgcmVzb3VyY2UgbG9hZGluZyBkZWxlZ2F0ZXMKKyAgICAgICAgZHVtcGlu Zy4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVyVHJlZS5jcHA6Cisg ICAgICAgICh3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0KToKKyAgICAgICAgKHdlYlZpZXdGaW5pc2hl ZFJlcXVlc3QpOgorICAgICAgICAobWFpbik6CisKIDIwMDktMDktMDMgIEtldmluIFdhdHRlcnMg IDxrZXZpbndhdHRlcnNAZ21haWwuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtldmluIE9s bGl2aWVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBS ZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9EdW1wUmVuZGVy VHJlZS5jcHAKaW5kZXggYWY0NTM1OS4uNjkwYzY1MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC02MDAsNiArNjAwLDQ4IEBA IHN0YXRpYyBnYm9vbGVhbiB3ZWJWaWV3Q2xvc2UoV2ViS2l0V2ViVmlldyogdmlldykKIAogc3Rh dGljIFdlYktpdFdlYlZpZXcqIHdlYlZpZXdDcmVhdGUoV2ViS2l0V2ViVmlldyosIFdlYktpdFdl YkZyYW1lKik7CiAKK3N0YXRpYyB2b2lkIHdlYlJlc291cmNlTG9hZFN0YXR1c0NoYW5nZWQoR09i amVjdCogb2JqZWN0LCBHUGFyYW1TcGVjKiBwc3BlYywgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICAv LyBGSVhNRTogPHVua25vd24+IGhlcmUgaXMsIG9uIE1hYywgdGhlIHN0cmluZyByZXByZXNlbnRh dGlvbiBvZgorICAgIC8vIHRoZSBvYmplY3QgdGhlIGlkZW50aWZpZXIgbWFwcyB0bworICAgIGlm ICghZG9uZSAmJiBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBSZXNvdXJjZUxvYWRDYWxsYmFj a3MoKSkKKyAgICAgICAgcHJpbnRmICgiPHVua25vd24+IC0gZGlkRmluaXNoTG9hZGluZ1xuIik7 Cit9CisKKy8vIEZJWE1FOiB0ZXN0cyB0aGF0IHVzZSB3aWxsU2VuZFJlcXVlc3QgYXJlIHRvbyBD Rk5ldHdvcmstY2VudHJpYzsgd2UKKy8vIHNob3VsZCBtYWtlIHRoZW0gbW9yZSBnZW5lcmljCitz dGF0aWMgdm9pZCB3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0KFdlYktpdFdlYlZpZXcqIHZpZXcsIFdl YktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0V2ViUmVzb3VyY2UqIHJlc291cmNlLCBXZWJLaXRO ZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSwg Z3BvaW50ZXIgZGF0YSkKK3sKKyAgICBTb3VwTWVzc2FnZSogbWVzc2FnZSA9IHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UocmVxdWVzdCk7CisgICAgY2hhciogdXJpID0gbWVzc2Fn ZSA/IHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwX21lc3NhZ2VfZ2V0X3VyaShtZXNzYWdlKSwgRkFM U0UpIDogZ19zdHJkdXAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJpKHJlcXVlc3QpKTsK KyAgICBjb25zdCBjaGFyKiByZWZlcmVyID0gTlVMTDsKKworICAgIGlmIChtZXNzYWdlKQorICAg ICAgICByZWZlcmVyID0gc291cF9tZXNzYWdlX2hlYWRlcnNfZ2V0X29uZSAobWVzc2FnZS0+cmVx dWVzdF9oZWFkZXJzLCAiUmVmZXJlciIpOworCisgICAgaWYgKCFkb25lICYmIGdMYXlvdXRUZXN0 Q29udHJvbGxlci0+ZHVtcFJlc291cmNlTG9hZENhbGxiYWNrcygpKSB7CisgICAgICAgIC8vIEZJ WE1FOiBoYW5kbGUgcmVzcG9uc2UgY29ycmVjdGx5IGhlcmUhCisgICAgICAgIHByaW50ZiAoIiVz IC0gd2lsbFNlbmRSZXF1ZXN0IDxOU1VSTFJlcXVlc3QgVVJMICVzLCBtYWluIGRvY3VtZW50IFVS TCAlcywgaHR0cCBtZXRob2QgJXM+IHJlZGlyZWN0UmVzcG9uc2UgKG51bGwpXG4iLCB1cmksIHVy aSwgcmVmZXJlciwgbWVzc2FnZS0+bWV0aG9kKTsKKyAgICB9CisKKyAgICBTb3VwVVJJKiBzb3Vw VVJJID0gc291cF91cmlfbmV3KHVyaSk7CisKKyAgICBpZiAoKCFnX2FzY2lpX3N0cmNhc2VjbXAo Imh0dHAiLCBzb3VwVVJJLT5zY2hlbWUpIHx8ICFnX2FzY2lpX3N0cmNhc2VjbXAoImh0dHBzIiwg c291cFVSSS0+c2NoZW1lKSkKKyAgICAgICAgJiYgZ19hc2NpaV9zdHJjYXNlY21wKCIxMjcuMC4w LjEiLCBzb3VwVVJJLT5ob3N0KQorICAgICAgICAmJiBnX2FzY2lpX3N0cmNhc2VjbXAoIjI1NS4y NTUuMjU1LjI1NSIsIHNvdXBVUkktPmhvc3QpCisgICAgICAgICYmIGdfYXNjaWlfc3RyY2FzZWNt cCgibG9jYWxob3N0Iiwgc291cFVSSS0+aG9zdCkpIHsKKyAgICAgICAgcHJpbnRmKCJCbG9ja2Vk IGFjY2VzcyB0byBleHRlcm5hbCBVUkwgJXNcbiIsIHVyaSk7CisgICAgICAgIHdlYmtpdF9uZXR3 b3JrX3JlcXVlc3Rfc2V0X3VyaShyZXF1ZXN0LCAiYWJvdXQ6YmxhbmsiKTsKKyAgICB9CisKKyAg ICBnX2ZyZWUodXJpKTsKKyAgICBzb3VwX3VyaV9mcmVlKHNvdXBVUkkpOworCisgICAgZ19zaWdu YWxfY29ubmVjdChyZXNvdXJjZSwgIm5vdGlmeTo6bG9hZC1zdGF0dXMiLAorICAgICAgICAgICAg ICAgICAgICAgR19DQUxMQkFDSyh3ZWJSZXNvdXJjZUxvYWRTdGF0dXNDaGFuZ2VkKSwgMCk7CisK K30KKwogc3RhdGljIFdlYktpdFdlYlZpZXcqIGNyZWF0ZVdlYlZpZXcoKQogewogICAgIFdlYktp dFdlYlZpZXcqIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsK QEAgLTYyMSw2ICs2NjMsNyBAQCBzdGF0aWMgV2ViS2l0V2ViVmlldyogY3JlYXRlV2ViVmlldygp CiAgICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpzdGF0dXMtYmFyLXRleHQtY2hhbmdlZCIs IHdlYlZpZXdTdGF0dXNCYXJUZXh0Q2hhbmdlZCwgMCwKICAgICAgICAgICAgICAgICAgICAgICJz aWduYWw6OmNyZWF0ZS13ZWItdmlldyIsIHdlYlZpZXdDcmVhdGUsIDAsCiAgICAgICAgICAgICAg ICAgICAgICAic2lnbmFsOjpjbG9zZS13ZWItdmlldyIsIHdlYlZpZXdDbG9zZSwgMCwKKyAgICAg ICAgICAgICAgICAgICAgICJzaWduYWw6OnJlc291cmNlLXJlcXVlc3Qtc3RhcnRpbmciLCB3ZWJW aWV3T3V0Z29pbmdSZXF1ZXN0LCAwLAogICAgICAgICAgICAgICAgICAgICAgTlVMTCk7CiAKICAg ICByZXR1cm4gdmlldzsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4u YyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwppbmRleCA2OTk0Njc0Li5iNjY2NWE0 IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKKysrIGIvV2ViS2l0 VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCkBAIC0xMDksNiArMTA5LDQ2IEBAIGdvX2ZvcndhcmRf Y2IgKEd0a1dpZGdldCogd2lkZ2V0LCBncG9pbnRlciBkYXRhKQogICAgIHdlYmtpdF93ZWJfdmll d19nb19mb3J3YXJkICh3ZWJfdmlldyk7CiB9CiAKK3N0YXRpYyB2b2lkCitsb2FkX3N0YXR1c19j aGFuZ2VkX2NiKEdPYmplY3QqIG9iamVjdCwgR1BhcmFtU3BlYyogcHNwZWMsIGdwb2ludGVyIGRh dGEpCit7CisgICAgV2ViS2l0V2ViUmVzb3VyY2UqIHdlYl9yZXNvdXJjZSA9IFdFQktJVF9XRUJf UkVTT1VSQ0UgKG9iamVjdCk7CisgICAgY29uc3QgY2hhciogbWltZV90eXBlOworCisgICAgZ19k ZWJ1ZyAoIm9iamVjdDogJXAgfCBuZXcgc3RhdHVzOiAlZCIsIHdlYl9yZXNvdXJjZSwgd2Via2l0 X3dlYl9yZXNvdXJjZV9nZXRfbG9hZF9zdGF0dXMgKHdlYl9yZXNvdXJjZSkpOworCisgICAgbWlt ZV90eXBlID0gd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfbWltZV90eXBlKHdlYl9yZXNvdXJjZSk7 CisgICAgZ19kZWJ1ZyAoIm1pbWU6ICVzIiwgbWltZV90eXBlKTsKKworICAgIGlmIChtaW1lX3R5 cGUgJiYgKGdfc3RyX2VxdWFsKCJ0ZXh0L2h0bWwiLCBtaW1lX3R5cGUpIHx8IGdfc3RyX2hhc19w cmVmaXgobWltZV90eXBlLCAidGV4dC8iKSkpCisgICAgICAgIGdfZGVidWcgKCJmcmFtZSBuYW1l OiAlc1xuZGF0YTogJXMiLAorICAgICAgICAgICAgICAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2dl dF9mcmFtZV9uYW1lKHdlYl9yZXNvdXJjZSksCisgICAgICAgICAgICAgICAgIHdlYmtpdF93ZWJf cmVzb3VyY2VfZ2V0X2RhdGEod2ViX3Jlc291cmNlKS0+c3RyKTsKK30KKworc3RhdGljIHZvaWQK K2xvYWRfZXJyb3JfY2IoV2ViS2l0V2ViUmVzb3VyY2UqIHdlYl9yZXNvdXJjZSwgY29uc3QgY2hh ciogdXJpLCBHRXJyb3IqIHdlYl9lcnJvcikKK3sKKyAgICBnX2RlYnVnICgiRVJST1I6ICVzIHwg JXMiLCB1cmksIHdlYl9lcnJvci0+bWVzc2FnZSk7Cit9CisKK3N0YXRpYyB2b2lkIG91dGdvaW5n X3JlcXVlc3RfY2IoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJf ZnJhbWUsIFdlYktpdFdlYlJlc291cmNlKiB3ZWJfcmVzb3VyY2UsIFdlYktpdE5ldHdvcmtSZXF1 ZXN0KiByZXF1ZXN0LCBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBncG9pbnRlciBk YXRhKQoreworICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdlOworCisgICAgZ19kZWJ1ZyAoIlxuT1VU R09JTkc6ICVwIC8gJXMiLCB3ZWJfcmVzb3VyY2UsIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0 X3VyaSAocmVxdWVzdCkpOworICAgIGdfb2JqZWN0X3JlZiAod2ViX3Jlc291cmNlKTsKKworICAg IG1lc3NhZ2UgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZSAocmVzcG9uc2Up OworICAgIGlmIChtZXNzYWdlKQorICAgICAgICBnX2RlYnVnICgiUkVESVJFQ1QhIExvY2F0aW9u OiAlcyIsIHNvdXBfbWVzc2FnZV9oZWFkZXJzX2dldF9vbmUobWVzc2FnZS0+cmVzcG9uc2VfaGVh ZGVycywgIkxvY2F0aW9uIikpOworICAgIGVsc2UKKyAgICAgICAgZ19kZWJ1ZyAoIk5PUk1BTCBS RVFVRVNUIik7CisKKyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYl9yZXNvdXJjZSwgIm5vdGlmeTo6 bG9hZC1zdGF0dXMiLCBHX0NBTExCQUNLKGxvYWRfc3RhdHVzX2NoYW5nZWRfY2IpLCBOVUxMKTsK KyAgICBnX3NpZ25hbF9jb25uZWN0KHdlYl9yZXNvdXJjZSwgImxvYWQtZXJyb3IiLCBHX0NBTExC QUNLKGxvYWRfZXJyb3JfY2IpLCBOVUxMKTsKK30KKwogc3RhdGljIEd0a1dpZGdldCoKIGNyZWF0 ZV9icm93c2VyICgpCiB7CkBAIC0xMjIsNiArMTYyLDcgQEAgY3JlYXRlX2Jyb3dzZXIgKCkKICAg ICBnX3NpZ25hbF9jb25uZWN0ICh3ZWJfdmlldywgIm5vdGlmeTo6bG9hZC1zdGF0dXMiLCBHX0NB TExCQUNLIChub3RpZnlfbG9hZF9zdGF0dXNfY2IpLCB3ZWJfdmlldyk7CiAgICAgZ19zaWduYWxf Y29ubmVjdCAod2ViX3ZpZXcsICJub3RpZnk6OnByb2dyZXNzIiwgR19DQUxMQkFDSyAobm90aWZ5 X3Byb2dyZXNzX2NiKSwgd2ViX3ZpZXcpOwogICAgIGdfc2lnbmFsX2Nvbm5lY3QgKHdlYl92aWV3 LCAiaG92ZXJpbmctb3Zlci1saW5rIiwgR19DQUxMQkFDSyAobGlua19ob3Zlcl9jYiksIHdlYl92 aWV3KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0ICh3ZWJfdmlldywgInJlc291cmNlLXJlcXVlc3Qt c3RhcnRpbmciLCBHX0NBTExCQUNLIChvdXRnb2luZ19yZXF1ZXN0X2NiKSwgd2ViX3ZpZXcpOwog CiAgICAgcmV0dXJuIHNjcm9sbGVkX3dpbmRvdzsKIH0KLS0gCjEuNi4zLjMKCg== 39076 2009-09-04 10:48:34 -0700 2009-09-04 10:48:34 -0700 the traditional Epiphany implementation as an example 0001-Basic-adblocking.patch text/plain 2535 gustavo RnJvbSA4OWM1MjllMTZiYTJmYzFiYzAwZWVjYjYwOTVlYTg1MTM3MTBhOGM0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFR1ZSwgMzAgSnVuIDIwMDkgMTY6Mjk6NTEgLTAzMDAK U3ViamVjdDogW1BBVENIXSBCYXNpYyBhZGJsb2NraW5nCgotLS0KIGVtYmVkL2VwaHktZW1iZWQu YyB8ICAgMjUgKysrKysrKysrKysrKysrKysrKysrKysrKwogMSBmaWxlcyBjaGFuZ2VkLCAyNSBp bnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2VtYmVkL2VwaHktZW1i ZWQuYyBiL2VtYmVkL2VwaHktZW1iZWQuYwppbmRleCAxZDVkYWEyLi4yNGJmYmI1IDEwMDY0NAot LS0gYS9lbWJlZC9lcGh5LWVtYmVkLmMKKysrIGIvZW1iZWQvZXBoeS1lbWJlZC5jCkBAIC0yNyw2 ICsyNyw3IEBACiAKICNpbmNsdWRlICJkb3dubG9hZGVyLXZpZXcuaCIKICNpbmNsdWRlICJlZWwt Z2NvbmYtZXh0ZW5zaW9ucy5oIgorI2luY2x1ZGUgImVwaHktYWRibG9jay1tYW5hZ2VyLmgiCiAj aW5jbHVkZSAiZXBoeS1jb21tYW5kLW1hbmFnZXIuaCIKICNpbmNsdWRlICJlcGh5LWRlYnVnLmgi CiAjaW5jbHVkZSAiZXBoeS1lbWJlZC5oIgpAQCAtMTk2LDYgKzE5NywyOSBAQCByZXN0b3JlX3pv b21fbGV2ZWwgKEVwaHlFbWJlZCAqZW1iZWQsCiB9CiAKIHN0YXRpYyB2b2lkCityZXNvdXJjZV9y ZXF1ZXN0X3N0YXJ0aW5nX2NiIChXZWJLaXRXZWJWaWV3ICp3ZWJfdmlldywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFdlYktpdFdlYkZyYW1lICp3ZWJfZnJhbWUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBXZWJLaXRXZWJSZXNvdXJjZSAqd2ViX3Jlc291cmNlLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0TmV0d29ya1JlcXVlc3QgKnJlcXVlc3Qs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UgKnJl c3BvbnNlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRXBoeUVtYmVkICplbWJlZCkK K3sKKyAgRXBoeUFkQmxvY2tNYW5hZ2VyICphZGJsb2NrX21hbmFnZXIgPSBFUEhZX0FEQkxPQ0tf TUFOQUdFUihlcGh5X2VtYmVkX3NoZWxsX2dldF9hZGJsb2NrX21hbmFnZXIgKGVtYmVkX3NoZWxs KSk7CisgIGNvbnN0IGNoYXIqIHVyaSA9IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShy ZXF1ZXN0KTsKKworICAvKiBGSVhNRTogSG93IGRvIHdlIGltcGxlbWVudCB0aGUgb3RoZXIgQ0hF Q0tfVFlQRXM/ICBQZXJoYXBzIHdlCisgICAqIHNob3VsZCBmaWd1cmUgb3V0IGEgd2F5IG9mIGFk ZGluZyBtb3JlIGluZm9ybWF0aW9uIGFib3V0IHdoYXQgdGhlCisgICAqIHJlc291cmNlIGlzIGZv ciB0byBXZWJSZXNvdXJjZT8gKi8KKyAgaWYoIWVwaHlfYWRibG9ja19tYW5hZ2VyX3Nob3VsZF9s b2FkKGFkYmxvY2tfbWFuYWdlciwgZW1iZWQsIHVyaSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIEFEX1VSSV9DSEVDS19UWVBFX09USEVSKSkgeworICAgIGdfc2lnbmFs X2VtaXRfYnlfbmFtZSAoRVBIWV9XRUJfVklFVyAod2ViX3ZpZXcpLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgImNvbnRlbnQtYmxvY2tlZCIsIHVyaSk7CisKKyAgICB3ZWJraXRfbmV0d29y a19yZXF1ZXN0X3NldF91cmkocmVxdWVzdCwgImFib3V0OmJsYW5rIik7CisgIH0KK30KKworc3Rh dGljIHZvaWQKIGxvYWRfc3RhdHVzX2NoYW5nZWRfY2IgKFdlYktpdFdlYlZpZXcgKnZpZXcsCiAg ICAgICAgICAgICAgICAgICAgICAgICBHUGFyYW1TcGVjICpzcGVjLAogICAgICAgICAgICAgICAg ICAgICAgICAgRXBoeUVtYmVkICplbWJlZCkKQEAgLTc1MCw2ICs3NzQsNyBAQCBlcGh5X2VtYmVk X2NvbnN0cnVjdGVkIChHT2JqZWN0ICpvYmplY3QpCiAKICAgZ19vYmplY3RfY29ubmVjdCAod2Vi X3ZpZXcsCiAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6Om5vdGlmeTo6bG9hZC1zdGF0dXMi LCBHX0NBTExCQUNLIChsb2FkX3N0YXR1c19jaGFuZ2VkX2NiKSwgZW1iZWQsCisgICAgICAgICAg ICAgICAgICAgICJzaWduYWw6OnJlc291cmNlLXJlcXVlc3Qtc3RhcnRpbmciLCBHX0NBTExCQUNL IChyZXNvdXJjZV9yZXF1ZXN0X3N0YXJ0aW5nX2NiKSwgZW1iZWQsCiAgICAgICAgICAgICAgICAg ICAgICJzaWduYWw6OmhvdmVyaW5nLW92ZXItbGluayIsIEdfQ0FMTEJBQ0sgKGhvdmVyaW5nX292 ZXJfbGlua19jYiksIGVtYmVkLAogICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjptaW1lLXR5 cGUtcG9saWN5LWRlY2lzaW9uLXJlcXVlc3RlZCIsIEdfQ0FMTEJBQ0sgKG1pbWVfdHlwZV9wb2xp Y3lfZGVjaXNpb25fcmVxdWVzdGVkX2NiKSwgZW1iZWQsCiAgICAgICAgICAgICAgICAgICAgICJz aWduYWw6OmRvd25sb2FkLXJlcXVlc3RlZCIsIEdfQ0FMTEJBQ0sgKGRvd25sb2FkX3JlcXVlc3Rl ZF9jYiksIGVtYmVkLAotLSAKMS42LjMuMwoK 39081 2009-09-04 12:11:28 -0700 2009-09-07 07:45:23 -0700 third draft, with some comments by Xan addressed, and no load-status/load-error for resources 0001-New-signals-to-better-handle-resource-loading.patch text/plain 46024 gustavo RnJvbSA4ZGJmMzllNjQwMjExZDM4NGQ2YjJiMmVhOWZkOTIwZjI2MWY1MzcwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFdlZCwgMiBTZXAgMjAwOSAxNTo1NDoxMSAtMDMwMApT dWJqZWN0OiBbUEFUQ0ggMS80XSBOZXcgc2lnbmFscyB0byBiZXR0ZXIgaGFuZGxlIHJlc291cmNl IGxvYWRpbmcKCi0tLQogQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDEwICsKIEdOVW1ha2VmaWxlLmFtICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgOCArCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgMTUgKysKIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlLmggICB8ICAgIDQgKwogLi4uL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlU291cC5jcHAgfCAgIDU1ICsrKysKIFdlYktpdC9ndGsvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2NSArKysrKwogV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgfCAgIDYzICsrKysr LQogV2ViS2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMgICAgICAgICAgICAgfCAg MTA4ICsrKysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaCAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgIDEgKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oICAgICAg ICAgICAgICAgICAgfCAgICAzICsKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1 ZXN0LmNwcCAgICAgICAgIHwgICAxMCAtCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVzcG9uc2UuY3BwICAgICAgICB8ICAyNjYgKysrKysrKysrKysrKysrKysrKysKIFdlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oICAgICAgICAgIHwgICA3NCArKysrKysK IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuY3BwICAgICAgICAgICAgICAgIHwgICAg OSArCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8 ICAgMjQgKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcCAgICAgICAg ICAgIHwgICA1NCArKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAg ICAgICAgICAgICAgfCAgIDc5ICsrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0bWFyc2hhbC5saXN0 ICAgICAgICAgICAgICAgICAgICAgIHwgICAgNCArCiAxOSBmaWxlcyBjaGFuZ2VkLCA4MjUgaW5z ZXJ0aW9ucygrKSwgMjggZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZVNvdXAuY3BwCiBjcmVhdGUgbW9k ZSAxMDA2NDQgV2ViS2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMKIGNyZWF0ZSBt b2RlIDEwMDY0NCBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwCiBj cmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNl LmgKCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggYTUxNTI5Yy4uNGUx NGYyYSAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEz IEBACisyMDA5LTA5LTA0ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFA Y29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAor ICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29p bmcgcmVxdWVzdHMKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOiBuZXcgZmlsZXMgYWRkZWQg dG8gdGhlIGJ1aWxkIGZvciBuZXcgY2xhc3MKKyAgICAgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNl CisKIDIwMDktMDktMDQgIEFsYmVydCBCYWNoYW5kICA8YWxiZXJ0YkBnb29nbGUuY29tPgogCiAg ICAgICAgIFJldmlld2VkIGJ5IEVyaWMgU2VpZGVsLgpkaWZmIC0tZ2l0IGEvR05VbWFrZWZpbGUu YW0gYi9HTlVtYWtlZmlsZS5hbQppbmRleCA1M2EwNGNkLi40N2RkZmI0IDEwMDY0NAotLS0gYS9H TlVtYWtlZmlsZS5hbQorKysgYi9HTlVtYWtlZmlsZS5hbQpAQCAtMzE5LDYgKzMxOSw3IEBAIHdl YmtpdGd0a19oX2FwaSArPSBcCiAJJChzcmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRv d25sb2FkLmggXAogCSQoc3JjZGlyKS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRlcnJvci5oIFwK IAkkKHNyY2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuaCBcCisJ JChzcmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oIFwKIAkk KHNyY2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuaCBcCiAJJChz cmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIFwKIAkk KHNyY2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2ViZGF0YXNvdXJjZS5oIFwKQEAgLTM2 MCw2ICszNjEsNyBAQCB3ZWJraXRndGtfc291cmNlcyArPSBcCiAJV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0ZG93bmxvYWQuY3BwIFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRlcnJvci5jcHAg XAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBcCisJV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0cHJpdmF0ZS5jcHAgXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu aCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuYyBcCkBAIC01Mjcs NiArNTI5LDcgQEAgd2Via2l0X3Rlc3RzX2xkZmxhZ3MgPSBcCiBURVNUX1BST0dTICs9IFByb2dy YW1zL3VuaXR0ZXN0cy90ZXN0aHR0cGJhY2tlbmQgXAogCVByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0 bG9hZGluZyBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3RuZXR3b3JrcmVxdWVzdCBcCisJUHJv Z3JhbXMvdW5pdHRlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UgXAogCVByb2dyYW1zL3VuaXR0ZXN0 cy90ZXN0d2ViZnJhbWUgXAogCVByb2dyYW1zL3VuaXR0ZXN0cy90ZXN0d2ViYmFja2ZvcndhcmRs aXN0IFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdlYmhpc3RvcnlpdGVtIFwKQEAgLTU1Myw2 ICs1NTYsMTEgQEAgUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RuZXR3b3JrcmVxdWVzdF9DRkxBR1Mg PSAkKHdlYmtpdF90ZXN0c19jZmxhZ3MpCiBQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmty ZXF1ZXN0X0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCiBQcm9ncmFtc191bml0dGVzdHNf dGVzdG5ldHdvcmtyZXF1ZXN0X0xERkxBR1MgPSAkKHdlYmtpdF90ZXN0c19sZGZsYWdzKQogCitQ cm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXNwb25zZV9TT1VSQ0VTID0gV2ViS2l0L2d0 ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMKK1Byb2dyYW1zX3VuaXR0ZXN0c190ZXN0bmV0 d29ya3Jlc3BvbnNlX0NGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2NmbGFncykKK1Byb2dyYW1zX3Vu aXR0ZXN0c190ZXN0bmV0d29ya3Jlc3BvbnNlX0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQp CitQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXNwb25zZV9MREZMQUdTID0gJCh3ZWJr aXRfdGVzdHNfbGRmbGFncykKKwogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3ZWJmcmFtZV9TT1VS Q0VTID0gV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2ViZnJhbWUuYwogUHJvZ3JhbXNfdW5pdHRlc3Rz X3Rlc3R3ZWJmcmFtZV9DRkxBR1MgPSAkKHdlYmtpdF90ZXN0c19jZmxhZ3MpCiBQcm9ncmFtc191 bml0dGVzdHNfdGVzdHdlYmZyYW1lX0xEQUREID0gJCh3ZWJraXRfdGVzdHNfbGRhZGQpCmRpZmYg LS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDhiYmJm ZGQuLmM0YTA2M2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMDktMDktMDQgIEd1c3Rhdm8gTm9yb25oYSBT aWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI2ODU0CisgICAgICAgIFtHVEtdIE5lZWRzIEFQSSB0byBhbGxvdyBt b3JlIGNvbnRyb2wgb3ZlciBvdXRnb2luZyByZXF1ZXN0cworCisgICAgICAgIEFkZCBpbmZyYXN0 cnVjdHVyZSByZXF1aXJlZCB0byBwcm92aWRlIHRoZSBuZXcKKyAgICAgICAgV2ViS2l0TmV0d29y a1Jlc3BvbnNlIG9iamVjdCBpbiBvdXIgQVBJLgorCisgICAgICAgICogR05VbWFrZWZpbGUuYW06 IEFkZCBuZXcgZmlsZXMgdG8gdGhlIGJ1aWxkLgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlLmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlUmVzcG9uc2VTb3VwLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpSZXNv dXJjZVJlc3BvbnNlOjp0b1NvdXBNZXNzYWdlKToKKwogMjAwOS0wOS0wNCAgQWxleGV5IFByb3Nr dXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBFcmljIFNlaWRl bC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2Vm aWxlLmFtCmluZGV4IDhiYjhkM2IuLjA2OTU1MzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFr ZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTk2MSw2ICsxOTYxLDcg QEAgd2ViY29yZWd0a19zb3VyY2VzICs9IFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZUVycm9yLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdFNvdXAuY3BwIFwKKwlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZVJlc3BvbnNlU291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jl c291cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJj ZVJlc3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vdGV4dC9ndGsvVGV4dEJyZWFrSXRlcmF0 b3JJbnRlcm5hbElDVUd0ay5jcHAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlUmVzcG9uc2UuaAppbmRleCBiOGNiNTg2Li41ZmEzMWEwIDEwMDY0NAotLS0gYS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZS5oCkBAIC0yOCw2ICsy OCw4IEBACiAKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNlQmFzZS5oIgogCisjaW5jbHVkZSA8 bGlic291cC9zb3VwLmg+CisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgUmVzb3VyY2VS ZXNwb25zZSA6IHB1YmxpYyBSZXNvdXJjZVJlc3BvbnNlQmFzZSB7CkBAIC00Miw2ICs0NCw4IEBA IHB1YmxpYzoKICAgICB7CiAgICAgfQogCisgICAgU291cE1lc3NhZ2UqIHRvU291cE1lc3NhZ2Uo KSBjb25zdDsKKwogcHJpdmF0ZToKICAgICBmcmllbmQgY2xhc3MgUmVzb3VyY2VSZXNwb25zZUJh c2U7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNl UmVzcG9uc2VTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNl UmVzcG9uc2VTb3VwLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZDdm ZDE2Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVz b3VyY2VSZXNwb25zZVNvdXAuY3BwCkBAIC0wLDAgKzEsNTUgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQ29s bGFib3JhIEx0ZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGVzc2VyIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFu a2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0Eu CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2Uu aCIKKworI2luY2x1ZGUgIkNTdHJpbmcuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5jbHVk ZSAiUGxhdGZvcm1TdHJpbmcuaCIKKworI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgorCit1c2lu ZyBuYW1lc3BhY2Ugc3RkOworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1NvdXBNZXNzYWdlKiBS ZXNvdXJjZVJlc3BvbnNlOjp0b1NvdXBNZXNzYWdlKCkgY29uc3QKK3sKKyAgICAvLyBUaGlzIEdF VCBoZXJlIGlzIGp1c3QgYmVjYXVzZSBTb3VwTWVzc2FnZSB3YW50cyBpdCwgd2UgZG4ndCByZWFs bHkga25vdy4KKyAgICBTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UgPSBzb3VwX21lc3NhZ2VfbmV3 KCJHRVQiLCB1cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBpZiAoIXNvdXBNZXNz YWdlKQorICAgICAgICByZXR1cm4gMDsKKworICAgIHNvdXBNZXNzYWdlLT5zdGF0dXNfY29kZSA9 IGh0dHBTdGF0dXNDb2RlKCk7CisKKyAgICBIVFRQSGVhZGVyTWFwIGhlYWRlcnMgPSBodHRwSGVh ZGVyRmllbGRzKCk7CisgICAgU291cE1lc3NhZ2VIZWFkZXJzKiBzb3VwSGVhZGVycyA9IHNvdXBN ZXNzYWdlLT5yZXNwb25zZV9oZWFkZXJzOworICAgIGlmICghaGVhZGVycy5pc0VtcHR5KCkpIHsK KyAgICAgICAgSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gaGVhZGVycy5lbmQo KTsKKyAgICAgICAgZm9yIChIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IGhlYWRl cnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAgICAgc291cF9tZXNzYWdlX2hl YWRlcnNfYXBwZW5kKHNvdXBIZWFkZXJzLCBpdC0+Zmlyc3Quc3RyaW5nKCkudXRmOCgpLmRhdGEo KSwgaXQtPnNlY29uZC51dGY4KCkuZGF0YSgpKTsKKyAgICB9CisKKyAgICAvLyBCb2R5IGRhdGEg aXMgbm90IGluIHRoZSBtZXNzYWdlLgorICAgIHJldHVybiBzb3VwTWVzc2FnZTsKK30KKworfQpk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpp bmRleCBlMjg4ZDkxLi4xZDVjOWEwIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZwor KysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY4IEBACisyMDA5LTA5LTAyICBH dXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVk cyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAg ICAgICBNYXAgdGhlIHdpbGxTZW5kUmVxdWVzdCBkZWxlZ2F0ZSB0byB0aGUgJ3Jlc291cmNlLXJl cXVlc3Qtc3RhcnRpbmcnCisgICAgICAgIHNpZ25hbCwgYWxsb3dpbmcgbW9yZSBjb250cm9sIG9m IHRoZSByZXNvdXJjZXMgdGhhdCBhcmUgZmV0Y2hlZC4KKworICAgICAgICBXZSBub3cgbWFwIHRo ZSBpZGVudGlmaWVycyBhc3NpZ25lZCBieSBXZWJDb3JlIHRvIHRoZSByZXNvdXJjZXMgaXQgbG9h ZHMKKyAgICAgICAgdG8gV2ViS2l0V2ViUmVzb3VyY2Ugb2JqZWN0cywgc3RvcmVkIGluIGEgR0hh c2hUYWJsZSBpbnNpZGUgdGhlCisgICAgICAgIFdlYktpdFdlYlZpZXcgb2JqZWN0LgorCisgICAg ICAgIE1hcHBpbmcgd2lsbFNlbmRSZXF1ZXN0IHByb3Blcmx5IHJlcXVpcmVzIGFuIGFwcHJvcHJp YXRlIFJlc3BvbnNlCisgICAgICAgIG9iamVjdCwgc28gd2UgYXJlIGludHJvZHVjaW5nIFdlYktp dE5ldHdvcmtSZXNwb25zZSwgd2hpY2ggd29ya3MgaW4gYQorICAgICAgICB3YXkgc2ltaWxhciB0 byBXZWJLaXROZXR3b3JrUmVxdWVzdC4KKworICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6aWRlbnRpZmllclRvU3RyaW5n KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoV2lsbFNlbmRS ZXF1ZXN0KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmFzc2lnbklkZW50 aWZpZXJUb0luaXRpYWxSZXF1ZXN0KToKKyAgICAgICAgKFdlYktpdDo6RnJhbWVMb2FkZXJDbGll bnQ6OmRpc3BhdGNoRGlkUmVjZWl2ZUNvbnRlbnRMZW5ndGgpOgorICAgICAgICAoV2ViS2l0OjpG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGaW5pc2hMb2FkaW5nKToKKyAgICAgICAgKFdl YktpdDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkRmFpbExvYWRpbmcpOgorICAgICAg ICAqIHRlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UuYzogQWRkZWQuCisgICAgICAgICh0ZXN0X25l dHdvcmtfcmVzcG9uc2VfY3JlYXRlX2Rlc3Ryb3kpOgorICAgICAgICAodGVzdF9uZXR3b3JrX3Jl c3BvbnNlX3Byb3BlcnRpZXMpOgorICAgICAgICAobWFpbik6CisgICAgICAgICogd2Via2l0L3dl YmtpdC5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRkZWZpbmVzLmg6CisgICAgICAgICogd2Vi a2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0bmV0 d29ya3Jlc3BvbnNlLmNwcDogQWRkZWQuCisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9maW5hbGl6ZSk6CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfcHJvcGVy dHkpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3Byb3BlcnR5KToKKyAg ICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2NsYXNzX2luaXQpOgorICAgICAgICAod2Vi a2l0X25ldHdvcmtfcmVzcG9uc2VfaW5pdCk6CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNw b25zZV9uZXdfd2l0aF9jb3JlX3Jlc3BvbnNlKToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX25ldyk6CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJpKToK KyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkpOgorICAgICAgICAod2Vi a2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2UpOgorICAgICAgICAqIHdlYmtpdC93ZWJr aXRuZXR3b3JrcmVzcG9uc2UuaDogQWRkZWQuCisgICAgICAgICogd2Via2l0L3dlYmtpdHByaXZh dGUuY3BwOgorICAgICAgICAoV1RGOjpTb3VwTWVzc2FnZSk6CisgICAgICAgICogd2Via2l0L3dl YmtpdHByaXZhdGUuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwOgor ICAgICAgICAod2Via2l0X3dlYl9yZXNvdXJjZV9jbGVhbnVwKToKKyAgICAgICAgKHdlYmtpdF93 ZWJfcmVzb3VyY2VfZmluYWxpemUpOgorICAgICAgICAod2Via2l0X3dlYl9yZXNvdXJjZV9jbGFz c19pbml0KToKKyAgICAgICAgKHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X3Byb3BlcnR5KToKKyAg ICAgICAgKHdlYmtpdF93ZWJfcmVzb3VyY2VfaW5pdF93aXRoX2NvcmVfcmVzb3VyY2UpOgorICAg ICAgICAod2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKToKKyAgICAgICAgKHdlYmtpdF93ZWJf cmVzb3VyY2VfZ2V0X2xvYWRfc3RhdHVzKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2VicmVz b3VyY2UuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CisgICAgICAgICh3 ZWJraXRfd2ViX3ZpZXdfZGlzcG9zZSk6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfY2xhc3Nf aW5pdCk6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfaW5pdCk6CisgICAgICAgICh3ZWJraXRf d2ViX3ZpZXdfYWRkX3Jlc291cmNlKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19nZXRfcmVz b3VyY2UpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJjZSk6CisgICAg ICAgICogd2Via2l0bWFyc2hhbC5saXN0OgorCiAyMDA5LTA5LTAzICBBZGFtIEJhcnRoICA8YWJh cnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgZXJpY0B3ZWJraXQub3JnLgpk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0 ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNw cAppbmRleCBkODU5MWJkLi5mMGM5OThhIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1 ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50R3RrLmgiCiAKKyNpbmNs dWRlICJBcmNoaXZlUmVzb3VyY2UuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUgIkRv Y3VtZW50TG9hZGVyLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXJHdGsuaCIKQEAgLTU0LDYg KzU1LDcgQEAKICNpbmNsdWRlICJTY3JpcHRDb250cm9sbGVyLmgiCiAjaW5jbHVkZSAid2Via2l0 ZXJyb3IuaCIKICNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVxdWVzdC5oIgorI2luY2x1ZGUgIndl YmtpdG5ldHdvcmtyZXNwb25zZS5oIgogI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKICNpbmNs dWRlICJ3ZWJraXR3ZWJmcmFtZS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYm5hdmlnYXRpb25hY3Rp b24uaCIKQEAgLTE4MSwxNSArMTgzLDU1IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3Bh dGNoRGlkQ2FuY2VsQXV0aGVudGljYXRpb25DaGFsbGVuZ2UoV2ViQ29yZTo6RG9jdW1lCiAgICAg bm90SW1wbGVtZW50ZWQoKTsKIH0KIAorLy8gV2UgY29udmVydCB0aGlzIHRvIHN0cmluZyBiZWNh dXNlIGl0J3MgZWFzaWVyIHRvIHVzZSBzdHJpbmdzIGFzCisvLyBrZXlzIGluIGEgR0hhc2hUYWJs ZS4KK3N0YXRpYyBjaGFyKiBpZGVudGlmaWVyVG9TdHJpbmcodW5zaWduZWQgbG9uZyBpZGVudGlm aWVyKQoreworICAgIHJldHVybiBnX3N0cmR1cF9wcmludGYoIiVsZCIsIGlkZW50aWZpZXIpOwor fQorCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVzdChXZWJD b3JlOjpEb2N1bWVudExvYWRlciogbG9hZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIFJl c291cmNlUmVxdWVzdCYgcmVxdWVzdCwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVkaXJlY3RS ZXNwb25zZSkKIHsKLSAgICBpZiAocmVkaXJlY3RSZXNwb25zZS5pc051bGwoKSkKKyAgICBXZWJL aXRXZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKKworICAgIEdP d25QdHI8Z2NoYXI+IGlkZW50aWZpZXJTdHJpbmcoaWRlbnRpZmllclRvU3RyaW5nKGlkZW50aWZp ZXIpKTsKKyAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSB3ZWJraXRfd2ViX3Zp ZXdfZ2V0X3Jlc291cmNlKHdlYlZpZXcsIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAg V2ViS2l0TmV0d29ya1JlcXVlc3QqIG5ldHdvcmtSZXF1ZXN0ID0gd2Via2l0X25ldHdvcmtfcmVx dWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVlc3QocmVxdWVzdCk7CisgICAgV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiBuZXR3b3JrUmVzcG9uc2U7CisKKyAgICAvLyBXZSBhcmUgYWRkaW5nIG9uZSBtb3Jl IHJlc291cmNlIHRvIHRoZSBsb2FkLCBvciBtYXliZSB3ZSBhcmUKKyAgICAvLyBqdXN0IHJlZGly ZWN0aW5nIGEgbG9hZCwgaW4gd2hpY2ggY2FzZSB3ZSBuZWVkIHRvIHVwZGF0ZSBvdXIKKyAgICAv LyBXZWJLaXRXZWJSZXNvdXJjZSdzIGtub3dsZWRnZSBvZiB0aGUgVVJJLgorICAgIGlmIChyZWRp cmVjdFJlc3BvbnNlLmlzTnVsbCgpKSB7CiAgICAgICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9j dW1lbnRMb2FkZXIqPihsb2FkZXIpLT5pbmNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKKwor ICAgICAgICBuZXR3b3JrUmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVj dF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgMCkpOworICAgIH0gZWxzZSB7Cisg ICAgICAgIGdfZnJlZSh3ZWJSZXNvdXJjZS0+cHJpdi0+dXJpKTsKKyAgICAgICAgd2ViUmVzb3Vy Y2UtPnByaXYtPnVyaSA9IGdfc3RyZHVwKHJlcXVlc3QudXJsKCkuc3RyaW5nKCkudXRmOCgpLmRh dGEoKSk7CisKKyAgICAgICAgbmV0d29ya1Jlc3BvbnNlID0gd2Via2l0X25ldHdvcmtfcmVzcG9u c2VfbmV3X3dpdGhfY29yZV9yZXNwb25zZShyZWRpcmVjdFJlc3BvbnNlKTsKKyAgICB9CisKKyAg ICBnX3NpZ25hbF9lbWl0X2J5X25hbWUod2ViVmlldywgInJlc291cmNlLXJlcXVlc3Qtc3RhcnRp bmciLCBtX2ZyYW1lLCB3ZWJSZXNvdXJjZSwgbmV0d29ya1JlcXVlc3QsIG5ldHdvcmtSZXNwb25z ZSk7CisKKyAgICAvLyBGZWVkIGFueSBjaGFuZ2VzIGJhY2sgaW50byB0aGUgUmVzb3VyY2VSZXF1 ZXN0IG9iamVjdC4KKyAgICByZXF1ZXN0ID0gY29yZShuZXR3b3JrUmVxdWVzdCk7CisgICAgZ19v YmplY3RfdW5yZWYobmV0d29ya1JlcXVlc3QpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50 Ojphc3NpZ25JZGVudGlmaWVyVG9Jbml0aWFsUmVxdWVzdCh1bnNpZ25lZCBsb25nIGlkZW50aWZp ZXIsIFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgY29uc3QgUmVzb3VyY2VSZXF1ZXN0JikKK3Zv aWQgRnJhbWVMb2FkZXJDbGllbnQ6OmFzc2lnbklkZW50aWZpZXJUb0luaXRpYWxSZXF1ZXN0KHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllciwgV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqLCBjb25zdCBS ZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QpCiB7Ci0gICAgbm90SW1wbGVtZW50ZWQoKTsKKyAgICBX ZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VCX1JFU09VUkNFKGdfb2Jq ZWN0X25ldyhXRUJLSVRfVFlQRV9XRUJfUkVTT1VSQ0UsIDApKTsKKworICAgIC8vIFRoZSBVUkkg aXMgaW1wb3J0YW50IHRvIGhhdmUgaW4gdGhlIHJlc291cmNlIGJlY2F1c2UgdGhhdCBpcyB3aGF0 IHdlIHVzZQorICAgIC8vIHRvIGZldGNoIHRoZSBXZWJDb3JlIG9iamVjdCwgbGF0ZXIgb24uIFdl IHVzZSB0aGUgcHJpdmF0ZSBzdHJ1Y3R1cmUKKyAgICAvLyBkaXJlY3RseSBoZXJlIHRvIGF2b2lk IGNoYW5naW5nIHRoZSBwcm9wZXJ0eSBtb2RlIGZyb20gUkVBREFCTEUgdG8KKyAgICAvLyBSRUFE V1JJVEUuCisgICAgd2ViUmVzb3VyY2UtPnByaXYtPnVyaSA9IGdfc3RyZHVwKHJlcXVlc3QudXJs KCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisKKyAgICB3ZWJraXRfd2ViX3ZpZXdfYWRkX3Jl c291cmNlKGdldFZpZXdGcm9tRnJhbWUobV9mcmFtZSksIGlkZW50aWZpZXJUb1N0cmluZyhpZGVu dGlmaWVyKSwgd2ViUmVzb3VyY2UpOwogfQogCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojpwb3N0 UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9uKCkKQEAgLTc5Miw3ICs4MzQsNyBAQCB2b2lkIEZy YW1lTG9hZGVyQ2xpZW50OjpzZXRUaXRsZShjb25zdCBTdHJpbmcmIHRpdGxlLCBjb25zdCBLVVJM JiB1cmwpCiAgICAgZnJhbWVEYXRhLT50aXRsZSA9IGdfc3RyZHVwKHRpdGxlLnV0ZjgoKS5kYXRh KCkpOwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZFJlY2VpdmVDb250 ZW50TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgdW5zaWduZWQgbG9uZyBpZGVudGlm aWVyLCBpbnQgbGVuZ3RoUmVjZWl2ZWQpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRj aERpZFJlY2VpdmVDb250ZW50TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIs IHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgaW50IGxlbmd0aFJlY2VpdmVkKQogewogICAgIG5v dEltcGxlbWVudGVkKCk7CiB9CkBAIC04MDAsMTMgKzg0MiwyMiBAQCB2b2lkIEZyYW1lTG9hZGVy Q2xpZW50OjpkaXNwYXRjaERpZFJlY2VpdmVDb250ZW50TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50 TG9hZGVyKgogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGaW5pc2hMb2FkaW5n KFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIsIHVuc2lnbmVkIGxvbmcgaWRlbnRpZmll cikKIHsKICAgICBzdGF0aWNfY2FzdDxXZWJLaXQ6OkRvY3VtZW50TG9hZGVyKj4obG9hZGVyKS0+ ZGVjcmVhc2VMb2FkQ291bnQoaWRlbnRpZmllcik7CisKKyAgICBHT3duUHRyPGdjaGFyPiBpZGVu dGlmaWVyU3RyaW5nKGlkZW50aWZpZXJUb1N0cmluZyhpZGVudGlmaWVyKSk7CisgICAgV2ViS2l0 V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlID0gd2Via2l0X3dlYl92aWV3X2dldF9yZXNvdXJjZShn ZXRWaWV3RnJvbUZyYW1lKG1fZnJhbWUpLCBpZGVudGlmaWVyU3RyaW5nLmdldCgpKTsKKworICAg IGNvbnN0IGNoYXIqIHVyaSA9IHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X3VyaSh3ZWJSZXNvdXJj ZSk7CisgICAgUmVmUHRyPEFyY2hpdmVSZXNvdXJjZT4gY29yZVJlc291cmNlKGxvYWRlci0+c3Vi cmVzb3VyY2UoS1VSTChLVVJMKCksIHVyaSkpKTsKKyAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2lu aXRfd2l0aF9jb3JlX3Jlc291cmNlKHdlYlJlc291cmNlLCBjb3JlUmVzb3VyY2UuZ2V0KCkpOwor CisgICAgd2Via2l0X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJjZShnZXRWaWV3RnJvbUZyYW1lKG1f ZnJhbWUpLCBpZGVudGlmaWVyU3RyaW5nLmdldCgpKTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6ZGlzcGF0Y2hEaWRGYWlsTG9hZGluZyhXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9h ZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIGNvbnN0IFJlc291cmNlRXJyb3ImIGVycm9y KQogewotICAgIC8vIEZJWE1FOiB3aGVuIGRvZXMgdGhpcyBvY2N1ciBhbmQgd2hhdCBzaG91bGQg aGFwcGVuPwotCiAgICAgc3RhdGljX2Nhc3Q8V2ViS2l0OjpEb2N1bWVudExvYWRlcio+KGxvYWRl ciktPmRlY3JlYXNlTG9hZENvdW50KGlkZW50aWZpZXIpOworCisgICAgbm90SW1wbGVtZW50ZWQo KTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRMb2FkUmVzb3VyY2VC eVhNTEh0dHBSZXF1ZXN0KHVuc2lnbmVkIGxvbmcsIGNvbnN0IFNjcmlwdFN0cmluZyYpCmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UuYyBiL1dlYktpdC9n dGsvdGVzdHMvdGVzdG5ldHdvcmtyZXNwb25zZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjkwNTBjMDQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rl c3RuZXR3b3JrcmVzcG9uc2UuYwpAQCAtMCwwICsxLDEwOCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAwOSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAqIENvcHlyaWdodCAoQykgMjAwOSBDb2xs YWJvcmEgTHRkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICog YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5v dCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZy YW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVT QS4KKyAqLworCisjaW5jbHVkZSA8ZXJybm8uaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNs dWRlIDxnbGliLmg+CisjaW5jbHVkZSA8Z2xpYi9nc3RkaW8uaD4KKyNpbmNsdWRlIDxndGsvZ3Rr Lmg+CisjaW5jbHVkZSA8c3RkbGliLmg+CisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdC5oPgorCisj aWYgR0xJQl9DSEVDS19WRVJTSU9OKDIsIDE2LCAwKSAmJiBHVEtfQ0hFQ0tfVkVSU0lPTigyLCAx NCwgMCkKKworc3RhdGljIHZvaWQgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX2NyZWF0ZV9kZXN0cm95 KCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlOworICAgIFNvdXBNZXNz YWdlKiBtZXNzYWdlOworCisgICAgLyogVGVzdCBjcmVhdGlvbiB3aXRoIFVSSSAqLworICAgIHJl c3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBF X05FVFdPUktfUkVTUE9OU0UsICJ1cmkiLCAiaHR0cDovL2RlYmlhbi5vcmcvIiwgTlVMTCkpOwor ICAgIGdfYXNzZXJ0KFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNlKSk7CisgICAg bWVzc2FnZSA9IHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKTsK KyAgICBnX2Fzc2VydCghbWVzc2FnZSk7CisgICAgZ19vYmplY3RfdW5yZWYocmVzcG9uc2UpOwor CisgICAgLyogVGVzdCBjcmVhdGlvbiB3aXRoIFNvdXBNZXNzYWdlICovCisgICAgbWVzc2FnZSA9 IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICByZXNw b25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9O RVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsIE5VTEwpKTsKKyAgICBnX2Fzc2Vy dChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIGdfYXNzZXJ0X2Nt cGludChHX09CSkVDVChtZXNzYWdlKS0+cmVmX2NvdW50LCA9PSwgMik7CisgICAgZ19vYmplY3Rf dW5yZWYocmVzcG9uc2UpOworICAgIGdfYXNzZXJ0X2NtcGludChHX09CSkVDVChtZXNzYWdlKS0+ cmVmX2NvdW50LCA9PSwgMSk7CisgICAgZ19vYmplY3RfdW5yZWYobWVzc2FnZSk7CisKKyAgICAv KiBUZXN0IGNyZWF0aW9uIHdpdGggYm90aCBTb3VwTWVzc2FnZSBhbmQgVVJJICovCisgICAgbWVz c2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAg ICByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRf VFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsICJ1cmkiLCAiaHR0cDov L2dub21lLm9yZy8iLCBOVUxMKSk7CisgICAgZ19hc3NlcnQoV0VCS0lUX0lTX05FVFdPUktfUkVT UE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1QobWVzc2FnZSkt PnJlZl9jb3VudCwgPT0sIDIpOworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9nZXRfdXJpKHJlc3BvbnNlKSwgPT0sICJodHRwOi8vZ25vbWUub3JnLyIpOworICAg IGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1Qo bWVzc2FnZSktPnJlZl9jb3VudCwgPT0sIDEpOworICAgIGdfb2JqZWN0X3VucmVmKG1lc3NhZ2Up OworfQorCitzdGF0aWMgdm9pZCB0ZXN0X25ldHdvcmtfcmVzcG9uc2VfcHJvcGVydGllcygpCit7 CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZTsKKyAgICBTb3VwTWVzc2FnZSog bWVzc2FnZTsKKyAgICBnY2hhciogc291cFVSSTsKKworICAgIC8qIFRlc3QgVVJJIGlzIHNldCBj b3JyZWN0bHkgd2hlbiBjcmVhdGluZyB3aXRoIFVSSSAqLworICAgIHJlc3BvbnNlID0gd2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfbmV3KCJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICBnX2Fzc2Vy dChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIGdfYXNzZXJ0X2Nt cHN0cih3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpKHJlc3BvbnNlKSwgPT0sICJodHRw Oi8vZGViaWFuLm9yZy8iKTsKKyAgICBnX29iamVjdF91bnJlZihyZXNwb25zZSk7CisKKyAgICAv KiBUZXN0IFVSSSBpcyBzZXQgY29ycmVjdGx5IHdoZW4gY3JlYXRpbmcgd2l0aCBNZXNzYWdlICov CisgICAgbWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIsICJodHRwOi8vZGViaWFuLm9y Zy8iKTsKKyAgICByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25l dyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIG1lc3NhZ2UsIE5VTEwp KTsKKyAgICBnX2Fzc2VydChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOwor ICAgIGdfb2JqZWN0X3VucmVmKG1lc3NhZ2UpOworCisgICAgbWVzc2FnZSA9IHdlYmtpdF9uZXR3 b3JrX3Jlc3BvbnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKTsKKyAgICBzb3VwVVJJID0gc291cF91 cmlfdG9fc3RyaW5nKHNvdXBfbWVzc2FnZV9nZXRfdXJpKG1lc3NhZ2UpLCBGQUxTRSk7CisgICAg Z19hc3NlcnRfY21wc3RyKHNvdXBVUkksID09LCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAg Z19mcmVlKHNvdXBVUkkpOworCisgICAgZ19hc3NlcnRfY21wc3RyKHdlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX2dldF91cmkocmVzcG9uc2UpLCA9PSwgImh0dHA6Ly9kZWJpYW4ub3JnLyIpOworICAg IGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKK30KKworaW50IG1haW4oaW50IGFyZ2MsIGNoYXIq KiBhcmd2KQoreworICAgIGdfdGhyZWFkX2luaXQoTlVMTCk7CisgICAgZ3RrX3Rlc3RfaW5pdCgm YXJnYywgJmFyZ3YsIE5VTEwpOworCisgICAgZ190ZXN0X2J1Z19iYXNlKCJodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy8iKTsKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvbmV0d29ya3Jlc3Bv bnNlL2NyZWF0ZWRlc3Ryb3kiLCB0ZXN0X25ldHdvcmtfcmVzcG9uc2VfY3JlYXRlX2Rlc3Ryb3kp OworICAgIGdfdGVzdF9hZGRfZnVuYygiL3dlYmtpdC9uZXR3b3JrcmVzcG9uc2UvcHJvcGVydGll cyIsIHRlc3RfbmV0d29ya19yZXNwb25zZV9wcm9wZXJ0aWVzKTsKKyAgICByZXR1cm4gZ190ZXN0 X3J1biAoKTsKK30KKworI2Vsc2UKK2ludCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJndikKK3sK KyAgICBnX2NyaXRpY2FsKCJZb3Ugd2lsbCBuZWVkIGF0IGxlYXN0IGdsaWItMi4xNi4wIGFuZCBn dGstMi4xNC4wIHRvIHJ1biB0aGUgdW5pdCB0ZXN0cy4gRG9pbmcgbm90aGluZyBub3cuIik7Cisg ICAgcmV0dXJuIDA7Cit9CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAppbmRleCA4ZGU3NWUwLi4xODIw MTk4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXQuaAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXQuaApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93 ZWJraXRkZWZpbmVzLmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRvd25sb2FkLmg+CiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3dl YmtpdG5ldHdvcmtyZXNwb25zZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRzb3VwYXV0aGRp YWxvZy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJkYXRhc291cmNlLmg+CiAjaW5jbHVk ZSA8d2Via2l0L3dlYmtpdHdlYmZyYW1lLmg+CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRkZWZpbmVzLmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKaW5k ZXggZWE5MDBhMC4uNmRkZGY4NCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 ZGVmaW5lcy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaApAQCAtNDQs NiArNDQsOSBAQCBHX0JFR0lOX0RFQ0xTCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1Jl cXVlc3QgV2ViS2l0TmV0d29ya1JlcXVlc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29y a1JlcXVlc3RDbGFzcyBXZWJLaXROZXR3b3JrUmVxdWVzdENsYXNzOwogCit0eXBlZGVmIHN0cnVj dCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlIFdlYktpdE5ldHdvcmtSZXNwb25zZTsKK3R5cGVkZWYg c3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VDbGFzcyBXZWJLaXROZXR3b3JrUmVzcG9uc2VD bGFzczsKKwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdCBXZWJLaXRX ZWJCYWNrRm9yd2FyZExpc3Q7CiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViQmFja0ZvcndhcmRM aXN0Q2xhc3MgV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0Q2xhc3M7CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcCBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcAppbmRleCBlOGEyMjVjLi41ZGU1N2JiIDEwMDY0 NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAKKysrIGIv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCkBAIC0yOCwxNiArMjgs NiBAQAogCiAjaW5jbHVkZSA8Z2xpYi9naTE4bi1saWIuaD4KIAotbmFtZXNwYWNlIFdURiB7Ci0K LXRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxTb3VwTWVzc2FnZT4oU291cE1lc3NhZ2Uq IHNvdXBNZXNzYWdlKQotewotICAgIGlmIChzb3VwTWVzc2FnZSkKLSAgICAgICAgZ19vYmplY3Rf dW5yZWYoc291cE1lc3NhZ2UpOwotfQotCi19Ci0KIC8qKgogICogU0VDVElPTjp3ZWJraXRuZXR3 b3JrcmVxdWVzdAogICogQHNob3J0X2Rlc2NyaXB0aW9uOiBUaGUgdGFyZ2V0IG9mIGEgbmF2aWdh dGlvbiByZXF1ZXN0CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVzcG9uc2UuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNw cApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNmQ2YjNhCi0tLSAvZGV2L251 bGwKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcApAQCAt MCwwICsxLDI2NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFu cyBQZXRlciBGcmV5dGhlcgorICogQ29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBT aWx2YQorICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgor ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v ciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCIKKworI2luY2x1ZGUgIkNT dHJpbmcuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25z ZS5oIgorI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKKworI2luY2x1ZGUgPGdsaWIvZ2kxOG4t bGliLmg+CisKKy8qKgorICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVzcG9uc2UKKyAqIEBzaG9y dF9kZXNjcmlwdGlvbjogdGhlIHJlc3BvbnNlIGdpdmVuIHRvIGEgbmV0d29yayByZXF1ZXN0Cisg KiBAc2VlX2Fsc286ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAqIFRoaXMgY2xhc3MgcmVw cmVzZW50cyB0aGUgbmV0d29yayByZWxhdGVkIGFzcGVjdHMgb2YgYSBuYXZpZ2F0aW9uCisgKiBy ZXNwb25zZS4KKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KKworR19ERUZJTkVfVFlQRShXZWJL aXROZXR3b3JrUmVzcG9uc2UsIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlLCBHX1RZUEVfT0JKRUNU KTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlIHsKKyAgICBnY2hhciog dXJpOworICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdlOworfTsKKworI2RlZmluZSBXRUJLSVRfTkVU V09SS19SRVNQT05TRV9HRVRfUFJJVkFURShvYmopIChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZB VEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNw b25zZVByaXZhdGUpKQorCitlbnVtIHsKKyAgICBQUk9QXzAsCisKKyAgICBQUk9QX1VSSSwKKyAg ICBQUk9QX01FU1NBR0UsCit9OworCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9kaXNwb3NlKEdPYmplY3QqIG9iamVjdCkKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2Uq IHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsKKyAgICBXZWJLaXRO ZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBpZiAo cHJpdi0+bWVzc2FnZSkgeworICAgICAgICBnX29iamVjdF91bnJlZihwcml2LT5tZXNzYWdlKTsK KyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IE5VTEw7CisgICAgfQorCisgICAgR19PQkpFQ1RfQ0xB U1Mod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfcGFyZW50X2NsYXNzKS0+ZGlzcG9zZShvYmplY3Qp OworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6ZShHT2Jq ZWN0KiBvYmplY3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdF QktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iamVjdCk7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNl UHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7 CisKKyAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9wYXJlbnRfY2xh c3MpLT5maW5hbGl6ZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9nZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBwcm9wZXJ0eUlELCBH VmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYykKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVz cG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsKKworICAg IHN3aXRjaChwcm9wZXJ0eUlEKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAgICAgICAgZ192YWx1 ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpKHJlc3Bv bnNlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9NRVNTQUdFOgorICAgICAgICBn X3ZhbHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9tZXNz YWdlKHJlc3BvbnNlKSk7CisgICAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICAgIEdf T0JKRUNUX1dBUk5fSU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BlcnR5SUQsIHBzcGVj KTsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF9w cm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BlcnR5SUQsIGNvbnN0IEdWYWx1ZSog dmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVjKQoreworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSog cmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShvYmplY3QpOworICAgIFdlYktpdE5l dHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsKKworICAgIHN3aXRj aChwcm9wZXJ0eUlEKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAgICAgICAgd2Via2l0X25ldHdv cmtfcmVzcG9uc2Vfc2V0X3VyaShyZXNwb25zZSwgZ192YWx1ZV9nZXRfc3RyaW5nKHZhbHVlKSk7 CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9NRVNTQUdFOgorICAgICAgICBwcml2LT5t ZXNzYWdlID0gU09VUF9NRVNTQUdFKGdfdmFsdWVfZHVwX29iamVjdCh2YWx1ZSkpOworICAgICAg ICBicmVhazsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFMSURfUFJP UEVSVFlfSUQob2JqZWN0LCBwcm9wZXJ0eUlELCBwc3BlYyk7CisgICAgfQorfQorCitzdGF0aWMg dm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9jbGFzc19pbml0KFdlYktpdE5ldHdvcmtSZXNw b25zZUNsYXNzKiByZXNwb25zZUNsYXNzKQoreworICAgIEdPYmplY3RDbGFzcyogb2JqZWN0Q2xh c3MgPSBHX09CSkVDVF9DTEFTUyhyZXNwb25zZUNsYXNzKTsKKworICAgIG9iamVjdENsYXNzLT5k aXNwb3NlID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZGlzcG9zZTsKKyAgICBvYmplY3RDbGFz cy0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6ZTsKKyAgICBvYmpl Y3RDbGFzcy0+Z2V0X3Byb3BlcnR5ID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Byb3Bl cnR5OworICAgIG9iamVjdENsYXNzLT5zZXRfcHJvcGVydHkgPSB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9zZXRfcHJvcGVydHk7CisKKyAgICB3ZWJraXRfaW5pdCgpOworCisgICAgLyoqCisgICAg ICogV2ViS2l0TmV0d29ya1Jlc3BvbnNlOnVyaToKKyAgICAgKgorICAgICAqIFRoZSBVUkkgdG8g d2hpY2ggdGhlIHJlc3BvbnNlIHdpbGwgYmUgbWFkZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAx LjEuMTQKKyAgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVj dENsYXNzLCBQUk9QX1VSSSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdf cGFyYW1fc3BlY19zdHJpbmcoInVyaSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIF8oIlVSSSIpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJUaGUgVVJJIHRvIHdoaWNoIHRo ZSByZXNwb25zZSB3aWxsIGJlIG1hZGUuIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChHUGFyYW1GbGFncykoV0VCS0lUX1BB UkFNX1JFQURXUklURSkpKTsKKworICAgIC8qKgorICAgICAqIFdlYktpdE5ldHdvcmtSZXNwb25z ZTptZXNzYWdlOgorICAgICAqCisgICAgICogVGhlICNTb3VwTWVzc2FnZSB0aGF0IGJhY2tzIHRo ZSByZXNwb25zZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBn X29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX01FU1NBR0Us CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFtX3NwZWNfb2JqZWN0 KCJtZXNzYWdlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgXygiTWVzc2FnZSIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJUaGUgU291cE1lc3NhZ2UgdGhhdCBiYWNrcyB0 aGUgcmVzcG9uc2UuIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFNPVVBfVFlQRV9NRVNTQUdFLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoR1BhcmFtRmxhZ3MpKFdFQktJVF9Q QVJBTV9SRUFEV1JJVEV8R19QQVJBTV9DT05TVFJVQ1RfT05MWSkpKTsKKworICAgIGdfdHlwZV9j bGFzc19hZGRfcHJpdmF0ZShyZXNwb25zZUNsYXNzLCBzaXplb2YoV2ViS2l0TmV0d29ya1Jlc3Bv bnNlUHJpdmF0ZSkpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9p bml0KFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCit7CisgICAgV2ViS2l0TmV0d29y a1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9QUklW QVRFKHJlc3BvbnNlKTsKKyAgICByZXNwb25zZS0+cHJpdiA9IHByaXY7Cit9CisKKy8vIGZvciBp bnRlcm5hbCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9uZXdfd2l0aF9jb3JlX3Jlc3BvbnNlKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVz cG9uc2UmIHJlc291cmNlUmVzcG9uc2UpCit7CisgICAgR093blB0cjxTb3VwTWVzc2FnZT4gc291 cE1lc3NhZ2UocmVzb3VyY2VSZXNwb25zZS50b1NvdXBNZXNzYWdlKCkpOworICAgIGlmIChzb3Vw TWVzc2FnZSkKKyAgICAgICAgcmV0dXJuIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0 X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIHNvdXBNZXNzYWdl LmdldCgpLCBOVUxMKSk7CisKKyAgICByZXR1cm4gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19v YmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsICJ1cmkiLCByZXNvdXJjZVJl c3BvbnNlLnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCksIE5VTEwpKTsKK30KKworLyoqCisg KiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXc6CisgKiBAdXJpOiBhbiBVUkkKKyAqCisgKiBD cmVhdGVzIGEgbmV3ICNXZWJLaXROZXR3b3JrUmVzcG9uc2UgaW5pdGlhbGl6ZWQgd2l0aCBhbiBV UkkuCisgKgorICogUmV0dXJuczogYSBuZXcgI1dlYktpdE5ldHdvcmtSZXNwb25zZSwgb3IgJU5V TEwgaWYgdGhlIFVSSSBpcworICogaW52YWxpZC4KKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8K K1dlYktpdE5ldHdvcmtSZXNwb25zZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3KGNvbnN0 IGdjaGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKKwor ICAgIHJldHVybiBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZ UEVfTkVUV09SS19SRVNQT05TRSwgInVyaSIsIHVyaSwgTlVMTCkpOworfQorCisvKioKKyAqIHdl YmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmk6CisgKiBAcmVzcG9uc2U6IGEgI1dlYktpdE5l dHdvcmtSZXNwb25zZQorICogQHVyaTogYW4gVVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQg YW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlc3BvbnNlLiBXaGVuIHRoZSByZXNwb25zZQorICogaGFz IGFuIGFzc29jaWF0ZWQgI1NvdXBNZXNzYWdlLCBpdHMgVVJJIHdpbGwgYWxzbyBiZSBzZXQgYnkg dGhpcworICogY2FsbC4KKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KK3ZvaWQgd2Via2l0X25l dHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBj b25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdP UktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX3JldHVybl9pZl9mYWlsKHVyaSk7CisKKyAg ICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisK KyAgICBpZiAocHJpdi0+dXJpKQorICAgICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBwcml2 LT51cmkgPSBnX3N0cmR1cCh1cmkpOworCisgICAgaWYgKCFwcml2LT5tZXNzYWdlKQorICAgICAg ICByZXR1cm47CisKKyAgICBTb3VwVVJJKiBzb3VwVVJJID0gc291cF91cmlfbmV3KHVyaSk7Cisg ICAgaWYgKCFzb3VwVVJJKSB7CisgICAgICAgIGdfd2FybmluZygiSW52YWxpZCBVUkk6ICVzIiwg dXJpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHNvdXBfbWVzc2FnZV9zZXRfdXJp KHByaXYtPm1lc3NhZ2UsIHNvdXBVUkkpOworICAgIHNvdXBfdXJpX2ZyZWUoc291cFVSSSk7Cit9 CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaToKKyAqIEByZXNwb25z ZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogUmV0dXJuczogdGhlIHVyaSBvZiB0 aGUgI1dlYktpdE5ldHdvcmtSZXNwb25zZQorICoKKyAqIFNpbmNlOiAxLjEuMTQKKyAqLworR19D T05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChX RUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSksIE5VTEwpOworCisgICAgV2ViS2l0 TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgaWYg KHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKworICAgIFNvdXBVUkkqIHNv dXBVUkkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaShwcml2LT5tZXNzYWdlKTsKKyAgICBwcml2LT51 cmkgPSBzb3VwX3VyaV90b19zdHJpbmcoc291cFVSSSwgRkFMU0UpOworICAgIHJldHVybiBwcml2 LT51cmk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3NvdXBfbWVz c2FnZToKKyAqIEByZXNwb25zZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogT2J0 YWlucyB0aGUgI1NvdXBNZXNzYWdlIHRoYXQgcmVwcmVzZW50cyB0aGUgZ2l2ZW4gcmVzcG9uc2Uu IE5vdGljZQorICogdGhhdCBvbmx5IHRoZSByZXNwb25zZSBzaWRlIG9mIHRoZSBIVFRQIGNvbnZl cnNhdGlvbiBpcworICogcmVwcmVzZW50ZWQuCisgKgorICogUmV0dXJuczogdGhlICNTb3VwTWVz c2FnZQorICogU2luY2U6IDEuMS4xNAorICovCitTb3VwTWVzc2FnZSogd2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sK KyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNw b25zZSksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9 IHJlc3BvbnNlLT5wcml2OworCisgICAgcmV0dXJuIHByaXYtPm1lc3NhZ2U7Cit9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmViMjMzYjUKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaApAQCAtMCwwICsxLDc0IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYgV0VCS0lUX05FVFdPUktfUkVTUE9O U0VfSAorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9ICisKKyNpbmNsdWRlIDxnbGli LW9iamVjdC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgorCisjaW5jbHVkZSA8d2Via2l0 L3dlYmtpdGRlZmluZXMuaD4KKworR19CRUdJTl9ERUNMUworCisjZGVmaW5lIFdFQktJVF9UWVBF X05FVFdPUktfUkVTUE9OU0UgICAgICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0 X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqKSAgICAgICAgICAg IChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FTVCgob2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19S RVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktf UkVTUE9OU0VfQ0xBU1Moa2xhc3MpICAgIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfQ0FTVCgoa2xhc3Mp LCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xh c3MpKQorI2RlZmluZSBXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShvYmopICAgICAgICAgKEdf VFlQRV9DSEVDS19JTlNUQU5DRV9UWVBFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BP TlNFKSkKKyNkZWZpbmUgV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpIChH X1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQRSgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQ T05TRSkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9DTEFTUyhvYmopICAo R19UWVBFX0lOU1RBTkNFX0dFVF9DTEFTUygob2JqKSwgIFdFQktJVF9UWVBFX05FVFdPUktfUkVT UE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dl YktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTsK Kworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2UgeworICAgIEdPYmplY3QgcGFyZW50X2lu c3RhbmNlOworCisgICAgLyo8IHByaXZhdGUgPiovCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNl UHJpdmF0ZSAqcHJpdjsKK307CisKK3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3Mg eworICAgIEdPYmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7CisKKyAgICAvKiBQYWRkaW5nIGZvciBm dXR1cmUgZXhwYW5zaW9uICovCisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQwKSAodm9pZCk7 CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQxKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJr aXRfcmVzZXJ2ZWQyKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQzKSAodm9p ZCk7Cit9OworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRf dHlwZSAodm9pZCk7CisKK1dFQktJVF9BUEkgV2ViS2l0TmV0d29ya1Jlc3BvbnNlICoKK3dlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX25ldyAgICAgIChjb25zdCBnY2hhciAgICAgICAgICAqdXJpKTsK KworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJpICAoV2Vi S2l0TmV0d29ya1Jlc3BvbnNlICpyZXNwb25zZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjb25zdCBnY2hhciogICAgICAgICAgdXJpKTsKKworV0VCS0lUX0FQSSBHX0NPTlNU X1JFVFVSTiBnY2hhciAqCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpICAoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlICpyZXNwb25zZSk7CisKK1dFQktJVF9BUEkgU291cE1lc3NhZ2UgKgor d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZSk7CisKK0dfRU5EX0RFQ0xTCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmNwcAppbmRleCA0ZTQ4NjEzLi44ZTkzNDhlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmNwcApAQCAtMTE4LDYgKzExOCwxNSBAQCBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3Ig Y29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSkKIAogfSAvKiogZW5kIG5hbWVzcGFjZSBX ZWJLaXQgKi8KIAorbmFtZXNwYWNlIFdURiB7Cit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQ dHI8U291cE1lc3NhZ2U+KFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSkKK3sKKyAgICBpZiAoc291 cE1lc3NhZ2UpCisgICAgICAgIGdfb2JqZWN0X3VucmVmKHNvdXBNZXNzYWdlKTsKK30KKworfQor CiBzdGF0aWMgR3RrV2lkZ2V0KiBjdXJyZW50VG9wbGV2ZWxDYWxsYmFjayhXZWJLaXRTb3VwQXV0 aERpYWxvZyogZmVhdHVyZSwgU291cE1lc3NhZ2UqIG1lc3NhZ2UsIGdwb2ludGVyIHVzZXJEYXRh KQogewogICAgIGdwb2ludGVyIG1lc3NhZ2VEYXRhID0gZ19vYmplY3RfZ2V0X2RhdGEoR19PQkpF Q1QobWVzc2FnZSksICJyZXNvdXJjZUhhbmRsZSIpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0cHJpdmF0ZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o CmluZGV4IGJkMmEwYjkuLjNhMGY4NjYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHByaXZhdGUuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKQEAg LTQ2LDYgKzQ2LDcgQEAKICNpbmNsdWRlICJCYWNrRm9yd2FyZExpc3QuaCIKICNpbmNsdWRlICJD U3RyaW5nLmgiCiAjaW5jbHVkZSA8ZW5jaGFudC5oPgorI2luY2x1ZGUgIkdPd25QdHIuaCIKICNp bmNsdWRlICJIaXN0b3J5SXRlbS5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAi UGFnZS5oIgpAQCAtODUsNiArODYsOCBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogICAgIFdlYkNv cmU6OlJlc291cmNlUmVxdWVzdCBjb3JlKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KTsK IAorICAgIFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgY29yZShXZWJLaXROZXR3b3JrUmVzcG9u c2UqIHJlc3BvbnNlKTsKKwogICAgIFdlYkNvcmU6OkVkaXRpbmdCZWhhdmlvciBjb3JlKFdlYktp dEVkaXRpbmdCZWhhdmlvciB0eXBlKTsKIH0KIApAQCAtMTMyLDYgKzEzNSw4IEBAIGV4dGVybiAi QyIgewogCiAgICAgICAgIGdib29sZWFuIGRpc3Bvc2luZzsKICAgICAgICAgZ2Jvb2xlYW4gdXNl UHJpbWFyeUZvclBhc3RlOworCisgICAgICAgIEdIYXNoVGFibGUqIHN1YlJlc291cmNlczsKICAg ICB9OwogCiAgICAgI2RlZmluZSBXRUJLSVRfV0VCX0ZSQU1FX0dFVF9QUklWQVRFKG9iaikgICAg KEdfVFlQRV9JTlNUQU5DRV9HRVRfUFJJVkFURSgob2JqKSwgV0VCS0lUX1RZUEVfV0VCX0ZSQU1F LCBXZWJLaXRXZWJGcmFtZVByaXZhdGUpKQpAQCAtMTgwLDYgKzE4NSw5IEBAIGV4dGVybiAiQyIg ewogICAgIH07CiAgICAgV2ViS2l0V2ViUmVzb3VyY2UqCiAgICAgd2Via2l0X3dlYl9yZXNvdXJj ZV9uZXdfd2l0aF9jb3JlX3Jlc291cmNlKFBhc3NSZWZQdHI8V2ViQ29yZTo6QXJjaGl2ZVJlc291 cmNlPik7CisKKyAgICB2b2lkCisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9pbml0X3dpdGhfY29y ZV9yZXNvdXJjZShXZWJLaXRXZWJSZXNvdXJjZSosIFBhc3NSZWZQdHI8V2ViQ29yZTo6QXJjaGl2 ZVJlc291cmNlPik7CiAgICAgLy8gZW5kIFdlYktpdFdlYlJlc291cmNlIHByaXZhdGUKIAogICAg IHZvaWQKQEAgLTIwMCw2ICsyMDgsMTUgQEAgZXh0ZXJuICJDIiB7CiAgICAgdm9pZAogICAgIHdl YmtpdF93ZWJfdmlld19yZXF1ZXN0X2Rvd25sb2FkKFdlYktpdFdlYlZpZXcqIHdlYl92aWV3LCBX ZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNw b25zZSYgcmVzcG9uc2UgPSBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlKCksIFdlYkNvcmU6OlJl c291cmNlSGFuZGxlKiBoYW5kbGUgPSAwKTsKIAorICAgIHZvaWQKKyAgICB3ZWJraXRfd2ViX3Zp ZXdfYWRkX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqLCBjaGFyKiwgV2ViS2l0V2ViUmVzb3VyY2Uq KTsKKworICAgIFdlYktpdFdlYlJlc291cmNlKgorICAgIHdlYmtpdF93ZWJfdmlld19nZXRfcmVz b3VyY2UoV2ViS2l0V2ViVmlldyosIGNoYXIqKTsKKworICAgIHZvaWQKKyAgICB3ZWJraXRfd2Vi X3ZpZXdfcmVtb3ZlX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqLCBjaGFyKik7CisKICAgICBXZWJL aXREb3dubG9hZCoKICAgICB3ZWJraXRfZG93bmxvYWRfbmV3X3dpdGhfaGFuZGxlKFdlYktpdE5l dHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZSogaGFuZGxlLCBj b25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNwb25zZSk7CiAKQEAgLTIxNSw2ICsy MzIsOSBAQCBleHRlcm4gIkMiIHsKICAgICBXZWJLaXROZXR3b3JrUmVxdWVzdCoKICAgICB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X25ld193aXRoX2NvcmVfcmVxdWVzdChjb25zdCBXZWJDb3JlOjpS ZXNvdXJjZVJlcXVlc3QmIHJlc291cmNlUmVxdWVzdCk7CiAKKyAgICBXZWJLaXROZXR3b3JrUmVz cG9uc2UqCisgICAgd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3X3dpdGhfY29yZV9yZXNwb25z ZShjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJiByZXNvdXJjZVJlc3BvbnNlKTsKKwog ICAgIC8vIEZJWE1FOiBtb3ZlIHRoaXMgdG8gd2Via2l0bmV0d29ya3JlcXVlc3QuaCBvbmNlIHRo ZSBBUEkgaXMgYWdyZWVkIHVwb24uCiAgICAgV0VCS0lUX0FQSSBTb3VwTWVzc2FnZSoKICAgICB3 ZWJraXRfbmV0d29ya19yZXF1ZXN0X2dldF9tZXNzYWdlKFdlYktpdE5ldHdvcmtSZXF1ZXN0KiBy ZXF1ZXN0KTsKQEAgLTI5Myw0ICszMTMsOCBAQCBleHRlcm4gIkMiIHsKICAgICB3ZWJraXRfd2Vi X2RhdGFfc291cmNlX25ld193aXRoX2xvYWRlcihQYXNzUmVmUHRyPFdlYktpdDo6RG9jdW1lbnRM b2FkZXI+KTsKIH0KIAorbmFtZXNwYWNlIFdURiB7CisgICAgdGVtcGxhdGUgPD4gdm9pZCBmcmVl T3duZWRHUHRyPFNvdXBNZXNzYWdlPihTb3VwTWVzc2FnZSogc291cE1lc3NhZ2UpOworfQorCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNw cCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAppbmRleCBjMTYyNTc4 Li5mZDRhYmI3IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJj ZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwCkBAIC0y Nyw2ICsyNyw4IEBACiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5n LmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAid2Via2l0ZW51bXR5cGVz LmgiCisjaW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgogI2luY2x1ZGUgInd0Zi9Bc3NlcnRpb25z LmgiCiAKICNpbmNsdWRlIDxnbGliLmg+CkBAIC01MCwxMyArNTIsMzQgQEAgZW51bSB7CiAgICAg UFJPUF9VUkksCiAgICAgUFJPUF9NSU1FX1RZUEUsCiAgICAgUFJPUF9FTkNPRElORywKLSAgICBQ Uk9QX0ZSQU1FX05BTUUKKyAgICBQUk9QX0ZSQU1FX05BTUUsCiB9OwogCiBHX0RFRklORV9UWVBF KFdlYktpdFdlYlJlc291cmNlLCB3ZWJraXRfd2ViX3Jlc291cmNlLCBHX1RZUEVfT0JKRUNUKTsK IAogc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfcHJvcGVydHkoR09iamVjdCog b2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYyk7 CiAKK3N0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xlYW51cChXZWJLaXRXZWJSZXNv dXJjZSogd2ViUmVzb3VyY2UpCit7CisgICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2 ID0gd2ViUmVzb3VyY2UtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBwcml2 LT51cmkgPSBOVUxMOworCisgICAgZ19mcmVlKHByaXYtPm1pbWVUeXBlKTsKKyAgICBwcml2LT5t aW1lVHlwZSA9IE5VTEw7CisKKyAgICBnX2ZyZWUocHJpdi0+dGV4dEVuY29kaW5nKTsKKyAgICBw cml2LT50ZXh0RW5jb2RpbmcgPSBOVUxMOworCisgICAgZ19mcmVlKHByaXYtPmZyYW1lTmFtZSk7 CisgICAgcHJpdi0+ZnJhbWVOYW1lID0gTlVMTDsKKworICAgIGlmIChwcml2LT5kYXRhKQorICAg ICAgICBnX3N0cmluZ19mcmVlKHByaXYtPmRhdGEsIFRSVUUpOworICAgIHByaXYtPmRhdGEgPSBO VUxMOworfQorCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2Rpc3Bvc2UoR09iamVj dCogb2JqZWN0KQogewogICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSA9IFdFQktJ VF9XRUJfUkVTT1VSQ0Uob2JqZWN0KTsKQEAgLTczLDE1ICs5Niw4IEBAIHN0YXRpYyB2b2lkIHdl YmtpdF93ZWJfcmVzb3VyY2VfZGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCiBzdGF0aWMgdm9pZCB3 ZWJraXRfd2ViX3Jlc291cmNlX2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKIHsKICAgICBXZWJL aXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VCX1JFU09VUkNFKG9iamVjdCk7 Ci0gICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7 CiAKLSAgICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAgICBnX2ZyZWUocHJpdi0+bWltZVR5cGUpOwot ICAgIGdfZnJlZShwcml2LT50ZXh0RW5jb2RpbmcpOwotICAgIGdfZnJlZShwcml2LT5mcmFtZU5h bWUpOwotCi0gICAgaWYgKHByaXYtPmRhdGEpCi0gICAgICAgIGdfc3RyaW5nX2ZyZWUocHJpdi0+ ZGF0YSwgVFJVRSk7CisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9jbGVhbnVwKHdlYlJlc291cmNl KTsKIAogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF93ZWJfcmVzb3VyY2VfcGFyZW50X2NsYXNz KS0+ZmluYWxpemUob2JqZWN0KTsKIH0KQEAgLTE5Nyw2ICsyMTMsMTggQEAgV2ViS2l0V2ViUmVz b3VyY2UqIHdlYmtpdF93ZWJfcmVzb3VyY2VfbmV3X3dpdGhfY29yZV9yZXNvdXJjZShQYXNzUmVm UHRyPEFyY2hpdmUKICAgICByZXR1cm4gd2ViUmVzb3VyY2U7CiB9CiAKK3ZvaWQgd2Via2l0X3dl Yl9yZXNvdXJjZV9pbml0X3dpdGhfY29yZV9yZXNvdXJjZShXZWJLaXRXZWJSZXNvdXJjZSogd2Vi UmVzb3VyY2UsIFBhc3NSZWZQdHI8QXJjaGl2ZVJlc291cmNlPiByZXNvdXJjZSkKK3sKKyAgICBX ZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUqIHByaXYgPSB3ZWJSZXNvdXJjZS0+cHJpdjsKKworICAg IGlmIChwcml2LT5yZXNvdXJjZSkKKyAgICAgICAgcHJpdi0+cmVzb3VyY2UtPmRlcmVmKCk7CisK KyAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2NsZWFudXAod2ViUmVzb3VyY2UpOworCisgICAgcHJp di0+cmVzb3VyY2UgPSByZXNvdXJjZS5yZWxlYXNlUmVmKCk7Cit9CisKIC8qKgogICogd2Via2l0 X3dlYl9yZXNvdXJjZV9uZXc6CiAgKiBAZGF0YTogdGhlIGRhdGEgdG8gaW5pdGlhbGl6ZSB0aGUg I1dlYktpdFdlYlJlc291cmNlCkBAIC0yNzAsMTEgKzI5OCwxNCBAQCBHX0NPTlNUX1JFVFVSTiBn Y2hhciogd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKFdlYktpdFdlYlJlc291cmNlKiB3ZWJS ZXNvdXJjZQogICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdFQktJVF9JU19XRUJfUkVTT1VSQ0Uo d2ViUmVzb3VyY2UpLCBOVUxMKTsKIAogICAgIFdlYktpdFdlYlJlc291cmNlUHJpdmF0ZSogcHJp diA9IHdlYlJlc291cmNlLT5wcml2OworCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0 dXJuIHByaXYtPnVyaTsKKwogICAgIGlmICghcHJpdi0+cmVzb3VyY2UpCiAgICAgICAgIHJldHVy biBOVUxMOwogCi0gICAgaWYgKCFwcml2LT51cmkpCi0gICAgICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHByaXYtPnJlc291cmNlLT51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBw cml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5yZXNvdXJjZS0+dXJsKCkuc3RyaW5nKCkudXRmOCgp LmRhdGEoKSk7CiAKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQpAQCAtMzQ0LDMgKzM3NSw0IEBA IEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9mcmFtZV9uYW1l KFdlYktpdFdlYlJlc291cmNlKiB3ZWJSCiAKICAgICByZXR1cm4gcHJpdi0+ZnJhbWVOYW1lOwog fQorCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDRjOGZjYTEuLjNmMzljZGYg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0yNSwxMSArMjUsMTMgQEAKICAq LwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAid2Via2l0d2Vidmlldy5oIgogCiAj aW5jbHVkZSAid2Via2l0ZG93bmxvYWQuaCIKLSNpbmNsdWRlICJ3ZWJraXR3ZWJ2aWV3LmgiCiAj aW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgiCiAjaW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgor I2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29y a3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAid2Via2l0cHJpdmF0ZS5oIgogI2luY2x1ZGUgIndlYmtp dHdlYmluc3BlY3Rvci5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIgpA QCAtMTQ0LDYgKzE0Niw3IEBAIGVudW0gewogICAgIENMT1NFX1dFQl9WSUVXLAogICAgIFVORE8s CiAgICAgUkVETywKKyAgICBSRVNPVVJDRV9SRVFVRVNUX1NUQVJUSU5HLAogICAgIExBU1RfU0lH TkFMCiB9OwogCkBAIC05OTAsNiArOTkzLDExIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmll d19kaXNwb3NlKEdPYmplY3QqIG9iamVjdCkKICAgICAgICAgcHJpdi0+cGFzdGVfdGFyZ2V0X2xp c3QgPSBOVUxMOwogICAgIH0KIAorICAgIGlmIChwcml2LT5zdWJSZXNvdXJjZXMpIHsKKyAgICAg ICAgZ19oYXNoX3RhYmxlX3VucmVmKHByaXYtPnN1YlJlc291cmNlcyk7CisgICAgICAgIHByaXYt PnN1YlJlc291cmNlcyA9IE5VTEw7CisgICAgfQorCiAgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0 X3dlYl92aWV3X3BhcmVudF9jbGFzcyktPmRpc3Bvc2Uob2JqZWN0KTsKIH0KIApAQCAtMTk1Miw2 ICsxOTYwLDQ3IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktp dFdlYlZpZXdDbGFzcyogd2ViVmlld0NsYXNzKQogICAgICAgICAgICAgR1RLX1RZUEVfV0lER0VU LCAzLAogICAgICAgICAgICAgR19UWVBFX1NUUklORywgR19UWVBFX1NUUklORywgR19UWVBFX0hB U0hfVEFCTEUpOwogCisgICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6cmVzb3VyY2UtcmVx dWVzdC1zdGFydGluZzoKKyAgICAgKiBAd2ViX3ZpZXc6IHRoZSBvYmplY3Qgd2hpY2ggcmVjZWl2 ZWQgdGhlIHNpZ25hbAorICAgICAqIEB3ZWJfZnJhbWU6IHRoZSAjV2ViS2l0V2ViRnJhbWUgd2hv c2UgbG9hZCBkaXNwYXRjaGVkIHRoaXMgcmVxdWVzdAorICAgICAqIEB3ZWJfcmVzb3VyY2U6IGFu IGVtcHR5ICNXZWJLaXRXZWJSZXNvdXJjZSBvYmplY3QKKyAgICAgKiBAcmVxdWVzdDogdGhlICNX ZWJLaXROZXR3b3JrUmVxdWVzdCB0aGF0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAqIEByZXNw b25zZTogdGhlICNXZWJLaXROZXR3b3JrUmVzcG9uc2UgcmVwcmVzZW50aW5nIHRoZSByZWRpcmVj dAorICAgICAqIHJlc3BvbnNlLCBpZiBhbnkKKyAgICAgKgorICAgICAqIEVtaXR0ZWQgd2hlbiBh IHJlcXVlc3QgaXMgYWJvdXQgdG8gYmUgc2VudC4gWW91IGNhbiBtb2RpZnkgdGhlCisgICAgICog cmVxdWVzdCwgYnkgYWRkaW5nL3JlbW92aW5nL3JlcGxhY2luZyBoZWFkZXJzLCBvciBjaGFuZ2lu ZyB0aGUKKyAgICAgKiBVUkksIHVzaW5nIHRoZSAjU291cE1lc3NhZ2Ugb2JqZWN0IGl0IGNhcnJp ZXMsIGlmIGl0IGlzCisgICAgICogcHJlc2VudC4gU2VlIHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rf Z2V0X21lc3NhZ2UoKS4gU2V0dGluZyB0aGUKKyAgICAgKiByZXF1ZXN0IFVSSSB0byAiYWJvdXQ6 YmxhbmsiIHdpbGwgZWZmZWN0aXZlbHkgY2F1c2UgdGhlIHJlcXVlc3QKKyAgICAgKiB0byBsb2Fk IG5vdGhpbmcsIGFuZCBjYW4gYmUgdXNlZCB0byBkaXNhYmxlIHRoZSBsb2FkaW5nIG9mCisgICAg ICogc3BlY2lmaWMgcmVzb3VyY2VzLgorICAgICAqCisgICAgICogTm90aWNlIHRoYXQgaW5mb3Jt YXRpb24gYWJvdXQgYW4gZXZlbnR1YWwgcmVkaXJlY3QgYXJlCisgICAgICogYXZhaWxhYmxlIGlu IEByZXNwb25zZSdzICNTb3VwTWVzc2FnZSwgbm90IGluIHRoZSAjU291cE1lc3NhZ2UKKyAgICAg KiBjYXJyaWVkIGJ5IHRoZSBAcmVxdWVzdC4gSWYgQHJlc3BvbnNlIGRvZXNuJ3QgaGF2ZSBhCisg ICAgICogI1NvdXBNZXNzYWdlIChpLmUuIGlmIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9t ZXNzYWdlKCkKKyAgICAgKiByZXR1cm5zICVOVUxMKSwgdGhlbiB0aGlzIGlzIG5vdCBhIHJlZGly ZWN0ZWQgcmVxdWVzdC4KKyAgICAgKgorICAgICAqIFRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ugb2Jq ZWN0IHdpbGwgYmUgdGhlIHNhbWUgdGhyb3VnaG91dCBhbGwKKyAgICAgKiB0aGUgbGlmZXRpbWUg b2YgdGhlIHJlc291cmNlLCBidXQgdGhlIGNvbnRlbnRzIG1heSBjaGFuZ2UgZnJvbQorICAgICAq IGluYmV0d2VlbiBzaWduYWwgZW1pc3Npb25zLgorICAgICAqCisgICAgICogU2luY2U6IDEuMS4x NAorICAgICAqLworICAgIHdlYmtpdF93ZWJfdmlld19zaWduYWxzW1JFU09VUkNFX1JFUVVFU1Rf U1RBUlRJTkddID0gZ19zaWduYWxfbmV3KCJyZXNvdXJjZS1yZXF1ZXN0LXN0YXJ0aW5nIiwKKyAg ICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNTKHdlYlZpZXdDbGFzcyksCisgICAgICAgICAgICAo R1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5fTEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAg ICAgICAgICAwLAorICAgICAgICAgICAgTlVMTCwgTlVMTCwKKyAgICAgICAgICAgIHdlYmtpdF9t YXJzaGFsX1ZPSURfX09CSkVDVF9PQkpFQ1RfT0JKRUNUX09CSkVDVCwKKyAgICAgICAgICAgIEdf VFlQRV9OT05FLCA0LAorICAgICAgICAgICAgV0VCS0lUX1RZUEVfV0VCX0ZSQU1FLAorICAgICAg ICAgICAgV0VCS0lUX1RZUEVfV0VCX1JFU09VUkNFLAorICAgICAgICAgICAgV0VCS0lUX1RZUEVf TkVUV09SS19SRVFVRVNULAorICAgICAgICAgICAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05T RSk7CisKICAgICAvKgogICAgICAqIGltcGxlbWVudGF0aW9ucyBvZiB2aXJ0dWFsIG1ldGhvZHMK ICAgICAgKi8KQEAgLTI0OTEsNiArMjU0MCw4IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmll d19pbml0KFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCiAgICAgZ19zaWduYWxfY29ubmVjdChwcml2 LT53ZWJTZXR0aW5ncywgIm5vdGlmeSIsIEdfQ0FMTEJBQ0sod2Via2l0X3dlYl92aWV3X3NldHRp bmdzX25vdGlmeSksIHdlYlZpZXcpOwogCiAgICAgcHJpdi0+d2ViV2luZG93RmVhdHVyZXMgPSB3 ZWJraXRfd2ViX3dpbmRvd19mZWF0dXJlc19uZXcoKTsKKworICAgIHByaXYtPnN1YlJlc291cmNl cyA9IGdfaGFzaF90YWJsZV9uZXdfZnVsbChnX3N0cl9oYXNoLCBnX3N0cl9lcXVhbCwgZ19mcmVl LCBnX29iamVjdF91bnJlZik7CiB9CiAKIEd0a1dpZGdldCogd2Via2l0X3dlYl92aWV3X25ldyh2 b2lkKQpAQCAtMzc3NiwzICszODI3LDI5IEBAIGdib29sZWFuIHdlYmtpdF93ZWJfdmlld19nZXRf dmlld19zb3VyY2VfbW9kZSAoV2ViS2l0V2ViVmlldyogd2ViVmlldykKIAogICAgIHJldHVybiBG QUxTRTsKIH0KKworLy8gSW50ZXJuYWwgc3VicmVzb3VyY2UgbWFuYWdlbWVudAordm9pZCB3ZWJr aXRfd2ViX3ZpZXdfYWRkX3Jlc291cmNlKFdlYktpdFdlYlZpZXcqIHdlYldlYlZpZXcsIGNoYXIq IGlkZW50aWZpZXIsIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJjZSkKK3sKKyAgICBXZWJL aXRXZWJWaWV3UHJpdmF0ZSogcHJpdiA9IHdlYldlYlZpZXctPnByaXY7CisgICAgZ19oYXNoX3Rh YmxlX2luc2VydChwcml2LT5zdWJSZXNvdXJjZXMsIGlkZW50aWZpZXIsIHdlYlJlc291cmNlKTsK K30KKworV2ViS2l0V2ViUmVzb3VyY2UqIHdlYmtpdF93ZWJfdmlld19nZXRfcmVzb3VyY2UoV2Vi S2l0V2ViVmlldyogd2ViV2ViVmlldywgY2hhciogaWRlbnRpZmllcikKK3sKKyAgICBXZWJLaXRX ZWJWaWV3UHJpdmF0ZSogcHJpdiA9IHdlYldlYlZpZXctPnByaXY7CisgICAgV2ViS2l0V2ViUmVz b3VyY2UqIHdlYlJlc291cmNlID0gTlVMTDsKKworICAgIGdib29sZWFuIHJlc291cmNlRm91bmQg PSBnX2hhc2hfdGFibGVfbG9va3VwX2V4dGVuZGVkKHByaXYtPnN1YlJlc291cmNlcywgaWRlbnRp ZmllciwgTlVMTCwgcmVpbnRlcnByZXRfY2FzdDxncG9pbnRlcio+KCZ3ZWJSZXNvdXJjZSkpOwor CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwocmVzb3VyY2VGb3VuZCwgTlVMTCk7CisKKyAgICBy ZXR1cm4gV0VCS0lUX1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSk7Cit9CisKK3ZvaWQgd2Via2l0 X3dlYl92aWV3X3JlbW92ZV9yZXNvdXJjZShXZWJLaXRXZWJWaWV3KiB3ZWJXZWJWaWV3LCBjaGFy KiBpZGVudGlmaWVyKQoreworICAgIFdlYktpdFdlYlZpZXdQcml2YXRlKiBwcml2ID0gd2ViV2Vi Vmlldy0+cHJpdjsKKyAgICBnX2hhc2hfdGFibGVfcmVtb3ZlKHByaXYtPnN1YlJlc291cmNlcywg aWRlbnRpZmllcik7Cit9CisKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0bWFyc2hhbC5s aXN0IGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKaW5kZXggYWEwZDQwYy4uY2ZmODAx OCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKKysrIGIvV2ViS2l0 L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKQEAgLTEzLDcgKzEzLDExIEBAIE9CSkVDVDpPQkpFQ1QK IE9CSkVDVDpTVFJJTkcsU1RSSU5HLFBPSU5URVIKIE9CSkVDVDpWT0lECiBWT0lEOk9CSkVDVCxP QkpFQ1QKK1ZPSUQ6T0JKRUNULE9CSkVDVCxPQkpFQ1QsT0JKRUNUCitWT0lEOk9CSkVDVCxQT0lO VEVSCiBWT0lEOk9CSkVDVCxQT0lOVEVSLFBPSU5URVIKIFZPSUQ6T0JKRUNULFNUUklORworVk9J RDpPQkpFQ1QsVUxPTkcKIFZPSUQ6U1RSSU5HCiBWT0lEOlNUUklORyxTVFJJTkcKK1ZPSUQ6U1RS SU5HLFBPSU5URVIKLS0gCjEuNi4zLjMKCg== 39082 2009-09-04 12:15:36 -0700 2009-09-08 14:44:37 -0700 load-status and load-error implementation for resource loading 0002-Implement-load-status-and-load-error-for-resources.patch text/plain 14062 gustavo RnJvbSA1YWY4NTJiZTY5NzMwYTQ2ZGNhOTQ4ODI3ODI4MGE5MmNlODM3NDUyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IEZyaSwgNCBTZXAgMjAwOSAxNTo0ODowMyAtMDMwMApT dWJqZWN0OiBbUEFUQ0ggMi80XSBJbXBsZW1lbnQgbG9hZC1zdGF0dXMgYW5kIGxvYWQtZXJyb3Ig Zm9yIHJlc291cmNlcwoKLS0tCiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTIgKysrKwogTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1NraXBw ZWQgICAgICAgICAgICAgICAgICAgfCAgICAyIC0KIFdlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIHwgICAxOCArKysrKy0KIFdlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHByaXZhdGUuaCAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAgICAgICAgICAgICB8ICAgNjQgKysrKysrKysrKysr KysrKysrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmggICAgICAgICAg ICAgIHwgICAyMSArKysrKysrCiBXZWJLaXRUb29scy9DaGFuZ2VMb2cgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTQgKysrKwogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3Rr L0R1bXBSZW5kZXJUcmVlLmNwcCAgfCAgIDQzICsrKysrKysrKysrKysKIDggZmlsZXMgY2hhbmdl ZCwgMTcyIGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGM0ODhkZTIuLjQ0 MTMxZGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAwOS0wOS0wMiAgR3VzdGF2byBOb3Jvbmhh IFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjY4NTQKKyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFsbG93 IG1vcmUgY29udHJvbCBvdmVyIG91dGdvaW5nIHJlcXVlc3RzCisKKyAgICAgICAgRW5hYmxlIHR3 byB0ZXN0cyB0aGF0IHByb2R1Y2UgdGhlIGV4cGVjdGVkIHJlc3VsdHMgd2l0aCB0aGUKKyAgICAg ICAgY2hhbmdlcy4KKworICAgICAgICAqIHBsYXRmb3JtL2d0ay9Ta2lwcGVkOgorCiAyMDA5LTA5 LTA0ICBBbGV4ZXkgUHJvc2t1cnlha292ICA8YXBAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IEVyaWMgU2VpZGVsLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3Rr L1NraXBwZWQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAppbmRleCA4NDdmNDEw Li5kYmMzMjgyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZAor KysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvU2tpcHBlZApAQCAtMzc1MCw5ICszNzUwLDcg QEAgaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55 LW1ldGEtdGFnLWluLWJvZHkuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9YRnJhbWVPcHRpb25z L3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLXBhcmVudC1zYW1lLW9yaWdpbi1hbGxvdy5o dG1sCiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLWRl bnktbWV0YS10YWctcGFyZW50LXNhbWUtb3JpZ2luLWRlbnkuaHRtbAogaHR0cC90ZXN0cy9zZWN1 cml0eS9YRnJhbWVPcHRpb25zL3gtZnJhbWUtb3B0aW9ucy1kZW55LW1ldGEtdGFnLmh0bWwKLWh0 dHAvdGVzdHMvc2VjdXJpdHkvWEZyYW1lT3B0aW9ucy94LWZyYW1lLW9wdGlvbnMtZGVueS5odG1s CiBodHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlvbnMveC1mcmFtZS1vcHRpb25zLXBhcmVu dC1zYW1lLW9yaWdpbi1hbGxvdy5odG1sCi1odHRwL3Rlc3RzL3NlY3VyaXR5L1hGcmFtZU9wdGlv bnMveC1mcmFtZS1vcHRpb25zLXBhcmVudC1zYW1lLW9yaWdpbi1kZW55Lmh0bWwKIGh0dHAvdGVz dHMvc2VjdXJpdHkvbGlzdGVuZXIveHNzLXdpbmRvdy1vbmNsaWNrLWFkZEV2ZW50TGlzdGVuZXIu aHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS9saXN0ZW5lci94c3Mtd2luZG93LW9uY2xpY2stc2hv cnRjdXQuaHRtbAogaHR0cC90ZXN0cy9zZWN1cml0eS94c3NBdWRpdG9yL2xpbmstb3BlbnMtbmV3 LXdpbmRvdy5odG1sCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuY3BwCmluZGV4IGYwYzk5OGEuLmE0ZmVkOGUgMTAwNjQ0Ci0tLSBhL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisrKyBiL1dlYktp dC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBAIC04MzYsNyAr ODM2LDExIEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldFRpdGxlKGNvbnN0IFN0cmluZyYg dGl0bGUsIGNvbnN0IEtVUkwmIHVybCkKIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0 Y2hEaWRSZWNlaXZlQ29udGVudExlbmd0aChXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9hZGVy LCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIGludCBsZW5ndGhSZWNlaXZlZCkKIHsKLSAgICBu b3RJbXBsZW1lbnRlZCgpOworICAgIEdPd25QdHI8Z2NoYXI+IGlkZW50aWZpZXJTdHJpbmcoaWRl bnRpZmllclRvU3RyaW5nKGlkZW50aWZpZXIpKTsKKyAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2Vi UmVzb3VyY2UgPSB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Jlc291cmNlKGdldFZpZXdGcm9tRnJhbWUo bV9mcmFtZSksIGlkZW50aWZpZXJTdHJpbmcuZ2V0KCkpOworCisgICAgd2ViUmVzb3VyY2UtPnBy aXYtPmxvYWRTdGF0dXMgPSBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9MT0FESU5HOworICAgIGdfb2Jq ZWN0X25vdGlmeShHX09CSkVDVCh3ZWJSZXNvdXJjZSksICJsb2FkLXN0YXR1cyIpOwogfQogCiB2 b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExvYWRpbmcoV2ViQ29yZTo6 RG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgdW5zaWduZWQgbG9uZyBpZGVudGlmaWVyKQpAQCAtODUw LDYgKzg1NCw5IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkRmluaXNoTG9h ZGluZyhXZWJDb3JlOjpEb2N1bWVudExvYWRlciogbG9hZGVyCiAgICAgUmVmUHRyPEFyY2hpdmVS ZXNvdXJjZT4gY29yZVJlc291cmNlKGxvYWRlci0+c3VicmVzb3VyY2UoS1VSTChLVVJMKCksIHVy aSkpKTsKICAgICB3ZWJraXRfd2ViX3Jlc291cmNlX2luaXRfd2l0aF9jb3JlX3Jlc291cmNlKHdl YlJlc291cmNlLCBjb3JlUmVzb3VyY2UuZ2V0KCkpOwogCisgICAgd2ViUmVzb3VyY2UtPnByaXYt PmxvYWRTdGF0dXMgPSBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9GSU5JU0hFRDsKKyAgICBnX29iamVj dF9ub3RpZnkoR19PQkpFQ1Qod2ViUmVzb3VyY2UpLCAibG9hZC1zdGF0dXMiKTsKKwogICAgIHdl YmtpdF93ZWJfdmlld19yZW1vdmVfcmVzb3VyY2UoZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKSwg aWRlbnRpZmllclN0cmluZy5nZXQoKSk7CiB9CiAKQEAgLTg1Nyw3ICs4NjQsMTQgQEAgdm9pZCBG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGYWlsTG9hZGluZyhXZWJDb3JlOjpEb2N1bWVu dExvYWRlciogbG9hZGVyLAogewogICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9jdW1lbnRMb2Fk ZXIqPihsb2FkZXIpLT5kZWNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKIAotICAgIG5vdElt cGxlbWVudGVkKCk7CisgICAgR093blB0cjxnY2hhcj4gaWRlbnRpZmllclN0cmluZyhpZGVudGlm aWVyVG9TdHJpbmcoaWRlbnRpZmllcikpOworICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNv dXJjZSA9IHdlYmtpdF93ZWJfdmlld19nZXRfcmVzb3VyY2UoZ2V0Vmlld0Zyb21GcmFtZShtX2Zy YW1lKSwgaWRlbnRpZmllclN0cmluZy5nZXQoKSk7CisKKyAgICBHRXJyb3IqIHdlYkVycm9yID0g Z19lcnJvcl9uZXdfbGl0ZXJhbChnX3F1YXJrX2Zyb21fc3RyaW5nKGVycm9yLmRvbWFpbigpLnV0 ZjgoKS5kYXRhKCkpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGVycm9yLmVycm9yQ29kZSgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGVycm9yLmxvY2FsaXplZERlc2NyaXB0aW9uKCkudXRmOCgpLmRhdGEoKSk7CisgICAg Z19zaWduYWxfZW1pdF9ieV9uYW1lKHdlYlJlc291cmNlLCAibG9hZC1lcnJvciIsIGVycm9yLmZh aWxpbmdVUkwoKS51dGY4KCkuZGF0YSgpLCB3ZWJFcnJvcik7CisgICAgZ19lcnJvcl9mcmVlKHdl YkVycm9yKTsKIH0KIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRMb2FkUmVz b3VyY2VCeVhNTEh0dHBSZXF1ZXN0KHVuc2lnbmVkIGxvbmcsIGNvbnN0IFNjcmlwdFN0cmluZyYp CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKaW5kZXggM2EwZjg2Ni4uNzZlZWUyOSAxMDA2NDQK LS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oCisrKyBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHByaXZhdGUuaApAQCAtMTgyLDYgKzE4Miw4IEBAIGV4dGVybiAiQyIgewog ICAgICAgICBnY2hhciogZnJhbWVOYW1lOwogCiAgICAgICAgIEdTdHJpbmcqIGRhdGE7CisKKyAg ICAgICAgV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzIGxvYWRTdGF0dXM7CiAgICAgfTsKICAgICBX ZWJLaXRXZWJSZXNvdXJjZSoKICAgICB3ZWJraXRfd2ViX3Jlc291cmNlX25ld193aXRoX2NvcmVf cmVzb3VyY2UoUGFzc1JlZlB0cjxXZWJDb3JlOjpBcmNoaXZlUmVzb3VyY2U+KTsKZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcCBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAppbmRleCBmZDRhYmI3Li42NjU0YTAwIDEwMDY0 NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAKKysrIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwCkBAIC00NywxNCArNDcsMjIgQEAg dXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiB1c2luZyBuYW1lc3BhY2UgV2ViS2l0OwogCiBlbnVt IHsKKyAgICBMT0FEX0VSUk9SLAorICAgIExBU1RfU0lHTkFMCit9OworCitlbnVtIHsKICAgICBQ Uk9QXzAsCiAKICAgICBQUk9QX1VSSSwKICAgICBQUk9QX01JTUVfVFlQRSwKICAgICBQUk9QX0VO Q09ESU5HLAogICAgIFBST1BfRlJBTUVfTkFNRSwKKyAgICBQUk9QX0xPQURfU1RBVFVTCiB9Owog CitzdGF0aWMgZ3VpbnQgd2Via2l0X3dlYl9yZXNvdXJjZV9zaWduYWxzW0xBU1RfU0lHTkFMXSA9 IHsgMCwgfTsKKwogR19ERUZJTkVfVFlQRShXZWJLaXRXZWJSZXNvdXJjZSwgd2Via2l0X3dlYl9y ZXNvdXJjZSwgR19UWVBFX09CSkVDVCk7CiAKIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3Vy Y2VfZ2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVlKiB2 YWx1ZSwgR1BhcmFtU3BlYyogcHNwZWMpOwpAQCAtMTExLDYgKzExOSwyNyBAQCBzdGF0aWMgdm9p ZCB3ZWJraXRfd2ViX3Jlc291cmNlX2NsYXNzX2luaXQoV2ViS2l0V2ViUmVzb3VyY2VDbGFzcyog a2xhc3MpCiAgICAgZ29iamVjdF9jbGFzcy0+Z2V0X3Byb3BlcnR5ID0gd2Via2l0X3dlYl9yZXNv dXJjZV9nZXRfcHJvcGVydHk7CiAKICAgICAvKioKKyAgICAgKiBXZWJLaXRXZWJSZXNvdXJjZTo6 bG9hZC1lcnJvcgorICAgICAqIEB3ZWJfcmVzb3VyY2U6IHRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ug d2hpY2ggZmFpbGVkIHRvIGxvYWQKKyAgICAgKiBAdXJpOiB0aGUgVVJJIGZyb20gd2hpY2ggdGhl IHJlc291cmNlIHdhcyBiZWluZyBsb2FkZWQKKyAgICAgKiBAd2ViX2Vycm9yOiB0aGUgI0dFcnJv ciB0aGF0IHdhcyB0cmlnZ2VyZWQKKyAgICAgKgorICAgICAqIEFuIGVycm9yIG9jY3VycmVkIHdo aWxlIGxvYWRpbmcgdGhpcyByZXNvdXJjZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQK KyAgICAgKi8KKyAgICB3ZWJraXRfd2ViX3Jlc291cmNlX3NpZ25hbHNbTE9BRF9FUlJPUl0gPSBn X3NpZ25hbF9uZXcoImxvYWQtZXJyb3IiLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mo a2xhc3MpLAorICAgICAgICAgICAgKEdTaWduYWxGbGFncylHX1NJR05BTF9SVU5fTEFTVCwKKyAg ICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLAorICAgICAgICAgICAgTlVMTCwKKyAgICAg ICAgICAgIHdlYmtpdF9tYXJzaGFsX1ZPSURfX1NUUklOR19QT0lOVEVSLAorICAgICAgICAgICAg R19UWVBFX05PTkUsIDIsCisgICAgICAgICAgICBHX1RZUEVfU1RSSU5HLAorICAgICAgICAgICAg R19UWVBFX1BPSU5URVIpOworCisgICAgLyoqCiAgICAgICogV2ViS2l0V2ViUmVzb3VyY2U6dXJp OgogICAgICAqCiAgICAgICogVGhlIFVSSSBvZiB0aGUgd2ViIHJlc291cmNlCkBAIC0xNzIsNiAr MjAxLDIxIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xhc3NfaW5pdChXZWJL aXRXZWJSZXNvdXJjZUNsYXNzKiBrbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRf UEFSQU1fUkVBREFCTEUpKTsKIAorICAgIC8qKgorICAgICAqIFdlYktpdFdlYlJlc291cmNlOmxv YWQtc3RhdHVzOgorICAgICAqCisgICAgICogRGV0ZXJtaW5lcyB0aGUgY3VycmVudCBzdGF0dXMg b2YgdGhlIGxvYWQgZm9yIHRoaXMgcmVzb3VyY2UuCisgICAgICoKKyAgICAgKiBTaW5jZTogMS4x LjE0CisgICAgICovCisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShnb2JqZWN0 X2NsYXNzLCBQUk9QX0xPQURfU1RBVFVTLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZ19wYXJhbV9zcGVjX2VudW0oImxvYWQtc3RhdHVzIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJMb2FkIFN0YXR1cyIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiRGV0ZXJt aW5lcyB0aGUgY3VycmVudCBzdGF0dXMgb2YgdGhlIGxvYWQgZm9yIHRoaXMgcmVzb3VyY2UiLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VC S0lUX1RZUEVfUkVTT1VSQ0VfTE9BRF9TVEFUVVMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9OT1RfU1RB UlRFRCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFdFQktJVF9QQVJBTV9SRUFEQUJMRSkpOworCiAgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2 YXRlKGdvYmplY3RfY2xhc3MsIHNpemVvZihXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGUpKTsKIH0K IApAQCAtMTkyLDYgKzIzNiw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0 X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhCiAgICAgY2FzZSBQ Uk9QX0ZSQU1FX05BTUU6CiAgICAgICAgIGdfdmFsdWVfc2V0X3N0cmluZyh2YWx1ZSwgd2Via2l0 X3dlYl9yZXNvdXJjZV9nZXRfZnJhbWVfbmFtZSh3ZWJSZXNvdXJjZSkpOwogICAgICAgICBicmVh azsKKyAgICBjYXNlIFBST1BfTE9BRF9TVEFUVVM6CisgICAgICAgIGdfdmFsdWVfc2V0X2VudW0o dmFsdWUsIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2xvYWRfc3RhdHVzKHdlYlJlc291cmNlKSk7 CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5W QUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAgICAgICAgYnJlYWs7 CkBAIC0zNzYsMyArNDIzLDIwIEBAIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfd2ViX3Jl c291cmNlX2dldF9mcmFtZV9uYW1lKFdlYktpdFdlYlJlc291cmNlKiB3ZWJSCiAgICAgcmV0dXJu IHByaXYtPmZyYW1lTmFtZTsKIH0KIAorLyoqCisgKiB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9s b2FkX3N0YXR1czoKKyAqIEB3ZWJfcmVzb3VyY2U6IGEgI1dlYktpdFdlYlJlc291cmNlCisgKgor ICogRGV0ZXJtaW5lcyB0aGUgY3VycmVudCBzdGF0dXMgb2YgdGhlIGxvYWQgZm9yIHRoaXMgcmVz b3VyY2UKKyAqCisgKiBSZXR1cm4gdmFsdWU6IGEgI1dlYktpdFJlc291cmNlTG9hZFN0YXR1cwor ICoKKyAqIFNpbmNlOiAxLjEuMTQKKyAqLworV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzIHdlYmtp dF93ZWJfcmVzb3VyY2VfZ2V0X2xvYWRfc3RhdHVzKFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNv dXJjZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX1JFU09VUkNF KHdlYlJlc291cmNlKSwgV0VCS0lUX1JFU09VUkNFX0xPQURfTk9UX1NUQVJURUQpOworCisgICAg V2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7CisgICAg cmV0dXJuIHByaXYtPmxvYWRTdGF0dXM7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJyZXNvdXJjZS5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3Vy Y2UuaAppbmRleCAyNmEwNDU4Li4yOTEwN2RlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJyZXNvdXJjZS5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJl c291cmNlLmgKQEAgLTM2LDYgKzM2LDI0IEBAIEdfQkVHSU5fREVDTFMKIAogdHlwZWRlZiBzdHJ1 Y3QgX1dlYktpdFdlYlJlc291cmNlUHJpdmF0ZSBXZWJLaXRXZWJSZXNvdXJjZVByaXZhdGU7CiAK Ky8qKgorICogV2ViS2l0UmVzb3VyY2VMb2FkU3RhdHVzCisgKiBAV0VCS0lUX1JFU09VUkNFX0xP QURfTk9UX1NUQVJURUQ6IHRoZSByZXNvdXJjZSBpcyBqdXN0IGEgc3R1YiwKKyAqIG5vdGhpbmcg aGFzIGFycml2ZWQgZnJvbSB0aGUgbmV0d29yayB5ZXQKKyAqIEBXRUJLSVRfUkVTT1VSQ0VfTE9B RF9MT0FESU5HOiB0aGUgcmVzb3VyY2UgYWxyZWFkeSBoYXMgc29tZSBkYXRhLAorICogYW5kIHdp bGwgc3RpbGwgcmVjZWl2ZSBzb21lIG1vcmU7IHRoZSBhY3R1YWwgZGF0YSBvbmx5IGJlY29tZXMK KyAqIGF2YWlsYWJsZSB3aGVuIHRoZSBsb2FkIGlzIGZpbmlzaGVkCisgKiBAV0VCS0lUX1JFU09V UkNFX0xPQURfRklOSVNIRUQ6IHRoZSByZXNvdXJjZSBpcyBkb25lIGxvYWRpbmcsIHRoZQorICog ZGF0YSwgYW5kIHRoZSBtZXRhZGF0YSBhcmUgbm93IGF2YWlsYWJsZSB0byBiZSBmZXRjaGVkIGZy b20gdGhlCisgKiBvYmplY3QsIGlmIGFuIGVycm9yIGhhcyBub3QgaGFwcGVuZWQsIGFuZCBXZWJL aXQgd2lsbCBubyBsb25nZXIKKyAqIGhhdmUgYSByZWZlcmVuY2UgdG8gdGhlICNXZWJLaXRXZWJS ZXNvdXJjZSBvYmplY3QKKyAqLwordHlwZWRlZiBlbnVtIHsKKyAgICBXRUJLSVRfUkVTT1VSQ0Vf TE9BRF9OT1RfU1RBUlRFRCwKKyAgICBXRUJLSVRfUkVTT1VSQ0VfTE9BRF9MT0FESU5HLAorICAg IFdFQktJVF9SRVNPVVJDRV9MT0FEX0ZJTklTSEVELAorfSBXZWJLaXRSZXNvdXJjZUxvYWRTdGF0 dXM7CisKIHN0cnVjdCBfV2ViS2l0V2ViUmVzb3VyY2UgewogICAgIEdPYmplY3QgcGFyZW50X2lu c3RhbmNlOwogCkBAIC03OSw2ICs5Nyw5IEBAIHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X2VuY29k aW5nICAgICAgICAgICAoV2ViS2l0V2ViUmVzb3VyY2UgICp3ZWJfcmVzb3VyY2UpOwogV0VCS0lU X0FQSSBHX0NPTlNUX1JFVFVSTiBnY2hhciAqCiB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9mcmFt ZV9uYW1lICAgICAgICAgKFdlYktpdFdlYlJlc291cmNlICAqd2ViX3Jlc291cmNlKTsKIAorV0VC S0lUX0FQSSBXZWJLaXRSZXNvdXJjZUxvYWRTdGF0dXMKK3dlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0 X2xvYWRfc3RhdHVzICAgICAgICAoV2ViS2l0V2ViUmVzb3VyY2UgICp3ZWJfcmVzb3VyY2UpOwor CiBHX0VORF9ERUNMUwogCiAjZW5kaWYgLyogV0VCS0lUX1dFQl9SRVNPVVJDRV9IICovCmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKaW5k ZXggNzM5ZmYyNy4uZWZiNGU2MiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCisr KyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDA5LTA5LTA0ICBH dXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9uaGFAY29sbGFib3JhLmNvLnVrPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1NAorICAgICAgICBbR1RLXSBOZWVk cyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0Z29pbmcgcmVxdWVzdHMKKworICAg ICAgICBBZGQgc3VwcG9ydCBmb3IgRHVtcFJlbmRlclRyZWUgdG8gYmUgYWJsZSB0byBydW4gc29t ZSBtb3JlIHRlc3RzLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJU cmVlLmNwcDoKKyAgICAgICAgKHdlYlJlc291cmNlTG9hZFN0YXR1c0NoYW5nZWQpOgorICAgICAg ICAod2ViVmlld091dGdvaW5nUmVxdWVzdCk6CisgICAgICAgIChjcmVhdGVXZWJWaWV3KToKKwog MjAwOS0wOS0wNCAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAgICAgICAgIFVu cmV2aWV3ZWQgYnVpbGQgZml4LgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0 ay9EdW1wUmVuZGVyVHJlZS5jcHAKaW5kZXggYWY0NTM1OS4uNjkwYzY1MyAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0R1bXBSZW5kZXJUcmVlLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvRHVtcFJlbmRlclRyZWUuY3BwCkBAIC02MDAs NiArNjAwLDQ4IEBAIHN0YXRpYyBnYm9vbGVhbiB3ZWJWaWV3Q2xvc2UoV2ViS2l0V2ViVmlldyog dmlldykKIAogc3RhdGljIFdlYktpdFdlYlZpZXcqIHdlYlZpZXdDcmVhdGUoV2ViS2l0V2ViVmll dyosIFdlYktpdFdlYkZyYW1lKik7CiAKK3N0YXRpYyB2b2lkIHdlYlJlc291cmNlTG9hZFN0YXR1 c0NoYW5nZWQoR09iamVjdCogb2JqZWN0LCBHUGFyYW1TcGVjKiBwc3BlYywgZ3BvaW50ZXIgZGF0 YSkKK3sKKyAgICAvLyBGSVhNRTogPHVua25vd24+IGhlcmUgaXMsIG9uIE1hYywgdGhlIHN0cmlu ZyByZXByZXNlbnRhdGlvbiBvZgorICAgIC8vIHRoZSBvYmplY3QgdGhlIGlkZW50aWZpZXIgbWFw cyB0bworICAgIGlmICghZG9uZSAmJiBnTGF5b3V0VGVzdENvbnRyb2xsZXItPmR1bXBSZXNvdXJj ZUxvYWRDYWxsYmFja3MoKSkKKyAgICAgICAgcHJpbnRmICgiPHVua25vd24+IC0gZGlkRmluaXNo TG9hZGluZ1xuIik7Cit9CisKKy8vIEZJWE1FOiB0ZXN0cyB0aGF0IHVzZSB3aWxsU2VuZFJlcXVl c3QgYXJlIHRvbyBDRk5ldHdvcmstY2VudHJpYzsgd2UKKy8vIHNob3VsZCBtYWtlIHRoZW0gbW9y ZSBnZW5lcmljCitzdGF0aWMgdm9pZCB3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0KFdlYktpdFdlYlZp ZXcqIHZpZXcsIFdlYktpdFdlYkZyYW1lKiBmcmFtZSwgV2ViS2l0V2ViUmVzb3VyY2UqIHJlc291 cmNlLCBXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCwgV2ViS2l0TmV0d29ya1Jlc3BvbnNl KiByZXNwb25zZSwgZ3BvaW50ZXIgZGF0YSkKK3sKKyAgICBTb3VwTWVzc2FnZSogbWVzc2FnZSA9 IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X21lc3NhZ2UocmVxdWVzdCk7CisgICAgY2hhciog dXJpID0gbWVzc2FnZSA/IHNvdXBfdXJpX3RvX3N0cmluZyhzb3VwX21lc3NhZ2VfZ2V0X3VyaSht ZXNzYWdlKSwgRkFMU0UpIDogZ19zdHJkdXAod2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfdXJp KHJlcXVlc3QpKTsKKyAgICBjb25zdCBjaGFyKiByZWZlcmVyID0gTlVMTDsKKworICAgIGlmICht ZXNzYWdlKQorICAgICAgICByZWZlcmVyID0gc291cF9tZXNzYWdlX2hlYWRlcnNfZ2V0X29uZSAo bWVzc2FnZS0+cmVxdWVzdF9oZWFkZXJzLCAiUmVmZXJlciIpOworCisgICAgaWYgKCFkb25lICYm IGdMYXlvdXRUZXN0Q29udHJvbGxlci0+ZHVtcFJlc291cmNlTG9hZENhbGxiYWNrcygpKSB7Cisg ICAgICAgIC8vIEZJWE1FOiBoYW5kbGUgcmVzcG9uc2UgY29ycmVjdGx5IGhlcmUhCisgICAgICAg IHByaW50ZiAoIiVzIC0gd2lsbFNlbmRSZXF1ZXN0IDxOU1VSTFJlcXVlc3QgVVJMICVzLCBtYWlu IGRvY3VtZW50IFVSTCAlcywgaHR0cCBtZXRob2QgJXM+IHJlZGlyZWN0UmVzcG9uc2UgKG51bGwp XG4iLCB1cmksIHVyaSwgcmVmZXJlciwgbWVzc2FnZS0+bWV0aG9kKTsKKyAgICB9CisKKyAgICBT b3VwVVJJKiBzb3VwVVJJID0gc291cF91cmlfbmV3KHVyaSk7CisKKyAgICBpZiAoKCFnX2FzY2lp X3N0cmNhc2VjbXAoImh0dHAiLCBzb3VwVVJJLT5zY2hlbWUpIHx8ICFnX2FzY2lpX3N0cmNhc2Vj bXAoImh0dHBzIiwgc291cFVSSS0+c2NoZW1lKSkKKyAgICAgICAgJiYgZ19hc2NpaV9zdHJjYXNl Y21wKCIxMjcuMC4wLjEiLCBzb3VwVVJJLT5ob3N0KQorICAgICAgICAmJiBnX2FzY2lpX3N0cmNh c2VjbXAoIjI1NS4yNTUuMjU1LjI1NSIsIHNvdXBVUkktPmhvc3QpCisgICAgICAgICYmIGdfYXNj aWlfc3RyY2FzZWNtcCgibG9jYWxob3N0Iiwgc291cFVSSS0+aG9zdCkpIHsKKyAgICAgICAgcHJp bnRmKCJCbG9ja2VkIGFjY2VzcyB0byBleHRlcm5hbCBVUkwgJXNcbiIsIHVyaSk7CisgICAgICAg IHdlYmtpdF9uZXR3b3JrX3JlcXVlc3Rfc2V0X3VyaShyZXF1ZXN0LCAiYWJvdXQ6YmxhbmsiKTsK KyAgICB9CisKKyAgICBnX2ZyZWUodXJpKTsKKyAgICBzb3VwX3VyaV9mcmVlKHNvdXBVUkkpOwor CisgICAgZ19zaWduYWxfY29ubmVjdChyZXNvdXJjZSwgIm5vdGlmeTo6bG9hZC1zdGF0dXMiLAor ICAgICAgICAgICAgICAgICAgICAgR19DQUxMQkFDSyh3ZWJSZXNvdXJjZUxvYWRTdGF0dXNDaGFu Z2VkKSwgMCk7CisKK30KKwogc3RhdGljIFdlYktpdFdlYlZpZXcqIGNyZWF0ZVdlYlZpZXcoKQog ewogICAgIFdlYktpdFdlYlZpZXcqIHZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dlYl92 aWV3X25ldygpKTsKQEAgLTYyMSw2ICs2NjMsNyBAQCBzdGF0aWMgV2ViS2l0V2ViVmlldyogY3Jl YXRlV2ViVmlldygpCiAgICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpzdGF0dXMtYmFyLXRl eHQtY2hhbmdlZCIsIHdlYlZpZXdTdGF0dXNCYXJUZXh0Q2hhbmdlZCwgMCwKICAgICAgICAgICAg ICAgICAgICAgICJzaWduYWw6OmNyZWF0ZS13ZWItdmlldyIsIHdlYlZpZXdDcmVhdGUsIDAsCiAg ICAgICAgICAgICAgICAgICAgICAic2lnbmFsOjpjbG9zZS13ZWItdmlldyIsIHdlYlZpZXdDbG9z ZSwgMCwKKyAgICAgICAgICAgICAgICAgICAgICJzaWduYWw6OnJlc291cmNlLXJlcXVlc3Qtc3Rh cnRpbmciLCB3ZWJWaWV3T3V0Z29pbmdSZXF1ZXN0LCAwLAogICAgICAgICAgICAgICAgICAgICAg TlVMTCk7CiAKICAgICByZXR1cm4gdmlldzsKLS0gCjEuNi4zLjMKCg== 39146 2009-09-07 07:45:23 -0700 2009-09-07 09:15:08 -0700 one more draft, with Xan's comments addressed 0001-New-signal-to-better-handle-resource-loading.patch text/plain 43968 gustavo RnJvbSAzM2QyNGZiMGRjYTkxMTc0Mjc2YjgzNGM5NGUzY2I0NzdmMDFlMDg0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFdlZCwgMiBTZXAgMjAwOSAxNTo1NDoxMSAtMDMwMApT dWJqZWN0OiBbUEFUQ0hdIE5ldyBzaWduYWwgdG8gYmV0dGVyIGhhbmRsZSByZXNvdXJjZSBsb2Fk aW5nCgotLS0KIENoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICAxMCArCiBHTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgIDggKwogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDE1ICsrCiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXNwb25zZS5oICAgfCAgICA0ICsKIC4uLi9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXNwb25zZVNvdXAuY3BwIHwgICA1MiArKysrCiBXZWJLaXQvZ3RrL0NoYW5nZUxv ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNjUgKysrKysKIFdlYktpdC9ndGsv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIHwgICAzMiArKy0KIFdlYktp dC9ndGsvdGVzdHMvdGVzdG5ldHdvcmtyZXNwb25zZS5jICAgICAgICAgICAgIHwgIDEwOCArKysr KysrKwogV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2VicmVzb3VyY2UuYyAgICAgICAgICAgICAgICAg fCAgIDQ2ICsrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdC5oICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAgMSArCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmggICAgICAg ICAgICAgICAgICB8ICAgIDMgKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVl c3QuY3BwICAgICAgICAgfCAgIDEwIC0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmty ZXNwb25zZS5jcHAgICAgICAgIHwgIDI2NCArKysrKysrKysrKysrKysrKysrKwogV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmggICAgICAgICAgfCAgIDc0ICsrKysrKwog V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAgfCAgIDI4 ICsrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAgICAgICB8 ICAgMTQgKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwICAgICAgICAg ICAgfCAgIDQzICsrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAg ICAgICAgICAgIHwgICA0NSArKysrLQogV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QgICAg ICAgICAgICAgICAgICAgICAgfCAgICAxICsKIDIwIGZpbGVzIGNoYW5nZWQsIDc5OSBpbnNlcnRp b25zKCspLCAyNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlU291cC5jcHAKIGNyZWF0ZSBtb2RlIDEw MDY0NCBXZWJLaXQvZ3RrL3Rlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UuYwogY3JlYXRlIG1vZGUg MTAwNjQ0IFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaAoK ZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCBiMzY5N2FlLi40OTZhYTkx IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMDktMDktMDcgIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xs YWJvcmEuY28udWs+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2ODU0CisgICAg ICAgIFtHVEtdIE5lZWRzIEFQSSB0byBhbGxvdyBtb3JlIGNvbnRyb2wgb3ZlciBvdXRnb2luZyBy ZXF1ZXN0cworCisgICAgICAgICogR05VbWFrZWZpbGUuYW06IG5ldyBmaWxlcyBhZGRlZCB0byB0 aGUgYnVpbGQgZm9yIG5ldyBjbGFzcworICAgICAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UKKwog MjAwOS0wOS0wNiAgTWFydGluIFJvYmluc29uICA8bWFydGluLmphbWVzLnJvYmluc29uQGdtYWls LmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBHdXN0YXZvIE5vcm9uaGEsIEphbiBBbG9uem8g YW5kIFhhbiBMb3Blei4KZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUu YW0KaW5kZXggNWMzMGRlZS4uYzUzZmIxYSAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysr IGIvR05VbWFrZWZpbGUuYW0KQEAgLTMxOSw2ICszMTksNyBAQCB3ZWJraXRndGtfaF9hcGkgKz0g XAogCSQoc3JjZGlyKS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3dubG9hZC5oIFwKIAkkKHNy Y2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZXJyb3IuaCBcCiAJJChzcmNkaXIpL1dlYktp dC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmggXAorCSQoc3JjZGlyKS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCBcCiAJJChzcmNkaXIpL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHNvdXBhdXRoZGlhbG9nLmggXAogCSQoc3JjZGlyKS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJiYWNrZm9yd2FyZGxpc3QuaCBcCiAJJChzcmNkaXIpL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYmRhdGFzb3VyY2UuaCBcCkBAIC0zNjIsNiArMzYzLDcgQEAgd2Vi a2l0Z3RrX3NvdXJjZXMgKz0gXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRvd25sb2FkLmNw cCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZXJyb3IuY3BwIFwKIAlXZWJLaXQvZ3RrL3dl YmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAgXAorCVdlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXNwb25zZS5jcHAgXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUu Y3BwIFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggXAogCVdlYktpdC9ndGsv d2Via2l0L3dlYmtpdHNvdXBhdXRoZGlhbG9nLmMgXApAQCAtNTMxLDYgKzUzMyw3IEBAIHdlYmtp dF90ZXN0c19sZGZsYWdzID0gXAogVEVTVF9QUk9HUyArPSBQcm9ncmFtcy91bml0dGVzdHMvdGVz dGh0dHBiYWNrZW5kIFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdGxvYWRpbmcgXAogCVByb2dy YW1zL3VuaXR0ZXN0cy90ZXN0bmV0d29ya3JlcXVlc3QgXAorCVByb2dyYW1zL3VuaXR0ZXN0cy90 ZXN0bmV0d29ya3Jlc3BvbnNlIFwKIAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdlYmZyYW1lIFwK IAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdHdlYmJhY2tmb3J3YXJkbGlzdCBcCiAJUHJvZ3JhbXMv dW5pdHRlc3RzL3Rlc3R3ZWJoaXN0b3J5aXRlbSBcCkBAIC01NTcsNiArNTYwLDExIEBAIFByb2dy YW1zX3VuaXR0ZXN0c190ZXN0bmV0d29ya3JlcXVlc3RfQ0ZMQUdTID0gJCh3ZWJraXRfdGVzdHNf Y2ZsYWdzKQogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RuZXR3b3JrcmVxdWVzdF9MREFERCA9ICQo d2Via2l0X3Rlc3RzX2xkYWRkKQogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RuZXR3b3JrcmVxdWVz dF9MREZMQUdTID0gJCh3ZWJraXRfdGVzdHNfbGRmbGFncykKIAorUHJvZ3JhbXNfdW5pdHRlc3Rz X3Rlc3RuZXR3b3JrcmVzcG9uc2VfU09VUkNFUyA9IFdlYktpdC9ndGsvdGVzdHMvdGVzdG5ldHdv cmtyZXNwb25zZS5jCitQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXNwb25zZV9DRkxB R1MgPSAkKHdlYmtpdF90ZXN0c19jZmxhZ3MpCitQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdv cmtyZXNwb25zZV9MREFERCA9ICQod2Via2l0X3Rlc3RzX2xkYWRkKQorUHJvZ3JhbXNfdW5pdHRl c3RzX3Rlc3RuZXR3b3JrcmVzcG9uc2VfTERGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2xkZmxhZ3Mp CisKIFByb2dyYW1zX3VuaXR0ZXN0c190ZXN0d2ViZnJhbWVfU09VUkNFUyA9IFdlYktpdC9ndGsv dGVzdHMvdGVzdHdlYmZyYW1lLmMKIFByb2dyYW1zX3VuaXR0ZXN0c190ZXN0d2ViZnJhbWVfQ0ZM QUdTID0gJCh3ZWJraXRfdGVzdHNfY2ZsYWdzKQogUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3R3ZWJm cmFtZV9MREFERCA9ICQod2Via2l0X3Rlc3RzX2xkYWRkKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9D aGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0YmYyYzYxLi4xNWM1YjdiIDEwMDY0 NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDE4IEBACisyMDA5LTA5LTA3ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5v cm9uaGFAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y Njg1NAorICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIg b3V0Z29pbmcgcmVxdWVzdHMKKworICAgICAgICBBZGQgaW5mcmFzdHJ1Y3R1cmUgcmVxdWlyZWQg dG8gcHJvdmlkZSB0aGUgbmV3CisgICAgICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSBvYmplY3Qg aW4gb3VyIEFQSS4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOiBBZGQgbmV3IGZpbGVzIHRv IHRoZSBidWlsZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNw b25zZS5oOgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNl U291cC5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZTo6dG9T b3VwTWVzc2FnZSk6CisKIDIwMDktMDktMDcgIE1pY2hhZWwgTm9yZG1hbiAgPG1pY2hhZWxuQGdv b2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gRmlzaGVyLgpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXgg NmFiZDgwNy4uYmM4YzU3OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysg Yi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xOTYzLDYgKzE5NjMsNyBAQCB3ZWJjb3JlZ3Rr X3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlRXJy b3IuaCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3Vw LmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291 cC5jcHAgXAorCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2VT b3VwLmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0 LmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaCBc CiAJV2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2d0ay9UZXh0QnJlYWtJdGVyYXRvckludGVybmFsSUNV R3RrLmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3Vy Y2VSZXNwb25zZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNw b25zZS5oCmluZGV4IGI4Y2I1ODYuLjVmYTMxYTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaAorKysgYi9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgKQEAgLTI4LDYgKzI4LDggQEAKIAogI2lu Y2x1ZGUgIlJlc291cmNlUmVzcG9uc2VCYXNlLmgiCiAKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAu aD4KKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBSZXNvdXJjZVJlc3BvbnNlIDogcHVi bGljIFJlc291cmNlUmVzcG9uc2VCYXNlIHsKQEAgLTQyLDYgKzQ0LDggQEAgcHVibGljOgogICAg IHsKICAgICB9CiAKKyAgICBTb3VwTWVzc2FnZSogdG9Tb3VwTWVzc2FnZSgpIGNvbnN0OworCiBw cml2YXRlOgogICAgIGZyaWVuZCBjbGFzcyBSZXNvdXJjZVJlc3BvbnNlQmFzZTsKIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZVNvdXAu Y3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZVNvdXAu Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5MzU3N2YKLS0tIC9kZXYv bnVsbAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNl U291cC5jcHAKQEAgLTAsMCArMSw1MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHdXN0 YXZvIE5vcm9uaGEgU2lsdmEKKyAqIENvcHlyaWdodCAoQykgMjAwOSBDb2xsYWJvcmEgTHRkLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv ciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwg RmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgorCisjaW5jbHVk ZSAiQ1N0cmluZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisKK3VzaW5nIG5hbWVz cGFjZSBzdGQ7CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworU291cE1lc3NhZ2UqIFJlc291cmNl UmVzcG9uc2U6OnRvU291cE1lc3NhZ2UoKSBjb25zdAoreworICAgIC8vIFRoaXMgR0VUIGhlcmUg aXMganVzdCBiZWNhdXNlIFNvdXBNZXNzYWdlIHdhbnRzIGl0LCB3ZSBkbid0IHJlYWxseSBrbm93 LgorICAgIFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSA9IHNvdXBfbWVzc2FnZV9uZXcoIkdFVCIs IHVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworICAgIGlmICghc291cE1lc3NhZ2UpCisg ICAgICAgIHJldHVybiAwOworCisgICAgc291cE1lc3NhZ2UtPnN0YXR1c19jb2RlID0gaHR0cFN0 YXR1c0NvZGUoKTsKKworICAgIEhUVFBIZWFkZXJNYXAgaGVhZGVycyA9IGh0dHBIZWFkZXJGaWVs ZHMoKTsKKyAgICBTb3VwTWVzc2FnZUhlYWRlcnMqIHNvdXBIZWFkZXJzID0gc291cE1lc3NhZ2Ut PnJlc3BvbnNlX2hlYWRlcnM7CisgICAgaWYgKCFoZWFkZXJzLmlzRW1wdHkoKSkgeworICAgICAg ICBIVFRQSGVhZGVyTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBoZWFkZXJzLmVuZCgpOworICAg ICAgICBmb3IgKEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gaGVhZGVycy5iZWdp bigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgICAgICBzb3VwX21lc3NhZ2VfaGVhZGVyc19h cHBlbmQoc291cEhlYWRlcnMsIGl0LT5maXJzdC5zdHJpbmcoKS51dGY4KCkuZGF0YSgpLCBpdC0+ c2Vjb25kLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKworICAgIC8vIEJvZHkgZGF0YSBpcyBub3Qg aW4gdGhlIG1lc3NhZ2UuCisgICAgcmV0dXJuIHNvdXBNZXNzYWdlOworfQorCit9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmluZGV4IGM3 NGFhNTUuLjJkNWMzYjAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisrKyBiL1dl YktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjggQEAKKzIwMDktMDktMDcgIEd1c3Rhdm8g Tm9yb25oYSBTaWx2YSAgPGd1c3Rhdm8ubm9yb25oYUBjb2xsYWJvcmEuY28udWs+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI2ODU0CisgICAgICAgIFtHVEtdIE5lZWRzIEFQSSB0 byBhbGxvdyBtb3JlIGNvbnRyb2wgb3ZlciBvdXRnb2luZyByZXF1ZXN0cworCisgICAgICAgIE1h cCB0aGUgd2lsbFNlbmRSZXF1ZXN0IGRlbGVnYXRlIHRvIHRoZSAncmVzb3VyY2UtcmVxdWVzdC1z dGFydGluZycKKyAgICAgICAgc2lnbmFsLCBhbGxvd2luZyBtb3JlIGNvbnRyb2wgb2YgdGhlIHJl c291cmNlcyB0aGF0IGFyZSBmZXRjaGVkLgorCisgICAgICAgIFdlIG5vdyBtYXAgdGhlIGlkZW50 aWZpZXJzIGFzc2lnbmVkIGJ5IFdlYkNvcmUgdG8gdGhlIHJlc291cmNlcyBpdCBsb2FkcworICAg ICAgICB0byBXZWJLaXRXZWJSZXNvdXJjZSBvYmplY3RzLCBzdG9yZWQgaW4gYSBHSGFzaFRhYmxl IGluc2lkZSB0aGUKKyAgICAgICAgV2ViS2l0V2ViVmlldyBvYmplY3QuCisKKyAgICAgICAgTWFw cGluZyB3aWxsU2VuZFJlcXVlc3QgcHJvcGVybHkgcmVxdWlyZXMgYW4gYXBwcm9wcmlhdGUgUmVz cG9uc2UKKyAgICAgICAgb2JqZWN0LCBzbyB3ZSBhcmUgaW50cm9kdWNpbmcgV2ViS2l0TmV0d29y a1Jlc3BvbnNlLCB3aGljaCB3b3JrcyBpbiBhCisgICAgICAgIHdheSBzaW1pbGFyIHRvIFdlYktp dE5ldHdvcmtSZXF1ZXN0LgorCisgICAgICAgICogV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJD bGllbnRHdGsuY3BwOgorICAgICAgICAoV2ViS2l0OjppZGVudGlmaWVyVG9TdHJpbmcpOgorICAg ICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxsU2VuZFJlcXVlc3Qp OgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6YXNzaWduSWRlbnRpZmllclRv SW5pdGlhbFJlcXVlc3QpOgorICAgICAgICAoV2ViS2l0OjpGcmFtZUxvYWRlckNsaWVudDo6ZGlz cGF0Y2hEaWRSZWNlaXZlQ29udGVudExlbmd0aCk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9h ZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZpbmlzaExvYWRpbmcpOgorICAgICAgICAoV2ViS2l0OjpG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGYWlsTG9hZGluZyk6CisgICAgICAgICogdGVz dHMvdGVzdG5ldHdvcmtyZXNwb25zZS5jOiBBZGRlZC4KKyAgICAgICAgKHRlc3RfbmV0d29ya19y ZXNwb25zZV9jcmVhdGVfZGVzdHJveSk6CisgICAgICAgICh0ZXN0X25ldHdvcmtfcmVzcG9uc2Vf cHJvcGVydGllcyk6CisgICAgICAgIChtYWluKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0Lmg6 CisgICAgICAgICogd2Via2l0L3dlYmtpdGRlZmluZXMuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Vi a2l0bmV0d29ya3JlcXVlc3QuY3BwOgorICAgICAgICAqIHdlYmtpdC93ZWJraXRuZXR3b3JrcmVz cG9uc2UuY3BwOiBBZGRlZC4KKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2ZpbmFs aXplKToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9wcm9wZXJ0eSk6Cisg ICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfcHJvcGVydHkpOgorICAgICAgICAo d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfY2xhc3NfaW5pdCk6CisgICAgICAgICh3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9pbml0KToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25l d193aXRoX2NvcmVfcmVzcG9uc2UpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2Vf bmV3KToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmkpOgorICAgICAg ICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaSk6CisgICAgICAgICh3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZSk6CisgICAgICAgICogd2Via2l0L3dlYmtpdG5ldHdv cmtyZXNwb25zZS5oOiBBZGRlZC4KKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHA6 CisgICAgICAgIChXVEY6OlNvdXBNZXNzYWdlKToKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0cHJp dmF0ZS5oOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHA6CisgICAgICAg ICh3ZWJraXRfd2ViX3Jlc291cmNlX2NsZWFudXApOgorICAgICAgICAod2Via2l0X3dlYl9yZXNv dXJjZV9maW5hbGl6ZSk6CisgICAgICAgICh3ZWJraXRfd2ViX3Jlc291cmNlX2NsYXNzX2luaXQp OgorICAgICAgICAod2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfcHJvcGVydHkpOgorICAgICAgICAo d2Via2l0X3dlYl9yZXNvdXJjZV9pbml0X3dpdGhfY29yZV9yZXNvdXJjZSk6CisgICAgICAgICh3 ZWJraXRfd2ViX3Jlc291cmNlX2dldF91cmkpOgorICAgICAgICAod2Via2l0X3dlYl9yZXNvdXJj ZV9nZXRfbG9hZF9zdGF0dXMpOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5o OgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKHdlYmtpdF93 ZWJfdmlld19kaXNwb3NlKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KToK KyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19pbml0KToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmll d19hZGRfcmVzb3VyY2UpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X2dldF9yZXNvdXJjZSk6 CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfcmVtb3ZlX3Jlc291cmNlKToKKyAgICAgICAgKiB3 ZWJraXRtYXJzaGFsLmxpc3Q6CisKIDIwMDktMDktMDYgIFhhbiBMb3BleiAgPHhsb3BlekBpZ2Fs aWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEd1c3Rhdm8gTm9yb25oYS4KZGlmZiAtLWdp dCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXgg ZDg1OTFiZC4uZGUwMTAyMiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5jcHAKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlICJjb25m aWcuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudEd0ay5oIgogCisjaW5jbHVkZSAiQXJj aGl2ZVJlc291cmNlLmgiCiAjaW5jbHVkZSAiQ29sb3IuaCIKICNpbmNsdWRlICJEb2N1bWVudExv YWRlci5oIgogI2luY2x1ZGUgIkRvY3VtZW50TG9hZGVyR3RrLmgiCkBAIC01NCw2ICs1NSw3IEBA CiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIndlYmtpdGVycm9yLmgi CiAjaW5jbHVkZSAid2Via2l0bmV0d29ya3JlcXVlc3QuaCIKKyNpbmNsdWRlICJ3ZWJraXRuZXR3 b3JrcmVzcG9uc2UuaCIKICNpbmNsdWRlICJ3ZWJraXRwcml2YXRlLmgiCiAjaW5jbHVkZSAid2Vi a2l0d2ViZnJhbWUuaCIKICNpbmNsdWRlICJ3ZWJraXR3ZWJuYXZpZ2F0aW9uYWN0aW9uLmgiCkBA IC0xODMsMTEgKzE4NSwyOSBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZENh bmNlbEF1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlKFdlYkNvcmU6OkRvY3VtZQogCiB2b2lkIEZyYW1l TG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxTZW5kUmVxdWVzdChXZWJDb3JlOjpEb2N1bWVudExv YWRlciogbG9hZGVyLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIFJlc291cmNlUmVxdWVzdCYg cmVxdWVzdCwgY29uc3QgUmVzb3VyY2VSZXNwb25zZSYgcmVkaXJlY3RSZXNwb25zZSkKIHsKKyAg ICBHT3duUHRyPFdlYktpdE5ldHdvcmtSZXNwb25zZT4gbmV0d29ya1Jlc3BvbnNlKDApOworCisg ICAgLy8gV2UgYXJlIGFkZGluZyBvbmUgbW9yZSByZXNvdXJjZSB0byB0aGUgbG9hZCwgb3IgbWF5 YmUgd2UgYXJlCisgICAgLy8ganVzdCByZWRpcmVjdGluZyBhIGxvYWQuCiAgICAgaWYgKHJlZGly ZWN0UmVzcG9uc2UuaXNOdWxsKCkpCiAgICAgICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9jdW1l bnRMb2FkZXIqPihsb2FkZXIpLT5pbmNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKKyAgICBl bHNlCisgICAgICAgIG5ldHdvcmtSZXNwb25zZS5zZXQod2Via2l0X25ldHdvcmtfcmVzcG9uc2Vf bmV3X3dpdGhfY29yZV9yZXNwb25zZShyZWRpcmVjdFJlc3BvbnNlKSk7CisKKyAgICBXZWJLaXRX ZWJWaWV3KiB3ZWJWaWV3ID0gZ2V0Vmlld0Zyb21GcmFtZShtX2ZyYW1lKTsKKworICAgIEdPd25Q dHI8V2ViS2l0V2ViUmVzb3VyY2U+IHdlYlJlc291cmNlKFdFQktJVF9XRUJfUkVTT1VSQ0UoZ19v YmplY3RfbmV3KFdFQktJVF9UWVBFX1dFQl9SRVNPVVJDRSwgMCkpKTsKKyAgICB3ZWJSZXNvdXJj ZS0+cHJpdi0+dXJpID0gZ19zdHJkdXAocmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0 YSgpKTsKKworICAgIEdPd25QdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+IG5ldHdvcmtSZXF1ZXN0 KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpKTsK KworICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAicmVzb3VyY2UtcmVxdWVzdC1z dGFydGluZyIsIG1fZnJhbWUsIHdlYlJlc291cmNlLmdldCgpLCBuZXR3b3JrUmVxdWVzdC5nZXQo KSwgbmV0d29ya1Jlc3BvbnNlLmdldCgpKTsKKworICAgIC8vIEZlZWQgYW55IGNoYW5nZXMgYmFj ayBpbnRvIHRoZSBSZXNvdXJjZVJlcXVlc3Qgb2JqZWN0LgorICAgIHJlcXVlc3QgPSBjb3JlKG5l dHdvcmtSZXF1ZXN0LmdldCgpKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6YXNzaWdu SWRlbnRpZmllclRvSW5pdGlhbFJlcXVlc3QodW5zaWduZWQgbG9uZyBpZGVudGlmaWVyLCBXZWJD b3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCit2b2lkIEZyYW1l TG9hZGVyQ2xpZW50Ojphc3NpZ25JZGVudGlmaWVyVG9Jbml0aWFsUmVxdWVzdCh1bnNpZ25lZCBs b25nLCBXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlUmVxdWVzdCYpCiB7 CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KQEAgLTc5Miw3ICs4MTIsNyBAQCB2b2lkIEZyYW1l TG9hZGVyQ2xpZW50OjpzZXRUaXRsZShjb25zdCBTdHJpbmcmIHRpdGxlLCBjb25zdCBLVVJMJiB1 cmwpCiAgICAgZnJhbWVEYXRhLT50aXRsZSA9IGdfc3RyZHVwKHRpdGxlLnV0ZjgoKS5kYXRhKCkp OwogfQogCi12b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZFJlY2VpdmVDb250ZW50 TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiwgdW5zaWduZWQgbG9uZyBpZGVudGlmaWVy LCBpbnQgbGVuZ3RoUmVjZWl2ZWQpCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERp ZFJlY2VpdmVDb250ZW50TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIsIHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllciwgaW50IGxlbmd0aFJlY2VpdmVkKQogewogICAgIG5vdElt cGxlbWVudGVkKCk7CiB9CkBAIC04MDAsMTMgKzgyMCwxNyBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50OjpkaXNwYXRjaERpZFJlY2VpdmVDb250ZW50TGVuZ3RoKFdlYkNvcmU6OkRvY3VtZW50TG9h ZGVyKgogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRGaW5pc2hMb2FkaW5nKFdl YkNvcmU6OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIsIHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllcikK IHsKICAgICBzdGF0aWNfY2FzdDxXZWJLaXQ6OkRvY3VtZW50TG9hZGVyKj4obG9hZGVyKS0+ZGVj cmVhc2VMb2FkQ291bnQoaWRlbnRpZmllcik7CisKKyAgICBub3RJbXBsZW1lbnRlZCgpOwogfQog CiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZhaWxMb2FkaW5nKFdlYkNvcmU6 OkRvY3VtZW50TG9hZGVyKiBsb2FkZXIsIHVuc2lnbmVkIGxvbmcgaWRlbnRpZmllciwgY29uc3Qg UmVzb3VyY2VFcnJvciYgZXJyb3IpCiB7Ci0gICAgLy8gRklYTUU6IHdoZW4gZG9lcyB0aGlzIG9j Y3VyIGFuZCB3aGF0IHNob3VsZCBoYXBwZW4/Ci0KICAgICBzdGF0aWNfY2FzdDxXZWJLaXQ6OkRv Y3VtZW50TG9hZGVyKj4obG9hZGVyKS0+ZGVjcmVhc2VMb2FkQ291bnQoaWRlbnRpZmllcik7CisK KyAgICAvLyBUaGlzIGZ1bmN0aW9uIHNob3VsZCBub3RpZnkgdGhlIGFwcGxpY2F0aW9uIHRoYXQg YSByZXNvdXJjZSBmYWlsZWQKKyAgICAvLyBsb2FkaW5nIChtYXliZSBhICdsb2FkLWVycm9yJyBz aWduYWwgaW4gdGhlIFdlYktpdFdlYlJlc291cmNlIG9iamVjdAorICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkTG9hZFJlc291cmNl QnlYTUxIdHRwUmVxdWVzdCh1bnNpZ25lZCBsb25nLCBjb25zdCBTY3JpcHRTdHJpbmcmKQpkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMgYi9XZWJLaXQv Z3RrL3Rlc3RzL3Rlc3RuZXR3b3JrcmVzcG9uc2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi45MDUwYzA0Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L2d0ay90ZXN0cy90 ZXN0bmV0d29ya3Jlc3BvbnNlLmMKQEAgLTAsMCArMSwxMDggQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQ29s bGFib3JhIEx0ZC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2Yg dGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAq IGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBu b3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBG cmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBV U0EuCisgKi8KKworI2luY2x1ZGUgPGVycm5vLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5j bHVkZSA8Z2xpYi5oPgorI2luY2x1ZGUgPGdsaWIvZ3N0ZGlvLmg+CisjaW5jbHVkZSA8Z3RrL2d0 ay5oPgorI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXQuaD4KKwor I2lmIEdMSUJfQ0hFQ0tfVkVSU0lPTigyLCAxNiwgMCkgJiYgR1RLX0NIRUNLX1ZFUlNJT04oMiwg MTQsIDApCisKK3N0YXRpYyB2b2lkIHRlc3RfbmV0d29ya19yZXNwb25zZV9jcmVhdGVfZGVzdHJv eSgpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZTsKKyAgICBTb3VwTWVz c2FnZSogbWVzc2FnZTsKKworICAgIC8qIFRlc3QgY3JlYXRpb24gd2l0aCBVUkkgKi8KKyAgICBy ZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQ RV9ORVRXT1JLX1JFU1BPTlNFLCAidXJpIiwgImh0dHA6Ly9kZWJpYW4ub3JnLyIsIE5VTEwpKTsK KyAgICBnX2Fzc2VydChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAg IG1lc3NhZ2UgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZShyZXNwb25zZSk7 CisgICAgZ19hc3NlcnQoIW1lc3NhZ2UpOworICAgIGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsK KworICAgIC8qIFRlc3QgY3JlYXRpb24gd2l0aCBTb3VwTWVzc2FnZSAqLworICAgIG1lc3NhZ2Ug PSBzb3VwX21lc3NhZ2VfbmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgcmVz cG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVf TkVUV09SS19SRVNQT05TRSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCBOVUxMKSk7CisgICAgZ19hc3Nl cnQoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9j bXBpbnQoR19PQkpFQ1QobWVzc2FnZSktPnJlZl9jb3VudCwgPT0sIDIpOworICAgIGdfb2JqZWN0 X3VucmVmKHJlc3BvbnNlKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1QobWVzc2FnZSkt PnJlZl9jb3VudCwgPT0sIDEpOworICAgIGdfb2JqZWN0X3VucmVmKG1lc3NhZ2UpOworCisgICAg LyogVGVzdCBjcmVhdGlvbiB3aXRoIGJvdGggU291cE1lc3NhZ2UgYW5kIFVSSSAqLworICAgIG1l c3NhZ2UgPSBzb3VwX21lc3NhZ2VfbmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5vcmcvIik7Cisg ICAgcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lU X1RZUEVfTkVUV09SS19SRVNQT05TRSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCAidXJpIiwgImh0dHA6 Ly9nbm9tZS5vcmcvIiwgTlVMTCkpOworICAgIGdfYXNzZXJ0KFdFQktJVF9JU19ORVRXT1JLX1JF U1BPTlNFKHJlc3BvbnNlKSk7CisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNUKG1lc3NhZ2Up LT5yZWZfY291bnQsID09LCAyKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZ2V0X3VyaShyZXNwb25zZSksID09LCAiaHR0cDovL2dub21lLm9yZy8iKTsKKyAg ICBnX29iamVjdF91bnJlZihyZXNwb25zZSk7CisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNU KG1lc3NhZ2UpLT5yZWZfY291bnQsID09LCAxKTsKKyAgICBnX29iamVjdF91bnJlZihtZXNzYWdl KTsKK30KKworc3RhdGljIHZvaWQgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX3Byb3BlcnRpZXMoKQor eworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2U7CisgICAgU291cE1lc3NhZ2Uq IG1lc3NhZ2U7CisgICAgZ2NoYXIqIHNvdXBVUkk7CisKKyAgICAvKiBUZXN0IFVSSSBpcyBzZXQg Y29ycmVjdGx5IHdoZW4gY3JlYXRpbmcgd2l0aCBVUkkgKi8KKyAgICByZXNwb25zZSA9IHdlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX25ldygiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgZ19hc3Nl cnQoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9j bXBzdHIod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3VyaShyZXNwb25zZSksID09LCAiaHR0 cDovL2RlYmlhbi5vcmcvIik7CisgICAgZ19vYmplY3RfdW5yZWYocmVzcG9uc2UpOworCisgICAg LyogVGVzdCBVUkkgaXMgc2V0IGNvcnJlY3RseSB3aGVuIGNyZWF0aW5nIHdpdGggTWVzc2FnZSAq LworICAgIG1lc3NhZ2UgPSBzb3VwX21lc3NhZ2VfbmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5v cmcvIik7CisgICAgcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9u ZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCBOVUxM KSk7CisgICAgZ19hc3NlcnQoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsK KyAgICBnX29iamVjdF91bnJlZihtZXNzYWdlKTsKKworICAgIG1lc3NhZ2UgPSB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZShyZXNwb25zZSk7CisgICAgc291cFVSSSA9IHNvdXBf dXJpX3RvX3N0cmluZyhzb3VwX21lc3NhZ2VfZ2V0X3VyaShtZXNzYWdlKSwgRkFMU0UpOworICAg IGdfYXNzZXJ0X2NtcHN0cihzb3VwVVJJLCA9PSwgImh0dHA6Ly9kZWJpYW4ub3JnLyIpOworICAg IGdfZnJlZShzb3VwVVJJKTsKKworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9nZXRfdXJpKHJlc3BvbnNlKSwgPT0sICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAg ICBnX29iamVjdF91bnJlZihyZXNwb25zZSk7Cit9CisKK2ludCBtYWluKGludCBhcmdjLCBjaGFy KiogYXJndikKK3sKKyAgICBnX3RocmVhZF9pbml0KE5VTEwpOworICAgIGd0a190ZXN0X2luaXQo JmFyZ2MsICZhcmd2LCBOVUxMKTsKKworICAgIGdfdGVzdF9idWdfYmFzZSgiaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvIik7CisgICAgZ190ZXN0X2FkZF9mdW5jKCIvd2Via2l0L25ldHdvcmtyZXNw b25zZS9jcmVhdGVkZXN0cm95IiwgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX2NyZWF0ZV9kZXN0cm95 KTsKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvbmV0d29ya3Jlc3BvbnNlL3Byb3BlcnRp ZXMiLCB0ZXN0X25ldHdvcmtfcmVzcG9uc2VfcHJvcGVydGllcyk7CisgICAgcmV0dXJuIGdfdGVz dF9ydW4gKCk7Cit9CisKKyNlbHNlCitpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCit7 CisgICAgZ19jcml0aWNhbCgiWW91IHdpbGwgbmVlZCBhdCBsZWFzdCBnbGliLTIuMTYuMCBhbmQg Z3RrLTIuMTQuMCB0byBydW4gdGhlIHVuaXQgdGVzdHMuIERvaW5nIG5vdGhpbmcgbm93LiIpOwor ICAgIHJldHVybiAwOworfQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvdGVzdHMv dGVzdHdlYnJlc291cmNlLmMgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJyZXNvdXJjZS5jCmlu ZGV4IDhmMjhiMWIuLmNiOWEwZDkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdl YnJlc291cmNlLmMKKysrIGIvV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2VicmVzb3VyY2UuYwpAQCAt ODcsNiArODcsNDkgQEAgc3RhdGljIHZvaWQgdGVzdF93ZWJraXRfd2ViX3Jlc291cmNlX2dldF9m cmFtZV9uYW1lKFdlYlJlc291cmNlRml4dHVyZSogZml4dHVyZSwKICAgICBnX2ZyZWUoZnJhbWVf bmFtZSk7CiB9CiAKK3N0YXRpYyB2b2lkIHJlc291cmNlX3JlcXVlc3Rfc3RhcnRpbmdfY2IoV2Vi S2l0V2ViVmlldyogd2ViX3ZpZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJfZnJhbWUsIFdlYktpdFdl YlJlc291cmNlKiB3ZWJfcmVzb3VyY2UsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBX ZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBncG9pbnRlciBkYXRhKQoreworICAgIGdi b29sZWFuKiBiZWVuX3RoZXJlID0gZGF0YTsKKyAgICAqYmVlbl90aGVyZSA9IFRSVUU7CisKKyAg ICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKHdlYl9yZXNvdXJj ZSksID09LCAiaHR0cDovL2dub21lLm9yZy8iKTsKKworICAgIC8qIENhbmNlbCB0aGUgcmVxdWVz dC4gKi8KKyAgICB3ZWJraXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkocmVxdWVzdCwgImFib3V0 OmJsYW5rIik7Cit9CisKK3N0YXRpYyB2b2lkIGxvYWRfZmluaXNoZWRfY2IoV2ViS2l0V2ViVmll dyogd2ViX3ZpZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJfZnJhbWUsIGdwb2ludGVyIGRhdGEpCit7 CisgICAgZ2Jvb2xlYW4qIGJlZW5fdGhlcmUgPSBkYXRhOworICAgICpiZWVuX3RoZXJlID0gVFJV RTsKKworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfd2ViX3ZpZXdfZ2V0X3VyaSh3ZWJfdmll dyksID09LCAiYWJvdXQ6YmxhbmsiKTsKK30KKworc3RhdGljIHZvaWQgdGVzdF93ZWJfcmVzb3Vy Y2VfbG9hZGluZygpCit7CisgICAgV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcgPSBXRUJLSVRfV0VC X1ZJRVcod2Via2l0X3dlYl92aWV3X25ldygpKTsKKyAgICBnYm9vbGVhbiBiZWVuX3RvX3Jlc291 cmNlX3JlcXVlc3Rfc3RhcnRpbmcgPSBGQUxTRTsKKyAgICBnYm9vbGVhbiBiZWVuX3RvX2xvYWRf ZmluaXNoZWQgPSBGQUxTRTsKKworICAgIGdfb2JqZWN0X3JlZl9zaW5rKHdlYl92aWV3KTsKKwor ICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2ViX3ZpZXcsICJyZXNvdXJjZS1yZXF1ZXN0LXN0YXJ0aW5n IiwKKyAgICAgICAgICAgICAgICAgICAgIEdfQ0FMTEJBQ0socmVzb3VyY2VfcmVxdWVzdF9zdGFy dGluZ19jYiksCisgICAgICAgICAgICAgICAgICAgICAmYmVlbl90b19yZXNvdXJjZV9yZXF1ZXN0 X3N0YXJ0aW5nKTsKKworICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2ViX3ZpZXcsICJsb2FkLWZpbmlz aGVkIiwKKyAgICAgICAgICAgICAgICAgICAgIEdfQ0FMTEJBQ0sobG9hZF9maW5pc2hlZF9jYiks CisgICAgICAgICAgICAgICAgICAgICAmYmVlbl90b19sb2FkX2ZpbmlzaGVkKTsKKworICAgIHdl YmtpdF93ZWJfdmlld19sb2FkX3VyaSh3ZWJfdmlldywgImh0dHA6Ly9nbm9tZS5vcmcvIik7CisK KyAgICBnX2Fzc2VydF9jbXBpbnQoYmVlbl90b19yZXNvdXJjZV9yZXF1ZXN0X3N0YXJ0aW5nLCA9 PSwgVFJVRSk7CisgICAgZ19hc3NlcnRfY21waW50KGJlZW5fdG9fbG9hZF9maW5pc2hlZCwgPT0s IFRSVUUpOworCisgICAgZ19vYmplY3RfdW5yZWYod2ViX3ZpZXcpOworfQorCiBpbnQgbWFpbihp bnQgYXJnYywgY2hhcioqIGFyZ3YpCiB7CiAgICAgZ190aHJlYWRfaW5pdChOVUxMKTsKQEAgLTEw OCw2ICsxNTEsOSBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCiAgICAgZ190ZXN0 X2FkZCgiL3dlYmtpdC93ZWJyZXNvdXJjZS9nZXRfZGF0YSIsCiAgICAgICAgICAgICAgICBXZWJS ZXNvdXJjZUZpeHR1cmUsIDAsIHdlYl9yZXNvdXJjZV9maXh0dXJlX3NldHVwLAogICAgICAgICAg ICAgICAgdGVzdF93ZWJraXRfd2ViX3Jlc291cmNlX2dldF9kYXRhLCB3ZWJfcmVzb3VyY2VfZml4 dHVyZV90ZWFyZG93bik7CisKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvd2VicmVzb3Vy Y2UvbG9hZGluZyIsIHRlc3Rfd2ViX3Jlc291cmNlX2xvYWRpbmcpOworCiAgICAgcmV0dXJuIGdf dGVzdF9ydW4gKCk7CiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdC5o IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKaW5kZXggZDM5MDRkMi4uMjk0NzYyZCAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0LmgKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVm aW5lcy5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkb3dubG9hZC5oPgogI2luY2x1ZGUgPHdl YmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3 b3JrcmVzcG9uc2UuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuaD4K ICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViZGF0YXNvdXJjZS5oPgogI2luY2x1ZGUgPHdlYmtp dC93ZWJraXR3ZWJmcmFtZS5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 ZGVmaW5lcy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oCmluZGV4IDQ0NWQ5 ZjcuLmFhZGY4NmUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMu aAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKQEAgLTQ0LDYgKzQ0LDkg QEAgR19CRUdJTl9ERUNMUwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0IFdl YktpdE5ldHdvcmtSZXF1ZXN0OwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0 Q2xhc3MgV2ViS2l0TmV0d29ya1JlcXVlc3RDbGFzczsKIAordHlwZWRlZiBzdHJ1Y3QgX1dlYktp dE5ldHdvcmtSZXNwb25zZSBXZWJLaXROZXR3b3JrUmVzcG9uc2U7Cit0eXBlZGVmIHN0cnVjdCBf V2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3M7CisK IHR5cGVkZWYgc3RydWN0IF9XZWJLaXRXZWJCYWNrRm9yd2FyZExpc3QgV2ViS2l0V2ViQmFja0Zv cndhcmRMaXN0OwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdENsYXNz IFdlYktpdFdlYkJhY2tGb3J3YXJkTGlzdENsYXNzOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJr aXRuZXR3b3JrcmVxdWVzdC5jcHAKaW5kZXggZThhMjI1Yy4uNWRlNTdiYiAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMjgsMTYgKzI4LDYgQEAKIAog I2luY2x1ZGUgPGdsaWIvZ2kxOG4tbGliLmg+CiAKLW5hbWVzcGFjZSBXVEYgewotCi10ZW1wbGF0 ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8U291cE1lc3NhZ2U+KFNvdXBNZXNzYWdlKiBzb3VwTWVz c2FnZSkKLXsKLSAgICBpZiAoc291cE1lc3NhZ2UpCi0gICAgICAgIGdfb2JqZWN0X3VucmVmKHNv dXBNZXNzYWdlKTsKLX0KLQotfQotCiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVl c3QKICAqIEBzaG9ydF9kZXNjcmlwdGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVx dWVzdApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNl LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDkzZDNiMQotLS0gL2Rldi9udWxsCisrKyBi L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKQEAgLTAsMCArMSwy NjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggSG9sZ2VyIEhhbnMgUGV0ZXIg RnJleXRoZXIKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAq IENvcHlyaWdodCAoQykgMjAwOSBDb2xsYWJvcmEgTHRkLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBC b3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAid2Via2l0bmV0d29ya3Jlc3BvbnNlLmgiCisKKyNpbmNsdWRlICJHT3duUHRyLmgi CisjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgorI2luY2x1ZGUgIndlYmtpdHByaXZhdGUu aCIKKworI2luY2x1ZGUgPGdsaWIvZ2kxOG4tbGliLmg+CisKKy8qKgorICogU0VDVElPTjp3ZWJr aXRuZXR3b3JrcmVzcG9uc2UKKyAqIEBzaG9ydF9kZXNjcmlwdGlvbjogdGhlIHJlc3BvbnNlIGdp dmVuIHRvIGEgbmV0d29yayByZXF1ZXN0CisgKiBAc2VlX2Fsc286ICNXZWJLaXROZXR3b3JrUmVx dWVzdAorICoKKyAqIFRoaXMgY2xhc3MgcmVwcmVzZW50cyB0aGUgbmV0d29yayByZWxhdGVkIGFz cGVjdHMgb2YgYSBuYXZpZ2F0aW9uCisgKiByZXNwb25zZS4KKyAqCisgKiBTaW5jZTogMS4xLjE0 CisgKi8KKworR19ERUZJTkVfVFlQRShXZWJLaXROZXR3b3JrUmVzcG9uc2UsIHdlYmtpdF9uZXR3 b3JrX3Jlc3BvbnNlLCBHX1RZUEVfT0JKRUNUKTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVz cG9uc2VQcml2YXRlIHsKKyAgICBnY2hhciogdXJpOworICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdl OworfTsKKworI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFURShvYmop IChHX1RZUEVfSU5TVEFOQ0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktf UkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUpKQorCitlbnVtIHsKKyAgICBQ Uk9QXzAsCisKKyAgICBQUk9QX1VSSSwKKyAgICBQUk9QX01FU1NBR0UsCit9OworCitzdGF0aWMg dm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9kaXNwb3NlKEdPYmplY3QqIG9iamVjdCkKK3sK KyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVT UE9OU0Uob2JqZWN0KTsKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0g cmVzcG9uc2UtPnByaXY7CisKKyAgICBpZiAocHJpdi0+bWVzc2FnZSkgeworICAgICAgICBnX29i amVjdF91bnJlZihwcml2LT5tZXNzYWdlKTsKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IE5VTEw7 CisgICAgfQorCisgICAgR19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfcGFy ZW50X2NsYXNzKS0+ZGlzcG9zZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9maW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCit7CisgICAgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKiByZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iamVjdCk7 CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2 OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7CisKKyAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRf bmV0d29ya19yZXNwb25zZV9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOworfQorCitz dGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfcHJvcGVydHkoR09iamVjdCog b2JqZWN0LCBndWludCBwcm9wZXJ0eUlELCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3Bl YykKK3sKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdP UktfUkVTUE9OU0Uob2JqZWN0KTsKKworICAgIHN3aXRjaChwcm9wZXJ0eUlEKSB7CisgICAgY2Fz ZSBQUk9QX1VSSToKKyAgICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9nZXRfdXJpKHJlc3BvbnNlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNh c2UgUFJPUF9NRVNTQUdFOgorICAgICAgICBnX3ZhbHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtp dF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKSk7CisgICAgICAgIGJyZWFr OworICAgIGRlZmF1bHQ6CisgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5WQUxJRF9QUk9QRVJUWV9J RChvYmplY3QsIHByb3BlcnR5SUQsIHBzcGVjKTsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIHdl YmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50 IHByb3BlcnR5SUQsIGNvbnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVjKQorewor ICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQ T05TRShvYmplY3QpOworICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSBy ZXNwb25zZS0+cHJpdjsKKworICAgIHN3aXRjaChwcm9wZXJ0eUlEKSB7CisgICAgY2FzZSBQUk9Q X1VSSToKKyAgICAgICAgd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShyZXNwb25zZSwg Z192YWx1ZV9nZXRfc3RyaW5nKHZhbHVlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJP UF9NRVNTQUdFOgorICAgICAgICBwcml2LT5tZXNzYWdlID0gU09VUF9NRVNTQUdFKGdfdmFsdWVf ZHVwX29iamVjdCh2YWx1ZSkpOworICAgICAgICBicmVhazsKKyAgICBkZWZhdWx0OgorICAgICAg ICBHX09CSkVDVF9XQVJOX0lOVkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wZXJ0eUlELCBw c3BlYyk7CisgICAgfQorfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9j bGFzc19pbml0KFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKiByZXNwb25zZUNsYXNzKQorewor ICAgIEdPYmplY3RDbGFzcyogb2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhyZXNwb25zZUNs YXNzKTsKKworICAgIG9iamVjdENsYXNzLT5kaXNwb3NlID0gd2Via2l0X25ldHdvcmtfcmVzcG9u c2VfZGlzcG9zZTsKKyAgICBvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9maW5hbGl6ZTsKKyAgICBvYmplY3RDbGFzcy0+Z2V0X3Byb3BlcnR5ID0gd2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Byb3BlcnR5OworICAgIG9iamVjdENsYXNzLT5zZXRfcHJv cGVydHkgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfcHJvcGVydHk7CisKKyAgICB3ZWJr aXRfaW5pdCgpOworCisgICAgLyoqCisgICAgICogV2ViS2l0TmV0d29ya1Jlc3BvbnNlOnVyaToK KyAgICAgKgorICAgICAqIFRoZSBVUkkgdG8gd2hpY2ggdGhlIHJlc3BvbnNlIHdpbGwgYmUgbWFk ZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBnX29iamVjdF9j bGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX1VSSSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19zdHJpbmcoInVyaSIsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIlVS SSIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBfKCJUaGUgVVJJIHRvIHdoaWNoIHRoZSByZXNwb25zZSB3aWxsIGJlIG1hZGUuIiksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5V TEwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIChHUGFyYW1GbGFncykoV0VCS0lUX1BBUkFNX1JFQURXUklURSkpKTsKKworICAgIC8qKgor ICAgICAqIFdlYktpdE5ldHdvcmtSZXNwb25zZTptZXNzYWdlOgorICAgICAqCisgICAgICogVGhl ICNTb3VwTWVzc2FnZSB0aGF0IGJhY2tzIHRoZSByZXNwb25zZS4KKyAgICAgKgorICAgICAqIFNp bmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5 KG9iamVjdENsYXNzLCBQUk9QX01FU1NBR0UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBnX3BhcmFtX3NwZWNfb2JqZWN0KCJtZXNzYWdlIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiTWVzc2FnZSIpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJU aGUgU291cE1lc3NhZ2UgdGhhdCBiYWNrcyB0aGUgcmVzcG9uc2UuIiksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNPVVBfVFlQRV9NRVNT QUdFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAoR1BhcmFtRmxhZ3MpKFdFQktJVF9QQVJBTV9SRUFEV1JJVEV8R19QQVJBTV9DT05TVFJV Q1RfT05MWSkpKTsKKworICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShyZXNwb25zZUNsYXNz LCBzaXplb2YoV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSkpOworfQorCitzdGF0aWMgdm9p ZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9pbml0KFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVz cG9uc2UpCit7CisgICAgcmVzcG9uc2UtPnByaXYgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9H RVRfUFJJVkFURShyZXNwb25zZSk7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2Vi S2l0TmV0d29ya1Jlc3BvbnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXdfd2l0aF9jb3Jl X3Jlc3BvbnNlKGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmIHJlc291cmNlUmVzcG9u c2UpCit7CisgICAgR093blB0cjxTb3VwTWVzc2FnZT4gc291cE1lc3NhZ2UocmVzb3VyY2VSZXNw b25zZS50b1NvdXBNZXNzYWdlKCkpOworICAgIGlmIChzb3VwTWVzc2FnZSkKKyAgICAgICAgcmV0 dXJuIFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRX T1JLX1JFU1BPTlNFLCAibWVzc2FnZSIsIHNvdXBNZXNzYWdlLmdldCgpLCBOVUxMKSk7CisKKyAg ICByZXR1cm4gV0VCS0lUX05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBF X05FVFdPUktfUkVTUE9OU0UsICJ1cmkiLCByZXNvdXJjZVJlc3BvbnNlLnVybCgpLnN0cmluZygp LnV0ZjgoKS5kYXRhKCksIE5VTEwpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNw b25zZV9uZXc6CisgKiBAdXJpOiBhbiBVUkkKKyAqCisgKiBDcmVhdGVzIGEgbmV3ICNXZWJLaXRO ZXR3b3JrUmVzcG9uc2UgaW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJuczog YSBuZXcgI1dlYktpdE5ldHdvcmtSZXNwb25zZSwgb3IgJU5VTEwgaWYgdGhlIFVSSSBpcworICog aW52YWxpZC4KKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KK1dlYktpdE5ldHdvcmtSZXNwb25z ZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCit7CisgICAg Z19yZXR1cm5fdmFsX2lmX2ZhaWwodXJpLCBOVUxMKTsKKworICAgIHJldHVybiBXRUJLSVRfTkVU V09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwg InVyaSIsIHVyaSwgTlVMTCkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNl X3NldF91cmk6CisgKiBAcmVzcG9uc2U6IGEgI1dlYktpdE5ldHdvcmtSZXNwb25zZQorICogQHVy aTogYW4gVVJJCisgKgorICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVu IHJlc3BvbnNlLiBXaGVuIHRoZSByZXNwb25zZQorICogaGFzIGFuIGFzc29jaWF0ZWQgI1NvdXBN ZXNzYWdlLCBpdHMgVVJJIHdpbGwgYWxzbyBiZSBzZXQgYnkgdGhpcworICogY2FsbC4KKyAqCisg KiBTaW5jZTogMS4xLjE0CisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3Vy aShXZWJLaXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlLCBjb25zdCBnY2hhciogdXJpKQorewor ICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2Up KTsKKyAgICBnX3JldHVybl9pZl9mYWlsKHVyaSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9u c2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBpZiAocHJpdi0+dXJpKQor ICAgICAgICBnX2ZyZWUocHJpdi0+dXJpKTsKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkp OworCisgICAgaWYgKCFwcml2LT5tZXNzYWdlKQorICAgICAgICByZXR1cm47CisKKyAgICBTb3Vw VVJJKiBzb3VwVVJJID0gc291cF91cmlfbmV3KHVyaSk7CisgICAgaWYgKCFzb3VwVVJJKSB7Cisg ICAgICAgIGdfd2FybmluZygiSW52YWxpZCBVUkk6ICVzIiwgdXJpKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKworICAgIHNvdXBfbWVzc2FnZV9zZXRfdXJpKHByaXYtPm1lc3NhZ2UsIHNvdXBV UkkpOworICAgIHNvdXBfdXJpX2ZyZWUoc291cFVSSSk7Cit9CisKKy8qKgorICogd2Via2l0X25l dHdvcmtfcmVzcG9uc2VfZ2V0X3VyaToKKyAqIEByZXNwb25zZTogYSAjV2ViS2l0TmV0d29ya1Jl c3BvbnNlCisgKgorICogUmV0dXJuczogdGhlIHVyaSBvZiB0aGUgI1dlYktpdE5ldHdvcmtSZXNw b25zZQorICoKKyAqIFNpbmNlOiAxLjEuMTQKKyAqLworR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdl YmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF91cmkoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNw b25zZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVNQ T05TRShyZXNwb25zZSksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0 ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAg cmV0dXJuIHByaXYtPnVyaTsKKworICAgIFNvdXBVUkkqIHNvdXBVUkkgPSBzb3VwX21lc3NhZ2Vf Z2V0X3VyaShwcml2LT5tZXNzYWdlKTsKKyAgICBwcml2LT51cmkgPSBzb3VwX3VyaV90b19zdHJp bmcoc291cFVSSSwgRkFMU0UpOworICAgIHJldHVybiBwcml2LT51cmk7Cit9CisKKy8qKgorICog d2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3NvdXBfbWVzc2FnZToKKyAqIEByZXNwb25zZTog YSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICogT2J0YWlucyB0aGUgI1NvdXBNZXNzYWdl IHRoYXQgcmVwcmVzZW50cyB0aGUgZ2l2ZW4gcmVzcG9uc2UuIE5vdGljZQorICogdGhhdCBvbmx5 IHRoZSByZXNwb25zZSBzaWRlIG9mIHRoZSBIVFRQIGNvbnZlcnNhdGlvbiBpcworICogcmVwcmVz ZW50ZWQuCisgKgorICogUmV0dXJuczogdGhlICNTb3VwTWVzc2FnZQorICogU2luY2U6IDEuMS4x NAorICovCitTb3VwTWVzc2FnZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2Uo V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZf ZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSksIE5VTEwpOworCisgICAg V2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisg ICAgcmV0dXJuIHByaXYtPm1lc3NhZ2U7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdv cmtyZXNwb25zZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmViMjMzYjUK LS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9u c2UuaApAQCAtMCwwICsxLDc0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9y YSBMdGQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgor ICovCisKKyNpZm5kZWYgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfSAorI2RlZmluZSBXRUJLSVRf TkVUV09SS19SRVNQT05TRV9ICisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorCisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KKwor R19CRUdJTl9ERUNMUworCisjZGVmaW5lIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UgICAg ICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VC S0lUX05FVFdPUktfUkVTUE9OU0Uob2JqKSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFO Q0VfQ0FTVCgob2JqKSwgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29y a1Jlc3BvbnNlKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3Mp ICAgIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfQ0FTVCgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09S S19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MpKQorI2RlZmluZSBXRUJLSVRf SVNfTkVUV09SS19SRVNQT05TRShvYmopICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9U WVBFKChvYmopLCBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFKSkKKyNkZWZpbmUgV0VCS0lU X0lTX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQ RSgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSkpCisjZGVmaW5lIFdFQktJ VF9ORVRXT1JLX1JFU1BPTlNFX0dFVF9DTEFTUyhvYmopICAoR19UWVBFX0lOU1RBTkNFX0dFVF9D TEFTUygob2JqKSwgIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtS ZXNwb25zZUNsYXNzKSkKKwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZVBy aXZhdGUgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZTsKKworc3RydWN0IF9XZWJLaXROZXR3 b3JrUmVzcG9uc2UgeworICAgIEdPYmplY3QgcGFyZW50X2luc3RhbmNlOworCisgICAgLyo8IHBy aXZhdGUgPiovCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSAqcHJpdjsKK307CisK K3N0cnVjdCBfV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MgeworICAgIEdPYmplY3RDbGFzcyBw YXJlbnRfY2xhc3M7CisKKyAgICAvKiBQYWRkaW5nIGZvciBmdXR1cmUgZXhwYW5zaW9uICovCisg ICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQwKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRf cmVzZXJ2ZWQxKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQyKSAodm9pZCk7 CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQzKSAodm9pZCk7Cit9OworCitXRUJLSVRfQVBJ IEdUeXBlCit3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdHlwZSAodm9pZCk7CisKK1dFQktJ VF9BUEkgV2ViS2l0TmV0d29ya1Jlc3BvbnNlICoKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25l dyAgICAgIChjb25zdCBnY2hhciAgICAgICAgICAqdXJpKTsKKworV0VCS0lUX0FQSSB2b2lkCit3 ZWJraXRfbmV0d29ya19yZXNwb25zZV9zZXRfdXJpICAoV2ViS2l0TmV0d29ya1Jlc3BvbnNlICpy ZXNwb25zZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciog ICAgICAgICAgdXJpKTsKKworV0VCS0lUX0FQSSBHX0NPTlNUX1JFVFVSTiBnY2hhciAqCit3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpICAoV2ViS2l0TmV0d29ya1Jlc3BvbnNlICpyZXNw b25zZSk7CisKK1dFQktJVF9BUEkgU291cE1lc3NhZ2UgKgord2Via2l0X25ldHdvcmtfcmVzcG9u c2VfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CisKK0dfRU5E X0RFQ0xTCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJp dmF0ZS5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCBkY2E1 NTVjLi42MDk1ZDUwIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRl LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMTE4LDYg KzExOCwzNCBAQCBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVo YXZpb3IgdHlwZSkKIAogfSAvKiogZW5kIG5hbWVzcGFjZSBXZWJLaXQgKi8KIAorbmFtZXNwYWNl IFdURiB7CisKK3RlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxTb3VwTWVzc2FnZT4oU291 cE1lc3NhZ2UqIHNvdXBNZXNzYWdlKQoreworICAgIGlmIChzb3VwTWVzc2FnZSkKKyAgICAgICAg Z19vYmplY3RfdW5yZWYoc291cE1lc3NhZ2UpOworfQorCit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVP d25lZEdQdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1 ZXN0KQoreworICAgIGlmIChyZXF1ZXN0KQorICAgICAgICBnX29iamVjdF91bnJlZihyZXF1ZXN0 KTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdE5ldHdvcmtSZXNw b25zZT4oV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBpZiAocmVzcG9u c2UpCisgICAgICAgIGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKK30KKwordGVtcGxhdGUgPD4g dm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdFdlYlJlc291cmNlPihXZWJLaXRXZWJSZXNvdXJjZSog cmVzb3VyY2UpCit7CisgICAgaWYgKHJlc291cmNlKQorICAgICAgICBnX29iamVjdF91bnJlZihy ZXNvdXJjZSk7Cit9CisKK30KKwogc3RhdGljIEd0a1dpZGdldCogY3VycmVudFRvcGxldmVsQ2Fs bGJhY2soV2ViS2l0U291cEF1dGhEaWFsb2cqIGZlYXR1cmUsIFNvdXBNZXNzYWdlKiBtZXNzYWdl LCBncG9pbnRlciB1c2VyRGF0YSkKIHsKICAgICBncG9pbnRlciBtZXNzYWdlRGF0YSA9IGdfb2Jq ZWN0X2dldF9kYXRhKEdfT0JKRUNUKG1lc3NhZ2UpLCAicmVzb3VyY2VIYW5kbGUiKTsKZGlmZiAt LWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHByaXZhdGUuaAppbmRleCAxYWQ4MDJmLi4wYTQ4ODJmIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0cHJpdmF0ZS5oCkBAIC00Nyw2ICs0Nyw3IEBACiAjaW5jbHVkZSAiQmFja0ZvcndhcmRM aXN0LmgiCiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgPGVuY2hhbnQuaD4KKyNpbmNs dWRlICJHT3duUHRyLmgiCiAjaW5jbHVkZSAiSGlzdG9yeUl0ZW0uaCIKICNpbmNsdWRlICJTZXR0 aW5ncy5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKQEAgLTg3LDYgKzg4LDggQEAgbmFtZXNwYWNlIFdl YktpdCB7CiAKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgY29yZShXZWJLaXROZXR3b3Jr UmVxdWVzdCogcmVxdWVzdCk7CiAKKyAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUo V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CisKICAgICBXZWJDb3JlOjpFZGl0aW5n QmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CiAKICAgICBXZWJLaXRT ZWN1cml0eU9yaWdpbioga2l0KFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luKik7CkBAIC0xOTYsNiAr MTk5LDcgQEAgZXh0ZXJuICJDIiB7CiAgICAgfTsKICAgICBXZWJLaXRXZWJSZXNvdXJjZSoKICAg ICB3ZWJraXRfd2ViX3Jlc291cmNlX25ld193aXRoX2NvcmVfcmVzb3VyY2UoUGFzc1JlZlB0cjxX ZWJDb3JlOjpBcmNoaXZlUmVzb3VyY2U+KTsKKwogICAgIC8vIGVuZCBXZWJLaXRXZWJSZXNvdXJj ZSBwcml2YXRlCiAKICAgICB2b2lkCkBAIC0yMzEsNiArMjM1LDkgQEAgZXh0ZXJuICJDIiB7CiAg ICAgV2ViS2l0TmV0d29ya1JlcXVlc3QqCiAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdf d2l0aF9jb3JlX3JlcXVlc3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJj ZVJlcXVlc3QpOwogCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKgorICAgIHdlYmtpdF9uZXR3 b3JrX3Jlc3BvbnNlX25ld193aXRoX2NvcmVfcmVzcG9uc2UoY29uc3QgV2ViQ29yZTo6UmVzb3Vy Y2VSZXNwb25zZSYgcmVzb3VyY2VSZXNwb25zZSk7CisKICAgICAvLyBGSVhNRTogbW92ZSB0aGlz IHRvIHdlYmtpdG5ldHdvcmtyZXF1ZXN0Lmggb25jZSB0aGUgQVBJIGlzIGFncmVlZCB1cG9uLgog ICAgIFdFQktJVF9BUEkgU291cE1lc3NhZ2UqCiAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9n ZXRfbWVzc2FnZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CkBAIC0zMTIsNCArMzE5 LDExIEBAIGV4dGVybiAiQyIgewogICAgIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3dlYl9k YXRhYmFzZShXZWJLaXRTZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4sIGNvbnN0IGNoYXIq IGRhdGFiYXNlTmFtZSk7CiB9CiAKK25hbWVzcGFjZSBXVEYgeworICAgIHRlbXBsYXRlIDw+IHZv aWQgZnJlZU93bmVkR1B0cjxTb3VwTWVzc2FnZT4oU291cE1lc3NhZ2UqKTsKKyAgICB0ZW1wbGF0 ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+KFdlYktpdE5ldHdv cmtSZXF1ZXN0Kik7CisgICAgdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdE5l dHdvcmtSZXNwb25zZT4oV2ViS2l0TmV0d29ya1Jlc3BvbnNlKik7CisgICAgdGVtcGxhdGUgPD4g dm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdFdlYlJlc291cmNlPihXZWJLaXRXZWJSZXNvdXJjZSop OworfQorCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJl c291cmNlLmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAppbmRl eCBjMTYyNTc4Li5lYWJkNDU5IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJyZXNvdXJjZS5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2Uu Y3BwCkBAIC0yNyw2ICsyNyw4IEBACiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRm b3JtU3RyaW5nLmgiCiAjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAid2Via2l0 ZW51bXR5cGVzLmgiCisjaW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgogI2luY2x1ZGUgInd0Zi9B c3NlcnRpb25zLmgiCiAKICNpbmNsdWRlIDxnbGliLmg+CkBAIC01Nyw2ICs1OSwyNyBAQCBHX0RF RklORV9UWVBFKFdlYktpdFdlYlJlc291cmNlLCB3ZWJraXRfd2ViX3Jlc291cmNlLCBHX1RZUEVf T0JKRUNUKTsKIAogc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfcHJvcGVydHko R09iamVjdCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVj KiBwc3BlYyk7CiAKK3N0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xlYW51cChXZWJL aXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UpCit7CisgICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2 YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7CisKKyAgICBnX2ZyZWUocHJpdi0+dXJpKTsK KyAgICBwcml2LT51cmkgPSBOVUxMOworCisgICAgZ19mcmVlKHByaXYtPm1pbWVUeXBlKTsKKyAg ICBwcml2LT5taW1lVHlwZSA9IE5VTEw7CisKKyAgICBnX2ZyZWUocHJpdi0+dGV4dEVuY29kaW5n KTsKKyAgICBwcml2LT50ZXh0RW5jb2RpbmcgPSBOVUxMOworCisgICAgZ19mcmVlKHByaXYtPmZy YW1lTmFtZSk7CisgICAgcHJpdi0+ZnJhbWVOYW1lID0gTlVMTDsKKworICAgIGlmIChwcml2LT5k YXRhKQorICAgICAgICBnX3N0cmluZ19mcmVlKHByaXYtPmRhdGEsIFRSVUUpOworICAgIHByaXYt PmRhdGEgPSBOVUxMOworfQorCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2Rpc3Bv c2UoR09iamVjdCogb2JqZWN0KQogewogICAgIFdlYktpdFdlYlJlc291cmNlKiB3ZWJSZXNvdXJj ZSA9IFdFQktJVF9XRUJfUkVTT1VSQ0Uob2JqZWN0KTsKQEAgLTczLDE1ICs5Niw4IEBAIHN0YXRp YyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2VfZGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCiBzdGF0 aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKIHsK ICAgICBXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VCX1JFU09VUkNF KG9iamVjdCk7Ci0gICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3Vy Y2UtPnByaXY7CiAKLSAgICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAgICBnX2ZyZWUocHJpdi0+bWlt ZVR5cGUpOwotICAgIGdfZnJlZShwcml2LT50ZXh0RW5jb2RpbmcpOwotICAgIGdfZnJlZShwcml2 LT5mcmFtZU5hbWUpOwotCi0gICAgaWYgKHByaXYtPmRhdGEpCi0gICAgICAgIGdfc3RyaW5nX2Zy ZWUocHJpdi0+ZGF0YSwgVFJVRSk7CisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9jbGVhbnVwKHdl YlJlc291cmNlKTsKIAogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF93ZWJfcmVzb3VyY2VfcGFy ZW50X2NsYXNzKS0+ZmluYWxpemUob2JqZWN0KTsKIH0KQEAgLTI3MCwxMSArMjg2LDE3IEBAIEdf Q09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF91cmkoV2ViS2l0V2Vi UmVzb3VyY2UqIHdlYlJlc291cmNlCiAgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lT X1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSksIE5VTEwpOwogCiAgICAgV2ViS2l0V2ViUmVzb3Vy Y2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7CisKKworICAgIC8vIFdlIG1heSBo YXZlIGFuIFVSSSB3aXRob3V0IGhhdmluZyBhIHJlc291cmNlIGFzc2lnbmVkIHRvIHVzIChlLmcu LCBpZiB0aGUKKyAgICAvLyBGcmFtZUxvYWRlckNsaWVudCBvbmx5IGhhZCBhIFJlc291cmNlUmVx dWVzdCB3aGVuIHdlIGdvdCBjcmVhdGVkCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0 dXJuIHByaXYtPnVyaTsKKwogICAgIGlmICghcHJpdi0+cmVzb3VyY2UpCiAgICAgICAgIHJldHVy biBOVUxMOwogCi0gICAgaWYgKCFwcml2LT51cmkpCi0gICAgICAgIHByaXYtPnVyaSA9IGdfc3Ry ZHVwKHByaXYtPnJlc291cmNlLT51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBw cml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5yZXNvdXJjZS0+dXJsKCkuc3RyaW5nKCkudXRmOCgp LmRhdGEoKSk7CiAKICAgICByZXR1cm4gcHJpdi0+dXJpOwogfQpAQCAtMzQ0LDMgKzM2Niw0IEBA IEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9mcmFtZV9uYW1l KFdlYktpdFdlYlJlc291cmNlKiB3ZWJSCiAKICAgICByZXR1cm4gcHJpdi0+ZnJhbWVOYW1lOwog fQorCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IGM3OTYzN2MuLmZhMGZlYjkg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0yNSwxMSArMjUsMTMgQEAKICAq LwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAid2Via2l0d2Vidmlldy5oIgogCiAj aW5jbHVkZSAid2Via2l0ZG93bmxvYWQuaCIKLSNpbmNsdWRlICJ3ZWJraXR3ZWJ2aWV3LmgiCiAj aW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgiCiAjaW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgor I2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29y a3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAid2Via2l0cHJpdmF0ZS5oIgogI2luY2x1ZGUgIndlYmtp dHdlYmluc3BlY3Rvci5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIgpA QCAtMTQ1LDYgKzE0Nyw3IEBAIGVudW0gewogICAgIFVORE8sCiAgICAgUkVETywKICAgICBEQVRB QkFTRV9RVU9UQV9FWENFRURFRCwKKyAgICBSRVNPVVJDRV9SRVFVRVNUX1NUQVJUSU5HLAogICAg IExBU1RfU0lHTkFMCiB9OwogCkBAIC0xOTc1LDYgKzE5NzgsNDYgQEAgc3RhdGljIHZvaWQgd2Vi a2l0X3dlYl92aWV3X2NsYXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3Mp CiAgICAgICAgICAgICBHX1RZUEVfTk9ORSwgMiwKICAgICAgICAgICAgIEdfVFlQRV9PQkpFQ1Qs IEdfVFlQRV9PQkpFQ1QpOwogCisgICAgLyoqCisgICAgICogV2ViS2l0V2ViVmlldzo6cmVzb3Vy Y2UtcmVxdWVzdC1zdGFydGluZzoKKyAgICAgKiBAd2ViX3ZpZXc6IHRoZSBvYmplY3Qgd2hpY2gg cmVjZWl2ZWQgdGhlIHNpZ25hbAorICAgICAqIEB3ZWJfZnJhbWU6IHRoZSAjV2ViS2l0V2ViRnJh bWUgd2hvc2UgbG9hZCBkaXNwYXRjaGVkIHRoaXMgcmVxdWVzdAorICAgICAqIEB3ZWJfcmVzb3Vy Y2U6IGFuIGVtcHR5ICNXZWJLaXRXZWJSZXNvdXJjZSBvYmplY3QKKyAgICAgKiBAcmVxdWVzdDog dGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdCB0aGF0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAq IEByZXNwb25zZTogdGhlICNXZWJLaXROZXR3b3JrUmVzcG9uc2UgcmVwcmVzZW50aW5nIHRoZSBy ZWRpcmVjdAorICAgICAqIHJlc3BvbnNlLCBpZiBhbnkKKyAgICAgKgorICAgICAqIEVtaXR0ZWQg d2hlbiBhIHJlcXVlc3QgaXMgYWJvdXQgdG8gYmUgc2VudC4gWW91IGNhbiBtb2RpZnkgdGhlCisg ICAgICogcmVxdWVzdCwgYnkgYWRkaW5nL3JlbW92aW5nL3JlcGxhY2luZyBoZWFkZXJzLCBvciBj aGFuZ2luZyB0aGUKKyAgICAgKiBVUkksIHVzaW5nIHRoZSAjU291cE1lc3NhZ2Ugb2JqZWN0IGl0 IGNhcnJpZXMsIGlmIGl0IGlzCisgICAgICogcHJlc2VudC4gU2VlIHdlYmtpdF9uZXR3b3JrX3Jl cXVlc3RfZ2V0X21lc3NhZ2UoKS4gU2V0dGluZyB0aGUKKyAgICAgKiByZXF1ZXN0IFVSSSB0byAi YWJvdXQ6YmxhbmsiIHdpbGwgZWZmZWN0aXZlbHkgY2F1c2UgdGhlIHJlcXVlc3QKKyAgICAgKiB0 byBsb2FkIG5vdGhpbmcsIGFuZCBjYW4gYmUgdXNlZCB0byBkaXNhYmxlIHRoZSBsb2FkaW5nIG9m CisgICAgICogc3BlY2lmaWMgcmVzb3VyY2VzLgorICAgICAqCisgICAgICogTm90aWNlIHRoYXQg aW5mb3JtYXRpb24gYWJvdXQgYW4gZXZlbnR1YWwgcmVkaXJlY3QgaXMgYXZhaWxhYmxlCisgICAg ICogaW4gQHJlc3BvbnNlJ3MgI1NvdXBNZXNzYWdlLCBub3QgaW4gdGhlICNTb3VwTWVzc2FnZSBj YXJyaWVkIGJ5CisgICAgICogdGhlIEByZXF1ZXN0LiBJZiBAcmVzcG9uc2UgaXMgJU5VTEwsIHRo ZW4gdGhpcyBpcyBub3QgYQorICAgICAqIHJlZGlyZWN0ZWQgcmVxdWVzdC4KKyAgICAgKgorICAg ICAqIFRoZSAjV2ViS2l0V2ViUmVzb3VyY2Ugb2JqZWN0IHdpbGwgYmUgdGhlIHNhbWUgdGhyb3Vn aG91dCBhbGwKKyAgICAgKiB0aGUgbGlmZXRpbWUgb2YgdGhlIHJlc291cmNlLCBidXQgdGhlIGNv bnRlbnRzIG1heSBjaGFuZ2UgZnJvbQorICAgICAqIGluYmV0d2VlbiBzaWduYWwgZW1pc3Npb25z LgorICAgICAqCisgICAgICogU2luY2U6IDEuMS4xNAorICAgICAqLworICAgIHdlYmtpdF93ZWJf dmlld19zaWduYWxzW1JFU09VUkNFX1JFUVVFU1RfU1RBUlRJTkddID0gZ19zaWduYWxfbmV3KCJy ZXNvdXJjZS1yZXF1ZXN0LXN0YXJ0aW5nIiwKKyAgICAgICAgICAgIEdfVFlQRV9GUk9NX0NMQVNT KHdlYlZpZXdDbGFzcyksCisgICAgICAgICAgICAoR1NpZ25hbEZsYWdzKShHX1NJR05BTF9SVU5f TEFTVCB8IEdfU0lHTkFMX0FDVElPTiksCisgICAgICAgICAgICAwLAorICAgICAgICAgICAgTlVM TCwgTlVMTCwKKyAgICAgICAgICAgIHdlYmtpdF9tYXJzaGFsX1ZPSURfX09CSkVDVF9PQkpFQ1Rf T0JKRUNUX09CSkVDVCwKKyAgICAgICAgICAgIEdfVFlQRV9OT05FLCA0LAorICAgICAgICAgICAg V0VCS0lUX1RZUEVfV0VCX0ZSQU1FLAorICAgICAgICAgICAgV0VCS0lUX1RZUEVfV0VCX1JFU09V UkNFLAorICAgICAgICAgICAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVFVRVNULAorICAgICAgICAg ICAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSk7CisKICAgICAvKgogICAgICAqIGltcGxl bWVudGF0aW9ucyBvZiB2aXJ0dWFsIG1ldGhvZHMKICAgICAgKi8KZGlmZiAtLWdpdCBhL1dlYktp dC9ndGsvd2Via2l0bWFyc2hhbC5saXN0IGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QK aW5kZXggYWEwZDQwYy4uZmVmZGZmMyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXRtYXJz aGFsLmxpc3QKKysrIGIvV2ViS2l0L2d0ay93ZWJraXRtYXJzaGFsLmxpc3QKQEAgLTEzLDYgKzEz LDcgQEAgT0JKRUNUOk9CSkVDVAogT0JKRUNUOlNUUklORyxTVFJJTkcsUE9JTlRFUgogT0JKRUNU OlZPSUQKIFZPSUQ6T0JKRUNULE9CSkVDVAorVk9JRDpPQkpFQ1QsT0JKRUNULE9CSkVDVCxPQkpF Q1QKIFZPSUQ6T0JKRUNULFBPSU5URVIsUE9JTlRFUgogVk9JRDpPQkpFQ1QsU1RSSU5HCiBWT0lE OlNUUklORwotLSAKMS42LjMuMwoK 39151 2009-09-07 09:15:08 -0700 2009-09-07 09:21:01 -0700 latest comments by Xan addressed 0001-New-signal-to-better-handle-resource-loading.patch text/plain 46748 gustavo RnJvbSA4OGUxZDBjNmE5YjcxOTNjZjZhZGU1NmNiMTgxMTRkYjM5ZTZiZGIwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGd1c3Rhdm8ubm9yb25o YUBjb2xsYWJvcmEuY28udWs+CkRhdGU6IFdlZCwgMiBTZXAgMjAwOSAxNTo1NDoxMSAtMDMwMApT dWJqZWN0OiBbUEFUQ0hdIE5ldyBzaWduYWwgdG8gYmV0dGVyIGhhbmRsZSByZXNvdXJjZSBsb2Fk aW5nCgotLS0KIENoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICAxMCArCiBHTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgIDggKwogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDE1ICsrCiBXZWJDb3JlL0dOVW1ha2VmaWxlLmFtICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgIDEgKwogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZVJlcXVlc3RTb3VwLmNwcCAgfCAgICAzICstCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlLmggICB8ICAgIDQgKwogLi4uL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlU291cC5jcHAgfCAgIDUyICsrKysKIFdlYktpdC9ndGsvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2NSArKysrKwogV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgfCAgIDM3ICsrKy0K IFdlYktpdC9ndGsvdGVzdHMvdGVzdG5ldHdvcmtyZXNwb25zZS5jICAgICAgICAgICAgIHwgIDEw OCArKysrKysrKwogV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2VicmVzb3VyY2UuYyAgICAgICAgICAg ICAgICAgfCAgIDQ2ICsrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdC5oICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMSArCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgg ICAgICAgICAgICAgICAgICB8ICAgIDMgKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29y a3JlcXVlc3QuY3BwICAgICAgICAgfCAgIDEwIC0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5l dHdvcmtyZXNwb25zZS5jcHAgICAgICAgIHwgIDI2NCArKysrKysrKysrKysrKysrKysrKwogV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmggICAgICAgICAgfCAgIDc0ICsr KysrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgICAgICAgICAgICAgICAg fCAgIDI4ICsrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmggICAgICAgICAgICAg ICAgICB8ICAgMTQgKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwICAg ICAgICAgICAgfCAgIDYyICsrKystCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNw cCAgICAgICAgICAgICAgICB8ICAgNDYgKysrKy0KIFdlYktpdC9ndGsvd2Via2l0bWFyc2hhbC5s aXN0ICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiAyMSBmaWxlcyBjaGFuZ2VkLCA4MjYg aW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZVNvdXAuY3BwCiBjcmVhdGUg bW9kZSAxMDA2NDQgV2ViS2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3Bw CiBjcmVhdGUgbW9kZSAxMDA2NDQgV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3Bv bnNlLmgKCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggYjM2OTdhZS4u NDk2YWE5MSAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsx LDEzIEBACisyMDA5LTA5LTA3ICBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgIDxndXN0YXZvLm5vcm9u aGFAY29sbGFib3JhLmNvLnVrPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjg1 NAorICAgICAgICBbR1RLXSBOZWVkcyBBUEkgdG8gYWxsb3cgbW9yZSBjb250cm9sIG92ZXIgb3V0 Z29pbmcgcmVxdWVzdHMKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOiBuZXcgZmlsZXMgYWRk ZWQgdG8gdGhlIGJ1aWxkIGZvciBuZXcgY2xhc3MKKyAgICAgICAgV2ViS2l0TmV0d29ya1Jlc3Bv bnNlCisKIDIwMDktMDktMDYgIE1hcnRpbiBSb2JpbnNvbiAgPG1hcnRpbi5qYW1lcy5yb2JpbnNv bkBnbWFpbC5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR3VzdGF2byBOb3JvbmhhLCBKYW4g QWxvbnpvIGFuZCBYYW4gTG9wZXouCmRpZmYgLS1naXQgYS9HTlVtYWtlZmlsZS5hbSBiL0dOVW1h a2VmaWxlLmFtCmluZGV4IDVjMzBkZWUuLmM1M2ZiMWEgMTAwNjQ0Ci0tLSBhL0dOVW1ha2VmaWxl LmFtCisrKyBiL0dOVW1ha2VmaWxlLmFtCkBAIC0zMTksNiArMzE5LDcgQEAgd2Via2l0Z3RrX2hf YXBpICs9IFwKIAkkKHNyY2RpcikvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZG93bmxvYWQuaCBc CiAJJChzcmNkaXIpL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGVycm9yLmggXAogCSQoc3JjZGly KS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5oIFwKKwkkKHNyY2Rpcikv V2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmggXAogCSQoc3JjZGlyKS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRzb3VwYXV0aGRpYWxvZy5oIFwKIAkkKHNyY2RpcikvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRsaXN0LmggXAogCSQoc3JjZGlyKS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJkYXRhc291cmNlLmggXApAQCAtMzYyLDYgKzM2Myw3 IEBAIHdlYmtpdGd0a19zb3VyY2VzICs9IFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRkb3du bG9hZC5jcHAgXAogCVdlYktpdC9ndGsvd2Via2l0L3dlYmtpdGVycm9yLmNwcCBcCiAJV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwIFwKKwlXZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuY3BwIFwKIAlXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRw cml2YXRlLmNwcCBcCiAJV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5oIFwKIAlXZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRzb3VwYXV0aGRpYWxvZy5jIFwKQEAgLTUzMSw2ICs1MzMsNyBA QCB3ZWJraXRfdGVzdHNfbGRmbGFncyA9IFwKIFRFU1RfUFJPR1MgKz0gUHJvZ3JhbXMvdW5pdHRl c3RzL3Rlc3RodHRwYmFja2VuZCBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3Rsb2FkaW5nIFwK IAlQcm9ncmFtcy91bml0dGVzdHMvdGVzdG5ldHdvcmtyZXF1ZXN0IFwKKwlQcm9ncmFtcy91bml0 dGVzdHMvdGVzdG5ldHdvcmtyZXNwb25zZSBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3R3ZWJm cmFtZSBcCiAJUHJvZ3JhbXMvdW5pdHRlc3RzL3Rlc3R3ZWJiYWNrZm9yd2FyZGxpc3QgXAogCVBy b2dyYW1zL3VuaXR0ZXN0cy90ZXN0d2ViaGlzdG9yeWl0ZW0gXApAQCAtNTU3LDYgKzU2MCwxMSBA QCBQcm9ncmFtc191bml0dGVzdHNfdGVzdG5ldHdvcmtyZXF1ZXN0X0NGTEFHUyA9ICQod2Via2l0 X3Rlc3RzX2NmbGFncykKIFByb2dyYW1zX3VuaXR0ZXN0c190ZXN0bmV0d29ya3JlcXVlc3RfTERB REQgPSAkKHdlYmtpdF90ZXN0c19sZGFkZCkKIFByb2dyYW1zX3VuaXR0ZXN0c190ZXN0bmV0d29y a3JlcXVlc3RfTERGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2xkZmxhZ3MpCiAKK1Byb2dyYW1zX3Vu aXR0ZXN0c190ZXN0bmV0d29ya3Jlc3BvbnNlX1NPVVJDRVMgPSBXZWJLaXQvZ3RrL3Rlc3RzL3Rl c3RuZXR3b3JrcmVzcG9uc2UuYworUHJvZ3JhbXNfdW5pdHRlc3RzX3Rlc3RuZXR3b3JrcmVzcG9u c2VfQ0ZMQUdTID0gJCh3ZWJraXRfdGVzdHNfY2ZsYWdzKQorUHJvZ3JhbXNfdW5pdHRlc3RzX3Rl c3RuZXR3b3JrcmVzcG9uc2VfTERBREQgPSAkKHdlYmtpdF90ZXN0c19sZGFkZCkKK1Byb2dyYW1z X3VuaXR0ZXN0c190ZXN0bmV0d29ya3Jlc3BvbnNlX0xERkxBR1MgPSAkKHdlYmtpdF90ZXN0c19s ZGZsYWdzKQorCiBQcm9ncmFtc191bml0dGVzdHNfdGVzdHdlYmZyYW1lX1NPVVJDRVMgPSBXZWJL aXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJmcmFtZS5jCiBQcm9ncmFtc191bml0dGVzdHNfdGVzdHdlYmZy YW1lX0NGTEFHUyA9ICQod2Via2l0X3Rlc3RzX2NmbGFncykKIFByb2dyYW1zX3VuaXR0ZXN0c190 ZXN0d2ViZnJhbWVfTERBREQgPSAkKHdlYmtpdF90ZXN0c19sZGFkZCkKZGlmZiAtLWdpdCBhL1dl YkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDAyM2U5My4uNTYyMWMx NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxOCBAQAorMjAwOS0wOS0wNyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3Vz dGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjY4NTQKKyAgICAgICAgW0dUS10gTmVlZHMgQVBJIHRvIGFsbG93IG1vcmUgY29udHJv bCBvdmVyIG91dGdvaW5nIHJlcXVlc3RzCisKKyAgICAgICAgQWRkIGluZnJhc3RydWN0dXJlIHJl cXVpcmVkIHRvIHByb3ZpZGUgdGhlIG5ldworICAgICAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2Ug b2JqZWN0IGluIG91ciBBUEkuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbTogQWRkIG5ldyBm aWxlcyB0byB0aGUgYnVpbGQuCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVzcG9uc2UuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VS ZXNwb25zZVNvdXAuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlUmVzcG9u c2U6OnRvU291cE1lc3NhZ2UpOgorCiAyMDA5LTA5LTA3ICBNYWRzIEFnZXIgIDxhZ2VyQGNocm9t aXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggNmFi ZDgwNy4uYmM4YzU3OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9X ZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xOTYzLDYgKzE5NjMsNyBAQCB3ZWJjb3JlZ3RrX3Nv dXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlRXJyb3Iu aCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNw cCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0U291cC5j cHAgXAorCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2VTb3Vw LmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXF1ZXN0Lmgg XAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaCBcCiAJ V2ViQ29yZS9wbGF0Zm9ybS90ZXh0L2d0ay9UZXh0QnJlYWtJdGVyYXRvckludGVybmFsSUNVR3Rr LmNwcApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VS ZXF1ZXN0U291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl cXVlc3RTb3VwLmNwcAppbmRleCA0YjBmYTEyLi5lYzJhNTMyIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcAorKysgYi9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlcXVlc3RTb3VwLmNwcApAQCAtNjYs NyArNjYsOCBAQCB2b2lkIFJlc291cmNlUmVxdWVzdDo6dXBkYXRlRnJvbVNvdXBNZXNzYWdlKFNv dXBNZXNzYWdlKiBzb3VwTWVzc2FnZSkKICAgICB3aGlsZSAoc291cF9tZXNzYWdlX2hlYWRlcnNf aXRlcl9uZXh0KCZoZWFkZXJzSXRlciwgJmhlYWRlck5hbWUsICZoZWFkZXJWYWx1ZSkpCiAgICAg ICAgIG1faHR0cEhlYWRlckZpZWxkcy5zZXQoU3RyaW5nOjpmcm9tVVRGOChoZWFkZXJOYW1lKSwg U3RyaW5nOjpmcm9tVVRGOChoZWFkZXJWYWx1ZSkpOwogCi0gICAgbV9odHRwQm9keSA9IEZvcm1E YXRhOjpjcmVhdGUoc291cE1lc3NhZ2UtPnJlcXVlc3RfYm9keS0+ZGF0YSwgc291cE1lc3NhZ2Ut PnJlcXVlc3RfYm9keS0+bGVuZ3RoKTsKKyAgICBpZiAoc291cE1lc3NhZ2UtPnJlcXVlc3RfYm9k eS0+ZGF0YSkKKyAgICAgICAgbV9odHRwQm9keSA9IEZvcm1EYXRhOjpjcmVhdGUoc291cE1lc3Nh Z2UtPnJlcXVlc3RfYm9keS0+ZGF0YSwgc291cE1lc3NhZ2UtPnJlcXVlc3RfYm9keS0+bGVuZ3Ro KTsKIAogICAgIC8vIEZJWE1FOiBtX2FsbG93Q29va2llcyBhbmQgbV9maXJzdFBhcnR5Rm9yQ29v a2llcyBzaG91bGQKICAgICAvLyBwcm9iYWJseSBiZSBoYW5kbGVkIGhlcmUgYW5kIG9uIGRvVXBk YXRlUGxhdGZvcm1SZXF1ZXN0CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZVJlc3BvbnNlLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZVJlc3BvbnNlLmgKaW5kZXggYjhjYjU4Ni4uNWZhMzFhMCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VSZXNwb25zZS5oCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVzcG9uc2UuaApAQCAtMjgsNiArMjgs OCBAQAogCiAjaW5jbHVkZSAiUmVzb3VyY2VSZXNwb25zZUJhc2UuaCIKIAorI2luY2x1ZGUgPGxp YnNvdXAvc291cC5oPgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIFJlc291cmNlUmVz cG9uc2UgOiBwdWJsaWMgUmVzb3VyY2VSZXNwb25zZUJhc2UgewpAQCAtNDIsNiArNDQsOCBAQCBw dWJsaWM6CiAgICAgewogICAgIH0KIAorICAgIFNvdXBNZXNzYWdlKiB0b1NvdXBNZXNzYWdlKCkg Y29uc3Q7CisKIHByaXZhdGU6CiAgICAgZnJpZW5kIGNsYXNzIFJlc291cmNlUmVzcG9uc2VCYXNl OwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlU291cC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjkzNTc3 ZgotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVzcG9uc2VTb3VwLmNwcApAQCAtMCwwICsxLDUyIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YQorICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxh Ym9yYSBMdGQuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmts aW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNlLmgi CisKKyNpbmNsdWRlICJDU3RyaW5nLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKwor dXNpbmcgbmFtZXNwYWNlIHN0ZDsKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitTb3VwTWVzc2Fn ZSogUmVzb3VyY2VSZXNwb25zZTo6dG9Tb3VwTWVzc2FnZSgpIGNvbnN0Cit7CisgICAgLy8gVGhp cyBHRVQgaGVyZSBpcyBqdXN0IGJlY2F1c2UgU291cE1lc3NhZ2Ugd2FudHMgaXQsIHdlIGRuJ3Qg cmVhbGx5IGtub3cuCisgICAgU291cE1lc3NhZ2UqIHNvdXBNZXNzYWdlID0gc291cF9tZXNzYWdl X25ldygiR0VUIiwgdXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisgICAgaWYgKCFzb3Vw TWVzc2FnZSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBzb3VwTWVzc2FnZS0+c3RhdHVzX2Nv ZGUgPSBodHRwU3RhdHVzQ29kZSgpOworCisgICAgSFRUUEhlYWRlck1hcCBoZWFkZXJzID0gaHR0 cEhlYWRlckZpZWxkcygpOworICAgIFNvdXBNZXNzYWdlSGVhZGVycyogc291cEhlYWRlcnMgPSBz b3VwTWVzc2FnZS0+cmVzcG9uc2VfaGVhZGVyczsKKyAgICBpZiAoIWhlYWRlcnMuaXNFbXB0eSgp KSB7CisgICAgICAgIEhUVFBIZWFkZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGhlYWRlcnMu ZW5kKCk7CisgICAgICAgIGZvciAoSFRUUEhlYWRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBo ZWFkZXJzLmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkKKyAgICAgICAgICAgIHNvdXBfbWVzc2Fn ZV9oZWFkZXJzX2FwcGVuZChzb3VwSGVhZGVycywgaXQtPmZpcnN0LnN0cmluZygpLnV0ZjgoKS5k YXRhKCksIGl0LT5zZWNvbmQudXRmOCgpLmRhdGEoKSk7CisgICAgfQorCisgICAgLy8gQm9keSBk YXRhIGlzIG5vdCBpbiB0aGUgbWVzc2FnZS4KKyAgICByZXR1cm4gc291cE1lc3NhZ2U7Cit9CisK K30KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKaW5kZXggYTJiZDcyNC4uMzk2MjI4MiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTEsNSArMSw3MCBAQAogMjAwOS0wOS0w NyAgR3VzdGF2byBOb3JvbmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51 az4KIAorICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjY4NTQKKyAgICAgICAgW0dUS10g TmVlZHMgQVBJIHRvIGFsbG93IG1vcmUgY29udHJvbCBvdmVyIG91dGdvaW5nIHJlcXVlc3RzCisK KyAgICAgICAgTWFwIHRoZSB3aWxsU2VuZFJlcXVlc3QgZGVsZWdhdGUgdG8gdGhlICdyZXNvdXJj ZS1yZXF1ZXN0LXN0YXJ0aW5nJworICAgICAgICBzaWduYWwsIGFsbG93aW5nIG1vcmUgY29udHJv bCBvZiB0aGUgcmVzb3VyY2VzIHRoYXQgYXJlIGZldGNoZWQuCisKKyAgICAgICAgV2Ugbm93IG1h cCB0aGUgaWRlbnRpZmllcnMgYXNzaWduZWQgYnkgV2ViQ29yZSB0byB0aGUgcmVzb3VyY2VzIGl0 IGxvYWRzCisgICAgICAgIHRvIFdlYktpdFdlYlJlc291cmNlIG9iamVjdHMsIHN0b3JlZCBpbiBh IEdIYXNoVGFibGUgaW5zaWRlIHRoZQorICAgICAgICBXZWJLaXRXZWJWaWV3IG9iamVjdC4KKwor ICAgICAgICBNYXBwaW5nIHdpbGxTZW5kUmVxdWVzdCBwcm9wZXJseSByZXF1aXJlcyBhbiBhcHBy b3ByaWF0ZSBSZXNwb25zZQorICAgICAgICBvYmplY3QsIHNvIHdlIGFyZSBpbnRyb2R1Y2luZyBX ZWJLaXROZXR3b3JrUmVzcG9uc2UsIHdoaWNoIHdvcmtzIGluIGEKKyAgICAgICAgd2F5IHNpbWls YXIgdG8gV2ViS2l0TmV0d29ya1JlcXVlc3QuCisKKyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OmlkZW50aWZpZXJUb1N0 cmluZyk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaFdpbGxT ZW5kUmVxdWVzdCk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50Ojphc3NpZ25J ZGVudGlmaWVyVG9Jbml0aWFsUmVxdWVzdCk6CisgICAgICAgIChXZWJLaXQ6OkZyYW1lTG9hZGVy Q2xpZW50OjpkaXNwYXRjaERpZFJlY2VpdmVDb250ZW50TGVuZ3RoKToKKyAgICAgICAgKFdlYktp dDo6RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkRmluaXNoTG9hZGluZyk6CisgICAgICAg IChXZWJLaXQ6OkZyYW1lTG9hZGVyQ2xpZW50OjpkaXNwYXRjaERpZEZhaWxMb2FkaW5nKToKKyAg ICAgICAgKiB0ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmM6IEFkZGVkLgorICAgICAgICAodGVz dF9uZXR3b3JrX3Jlc3BvbnNlX2NyZWF0ZV9kZXN0cm95KToKKyAgICAgICAgKHRlc3RfbmV0d29y a19yZXNwb25zZV9wcm9wZXJ0aWVzKToKKyAgICAgICAgKG1haW4pOgorICAgICAgICAqIHdlYmtp dC93ZWJraXQuaDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0ZGVmaW5lcy5oOgorICAgICAgICAq IHdlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVzdC5jcHA6CisgICAgICAgICogd2Via2l0L3dlYmtp dG5ldHdvcmtyZXNwb25zZS5jcHA6IEFkZGVkLgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVz cG9uc2VfZmluYWxpemUpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3By b3BlcnR5KToKKyAgICAgICAgKHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF9wcm9wZXJ0eSk6 CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9jbGFzc19pbml0KToKKyAgICAgICAg KHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2luaXQpOgorICAgICAgICAod2Via2l0X25ldHdvcmtf cmVzcG9uc2VfbmV3X3dpdGhfY29yZV9yZXNwb25zZSk6CisgICAgICAgICh3ZWJraXRfbmV0d29y a19yZXNwb25zZV9uZXcpOgorICAgICAgICAod2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3Vy aSk6CisgICAgICAgICh3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJpKToKKyAgICAgICAg KHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX2dldF9tZXNzYWdlKToKKyAgICAgICAgKiB3ZWJraXQv d2Via2l0bmV0d29ya3Jlc3BvbnNlLmg6IEFkZGVkLgorICAgICAgICAqIHdlYmtpdC93ZWJraXRw cml2YXRlLmNwcDoKKyAgICAgICAgKFdURjo6U291cE1lc3NhZ2UpOgorICAgICAgICAqIHdlYmtp dC93ZWJraXRwcml2YXRlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNw cDoKKyAgICAgICAgKHdlYmtpdF93ZWJfcmVzb3VyY2VfY2xlYW51cCk6CisgICAgICAgICh3ZWJr aXRfd2ViX3Jlc291cmNlX2ZpbmFsaXplKToKKyAgICAgICAgKHdlYmtpdF93ZWJfcmVzb3VyY2Vf Y2xhc3NfaW5pdCk6CisgICAgICAgICh3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9wcm9wZXJ0eSk6 CisgICAgICAgICh3ZWJraXRfd2ViX3Jlc291cmNlX2luaXRfd2l0aF9jb3JlX3Jlc291cmNlKToK KyAgICAgICAgKHdlYmtpdF93ZWJfcmVzb3VyY2VfZ2V0X3VyaSk6CisgICAgICAgICh3ZWJraXRf d2ViX3Jlc291cmNlX2dldF9sb2FkX3N0YXR1cyk6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdl YnJlc291cmNlLmg6CisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAg ICAod2Via2l0X3dlYl92aWV3X2Rpc3Bvc2UpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X2Ns YXNzX2luaXQpOgorICAgICAgICAod2Via2l0X3dlYl92aWV3X2luaXQpOgorICAgICAgICAod2Vi a2l0X3dlYl92aWV3X2FkZF9yZXNvdXJjZSk6CisgICAgICAgICh3ZWJraXRfd2ViX3ZpZXdfZ2V0 X3Jlc291cmNlKToKKyAgICAgICAgKHdlYmtpdF93ZWJfdmlld19yZW1vdmVfcmVzb3VyY2UpOgor ICAgICAgICAqIHdlYmtpdG1hcnNoYWwubGlzdDoKKworMjAwOS0wOS0wNyAgR3VzdGF2byBOb3Jv bmhhIFNpbHZhICA8Z3VzdGF2by5ub3JvbmhhQGNvbGxhYm9yYS5jby51az4KKwogICAgICAgICBS ZXZpZXdlZCBieSBYYW4gTG9wZXouCiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI4OTc5CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQv RnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IGQ4NTkxYmQuLmQwZjAxMDYgMTAwNjQ0Ci0t LSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCisr KyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCkBA IC0yMyw2ICsyMyw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiRnJhbWVMb2Fk ZXJDbGllbnRHdGsuaCIKIAorI2luY2x1ZGUgIkFyY2hpdmVSZXNvdXJjZS5oIgogI2luY2x1ZGUg IkNvbG9yLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnRMb2FkZXIuaCIKICNpbmNsdWRlICJEb2N1bWVu dExvYWRlckd0ay5oIgpAQCAtNTQsNiArNTUsNyBAQAogI2luY2x1ZGUgIlNjcmlwdENvbnRyb2xs ZXIuaCIKICNpbmNsdWRlICJ3ZWJraXRlcnJvci5oIgogI2luY2x1ZGUgIndlYmtpdG5ldHdvcmty ZXF1ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAi d2Via2l0cHJpdmF0ZS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmZyYW1lLmgiCiAjaW5jbHVkZSAi d2Via2l0d2VibmF2aWdhdGlvbmFjdGlvbi5oIgpAQCAtMTgzLDExICsxODUsMzIgQEAgdm9pZCBG cmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hEaWRDYW5jZWxBdXRoZW50aWNhdGlvbkNoYWxsZW5n ZShXZWJDb3JlOjpEb2N1bWUKIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudDo6ZGlzcGF0Y2hXaWxs U2VuZFJlcXVlc3QoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgdW5zaWduZWQgbG9u ZyBpZGVudGlmaWVyLCBSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IFJlc291cmNlUmVz cG9uc2UmIHJlZGlyZWN0UmVzcG9uc2UpCiB7CisgICAgR093blB0cjxXZWJLaXROZXR3b3JrUmVz cG9uc2U+IG5ldHdvcmtSZXNwb25zZSgwKTsKKworICAgIC8vIFdlIGFyZSBhZGRpbmcgb25lIG1v cmUgcmVzb3VyY2UgdG8gdGhlIGxvYWQsIG9yIG1heWJlIHdlIGFyZQorICAgIC8vIGp1c3QgcmVk aXJlY3RpbmcgYSBsb2FkLgogICAgIGlmIChyZWRpcmVjdFJlc3BvbnNlLmlzTnVsbCgpKQogICAg ICAgICBzdGF0aWNfY2FzdDxXZWJLaXQ6OkRvY3VtZW50TG9hZGVyKj4obG9hZGVyKS0+aW5jcmVh c2VMb2FkQ291bnQoaWRlbnRpZmllcik7CisgICAgZWxzZQorICAgICAgICBuZXR3b3JrUmVzcG9u c2Uuc2V0KHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25ld193aXRoX2NvcmVfcmVzcG9uc2UocmVk aXJlY3RSZXNwb25zZSkpOworCisgICAgV2ViS2l0V2ViVmlldyogd2ViVmlldyA9IGdldFZpZXdG cm9tRnJhbWUobV9mcmFtZSk7CisgICAgR093blB0cjxXZWJLaXRXZWJSZXNvdXJjZT4gd2ViUmVz b3VyY2UoV0VCS0lUX1dFQl9SRVNPVVJDRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfV0VCX1JF U09VUkNFLCAidXJpIiwgcmVxdWVzdC51cmwoKS5zdHJpbmcoKS51dGY4KCkuZGF0YSgpLCAwKSkp OworICAgIEdPd25QdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+IG5ldHdvcmtSZXF1ZXN0KHdlYmtp dF9uZXR3b3JrX3JlcXVlc3RfbmV3X3dpdGhfY29yZV9yZXF1ZXN0KHJlcXVlc3QpKTsKKworICAg IGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3ZWJWaWV3LCAicmVzb3VyY2UtcmVxdWVzdC1zdGFydGlu ZyIsIG1fZnJhbWUsIHdlYlJlc291cmNlLmdldCgpLCBuZXR3b3JrUmVxdWVzdC5nZXQoKSwgbmV0 d29ya1Jlc3BvbnNlLmdldCgpKTsKKworICAgIC8vIEZlZWQgYW55IGNoYW5nZXMgYmFjayBpbnRv IHRoZSBSZXNvdXJjZVJlcXVlc3Qgb2JqZWN0LgorICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdlID0g d2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZShuZXR3b3JrUmVxdWVzdC5nZXQoKSk7 CisgICAgaWYgKCFtZXNzYWdlKSB7CisgICAgICAgIHJlcXVlc3Quc2V0VVJMKEtVUkwoS1VSTCgp LCBTdHJpbmc6OmZyb21VVEY4KHdlYmtpdF9uZXR3b3JrX3JlcXVlc3RfZ2V0X3VyaShuZXR3b3Jr UmVxdWVzdC5nZXQoKSkpKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICByZXF1ZXN0 LnVwZGF0ZUZyb21Tb3VwTWVzc2FnZShtZXNzYWdlKTsKIH0KIAotdm9pZCBGcmFtZUxvYWRlckNs aWVudDo6YXNzaWduSWRlbnRpZmllclRvSW5pdGlhbFJlcXVlc3QodW5zaWduZWQgbG9uZyBpZGVu dGlmaWVyLCBXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNlUmVxdWVzdCYp Cit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojphc3NpZ25JZGVudGlmaWVyVG9Jbml0aWFsUmVxdWVz dCh1bnNpZ25lZCBsb25nLCBXZWJDb3JlOjpEb2N1bWVudExvYWRlciosIGNvbnN0IFJlc291cmNl UmVxdWVzdCYpCiB7CiAgICAgbm90SW1wbGVtZW50ZWQoKTsKIH0KQEAgLTgwMCwxMyArODIzLDIx IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkUmVjZWl2ZUNvbnRlbnRMZW5n dGgoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpkaXNw YXRjaERpZEZpbmlzaExvYWRpbmcoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqIGxvYWRlciwgdW5z aWduZWQgbG9uZyBpZGVudGlmaWVyKQogewogICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9jdW1l bnRMb2FkZXIqPihsb2FkZXIpLT5kZWNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKKworICAg IC8vIEZJWE1FOiBUaGlzIGZ1bmN0aW9uIHNob3VsZCBub3RpZnkgdGhlIGFwcGxpY2F0aW9uIHRo YXQgdGhlIHJlc291cmNlCisgICAgLy8gZmluaXNoZWQgbG9hZGluZywgbWF5YmUgdXNpbmcgYSBs b2FkLXN0YXR1cyBwcm9wZXJ0eSBpbiB0aGUKKyAgICAvLyBXZWJLaXRXZWJSZXNvdXJjZSBvYmpl Y3QsIHNpbWlsYXIgdG8gd2hhdCB3ZSBkbyBmb3IgV2ViS2l0V2ViRnJhbWUnCisgICAgLy8gc2ln bmFsLgorICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6 OmRpc3BhdGNoRGlkRmFpbExvYWRpbmcoV2ViQ29yZTo6RG9jdW1lbnRMb2FkZXIqIGxvYWRlciwg dW5zaWduZWQgbG9uZyBpZGVudGlmaWVyLCBjb25zdCBSZXNvdXJjZUVycm9yJiBlcnJvcikKIHsK LSAgICAvLyBGSVhNRTogd2hlbiBkb2VzIHRoaXMgb2NjdXIgYW5kIHdoYXQgc2hvdWxkIGhhcHBl bj8KLQogICAgIHN0YXRpY19jYXN0PFdlYktpdDo6RG9jdW1lbnRMb2FkZXIqPihsb2FkZXIpLT5k ZWNyZWFzZUxvYWRDb3VudChpZGVudGlmaWVyKTsKKworICAgIC8vIEZJWE1FOiBUaGlzIGZ1bmN0 aW9uIHNob3VsZCBub3RpZnkgdGhlIGFwcGxpY2F0aW9uIHRoYXQgdGhlIHJlc291cmNlIGZhaWxl ZAorICAgIC8vIGxvYWRpbmcsIG1heWJlIGEgJ2xvYWQtZXJyb3InIHNpZ25hbCBpbiB0aGUgV2Vi S2l0V2ViUmVzb3VyY2Ugb2JqZWN0LgorICAgIG5vdEltcGxlbWVudGVkKCk7CiB9CiAKIHZvaWQg RnJhbWVMb2FkZXJDbGllbnQ6OmRpc3BhdGNoRGlkTG9hZFJlc291cmNlQnlYTUxIdHRwUmVxdWVz dCh1bnNpZ25lZCBsb25nLCBjb25zdCBTY3JpcHRTdHJpbmcmKQpkaWZmIC0tZ2l0IGEvV2ViS2l0 L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3BvbnNlLmMgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3Ru ZXR3b3JrcmVzcG9uc2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45MDUw YzA0Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0L2d0ay90ZXN0cy90ZXN0bmV0d29ya3Jlc3Bv bnNlLmMKQEAgLTAsMCArMSwxMDggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2 byBOb3JvbmhhIFNpbHZhCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgQ29sbGFib3JhIEx0ZC4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUg aXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhp cyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisg KiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQs IEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKworI2lu Y2x1ZGUgPGVycm5vLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8Z2xpYi5oPgor I2luY2x1ZGUgPGdsaWIvZ3N0ZGlvLmg+CisjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUg PHN0ZGxpYi5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXQuaD4KKworI2lmIEdMSUJfQ0hFQ0tf VkVSU0lPTigyLCAxNiwgMCkgJiYgR1RLX0NIRUNLX1ZFUlNJT04oMiwgMTQsIDApCisKK3N0YXRp YyB2b2lkIHRlc3RfbmV0d29ya19yZXNwb25zZV9jcmVhdGVfZGVzdHJveSgpCit7CisgICAgV2Vi S2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZTsKKyAgICBTb3VwTWVzc2FnZSogbWVzc2FnZTsK KworICAgIC8qIFRlc3QgY3JlYXRpb24gd2l0aCBVUkkgKi8KKyAgICByZXNwb25zZSA9IFdFQktJ VF9ORVRXT1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BP TlNFLCAidXJpIiwgImh0dHA6Ly9kZWJpYW4ub3JnLyIsIE5VTEwpKTsKKyAgICBnX2Fzc2VydChX RUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSkpOworICAgIG1lc3NhZ2UgPSB3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfbWVzc2FnZShyZXNwb25zZSk7CisgICAgZ19hc3NlcnQo IW1lc3NhZ2UpOworICAgIGdfb2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKKworICAgIC8qIFRlc3Qg Y3JlYXRpb24gd2l0aCBTb3VwTWVzc2FnZSAqLworICAgIG1lc3NhZ2UgPSBzb3VwX21lc3NhZ2Vf bmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgcmVzcG9uc2UgPSBXRUJLSVRf TkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05T RSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCBOVUxMKSk7CisgICAgZ19hc3NlcnQoV0VCS0lUX0lTX05F VFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1Qo bWVzc2FnZSktPnJlZl9jb3VudCwgPT0sIDIpOworICAgIGdfb2JqZWN0X3VucmVmKHJlc3BvbnNl KTsKKyAgICBnX2Fzc2VydF9jbXBpbnQoR19PQkpFQ1QobWVzc2FnZSktPnJlZl9jb3VudCwgPT0s IDEpOworICAgIGdfb2JqZWN0X3VucmVmKG1lc3NhZ2UpOworCisgICAgLyogVGVzdCBjcmVhdGlv biB3aXRoIGJvdGggU291cE1lc3NhZ2UgYW5kIFVSSSAqLworICAgIG1lc3NhZ2UgPSBzb3VwX21l c3NhZ2VfbmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgcmVzcG9uc2UgPSBX RUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19S RVNQT05TRSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCAidXJpIiwgImh0dHA6Ly9nbm9tZS5vcmcvIiwg TlVMTCkpOworICAgIGdfYXNzZXJ0KFdFQktJVF9JU19ORVRXT1JLX1JFU1BPTlNFKHJlc3BvbnNl KSk7CisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNUKG1lc3NhZ2UpLT5yZWZfY291bnQsID09 LCAyKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3Vy aShyZXNwb25zZSksID09LCAiaHR0cDovL2dub21lLm9yZy8iKTsKKyAgICBnX29iamVjdF91bnJl ZihyZXNwb25zZSk7CisgICAgZ19hc3NlcnRfY21waW50KEdfT0JKRUNUKG1lc3NhZ2UpLT5yZWZf Y291bnQsID09LCAxKTsKKyAgICBnX29iamVjdF91bnJlZihtZXNzYWdlKTsKK30KKworc3RhdGlj IHZvaWQgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX3Byb3BlcnRpZXMoKQoreworICAgIFdlYktpdE5l dHdvcmtSZXNwb25zZSogcmVzcG9uc2U7CisgICAgU291cE1lc3NhZ2UqIG1lc3NhZ2U7CisgICAg Z2NoYXIqIHNvdXBVUkk7CisKKyAgICAvKiBUZXN0IFVSSSBpcyBzZXQgY29ycmVjdGx5IHdoZW4g Y3JlYXRpbmcgd2l0aCBVUkkgKi8KKyAgICByZXNwb25zZSA9IHdlYmtpdF9uZXR3b3JrX3Jlc3Bv bnNlX25ldygiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgZ19hc3NlcnQoV0VCS0lUX0lTX05F VFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX2Fzc2VydF9jbXBzdHIod2Via2l0X25l dHdvcmtfcmVzcG9uc2VfZ2V0X3VyaShyZXNwb25zZSksID09LCAiaHR0cDovL2RlYmlhbi5vcmcv Iik7CisgICAgZ19vYmplY3RfdW5yZWYocmVzcG9uc2UpOworCisgICAgLyogVGVzdCBVUkkgaXMg c2V0IGNvcnJlY3RseSB3aGVuIGNyZWF0aW5nIHdpdGggTWVzc2FnZSAqLworICAgIG1lc3NhZ2Ug PSBzb3VwX21lc3NhZ2VfbmV3KCJHRVQiLCAiaHR0cDovL2RlYmlhbi5vcmcvIik7CisgICAgcmVz cG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShnX29iamVjdF9uZXcoV0VCS0lUX1RZUEVf TkVUV09SS19SRVNQT05TRSwgIm1lc3NhZ2UiLCBtZXNzYWdlLCBOVUxMKSk7CisgICAgZ19hc3Nl cnQoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX29iamVjdF91 bnJlZihtZXNzYWdlKTsKKworICAgIG1lc3NhZ2UgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9n ZXRfbWVzc2FnZShyZXNwb25zZSk7CisgICAgc291cFVSSSA9IHNvdXBfdXJpX3RvX3N0cmluZyhz b3VwX21lc3NhZ2VfZ2V0X3VyaShtZXNzYWdlKSwgRkFMU0UpOworICAgIGdfYXNzZXJ0X2NtcHN0 cihzb3VwVVJJLCA9PSwgImh0dHA6Ly9kZWJpYW4ub3JnLyIpOworICAgIGdfZnJlZShzb3VwVVJJ KTsKKworICAgIGdfYXNzZXJ0X2NtcHN0cih3ZWJraXRfbmV0d29ya19yZXNwb25zZV9nZXRfdXJp KHJlc3BvbnNlKSwgPT0sICJodHRwOi8vZGViaWFuLm9yZy8iKTsKKyAgICBnX29iamVjdF91bnJl ZihyZXNwb25zZSk7Cit9CisKK2ludCBtYWluKGludCBhcmdjLCBjaGFyKiogYXJndikKK3sKKyAg ICBnX3RocmVhZF9pbml0KE5VTEwpOworICAgIGd0a190ZXN0X2luaXQoJmFyZ2MsICZhcmd2LCBO VUxMKTsKKworICAgIGdfdGVzdF9idWdfYmFzZSgiaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvIik7 CisgICAgZ190ZXN0X2FkZF9mdW5jKCIvd2Via2l0L25ldHdvcmtyZXNwb25zZS9jcmVhdGVkZXN0 cm95IiwgdGVzdF9uZXR3b3JrX3Jlc3BvbnNlX2NyZWF0ZV9kZXN0cm95KTsKKyAgICBnX3Rlc3Rf YWRkX2Z1bmMoIi93ZWJraXQvbmV0d29ya3Jlc3BvbnNlL3Byb3BlcnRpZXMiLCB0ZXN0X25ldHdv cmtfcmVzcG9uc2VfcHJvcGVydGllcyk7CisgICAgcmV0dXJuIGdfdGVzdF9ydW4gKCk7Cit9CisK KyNlbHNlCitpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCit7CisgICAgZ19jcml0aWNh bCgiWW91IHdpbGwgbmVlZCBhdCBsZWFzdCBnbGliLTIuMTYuMCBhbmQgZ3RrLTIuMTQuMCB0byBy dW4gdGhlIHVuaXQgdGVzdHMuIERvaW5nIG5vdGhpbmcgbm93LiIpOworICAgIHJldHVybiAwOwor fQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYnJlc291cmNl LmMgYi9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3R3ZWJyZXNvdXJjZS5jCmluZGV4IDhmMjhiMWIuLmNi OWEwZDkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdHdlYnJlc291cmNlLmMKKysr IGIvV2ViS2l0L2d0ay90ZXN0cy90ZXN0d2VicmVzb3VyY2UuYwpAQCAtODcsNiArODcsNDkgQEAg c3RhdGljIHZvaWQgdGVzdF93ZWJraXRfd2ViX3Jlc291cmNlX2dldF9mcmFtZV9uYW1lKFdlYlJl c291cmNlRml4dHVyZSogZml4dHVyZSwKICAgICBnX2ZyZWUoZnJhbWVfbmFtZSk7CiB9CiAKK3N0 YXRpYyB2b2lkIHJlc291cmNlX3JlcXVlc3Rfc3RhcnRpbmdfY2IoV2ViS2l0V2ViVmlldyogd2Vi X3ZpZXcsIFdlYktpdFdlYkZyYW1lKiB3ZWJfZnJhbWUsIFdlYktpdFdlYlJlc291cmNlKiB3ZWJf cmVzb3VyY2UsIFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0LCBXZWJLaXROZXR3b3JrUmVz cG9uc2UqIHJlc3BvbnNlLCBncG9pbnRlciBkYXRhKQoreworICAgIGdib29sZWFuKiBiZWVuX3Ro ZXJlID0gZGF0YTsKKyAgICAqYmVlbl90aGVyZSA9IFRSVUU7CisKKyAgICBnX2Fzc2VydF9jbXBz dHIod2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfdXJpKHdlYl9yZXNvdXJjZSksID09LCAiaHR0cDov L2dub21lLm9yZy8iKTsKKworICAgIC8qIENhbmNlbCB0aGUgcmVxdWVzdC4gKi8KKyAgICB3ZWJr aXRfbmV0d29ya19yZXF1ZXN0X3NldF91cmkocmVxdWVzdCwgImFib3V0OmJsYW5rIik7Cit9CisK K3N0YXRpYyB2b2lkIGxvYWRfZmluaXNoZWRfY2IoV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcsIFdl YktpdFdlYkZyYW1lKiB3ZWJfZnJhbWUsIGdwb2ludGVyIGRhdGEpCit7CisgICAgZ2Jvb2xlYW4q IGJlZW5fdGhlcmUgPSBkYXRhOworICAgICpiZWVuX3RoZXJlID0gVFJVRTsKKworICAgIGdfYXNz ZXJ0X2NtcHN0cih3ZWJraXRfd2ViX3ZpZXdfZ2V0X3VyaSh3ZWJfdmlldyksID09LCAiYWJvdXQ6 YmxhbmsiKTsKK30KKworc3RhdGljIHZvaWQgdGVzdF93ZWJfcmVzb3VyY2VfbG9hZGluZygpCit7 CisgICAgV2ViS2l0V2ViVmlldyogd2ViX3ZpZXcgPSBXRUJLSVRfV0VCX1ZJRVcod2Via2l0X3dl Yl92aWV3X25ldygpKTsKKyAgICBnYm9vbGVhbiBiZWVuX3RvX3Jlc291cmNlX3JlcXVlc3Rfc3Rh cnRpbmcgPSBGQUxTRTsKKyAgICBnYm9vbGVhbiBiZWVuX3RvX2xvYWRfZmluaXNoZWQgPSBGQUxT RTsKKworICAgIGdfb2JqZWN0X3JlZl9zaW5rKHdlYl92aWV3KTsKKworICAgIGdfc2lnbmFsX2Nv bm5lY3Qod2ViX3ZpZXcsICJyZXNvdXJjZS1yZXF1ZXN0LXN0YXJ0aW5nIiwKKyAgICAgICAgICAg ICAgICAgICAgIEdfQ0FMTEJBQ0socmVzb3VyY2VfcmVxdWVzdF9zdGFydGluZ19jYiksCisgICAg ICAgICAgICAgICAgICAgICAmYmVlbl90b19yZXNvdXJjZV9yZXF1ZXN0X3N0YXJ0aW5nKTsKKwor ICAgIGdfc2lnbmFsX2Nvbm5lY3Qod2ViX3ZpZXcsICJsb2FkLWZpbmlzaGVkIiwKKyAgICAgICAg ICAgICAgICAgICAgIEdfQ0FMTEJBQ0sobG9hZF9maW5pc2hlZF9jYiksCisgICAgICAgICAgICAg ICAgICAgICAmYmVlbl90b19sb2FkX2ZpbmlzaGVkKTsKKworICAgIHdlYmtpdF93ZWJfdmlld19s b2FkX3VyaSh3ZWJfdmlldywgImh0dHA6Ly9nbm9tZS5vcmcvIik7CisKKyAgICBnX2Fzc2VydF9j bXBpbnQoYmVlbl90b19yZXNvdXJjZV9yZXF1ZXN0X3N0YXJ0aW5nLCA9PSwgVFJVRSk7CisgICAg Z19hc3NlcnRfY21waW50KGJlZW5fdG9fbG9hZF9maW5pc2hlZCwgPT0sIFRSVUUpOworCisgICAg Z19vYmplY3RfdW5yZWYod2ViX3ZpZXcpOworfQorCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioq IGFyZ3YpCiB7CiAgICAgZ190aHJlYWRfaW5pdChOVUxMKTsKQEAgLTEwOCw2ICsxNTEsOSBAQCBp bnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3YpCiAgICAgZ190ZXN0X2FkZCgiL3dlYmtpdC93 ZWJyZXNvdXJjZS9nZXRfZGF0YSIsCiAgICAgICAgICAgICAgICBXZWJSZXNvdXJjZUZpeHR1cmUs IDAsIHdlYl9yZXNvdXJjZV9maXh0dXJlX3NldHVwLAogICAgICAgICAgICAgICAgdGVzdF93ZWJr aXRfd2ViX3Jlc291cmNlX2dldF9kYXRhLCB3ZWJfcmVzb3VyY2VfZml4dHVyZV90ZWFyZG93bik7 CisKKyAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQvd2VicmVzb3VyY2UvbG9hZGluZyIsIHRl c3Rfd2ViX3Jlc291cmNlX2xvYWRpbmcpOworCiAgICAgcmV0dXJuIGdfdGVzdF9ydW4gKCk7CiB9 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdC5oIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0LmgKaW5kZXggZDM5MDRkMi4uMjk0NzYyZCAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0LmgKQEAg LTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVmaW5lcy5oPgogI2luY2x1 ZGUgPHdlYmtpdC93ZWJraXRkb3dubG9hZC5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3 b3JrcmVxdWVzdC5oPgorI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaD4K ICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0c291cGF1dGhkaWFsb2cuaD4KICNpbmNsdWRlIDx3ZWJr aXQvd2Via2l0d2ViZGF0YXNvdXJjZS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJmcmFt ZS5oPgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oIGIvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0ZGVmaW5lcy5oCmluZGV4IDQ0NWQ5ZjcuLmFhZGY4NmUgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdGRlZmluZXMuaAorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXRkZWZpbmVzLmgKQEAgLTQ0LDYgKzQ0LDkgQEAgR19CRUdJTl9ERUNM UwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0IFdlYktpdE5ldHdvcmtSZXF1 ZXN0OwogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXF1ZXN0Q2xhc3MgV2ViS2l0TmV0 d29ya1JlcXVlc3RDbGFzczsKIAordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25z ZSBXZWJLaXROZXR3b3JrUmVzcG9uc2U7Cit0eXBlZGVmIHN0cnVjdCBfV2ViS2l0TmV0d29ya1Jl c3BvbnNlQ2xhc3MgV2ViS2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3M7CisKIHR5cGVkZWYgc3RydWN0 IF9XZWJLaXRXZWJCYWNrRm9yd2FyZExpc3QgV2ViS2l0V2ViQmFja0ZvcndhcmRMaXN0OwogdHlw ZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkJhY2tGb3J3YXJkTGlzdENsYXNzIFdlYktpdFdlYkJhY2tG b3J3YXJkTGlzdENsYXNzOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRu ZXR3b3JrcmVxdWVzdC5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVxdWVz dC5jcHAKaW5kZXggNGY2YWI0MS4uMjkxZjRmYyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0bmV0d29ya3JlcXVlc3QuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dG5ldHdvcmtyZXF1ZXN0LmNwcApAQCAtMjgsMTYgKzI4LDYgQEAKIAogI2luY2x1ZGUgPGdsaWIv Z2kxOG4tbGliLmg+CiAKLW5hbWVzcGFjZSBXVEYgewotCi10ZW1wbGF0ZSA8PiB2b2lkIGZyZWVP d25lZEdQdHI8U291cE1lc3NhZ2U+KFNvdXBNZXNzYWdlKiBzb3VwTWVzc2FnZSkKLXsKLSAgICBp ZiAoc291cE1lc3NhZ2UpCi0gICAgICAgIGdfb2JqZWN0X3VucmVmKHNvdXBNZXNzYWdlKTsKLX0K LQotfQotCiAvKioKICAqIFNFQ1RJT046d2Via2l0bmV0d29ya3JlcXVlc3QKICAqIEBzaG9ydF9k ZXNjcmlwdGlvbjogVGhlIHRhcmdldCBvZiBhIG5hdmlnYXRpb24gcmVxdWVzdApkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0bmV0d29ya3Jlc3BvbnNlLmNwcCBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uNDkzZDNiMQotLS0gL2Rldi9udWxsCisrKyBiL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5jcHAKQEAgLTAsMCArMSwyNjQgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggSG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKKyAqIENv cHlyaWdodCAoQykgMjAwOSBHdXN0YXZvIE5vcm9uaGEgU2lsdmEKKyAqIENvcHlyaWdodCAoQykg MjAwOSBDb2xsYWJvcmEgTHRkLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBp dCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBl dmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJ Qi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsCisgKiBCb3N0b24sIE1BIDAyMTEw LTEzMDEsIFVTQS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAid2Via2l0 bmV0d29ya3Jlc3BvbnNlLmgiCisKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5jbHVkZSAiUmVz b3VyY2VSZXNwb25zZS5oIgorI2luY2x1ZGUgIndlYmtpdHByaXZhdGUuaCIKKworI2luY2x1ZGUg PGdsaWIvZ2kxOG4tbGliLmg+CisKKy8qKgorICogU0VDVElPTjp3ZWJraXRuZXR3b3JrcmVzcG9u c2UKKyAqIEBzaG9ydF9kZXNjcmlwdGlvbjogdGhlIHJlc3BvbnNlIGdpdmVuIHRvIGEgbmV0d29y ayByZXF1ZXN0CisgKiBAc2VlX2Fsc286ICNXZWJLaXROZXR3b3JrUmVxdWVzdAorICoKKyAqIFRo aXMgY2xhc3MgcmVwcmVzZW50cyB0aGUgbmV0d29yayByZWxhdGVkIGFzcGVjdHMgb2YgYSBuYXZp Z2F0aW9uCisgKiByZXNwb25zZS4KKyAqCisgKiBTaW5jZTogMS4xLjE0CisgKi8KKworR19ERUZJ TkVfVFlQRShXZWJLaXROZXR3b3JrUmVzcG9uc2UsIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlLCBH X1RZUEVfT0JKRUNUKTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlIHsK KyAgICBnY2hhciogdXJpOworICAgIFNvdXBNZXNzYWdlKiBtZXNzYWdlOworfTsKKworI2RlZmlu ZSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFURShvYmopIChHX1RZUEVfSU5TVEFO Q0VfR0VUX1BSSVZBVEUoKG9iaiksIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktp dE5ldHdvcmtSZXNwb25zZVByaXZhdGUpKQorCitlbnVtIHsKKyAgICBQUk9QXzAsCisKKyAgICBQ Uk9QX1VSSSwKKyAgICBQUk9QX01FU1NBR0UsCit9OworCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0 d29ya19yZXNwb25zZV9kaXNwb3NlKEdPYmplY3QqIG9iamVjdCkKK3sKKyAgICBXZWJLaXROZXR3 b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2JqZWN0KTsK KyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2ID0gcmVzcG9uc2UtPnByaXY7 CisKKyAgICBpZiAocHJpdi0+bWVzc2FnZSkgeworICAgICAgICBnX29iamVjdF91bnJlZihwcml2 LT5tZXNzYWdlKTsKKyAgICAgICAgcHJpdi0+bWVzc2FnZSA9IE5VTEw7CisgICAgfQorCisgICAg R19PQkpFQ1RfQ0xBU1Mod2Via2l0X25ldHdvcmtfcmVzcG9uc2VfcGFyZW50X2NsYXNzKS0+ZGlz cG9zZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9m aW5hbGl6ZShHT2JqZWN0KiBvYmplY3QpCit7CisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiBy ZXNwb25zZSA9IFdFQktJVF9ORVRXT1JLX1JFU1BPTlNFKG9iamVjdCk7CisgICAgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgZ19mcmVl KHByaXYtPnVyaSk7CisKKyAgICBHX09CSkVDVF9DTEFTUyh3ZWJraXRfbmV0d29ya19yZXNwb25z ZV9wYXJlbnRfY2xhc3MpLT5maW5hbGl6ZShvYmplY3QpOworfQorCitzdGF0aWMgdm9pZCB3ZWJr aXRfbmV0d29ya19yZXNwb25zZV9nZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWludCBw cm9wZXJ0eUlELCBHVmFsdWUqIHZhbHVlLCBHUGFyYW1TcGVjKiBwc3BlYykKK3sKKyAgICBXZWJL aXROZXR3b3JrUmVzcG9uc2UqIHJlc3BvbnNlID0gV0VCS0lUX05FVFdPUktfUkVTUE9OU0Uob2Jq ZWN0KTsKKworICAgIHN3aXRjaChwcm9wZXJ0eUlEKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAg ICAgICAgZ192YWx1ZV9zZXRfc3RyaW5nKHZhbHVlLCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9n ZXRfdXJpKHJlc3BvbnNlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9NRVNTQUdF OgorICAgICAgICBnX3ZhbHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF9uZXR3b3JrX3Jlc3Bv bnNlX2dldF9tZXNzYWdlKHJlc3BvbnNlKSk7CisgICAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6 CisgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3Bl cnR5SUQsIHBzcGVjKTsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIHdlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX3NldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BlcnR5SUQsIGNv bnN0IEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVjKQoreworICAgIFdlYktpdE5ldHdv cmtSZXNwb25zZSogcmVzcG9uc2UgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRShvYmplY3QpOwor ICAgIFdlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUqIHByaXYgPSByZXNwb25zZS0+cHJpdjsK KworICAgIHN3aXRjaChwcm9wZXJ0eUlEKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAgICAgICAg d2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShyZXNwb25zZSwgZ192YWx1ZV9nZXRfc3Ry aW5nKHZhbHVlKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9NRVNTQUdFOgorICAg ICAgICBwcml2LT5tZXNzYWdlID0gU09VUF9NRVNTQUdFKGdfdmFsdWVfZHVwX29iamVjdCh2YWx1 ZSkpOworICAgICAgICBicmVhazsKKyAgICBkZWZhdWx0OgorICAgICAgICBHX09CSkVDVF9XQVJO X0lOVkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wZXJ0eUlELCBwc3BlYyk7CisgICAgfQor fQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9jbGFzc19pbml0KFdlYktp dE5ldHdvcmtSZXNwb25zZUNsYXNzKiByZXNwb25zZUNsYXNzKQoreworICAgIEdPYmplY3RDbGFz cyogb2JqZWN0Q2xhc3MgPSBHX09CSkVDVF9DTEFTUyhyZXNwb25zZUNsYXNzKTsKKworICAgIG9i amVjdENsYXNzLT5kaXNwb3NlID0gd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZGlzcG9zZTsKKyAg ICBvYmplY3RDbGFzcy0+ZmluYWxpemUgPSB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9maW5hbGl6 ZTsKKyAgICBvYmplY3RDbGFzcy0+Z2V0X3Byb3BlcnR5ID0gd2Via2l0X25ldHdvcmtfcmVzcG9u c2VfZ2V0X3Byb3BlcnR5OworICAgIG9iamVjdENsYXNzLT5zZXRfcHJvcGVydHkgPSB3ZWJraXRf bmV0d29ya19yZXNwb25zZV9zZXRfcHJvcGVydHk7CisKKyAgICB3ZWJraXRfaW5pdCgpOworCisg ICAgLyoqCisgICAgICogV2ViS2l0TmV0d29ya1Jlc3BvbnNlOnVyaToKKyAgICAgKgorICAgICAq IFRoZSBVUkkgdG8gd2hpY2ggdGhlIHJlc3BvbnNlIHdpbGwgYmUgbWFkZS4KKyAgICAgKgorICAg ICAqIFNpbmNlOiAxLjEuMTQKKyAgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3By b3BlcnR5KG9iamVjdENsYXNzLCBQUk9QX1VSSSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGdfcGFyYW1fc3BlY19zdHJpbmcoInVyaSIsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIlVSSSIpLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJUaGUgVVJJ IHRvIHdoaWNoIHRoZSByZXNwb25zZSB3aWxsIGJlIG1hZGUuIiksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChHUGFyYW1GbGFn cykoV0VCS0lUX1BBUkFNX1JFQURXUklURSkpKTsKKworICAgIC8qKgorICAgICAqIFdlYktpdE5l dHdvcmtSZXNwb25zZTptZXNzYWdlOgorICAgICAqCisgICAgICogVGhlICNTb3VwTWVzc2FnZSB0 aGF0IGJhY2tzIHRoZSByZXNwb25zZS4KKyAgICAgKgorICAgICAqIFNpbmNlOiAxLjEuMTQKKyAg ICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9iamVjdENsYXNzLCBQ Uk9QX01FU1NBR0UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnX3BhcmFt X3NwZWNfb2JqZWN0KCJtZXNzYWdlIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXygiTWVzc2FnZSIpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJUaGUgU291cE1lc3NhZ2Ug dGhhdCBiYWNrcyB0aGUgcmVzcG9uc2UuIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNPVVBfVFlQRV9NRVNTQUdFLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoR1BhcmFtRmxh Z3MpKFdFQktJVF9QQVJBTV9SRUFEV1JJVEV8R19QQVJBTV9DT05TVFJVQ1RfT05MWSkpKTsKKwor ICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZShyZXNwb25zZUNsYXNzLCBzaXplb2YoV2ViS2l0 TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSkpOworfQorCitzdGF0aWMgdm9pZCB3ZWJraXRfbmV0d29y a19yZXNwb25zZV9pbml0KFdlYktpdE5ldHdvcmtSZXNwb25zZSogcmVzcG9uc2UpCit7CisgICAg cmVzcG9uc2UtPnByaXYgPSBXRUJLSVRfTkVUV09SS19SRVNQT05TRV9HRVRfUFJJVkFURShyZXNw b25zZSk7Cit9CisKKy8vIGZvciBpbnRlcm5hbCB1c2Ugb25seQorV2ViS2l0TmV0d29ya1Jlc3Bv bnNlKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXdfd2l0aF9jb3JlX3Jlc3BvbnNlKGNvbnN0 IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmIHJlc291cmNlUmVzcG9uc2UpCit7CisgICAgR093 blB0cjxTb3VwTWVzc2FnZT4gc291cE1lc3NhZ2UocmVzb3VyY2VSZXNwb25zZS50b1NvdXBNZXNz YWdlKCkpOworICAgIGlmIChzb3VwTWVzc2FnZSkKKyAgICAgICAgcmV0dXJuIFdFQktJVF9ORVRX T1JLX1JFU1BPTlNFKGdfb2JqZWN0X25ldyhXRUJLSVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFLCAi bWVzc2FnZSIsIHNvdXBNZXNzYWdlLmdldCgpLCBOVUxMKSk7CisKKyAgICByZXR1cm4gV0VCS0lU X05FVFdPUktfUkVTUE9OU0UoZ19vYmplY3RfbmV3KFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9O U0UsICJ1cmkiLCByZXNvdXJjZVJlc3BvbnNlLnVybCgpLnN0cmluZygpLnV0ZjgoKS5kYXRhKCks IE5VTEwpKTsKK30KKworLyoqCisgKiB3ZWJraXRfbmV0d29ya19yZXNwb25zZV9uZXc6CisgKiBA dXJpOiBhbiBVUkkKKyAqCisgKiBDcmVhdGVzIGEgbmV3ICNXZWJLaXROZXR3b3JrUmVzcG9uc2Ug aW5pdGlhbGl6ZWQgd2l0aCBhbiBVUkkuCisgKgorICogUmV0dXJuczogYSBuZXcgI1dlYktpdE5l dHdvcmtSZXNwb25zZSwgb3IgJU5VTEwgaWYgdGhlIFVSSSBpcworICogaW52YWxpZC4KKyAqCisg KiBTaW5jZTogMS4xLjE0CisgKi8KK1dlYktpdE5ldHdvcmtSZXNwb25zZSogd2Via2l0X25ldHdv cmtfcmVzcG9uc2VfbmV3KGNvbnN0IGdjaGFyKiB1cmkpCit7CisgICAgZ19yZXR1cm5fdmFsX2lm X2ZhaWwodXJpLCBOVUxMKTsKKworICAgIHJldHVybiBXRUJLSVRfTkVUV09SS19SRVNQT05TRShn X29iamVjdF9uZXcoV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgInVyaSIsIHVyaSwgTlVM TCkpOworfQorCisvKioKKyAqIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX3NldF91cmk6CisgKiBA cmVzcG9uc2U6IGEgI1dlYktpdE5ldHdvcmtSZXNwb25zZQorICogQHVyaTogYW4gVVJJCisgKgor ICogU2V0cyB0aGUgVVJJIGhlbGQgYW5kIHVzZWQgYnkgdGhlIGdpdmVuIHJlc3BvbnNlLiBXaGVu IHRoZSByZXNwb25zZQorICogaGFzIGFuIGFzc29jaWF0ZWQgI1NvdXBNZXNzYWdlLCBpdHMgVVJJ IHdpbGwgYWxzbyBiZSBzZXQgYnkgdGhpcworICogY2FsbC4KKyAqCisgKiBTaW5jZTogMS4xLjE0 CisgKi8KK3ZvaWQgd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vfc2V0X3VyaShXZWJLaXROZXR3b3Jr UmVzcG9uc2UqIHJlc3BvbnNlLCBjb25zdCBnY2hhciogdXJpKQoreworICAgIGdfcmV0dXJuX2lm X2ZhaWwoV0VCS0lUX0lTX05FVFdPUktfUkVTUE9OU0UocmVzcG9uc2UpKTsKKyAgICBnX3JldHVy bl9pZl9mYWlsKHVyaSk7CisKKyAgICBXZWJLaXROZXR3b3JrUmVzcG9uc2VQcml2YXRlKiBwcml2 ID0gcmVzcG9uc2UtPnByaXY7CisKKyAgICBpZiAocHJpdi0+dXJpKQorICAgICAgICBnX2ZyZWUo cHJpdi0+dXJpKTsKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1cCh1cmkpOworCisgICAgaWYgKCFw cml2LT5tZXNzYWdlKQorICAgICAgICByZXR1cm47CisKKyAgICBTb3VwVVJJKiBzb3VwVVJJID0g c291cF91cmlfbmV3KHVyaSk7CisgICAgaWYgKCFzb3VwVVJJKSB7CisgICAgICAgIGdfd2Fybmlu ZygiSW52YWxpZCBVUkk6ICVzIiwgdXJpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAg IHNvdXBfbWVzc2FnZV9zZXRfdXJpKHByaXYtPm1lc3NhZ2UsIHNvdXBVUkkpOworICAgIHNvdXBf dXJpX2ZyZWUoc291cFVSSSk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtfcmVzcG9uc2Vf Z2V0X3VyaToKKyAqIEByZXNwb25zZTogYSAjV2ViS2l0TmV0d29ya1Jlc3BvbnNlCisgKgorICog UmV0dXJuczogdGhlIHVyaSBvZiB0aGUgI1dlYktpdE5ldHdvcmtSZXNwb25zZQorICoKKyAqIFNp bmNlOiAxLjEuMTQKKyAqLworR19DT05TVF9SRVRVUk4gZ2NoYXIqIHdlYmtpdF9uZXR3b3JrX3Jl c3BvbnNlX2dldF91cmkoV2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBn X3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfTkVUV09SS19SRVNQT05TRShyZXNwb25zZSks IE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3Bv bnNlLT5wcml2OworCisgICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVy aTsKKworICAgIFNvdXBVUkkqIHNvdXBVUkkgPSBzb3VwX21lc3NhZ2VfZ2V0X3VyaShwcml2LT5t ZXNzYWdlKTsKKyAgICBwcml2LT51cmkgPSBzb3VwX3VyaV90b19zdHJpbmcoc291cFVSSSwgRkFM U0UpOworICAgIHJldHVybiBwcml2LT51cmk7Cit9CisKKy8qKgorICogd2Via2l0X25ldHdvcmtf cmVzcG9uc2VfZ2V0X3NvdXBfbWVzc2FnZToKKyAqIEByZXNwb25zZTogYSAjV2ViS2l0TmV0d29y a1Jlc3BvbnNlCisgKgorICogT2J0YWlucyB0aGUgI1NvdXBNZXNzYWdlIHRoYXQgcmVwcmVzZW50 cyB0aGUgZ2l2ZW4gcmVzcG9uc2UuIE5vdGljZQorICogdGhhdCBvbmx5IHRoZSByZXNwb25zZSBz aWRlIG9mIHRoZSBIVFRQIGNvbnZlcnNhdGlvbiBpcworICogcmVwcmVzZW50ZWQuCisgKgorICog UmV0dXJuczogdGhlICNTb3VwTWVzc2FnZQorICogU2luY2U6IDEuMS4xNAorICovCitTb3VwTWVz c2FnZSogd2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2UoV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNf TkVUV09SS19SRVNQT05TRShyZXNwb25zZSksIE5VTEwpOworCisgICAgV2ViS2l0TmV0d29ya1Jl c3BvbnNlUHJpdmF0ZSogcHJpdiA9IHJlc3BvbnNlLT5wcml2OworCisgICAgcmV0dXJuIHByaXYt Pm1lc3NhZ2U7Cit9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3Jr cmVzcG9uc2UuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdG5ldHdvcmtyZXNwb25zZS5oCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmViMjMzYjUKLS0tIC9kZXYvbnVsbAor KysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRuZXR3b3JrcmVzcG9uc2UuaApAQCAtMCwwICsx LDc0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IENvbGxhYm9yYSBMdGQuCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFu ZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBk aXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK KyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGli cmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0 aCBGbG9vciwKKyAqIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisKKyNpZm5kZWYg V0VCS0lUX05FVFdPUktfUkVTUE9OU0VfSAorI2RlZmluZSBXRUJLSVRfTkVUV09SS19SRVNQT05T RV9ICisKKyNpbmNsdWRlIDxnbGliLW9iamVjdC5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5o PgorCisjaW5jbHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KKworR19CRUdJTl9ERUNMUwor CisjZGVmaW5lIFdFQktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UgICAgICAgICAgICAod2Via2l0 X25ldHdvcmtfcmVzcG9uc2VfZ2V0X3R5cGUoKSkKKyNkZWZpbmUgV0VCS0lUX05FVFdPUktfUkVT UE9OU0Uob2JqKSAgICAgICAgICAgIChHX1RZUEVfQ0hFQ0tfSU5TVEFOQ0VfQ0FTVCgob2JqKSwg V0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKSkKKyNk ZWZpbmUgV0VCS0lUX05FVFdPUktfUkVTUE9OU0VfQ0xBU1Moa2xhc3MpICAgIChHX1RZUEVfQ0hF Q0tfQ0xBU1NfQ0FTVCgoa2xhc3MpLCAgV0VCS0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSwgV2Vi S2l0TmV0d29ya1Jlc3BvbnNlQ2xhc3MpKQorI2RlZmluZSBXRUJLSVRfSVNfTkVUV09SS19SRVNQ T05TRShvYmopICAgICAgICAgKEdfVFlQRV9DSEVDS19JTlNUQU5DRV9UWVBFKChvYmopLCBXRUJL SVRfVFlQRV9ORVRXT1JLX1JFU1BPTlNFKSkKKyNkZWZpbmUgV0VCS0lUX0lTX05FVFdPUktfUkVT UE9OU0VfQ0xBU1Moa2xhc3MpIChHX1RZUEVfQ0hFQ0tfQ0xBU1NfVFlQRSgoa2xhc3MpLCAgV0VC S0lUX1RZUEVfTkVUV09SS19SRVNQT05TRSkpCisjZGVmaW5lIFdFQktJVF9ORVRXT1JLX1JFU1BP TlNFX0dFVF9DTEFTUyhvYmopICAoR19UWVBFX0lOU1RBTkNFX0dFVF9DTEFTUygob2JqKSwgIFdF QktJVF9UWVBFX05FVFdPUktfUkVTUE9OU0UsIFdlYktpdE5ldHdvcmtSZXNwb25zZUNsYXNzKSkK KwordHlwZWRlZiBzdHJ1Y3QgX1dlYktpdE5ldHdvcmtSZXNwb25zZVByaXZhdGUgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlUHJpdmF0ZTsKKworc3RydWN0IF9XZWJLaXROZXR3b3JrUmVzcG9uc2Ugewor ICAgIEdPYmplY3QgcGFyZW50X2luc3RhbmNlOworCisgICAgLyo8IHByaXZhdGUgPiovCisgICAg V2ViS2l0TmV0d29ya1Jlc3BvbnNlUHJpdmF0ZSAqcHJpdjsKK307CisKK3N0cnVjdCBfV2ViS2l0 TmV0d29ya1Jlc3BvbnNlQ2xhc3MgeworICAgIEdPYmplY3RDbGFzcyBwYXJlbnRfY2xhc3M7CisK KyAgICAvKiBQYWRkaW5nIGZvciBmdXR1cmUgZXhwYW5zaW9uICovCisgICAgdm9pZCAoKl93ZWJr aXRfcmVzZXJ2ZWQwKSAodm9pZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQxKSAodm9p ZCk7CisgICAgdm9pZCAoKl93ZWJraXRfcmVzZXJ2ZWQyKSAodm9pZCk7CisgICAgdm9pZCAoKl93 ZWJraXRfcmVzZXJ2ZWQzKSAodm9pZCk7Cit9OworCitXRUJLSVRfQVBJIEdUeXBlCit3ZWJraXRf bmV0d29ya19yZXNwb25zZV9nZXRfdHlwZSAodm9pZCk7CisKK1dFQktJVF9BUEkgV2ViS2l0TmV0 d29ya1Jlc3BvbnNlICoKK3dlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25ldyAgICAgIChjb25zdCBn Y2hhciAgICAgICAgICAqdXJpKTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfbmV0d29ya19y ZXNwb25zZV9zZXRfdXJpICAoV2ViS2l0TmV0d29ya1Jlc3BvbnNlICpyZXNwb25zZSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnY2hhciogICAgICAgICAgdXJpKTsK KworV0VCS0lUX0FQSSBHX0NPTlNUX1JFVFVSTiBnY2hhciAqCit3ZWJraXRfbmV0d29ya19yZXNw b25zZV9nZXRfdXJpICAoV2ViS2l0TmV0d29ya1Jlc3BvbnNlICpyZXNwb25zZSk7CisKK1dFQktJ VF9BUEkgU291cE1lc3NhZ2UgKgord2Via2l0X25ldHdvcmtfcmVzcG9uc2VfZ2V0X21lc3NhZ2Uo V2ViS2l0TmV0d29ya1Jlc3BvbnNlKiByZXNwb25zZSk7CisKK0dfRU5EX0RFQ0xTCisKKyNlbmRp ZgpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5jcHAgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAppbmRleCBkY2E1NTVjLi42MDk1ZDUwIDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcAorKysgYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXRwcml2YXRlLmNwcApAQCAtMTE4LDYgKzExOCwzNCBAQCBXZWJD b3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShXZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSkKIAog fSAvKiogZW5kIG5hbWVzcGFjZSBXZWJLaXQgKi8KIAorbmFtZXNwYWNlIFdURiB7CisKK3RlbXBs YXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0cjxTb3VwTWVzc2FnZT4oU291cE1lc3NhZ2UqIHNvdXBN ZXNzYWdlKQoreworICAgIGlmIChzb3VwTWVzc2FnZSkKKyAgICAgICAgZ19vYmplY3RfdW5yZWYo c291cE1lc3NhZ2UpOworfQorCit0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVPd25lZEdQdHI8V2ViS2l0 TmV0d29ya1JlcXVlc3Q+KFdlYktpdE5ldHdvcmtSZXF1ZXN0KiByZXF1ZXN0KQoreworICAgIGlm IChyZXF1ZXN0KQorICAgICAgICBnX29iamVjdF91bnJlZihyZXF1ZXN0KTsKK30KKwordGVtcGxh dGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdE5ldHdvcmtSZXNwb25zZT4oV2ViS2l0TmV0 d29ya1Jlc3BvbnNlKiByZXNwb25zZSkKK3sKKyAgICBpZiAocmVzcG9uc2UpCisgICAgICAgIGdf b2JqZWN0X3VucmVmKHJlc3BvbnNlKTsKK30KKwordGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRH UHRyPFdlYktpdFdlYlJlc291cmNlPihXZWJLaXRXZWJSZXNvdXJjZSogcmVzb3VyY2UpCit7Cisg ICAgaWYgKHJlc291cmNlKQorICAgICAgICBnX29iamVjdF91bnJlZihyZXNvdXJjZSk7Cit9CisK K30KKwogc3RhdGljIEd0a1dpZGdldCogY3VycmVudFRvcGxldmVsQ2FsbGJhY2soV2ViS2l0U291 cEF1dGhEaWFsb2cqIGZlYXR1cmUsIFNvdXBNZXNzYWdlKiBtZXNzYWdlLCBncG9pbnRlciB1c2Vy RGF0YSkKIHsKICAgICBncG9pbnRlciBtZXNzYWdlRGF0YSA9IGdfb2JqZWN0X2dldF9kYXRhKEdf T0JKRUNUKG1lc3NhZ2UpLCAicmVzb3VyY2VIYW5kbGUiKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHByaXZhdGUuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHByaXZh dGUuaAppbmRleCAxYWQ4MDJmLi4wYTQ4ODJmIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXRwcml2YXRlLmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0cHJpdmF0ZS5o CkBAIC00Nyw2ICs0Nyw3IEBACiAjaW5jbHVkZSAiQmFja0ZvcndhcmRMaXN0LmgiCiAjaW5jbHVk ZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgPGVuY2hhbnQuaD4KKyNpbmNsdWRlICJHT3duUHRyLmgi CiAjaW5jbHVkZSAiSGlzdG9yeUl0ZW0uaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1 ZGUgIlBhZ2UuaCIKQEAgLTg3LDYgKzg4LDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICAgICBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgY29yZShXZWJLaXROZXR3b3JrUmVxdWVzdCogcmVxdWVz dCk7CiAKKyAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIGNvcmUoV2ViS2l0TmV0d29ya1Jl c3BvbnNlKiByZXNwb25zZSk7CisKICAgICBXZWJDb3JlOjpFZGl0aW5nQmVoYXZpb3IgY29yZShX ZWJLaXRFZGl0aW5nQmVoYXZpb3IgdHlwZSk7CiAKICAgICBXZWJLaXRTZWN1cml0eU9yaWdpbiog a2l0KFdlYkNvcmU6OlNlY3VyaXR5T3JpZ2luKik7CkBAIC0xOTYsNiArMTk5LDcgQEAgZXh0ZXJu ICJDIiB7CiAgICAgfTsKICAgICBXZWJLaXRXZWJSZXNvdXJjZSoKICAgICB3ZWJraXRfd2ViX3Jl c291cmNlX25ld193aXRoX2NvcmVfcmVzb3VyY2UoUGFzc1JlZlB0cjxXZWJDb3JlOjpBcmNoaXZl UmVzb3VyY2U+KTsKKwogICAgIC8vIGVuZCBXZWJLaXRXZWJSZXNvdXJjZSBwcml2YXRlCiAKICAg ICB2b2lkCkBAIC0yMzEsNiArMjM1LDkgQEAgZXh0ZXJuICJDIiB7CiAgICAgV2ViS2l0TmV0d29y a1JlcXVlc3QqCiAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9uZXdfd2l0aF9jb3JlX3JlcXVl c3QoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXNvdXJjZVJlcXVlc3QpOwogCisg ICAgV2ViS2l0TmV0d29ya1Jlc3BvbnNlKgorICAgIHdlYmtpdF9uZXR3b3JrX3Jlc3BvbnNlX25l d193aXRoX2NvcmVfcmVzcG9uc2UoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSYgcmVz b3VyY2VSZXNwb25zZSk7CisKICAgICAvLyBGSVhNRTogbW92ZSB0aGlzIHRvIHdlYmtpdG5ldHdv cmtyZXF1ZXN0Lmggb25jZSB0aGUgQVBJIGlzIGFncmVlZCB1cG9uLgogICAgIFdFQktJVF9BUEkg U291cE1lc3NhZ2UqCiAgICAgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVzc2FnZShXZWJL aXROZXR3b3JrUmVxdWVzdCogcmVxdWVzdCk7CkBAIC0zMTIsNCArMzE5LDExIEBAIGV4dGVybiAi QyIgewogICAgIHdlYmtpdF9zZWN1cml0eV9vcmlnaW5fZ2V0X3dlYl9kYXRhYmFzZShXZWJLaXRT ZWN1cml0eU9yaWdpbiogc2VjdXJpdHlPcmlnaW4sIGNvbnN0IGNoYXIqIGRhdGFiYXNlTmFtZSk7 CiB9CiAKK25hbWVzcGFjZSBXVEYgeworICAgIHRlbXBsYXRlIDw+IHZvaWQgZnJlZU93bmVkR1B0 cjxTb3VwTWVzc2FnZT4oU291cE1lc3NhZ2UqKTsKKyAgICB0ZW1wbGF0ZSA8PiB2b2lkIGZyZWVP d25lZEdQdHI8V2ViS2l0TmV0d29ya1JlcXVlc3Q+KFdlYktpdE5ldHdvcmtSZXF1ZXN0Kik7Cisg ICAgdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRHUHRyPFdlYktpdE5ldHdvcmtSZXNwb25zZT4o V2ViS2l0TmV0d29ya1Jlc3BvbnNlKik7CisgICAgdGVtcGxhdGUgPD4gdm9pZCBmcmVlT3duZWRH UHRyPFdlYktpdFdlYlJlc291cmNlPihXZWJLaXRXZWJSZXNvdXJjZSopOworfQorCiAjZW5kaWYK ZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnJlc291cmNlLmNwcAppbmRleCBjMTYyNTc4Li44NTJh NTA5IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJyZXNvdXJjZS5jcHAK KysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2VicmVzb3VyY2UuY3BwCkBAIC0yNyw2ICsy Nyw4IEBACiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAj aW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgiCisj aW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgogI2luY2x1ZGUgInd0Zi9Bc3NlcnRpb25zLmgiCiAK ICNpbmNsdWRlIDxnbGliLmg+CkBAIC01Niw2ICs1OCwyOCBAQCBlbnVtIHsKIEdfREVGSU5FX1RZ UEUoV2ViS2l0V2ViUmVzb3VyY2UsIHdlYmtpdF93ZWJfcmVzb3VyY2UsIEdfVFlQRV9PQkpFQ1Qp OwogCiBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2dldF9wcm9wZXJ0eShHT2JqZWN0 KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSogdmFsdWUsIEdQYXJhbVNwZWMqIHBzcGVj KTsKK3N0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3VyY2Vfc2V0X3Byb3BlcnR5KEdPYmplY3Qq IG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgY29uc3QgR1ZhbHVlKiB2YWx1ZSwgR1BhcmFtU3BlYyog cHNwZWMpOworCitzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Jlc291cmNlX2NsZWFudXAoV2ViS2l0 V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlKQoreworICAgIFdlYktpdFdlYlJlc291cmNlUHJpdmF0 ZSogcHJpdiA9IHdlYlJlc291cmNlLT5wcml2OworCisgICAgZ19mcmVlKHByaXYtPnVyaSk7Cisg ICAgcHJpdi0+dXJpID0gTlVMTDsKKworICAgIGdfZnJlZShwcml2LT5taW1lVHlwZSk7CisgICAg cHJpdi0+bWltZVR5cGUgPSBOVUxMOworCisgICAgZ19mcmVlKHByaXYtPnRleHRFbmNvZGluZyk7 CisgICAgcHJpdi0+dGV4dEVuY29kaW5nID0gTlVMTDsKKworICAgIGdfZnJlZShwcml2LT5mcmFt ZU5hbWUpOworICAgIHByaXYtPmZyYW1lTmFtZSA9IE5VTEw7CisKKyAgICBpZiAocHJpdi0+ZGF0 YSkKKyAgICAgICAgZ19zdHJpbmdfZnJlZShwcml2LT5kYXRhLCBUUlVFKTsKKyAgICBwcml2LT5k YXRhID0gTlVMTDsKK30KIAogc3RhdGljIHZvaWQgd2Via2l0X3dlYl9yZXNvdXJjZV9kaXNwb3Nl KEdPYmplY3QqIG9iamVjdCkKIHsKQEAgLTczLDE1ICs5Nyw4IEBAIHN0YXRpYyB2b2lkIHdlYmtp dF93ZWJfcmVzb3VyY2VfZGlzcG9zZShHT2JqZWN0KiBvYmplY3QpCiBzdGF0aWMgdm9pZCB3ZWJr aXRfd2ViX3Jlc291cmNlX2ZpbmFsaXplKEdPYmplY3QqIG9iamVjdCkKIHsKICAgICBXZWJLaXRX ZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UgPSBXRUJLSVRfV0VCX1JFU09VUkNFKG9iamVjdCk7Ci0g ICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3VyY2UtPnByaXY7Ci0K LSAgICBnX2ZyZWUocHJpdi0+dXJpKTsKLSAgICBnX2ZyZWUocHJpdi0+bWltZVR5cGUpOwotICAg IGdfZnJlZShwcml2LT50ZXh0RW5jb2RpbmcpOwotICAgIGdfZnJlZShwcml2LT5mcmFtZU5hbWUp OwogCi0gICAgaWYgKHByaXYtPmRhdGEpCi0gICAgICAgIGdfc3RyaW5nX2ZyZWUocHJpdi0+ZGF0 YSwgVFJVRSk7CisgICAgd2Via2l0X3dlYl9yZXNvdXJjZV9jbGVhbnVwKHdlYlJlc291cmNlKTsK IAogICAgIEdfT0JKRUNUX0NMQVNTKHdlYmtpdF93ZWJfcmVzb3VyY2VfcGFyZW50X2NsYXNzKS0+ ZmluYWxpemUob2JqZWN0KTsKIH0KQEAgLTkzLDYgKzExMCw3IEBAIHN0YXRpYyB2b2lkIHdlYmtp dF93ZWJfcmVzb3VyY2VfY2xhc3NfaW5pdChXZWJLaXRXZWJSZXNvdXJjZUNsYXNzKiBrbGFzcykK ICAgICBnb2JqZWN0X2NsYXNzLT5kaXNwb3NlID0gd2Via2l0X3dlYl9yZXNvdXJjZV9kaXNwb3Nl OwogICAgIGdvYmplY3RfY2xhc3MtPmZpbmFsaXplID0gd2Via2l0X3dlYl9yZXNvdXJjZV9maW5h bGl6ZTsKICAgICBnb2JqZWN0X2NsYXNzLT5nZXRfcHJvcGVydHkgPSB3ZWJraXRfd2ViX3Jlc291 cmNlX2dldF9wcm9wZXJ0eTsKKyAgICBnb2JqZWN0X2NsYXNzLT5zZXRfcHJvcGVydHkgPSB3ZWJr aXRfd2ViX3Jlc291cmNlX3NldF9wcm9wZXJ0eTsKIAogICAgIC8qKgogICAgICAqIFdlYktpdFdl YlJlc291cmNlOnVyaToKQEAgLTEwOCw3ICsxMjYsNyBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2Vi X3Jlc291cmNlX2NsYXNzX2luaXQoV2ViS2l0V2ViUmVzb3VyY2VDbGFzcyoga2xhc3MpCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJVUkkiKSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIF8oIlRoZSB1cmkgb2YgdGhlIHJlc291cmNlIiksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMLAotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURBQkxFKSk7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAoR1BhcmFtRmxhZ3MpKFdFQktJVF9QQVJBTV9SRUFEV1JJ VEV8R19QQVJBTV9DT05TVFJVQ1RfT05MWSkpKTsKICAgICAvKioKICAgICAgKiBXZWJLaXRXZWJS ZXNvdXJjZTptaW1lLXR5cGU6CiAgICAgICoKQEAgLTE4Miw2ICsyMDAsMjEgQEAgc3RhdGljIHZv aWQgd2Via2l0X3dlYl9yZXNvdXJjZV9nZXRfcHJvcGVydHkoR09iamVjdCogb2JqZWN0LCBndWlu dCBwcm9wX2lkLCBHVmEKICAgICB9CiB9CiAKK3N0YXRpYyB2b2lkIHdlYmtpdF93ZWJfcmVzb3Vy Y2Vfc2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgY29uc3QgR1Zh bHVlKiB2YWx1ZSwgR1BhcmFtU3BlYyogcHNwZWMpCit7CisgICAgV2ViS2l0V2ViUmVzb3VyY2Uq IHdlYlJlc291cmNlID0gV0VCS0lUX1dFQl9SRVNPVVJDRShvYmplY3QpOworCisgICAgc3dpdGNo IChwcm9wX2lkKSB7CisgICAgY2FzZSBQUk9QX1VSSToKKyAgICAgICAgZ19mcmVlKHdlYlJlc291 cmNlLT5wcml2LT51cmkpOworICAgICAgICB3ZWJSZXNvdXJjZS0+cHJpdi0+dXJpID0gZ192YWx1 ZV9kdXBfc3RyaW5nKHZhbHVlKTsKKyAgICAgICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAg ICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcF9pZCwgcHNw ZWMpOworICAgICAgICBicmVhazsKKyAgICB9Cit9CisKIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJf cmVzb3VyY2VfaW5pdChXZWJLaXRXZWJSZXNvdXJjZSogd2ViUmVzb3VyY2UpCiB7CiAgICAgd2Vi UmVzb3VyY2UtPnByaXYgPSBXRUJLSVRfV0VCX1JFU09VUkNFX0dFVF9QUklWQVRFKHdlYlJlc291 cmNlKTsKQEAgLTI3MCwxMSArMzAzLDE3IEBAIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJraXRf d2ViX3Jlc291cmNlX2dldF91cmkoV2ViS2l0V2ViUmVzb3VyY2UqIHdlYlJlc291cmNlCiAgICAg Z19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9SRVNPVVJDRSh3ZWJSZXNvdXJjZSks IE5VTEwpOwogCiAgICAgV2ViS2l0V2ViUmVzb3VyY2VQcml2YXRlKiBwcml2ID0gd2ViUmVzb3Vy Y2UtPnByaXY7CisKKworICAgIC8vIFdlIG1heSBoYXZlIGFuIFVSSSB3aXRob3V0IGhhdmluZyBh IHJlc291cmNlIGFzc2lnbmVkIHRvIHVzIChlLmcuLCBpZiB0aGUKKyAgICAvLyBGcmFtZUxvYWRl ckNsaWVudCBvbmx5IGhhZCBhIFJlc291cmNlUmVxdWVzdCB3aGVuIHdlIGdvdCBjcmVhdGVkCisg ICAgaWYgKHByaXYtPnVyaSkKKyAgICAgICAgcmV0dXJuIHByaXYtPnVyaTsKKwogICAgIGlmICgh cHJpdi0+cmVzb3VyY2UpCiAgICAgICAgIHJldHVybiBOVUxMOwogCi0gICAgaWYgKCFwcml2LT51 cmkpCi0gICAgICAgIHByaXYtPnVyaSA9IGdfc3RyZHVwKHByaXYtPnJlc291cmNlLT51cmwoKS5z dHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyAgICBwcml2LT51cmkgPSBnX3N0cmR1cChwcml2LT5y ZXNvdXJjZS0+dXJsKCkuc3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CiAKICAgICByZXR1cm4gcHJp di0+dXJpOwogfQpAQCAtMzQ0LDMgKzM4Myw0IEBAIEdfQ09OU1RfUkVUVVJOIGdjaGFyKiB3ZWJr aXRfd2ViX3Jlc291cmNlX2dldF9mcmFtZV9uYW1lKFdlYktpdFdlYlJlc291cmNlKiB3ZWJSCiAK ICAgICByZXR1cm4gcHJpdi0+ZnJhbWVOYW1lOwogfQorCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZp ZXcuY3BwCmluZGV4IGM3OTYzN2MuLmEzNGUwMGYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZp ZXcuY3BwCkBAIC0yNSwxMSArMjUsMTMgQEAKICAqLwogCiAjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAid2Via2l0d2Vidmlldy5oIgogCiAjaW5jbHVkZSAid2Via2l0ZG93bmxvYWQuaCIK LSNpbmNsdWRlICJ3ZWJraXR3ZWJ2aWV3LmgiCiAjaW5jbHVkZSAid2Via2l0ZW51bXR5cGVzLmgi CiAjaW5jbHVkZSAid2Via2l0bWFyc2hhbC5oIgorI2luY2x1ZGUgIndlYmtpdG5ldHdvcmtyZXF1 ZXN0LmgiCisjaW5jbHVkZSAid2Via2l0bmV0d29ya3Jlc3BvbnNlLmgiCiAjaW5jbHVkZSAid2Vi a2l0cHJpdmF0ZS5oIgogI2luY2x1ZGUgIndlYmtpdHdlYmluc3BlY3Rvci5oIgogI2luY2x1ZGUg IndlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oIgpAQCAtMTQ1LDYgKzE0Nyw3IEBAIGVudW0gewog ICAgIFVORE8sCiAgICAgUkVETywKICAgICBEQVRBQkFTRV9RVU9UQV9FWENFRURFRCwKKyAgICBS RVNPVVJDRV9SRVFVRVNUX1NUQVJUSU5HLAogICAgIExBU1RfU0lHTkFMCiB9OwogCkBAIC0xOTc1 LDYgKzE5NzgsNDcgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2luaXQoV2Vi S2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICBHX1RZUEVfTk9ORSwg MiwKICAgICAgICAgICAgIEdfVFlQRV9PQkpFQ1QsIEdfVFlQRV9PQkpFQ1QpOwogCisgICAgLyoq CisgICAgICogV2ViS2l0V2ViVmlldzo6cmVzb3VyY2UtcmVxdWVzdC1zdGFydGluZzoKKyAgICAg KiBAd2ViX3ZpZXc6IHRoZSBvYmplY3Qgd2hpY2ggcmVjZWl2ZWQgdGhlIHNpZ25hbAorICAgICAq IEB3ZWJfZnJhbWU6IHRoZSAjV2ViS2l0V2ViRnJhbWUgd2hvc2UgbG9hZCBkaXNwYXRjaGVkIHRo aXMgcmVxdWVzdAorICAgICAqIEB3ZWJfcmVzb3VyY2U6IGFuIGVtcHR5ICNXZWJLaXRXZWJSZXNv dXJjZSBvYmplY3QKKyAgICAgKiBAcmVxdWVzdDogdGhlICNXZWJLaXROZXR3b3JrUmVxdWVzdCB0 aGF0IHdpbGwgYmUgZGlzcGF0Y2hlZAorICAgICAqIEByZXNwb25zZTogdGhlICNXZWJLaXROZXR3 b3JrUmVzcG9uc2UgcmVwcmVzZW50aW5nIHRoZSByZWRpcmVjdAorICAgICAqIHJlc3BvbnNlLCBp ZiBhbnkKKyAgICAgKgorICAgICAqIEVtaXR0ZWQgd2hlbiBhIHJlcXVlc3QgaXMgYWJvdXQgdG8g YmUgc2VudC4gWW91IGNhbiBtb2RpZnkgdGhlCisgICAgICogcmVxdWVzdCB3aGlsZSBoYW5kbGlu ZyB0aGlzIHNpZ25hbC4gWW91IGNhbiBzZXQgdGhlIFVSSSBpbiB0aGUKKyAgICAgKiAjV2ViS2l0 TmV0d29ya1JlcXVlc3Qgb2JqZWN0IGl0c2VsZiwgYW5kIGFkZC9yZW1vdmUvcmVwbGFjZQorICAg ICAqIGhlYWRlcnMgdXNpbmcgdGhlICNTb3VwTWVzc2FnZSBvYmplY3QgaXQgY2FycmllcywgaWYg aXQgaXMKKyAgICAgKiBwcmVzZW50LiBTZWUgd2Via2l0X25ldHdvcmtfcmVxdWVzdF9nZXRfbWVz c2FnZSgpLiBTZXR0aW5nIHRoZQorICAgICAqIHJlcXVlc3QgVVJJIHRvICJhYm91dDpibGFuayIg d2lsbCBlZmZlY3RpdmVseSBjYXVzZSB0aGUgcmVxdWVzdAorICAgICAqIHRvIGxvYWQgbm90aGlu ZywgYW5kIGNhbiBiZSB1c2VkIHRvIGRpc2FibGUgdGhlIGxvYWRpbmcgb2YKKyAgICAgKiBzcGVj aWZpYyByZXNvdXJjZXMuCisgICAgICoKKyAgICAgKiBOb3RpY2UgdGhhdCBpbmZvcm1hdGlvbiBh Ym91dCBhbiBldmVudHVhbCByZWRpcmVjdCBpcyBhdmFpbGFibGUKKyAgICAgKiBpbiBAcmVzcG9u c2UncyAjU291cE1lc3NhZ2UsIG5vdCBpbiB0aGUgI1NvdXBNZXNzYWdlIGNhcnJpZWQgYnkKKyAg ICAgKiB0aGUgQHJlcXVlc3QuIElmIEByZXNwb25zZSBpcyAlTlVMTCwgdGhlbiB0aGlzIGlzIG5v dCBhCisgICAgICogcmVkaXJlY3RlZCByZXF1ZXN0LgorICAgICAqCisgICAgICogVGhlICNXZWJL aXRXZWJSZXNvdXJjZSBvYmplY3Qgd2lsbCBiZSB0aGUgc2FtZSB0aHJvdWdob3V0IGFsbAorICAg ICAqIHRoZSBsaWZldGltZSBvZiB0aGUgcmVzb3VyY2UsIGJ1dCB0aGUgY29udGVudHMgbWF5IGNo YW5nZSBmcm9tCisgICAgICogaW5iZXR3ZWVuIHNpZ25hbCBlbWlzc2lvbnMuCisgICAgICoKKyAg ICAgKiBTaW5jZTogMS4xLjE0CisgICAgICovCisgICAgd2Via2l0X3dlYl92aWV3X3NpZ25hbHNb UkVTT1VSQ0VfUkVRVUVTVF9TVEFSVElOR10gPSBnX3NpZ25hbF9uZXcoInJlc291cmNlLXJlcXVl c3Qtc3RhcnRpbmciLAorICAgICAgICAgICAgR19UWVBFX0ZST01fQ0xBU1Mod2ViVmlld0NsYXNz KSwKKyAgICAgICAgICAgIChHU2lnbmFsRmxhZ3MpKEdfU0lHTkFMX1JVTl9MQVNUIHwgR19TSUdO QUxfQUNUSU9OKSwKKyAgICAgICAgICAgIDAsCisgICAgICAgICAgICBOVUxMLCBOVUxMLAorICAg ICAgICAgICAgd2Via2l0X21hcnNoYWxfVk9JRF9fT0JKRUNUX09CSkVDVF9PQkpFQ1RfT0JKRUNU LAorICAgICAgICAgICAgR19UWVBFX05PTkUsIDQsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9X RUJfRlJBTUUsCisgICAgICAgICAgICBXRUJLSVRfVFlQRV9XRUJfUkVTT1VSQ0UsCisgICAgICAg ICAgICBXRUJLSVRfVFlQRV9ORVRXT1JLX1JFUVVFU1QsCisgICAgICAgICAgICBXRUJLSVRfVFlQ RV9ORVRXT1JLX1JFU1BPTlNFKTsKKwogICAgIC8qCiAgICAgICogaW1wbGVtZW50YXRpb25zIG9m IHZpcnR1YWwgbWV0aG9kcwogICAgICAqLwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXRt YXJzaGFsLmxpc3QgYi9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdAppbmRleCBhYTBkNDBj Li5mZWZkZmYzIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdAorKysg Yi9XZWJLaXQvZ3RrL3dlYmtpdG1hcnNoYWwubGlzdApAQCAtMTMsNiArMTMsNyBAQCBPQkpFQ1Q6 T0JKRUNUCiBPQkpFQ1Q6U1RSSU5HLFNUUklORyxQT0lOVEVSCiBPQkpFQ1Q6Vk9JRAogVk9JRDpP QkpFQ1QsT0JKRUNUCitWT0lEOk9CSkVDVCxPQkpFQ1QsT0JKRUNULE9CSkVDVAogVk9JRDpPQkpF Q1QsUE9JTlRFUixQT0lOVEVSCiBWT0lEOk9CSkVDVCxTVFJJTkcKIFZPSUQ6U1RSSU5HCi0tIAox LjYuMy4zCgo=