22624 2008-12-03 05:26:07 -0800 [SOUP][GTK] Need API to get SoupSession from WebKit. 2010-08-20 13:13:51 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 1 xan.lopez christian christian cosimoc grant_gayed gsherwood gustavo mrobinson mrowe pochu27 sandshrew tonikitoo xan.lopez oldest_to_newest 101183 0 xan.lopez 2008-12-03 05:26:07 -0800 Soup trunk (2.25.x) has support for persistent cookies now. We need to add some API/code in order to use that functionality in a WebKit browser: - First of all, we need a way to get the SoupSession created internally in WebKit, as that it's the entry point for most actions in libsoup (ie, you need that to see all the cookie data, for example). - We need a way to let the user select which backend will be used to persist the cookies, the existing options at the time of writing being txt and sqlite. - We need a way to let the user select where will the cookies file be stored. For the first problem the most straightforward solution is to define a soup-only getSession() method in ResourceHandle.h, and just use that to return the session in a public webkit function (webkit_get_soup_session()). There's many ways to fix the configurability issues. For the backend selection we could add API to define the SoupSessionFeatures to use, which would also serve for future bugs/functionality (proxy, http cache, ...). To set the directory where we want to store our data I guess a reasonable solution would be to use the XDG Base Directory as default optionally allowing to override it via an environment variable? I have a patch that implements the get_session function hardcoding everything else that I used for testing, I can attach it here if anyone thinks it would be helpful. 101377 1 25749 xan.lopez 2008-12-04 13:10:02 -0800 Created attachment 25749 Trivial example of how to do this. The mentioned hack I used for testing. Everything is hardcoded and there's actually a bug: we need to create the session if it does not exist in the get method. 103125 2 26185 xan.lopez 2008-12-21 10:42:58 -0800 Created attachment 26185 0001-Add-API-to-get-the-internal-SoupSession-used-by-web.patch 103330 3 26230 christian 2008-12-23 15:26:05 -0800 Created attachment 26230 API to retrieve the soup session from the view Based on the previous patch: I made libsoup a requirement by removing the HTTP backend concept. I changed webkit_web_view_get_session so that it requires a valid view, with regard to language bindings we can't work with a NULL view. And I bumped the required libsoup version and used the new soup_session_get_feature found in yesterday's libsoup release. I started a discussion on the WebKit mailing list with regard to always using libsoup in the Gtk port, and so far the response seems to be positive. 103362 4 26230 zecke 2008-12-24 07:38:00 -0800 Comment on attachment 26230 API to retrieve the soup session from the view > +static SoupCookieJar* cookie_jar = NULL; No null, please use 0 which will be turned into a null pointer. > SoupCookieJar* getCookieJar() > { > - static SoupCookieJar* jar = soup_cookie_jar_new(); > - return jar; > + if (cookie_jar == NULL) { > + cookie_jar = soup_cookie_jar_new(); > + } > +void setCookieJar(SoupCookieJar *jar) > +{ > + if (cookie_jar == NULL) { > + cookie_jar = jar; > + } > } According to our coding style we do not use '{' in these two cases. > +static void soupSessionInitalize() > +{ > + SoupSessionFeature *jar = 0; > + const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING"); It would be cool if we could unite this with the LogNetworking WTFLogChannel (WebCore/platform/Logging.h) > + > + jar = soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR); > + if (!jar) { > soup_session_add_feature(session, SOUP_SESSION_FEATURE(getCookieJar())); > + } else { > + setCookieJar(SOUP_COOKIE_JAR(g_object_ref(jar))); > + } Coding Style :) > WebKitWebViewPrivate* priv = webView->priv; > if (priv->zoomFullContent == zoomFullContent) > - return; > + return; right, not for this patch though. > > priv->zoomFullContent = zoomFullContent; > webkit_web_view_apply_zoom_level(webView, webkit_web_view_get_zoom_level(webView)); > @@ -2593,4 +2612,24 @@ void webkit_web_view_set_full_content_zoom(WebKitWebView* webView, gboolean zoom > g_object_notify(G_OBJECT(webView), "full-content-zoom"); > } > > +/** > + * webkit_web_view_get_session I think you need a colon here for gtk-doc General comments: - Coding Style, sepcially brackets on the if/else :) - on QtWebKit we allow to have something like a SoupSession per WebView... would that make sense as well? E.g. sometimes you do not want two different WebView to share the same cookie pool? If we want that the WebView should hold a SoupSession and there should be one default session so by default every WebView is sharing this session? 103372 5 26240 christian 2008-12-24 11:55:55 -0800 Created attachment 26240 API to retrieve the soup session from the view #2 (In reply to comment #4) > (From update of attachment 26230 [review]) > General comments: > - Coding Style, sepcially brackets on the if/else :) Updated to correct the coding style. > - on QtWebKit we allow to have something like a SoupSession per WebView... > would that make sense as well? E.g. sometimes you do not want two different > WebView to share the same cookie pool? If we want that the WebView should hold > a SoupSession and there should be one default session so by default every > WebView is sharing this session? That is actually the plan, and we discussed this a bit already. We figured it would be good to allow for it in the API, by having a view specific function, and in a second step add the logic for individual sessions and another function. > It would be cool if we could unite this with the LogNetworking WTFLogChannel > (WebCore/platform/Logging.h) I changed the logging part to look for WEBKIT_DEBUG with a value of 'network', similar to GTK_DEBUG or G_DEBUG. It seems like a good idea to integrate it with WebCore's logging, however probably not in this same patch. 103383 6 zecke 2008-12-24 14:05:42 -0800 (In reply to comment #5) > Created an attachment (id=26240) [review] > API to retrieve the soup session from the view #2 > > (In reply to comment #4) > > (From update of attachment 26230 [review] [review]) > > General comments: > > - Coding Style, sepcially brackets on the if/else :) > Updated to correct the coding style. > > > - on QtWebKit we allow to have something like a SoupSession per WebView... > > would that make sense as well? E.g. sometimes you do not want two different > > WebView to share the same cookie pool? If we want that the WebView should hold > > a SoupSession and there should be one default session so by default every > > WebView is sharing this session? > That is actually the plan, and we discussed this a bit already. We figured it > would be good to allow for it in the API, by having a view specific function, > and in a second step add the logic for individual sessions and another > function. For the QtWebKit port we have added the necessary Document* pointers to be able to get the QNetworkManager of the the QWebView. What I probably tried to say/encourage is that newly created code should try to get the SoupSession through the (Document->ChromeClient->WebKitWebPage). Whenever we decide to allow to set a per session SoupSession we only have to change WebKitWebPage and the rest will be fine. I think it should be little work to do that right from the start. 103650 7 26286 christian 2008-12-28 16:43:55 -0800 Created attachment 26286 API to retrieve the soup session from the view #3 (In reply to comment #6) > (In reply to comment #5) > > Created an attachment (id=26240) [review] [review] > > API to retrieve the soup session from the view #2 > For the QtWebKit port we have added the necessary Document* pointers to be > able to get the QNetworkManager of the the QWebView. What I probably tried to > say/ encourage is that newly created code should try to get the SoupSession > through the (Document->ChromeClient->WebKitWebPage). Whenever we decide to > allow to set a per session SoupSession we only have to change WebKitWebPage > and the rest will be fine. I think it should be little work to do that right > from the start. I took an inspirative look at what Qt does and ended up adding a FrameLoaderClient::session() function, giving ResourceHandle::Session a Frame* argument and replacing global jar and session variables with Document* or Session* arguments. FrameLoaderClient seemed the right place for a network session. I don't know if this is the best approach, particularly I'm not sure where the initial session should be set from and if it's good that WebKit now always creates a cookie jar if there is none. 105424 8 xan.lopez 2009-01-12 17:51:08 -0800 Some points from a discussion on IRC between Christian, Gustavo and me: It seems to us the following API should be enough to cover all use cases for global an per-view soup sessions. - SoupSession* webkit_get_global_session() Returns the global session used by all views by default. - SoupSession* webkit_web_view_get_session (WebKitWebView *view) Returns a private soup session for the view, created on demand the first time it's requested. The view will use that session from now on. - void webkit_web_view_set_session (WebKitWebView *view, SoupSession *session) Makes view use the given session from now on. Useful for: reset views to use the global session, create groups of "private" views all using the same session different from the global one. The documentation should probably mention that creating sessions from scratch and setting them on views shouldn't be done unless you really know what you are doing. It should also probably say all WebKit-GTK soup sessions have to be async (and _set_session should check the type of the session given to make sure of this). 105816 9 26736 christian 2009-01-14 16:36:52 -0800 Created attachment 26736 API to retrieve and set soup sessions #4 Revised patch, including webkit_get_default_session and webkit_web_view_set_session now. I haven't tested it very much. There seem to be a race condition which leads to warnings with soup_session_get_feature. Wrt webkit_get_global_session Vs. webkit_get_default_session, I think the _default_ naming is pretty common, if you think of GdkScreen, GtkSettings and such. Arguments in favour or against either are welcome. 105832 10 26741 christian 2009-01-14 18:29:14 -0800 Created attachment 26741 API to retrieve and set soup sessions #5 Small correction, "session" is writable and webkit_web_view_set_session is actually defined in the header. 105884 11 xan.lopez 2009-01-15 06:00:16 -0800 (In reply to comment #10) > Created an attachment (id=26741) [review] > API to retrieve and set soup sessions #5 > > Small correction, "session" is writable and webkit_web_view_set_session is > actually defined in the header. > Looks pretty good to me. +#if PLATFORM(GTK) + virtual SoupSession* session() = 0; + virtual void setSession(SoupSession*) = 0; +#endif Indentation. + if (!jar) { + jar = soup_cookie_jar_new(); + soup_session_add_feature(session, SOUP_SESSION_FEATURE(jar)); + g_object_unref(G_OBJECT(jar)); + } g_object_unref takes a gpointer. +SoupSession* ResourceHandle::getSession(const Frame *frame) +{ + static SoupSession* default_session = soup_session_async_new(); + + if (!frame) + return default_session; + FrameLoader *loader = frame->loader(); + if (!loader) + return 0; Why not return the default session here? If this is some kind of catastrophic error situation maybe we should assert or something... + SoupSession* session = static_cast<FrameLoaderClient*>(loader->client())->session(); + return session ? session : default_session; +} Also, just wondering in general, if the sessions are async maybe some checks wold be in order when swapping them (making sure they have no pending work?). Maybe that's related to your error... And as a soptimization, I think a flag saying the session is initialized instead of checking for the features every time we go through startHttp would be good (I think I had this in previous patches). 106218 12 26836 christian 2009-01-18 14:43:23 -0800 Created attachment 26836 API to retrieve and set soup sessions #6 (In reply to comment #11) > (In reply to comment #10) > > Created an attachment (id=26741) [review] [review] > > API to retrieve and set soup sessions #5 > +SoupSession* ResourceHandle::getSession(const Frame *frame) > +{ > + static SoupSession* default_session = soup_session_async_new(); > + > + if (!frame) > + return default_session; > + FrameLoader *loader = frame->loader(); > + if (!loader) > + return 0; > > Why not return the default session here? If this is some kind of catastrophic > error situation maybe we should assert or something... There is no catstrohpe, but I acknowledge you might think so if you don't see it in the full context. In fact I defined getSession(0) to return default session. Your question lead me to separate this into a function getDefaultSession, to avoid confusion. I think we must not assert actually, in case the view is being used while the object is finalized. Nothing harmful should happen in any case. > + SoupSession* session = > static_cast<FrameLoaderClient*>(loader->client())->session(); > + return session ? session : default_session; > +} > > Also, just wondering in general, if the sessions are async maybe some checks > wold be in order when swapping them (making sure they have no pending work?). > Maybe that's related to your error... My error came during browsing while keeping the default session, and while using a non-default session, so it doesn't look like swapping is the problem. I added an if(!session) to ensureSession now, and it looks like it prevents that wanring. I'm still unsure however under what condition startHttp would have an empty session... > And as an optimization, I think a flag saying the session is initialized > instead of checking for the features every time we go through startHttp would > be good (I think I had this in previous patches). I wonder about that, I was thinking you intended to make it dynamic later on. Do you think the feature test is that slow? If we agree on which we prefer and how to document that API wise, I can change it accordingly. 106297 13 xan.lopez 2009-01-19 17:49:11 -0800 (In reply to comment #12) > > + SoupSession* session = > > static_cast<FrameLoaderClient*>(loader->client())->session(); > > + return session ? session : default_session; > > +} > > > > Also, just wondering in general, if the sessions are async maybe some checks > > wold be in order when swapping them (making sure they have no pending work?). > > Maybe that's related to your error... > > My error came during browsing while keeping the default session, and while > using a non-default session, so it doesn't look like swapping is the problem. I > added an if(!session) to ensureSession now, and it looks like it prevents that > wanring. I'm still unsure however under what condition startHttp would have an > empty session... That still does not cover changing the session for a view while the view is using it. It seems to me that the way it's done in the patch can't be too safe. At the very least we should check the queued messages and cancel them...? > > > And as an optimization, I think a flag saying the session is initialized > > instead of checking for the features every time we go through startHttp would > > be good (I think I had this in previous patches). > > I wonder about that, I was thinking you intended to make it dynamic later on. > Do you think the feature test is that slow? If we agree on which we prefer and > how to document that API wise, I can change it accordingly. > It might be a soptimization, but I think it's pretty sane to just set a flag after you are done (and reset it when we swap sessions) so you just don't check the features over and over again... 106394 14 xan.lopez 2009-01-20 14:59:46 -0800 A couple more things before I forget: - I think the FrameLoaderClient should ref its session. - On the topic of "safe swapping", it seems that at least we should cancel all queued messages in the session before replacing it. 106863 15 26996 christian 2009-01-24 08:37:11 -0800 Created attachment 26996 API to retrieve and set soup sessions #7 Changed to address the last comments. The frame loader does keep a reference to the session now, I completely forgot that. The session has a flag indicating whether it was initialized, similar to before, but the flag is on the actual message since sessions can be shuffled around and we only want to fill it once. Setting the session *stops* the loader, I hope it's the right way of cancelling pending loads when exchanging the session. I did not cancel all messages on the session because the session might be used for other frames independently. 106885 16 xan.lopez 2009-01-24 15:58:09 -0800 Looks pretty good to me with these changes. Maybe one nitpick would be to print a human readable message in webkit_web_view_set_session when the session is not async, something along the lines: "You are trying to set a sync session for the view to use, but webkit needs async sessions in order to work properly". 106889 17 27002 christian 2009-01-24 16:29:00 -0800 Created attachment 27002 API to retrieve and set soup sessions #8 Updated patch, including a verbose message when trying to set a non-async session as Xan suggested. I also added a comment to the function documentation that WebKit only supports SoupSessionAsync. 107679 18 27002 mrowe 2009-01-30 05:49:40 -0800 Comment on attachment 27002 API to retrieve and set soup sessions #8 This patch appears to do a bunch of unrelated things: removing the option to build with curl, reworking some plumbing in WebCore, adding API in WebKit, and making an apparently unrelated change in GtkLauncher. Without ChangeLog entries its also rather hard to follow what's going on. Can you please split out the unrelated bits and add ChangeLog entries so it's easier to follow? I have a few minor comments. > diff --git a/WebCore/loader/FrameLoaderClient.h b/WebCore/loader/FrameLoaderClient.h > index b90cecd..2f1c41a 100644 > --- a/WebCore/loader/FrameLoaderClient.h > +++ b/WebCore/loader/FrameLoaderClient.h > @@ -35,6 +35,10 @@ > #include <wtf/Platform.h> > #include <wtf/Vector.h> > > +#if PLATFORM(GTK) > +#include <libsoup/soup.h> > +#endif > + You should forward-declare SoupSession rather than adding an #include to the header. > diff --git a/WebCore/platform/network/ResourceHandle.h b/WebCore/platform/network/ResourceHandle.h > index c93af21..515e0ee 100644 > --- a/WebCore/platform/network/ResourceHandle.h > +++ b/WebCore/platform/network/ResourceHandle.h > @@ -30,6 +30,10 @@ > #include "HTTPHeaderMap.h" > #include <wtf/OwnPtr.h> > > +#if USE(SOUP) > +#include <libsoup/soup.h> > +#endif Same here. > diff --git a/WebCore/platform/network/soup/CookieJarSoup.cpp b/WebCore/platform/network/soup/CookieJarSoup.cpp > index 88109e8..e647e21 100644 > --- a/WebCore/platform/network/soup/CookieJarSoup.cpp > +++ b/WebCore/platform/network/soup/CookieJarSoup.cpp > @@ -22,18 +22,28 @@ > > #include "CString.h" > #include "KURL.h" > +#include "Frame.h" > +#include "FrameLoader.h" > +#include "FrameLoaderClient.h" Alphabetical order. > > namespace WebCore { > > -SoupCookieJar* getCookieJar() > +SoupCookieJar* getCookieJar(const Document* document) > { > - static SoupCookieJar* jar = soup_cookie_jar_new(); > + Frame *frame = document->frame(); > + if (!frame) > + return 0; > + FrameLoader *loader = frame->loader(); > + if (!loader) > + return 0; > + SoupSession* session = static_cast<FrameLoaderClient*>(loader->client())->session(); > + SoupCookieJar* jar = (SoupCookieJar*)soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR); > return jar; > } The local "jar" variable doesn't seem necessary now. The C-style cast should be upgraded to a C++-style cast. Is the cast on the result of loader->client() necessary? It doesn't seem like it should be, and you've added it in a few different places. > @@ -173,6 +173,8 @@ static void finishedCallback(SoupSession *session, SoupMessage* msg, gpointer da > return; > > ResourceHandleInternal* d = handle->getInternal(); > + g_object_unref(d->m_session); > + d->m_session = NULL; 0 rather than NULL. > + SoupCookieJar* jar; > + const char* webkit_debug = g_getenv("WEBKIT_DEBUG"); "jar" should be declared when it is first initialised. webkit_debug doesn't follow our naming conventions. > - const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING"); > - if (soup_debug) { > - int soup_debug_level = atoi(soup_debug); > + jar = (SoupCookieJar*)soup_session_get_feature(session, SOUP_TYPE_COOKIE_JAR); C++-style cast. > +bool ResourceHandle::startHttp(SoupSession* session, String urlString) > +{ > + if(!session) > + return false; Need a space after "if". > diff --git a/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h > index 299d023..ea54bf7 100644 > --- a/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h > +++ b/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h > @@ -22,6 +22,7 @@ > > #include "ChromeClient.h" > #include "KURL.h" > +#include <libsoup/soup.h> Can just forward-declare SoupSession instead. > +SoupSession* webkit_web_view_get_session (WebKitWebView* webView) > +{ > + SoupSession* session; > + > + g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL); > + > + session = ResourceHandle::getSession(core(webView->priv->mainFrame)); > + if (!session) { > + session = soup_session_async_new (); > + ResourceHandle::setSession(core(webView->priv->mainFrame), session); > + } Why does it make sense to create a new session and set it when retrieving a session? Is there a reason that this doesn't reuse the same session as ResourceHandle::getDefaultSession? > diff --git a/WebKit/gtk/webkit/webkitwebview.h b/WebKit/gtk/webkit/webkitwebview.h > index 2bb8c61..1a9bf58 100644 > --- a/WebKit/gtk/webkit/webkitwebview.h > +++ b/WebKit/gtk/webkit/webkitwebview.h > @@ -29,6 +29,7 @@ > #include <webkit/webkitwebbackforwardlist.h> > #include <webkit/webkitwebhistoryitem.h> > #include <webkit/webkitwebsettings.h> > +#include <libsoup/soup.h> Forward-declare rather than include? 107681 19 xan.lopez 2009-01-30 05:56:56 -0800 (In reply to comment #18) > > +SoupSession* webkit_web_view_get_session (WebKitWebView* webView) > > +{ > > + SoupSession* session; > > + > > + g_return_val_if_fail(WEBKIT_IS_WEB_VIEW(webView), NULL); > > + > > + session = ResourceHandle::getSession(core(webView->priv->mainFrame)); > > + if (!session) { > > + session = soup_session_async_new (); > > + ResourceHandle::setSession(core(webView->priv->mainFrame), session); > > + } > > Why does it make sense to create a new session and set it when retrieving a > session? Is there a reason that this doesn't reuse the same session as > ResourceHandle::getDefaultSession? > The idea is to allow individual views to use their own private sessions instead of the default/global one (think of privacy mode or similar). We decided to do this by creating them on demand when the user asks for the session of an individual view. 107682 20 mrowe 2009-01-30 06:07:14 -0800 > > Why does it make sense to create a new session and set it when retrieving a > > session? Is there a reason that this doesn't reuse the same session as > > ResourceHandle::getDefaultSession? > > > > The idea is to allow individual views to use their own private sessions instead > of the default/global one (think of privacy mode or similar). We decided to do > this by creating them on demand when the user asks for the session of an > individual view. That seems like it could be confusing. Calling setSession will stop a load that is in progress, which means that calling this "get" API at the wrong time could result in some rather odd behaviour. 107683 21 mrowe 2009-01-30 06:09:41 -0800 I just noticed that the API is added to the WebView, but the sessions appears to only ever be set on the main frame's loader. Is that really the behaviour that you're after? 107685 22 xan.lopez 2009-01-30 06:13:53 -0800 (In reply to comment #20) > > The idea is to allow individual views to use their own private sessions instead > > of the default/global one (think of privacy mode or similar). We decided to do > > this by creating them on demand when the user asks for the session of an > > individual view. > > That seems like it could be confusing. Calling setSession will stop a load > that is in progress, which means that calling this "get" API at the wrong time > could result in some rather odd behaviour. > Well, I don't see a way around this. If you provide this functionality the programmer will always be able to replace the session while it's being used. But he should know what he's doing. 107687 23 mrowe 2009-01-30 06:16:55 -0800 > > That seems like it could be confusing. Calling setSession will stop a load > > that is in progress, which means that calling this "get" API at the wrong time > > could result in some rather odd behaviour. > > > > Well, I don't see a way around this. If you provide this functionality the > programmer will always be able to replace the session while it's being used. > But he should know what he's doing. It makes sense for webkit_web_view_set_session to potentially have this sort of effect, but it doesn't make sense to me that a getter would be a potentially destructive operation. 107688 24 xan.lopez 2009-01-30 06:21:52 -0800 (In reply to comment #23) > > Well, I don't see a way around this. If you provide this functionality the > > programmer will always be able to replace the session while it's being used. > > But he should know what he's doing. > > It makes sense for webkit_web_view_set_session to potentially have this sort of > effect, but it doesn't make sense to me that a getter would be a potentially > destructive operation. > Right. The idea here is that you shouldn't need to create sessions outside of webkit. An slightly less magical alternative would be... session = webkit_create_soup_session (); webkit_web_view_set_session (view, session); 109489 25 christian 2009-02-12 09:44:27 -0800 (In reply to comment #24) > (In reply to comment #23) > > > Well, I don't see a way around this. If you provide this functionality the > > > programmer will always be able to replace the session while it's being used. > > > But he should know what he's doing. > > > > It makes sense for webkit_web_view_set_session to potentially have this sort of > > effect, but it doesn't make sense to me that a getter would be a potentially > > destructive operation. > > > > Right. The idea here is that you shouldn't need to create sessions outside of > webkit. An slightly less magical alternative would be... > > session = webkit_create_soup_session (); > webkit_web_view_set_session (view, session); I understand the concerns. And I'm fine if we agree to make it explicit, without any 'magic'. At this point I wonder if we should just recommend using any async session and leave out the webkit_create_soup_session function. At least currently it wouldn't do more than a non-persistent cookie jar. That *might* be different if we add more features, not sure. 110191 26 27783 xan.lopez 2009-02-19 02:52:29 -0800 Created attachment 27783 removecurl.patch Trying to do this piece by piece now. This patch removes the CURL backend support from WebKit/GTK+. 110199 27 27787 xan.lopez 2009-02-19 03:38:31 -0800 Created attachment 27787 removecurl.patch Remove unneeded LIBS flag in WebKitTools. 110201 28 27788 xan.lopez 2009-02-19 03:44:54 -0800 Created attachment 27788 getsession.patch Add API to get the default soup session. 110202 29 christian 2009-02-19 03:52:53 -0800 (In reply to comment #28) > Created an attachment (id=27788) [review] > getsession.patch > > Add API to get the default soup session. "so if you insert for your own #SoupCookieJar before any network" should be "so if you insert your own #SoupCookieJar before any network" And you seem to have forgotten the webkit_web_view_get_session() function Otherwise nice, let's get this cool stuff in :) 110206 30 27790 xan.lopez 2009-02-19 06:38:38 -0800 Created attachment 27790 getsession.patch Remove the session property and the view-specific API after some discussion on IRC. They'll come in the next patches, where they'll actually do something relevant. 110538 31 27790 ap 2009-02-23 00:33:22 -0800 Comment on attachment 27790 getsession.patch > WARNING: NO TEST CASES ADDED OR CHANGED This line is just a reminder to the author of the patch, please remove it (perhaps explaining why test cases aren't needed or possible). > +#if USE(SOUP) > +#include <libsoup/soup.h> > +#endif Could you just forward declare SoupSession? > + * Copyright (C) 2009 Igalia S.L., Author: Xan Lopez <xlopez@igalia.com> This isn't a usual form of copyright line. I don't know if it's a real problem, but it certainly makes me nervous. > +static void ensureSession(SoupSession* session) This name doesn't seem descriptive enough to me. What does this function do with the session? > + if (soup_session_get_feature(session, SOUP_TYPE_LOGGER) == NULL Per coding style, this should be "if (!soup_session_get_feature(session, SOUP_TYPE_LOGGER)" > +bool ResourceHandle::startHttp(String urlString) > +{ > + if (!session) > + createSoupSession(); This is what getSession() does - could you just call it? In this case, the static variable could just move to getSession(). > +SoupSession* ResourceHandle::getSession() The names "getSession" and "getCookieJar" are misleading, and don't follow out usual style. First, a getXXX function is one that returns its result in an argument, a getter would be just "cookieJar", for example. More importantly, these functions aren't getters, as they can create objects. I think that the usual naming would be something like "sharedSession", "commonSession", "defaultSession" etc. > - * Copyright (C) 2007, 2008 Christian Dywan <christian@imendio.com> > + * Copyright (C) 2007-2009 Christian Dywan <christian@imendio.com> Again, I don't know why, but we list all years comma-separated in copyright lines. Looks like this needs another round of review. 110554 32 27873 xan.lopez 2009-02-23 01:48:04 -0800 Created attachment 27873 removecurl.patch 110555 33 27874 xan.lopez 2009-02-23 01:48:31 -0800 Created attachment 27874 defaultsession.patch Address ap's review points. 110558 34 27873 ap 2009-02-23 02:07:23 -0800 Comment on attachment 27873 removecurl.patch r=me 110559 35 27875 xan.lopez 2009-02-23 02:08:11 -0800 Created attachment 27875 defaultsession2.patch Do not recreate the cookie jar all the time in defaultCookieJar, as it can be set to NULL by the user. 110560 36 27875 ap 2009-02-23 02:12:12 -0800 Comment on attachment 27875 defaultsession2.patch r=me > + static SoupSession* session = createSoupSession();; That's a bit too many semicolons! 110565 37 27873 christian 2009-02-23 03:28:02 -0800 Comment on attachment 27873 removecurl.patch Remove CURL support in the Gtk port, the HTTP backend is SOUP now. https://bugs.webkit.org/show_bug.cgi?id=22624 [SOUP][GTK] Need API to get SoupSession from WebKit. 110566 38 27875 christian 2009-02-23 03:28:51 -0800 Comment on attachment 27875 defaultsession2.patch Allow retrieving the Soup session and modify the code to take into account users changing features on it. https://bugs.webkit.org/show_bug.cgi?id=22624 [SOUP][GTK] Need API to get SoupSession from WebKit. 267368 39 mrobinson 2010-08-20 13:13:51 -0700 This issue seems resolved. Feel free to re-open if not. 25749 2008-12-04 13:10:02 -0800 2008-12-21 10:42:58 -0800 Trivial example of how to do this. webkitsession.diff text/plain 3524 xan.lopez ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oIGIv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKaW5kZXggNjFiYTUxMi4u MTQxZDE4NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFu ZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKQEAg LTMwLDYgKzMwLDEwIEBACiAjaW5jbHVkZSAiSFRUUEhlYWRlck1hcC5oIgogI2luY2x1ZGUgPHd0 Zi9Pd25QdHIuaD4KIAorI2lmIFVTRShTT1VQKQorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgor I2VuZGlmCisKICNpZiBQTEFURk9STShDRikKIHR5cGVkZWYgY29uc3Qgc3RydWN0IF9fQ0ZEYXRh ICogQ0ZEYXRhUmVmOwogI2VuZGlmCkBAIC04Niw2ICs5MCwxMCBAQCBjbGFzcyBTaGFyZWRCdWZm ZXI7CiBjbGFzcyBTdWJyZXNvdXJjZUxvYWRlcjsKIGNsYXNzIFN1YnJlc291cmNlTG9hZGVyQ2xp ZW50OwogCisjaWYgVVNFKFNPVVApCitTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbigpOworI2VuZGlm CisKIHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBjbGFzcyBUaW1lcjsKIAogY2xhc3MgUmVzb3VyY2VI YW5kbGUgOiBwdWJsaWMgUmVmQ291bnRlZDxSZXNvdXJjZUhhbmRsZT4gewpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRleCA4ODEwOWU4Li41 MWQxYWQzIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVK YXJTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJT b3VwLmNwcApAQCAtMjcsNyArMjcsMTEgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBTb3VwQ29v a2llSmFyKiBnZXRDb29raWVKYXIoKQogewotICAgIHN0YXRpYyBTb3VwQ29va2llSmFyKiBqYXIg PSBzb3VwX2Nvb2tpZV9qYXJfbmV3KCk7CisgICAgc3RhdGljIFNvdXBDb29raWVKYXIqIGphciA9 IE5VTEw7CisKKyAgICBpZiAoIWphcikKKyAgICAgICAgamFyID0gc291cF9jb29raWVfamFyX3Rl eHRfbmV3KCIvdG1wL2dhbGxldGFzLnR4dCIsIEZBTFNFKTsKKwogICAgIHJldHVybiBqYXI7CiB9 CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRs ZVNvdXAuY3BwCmluZGV4IGFmNTc3YmEuLjkyNzJhZjkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNTg3LDUgKzU4 NywxMCBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEdpbyhTdHJpbmcgdXJsU3RyaW5nKQog ICAgIHJldHVybiB0cnVlOwogfQogCitTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbigpCit7CisgIHJl dHVybiBzZXNzaW9uOworfQorCiB9CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5k ZXggYjk0ZWM2Mi4uMjE0ODRiZSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAg LTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQbGF0Zm9ybUtleWJvYXJkRXZlbnQuaCIKICNpbmNs dWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKICNpbmNsdWRlICJTY3JpcHRWYWx1ZS5oIgorI2lu Y2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFyLmgiCiAjaW5jbHVk ZSAiU3Vic3RpdHV0ZURhdGEuaCIKICNpbmNsdWRlIDx3dGYvR093blB0ci5oPgpAQCAtMjUwNCw0 ICsyNTA1LDggQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdl YktpdFdlYlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpvb20KICAgICBnX29iamVjdF9ub3RpZnko R19PQkpFQ1Qod2ViVmlldyksICJmdWxsLWNvbnRlbnQtem9vbSIpOwogfQogCitTb3VwU2Vzc2lv biogd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKCkKK3sKKyAgICByZXR1cm4gZ2V0U2Vzc2lv bigpOworfQogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5o IGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCmluZGV4IDIxOGJmNzguLjNjNjE2 ZTIgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKQEAgLTI5LDYgKzI5LDggQEAKICNpbmNs dWRlIDx3ZWJraXQvd2Via2l0d2ViaGlzdG9yeWl0ZW0uaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Vi a2l0d2Vic2V0dGluZ3MuaD4KIAorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgorCiBHX0JFR0lO X0RFQ0xTCiAKICNkZWZpbmUgV0VCS0lUX1RZUEVfV0VCX1ZJRVcgICAgICAgICAgICAod2Via2l0 X3dlYl92aWV3X2dldF90eXBlKCkpCkBAIC0yODYsNiArMjg4LDkgQEAgV0VCS0lUX0FQSSB2b2lk CiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tICAgICAgICAgICAoV2ViS2l0 V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgICAgICAgICAgICBmdWxsX2NvbnRlbnRfem9v bSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Np b24gICAgICAgICAgICAgICAgICAgICAoKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBiL1dlYktpdFRvb2xzL0dOVW1ha2Vm aWxlLmFtCmluZGV4IDJmMjE2YjIuLmJjMWVlNTcgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0dO VW1ha2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCkBAIC0yMCw2ICsy MCw3IEBAIFByb2dyYW1zX0d0a0xhdW5jaGVyX0NGTEFHUyA9IFwKIAktZm5vLXN0cmljdC1hbGlh c2luZyBcCiAJLU8yIFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBc CiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFtc19HdGtMYXVuY2hlcl9MREFERCA9IFwKQEAgLTY2 LDYgKzY3LDcgQEAgUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfQ0ZMQUdTID0gXAogCS1PMiBcCiAJ JChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTE9CQUxERVBTX0NGTEFHUykgXAorCSQoTElCU09VUF9D RkxBR1MpIFwKIAkkKENBSVJPX0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykKIAo= 26185 2008-12-21 10:42:58 -0800 2008-12-23 15:26:05 -0800 0001-Add-API-to-get-the-internal-SoupSession-used-by-web.patch 0001-Add-API-to-get-the-internal-SoupSession-used-by-web.patch text/plain 8501 xan.lopez RnJvbSA0NzI3NzQxMTdkZTg1YTgzMzhhN2YwYTc4ZDdiYjdiYWY1YTE3YWE1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFN1biwg MjEgRGVjIDIwMDggMjA6Mzk6MDEgKzAyMDAKU3ViamVjdDogW1BBVENIXSBBZGQgQVBJIHRvIGdl dCB0aGUgaW50ZXJuYWwgU291cFNlc3Npb24qIHVzZWQgYnkgd2Via2l0LgoKTm93IHVzZXJzIGNh biBtb2RpZnkgdGhlIHNlc3Npb24gZmVhdHVyZXMgYW5kIHdlYmtpdCB3b24ndCBhZGQgaXRzCmRl ZmF1bHRzIGlmIHRoZXJlJ3MgYW4gZXF1aXZhbGVudCBmZWF0dXJlIGFscmVhZHkgcHJlc2VudCAo aWUsIHdlYmtpdAp3b24ndCBhZGQgYSBjb29raWUgamFyIGlmIHRoZSB1c2VyIGFkZHMgb25lKS4K LS0tCiBHTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgIDEgKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmggICAgICAg ICAgfCAgICA4ICsrKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291 cC5jcHAgICAgfCAgIDE2ICsrKystCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29r aWVKYXJTb3VwLmggICAgICB8ICAgIDEgKwogLi4uL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNv dXJjZUhhbmRsZVNvdXAuY3BwICAgfCAgIDY1ICsrKysrKysrKysrKysrKysrLS0tCiBXZWJLaXQv Z3RrL3dlYmtpdC5wYy5pbiAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAgICAgICAgICAgICAgIHwgICAyMiAr KysrKysrCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggICAgICAgICAgICAgICAg ICB8ICAgIDQgKwogV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0gICAgICAgICAgICAgICAgICAg ICAgICAgfCAgICAyICsKIDkgZmlsZXMgY2hhbmdlZCwgMTA4IGluc2VydGlvbnMoKyksIDEzIGRl bGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0K aW5kZXggN2FlYzA2MS4uNTE0NzNiYSAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIv R05VbWFrZWZpbGUuYW0KQEAgLTQ4MSw2ICs0ODEsNyBAQCBQcm9ncmFtc19Vbml0VGVzdHNfQ0ZM QUdTID0gXAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTElCX0NGTEFHUykgXAor CSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFByb2dyYW1zX1VuaXRUZXN0 c19MREFERCA9IFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZUhhbmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKaW5k ZXggYzkzYWYyMS4uZDE1M2I5MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl SGFuZGxlLmgKQEAgLTMwLDYgKzMwLDEwIEBACiAjaW5jbHVkZSAiSFRUUEhlYWRlck1hcC5oIgog I2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KIAorI2lmIFVTRShTT1VQKQorI2luY2x1ZGUgPGxpYnNv dXAvc291cC5oPgorI2VuZGlmCisKICNpZiBQTEFURk9STShDRikKIHR5cGVkZWYgY29uc3Qgc3Ry dWN0IF9fQ0ZEYXRhICogQ0ZEYXRhUmVmOwogI2VuZGlmCkBAIC0xNTksNiArMTYzLDEwIEBAIHB1 YmxpYzoKICAgICBSZXNvdXJjZUhhbmRsZUludGVybmFsKiBnZXRJbnRlcm5hbCgpIHsgcmV0dXJu IGQuZ2V0KCk7IH0KICNlbmRpZgogCisjaWYgVVNFKFNPVVApCisgICAgc3RhdGljIFNvdXBTZXNz aW9uKiBnZXRTZXNzaW9uKCk7CisjZW5kaWYKKwogICAgIC8vIFVzZWQgdG8gd29yayBhcm91bmQg dGhlIGZhY3QgdGhhdCB5b3UgZG9uJ3QgZ2V0IGFueSBtb3JlIE5TVVJMQ29ubmVjdGlvbiBjYWxs YmFja3MgdW50aWwgeW91IHJldHVybiBmcm9tIHRoZSBvbmUgeW91J3JlIGluLgogICAgIHN0YXRp YyBib29sIGxvYWRzQmxvY2tlZCgpOyAgICAKICAgICAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAKaW5kZXggODgxMDllOC4uNDRkMmE3NiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAK KysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAKQEAg LTI1LDEwICsyNSwyMiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBTb3VwQ29v a2llSmFyKiBjb29raWVfamFyID0gTlVMTDsKKwogU291cENvb2tpZUphciogZ2V0Q29va2llSmFy KCkKIHsKLSAgICBzdGF0aWMgU291cENvb2tpZUphciogamFyID0gc291cF9jb29raWVfamFyX25l dygpOwotICAgIHJldHVybiBqYXI7CisgICAgaWYgKGNvb2tpZV9qYXIgPT0gTlVMTCkgeworICAg ICAgICBjb29raWVfamFyID0gc291cF9jb29raWVfamFyX25ldygpOworICAgIH0KKworICAgIHJl dHVybiBjb29raWVfamFyOworfQorCit2b2lkIHNldENvb2tpZUphcihTb3VwQ29va2llSmFyICpq YXIpCit7CisgICAgaWYgKGNvb2tpZV9qYXIgPT0gTlVMTCkgeworICAgICAgICBjb29raWVfamFy ID0gamFyOworICAgIH0KIH0KIAogdm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50 Ki8sIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwqLywgY29uc3QgU3Ry aW5nJiB2YWx1ZSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nv b2tpZUphclNvdXAuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNv dXAuaAppbmRleCA2MTE3OWFlLi5jMzQzMGY5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvQ29va2llSmFyU291cC5oCkBAIC0zMiw2ICszMiw3IEBACiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKICAgICBTb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIoKTsKKyAgICB2b2lkIHNl dENvb2tpZUphcihTb3VwQ29va2llSmFyICpqYXIpOwogfQogCiAjZW5kaWYKZGlmZiAtLWdpdCBh L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4 IDVmZDNhNGQuLmE5YzkxNmMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtNDksNiArNDksNyBAQAogbmFtZXNwYWNl IFdlYkNvcmUgewogCiBzdGF0aWMgU291cFNlc3Npb24qIHNlc3Npb24gPSAwOworc3RhdGljIGJv b2wgc2Vzc2lvbkluaXRpYWxpemVkID0gZmFsc2U7CiAKIGVudW0KIHsKQEAgLTI3MCwyMSArMjcx LDU2IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0RGF0YShTdHJpbmcgdXJsU3RyaW5nKQog ICAgICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRw KFN0cmluZyB1cmxTdHJpbmcpCitzdGF0aWMgdm9pZCBjcmVhdGVTb3VwU2Vzc2lvbigpCiB7Ci0g ICAgaWYgKCFzZXNzaW9uKSB7Ci0gICAgICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNf bmV3KCk7CisgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKK30KKworc3Rh dGljIHZvaWQgc291cFNlc3Npb25Jbml0YWxpemUoKQoreworICAgIEdTTGlzdCAqZmVhdHVyZXMs ICpsOworICAgIFNvdXBDb29raWVKYXIgKmphciA9IDA7CisgICAgYm9vbCBoYXNfbG9nZ2VyX2Zl YXR1cmUgPSBmYWxzZTsKKworICAgIGZlYXR1cmVzID0gc291cF9zZXNzaW9uX2dldF9mZWF0dXJl cyhzZXNzaW9uKTsKKyAgICBmb3IgKGwgPSBmZWF0dXJlczsgbDsgbCA9IGwtPm5leHQpIHsKKyAg ICAgICAgaWYgKFNPVVBfSVNfQ09PS0lFX0pBUiAobC0+ZGF0YSkpIHsKKyAgICAgICAgICAgIGph ciA9IChTb3VwQ29va2llSmFyKilsLT5kYXRhOworICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIH0KIAorICAgICAgICBpZiAoU09VUF9JU19MT0dHRVIgKGwtPmRhdGEpKSB7CisgICAgICAg ICAgICBoYXNfbG9nZ2VyX2ZlYXR1cmUgPSB0cnVlOworICAgICAgICAgICAgY29udGludWU7Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAoIWphcikgewogICAgICAgICBzb3VwX3Nlc3Npb25f YWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNTSU9OX0ZFQVRVUkUoZ2V0Q29va2llSmFyKCkp KTsKKyAgICB9IGVsc2UgeworICAgICAgICBzZXRDb29raWVKYXIoamFyKTsKKyAgICB9CisgICAg CisgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfU09VUF9MT0dH SU5HIik7CisgICAgaWYgKHNvdXBfZGVidWcgJiYgIWhhc19sb2dnZXJfZmVhdHVyZSkgeworICAg ICAgICBpbnQgc291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAgICAgIAor ICAgICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8 U291cExvZ2dlckxvZ0xldmVsPihzb3VwX2RlYnVnX2xldmVsKSwgLTEpOworICAgICAgICBzb3Vw X2xvZ2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYo bG9nZ2VyKTsKKyAgICB9CiAKLSAgICAgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0 ZW52KCJXRUJLSVRfU09VUF9MT0dHSU5HIik7Ci0gICAgICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0g ICAgICAgICAgICBpbnQgc291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAg c2Vzc2lvbkluaXRpYWxpemVkID0gdHJ1ZTsKK30KIAotICAgICAgICAgICAgU291cExvZ2dlciog bG9nZ2VyID0gc291cF9sb2dnZXJfbmV3KHN0YXRpY19jYXN0PFNvdXBMb2dnZXJMb2dMZXZlbD4o c291cF9kZWJ1Z19sZXZlbCksIC0xKTsKLSAgICAgICAgICAgIHNvdXBfbG9nZ2VyX2F0dGFjaChs b2dnZXIsIHNlc3Npb24pOwotICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsKLSAg ICAgICAgfQorYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcp Cit7CisgICAgaWYgKCFzZXNzaW9uKSB7CisgICAgICAgIGNyZWF0ZVNvdXBTZXNzaW9uKCk7Cisg ICAgfQorCisgICAgaWYgKCFzZXNzaW9uSW5pdGlhbGl6ZWQpIHsKKyAgICAgICAgc291cFNlc3Np b25Jbml0YWxpemUoKTsKICAgICB9CiAKICAgICBTb3VwTWVzc2FnZSogbXNnOwpAQCAtNTg3LDUg KzYyMywxNCBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEdpbyhTdHJpbmcgdXJsU3RyaW5n KQogICAgIHJldHVybiB0cnVlOwogfQogCitTb3VwU2Vzc2lvbiogUmVzb3VyY2VIYW5kbGU6Omdl dFNlc3Npb24oKQoreworICAgIGlmICghc2Vzc2lvbikgeworICAgICAgICBjcmVhdGVTb3VwU2Vz c2lvbigpOworICAgIH0KKyAgICAKKyAgICByZXR1cm4gc2Vzc2lvbjsKK30KKwogfQogCmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmlu CmluZGV4IDBjZTZmNzEuLjg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBj LmluCisrKyBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRl ZGlyPUBpbmNsdWRlZGlyQAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQg ZW5naW5lIGZvciBHVEsrCiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAor UmVxdWlyZXM6IGd0aystMi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtp dC0xLjAKIENmbGFnczogLUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAKaW5kZXggZTk4ZDNmNy4uYmI5NzljOSAxMDA2NDQKLS0tIGEvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAKQEAgLTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQYXN0ZWJvYXJkSGVs cGVyLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiUGxh dGZvcm1XaGVlbEV2ZW50LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRl ICJTY3JpcHRWYWx1ZS5oIgogI2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlN1YnN0 aXR1dGVEYXRhLmgiCkBAIC0yNTkzLDQgKzI1OTQsMjUgQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdf c2V0X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpv b20KICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qod2ViVmlldyksICJmdWxsLWNvbnRlbnQt em9vbSIpOwogfQogCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbgorICogQHdl Yl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKgorICogUmV0dXJucyB0aGUgZ2xvYmFsICNTb3Vw U2Vzc2lvbiB1c2VkIGJ5IFdlYktpdC4gRm9yIG5vdyB0aGVyZSdzIG9ubHkKKyAqIG9uZSBmb3Ig dGhlIGJyb3dzZXIsIHNvIHRoZSBAd2ViX3ZpZXcgcGFyYW1ldGVyIHVzIHVzZWxlc3MgYW5kIE5V TEwKKyAqIG11c3QgYmUgcGFzc2VkLgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlICNTb3VwU2Vz c2lvbiB1c2VkIGJ5IFdlYktpdAorICoKKyAqIFNpbmNlOiAxLjAuMworICovCitTb3VwU2Vzc2lv biogd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uIChXZWJLaXRXZWJWaWV3ICp3ZWJfdmlldykK K3sKKyAgICBpZiAoIXdlYl92aWV3KSB7CisgICAgICAgIHJldHVybiBSZXNvdXJjZUhhbmRsZTo6 Z2V0U2Vzc2lvbigpOworICAgIH0KKworICAgIHJldHVybiBOVUxMOworfQorCiB9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmgKaW5kZXggZDczNzY1OC4uZDM2OGQwNyAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuaApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3 ZWJiYWNrZm9yd2FyZGxpc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViaGlzdG9yeWl0 ZW0uaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4KKyNpbmNsdWRlIDxs aWJzb3VwL3NvdXAuaD4KIAogR19CRUdJTl9ERUNMUwogCkBAIC0yODQsNiArMjg1LDkgQEAgV0VC S0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tICAgICAg ICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgICAgICAgICAgICBmdWxs X2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3ZWJraXRfd2ViX3Zp ZXdfZ2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAqd2ViX3Zp ZXcpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0dO VW1ha2VmaWxlLmFtIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KaW5kZXggMDQ5YjExZi4u NjExODI1MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KKysrIGIvV2Vi S2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KQEAgLTIwLDYgKzIwLDcgQEAgUHJvZ3JhbXNfR3RrTGF1 bmNoZXJfQ0ZMQUdTID0gXAogCS1mbm8tc3RyaWN0LWFsaWFzaW5nIFwKIAktTzIgXAogCSQoZ2xv YmFsX2NmbGFncykgXAorCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFBy b2dyYW1zX0d0a0xhdW5jaGVyX0xEQUREID0gXApAQCAtNjcsNiArNjgsNyBAQCBQcm9ncmFtc19E dW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTE9CQUxE RVBTX0NGTEFHUykgXAogCSQoQ0FJUk9fQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykgXAog CSQoR1RLX0NGTEFHUykKIAogUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfTERBREQgPSBcCi0tIAox LjYuMC42Cgo= 26230 2008-12-23 15:26:05 -0800 2008-12-24 11:56:22 -0800 API to retrieve the soup session from the view p.diff text/plain 14387 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCBmNDlhZDk2Li5kNTI1NDNmIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NDQsMzEgKzE3NDQsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzgyLDcgKzE3NTcsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IGM5M2FmMjEuLmQxNTNiOTIgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBA QAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAK KyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRpZgorCiAjaWYg UExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsK ICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMCBAQCBwdWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJ bnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVybiBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lm IFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbigpOworI2VuZGlm CisKICAgICAvLyBVc2VkIHRvIHdvcmsgYXJvdW5kIHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdl dCBhbnkgbW9yZSBOU1VSTENvbm5lY3Rpb24gY2FsbGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJv bSB0aGUgb25lIHlvdSdyZSBpbi4KICAgICBzdGF0aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAg CiAgICAgCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVK YXJTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu Y3BwCmluZGV4IDg4MTA5ZTguLjQ0ZDJhNzYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCkBAIC0yNSwxMCArMjUsMjIgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitzdGF0aWMgU291cENvb2tpZUphciogY29va2llX2phciA9IE5VTEw7 CisKIFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpCiB7Ci0gICAgc3RhdGljIFNvdXBDb29r aWVKYXIqIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKLSAgICByZXR1cm4gamFyOworICAg IGlmIChjb29raWVfamFyID09IE5VTEwpIHsKKyAgICAgICAgY29va2llX2phciA9IHNvdXBfY29v a2llX2phcl9uZXcoKTsKKyAgICB9CisKKyAgICByZXR1cm4gY29va2llX2phcjsKK30KKwordm9p ZCBzZXRDb29raWVKYXIoU291cENvb2tpZUphciAqamFyKQoreworICAgIGlmIChjb29raWVfamFy ID09IE5VTEwpIHsKKyAgICAgICAgY29va2llX2phciA9IGphcjsKKyAgICB9CiB9CiAKIHZvaWQg c2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0 IEtVUkwmIC8qcG9saWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uYzM0MzBm OSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291 cC5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaApA QCAtMzIsNiArMzIsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgU291cENvb2tpZUph ciogZ2V0Q29va2llSmFyKCk7CisgICAgdm9pZCBzZXRDb29raWVKYXIoU291cENvb2tpZUphciAq amFyKTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCA1ZmQzYTRkLi4zNGJlZGVjIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3Bw CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5j cHAKQEAgLTQ5LDYgKzQ5LDcgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogc3RhdGljIFNvdXBT ZXNzaW9uKiBzZXNzaW9uID0gMDsKK3N0YXRpYyBib29sIHNlc3Npb25Jbml0aWFsaXplZCA9IGZh bHNlOwogCiBlbnVtCiB7CkBAIC0yNzAsMjEgKzI3MSw0MyBAQCBib29sIFJlc291cmNlSGFuZGxl OjpzdGFydERhdGEoU3RyaW5nIHVybFN0cmluZykKICAgICAgICAgcmV0dXJuIHRydWU7CiB9CiAK LWJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQorc3RhdGlj IHZvaWQgY3JlYXRlU291cFNlc3Npb24oKQogewotICAgIGlmICghc2Vzc2lvbikgewotICAgICAg ICBzZXNzaW9uID0gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworICAgIHNlc3Npb24gPSBzb3Vw X3Nlc3Npb25fYXN5bmNfbmV3KCk7Cit9CiAKK3N0YXRpYyB2b2lkIHNvdXBTZXNzaW9uSW5pdGFs aXplKCkKK3sKKyAgICBTb3VwU2Vzc2lvbkZlYXR1cmUgKmphciA9IDA7CisgICAgY29uc3QgY2hh ciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfU09VUF9MT0dHSU5HIik7CisKKyAgICBq YXIgPSBzb3VwX3Nlc3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0NPT0tJRV9K QVIpOworICAgIGlmICghamFyKSB7CiAgICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShz ZXNzaW9uLCBTT1VQX1NFU1NJT05fRkVBVFVSRShnZXRDb29raWVKYXIoKSkpOworICAgIH0gZWxz ZSB7CisgICAgICAgIHNldENvb2tpZUphcihTT1VQX0NPT0tJRV9KQVIoZ19vYmplY3RfcmVmKGph cikpKTsKKyAgICB9CiAKLSAgICAgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52 KCJXRUJLSVRfU09VUF9MT0dHSU5HIik7Ci0gICAgICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0gICAg ICAgICAgICBpbnQgc291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAgaWYg KHNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfTE9HR0VSKSA9PSBO VUxMCisgICAgICAgICYmIHNvdXBfZGVidWcpIHsKKyAgICAgICAgaW50IHNvdXBfZGVidWdfbGV2 ZWwgPSBhdG9pKHNvdXBfZGVidWcpOwogCi0gICAgICAgICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIg PSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291cExvZ2dlckxvZ0xldmVsPihzb3VwX2Rl YnVnX2xldmVsKSwgLTEpOwotICAgICAgICAgICAgc291cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwg c2Vzc2lvbik7Ci0gICAgICAgICAgICBnX29iamVjdF91bnJlZihsb2dnZXIpOwotICAgICAgICB9 CisgICAgICAgIFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2Fz dDxTb3VwTG9nZ2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2ZWwpLCAtMSk7CisgICAgICAgIHNv dXBfbG9nZ2VyX2F0dGFjaChsb2dnZXIsIHNlc3Npb24pOworICAgICAgICBnX29iamVjdF91bnJl Zihsb2dnZXIpOworICAgIH0KKworICAgIHNlc3Npb25Jbml0aWFsaXplZCA9IHRydWU7Cit9CisK K2Jvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQoreworICAg IGlmICghc2Vzc2lvbikgeworICAgICAgICBjcmVhdGVTb3VwU2Vzc2lvbigpOworICAgIH0KKwor ICAgIGlmICghc2Vzc2lvbkluaXRpYWxpemVkKSB7CisgICAgICAgIHNvdXBTZXNzaW9uSW5pdGFs aXplKCk7CiAgICAgfQogCiAgICAgU291cE1lc3NhZ2UqIG1zZzsKQEAgLTU4Nyw1ICs2MTAsMTQg QEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3RyaW5nIHVybFN0cmluZykKICAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291cmNlSGFuZGxlOjpnZXRTZXNzaW9u KCkKK3sKKyAgICBpZiAoIXNlc3Npb24pIHsKKyAgICAgICAgY3JlYXRlU291cFNlc3Npb24oKTsK KyAgICB9CisKKyAgICByZXR1cm4gc2Vzc2lvbjsKK30KKwogfQogCmRpZmYgLS1naXQgYS9XZWJL aXQvZ3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCmluZGV4IDBjZTZm NzEuLjg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCisrKyBiL1dl YktpdC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRlZGlyPUBpbmNsdWRl ZGlyQAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQgZW5naW5lIGZvciBH VEsrCiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAorUmVxdWlyZXM6IGd0 aystMi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtpdC0xLjAKIENmbGFn czogLUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Vi a2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5j cHAKaW5kZXggZTk4ZDNmNy4uZmRjNTYxOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5j cHAKQEAgLTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQYXN0ZWJvYXJkSGVscGVyLmgiCiAjaW5j bHVkZSAiUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1XaGVlbEV2 ZW50LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJTY3JpcHRWYWx1 ZS5oIgogI2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlN1YnN0aXR1dGVEYXRhLmgi CkBAIC0xMTMsNyArMTE0LDggQEAgZW51bSB7CiAgICAgUFJPUF9XSU5ET1dfRkVBVFVSRVMsCiAg ICAgUFJPUF9UUkFOU1BBUkVOVCwKICAgICBQUk9QX1pPT01fTEVWRUwsCi0gICAgUFJPUF9GVUxM X0NPTlRFTlRfWk9PTQorICAgIFBST1BfRlVMTF9DT05URU5UX1pPT00sCisgICAgUFJPUF9TRVNT SU9OLAogfTsKIAogc3RhdGljIGd1aW50IHdlYmtpdF93ZWJfdmlld19zaWduYWxzW0xBU1RfU0lH TkFMXSA9IHsgMCwgfTsKQEAgLTI3MSw2ICsyNzMsOSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2Vi X3ZpZXdfZ2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVl KgogICAgIGNhc2UgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTToKICAgICAgICAgZ192YWx1ZV9zZXRf Ym9vbGVhbih2YWx1ZSwgd2Via2l0X3dlYl92aWV3X2dldF9mdWxsX2NvbnRlbnRfem9vbSh3ZWJW aWV3KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9TRVNTSU9OOgorICAgICAgICBn X3ZhbHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbih3ZWJW aWV3KSk7CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JKRUNUX1dB Uk5fSU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAgICB9CkBA IC0xNTA1LDYgKzE1MTAsMjAgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2lu aXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGQUxTRSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJB TV9SRUFEV1JJVEUpKTsKIAorICAgIC8qKgorICAgICogV2ViS2l0V2ViVmlldzpzZXNzaW9uOgor ICAgICoKKyAgICAqIFJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUgdmlldy4KKyAgICAqCisg ICAgKiBTaW5jZTogMS4wLjMKKyAgICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJv cGVydHkob2JqZWN0Q2xhc3MsIFBST1BfU0VTU0lPTiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19vYmplY3QoInNlc3Npb24iLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiU2Vzc2lvbiIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJS ZXRyaWV2ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXciLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX1RZUEVfU0VTU0lPTiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VC S0lUX1BBUkFNX1JFQURBQkxFKSk7CisKICAgICBnX3R5cGVfY2xhc3NfYWRkX3ByaXZhdGUod2Vi Vmlld0NsYXNzLCBzaXplb2YoV2ViS2l0V2ViVmlld1ByaXZhdGUpKTsKIH0KIApAQCAtMjU4NSw3 ICsyNjA0LDcgQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdl YktpdFdlYlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpvb20KIAogICAgIFdlYktpdFdlYlZpZXdQ cml2YXRlKiBwcml2ID0gd2ViVmlldy0+cHJpdjsKICAgICBpZiAocHJpdi0+em9vbUZ1bGxDb250 ZW50ID09IHpvb21GdWxsQ29udGVudCkKLSAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuOwog CiAgICAgcHJpdi0+em9vbUZ1bGxDb250ZW50ID0gem9vbUZ1bGxDb250ZW50OwogICAgIHdlYmtp dF93ZWJfdmlld19hcHBseV96b29tX2xldmVsKHdlYlZpZXcsIHdlYmtpdF93ZWJfdmlld19nZXRf em9vbV9sZXZlbCh3ZWJWaWV3KSk7CkBAIC0yNTkzLDQgKzI2MTIsMjQgQEAgdm9pZCB3ZWJraXRf d2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsIGdi b29sZWFuIHpvb20KICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qod2ViVmlldyksICJmdWxs LWNvbnRlbnQtem9vbSIpOwogfQogCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lv bgorICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKgorICogUmV0cmlldmVzIHRoZSAj U291cFNlc3Npb24gb2YgdGhlIHZpZXcuIE5vdGUgdGhhdCB0aGUKKyAqIHNlc3Npb24gZmVhdHVy ZXMgYXJlIGFkZGVkIGJ5IFdlYktpdCBvbiBkZW1hbmQsIHNvIGlmCisgKiB5b3UgaW5zZXJ0IGZv ciB5b3VyIG93biAjU291cENvb2tpZUphciBiZWZvcmUgYW55IG5ldHdvcmsKKyAqIHRyYWZmaWMg b2NjdXJzLCBXZWJLaXQgd2lsbCB1c2UgaXQgaW5zdGVhZCBvZiB0aGUgZGVmYXVsdC4KKyAqCisg KiBSZXR1cm4gdmFsdWU6IHRoZSAjU291cFNlc3Npb24gb2YgdGhlIHZpZXcKKyAqCisgKiBTaW5j ZTogMS4wLjMKKyAqLworU291cFNlc3Npb24qIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbiAo V2ViS2l0V2ViVmlldyogd2ViX3ZpZXcpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VC S0lUX0lTX1dFQl9WSUVXKHdlYl92aWV3KSwgTlVMTCk7CisKKyAgICByZXR1cm4gUmVzb3VyY2VI YW5kbGU6OmdldFNlc3Npb24oKTsKK30KKwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2Vidmlldy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCmlu ZGV4IGQ3Mzc2NTguLmQzNjhkMDcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKQEAgLTI5 LDYgKzI5LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRsaXN0Lmg+ CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmhpc3RvcnlpdGVtLmg+CiAjaW5jbHVkZSA8d2Vi a2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIEdf QkVHSU5fREVDTFMKIApAQCAtMjg0LDYgKzI4NSw5IEBAIFdFQktJVF9BUEkgdm9pZAogd2Via2l0 X3dlYl92aWV3X3NldF9mdWxsX2NvbnRlbnRfem9vbSAgICAgICAgICAgKFdlYktpdFdlYlZpZXcg ICAgICAgICp3ZWJfdmlldywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBnYm9vbGVhbiAgICAgICAgICAgICAgZnVsbF9jb250ZW50X3pvb20pOwogCitX RUJLSVRfQVBJIFNvdXBTZXNzaW9uKgord2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uICAgICAg ICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgKndlYl92aWV3KTsKKwogR19FTkRfREVDTFMK IAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBiL1dlYktp dFRvb2xzL0dOVW1ha2VmaWxlLmFtCmluZGV4IDA0OWIxMWYuLjYxMTgyNTMgMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxl LmFtCkBAIC0yMCw2ICsyMCw3IEBAIFByb2dyYW1zX0d0a0xhdW5jaGVyX0NGTEFHUyA9IFwKIAkt Zm5vLXN0cmljdC1hbGlhc2luZyBcCiAJLU8yIFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwKKwkkKExJ QlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFtc19HdGtMYXVuY2hlcl9M REFERCA9IFwKQEAgLTY3LDYgKzY4LDcgQEAgUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfQ0ZMQUdT ID0gXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xPQkFMREVQU19DRkxBR1MpIFwKIAkkKENB SVJPX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFBy b2dyYW1zX0R1bXBSZW5kZXJUcmVlX0xEQUREID0gXApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv R3RrTGF1bmNoZXIvbWFpbi5jIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCmluZGV4 IDhlZDI2OTAuLjM4Y2I1ZWMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21h aW4uYworKysgYi9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKQEAgLTE4Miw2ICsxODIs OCBAQCBjcmVhdGVfd2luZG93ICgpCiBpbnQKIG1haW4gKGludCBhcmdjLCBjaGFyKiBhcmd2W10p CiB7CisgICAgaWYgKCFnX3RocmVhZF9zdXBwb3J0ZWQgKCkpCisgICAgICAgIGdfdGhyZWFkX2lu aXQgKE5VTEwpOwogICAgIGd0a19pbml0ICgmYXJnYywgJmFyZ3YpOwogCiAgICAgR3RrV2lkZ2V0 KiB2Ym94ID0gZ3RrX3Zib3hfbmV3IChGQUxTRSwgMCk7CmRpZmYgLS1naXQgYS9jb25maWd1cmUu YWMgYi9jb25maWd1cmUuYWMKaW5kZXggNGU0ZDlmOS4uMWI2MWJkZiAxMDA2NDQKLS0tIGEvY29u ZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtMjg2LDIwICsyODYsNiBAQCBpZiB0ZXN0 ICIkd2l0aF9oaWxkb24iID0gInllcyI7IHRoZW4KICAgICBBQ19TVUJTVChbSElMRE9OX0xJQlNd KQogZmkKIAotIyBkZXRlcm1pbmUgdGhlIGh0dHAgYmFja2VuZAotQUNfTVNHX0NIRUNLSU5HKFt0 aGUgSFRUUCBiYWNrZW5kIHRvIHVzZV0pCi1BQ19BUkdfV0lUSChodHRwX2JhY2tlbmQsCi0gICAg ICAgICAgICBBQ19IRUxQX1NUUklORyhbLS13aXRoLWh0dHAtYmFja2VuZD1APDpAY3VybC9zb3Vw QDo+QF0sCi0gICAgICAgICAgICAgICAgICAgICAgICAgICBbU2VsZWN0IEhUVFAgYmFja2VuZCBb ZGVmYXVsdD1jdXJsXV0pLAotICAgICAgICAgICAgW10sW3dpdGhfaHR0cF9iYWNrZW5kPSJjdXJs Il0pCi0KLWNhc2UgIiR3aXRoX2h0dHBfYmFja2VuZCIgaW4KLSAgICAgY3VybHxzb3VwKSA7Owot ICAgICAqKSBBQ19NU0dfRVJST1IoW0ludmFsaWQgSFRUUCBiYWNrZW5kOiBtdXN0IGJlIGN1cmws IHNvdXAuXSkgOzsKLWVzYWMKLQotQUNfTVNHX1JFU1VMVChbJHdpdGhfaHR0cF9iYWNrZW5kXSkK LQogIyBtaW5pbXVtIGJhc2UgZGVwZW5kZW5jaWVzCiBDQUlST19SRVFVSVJFRF9WRVJTSU9OPTEu MgogRk9OVENPTkZJR19SRVFVSVJFRF9WRVJTSU9OPTIuNApAQCAtMzE0LDggKzMwMCw3IEBAIFBB TkdPX1JFUVVJUkVEX1ZFUlNJT049MS4wCiBHVEtfUkVRVUlSRURfVkVSU0lPTj0yLjgKIAogIyBv cHRpb25hbCBtb2R1bGVzCi1MSUJDVVJMX1JFUVVJUkVEX1ZFUlNJT049Ny4xNQotTElCU09VUF9S RVFVSVJFRF9WRVJTSU9OPTIuMjMKK0xJQlNPVVBfUkVRVUlSRURfVkVSU0lPTj0yLjI1LjQKIExJ QlhTTFRfUkVRVUlSRURfVkVSU0lPTj0xLjEuNwogU1FMSVRFX1JFUVVJUkVEX1ZFUlNJT049My4w CiBHU1RSRUFNRVJfUkVRVUlSRURfVkVSU0lPTj0wLjEwCkBAIC02MjQsMjMgKzYwOSwxMSBAQCBl bHNlCiAgICBDRkxBR1M9IiRDRkxBR1MgLU8wIgogZmkKIAotIyBjaGVjayBpZiBjdXJsIGlzIGF2 YWlsYWJsZQotaWYgdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJjdXJsIjsgdGhlbgotICAg UEtHX0NIRUNLX01PRFVMRVMoW0xJQkNVUkxdLAotICAgICAgICAgICAgICAgICAgICAgW2xpYmN1 cmwgPj0gJExJQkNVUkxfUkVRVUlSRURfVkVSU0lPTl0pCi0gICBpZiB0ZXN0ICIkb3Nfd2luMzIi ID0gInllcyI7IHRoZW4KLSAgICAgIExJQkNVUkxfTElCUz0iJExJQkNVUkxfTElCUyAtbHdzMl8z MiIKLSAgIGZpCi0gICBBQ19TVUJTVChbTElCQ1VSTF9DRkxBR1NdKQotICAgQUNfU1VCU1QoW0xJ QkNVUkxfTElCU10pCi1maQogCi1pZiB0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gInNvdXAi OyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCU09VUF0sCi0gICAgICAgICAgICAgICAg ICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVRVUlSRURfVkVSU0lPTl0pCi0gICBBQ19T VUJTVChbTElCU09VUF9DRkxBR1NdKQotICAgQUNfU1VCU1QoW0xJQlNPVVBfTElCU10pCi1maQor UEtHX0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAorICAgICAgICAgICAgICAgICAgW2xpYnNvdXAt Mi40ID49ICRMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT05dKQorQUNfU1VCU1QoW0xJQlNPVVBfQ0ZM QUdTXSkKK0FDX1NVQlNUKFtMSUJTT1VQX0xJQlNdKQogCiAjIGNoZWNrIGlmIEZyZWVUeXBlL0Zv bnRDb25maWcgYXJlIGF2YWlsYWJsZQogaWYgdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5kIiA9ICJm cmVldHlwZSI7IHRoZW4KQEAgLTcxMiwxMCArNjg1LDYgQEAgQU1fQ09ORElUSU9OQUwoW1RBUkdF VF9XSU4zMl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gIndpbjMyIl0pCiBBTV9DT05ESVRJT05B TChbVEFSR0VUX1FVQVJUWl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gInF1YXJ0eiJdKQogQU1f Q09ORElUSU9OQUwoW1RBUkdFVF9ESVJFQ1RGQl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gImRp cmVjdGZiIl0pCiAKLSMgSFRUUCBiYWNrZW5kIGNvbmRpdGlvbmFscwotQU1fQ09ORElUSU9OQUwo W1VTRV9DVVJMXSwgW3Rlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAiY3VybCJdKQotQU1fQ09O RElUSU9OQUwoW1VTRV9TT1VQXSwgW3Rlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAic291cCJd KQotCiAjIEZvbnQgYmFja2VuZCBjb25kaXRpb25hbHMKIEFNX0NPTkRJVElPTkFMKFtVU0VfRlJF RVRZUEVdLCBbdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5kIiA9ICJmcmVldHlwZSJdKQogQU1fQ09O RElUSU9OQUwoW1VTRV9QQU5HT10sIFt0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gInBhbmdv Il0pCkBAIC03NjIsNyArNzMxLDYgQEAgQnVpbGQgY29uZmlndXJhdGlvbjoKICBFbmFibGUgR0ND IGJ1aWxkIG9wdGltaXphdGlvbiAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVf b3B0aW1pemF0aW9ucwogIENvZGUgY292ZXJhZ2Ugc3VwcG9ydCAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIDogJGVuYWJsZV9jb3ZlcmFnZQogIFVuaWNvZGUgYmFja2VuZCAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJHVuaWNvZGVfYmFja2VuZAot IEhUVFAgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDogJHdpdGhfaHR0cF9iYWNrZW5kCiAgRm9udCBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9mb250X2JhY2tlbmQKICBPcHRpbWl6ZWQg bWVtb3J5IGFsbG9jYXRvciAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVf ZmFzdF9tYWxsb2MKIEZlYXR1cmVzOgo= 26240 2008-12-24 11:55:55 -0800 2008-12-28 16:43:55 -0800 API to retrieve the soup session from the view #2 p.diff text/plain 13951 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCBmNDlhZDk2Li5kNTI1NDNmIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NDQsMzEgKzE3NDQsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzgyLDcgKzE3NTcsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IGM5M2FmMjEuLmQxNTNiOTIgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBA QAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAK KyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRpZgorCiAjaWYg UExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsK ICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMCBAQCBwdWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJ bnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVybiBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lm IFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbigpOworI2VuZGlm CisKICAgICAvLyBVc2VkIHRvIHdvcmsgYXJvdW5kIHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdl dCBhbnkgbW9yZSBOU1VSTENvbm5lY3Rpb24gY2FsbGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJv bSB0aGUgb25lIHlvdSdyZSBpbi4KICAgICBzdGF0aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAg CiAgICAgCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVK YXJTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu Y3BwCmluZGV4IDg4MTA5ZTguLmE3M2M3Y2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCkBAIC0yNSwxMCArMjUsMjAgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCitzdGF0aWMgU291cENvb2tpZUphciogY29va2llX2phciA9IDA7CisK IFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpCiB7Ci0gICAgc3RhdGljIFNvdXBDb29raWVK YXIqIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKLSAgICByZXR1cm4gamFyOworICAgIGlm ICghY29va2llX2phcikKKyAgICAgICAgY29va2llX2phciA9IHNvdXBfY29va2llX2phcl9uZXco KTsKKworICAgIHJldHVybiBjb29raWVfamFyOworfQorCit2b2lkIHNldENvb2tpZUphcihTb3Vw Q29va2llSmFyICpqYXIpCit7CisgICAgaWYgKCFjb29raWVfamFyKQorICAgICAgICBjb29raWVf amFyID0gamFyOwogfQogCiB2b2lkIHNldENvb2tpZXMoRG9jdW1lbnQqIC8qZG9jdW1lbnQqLywg Y29uc3QgS1VSTCYgdXJsLCBjb25zdCBLVVJMJiAvKnBvbGljeVVSTCovLCBjb25zdCBTdHJpbmcm IHZhbHVlKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2ll SmFyU291cC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5o CmluZGV4IDYxMTc5YWUuLmMzNDMwZjkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9Db29raWVKYXJTb3VwLmgKQEAgLTMyLDYgKzMyLDcgQEAKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogICAgIFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpOworICAgIHZvaWQgc2V0Q29v a2llSmFyKFNvdXBDb29raWVKYXIgKmphcik7CiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXggNWZk M2E0ZC4uZTczOTQyYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC00OSw2ICs0OSw3IEBACiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKIHN0YXRpYyBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9IDA7CitzdGF0aWMgYm9vbCBz ZXNzaW9uSW5pdGlhbGl6ZWQgPSBmYWxzZTsKIAogZW51bQogewpAQCAtMjcwLDIxICsyNzEsNDAg QEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnREYXRhKFN0cmluZyB1cmxTdHJpbmcpCiAgICAg ICAgIHJldHVybiB0cnVlOwogfQogCi1ib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAoU3Ry aW5nIHVybFN0cmluZykKK3N0YXRpYyB2b2lkIGNyZWF0ZVNvdXBTZXNzaW9uKCkKIHsKLSAgICBp ZiAoIXNlc3Npb24pIHsKLSAgICAgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXco KTsKKyAgICBzZXNzaW9uID0gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworfQorCitzdGF0aWMg dm9pZCBzb3VwU2Vzc2lvbkluaXRhbGl6ZSgpCit7CisgICAgU291cFNlc3Npb25GZWF0dXJlICpq YXIgPSAwOworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRf REVCVUciKTsKIAorICAgIGphciA9IHNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBT T1VQX1RZUEVfQ09PS0lFX0pBUik7CisgICAgaWYgKCFqYXIpCiAgICAgICAgIHNvdXBfc2Vzc2lv bl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1NFU1NJT05fRkVBVFVSRShnZXRDb29raWVKYXIo KSkpOworICAgIGVsc2UKKyAgICAgICAgc2V0Q29va2llSmFyKFNPVVBfQ09PS0lFX0pBUihnX29i amVjdF9yZWYoamFyKSkpOworCisgICAgaWYgKHNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNz aW9uLCBTT1VQX1RZUEVfTE9HR0VSKSA9PSBOVUxMCisgICAgICAgICYmIHdlYmtpdF9kZWJ1ZyAm JiAhc3RyY21wKHdlYmtpdF9kZWJ1ZywgIm5ldHdvcmsiKSkgeworICAgICAgICBTb3VwTG9nZ2Vy KiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291cExvZ2dlckxvZ0xldmVs PihTT1VQX0xPR0dFUl9MT0dfQk9EWSksIC0xKTsKKyAgICAgICAgc291cF9sb2dnZXJfYXR0YWNo KGxvZ2dlciwgc2Vzc2lvbik7CisgICAgICAgIGdfb2JqZWN0X3VucmVmKGxvZ2dlcik7CisgICAg fQogCi0gICAgICAgIGNvbnN0IGNoYXIqIHNvdXBfZGVidWcgPSBnX2dldGVudigiV0VCS0lUX1NP VVBfTE9HR0lORyIpOwotICAgICAgICBpZiAoc291cF9kZWJ1ZykgewotICAgICAgICAgICAgaW50 IHNvdXBfZGVidWdfbGV2ZWwgPSBhdG9pKHNvdXBfZGVidWcpOworICAgIHNlc3Npb25Jbml0aWFs aXplZCA9IHRydWU7Cit9CiAKLSAgICAgICAgICAgIFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBf bG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9nZ2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2 ZWwpLCAtMSk7Ci0gICAgICAgICAgICBzb3VwX2xvZ2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9u KTsKLSAgICAgICAgICAgIGdfb2JqZWN0X3VucmVmKGxvZ2dlcik7Ci0gICAgICAgIH0KK2Jvb2wg UmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQoreworICAgIGlmICgh c2Vzc2lvbikgeworICAgICAgICBjcmVhdGVTb3VwU2Vzc2lvbigpOworICAgIH0KKworICAgIGlm ICghc2Vzc2lvbkluaXRpYWxpemVkKSB7CisgICAgICAgIHNvdXBTZXNzaW9uSW5pdGFsaXplKCk7 CiAgICAgfQogCiAgICAgU291cE1lc3NhZ2UqIG1zZzsKQEAgLTU4Nyw1ICs2MDcsMTQgQEAgYm9v bCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3RyaW5nIHVybFN0cmluZykKICAgICByZXR1cm4g dHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291cmNlSGFuZGxlOjpnZXRTZXNzaW9uKCkKK3sK KyAgICBpZiAoIXNlc3Npb24pIHsKKyAgICAgICAgY3JlYXRlU291cFNlc3Npb24oKTsKKyAgICB9 CisKKyAgICByZXR1cm4gc2Vzc2lvbjsKK30KKwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCmluZGV4IDBjZTZmNzEuLjg0 ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCisrKyBiL1dlYktpdC9n dGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRlZGlyPUBpbmNsdWRlZGlyQAog TmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQgZW5naW5lIGZvciBHVEsrCiBW ZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAorUmVxdWlyZXM6IGd0aystMi4w IGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtpdC0xLjAKIENmbGFnczogLUkk e2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKaW5k ZXggZTk4ZDNmNy4uNTQ0ZTdiNCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0 d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKQEAg LTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQYXN0ZWJvYXJkSGVscGVyLmgiCiAjaW5jbHVkZSAi UGxhdGZvcm1LZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1XaGVlbEV2ZW50Lmgi CisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJTY3JpcHRWYWx1ZS5oIgog I2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlN1YnN0aXR1dGVEYXRhLmgiCkBAIC0x MTMsNyArMTE0LDggQEAgZW51bSB7CiAgICAgUFJPUF9XSU5ET1dfRkVBVFVSRVMsCiAgICAgUFJP UF9UUkFOU1BBUkVOVCwKICAgICBQUk9QX1pPT01fTEVWRUwsCi0gICAgUFJPUF9GVUxMX0NPTlRF TlRfWk9PTQorICAgIFBST1BfRlVMTF9DT05URU5UX1pPT00sCisgICAgUFJPUF9TRVNTSU9OLAog fTsKIAogc3RhdGljIGd1aW50IHdlYmtpdF93ZWJfdmlld19zaWduYWxzW0xBU1RfU0lHTkFMXSA9 IHsgMCwgfTsKQEAgLTI3MSw2ICsyNzMsOSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3ZpZXdf Z2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVlKgogICAg IGNhc2UgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTToKICAgICAgICAgZ192YWx1ZV9zZXRfYm9vbGVh bih2YWx1ZSwgd2Via2l0X3dlYl92aWV3X2dldF9mdWxsX2NvbnRlbnRfem9vbSh3ZWJWaWV3KSk7 CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9TRVNTSU9OOgorICAgICAgICBnX3ZhbHVl X3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbih3ZWJWaWV3KSk7 CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5W QUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAgICB9CkBAIC0xNTA1 LDYgKzE1MTAsMjAgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2luaXQoV2Vi S2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGQUxTRSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFE V1JJVEUpKTsKIAorICAgIC8qKgorICAgICogV2ViS2l0V2ViVmlldzpzZXNzaW9uOgorICAgICoK KyAgICAqIFJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUgdmlldy4KKyAgICAqCisgICAgKiBT aW5jZTogMS4wLjMKKyAgICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVydHko b2JqZWN0Q2xhc3MsIFBST1BfU0VTU0lPTiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGdfcGFyYW1fc3BlY19vYmplY3QoInNlc3Npb24iLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiU2Vzc2lvbiIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJSZXRyaWV2 ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXciLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX1RZUEVfU0VTU0lPTiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BB UkFNX1JFQURBQkxFKSk7CisKICAgICBnX3R5cGVfY2xhc3NfYWRkX3ByaXZhdGUod2ViVmlld0Ns YXNzLCBzaXplb2YoV2ViS2l0V2ViVmlld1ByaXZhdGUpKTsKIH0KIApAQCAtMjU5Myw0ICsyNjEy LDI0IEBAIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldF9mdWxsX2NvbnRlbnRfem9vbShXZWJLaXRX ZWJWaWV3KiB3ZWJWaWV3LCBnYm9vbGVhbiB6b29tCiAgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JK RUNUKHdlYlZpZXcpLCAiZnVsbC1jb250ZW50LXpvb20iKTsKIH0KIAorLyoqCisgKiB3ZWJraXRf d2ViX3ZpZXdfZ2V0X3Nlc3Npb246CisgKiBAd2ViX3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAq CisgKiBSZXRyaWV2ZXMgdGhlICNTb3VwU2Vzc2lvbiBvZiB0aGUgdmlldy4gTm90ZSB0aGF0IHRo ZQorICogc2Vzc2lvbiBmZWF0dXJlcyBhcmUgYWRkZWQgYnkgV2ViS2l0IG9uIGRlbWFuZCwgc28g aWYKKyAqIHlvdSBpbnNlcnQgZm9yIHlvdXIgb3duICNTb3VwQ29va2llSmFyIGJlZm9yZSBhbnkg bmV0d29yaworICogdHJhZmZpYyBvY2N1cnMsIFdlYktpdCB3aWxsIHVzZSBpdCBpbnN0ZWFkIG9m IHRoZSBkZWZhdWx0LgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlICNTb3VwU2Vzc2lvbiBvZiB0 aGUgdmlldworICoKKyAqIFNpbmNlOiAxLjAuMworICovCitTb3VwU2Vzc2lvbiogd2Via2l0X3dl Yl92aWV3X2dldF9zZXNzaW9uIChXZWJLaXRXZWJWaWV3KiB3ZWJfdmlldykKK3sKKyAgICBnX3Jl dHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViX3ZpZXcpLCBOVUxMKTsKKwor ICAgIHJldHVybiBSZXNvdXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbigpOworfQorCiB9CmRpZmYgLS1n aXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmgKaW5kZXggZDczNzY1OC4uZDM2OGQwNyAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuaApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3 ZWJiYWNrZm9yd2FyZGxpc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViaGlzdG9yeWl0 ZW0uaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4KKyNpbmNsdWRlIDxs aWJzb3VwL3NvdXAuaD4KIAogR19CRUdJTl9ERUNMUwogCkBAIC0yODQsNiArMjg1LDkgQEAgV0VC S0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tICAgICAg ICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgICAgICAgICAgICBmdWxs X2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3ZWJraXRfd2ViX3Zp ZXdfZ2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAqd2ViX3Zp ZXcpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0dO VW1ha2VmaWxlLmFtIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KaW5kZXggMDQ5YjExZi4u NjExODI1MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KKysrIGIvV2Vi S2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KQEAgLTIwLDYgKzIwLDcgQEAgUHJvZ3JhbXNfR3RrTGF1 bmNoZXJfQ0ZMQUdTID0gXAogCS1mbm8tc3RyaWN0LWFsaWFzaW5nIFwKIAktTzIgXAogCSQoZ2xv YmFsX2NmbGFncykgXAorCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFBy b2dyYW1zX0d0a0xhdW5jaGVyX0xEQUREID0gXApAQCAtNjcsNiArNjgsNyBAQCBQcm9ncmFtc19E dW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTE9CQUxE RVBTX0NGTEFHUykgXAogCSQoQ0FJUk9fQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykgXAog CSQoR1RLX0NGTEFHUykKIAogUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfTERBREQgPSBcCmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMgYi9XZWJLaXRUb29scy9HdGtM YXVuY2hlci9tYWluLmMKaW5kZXggOGVkMjY5MC4uMzhjYjVlYyAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCisrKyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21h aW4uYwpAQCAtMTgyLDYgKzE4Miw4IEBAIGNyZWF0ZV93aW5kb3cgKCkKIGludAogbWFpbiAoaW50 IGFyZ2MsIGNoYXIqIGFyZ3ZbXSkKIHsKKyAgICBpZiAoIWdfdGhyZWFkX3N1cHBvcnRlZCAoKSkK KyAgICAgICAgZ190aHJlYWRfaW5pdCAoTlVMTCk7CiAgICAgZ3RrX2luaXQgKCZhcmdjLCAmYXJn dik7CiAKICAgICBHdGtXaWRnZXQqIHZib3ggPSBndGtfdmJveF9uZXcgKEZBTFNFLCAwKTsKZGlm ZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYwppbmRleCA0ZTRkOWY5Li4xYjYx YmRmIDEwMDY0NAotLS0gYS9jb25maWd1cmUuYWMKKysrIGIvY29uZmlndXJlLmFjCkBAIC0yODYs MjAgKzI4Niw2IEBAIGlmIHRlc3QgIiR3aXRoX2hpbGRvbiIgPSAieWVzIjsgdGhlbgogICAgIEFD X1NVQlNUKFtISUxET05fTElCU10pCiBmaQogCi0jIGRldGVybWluZSB0aGUgaHR0cCBiYWNrZW5k Ci1BQ19NU0dfQ0hFQ0tJTkcoW3RoZSBIVFRQIGJhY2tlbmQgdG8gdXNlXSkKLUFDX0FSR19XSVRI KGh0dHBfYmFja2VuZCwKLSAgICAgICAgICAgIEFDX0hFTFBfU1RSSU5HKFstLXdpdGgtaHR0cC1i YWNrZW5kPUA8OkBjdXJsL3NvdXBAOj5AXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIFtT ZWxlY3QgSFRUUCBiYWNrZW5kIFtkZWZhdWx0PWN1cmxdXSksCi0gICAgICAgICAgICBbXSxbd2l0 aF9odHRwX2JhY2tlbmQ9ImN1cmwiXSkKLQotY2FzZSAiJHdpdGhfaHR0cF9iYWNrZW5kIiBpbgot ICAgICBjdXJsfHNvdXApIDs7Ci0gICAgICopIEFDX01TR19FUlJPUihbSW52YWxpZCBIVFRQIGJh Y2tlbmQ6IG11c3QgYmUgY3VybCwgc291cC5dKSA7OwotZXNhYwotCi1BQ19NU0dfUkVTVUxUKFsk d2l0aF9odHRwX2JhY2tlbmRdKQotCiAjIG1pbmltdW0gYmFzZSBkZXBlbmRlbmNpZXMKIENBSVJP X1JFUVVJUkVEX1ZFUlNJT049MS4yCiBGT05UQ09ORklHX1JFUVVJUkVEX1ZFUlNJT049Mi40CkBA IC0zMTQsOCArMzAwLDcgQEAgUEFOR09fUkVRVUlSRURfVkVSU0lPTj0xLjAKIEdUS19SRVFVSVJF RF9WRVJTSU9OPTIuOAogCiAjIG9wdGlvbmFsIG1vZHVsZXMKLUxJQkNVUkxfUkVRVUlSRURfVkVS U0lPTj03LjE1Ci1MSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT049Mi4yMworTElCU09VUF9SRVFVSVJF RF9WRVJTSU9OPTIuMjUuNAogTElCWFNMVF9SRVFVSVJFRF9WRVJTSU9OPTEuMS43CiBTUUxJVEVf UkVRVUlSRURfVkVSU0lPTj0zLjAKIEdTVFJFQU1FUl9SRVFVSVJFRF9WRVJTSU9OPTAuMTAKQEAg LTYyNCwyMyArNjA5LDExIEBAIGVsc2UKICAgIENGTEFHUz0iJENGTEFHUyAtTzAiCiBmaQogCi0j IGNoZWNrIGlmIGN1cmwgaXMgYXZhaWxhYmxlCi1pZiB0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQi ID0gImN1cmwiOyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCQ1VSTF0sCi0gICAgICAg ICAgICAgICAgICAgICBbbGliY3VybCA+PSAkTElCQ1VSTF9SRVFVSVJFRF9WRVJTSU9OXSkKLSAg IGlmIHRlc3QgIiRvc193aW4zMiIgPSAieWVzIjsgdGhlbgotICAgICAgTElCQ1VSTF9MSUJTPSIk TElCQ1VSTF9MSUJTIC1sd3MyXzMyIgotICAgZmkKLSAgIEFDX1NVQlNUKFtMSUJDVVJMX0NGTEFH U10pCi0gICBBQ19TVUJTVChbTElCQ1VSTF9MSUJTXSkKLWZpCiAKLWlmIHRlc3QgIiR3aXRoX2h0 dHBfYmFja2VuZCIgPSAic291cCI7IHRoZW4KLSAgIFBLR19DSEVDS19NT0RVTEVTKFtMSUJTT1VQ XSwKLSAgICAgICAgICAgICAgICAgICAgIFtsaWJzb3VwLTIuNCA+PSAkTElCU09VUF9SRVFVSVJF RF9WRVJTSU9OXSkKLSAgIEFDX1NVQlNUKFtMSUJTT1VQX0NGTEFHU10pCi0gICBBQ19TVUJTVChb TElCU09VUF9MSUJTXSkKLWZpCitQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCU09VUF0sCisgICAgICAg ICAgICAgICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVRVUlSRURfVkVSU0lPTl0pCitB Q19TVUJTVChbTElCU09VUF9DRkxBR1NdKQorQUNfU1VCU1QoW0xJQlNPVVBfTElCU10pCiAKICMg Y2hlY2sgaWYgRnJlZVR5cGUvRm9udENvbmZpZyBhcmUgYXZhaWxhYmxlCiBpZiB0ZXN0ICIkd2l0 aF9mb250X2JhY2tlbmQiID0gImZyZWV0eXBlIjsgdGhlbgpAQCAtNzEyLDEwICs2ODUsNiBAQCBB TV9DT05ESVRJT05BTChbVEFSR0VUX1dJTjMyXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAid2lu MzIiXSkKIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfUVVBUlRaXSwgW3Rlc3QgIiR3aXRoX3Rhcmdl dCIgPSAicXVhcnR6Il0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VUX0RJUkVDVEZCXSwgW3Rlc3Qg IiR3aXRoX3RhcmdldCIgPSAiZGlyZWN0ZmIiXSkKIAotIyBIVFRQIGJhY2tlbmQgY29uZGl0aW9u YWxzCi1BTV9DT05ESVRJT05BTChbVVNFX0NVUkxdLCBbdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5k IiA9ICJjdXJsIl0pCi1BTV9DT05ESVRJT05BTChbVVNFX1NPVVBdLCBbdGVzdCAiJHdpdGhfaHR0 cF9iYWNrZW5kIiA9ICJzb3VwIl0pCi0KICMgRm9udCBiYWNrZW5kIGNvbmRpdGlvbmFscwogQU1f Q09ORElUSU9OQUwoW1VTRV9GUkVFVFlQRV0sIFt0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0g ImZyZWV0eXBlIl0pCiBBTV9DT05ESVRJT05BTChbVVNFX1BBTkdPXSwgW3Rlc3QgIiR3aXRoX2Zv bnRfYmFja2VuZCIgPSAicGFuZ28iXSkKQEAgLTc2Miw3ICs3MzEsNiBAQCBCdWlsZCBjb25maWd1 cmF0aW9uOgogIEVuYWJsZSBHQ0MgYnVpbGQgb3B0aW1pemF0aW9uICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDogJGVuYWJsZV9vcHRpbWl6YXRpb25zCiAgQ29kZSBjb3ZlcmFnZSBzdXBwb3J0 ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkZW5hYmxlX2NvdmVyYWdlCiAg VW5pY29kZSBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg OiAkdW5pY29kZV9iYWNrZW5kCi0gSFRUUCBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9odHRwX2JhY2tlbmQKICBGb250IGJhY2tlbmQg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICR3aXRoX2ZvbnRf YmFja2VuZAogIE9wdGltaXplZCBtZW1vcnkgYWxsb2NhdG9yICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDogJGVuYWJsZV9mYXN0X21hbGxvYwogRmVhdHVyZXM6Cg== 26286 2008-12-28 16:43:55 -0800 2009-01-14 16:36:52 -0800 API to retrieve the soup session from the view #3 p.diff text/plain 20917 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCBmNDlhZDk2Li5kNTI1NDNmIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NDQsMzEgKzE3NDQsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzgyLDcgKzE3NTcsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXJDbGllbnQuaAppbmRleCA0ZDVlYTNhLi42MTYyZDIyIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50LmgKQEAgLTM0LDYgKzM0LDEwIEBACiAjaW5jbHVkZSA8d3RmL1BsYXRmb3JtLmg+ CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorI2VuZGlmCisKIHR5cGVkZWYgY2xhc3MgX2pvYmplY3QqIGpvYmpl Y3Q7CiAKICNpZiBQTEFURk9STShNQUMpICYmICFkZWZpbmVkKF9fT0JKQ19fKQpAQCAtMjA4LDYg KzIxMiw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogICAgICAgICB2aXJ0dWFsIE5T Q2FjaGVkVVJMUmVzcG9uc2UqIHdpbGxDYWNoZVJlc3BvbnNlKERvY3VtZW50TG9hZGVyKiwgdW5z aWduZWQgbG9uZyBpZGVudGlmaWVyLCBOU0NhY2hlZFVSTFJlc3BvbnNlKikgY29uc3QgPSAwOwog I2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgICAgICB2aXJ0dWFsIFNvdXBTZXNzaW9uKiBz ZXNzaW9uKCkgPSAwOworI2VuZGlmCiAKICAgICBwcm90ZWN0ZWQ6CiAgICAgICAgIHN0YXRpYyB2 b2lkIHRyYW5zaXRpb25Ub0NvbW1pdHRlZEZvck5ld1BhZ2UoRnJhbWUqLCBjb25zdCBJbnRTaXpl JiwgY29uc3QgQ29sb3ImLCBib29sKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9SZXNvdXJjZUhhbmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl SGFuZGxlLmgKaW5kZXggYzkzYWYyMS4uOWE2MWZmMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL1Jlc291cmNlSGFuZGxlLmgKQEAgLTMwLDYgKzMwLDEwIEBACiAjaW5jbHVkZSAiSFRUUEhl YWRlck1hcC5oIgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KIAorI2lmIFVTRShTT1VQKQorI2lu Y2x1ZGUgPGxpYnNvdXAvc291cC5oPgorI2VuZGlmCisKICNpZiBQTEFURk9STShDRikKIHR5cGVk ZWYgY29uc3Qgc3RydWN0IF9fQ0ZEYXRhICogQ0ZEYXRhUmVmOwogI2VuZGlmCkBAIC0xNTksNiAr MTYzLDEwIEBAIHB1YmxpYzoKICAgICBSZXNvdXJjZUhhbmRsZUludGVybmFsKiBnZXRJbnRlcm5h bCgpIHsgcmV0dXJuIGQuZ2V0KCk7IH0KICNlbmRpZgogCisjaWYgVVNFKFNPVVApCisgICAgc3Rh dGljIFNvdXBTZXNzaW9uKiBnZXRTZXNzaW9uKGNvbnN0IEZyYW1lICpmcmFtZSk7CisjZW5kaWYK KwogICAgIC8vIFVzZWQgdG8gd29yayBhcm91bmQgdGhlIGZhY3QgdGhhdCB5b3UgZG9uJ3QgZ2V0 IGFueSBtb3JlIE5TVVJMQ29ubmVjdGlvbiBjYWxsYmFja3MgdW50aWwgeW91IHJldHVybiBmcm9t IHRoZSBvbmUgeW91J3JlIGluLgogICAgIHN0YXRpYyBib29sIGxvYWRzQmxvY2tlZCgpOyAgICAK ICAgICAKQEAgLTE3OCw3ICsxODYsNyBAQCBwdWJsaWM6CiBwcml2YXRlOgogI2lmIFVTRShTT1VQ KQogICAgIGJvb2wgc3RhcnREYXRhKFN0cmluZyB1cmxTdHJpbmcpOwotICAgIGJvb2wgc3RhcnRI dHRwKFN0cmluZyB1cmxTdHJpbmcpOworICAgIGJvb2wgc3RhcnRIdHRwKFNvdXBTZXNzaW9uKiBz ZXNzaW9uLCBTdHJpbmcgdXJsU3RyaW5nKTsKICAgICBib29sIHN0YXJ0R2lvKFN0cmluZyB1cmxT dHJpbmcpOwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUhhbmRsZUludGVybmFsLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGVJbnRlcm5hbC5oCmluZGV4IDVhZGEyZjUuLjk4NjU0ODggMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgKKysrIGIvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaApAQCAtMTc3LDYg KzE3Nyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICAgICAgVmVjdG9yPGNoYXI+IG1fcG9z dEJ5dGVzOwogI2VuZGlmCiAjaWYgVVNFKFNPVVApCisgICAgICAgIFNvdXBTZXNzaW9uKiBtX3Nl c3Npb247CiAgICAgICAgIFNvdXBNZXNzYWdlKiBtX21zZzsKICAgICAgICAgUmVzb3VyY2VSZXNw b25zZSBtX3Jlc3BvbnNlOwogICAgICAgICBib29sIG1fY2FuY2VsbGVkOwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAgYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRleCA4ODEwOWU4Li5l NjQ3ZTIxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVK YXJTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJT b3VwLmNwcApAQCAtMjIsMTggKzIyLDI4IEBACiAKICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5j bHVkZSAiS1VSTC5oIgorI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIu aCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVudC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKLVNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpCitTb3VwQ29va2llSmFyKiBnZXRDb29r aWVKYXIoY29uc3QgRG9jdW1lbnQqIGRvY3VtZW50KQogewotICAgIHN0YXRpYyBTb3VwQ29va2ll SmFyKiBqYXIgPSBzb3VwX2Nvb2tpZV9qYXJfbmV3KCk7CisgICAgRnJhbWUgKmZyYW1lID0gZG9j dW1lbnQtPmZyYW1lKCk7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAg RnJhbWVMb2FkZXIgKmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikK KyAgICAgICAgcmV0dXJuIDA7CisgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2Fz dDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAg U291cENvb2tpZUphciogamFyID0gKFNvdXBDb29raWVKYXIqKXNvdXBfc2Vzc2lvbl9nZXRfZmVh dHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfQ09PS0lFX0pBUik7CiAgICAgcmV0dXJuIGphcjsKIH0K IAotdm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVy bCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwqLywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3ZvaWQg c2V0Q29va2llcyhEb2N1bWVudCogZG9jdW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VS TCYgLypwb2xpY3lVUkwqLywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKIHsKLSAgICBTb3VwQ29va2ll SmFyKiBqYXIgPSBnZXRDb29raWVKYXIoKTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRD b29raWVKYXIoZG9jdW1lbnQpOwogICAgIGlmICghamFyKQogICAgICAgICByZXR1cm47CiAKQEAg LTQzLDkgKzUzLDkgQEAgdm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNv bnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwKICAgICBzb3VwX3VyaV9mcmVl KG9yaWdpbik7CiB9CiAKLVN0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiAvKmRvY3VtZW50 Ki8sIGNvbnN0IEtVUkwmIHVybCkKK1N0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiBkb2N1 bWVudCwgY29uc3QgS1VSTCYgdXJsKQogewotICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENv b2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcihkb2N1bWVu dCk7CiAgICAgaWYgKCFqYXIpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKIApAQCAtNTksOSAr NjksOSBAQCBTdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25z dCBLVVJMJiB1cmwpCiAgICAgcmV0dXJuIHJlc3VsdDsKIH0KIAotYm9vbCBjb29raWVzRW5hYmxl ZChjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovKQorYm9vbCBjb29raWVzRW5hYmxlZChjb25z dCBEb2N1bWVudCogZG9jdW1lbnQpCiB7Ci0gICAgcmV0dXJuIGdldENvb2tpZUphcigpOworICAg IHJldHVybiBnZXRDb29raWVKYXIoZG9jdW1lbnQpOwogfQogCiB9CmRpZmYgLS1naXQgYS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uNmU1MTY5MiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5o CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaApAQCAt MzEsNyArMzEsNyBAQAogI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7Ci0gICAgU291cENvb2tpZUphciogZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tp ZUphciogZ2V0Q29va2llSmFyKGNvbnN0IERvY3VtZW50KiBkb2N1bWVudCk7CiB9CiAKICNlbmRp ZgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5k bGVTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxl U291cC5jcHAKaW5kZXggNWZkM2E0ZC4uOWU2MTFiZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0yNyw2ICsyNyw4 IEBACiAjaW5jbHVkZSAiQ29va2llSmFyU291cC5oIgogI2luY2x1ZGUgIkRvY0xvYWRlci5oIgog I2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJG cmFtZUxvYWRlckNsaWVudC5oIgogI2luY2x1ZGUgIkhUVFBQYXJzZXJzLmgiCiAjaW5jbHVkZSAi TUlNRVR5cGVSZWdpc3RyeS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCkBAIC00OCw4 ICs1MCw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIFNvdXBTZXNzaW9uKiBz ZXNzaW9uID0gMDsKLQogZW51bQogewogICAgIEVSUk9SX1RSQU5TUE9SVCwKQEAgLTE2NCw2ICsx NjQsNyBAQCBzdGF0aWMgdm9pZCBmaW5pc2hlZENhbGxiYWNrKFNvdXBTZXNzaW9uICpzZXNzaW9u LCBTb3VwTWVzc2FnZSogbXNnLCBncG9pbnRlciBkYQogCiAgICAgUmVzb3VyY2VIYW5kbGVJbnRl cm5hbCogZCA9IGhhbmRsZS0+Z2V0SW50ZXJuYWwoKTsKICAgICAvLyBUaGUgbWVzc2FnZSBoYXMg YmVlbiBoYW5kbGVkLgorICAgIGQtPm1fc2Vzc2lvbiA9IE5VTEw7CiAgICAgZC0+bV9tc2cgPSBO VUxMOwogCiAgICAgUmVzb3VyY2VIYW5kbGVDbGllbnQqIGNsaWVudCA9IGhhbmRsZS0+Y2xpZW50 KCk7CkBAIC0yNzAsMjIgKzI3MSwyOSBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydERhdGEo U3RyaW5nIHVybFN0cmluZykKICAgICAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgUmVzb3Vy Y2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQorc3RhdGljIHZvaWQgZW5zdXJl U2Vzc2lvbihTb3VwU2Vzc2lvbiogc2Vzc2lvbikKIHsKLSAgICBpZiAoIXNlc3Npb24pIHsKLSAg ICAgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKLQotICAgICAgICBzb3Vw X3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNTSU9OX0ZFQVRVUkUoZ2V0Q29v a2llSmFyKCkpKTsKLQotICAgICAgICBjb25zdCBjaGFyKiBzb3VwX2RlYnVnID0gZ19nZXRlbnYo IldFQktJVF9TT1VQX0xPR0dJTkciKTsKLSAgICAgICAgaWYgKHNvdXBfZGVidWcpIHsKLSAgICAg ICAgICAgIGludCBzb3VwX2RlYnVnX2xldmVsID0gYXRvaShzb3VwX2RlYnVnKTsKKyAgICBTb3Vw Q29va2llSmFyKiBqYXIgPSAwOworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1ZyA9IGdfZ2V0 ZW52KCJXRUJLSVRfREVCVUciKTsKKworICAgIGphciA9IChTb3VwQ29va2llSmFyKilzb3VwX3Nl c3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpOworICAgIGlm ICghamFyKSB7CisgICAgICAgIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKKyAgICAgICAg c291cF9zZXNzaW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfU0VTU0lPTl9GRUFUVVJFKGph cikpOworICAgICAgICBnX29iamVjdF91bnJlZihHX09CSkVDVChqYXIpKTsKKyAgICB9CiAKLSAg ICAgICAgICAgIFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2Fz dDxTb3VwTG9nZ2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2ZWwpLCAtMSk7Ci0gICAgICAgICAg ICBzb3VwX2xvZ2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKLSAgICAgICAgICAgIGdfb2Jq ZWN0X3VucmVmKGxvZ2dlcik7Ci0gICAgICAgIH0KKyAgICBpZiAoc291cF9zZXNzaW9uX2dldF9m ZWF0dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9MT0dHRVIpID09IE5VTEwKKyAgICAgICAgJiYgd2Vi a2l0X2RlYnVnICYmICFzdHJjbXAod2Via2l0X2RlYnVnLCAibmV0d29yayIpKSB7CisgICAgICAg IFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9n Z2VyTG9nTGV2ZWw+KFNPVVBfTE9HR0VSX0xPR19CT0RZKSwgLTEpOworICAgICAgICBzb3VwX2xv Z2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobG9n Z2VyKTsKICAgICB9Cit9CisKK2Jvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTb3VwU2Vz c2lvbiogc2Vzc2lvbiwgU3RyaW5nIHVybFN0cmluZykKK3sKKyAgICBlbnN1cmVTZXNzaW9uKHNl c3Npb24pOwogCiAgICAgU291cE1lc3NhZ2UqIG1zZzsKICAgICBtc2cgPSBzb3VwX21lc3NhZ2Vf bmV3KHJlcXVlc3QoKS5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0Zjgo KS5kYXRhKCkpOwpAQCAtMzE2LDggKzMyNCw5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0 SHR0cChTdHJpbmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg U09VUF9NRU1PUllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICB9CiAKKyAg ICBkLT5tX3Nlc3Npb24gPSBzdGF0aWNfY2FzdDxTb3VwU2Vzc2lvbio+KGdfb2JqZWN0X3JlZihz ZXNzaW9uKSk7CiAgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2Jq ZWN0X3JlZihtc2cpKTsKLSAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBk LT5tX21zZywgZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CisgICAgc291cF9zZXNzaW9uX3F1ZXVl X21lc3NhZ2Uoc2Vzc2lvbiwgbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKIAogICAgIHJl dHVybiB0cnVlOwogfQpAQCAtMzM4LDcgKzM0Nyw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0 YXJ0KEZyYW1lKiBmcmFtZSkKICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJk YXRhIikpCiAgICAgICAgIHJldHVybiBzdGFydERhdGEodXJsU3RyaW5nKTsKICAgICBlbHNlIGlm IChlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImh0dHAiKSB8fCBlcXVhbElnbm9yaW5nQ2Fz ZShwcm90b2NvbCwgImh0dHBzIikpCi0gICAgICAgIHJldHVybiBzdGFydEh0dHAodXJsU3RyaW5n KTsKKyAgICAgICAgcmV0dXJuIHN0YXJ0SHR0cChnZXRTZXNzaW9uKGZyYW1lKSwgdXJsU3RyaW5n KTsKICAgICBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZpbGUiKSB8fCBl cXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZ0cCIpIHx8IGVxdWFsSWdub3JpbmdDYXNlKHBy b3RvY29sLCAiZnRwcyIpKQogICAgICAgICAvLyBGSVhNRTogc2hvdWxkIHdlIGJlIGRvaW5nIGFu eSBvdGhlciBwcm90b2NvbHMgaGVyZT8KICAgICAgICAgcmV0dXJuIHN0YXJ0R2lvKHVybFN0cmlu Zyk7CkBAIC0zNTYsNyArMzY1LDcgQEAgdm9pZCBSZXNvdXJjZUhhbmRsZTo6Y2FuY2VsKCkKIHsK ICAgICBkLT5tX2NhbmNlbGxlZCA9IHRydWU7CiAgICAgaWYgKGQtPm1fbXNnKSB7Ci0gICAgICAg IHNvdXBfc2Vzc2lvbl9jYW5jZWxfbWVzc2FnZShzZXNzaW9uLCBkLT5tX21zZywgU09VUF9TVEFU VVNfQ0FOQ0VMTEVEKTsKKyAgICAgICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKGQtPm1f c2Vzc2lvbiwgZC0+bV9tc2csIFNPVVBfU1RBVFVTX0NBTkNFTExFRCk7CiAgICAgICAgIC8vIEZv ciByZS1lbnRyYW5jeSB0cm91YmxlcyB3ZSBjYWxsIGRpZEZpbmlzaExvYWRpbmcgd2hlbiB0aGUg bWVzc2FnZSBoYXNuJ3QgYmVlbiBoYW5kbGVkIHlldC4KICAgICAgICAgZC0+Y2xpZW50KCktPmRp ZEZpbmlzaExvYWRpbmcodGhpcyk7CiAgICAgfSBlbHNlIGlmIChkLT5tX2NhbmNlbGxhYmxlKSB7 CkBAIC01ODcsNSArNTk2LDE2IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0R2lvKFN0cmlu ZyB1cmxTdHJpbmcpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKK1NvdXBTZXNzaW9uKiBSZXNvdXJj ZUhhbmRsZTo6Z2V0U2Vzc2lvbihjb25zdCBGcmFtZSAqZnJhbWUpCit7CisgICAgaWYgKCFmcmFt ZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgRnJhbWVMb2FkZXIgKmxvYWRlciA9IGZyYW1lLT5s b2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0dXJuIDA7CisgICAgU291cFNl c3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+ Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAgcmV0dXJuIHNlc3Npb247Cit9CisKIH0KIApkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaCBiL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmgKaW5kZXggMTZhMGQ4Zi4u MWRlYTRlMSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGll bnRHdGsuaAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5o CkBAIC0yMiw2ICsyMiw3IEBACiAKICNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNsdWRl ICJLVVJMLmgiCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIHR5cGVkZWYgc3RydWN0IF9X ZWJLaXRXZWJWaWV3IFdlYktpdFdlYlZpZXc7CiAKQEAgLTMxLDYgKzMyLDcgQEAgbmFtZXNwYWNl IFdlYktpdCB7CiAgICAgcHVibGljOgogICAgICAgICBDaHJvbWVDbGllbnQoV2ViS2l0V2ViVmll dyopOwogICAgICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KCkgY29uc3QgeyByZXR1cm4gbV93 ZWJWaWV3OyB9CisgICAgICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uKCk7CiAKICAgICAgICAgdmly dHVhbCB2b2lkIGNocm9tZURlc3Ryb3llZCgpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IGI5ZDRlODMuLjRkZmZmNzkg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRH dGsuY3BwCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRH dGsuY3BwCkBAIC04NzMsNCArODczLDEyIEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnRyYW5z aXRpb25Ub0NvbW1pdHRlZEZvck5ld1BhZ2UoKQogICAgIGZyYW1lLT52aWV3KCktPnNldEd0a0Fk anVzdG1lbnRzKHByaXYtPmhvcml6b250YWxBZGp1c3RtZW50LCBwcml2LT52ZXJ0aWNhbEFkanVz dG1lbnQpOwogfQogCitTb3VwU2Vzc2lvbiogRnJhbWVMb2FkZXJDbGllbnQ6OnNlc3Npb24oKQor eworICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogbV9zZXNzaW9uID0gMDsKKyAgICBpZiAoIW1fc2Vz c2lvbikKKyAgICAgICAgbV9zZXNzaW9uID0gc291cF9zZXNzaW9uX2FzeW5jX25ldyAoKTsKKyAg ICByZXR1cm4gbV9zZXNzaW9uOworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNv cmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmggYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBw b3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKaW5kZXggYzY5NTJkYi4uZTVmYzIyMyAxMDA2NDQK LS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCisr KyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaApAQCAt MzQsNiArMzQsNyBAQAogI2luY2x1ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJQ bHVnaW5WaWV3LmgiCiAjaW5jbHVkZSAid2Via2l0d2VicG9saWN5ZGVjaXNpb24uaCIKKyNpbmNs dWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkZyYW1lIFdl YktpdFdlYkZyYW1lOwogCkBAIC0xNjksNiArMTcwLDggQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAK ICAgICAgICAgdmlydHVhbCBib29sIGNhbkNhY2hlUGFnZSgpIGNvbnN0OwogICAgICAgICB2aXJ0 dWFsIHZvaWQgZG93bmxvYWQoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGUqLCBjb25zdCBXZWJDb3Jl OjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25z dCBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlJik7CisKKyAgICAgICAgdmlydHVhbCBTb3VwU2Vz c2lvbiogc2Vzc2lvbigpOwogICAgIHByaXZhdGU6CiAgICAgICAgIFdlYktpdFdlYkZyYW1lKiBt X2ZyYW1lOwogICAgICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIG1fcmVzcG9uc2U7CmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBj LmluCmluZGV4IDBjZTZmNzEuLjg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0 LnBjLmluCisrKyBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNs dWRlZGlyPUBpbmNsdWRlZGlyQAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRl bnQgZW5naW5lIGZvciBHVEsrCiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIu MAorUmVxdWlyZXM6IGd0aystMi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdl YmtpdC0xLjAKIENmbGFnczogLUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0d2Vidmlldy5jcHAKaW5kZXggZTk4ZDNmNy4uYzhjYzhkMiAxMDA2NDQKLS0tIGEvV2Vi S2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQv d2Via2l0d2Vidmlldy5jcHAKQEAgLTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQYXN0ZWJvYXJk SGVscGVyLmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAi UGxhdGZvcm1XaGVlbEV2ZW50LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNs dWRlICJTY3JpcHRWYWx1ZS5oIgogI2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlN1 YnN0aXR1dGVEYXRhLmgiCkBAIC0xMTMsNyArMTE0LDggQEAgZW51bSB7CiAgICAgUFJPUF9XSU5E T1dfRkVBVFVSRVMsCiAgICAgUFJPUF9UUkFOU1BBUkVOVCwKICAgICBQUk9QX1pPT01fTEVWRUws Ci0gICAgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTQorICAgIFBST1BfRlVMTF9DT05URU5UX1pPT00s CisgICAgUFJPUF9TRVNTSU9OLAogfTsKIAogc3RhdGljIGd1aW50IHdlYmtpdF93ZWJfdmlld19z aWduYWxzW0xBU1RfU0lHTkFMXSA9IHsgMCwgfTsKQEAgLTI3MSw2ICsyNzMsOSBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQg cHJvcF9pZCwgR1ZhbHVlKgogICAgIGNhc2UgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTToKICAgICAg ICAgZ192YWx1ZV9zZXRfYm9vbGVhbih2YWx1ZSwgd2Via2l0X3dlYl92aWV3X2dldF9mdWxsX2Nv bnRlbnRfem9vbSh3ZWJWaWV3KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9TRVNT SU9OOgorICAgICAgICBnX3ZhbHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF93ZWJfdmlld19n ZXRfc2Vzc2lvbih3ZWJWaWV3KSk7CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAg ICAgIEdfT0JKRUNUX1dBUk5fSU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBz cGVjKTsKICAgICB9CkBAIC0xNTA1LDYgKzE1MTAsMjAgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dl Yl92aWV3X2NsYXNzX2luaXQoV2ViS2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGQUxT RSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFdFQktJVF9QQVJBTV9SRUFEV1JJVEUpKTsKIAorICAgIC8qKgorICAgICogV2ViS2l0V2Vi VmlldzpzZXNzaW9uOgorICAgICoKKyAgICAqIFJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUg dmlldy4KKyAgICAqCisgICAgKiBTaW5jZTogMS4wLjMKKyAgICAqLworICAgIGdfb2JqZWN0X2Ns YXNzX2luc3RhbGxfcHJvcGVydHkob2JqZWN0Q2xhc3MsIFBST1BfU0VTU0lPTiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdfcGFyYW1fc3BlY19vYmplY3QoInNlc3Npb24i LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAiU2Vzc2lvbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICJSZXRyaWV2ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXciLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX1RZ UEVfU0VTU0lPTiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURBQkxFKSk7CisKICAgICBnX3R5cGVfY2xhc3Nf YWRkX3ByaXZhdGUod2ViVmlld0NsYXNzLCBzaXplb2YoV2ViS2l0V2ViVmlld1ByaXZhdGUpKTsK IH0KIApAQCAtMjU5Myw0ICsyNjEyLDI1IEBAIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldF9mdWxs X2NvbnRlbnRfem9vbShXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3LCBnYm9vbGVhbiB6b29tCiAgICAg Z19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHdlYlZpZXcpLCAiZnVsbC1jb250ZW50LXpvb20iKTsK IH0KIAorLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb246CisgKiBAd2ViX3ZpZXc6 IGEgI1dlYktpdFdlYlZpZXcKKyAqCisgKiBSZXRyaWV2ZXMgdGhlICNTb3VwU2Vzc2lvbiBvZiB0 aGUgdmlldy4KKyAqCisgKiBUaGUgc2Vzc2lvbiBpcyBpbml0aWFsbHkgZW1wdHkuIFVwb24gdGhl IGZpcnN0IGxvYWQKKyAqIGEgY29va2llIGphciB3aWxsIGJlIGFkZGVkLiBIb3dldmVyIHlvdSBj YW4KKyAqIGFkZCB5b3VyIG93biBjb29raWUgamFyIGFuZCBXZWJLaXQgd2lsbCB1c2UgaXQuCisg KgorICogUmV0dXJuIHZhbHVlOiB0aGUgI1NvdXBTZXNzaW9uIG9mIHRoZSB2aWV3CisgKgorICog U2luY2U6IDEuMC4zCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Np b24gKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7CisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwo V0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZpZXcpLCBOVUxMKTsKKworICAgIHJldHVybiBSZXNvdXJj ZUhhbmRsZTo6Z2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnByaXYtPm1haW5GcmFtZSkpOworfQor CiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKaW5kZXggZDczNzY1OC4uZDM2OGQwNyAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPHdl YmtpdC93ZWJraXR3ZWJiYWNrZm9yd2FyZGxpc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0 d2ViaGlzdG9yeWl0ZW0uaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4K KyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogR19CRUdJTl9ERUNMUwogCkBAIC0yODQsNiAr Mjg1LDkgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVu dF96b29tICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAgICAg ICAgICAgICBmdWxsX2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3 ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2Vi VmlldyAqd2ViX3ZpZXcpOworCiBHX0VORF9ERUNMUwogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dl YktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KaW5k ZXggMDQ5YjExZi4uNjExODI1MyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUu YW0KKysrIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KQEAgLTIwLDYgKzIwLDcgQEAgUHJv Z3JhbXNfR3RrTGF1bmNoZXJfQ0ZMQUdTID0gXAogCS1mbm8tc3RyaWN0LWFsaWFzaW5nIFwKIAkt TzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAorCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19D RkxBR1MpCiAKIFByb2dyYW1zX0d0a0xhdW5jaGVyX0xEQUREID0gXApAQCAtNjcsNiArNjgsNyBA QCBQcm9ncmFtc19EdW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBcCiAJJChnbG9iYWxfY2ZsYWdzKSBc CiAJJChHTE9CQUxERVBTX0NGTEFHUykgXAogCSQoQ0FJUk9fQ0ZMQUdTKSBcCisJJChMSUJTT1VQ X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykKIAogUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfTERB REQgPSBcCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMgYi9XZWJL aXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKaW5kZXggOGVkMjY5MC4uMzhjYjVlYyAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCisrKyBiL1dlYktpdFRvb2xzL0d0 a0xhdW5jaGVyL21haW4uYwpAQCAtMTgyLDYgKzE4Miw4IEBAIGNyZWF0ZV93aW5kb3cgKCkKIGlu dAogbWFpbiAoaW50IGFyZ2MsIGNoYXIqIGFyZ3ZbXSkKIHsKKyAgICBpZiAoIWdfdGhyZWFkX3N1 cHBvcnRlZCAoKSkKKyAgICAgICAgZ190aHJlYWRfaW5pdCAoTlVMTCk7CiAgICAgZ3RrX2luaXQg KCZhcmdjLCAmYXJndik7CiAKICAgICBHdGtXaWRnZXQqIHZib3ggPSBndGtfdmJveF9uZXcgKEZB TFNFLCAwKTsKZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYwppbmRleCA0 ZTRkOWY5Li4xYjYxYmRmIDEwMDY0NAotLS0gYS9jb25maWd1cmUuYWMKKysrIGIvY29uZmlndXJl LmFjCkBAIC0yODYsMjAgKzI4Niw2IEBAIGlmIHRlc3QgIiR3aXRoX2hpbGRvbiIgPSAieWVzIjsg dGhlbgogICAgIEFDX1NVQlNUKFtISUxET05fTElCU10pCiBmaQogCi0jIGRldGVybWluZSB0aGUg aHR0cCBiYWNrZW5kCi1BQ19NU0dfQ0hFQ0tJTkcoW3RoZSBIVFRQIGJhY2tlbmQgdG8gdXNlXSkK LUFDX0FSR19XSVRIKGh0dHBfYmFja2VuZCwKLSAgICAgICAgICAgIEFDX0hFTFBfU1RSSU5HKFst LXdpdGgtaHR0cC1iYWNrZW5kPUA8OkBjdXJsL3NvdXBAOj5AXSwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgIFtTZWxlY3QgSFRUUCBiYWNrZW5kIFtkZWZhdWx0PWN1cmxdXSksCi0gICAgICAg ICAgICBbXSxbd2l0aF9odHRwX2JhY2tlbmQ9ImN1cmwiXSkKLQotY2FzZSAiJHdpdGhfaHR0cF9i YWNrZW5kIiBpbgotICAgICBjdXJsfHNvdXApIDs7Ci0gICAgICopIEFDX01TR19FUlJPUihbSW52 YWxpZCBIVFRQIGJhY2tlbmQ6IG11c3QgYmUgY3VybCwgc291cC5dKSA7OwotZXNhYwotCi1BQ19N U0dfUkVTVUxUKFskd2l0aF9odHRwX2JhY2tlbmRdKQotCiAjIG1pbmltdW0gYmFzZSBkZXBlbmRl bmNpZXMKIENBSVJPX1JFUVVJUkVEX1ZFUlNJT049MS4yCiBGT05UQ09ORklHX1JFUVVJUkVEX1ZF UlNJT049Mi40CkBAIC0zMTQsOCArMzAwLDcgQEAgUEFOR09fUkVRVUlSRURfVkVSU0lPTj0xLjAK IEdUS19SRVFVSVJFRF9WRVJTSU9OPTIuOAogCiAjIG9wdGlvbmFsIG1vZHVsZXMKLUxJQkNVUkxf UkVRVUlSRURfVkVSU0lPTj03LjE1Ci1MSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT049Mi4yMworTElC U09VUF9SRVFVSVJFRF9WRVJTSU9OPTIuMjUuNAogTElCWFNMVF9SRVFVSVJFRF9WRVJTSU9OPTEu MS43CiBTUUxJVEVfUkVRVUlSRURfVkVSU0lPTj0zLjAKIEdTVFJFQU1FUl9SRVFVSVJFRF9WRVJT SU9OPTAuMTAKQEAgLTYyNCwyMyArNjA5LDExIEBAIGVsc2UKICAgIENGTEFHUz0iJENGTEFHUyAt TzAiCiBmaQogCi0jIGNoZWNrIGlmIGN1cmwgaXMgYXZhaWxhYmxlCi1pZiB0ZXN0ICIkd2l0aF9o dHRwX2JhY2tlbmQiID0gImN1cmwiOyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCQ1VS TF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGliY3VybCA+PSAkTElCQ1VSTF9SRVFVSVJFRF9W RVJTSU9OXSkKLSAgIGlmIHRlc3QgIiRvc193aW4zMiIgPSAieWVzIjsgdGhlbgotICAgICAgTElC Q1VSTF9MSUJTPSIkTElCQ1VSTF9MSUJTIC1sd3MyXzMyIgotICAgZmkKLSAgIEFDX1NVQlNUKFtM SUJDVVJMX0NGTEFHU10pCi0gICBBQ19TVUJTVChbTElCQ1VSTF9MSUJTXSkKLWZpCiAKLWlmIHRl c3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAic291cCI7IHRoZW4KLSAgIFBLR19DSEVDS19NT0RV TEVTKFtMSUJTT1VQXSwKLSAgICAgICAgICAgICAgICAgICAgIFtsaWJzb3VwLTIuNCA+PSAkTElC U09VUF9SRVFVSVJFRF9WRVJTSU9OXSkKLSAgIEFDX1NVQlNUKFtMSUJTT1VQX0NGTEFHU10pCi0g ICBBQ19TVUJTVChbTElCU09VUF9MSUJTXSkKLWZpCitQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCU09V UF0sCisgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVRVUlSRURf VkVSU0lPTl0pCitBQ19TVUJTVChbTElCU09VUF9DRkxBR1NdKQorQUNfU1VCU1QoW0xJQlNPVVBf TElCU10pCiAKICMgY2hlY2sgaWYgRnJlZVR5cGUvRm9udENvbmZpZyBhcmUgYXZhaWxhYmxlCiBp ZiB0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gImZyZWV0eXBlIjsgdGhlbgpAQCAtNzEyLDEw ICs2ODUsNiBAQCBBTV9DT05ESVRJT05BTChbVEFSR0VUX1dJTjMyXSwgW3Rlc3QgIiR3aXRoX3Rh cmdldCIgPSAid2luMzIiXSkKIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfUVVBUlRaXSwgW3Rlc3Qg IiR3aXRoX3RhcmdldCIgPSAicXVhcnR6Il0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VUX0RJUkVD VEZCXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAiZGlyZWN0ZmIiXSkKIAotIyBIVFRQIGJhY2tl bmQgY29uZGl0aW9uYWxzCi1BTV9DT05ESVRJT05BTChbVVNFX0NVUkxdLCBbdGVzdCAiJHdpdGhf aHR0cF9iYWNrZW5kIiA9ICJjdXJsIl0pCi1BTV9DT05ESVRJT05BTChbVVNFX1NPVVBdLCBbdGVz dCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJzb3VwIl0pCi0KICMgRm9udCBiYWNrZW5kIGNvbmRp dGlvbmFscwogQU1fQ09ORElUSU9OQUwoW1VTRV9GUkVFVFlQRV0sIFt0ZXN0ICIkd2l0aF9mb250 X2JhY2tlbmQiID0gImZyZWV0eXBlIl0pCiBBTV9DT05ESVRJT05BTChbVVNFX1BBTkdPXSwgW3Rl c3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAicGFuZ28iXSkKQEAgLTc2Miw3ICs3MzEsNiBAQCBC dWlsZCBjb25maWd1cmF0aW9uOgogIEVuYWJsZSBHQ0MgYnVpbGQgb3B0aW1pemF0aW9uICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9vcHRpbWl6YXRpb25zCiAgQ29kZSBjb3Zl cmFnZSBzdXBwb3J0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkZW5hYmxl X2NvdmVyYWdlCiAgVW5pY29kZSBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgOiAkdW5pY29kZV9iYWNrZW5kCi0gSFRUUCBiYWNrZW5kICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9odHRwX2JhY2tlbmQKICBG b250IGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6 ICR3aXRoX2ZvbnRfYmFja2VuZAogIE9wdGltaXplZCBtZW1vcnkgYWxsb2NhdG9yICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9mYXN0X21hbGxvYwogRmVhdHVyZXM6Cg== 26736 2009-01-14 16:36:52 -0800 2009-01-14 18:29:14 -0800 API to retrieve and set soup sessions #4 p.diff text/plain 23436 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAzMDMyZDI2Li45Njk0NGVjIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NTUsMzEgKzE3NTUsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzkzLDcgKzE3NjgsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXJDbGllbnQuaAppbmRleCA0NGFiNGE0Li4yMmJhMjhiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50LmgKQEAgLTM1LDYgKzM1LDEwIEBACiAjaW5jbHVkZSA8d3RmL1BsYXRmb3JtLmg+ CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorI2VuZGlmCisKIHR5cGVkZWYgY2xhc3MgX2pvYmplY3QqIGpvYmpl Y3Q7CiAKICNpZiBQTEFURk9STShNQUMpICYmICFkZWZpbmVkKF9fT0JKQ19fKQpAQCAtMjA5LDYg KzIxMywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjZW5kaWYKICAgICAgICAgdmlydHVhbCBO U0NhY2hlZFVSTFJlc3BvbnNlKiB3aWxsQ2FjaGVSZXNwb25zZShEb2N1bWVudExvYWRlciosIHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllciwgTlNDYWNoZWRVUkxSZXNwb25zZSopIGNvbnN0ID0gMDsK ICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICAgICAgdmlydHVhbCBTb3VwU2Vzc2lvbiog c2Vzc2lvbigpID0gMDsKKwl2aXJ0dWFsIHZvaWQgc2V0U2Vzc2lvbihTb3VwU2Vzc2lvbiopID0g MDsKKyNlbmRpZgogCiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRVc2VQbHVnaW5Eb2N1bWVu dChjb25zdCBTdHJpbmcmIG1pbWVUeXBlKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IGM5M2FmMjEuLjE4M2Ux MDAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5o CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCkBAIC0zMCw2 ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlIDx3dGYvT3du UHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRp ZgorCiAjaWYgUExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0cnVjdCBfX0NGRGF0YSAqIENG RGF0YVJlZjsKICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMSBAQCBwdWJsaWM6CiAgICAgUmVzb3Vy Y2VIYW5kbGVJbnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVybiBkLmdldCgpOyB9CiAjZW5k aWYKIAorI2lmIFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbihj b25zdCBGcmFtZSAqZnJhbWUpOworICAgIHN0YXRpYyB2b2lkIHNldFNlc3Npb24oY29uc3QgRnJh bWUgKmZyYW1lLCBTb3VwU2Vzc2lvbiAqc2Vzc2lvbik7CisjZW5kaWYKKwogICAgIC8vIFVzZWQg dG8gd29yayBhcm91bmQgdGhlIGZhY3QgdGhhdCB5b3UgZG9uJ3QgZ2V0IGFueSBtb3JlIE5TVVJM Q29ubmVjdGlvbiBjYWxsYmFja3MgdW50aWwgeW91IHJldHVybiBmcm9tIHRoZSBvbmUgeW91J3Jl IGluLgogICAgIHN0YXRpYyBib29sIGxvYWRzQmxvY2tlZCgpOyAgICAKICAgICAKQEAgLTE3OCw3 ICsxODcsNyBAQCBwdWJsaWM6CiBwcml2YXRlOgogI2lmIFVTRShTT1VQKQogICAgIGJvb2wgc3Rh cnREYXRhKFN0cmluZyB1cmxTdHJpbmcpOwotICAgIGJvb2wgc3RhcnRIdHRwKFN0cmluZyB1cmxT dHJpbmcpOworICAgIGJvb2wgc3RhcnRIdHRwKFNvdXBTZXNzaW9uKiBzZXNzaW9uLCBTdHJpbmcg dXJsU3RyaW5nKTsKICAgICBib29sIHN0YXJ0R2lvKFN0cmluZyB1cmxTdHJpbmcpOwogI2VuZGlm CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUlu dGVybmFsLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5h bC5oCmluZGV4IDY2YWE0YzEuLjU4NDU0OGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaApAQCAtMTc4LDYgKzE3OCw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgVmVjdG9yPGNoYXI+IG1fcG9zdEJ5dGVzOwogI2VuZGlm CiAjaWYgVVNFKFNPVVApCisgICAgICAgIFNvdXBTZXNzaW9uKiBtX3Nlc3Npb247CiAgICAgICAg IFNvdXBNZXNzYWdlKiBtX21zZzsKICAgICAgICAgUmVzb3VyY2VSZXNwb25zZSBtX3Jlc3BvbnNl OwogICAgICAgICBib29sIG1fY2FuY2VsbGVkOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRleCA4ODEwOWU4Li5lNjQ3ZTIxIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAorKysg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcApAQCAtMjIs MTggKzIyLDI4IEBACiAKICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiS1VSTC5oIgor I2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJG cmFtZUxvYWRlckNsaWVudC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVNvdXBDb29raWVK YXIqIGdldENvb2tpZUphcigpCitTb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIoY29uc3QgRG9j dW1lbnQqIGRvY3VtZW50KQogewotICAgIHN0YXRpYyBTb3VwQ29va2llSmFyKiBqYXIgPSBzb3Vw X2Nvb2tpZV9qYXJfbmV3KCk7CisgICAgRnJhbWUgKmZyYW1lID0gZG9jdW1lbnQtPmZyYW1lKCk7 CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgRnJhbWVMb2FkZXIgKmxv YWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0dXJu IDA7CisgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNs aWVudCo+KGxvYWRlci0+Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAgU291cENvb2tpZUphciog amFyID0gKFNvdXBDb29raWVKYXIqKXNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBT T1VQX1RZUEVfQ09PS0lFX0pBUik7CiAgICAgcmV0dXJuIGphcjsKIH0KIAotdm9pZCBzZXRDb29r aWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYg Lypwb2xpY3lVUkwqLywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3ZvaWQgc2V0Q29va2llcyhEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwq LywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKIHsKLSAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRD b29raWVKYXIoKTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIoZG9jdW1l bnQpOwogICAgIGlmICghamFyKQogICAgICAgICByZXR1cm47CiAKQEAgLTQzLDkgKzUzLDkgQEAg dm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCwg Y29uc3QgS1VSTCYgLypwb2xpY3lVUkwKICAgICBzb3VwX3VyaV9mcmVlKG9yaWdpbik7CiB9CiAK LVN0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwm IHVybCkKK1N0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgS1VS TCYgdXJsKQogewotICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcigpOworICAg IFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcihkb2N1bWVudCk7CiAgICAgaWYgKCFq YXIpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKIApAQCAtNTksOSArNjksOSBAQCBTdHJpbmcg Y29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwpCiAg ICAgcmV0dXJuIHJlc3VsdDsKIH0KIAotYm9vbCBjb29raWVzRW5hYmxlZChjb25zdCBEb2N1bWVu dCogLypkb2N1bWVudCovKQorYm9vbCBjb29raWVzRW5hYmxlZChjb25zdCBEb2N1bWVudCogZG9j dW1lbnQpCiB7Ci0gICAgcmV0dXJuIGdldENvb2tpZUphcigpOworICAgIHJldHVybiBnZXRDb29r aWVKYXIoZG9jdW1lbnQpOwogfQogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uNmU1MTY5MiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaApAQCAtMzEsNyArMzEsNyBAQAog I2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7Ci0gICAgU291 cENvb2tpZUphciogZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogZ2V0Q29va2ll SmFyKGNvbnN0IERvY3VtZW50KiBkb2N1bWVudCk7CiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXgg ODJhZDM2YS4uNjQ1NGI4MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0yOCw2ICsyOCw4IEBACiAjaW5jbHVkZSAi Q29va2llSmFyU291cC5oIgogI2luY2x1ZGUgIkRvY0xvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1l LmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVu dC5oIgogI2luY2x1ZGUgIkhUVFBQYXJzZXJzLmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3Ry eS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCkBAIC00OSw4ICs1MSw2IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gMDsKLQog ZW51bQogewogICAgIEVSUk9SX1RSQU5TUE9SVCwKQEAgLTE3Myw2ICsxNzMsOCBAQCBzdGF0aWMg dm9pZCBmaW5pc2hlZENhbGxiYWNrKFNvdXBTZXNzaW9uICpzZXNzaW9uLCBTb3VwTWVzc2FnZSog bXNnLCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAKICAgICBSZXNvdXJjZUhhbmRsZUlu dGVybmFsKiBkID0gaGFuZGxlLT5nZXRJbnRlcm5hbCgpOworICAgIGdfb2JqZWN0X3VucmVmKGQt Pm1fc2Vzc2lvbik7CisgICAgZC0+bV9zZXNzaW9uID0gTlVMTDsKIAogICAgIFJlc291cmNlSGFu ZGxlQ2xpZW50KiBjbGllbnQgPSBoYW5kbGUtPmNsaWVudCgpOwogICAgIGlmICghY2xpZW50KQpA QCAtMjgyLDIyICsyODQsMjkgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnREYXRhKFN0cmlu ZyB1cmxTdHJpbmcpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgUmVzb3VyY2VIYW5kbGU6 OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQorc3RhdGljIHZvaWQgZW5zdXJlU2Vzc2lvbihT b3VwU2Vzc2lvbiogc2Vzc2lvbikKIHsKLSAgICBpZiAoIXNlc3Npb24pIHsKLSAgICAgICAgc2Vz c2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKLQotICAgICAgICBzb3VwX3Nlc3Npb25f YWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNTSU9OX0ZFQVRVUkUoZ2V0Q29va2llSmFyKCkp KTsKLQotICAgICAgICBjb25zdCBjaGFyKiBzb3VwX2RlYnVnID0gZ19nZXRlbnYoIldFQktJVF9T T1VQX0xPR0dJTkciKTsKLSAgICAgICAgaWYgKHNvdXBfZGVidWcpIHsKLSAgICAgICAgICAgIGlu dCBzb3VwX2RlYnVnX2xldmVsID0gYXRvaShzb3VwX2RlYnVnKTsKKyAgICBTb3VwQ29va2llSmFy KiBqYXIgPSAwOworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJL SVRfREVCVUciKTsKKworICAgIGphciA9IChTb3VwQ29va2llSmFyKilzb3VwX3Nlc3Npb25fZ2V0 X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpOworICAgIGlmICghamFyKSB7 CisgICAgICAgIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKKyAgICAgICAgc291cF9zZXNz aW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfU0VTU0lPTl9GRUFUVVJFKGphcikpOworICAg ICAgICBnX29iamVjdF91bnJlZihHX09CSkVDVChqYXIpKTsKKyAgICB9CiAKLSAgICAgICAgICAg IFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9n Z2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2ZWwpLCAtMSk7Ci0gICAgICAgICAgICBzb3VwX2xv Z2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKLSAgICAgICAgICAgIGdfb2JqZWN0X3VucmVm KGxvZ2dlcik7Ci0gICAgICAgIH0KKyAgICBpZiAoc291cF9zZXNzaW9uX2dldF9mZWF0dXJlKHNl c3Npb24sIFNPVVBfVFlQRV9MT0dHRVIpID09IE5VTEwKKyAgICAgICAgJiYgd2Via2l0X2RlYnVn ICYmICFzdHJjbXAod2Via2l0X2RlYnVnLCAibmV0d29yayIpKSB7CisgICAgICAgIFNvdXBMb2dn ZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9nZ2VyTG9nTGV2 ZWw+KFNPVVBfTE9HR0VSX0xPR19CT0RZKSwgLTEpOworICAgICAgICBzb3VwX2xvZ2dlcl9hdHRh Y2gobG9nZ2VyLCBzZXNzaW9uKTsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsKICAg ICB9Cit9CisKK2Jvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTb3VwU2Vzc2lvbiogc2Vz c2lvbiwgU3RyaW5nIHVybFN0cmluZykKK3sKKyAgICBlbnN1cmVTZXNzaW9uKHNlc3Npb24pOwog CiAgICAgU291cE1lc3NhZ2UqIG1zZzsKICAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVl c3QoKS5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkp OwpAQCAtMzI4LDggKzMzNyw5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJp bmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9NRU1P UllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICB9CiAKKyAgICBkLT5tX3Nl c3Npb24gPSBzdGF0aWNfY2FzdDxTb3VwU2Vzc2lvbio+KGdfb2JqZWN0X3JlZihzZXNzaW9uKSk7 CiAgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2JqZWN0X3JlZiht c2cpKTsKLSAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBkLT5tX21zZywg ZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CisgICAgc291cF9zZXNzaW9uX3F1ZXVlX21lc3NhZ2Uo c2Vzc2lvbiwgbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKIAogICAgIHJldHVybiB0cnVl OwogfQpAQCAtMzUwLDcgKzM2MCw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0KEZyYW1l KiBmcmFtZSkKICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJkYXRhIikpCiAg ICAgICAgIHJldHVybiBzdGFydERhdGEodXJsU3RyaW5nKTsKICAgICBlbHNlIGlmICgoZXF1YWxJ Z25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9j b2wsICJodHRwcyIpKSAmJiBTT1VQX1VSSV9WQUxJRF9GT1JfSFRUUChzb3VwX3VyaV9uZXcodXJs U3RyaW5nLnV0ZjgoKS5kYXRhKCkpKSkKLSAgICAgICAgcmV0dXJuIHN0YXJ0SHR0cCh1cmxTdHJp bmcpOworICAgICAgICByZXR1cm4gc3RhcnRIdHRwKGdldFNlc3Npb24oZnJhbWUpLCB1cmxTdHJp bmcpOwogICAgIGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZmlsZSIpIHx8 IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2Uo cHJvdG9jb2wsICJmdHBzIikpCiAgICAgICAgIC8vIEZJWE1FOiBzaG91bGQgd2UgYmUgZG9pbmcg YW55IG90aGVyIHByb3RvY29scyBoZXJlPwogICAgICAgICByZXR1cm4gc3RhcnRHaW8odXJsU3Ry aW5nKTsKQEAgLTM2OCw3ICszNzgsNyBAQCB2b2lkIFJlc291cmNlSGFuZGxlOjpjYW5jZWwoKQog ewogICAgIGQtPm1fY2FuY2VsbGVkID0gdHJ1ZTsKICAgICBpZiAoZC0+bV9tc2cpIHsKLSAgICAg ICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKHNlc3Npb24sIGQtPm1fbXNnLCBTT1VQX1NU QVRVU19DQU5DRUxMRUQpOworICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2UoZC0+ bV9zZXNzaW9uLCBkLT5tX21zZywgU09VUF9TVEFUVVNfQ0FOQ0VMTEVEKTsKICAgICAgICAgLy8g Rm9yIHJlLWVudHJhbmN5IHRyb3VibGVzIHdlIGNhbGwgZGlkRmluaXNoTG9hZGluZyB3aGVuIHRo ZSBtZXNzYWdlIGhhc24ndCBiZWVuIGhhbmRsZWQgeWV0LgogICAgICAgICBkLT5jbGllbnQoKS0+ ZGlkRmluaXNoTG9hZGluZyh0aGlzKTsKICAgICB9IGVsc2UgaWYgKGQtPm1fY2FuY2VsbGFibGUp IHsKQEAgLTYxNyw1ICs2MjcsMjggQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3Ry aW5nIHVybFN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291 cmNlSGFuZGxlOjpnZXRTZXNzaW9uKGNvbnN0IEZyYW1lICpmcmFtZSkKK3sKKyAgICBzdGF0aWMg U291cFNlc3Npb24qIGRlZmF1bHRfc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsK KworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiBkZWZhdWx0X3Nlc3Npb247CisgICAg RnJhbWVMb2FkZXIgKmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikK KyAgICAgICAgcmV0dXJuIDA7CisgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2Fz dDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAg cmV0dXJuIHNlc3Npb24gPyBzZXNzaW9uIDogZGVmYXVsdF9zZXNzaW9uOworfQorCit2b2lkIFJl c291cmNlSGFuZGxlOjpzZXRTZXNzaW9uKGNvbnN0IEZyYW1lICpmcmFtZSwgU291cFNlc3Npb24g KnNlc3Npb24pCit7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuOworICAgIEZyYW1l TG9hZGVyICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAg ICAgIHJldHVybjsKKyAgICBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+ Y2xpZW50KCkpLT5zZXRTZXNzaW9uKHNlc3Npb24pOworfQorCiB9CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmggYi9XZWJLaXQvZ3RrL1dl YkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5oCmluZGV4IDI5OWQwMjMuLmVhNTRiZjcgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmgKKysr IGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaApAQCAtMjIsNiAr MjIsNyBAQAogCiAjaW5jbHVkZSAiQ2hyb21lQ2xpZW50LmgiCiAjaW5jbHVkZSAiS1VSTC5oIgor I2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViVmll dyBXZWJLaXRXZWJWaWV3OwogCkBAIC0zMSw2ICszMiw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewog ICAgIHB1YmxpYzoKICAgICAgICAgQ2hyb21lQ2xpZW50KFdlYktpdFdlYlZpZXcqKTsKICAgICAg ICAgV2ViS2l0V2ViVmlldyogd2ViVmlldygpIGNvbnN0IHsgcmV0dXJuIG1fd2ViVmlldzsgfQor ICAgICAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbigpOwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBj aHJvbWVEZXN0cm95ZWQoKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCAxYjQxMGM3Li42NTBhM2U2IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysg Yi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAt NjQsNiArNjQsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogRnJhbWVMb2FkZXJDbGllbnQ6OkZy YW1lTG9hZGVyQ2xpZW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKICAgICA6IG1fZnJhbWUoZnJh bWUpCisgICAgLCBtX3Nlc3Npb24oMCkKICAgICAsIG1fdXNlckFnZW50KCIiKQogICAgICwgbV9w b2xpY3lEZWNpc2lvbigwKQogICAgICwgbV9wbHVnaW5WaWV3KDApCkBAIC04NzUsNCArODc2LDE0 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZEZvck5ld1Bh Z2UoKQogICAgIGZyYW1lLT52aWV3KCktPnNldEd0a0FkanVzdG1lbnRzKHByaXYtPmhvcml6b250 YWxBZGp1c3RtZW50LCBwcml2LT52ZXJ0aWNhbEFkanVzdG1lbnQpOwogfQogCitTb3VwU2Vzc2lv biogRnJhbWVMb2FkZXJDbGllbnQ6OnNlc3Npb24oKQoreworICAgIHJldHVybiBtX3Nlc3Npb247 Cit9CisKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldFNlc3Npb24oU291cFNlc3Npb24qIHNl c3Npb24pCit7CisgICAgbV9zZXNzaW9uID0gc2Vzc2lvbjsKK30KKwogfQpkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oIGIvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCmluZGV4IGM2OTUyZGIu LjIzZDI5YzEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuaAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmgKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNl LmgiCiAjaW5jbHVkZSAiUGx1Z2luVmlldy5oIgogI2luY2x1ZGUgIndlYmtpdHdlYnBvbGljeWRl Y2lzaW9uLmgiCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIHR5cGVkZWYgc3RydWN0IF9X ZWJLaXRXZWJGcmFtZSBXZWJLaXRXZWJGcmFtZTsKIApAQCAtMTY5LDggKzE3MCwxMiBAQCBuYW1l c3BhY2UgV2ViS2l0IHsKIAogICAgICAgICB2aXJ0dWFsIGJvb2wgY2FuQ2FjaGVQYWdlKCkgY29u c3Q7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkb3dubG9hZChXZWJDb3JlOjpSZXNvdXJjZUhhbmRs ZSosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmKTsKKworICAgICAg ICB2aXJ0dWFsIFNvdXBTZXNzaW9uKiBzZXNzaW9uKCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBz ZXRTZXNzaW9uKFNvdXBTZXNzaW9uKik7CiAgICAgcHJpdmF0ZToKICAgICAgICAgV2ViS2l0V2Vi RnJhbWUqIG1fZnJhbWU7CisgICAgICAgIFNvdXBTZXNzaW9uKiBtX3Nlc3Npb247CiAgICAgICAg IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgbV9yZXNwb25zZTsKICAgICAgICAgV2ViQ29yZTo6 U3RyaW5nIG1fdXNlckFnZW50OwogICAgICAgICBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogbV9w b2xpY3lEZWNpc2lvbjsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluIGIvV2Vi S2l0L2d0ay93ZWJraXQucGMuaW4KaW5kZXggMGNlNmY3MS4uODRkNjExNSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQucGMuaW4KKysrIGIvV2ViS2l0L2d0ay93ZWJraXQucGMuaW4KQEAg LTYsNiArNiw2IEBAIGluY2x1ZGVkaXI9QGluY2x1ZGVkaXJACiBOYW1lOiBXZWJLaXQKIERlc2Ny aXB0aW9uOiBXZWIgY29udGVudCBlbmdpbmUgZm9yIEdUSysKIFZlcnNpb246IEBWRVJTSU9OQAot UmVxdWlyZXM6IGd0aystMi4wCitSZXF1aXJlczogZ3RrKy0yLjAgbGlic291cC0yLjQKIExpYnM6 IC1MJHtsaWJkaXJ9IC1sd2Via2l0LTEuMAogQ2ZsYWdzOiAtSSR7aW5jbHVkZWRpcn0vd2Via2l0 LTEuMApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCAzNThhY2U5Li4yMTA0NDQ3 IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtNTksNiArNTksNyBAQAogI2lu Y2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUtleWJvYXJkRXZl bnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJj ZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFy LmgiCiAjaW5jbHVkZSAiU3Vic3RpdHV0ZURhdGEuaCIKQEAgLTE0Niw3ICsxNDcsOCBAQCBlbnVt IHsKICAgICBQUk9QX1dJTkRPV19GRUFUVVJFUywKICAgICBQUk9QX1RSQU5TUEFSRU5ULAogICAg IFBST1BfWk9PTV9MRVZFTCwKLSAgICBQUk9QX0ZVTExfQ09OVEVOVF9aT09NCisgICAgUFJPUF9G VUxMX0NPTlRFTlRfWk9PTSwKKyAgICBQUk9QX1NFU1NJT04sCiB9OwogCiBzdGF0aWMgZ3VpbnQg d2Via2l0X3dlYl92aWV3X3NpZ25hbHNbTEFTVF9TSUdOQUxdID0geyAwLCB9OwpAQCAtMzA0LDYg KzMwNiw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19nZXRfcHJvcGVydHkoR09iamVj dCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqCiAgICAgY2FzZSBQUk9QX0ZVTExfQ09O VEVOVF9aT09NOgogICAgICAgICBnX3ZhbHVlX3NldF9ib29sZWFuKHZhbHVlLCB3ZWJraXRfd2Vi X3ZpZXdfZ2V0X2Z1bGxfY29udGVudF96b29tKHdlYlZpZXcpKTsKICAgICAgICAgYnJlYWs7Cisg ICAgY2FzZSBQUk9QX1NFU1NJT046CisgICAgICAgIGdfdmFsdWVfc2V0X29iamVjdCh2YWx1ZSwg d2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKHdlYlZpZXcpKTsKKyAgICAgICAgYnJlYWs7CiAg ICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9i amVjdCwgcHJvcF9pZCwgcHNwZWMpOwogICAgIH0KQEAgLTE1NjksNiArMTU3NCwyMCBAQCBzdGF0 aWMgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfY2xhc3NfaW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdl YlZpZXdDbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIEZBTFNFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOwogCisgICAgLyoq CisgICAgKiBXZWJLaXRXZWJWaWV3OnNlc3Npb246CisgICAgKgorICAgICogUmV0cmlldmVzIHRo ZSBzZXNzaW9uIG9mIHRoZSB2aWV3LgorICAgICoKKyAgICAqIFNpbmNlOiAxLjAuMworICAgICov CisgICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJPUF9T RVNTSU9OLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVj X29iamVjdCgic2Vzc2lvbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJTZXNzaW9uIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0 aGUgdmlldyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFNPVVBfVFlQRV9TRVNTSU9OLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBREFCTEUpKTsKKwog ICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZSh3ZWJWaWV3Q2xhc3MsIHNpemVvZihXZWJLaXRX ZWJWaWV3UHJpdmF0ZSkpOwogfQogCkBAIC0yNjcyLDQgKzI2OTEsNzQgQEAgdm9pZCB3ZWJraXRf d2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsIGdi b29sZWFuIHpvb20KICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qod2ViVmlldyksICJmdWxs LWNvbnRlbnQtem9vbSIpOwogfQogCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lv bjoKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICoKKyAqIFJldHJpZXZlcyB0aGUg I1NvdXBTZXNzaW9uIG9mIHRoZSB2aWV3LCBjcmVhdGVkIHdoZW4gdGhpcworICogZnVuY3Rpb24g aXMgY2FsbGVkIGZvciB0aGUgZmlyc3QgdGltZS4KKyAqCisgKiBEb24ndCB1c2UgdGhpcyBmdW5j dGlvbiB1bmxlc3MgeW91IGludGVuZCB0byBtYW5hZ2Ugc2Vzc2lvbnMKKyAqIGZvciB5b3VyIHdl YiB2aWV3cyBvbiB5b3VyIG93bi4gU2VlIGFsc28gd2Via2l0X3dlYl92aWV3X3NldF9zZXNzaW9u KCkuCisgKgorICogUmV0dXJuIHZhbHVlOiB0aGUgI1NvdXBTZXNzaW9uIG9mIHRoZSB2aWV3Cisg KgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0 X3Nlc3Npb24gKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7CisgICAgU291cFNlc3Npb24qIHNl c3Npb247CisKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2Vi VmlldyksIE5VTEwpOworCisgICAgc2Vzc2lvbiA9IFJlc291cmNlSGFuZGxlOjpnZXRTZXNzaW9u KGNvcmUod2ViVmlldy0+cHJpdi0+bWFpbkZyYW1lKSk7CisgICAgaWYgKCFzZXNzaW9uKSB7Cisg ICAgICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3ICgpOworICAgICAgICBSZXNv dXJjZUhhbmRsZTo6c2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnByaXYtPm1haW5GcmFtZSksIHNl c3Npb24pOworICAgIH0KKyAgICByZXR1cm4gc2Vzc2lvbjsKK30KKworLyoqCisgKiB3ZWJraXRf d2ViX3ZpZXdfc2V0X3Nlc3Npb246CisgKiBAd2ViX3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAq IEBzZXNzaW9uOiBhICNTb3VwU2Vzc2lvbgorICoKKyAqIEFzc2lnbnMgYSBwYXJ0aWN1bGFyIHNl c3Npb24gdG8gdGhlIHdlYiB2aWV3LiBJdCBpcyByZWNvbW1lbmRlZAorICogdGhhdCB5b3Ugb25s eSB1c2Ugc2Vzc2lvbnMgcmV0dXJuZWQgYnkgd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKCkK KyAqIG9yIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uKCkuCisgKgorICogRG9uJ3QgdXNlIHRo aXMgZnVuY3Rpb24gdW5sZXNzIHlvdSBpbnRlbmQgdG8gbWFuYWdlIHNlc3Npb25zCisgKiBmb3Ig eW91ciB3ZWIgdmlld3Mgb24geW91ciBvd24uIFNlZSBhbHNvIHdlYmtpdF93ZWJfdmlld19nZXRf c2Vzc2lvbigpLgorICoKKyAqIFNpbmNlOiAxLjEuMQorICovCit2b2lkIHdlYmtpdF93ZWJfdmll d19zZXRfc2Vzc2lvbiAoV2ViS2l0V2ViVmlldyogd2ViVmlldywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBTb3VwU2Vzc2lvbiogICBzZXNzaW9uKQoreworICAgIGdfcmV0dXJu X2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZpZXcpKTsKKyAgICBnX3JldHVybl9pZl9m YWlsKFNPVVBfSVNfU0VTU0lPTl9BU1lOQyhzZXNzaW9uKSk7CisKKyAgICBSZXNvdXJjZUhhbmRs ZTo6c2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnByaXYtPm1haW5GcmFtZSksIHNlc3Npb24pOwor fQorCisvKioKKyAqIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uOgorICoKKyAqIFJldHJpZXZl cyB0aGUgZGVmYXVsdCAjU291cFNlc3Npb24gdXNlZCBieSBhbGwgd2ViIHZpZXdzIHVubGVzcwor ICogd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKCkgaXMgY2FsbGVkLgorICoKKyAqIFRoZSBz ZXNzaW9uIGlzIGluaXRpYWxseSBlbXB0eS4gVXBvbiB0aGUgZmlyc3QgbG9hZAorICogYSBjb29r aWUgamFyIHdpbGwgYmUgYWRkZWQuIEhvd2V2ZXIgeW91IGNhbgorICogYWRkIHlvdXIgb3duIGNv b2tpZSBqYXIgYW5kIFdlYktpdCB3aWxsIHVzZSBpdC4KKyAqCisgKiBSZXR1cm4gdmFsdWU6IHRo ZSBkZWZhdWx0ICNTb3VwU2Vzc2lvbgorICoKKyAqIFNpbmNlOiAxLjEuMQorICovCitTb3VwU2Vz c2lvbiogd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Npb24gKHZvaWQpCit7CisgICAgcmV0dXJuIFJl c291cmNlSGFuZGxlOjpnZXRTZXNzaW9uKDApOworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmgKaW5kZXggMmJiOGM2MS4uZTA1NTA0OCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcu aApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJiYWNrZm9yd2Fy ZGxpc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViaGlzdG9yeWl0ZW0uaD4KICNpbmNs dWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAu aD4KIAogR19CRUdJTl9ERUNMUwogCkBAIC0yOTYsNiArMjk3LDEyIEBAIFdFQktJVF9BUEkgdm9p ZAogd2Via2l0X3dlYl92aWV3X3NldF9mdWxsX2NvbnRlbnRfem9vbSAgICAgICAgICAgKFdlYktp dFdlYlZpZXcgICAgICAgICp3ZWJfdmlldywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICAgICAgICAgICAgZnVsbF9jb250ZW50X3pv b20pOwogCitXRUJLSVRfQVBJIFNvdXBTZXNzaW9uKgord2Via2l0X3dlYl92aWV3X2dldF9zZXNz aW9uICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICp3ZWJfdmlldyk7 CisKK1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAg ICAgICAgICAgICAgICAgICAgICAodm9pZCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0gYi9XZWJLaXRUb29scy9HTlVtYWtl ZmlsZS5hbQppbmRleCAyNjIwMGM4Li40NDFiYzAyIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9H TlVtYWtlZmlsZS5hbQorKysgYi9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbQpAQCAtMjAsNiAr MjAsNyBAQCBQcm9ncmFtc19HdGtMYXVuY2hlcl9DRkxBR1MgPSBcCiAJLWZuby1zdHJpY3QtYWxp YXNpbmcgXAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCisJJChMSUJTT1VQX0NGTEFHUykg XAogCSQoR1RLX0NGTEFHUykKIAogUHJvZ3JhbXNfR3RrTGF1bmNoZXJfTERBREQgPSBcCkBAIC02 Nyw2ICs2OCw3IEBAIFByb2dyYW1zX0R1bXBSZW5kZXJUcmVlX0NGTEFHUyA9IFwKIAkkKGdsb2Jh bF9jZmxhZ3MpIFwKIAkkKEdMT0JBTERFUFNfQ0ZMQUdTKSBcCiAJJChDQUlST19DRkxBR1MpIFwK KwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFtc19EdW1wUmVu ZGVyVHJlZV9MREFERCA9IFwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21h aW4uYyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwppbmRleCA4ZWQyNjkwLi4zOGNi NWVjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKKysrIGIvV2Vi S2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCkBAIC0xODIsNiArMTgyLDggQEAgY3JlYXRlX3dp bmRvdyAoKQogaW50CiBtYWluIChpbnQgYXJnYywgY2hhciogYXJndltdKQogeworICAgIGlmICgh Z190aHJlYWRfc3VwcG9ydGVkICgpKQorICAgICAgICBnX3RocmVhZF9pbml0IChOVUxMKTsKICAg ICBndGtfaW5pdCAoJmFyZ2MsICZhcmd2KTsKIAogICAgIEd0a1dpZGdldCogdmJveCA9IGd0a192 Ym94X25ldyAoRkFMU0UsIDApOwpkaWZmIC0tZ2l0IGEvY29uZmlndXJlLmFjIGIvY29uZmlndXJl LmFjCmluZGV4IDZhYzZmOGIuLjdmMWM0OWYgMTAwNjQ0Ci0tLSBhL2NvbmZpZ3VyZS5hYworKysg Yi9jb25maWd1cmUuYWMKQEAgLTI4NiwyMCArMjg2LDYgQEAgaWYgdGVzdCAiJHdpdGhfaGlsZG9u IiA9ICJ5ZXMiOyB0aGVuCiAgICAgQUNfU1VCU1QoW0hJTERPTl9MSUJTXSkKIGZpCiAKLSMgZGV0 ZXJtaW5lIHRoZSBodHRwIGJhY2tlbmQKLUFDX01TR19DSEVDS0lORyhbdGhlIEhUVFAgYmFja2Vu ZCB0byB1c2VdKQotQUNfQVJHX1dJVEgoaHR0cF9iYWNrZW5kLAotICAgICAgICAgICAgQUNfSEVM UF9TVFJJTkcoWy0td2l0aC1odHRwLWJhY2tlbmQ9QDw6QGN1cmwvc291cEA6PkBdLAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgW1NlbGVjdCBIVFRQIGJhY2tlbmQgW2RlZmF1bHQ9Y3VybF1d KSwKLSAgICAgICAgICAgIFtdLFt3aXRoX2h0dHBfYmFja2VuZD0iY3VybCJdKQotCi1jYXNlICIk d2l0aF9odHRwX2JhY2tlbmQiIGluCi0gICAgIGN1cmx8c291cCkgOzsKLSAgICAgKikgQUNfTVNH X0VSUk9SKFtJbnZhbGlkIEhUVFAgYmFja2VuZDogbXVzdCBiZSBjdXJsLCBzb3VwLl0pIDs7Ci1l c2FjCi0KLUFDX01TR19SRVNVTFQoWyR3aXRoX2h0dHBfYmFja2VuZF0pCi0KICMgbWluaW11bSBi YXNlIGRlcGVuZGVuY2llcwogQ0FJUk9fUkVRVUlSRURfVkVSU0lPTj0xLjIKIEZPTlRDT05GSUdf UkVRVUlSRURfVkVSU0lPTj0yLjQKQEAgLTMxNCw4ICszMDAsNyBAQCBQQU5HT19SRVFVSVJFRF9W RVJTSU9OPTEuMAogR1RLX1JFUVVJUkVEX1ZFUlNJT049Mi44CiAKICMgb3B0aW9uYWwgbW9kdWxl cwotTElCQ1VSTF9SRVFVSVJFRF9WRVJTSU9OPTcuMTUKLUxJQlNPVVBfUkVRVUlSRURfVkVSU0lP Tj0yLjIzCitMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT049Mi4yNS40CiBMSUJYU0xUX1JFUVVJUkVE X1ZFUlNJT049MS4xLjcKIFNRTElURV9SRVFVSVJFRF9WRVJTSU9OPTMuMAogR1NUUkVBTUVSX1JF UVVJUkVEX1ZFUlNJT049MC4xMApAQCAtNjI0LDIzICs2MDksMTEgQEAgZWxzZQogICAgQ0ZMQUdT PSIkQ0ZMQUdTIC1PMCIKIGZpCiAKLSMgY2hlY2sgaWYgY3VybCBpcyBhdmFpbGFibGUKLWlmIHRl c3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAiY3VybCI7IHRoZW4KLSAgIFBLR19DSEVDS19NT0RV TEVTKFtMSUJDVVJMXSwKLSAgICAgICAgICAgICAgICAgICAgIFtsaWJjdXJsID49ICRMSUJDVVJM X1JFUVVJUkVEX1ZFUlNJT05dKQotICAgaWYgdGVzdCAiJG9zX3dpbjMyIiA9ICJ5ZXMiOyB0aGVu Ci0gICAgICBMSUJDVVJMX0xJQlM9IiRMSUJDVVJMX0xJQlMgLWx3czJfMzIiCi0gICBmaQotICAg QUNfU1VCU1QoW0xJQkNVUkxfQ0ZMQUdTXSkKLSAgIEFDX1NVQlNUKFtMSUJDVVJMX0xJQlNdKQot ZmkKIAotaWYgdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJzb3VwIjsgdGhlbgotICAgUEtH X0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAotICAgICAgICAgICAgICAgICAgICAgW2xpYnNvdXAt Mi40ID49ICRMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT05dKQotICAgQUNfU1VCU1QoW0xJQlNPVVBf Q0ZMQUdTXSkKLSAgIEFDX1NVQlNUKFtMSUJTT1VQX0xJQlNdKQotZmkKK1BLR19DSEVDS19NT0RV TEVTKFtMSUJTT1VQXSwKKyAgICAgICAgICAgICAgICAgIFtsaWJzb3VwLTIuNCA+PSAkTElCU09V UF9SRVFVSVJFRF9WRVJTSU9OXSkKK0FDX1NVQlNUKFtMSUJTT1VQX0NGTEFHU10pCitBQ19TVUJT VChbTElCU09VUF9MSUJTXSkKIAogIyBjaGVjayBpZiBGcmVlVHlwZS9Gb250Q29uZmlnIGFyZSBh dmFpbGFibGUKIGlmIHRlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5cGUiOyB0aGVu CkBAIC03MTIsMTAgKzY4NSw2IEBAIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfV0lOMzJdLCBbdGVz dCAiJHdpdGhfdGFyZ2V0IiA9ICJ3aW4zMiJdKQogQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9RVUFS VFpdLCBbdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJxdWFydHoiXSkKIEFNX0NPTkRJVElPTkFMKFtU QVJHRVRfRElSRUNURkJdLCBbdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJkaXJlY3RmYiJdKQogCi0j IEhUVFAgYmFja2VuZCBjb25kaXRpb25hbHMKLUFNX0NPTkRJVElPTkFMKFtVU0VfQ1VSTF0sIFt0 ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gImN1cmwiXSkKLUFNX0NPTkRJVElPTkFMKFtVU0Vf U09VUF0sIFt0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gInNvdXAiXSkKLQogIyBGb250IGJh Y2tlbmQgY29uZGl0aW9uYWxzCiBBTV9DT05ESVRJT05BTChbVVNFX0ZSRUVUWVBFXSwgW3Rlc3Qg IiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5cGUiXSkKIEFNX0NPTkRJVElPTkFMKFtVU0Vf UEFOR09dLCBbdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5kIiA9ICJwYW5nbyJdKQpAQCAtNzYyLDcg KzczMSw2IEBAIEJ1aWxkIGNvbmZpZ3VyYXRpb246CiAgRW5hYmxlIEdDQyBidWlsZCBvcHRpbWl6 YXRpb24gICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkZW5hYmxlX29wdGltaXphdGlvbnMK ICBDb2RlIGNvdmVyYWdlIHN1cHBvcnQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICA6ICRlbmFibGVfY292ZXJhZ2UKICBVbmljb2RlIGJhY2tlbmQgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICA6ICR1bmljb2RlX2JhY2tlbmQKLSBIVFRQIGJhY2tlbmQg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICR3aXRoX2h0dHBf YmFja2VuZAogIEZvbnQgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDogJHdpdGhfZm9udF9iYWNrZW5kCiAgT3B0aW1pemVkIG1lbW9yeSBhbGxvY2F0 b3IgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkZW5hYmxlX2Zhc3RfbWFsbG9jCiBG ZWF0dXJlczoK 26741 2009-01-14 18:29:14 -0800 2009-01-18 14:43:23 -0800 API to retrieve and set soup sessions #5 p.diff text/plain 24073 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAzMDMyZDI2Li45Njk0NGVjIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NTUsMzEgKzE3NTUsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzkzLDcgKzE3NjgsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXJDbGllbnQuaAppbmRleCA0NGFiNGE0Li4yMmJhMjhiIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50LmgKQEAgLTM1LDYgKzM1LDEwIEBACiAjaW5jbHVkZSA8d3RmL1BsYXRmb3JtLmg+ CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorI2VuZGlmCisKIHR5cGVkZWYgY2xhc3MgX2pvYmplY3QqIGpvYmpl Y3Q7CiAKICNpZiBQTEFURk9STShNQUMpICYmICFkZWZpbmVkKF9fT0JKQ19fKQpAQCAtMjA5LDYg KzIxMywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjZW5kaWYKICAgICAgICAgdmlydHVhbCBO U0NhY2hlZFVSTFJlc3BvbnNlKiB3aWxsQ2FjaGVSZXNwb25zZShEb2N1bWVudExvYWRlciosIHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllciwgTlNDYWNoZWRVUkxSZXNwb25zZSopIGNvbnN0ID0gMDsK ICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICAgICAgdmlydHVhbCBTb3VwU2Vzc2lvbiog c2Vzc2lvbigpID0gMDsKKwl2aXJ0dWFsIHZvaWQgc2V0U2Vzc2lvbihTb3VwU2Vzc2lvbiopID0g MDsKKyNlbmRpZgogCiAgICAgICAgIHZpcnR1YWwgYm9vbCBzaG91bGRVc2VQbHVnaW5Eb2N1bWVu dChjb25zdCBTdHJpbmcmIG1pbWVUeXBlKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCmRpZmYg LS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmluZGV4IGM5M2FmMjEuLjE4M2Ux MDAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5o CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCkBAIC0zMCw2 ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIKICNpbmNsdWRlIDx3dGYvT3du UHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRp ZgorCiAjaWYgUExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0cnVjdCBfX0NGRGF0YSAqIENG RGF0YVJlZjsKICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMSBAQCBwdWJsaWM6CiAgICAgUmVzb3Vy Y2VIYW5kbGVJbnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVybiBkLmdldCgpOyB9CiAjZW5k aWYKIAorI2lmIFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogZ2V0U2Vzc2lvbihj b25zdCBGcmFtZSAqZnJhbWUpOworICAgIHN0YXRpYyB2b2lkIHNldFNlc3Npb24oY29uc3QgRnJh bWUgKmZyYW1lLCBTb3VwU2Vzc2lvbiAqc2Vzc2lvbik7CisjZW5kaWYKKwogICAgIC8vIFVzZWQg dG8gd29yayBhcm91bmQgdGhlIGZhY3QgdGhhdCB5b3UgZG9uJ3QgZ2V0IGFueSBtb3JlIE5TVVJM Q29ubmVjdGlvbiBjYWxsYmFja3MgdW50aWwgeW91IHJldHVybiBmcm9tIHRoZSBvbmUgeW91J3Jl IGluLgogICAgIHN0YXRpYyBib29sIGxvYWRzQmxvY2tlZCgpOyAgICAKICAgICAKQEAgLTE3OCw3 ICsxODcsNyBAQCBwdWJsaWM6CiBwcml2YXRlOgogI2lmIFVTRShTT1VQKQogICAgIGJvb2wgc3Rh cnREYXRhKFN0cmluZyB1cmxTdHJpbmcpOwotICAgIGJvb2wgc3RhcnRIdHRwKFN0cmluZyB1cmxT dHJpbmcpOworICAgIGJvb2wgc3RhcnRIdHRwKFNvdXBTZXNzaW9uKiBzZXNzaW9uLCBTdHJpbmcg dXJsU3RyaW5nKTsKICAgICBib29sIHN0YXJ0R2lvKFN0cmluZyB1cmxTdHJpbmcpOwogI2VuZGlm CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUlu dGVybmFsLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5h bC5oCmluZGV4IDY2YWE0YzEuLjU4NDU0OGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaApAQCAtMTc4LDYgKzE3OCw3IEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKICAgICAgICAgVmVjdG9yPGNoYXI+IG1fcG9zdEJ5dGVzOwogI2VuZGlm CiAjaWYgVVNFKFNPVVApCisgICAgICAgIFNvdXBTZXNzaW9uKiBtX3Nlc3Npb247CiAgICAgICAg IFNvdXBNZXNzYWdlKiBtX21zZzsKICAgICAgICAgUmVzb3VyY2VSZXNwb25zZSBtX3Jlc3BvbnNl OwogICAgICAgICBib29sIG1fY2FuY2VsbGVkOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRleCA4ODEwOWU4Li5lNjQ3ZTIxIDEwMDY0NAot LS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAorKysg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcApAQCAtMjIs MTggKzIyLDI4IEBACiAKICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiS1VSTC5oIgor I2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJG cmFtZUxvYWRlckNsaWVudC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLVNvdXBDb29raWVK YXIqIGdldENvb2tpZUphcigpCitTb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIoY29uc3QgRG9j dW1lbnQqIGRvY3VtZW50KQogewotICAgIHN0YXRpYyBTb3VwQ29va2llSmFyKiBqYXIgPSBzb3Vw X2Nvb2tpZV9qYXJfbmV3KCk7CisgICAgRnJhbWUgKmZyYW1lID0gZG9jdW1lbnQtPmZyYW1lKCk7 CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgRnJhbWVMb2FkZXIgKmxv YWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0dXJu IDA7CisgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNs aWVudCo+KGxvYWRlci0+Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAgU291cENvb2tpZUphciog amFyID0gKFNvdXBDb29raWVKYXIqKXNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBT T1VQX1RZUEVfQ09PS0lFX0pBUik7CiAgICAgcmV0dXJuIGphcjsKIH0KIAotdm9pZCBzZXRDb29r aWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYg Lypwb2xpY3lVUkwqLywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKK3ZvaWQgc2V0Q29va2llcyhEb2N1 bWVudCogZG9jdW1lbnQsIGNvbnN0IEtVUkwmIHVybCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwq LywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKIHsKLSAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRD b29raWVKYXIoKTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIoZG9jdW1l bnQpOwogICAgIGlmICghamFyKQogICAgICAgICByZXR1cm47CiAKQEAgLTQzLDkgKzUzLDkgQEAg dm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCwg Y29uc3QgS1VSTCYgLypwb2xpY3lVUkwKICAgICBzb3VwX3VyaV9mcmVlKG9yaWdpbik7CiB9CiAK LVN0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwm IHVybCkKK1N0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiBkb2N1bWVudCwgY29uc3QgS1VS TCYgdXJsKQogewotICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcigpOworICAg IFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcihkb2N1bWVudCk7CiAgICAgaWYgKCFq YXIpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKIApAQCAtNTksOSArNjksOSBAQCBTdHJpbmcg Y29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwpCiAg ICAgcmV0dXJuIHJlc3VsdDsKIH0KIAotYm9vbCBjb29raWVzRW5hYmxlZChjb25zdCBEb2N1bWVu dCogLypkb2N1bWVudCovKQorYm9vbCBjb29raWVzRW5hYmxlZChjb25zdCBEb2N1bWVudCogZG9j dW1lbnQpCiB7Ci0gICAgcmV0dXJuIGdldENvb2tpZUphcigpOworICAgIHJldHVybiBnZXRDb29r aWVKYXIoZG9jdW1lbnQpOwogfQogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uNmU1MTY5MiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oCisrKyBiL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaApAQCAtMzEsNyArMzEsNyBAQAog I2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7Ci0gICAgU291 cENvb2tpZUphciogZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogZ2V0Q29va2ll SmFyKGNvbnN0IERvY3VtZW50KiBkb2N1bWVudCk7CiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKaW5kZXgg ODJhZDM2YS4uNjQ1NGI4MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCkBAIC0yOCw2ICsyOCw4IEBACiAjaW5jbHVkZSAi Q29va2llSmFyU291cC5oIgogI2luY2x1ZGUgIkRvY0xvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1l LmgiCisjaW5jbHVkZSAiRnJhbWVMb2FkZXIuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlckNsaWVu dC5oIgogI2luY2x1ZGUgIkhUVFBQYXJzZXJzLmgiCiAjaW5jbHVkZSAiTUlNRVR5cGVSZWdpc3Ry eS5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCkBAIC00OSw4ICs1MSw2IEBACiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gMDsKLQog ZW51bQogewogICAgIEVSUk9SX1RSQU5TUE9SVCwKQEAgLTE3Myw2ICsxNzMsOCBAQCBzdGF0aWMg dm9pZCBmaW5pc2hlZENhbGxiYWNrKFNvdXBTZXNzaW9uICpzZXNzaW9uLCBTb3VwTWVzc2FnZSog bXNnLCBncG9pbnRlciBkYQogICAgICAgICByZXR1cm47CiAKICAgICBSZXNvdXJjZUhhbmRsZUlu dGVybmFsKiBkID0gaGFuZGxlLT5nZXRJbnRlcm5hbCgpOworICAgIGdfb2JqZWN0X3VucmVmKGQt Pm1fc2Vzc2lvbik7CisgICAgZC0+bV9zZXNzaW9uID0gTlVMTDsKIAogICAgIFJlc291cmNlSGFu ZGxlQ2xpZW50KiBjbGllbnQgPSBoYW5kbGUtPmNsaWVudCgpOwogICAgIGlmICghY2xpZW50KQpA QCAtMjgyLDIyICsyODQsMjkgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnREYXRhKFN0cmlu ZyB1cmxTdHJpbmcpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgUmVzb3VyY2VIYW5kbGU6 OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQorc3RhdGljIHZvaWQgZW5zdXJlU2Vzc2lvbihT b3VwU2Vzc2lvbiogc2Vzc2lvbikKIHsKLSAgICBpZiAoIXNlc3Npb24pIHsKLSAgICAgICAgc2Vz c2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKLQotICAgICAgICBzb3VwX3Nlc3Npb25f YWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNTSU9OX0ZFQVRVUkUoZ2V0Q29va2llSmFyKCkp KTsKLQotICAgICAgICBjb25zdCBjaGFyKiBzb3VwX2RlYnVnID0gZ19nZXRlbnYoIldFQktJVF9T T1VQX0xPR0dJTkciKTsKLSAgICAgICAgaWYgKHNvdXBfZGVidWcpIHsKLSAgICAgICAgICAgIGlu dCBzb3VwX2RlYnVnX2xldmVsID0gYXRvaShzb3VwX2RlYnVnKTsKKyAgICBTb3VwQ29va2llSmFy KiBqYXIgPSAwOworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJL SVRfREVCVUciKTsKKworICAgIGphciA9IChTb3VwQ29va2llSmFyKilzb3VwX3Nlc3Npb25fZ2V0 X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpOworICAgIGlmICghamFyKSB7 CisgICAgICAgIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKKyAgICAgICAgc291cF9zZXNz aW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfU0VTU0lPTl9GRUFUVVJFKGphcikpOworICAg ICAgICBnX29iamVjdF91bnJlZihHX09CSkVDVChqYXIpKTsKKyAgICB9CiAKLSAgICAgICAgICAg IFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9n Z2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2ZWwpLCAtMSk7Ci0gICAgICAgICAgICBzb3VwX2xv Z2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKLSAgICAgICAgICAgIGdfb2JqZWN0X3VucmVm KGxvZ2dlcik7Ci0gICAgICAgIH0KKyAgICBpZiAoc291cF9zZXNzaW9uX2dldF9mZWF0dXJlKHNl c3Npb24sIFNPVVBfVFlQRV9MT0dHRVIpID09IE5VTEwKKyAgICAgICAgJiYgd2Via2l0X2RlYnVn ICYmICFzdHJjbXAod2Via2l0X2RlYnVnLCAibmV0d29yayIpKSB7CisgICAgICAgIFNvdXBMb2dn ZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9nZ2VyTG9nTGV2 ZWw+KFNPVVBfTE9HR0VSX0xPR19CT0RZKSwgLTEpOworICAgICAgICBzb3VwX2xvZ2dlcl9hdHRh Y2gobG9nZ2VyLCBzZXNzaW9uKTsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsKICAg ICB9Cit9CisKK2Jvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTb3VwU2Vzc2lvbiogc2Vz c2lvbiwgU3RyaW5nIHVybFN0cmluZykKK3sKKyAgICBlbnN1cmVTZXNzaW9uKHNlc3Npb24pOwog CiAgICAgU291cE1lc3NhZ2UqIG1zZzsKICAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVl c3QoKS5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkp OwpAQCAtMzI4LDggKzMzNyw5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJp bmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9NRU1P UllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICB9CiAKKyAgICBkLT5tX3Nl c3Npb24gPSBzdGF0aWNfY2FzdDxTb3VwU2Vzc2lvbio+KGdfb2JqZWN0X3JlZihzZXNzaW9uKSk7 CiAgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2JqZWN0X3JlZiht c2cpKTsKLSAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBkLT5tX21zZywg ZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CisgICAgc291cF9zZXNzaW9uX3F1ZXVlX21lc3NhZ2Uo c2Vzc2lvbiwgbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKIAogICAgIHJldHVybiB0cnVl OwogfQpAQCAtMzUwLDcgKzM2MCw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0KEZyYW1l KiBmcmFtZSkKICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJkYXRhIikpCiAg ICAgICAgIHJldHVybiBzdGFydERhdGEodXJsU3RyaW5nKTsKICAgICBlbHNlIGlmICgoZXF1YWxJ Z25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9j b2wsICJodHRwcyIpKSAmJiBTT1VQX1VSSV9WQUxJRF9GT1JfSFRUUChzb3VwX3VyaV9uZXcodXJs U3RyaW5nLnV0ZjgoKS5kYXRhKCkpKSkKLSAgICAgICAgcmV0dXJuIHN0YXJ0SHR0cCh1cmxTdHJp bmcpOworICAgICAgICByZXR1cm4gc3RhcnRIdHRwKGdldFNlc3Npb24oZnJhbWUpLCB1cmxTdHJp bmcpOwogICAgIGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZmlsZSIpIHx8 IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2Uo cHJvdG9jb2wsICJmdHBzIikpCiAgICAgICAgIC8vIEZJWE1FOiBzaG91bGQgd2UgYmUgZG9pbmcg YW55IG90aGVyIHByb3RvY29scyBoZXJlPwogICAgICAgICByZXR1cm4gc3RhcnRHaW8odXJsU3Ry aW5nKTsKQEAgLTM2OCw3ICszNzgsNyBAQCB2b2lkIFJlc291cmNlSGFuZGxlOjpjYW5jZWwoKQog ewogICAgIGQtPm1fY2FuY2VsbGVkID0gdHJ1ZTsKICAgICBpZiAoZC0+bV9tc2cpIHsKLSAgICAg ICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKHNlc3Npb24sIGQtPm1fbXNnLCBTT1VQX1NU QVRVU19DQU5DRUxMRUQpOworICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2UoZC0+ bV9zZXNzaW9uLCBkLT5tX21zZywgU09VUF9TVEFUVVNfQ0FOQ0VMTEVEKTsKICAgICAgICAgLy8g Rm9yIHJlLWVudHJhbmN5IHRyb3VibGVzIHdlIGNhbGwgZGlkRmluaXNoTG9hZGluZyB3aGVuIHRo ZSBtZXNzYWdlIGhhc24ndCBiZWVuIGhhbmRsZWQgeWV0LgogICAgICAgICBkLT5jbGllbnQoKS0+ ZGlkRmluaXNoTG9hZGluZyh0aGlzKTsKICAgICB9IGVsc2UgaWYgKGQtPm1fY2FuY2VsbGFibGUp IHsKQEAgLTYxNyw1ICs2MjcsMjggQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3Ry aW5nIHVybFN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291 cmNlSGFuZGxlOjpnZXRTZXNzaW9uKGNvbnN0IEZyYW1lICpmcmFtZSkKK3sKKyAgICBzdGF0aWMg U291cFNlc3Npb24qIGRlZmF1bHRfc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsK KworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiBkZWZhdWx0X3Nlc3Npb247CisgICAg RnJhbWVMb2FkZXIgKmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikK KyAgICAgICAgcmV0dXJuIDA7CisgICAgU291cFNlc3Npb24qIHNlc3Npb24gPSBzdGF0aWNfY2Fz dDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+Y2xpZW50KCkpLT5zZXNzaW9uKCk7CisgICAg cmV0dXJuIHNlc3Npb24gPyBzZXNzaW9uIDogZGVmYXVsdF9zZXNzaW9uOworfQorCit2b2lkIFJl c291cmNlSGFuZGxlOjpzZXRTZXNzaW9uKGNvbnN0IEZyYW1lICpmcmFtZSwgU291cFNlc3Npb24g KnNlc3Npb24pCit7CisgICAgaWYgKCFmcmFtZSkKKyAgICAgICAgcmV0dXJuOworICAgIEZyYW1l TG9hZGVyICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAg ICAgIHJldHVybjsKKyAgICBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+ Y2xpZW50KCkpLT5zZXRTZXNzaW9uKHNlc3Npb24pOworfQorCiB9CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmggYi9XZWJLaXQvZ3RrL1dl YkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0ay5oCmluZGV4IDI5OWQwMjMuLmVhNTRiZjcgMTAw NjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmgKKysr IGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaApAQCAtMjIsNiAr MjIsNyBAQAogCiAjaW5jbHVkZSAiQ2hyb21lQ2xpZW50LmgiCiAjaW5jbHVkZSAiS1VSTC5oIgor I2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViVmll dyBXZWJLaXRXZWJWaWV3OwogCkBAIC0zMSw2ICszMiw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewog ICAgIHB1YmxpYzoKICAgICAgICAgQ2hyb21lQ2xpZW50KFdlYktpdFdlYlZpZXcqKTsKICAgICAg ICAgV2ViS2l0V2ViVmlldyogd2ViVmlldygpIGNvbnN0IHsgcmV0dXJuIG1fd2ViVmlldzsgfQor ICAgICAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbigpOwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCBj aHJvbWVEZXN0cm95ZWQoKTsKIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Zy YW1lTG9hZGVyQ2xpZW50R3RrLmNwcAppbmRleCAxYjQxMGM3Li42NTBhM2U2IDEwMDY0NAotLS0g YS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcAorKysg Yi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcApAQCAt NjQsNiArNjQsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAogRnJhbWVMb2FkZXJDbGllbnQ6OkZy YW1lTG9hZGVyQ2xpZW50KFdlYktpdFdlYkZyYW1lKiBmcmFtZSkKICAgICA6IG1fZnJhbWUoZnJh bWUpCisgICAgLCBtX3Nlc3Npb24oMCkKICAgICAsIG1fdXNlckFnZW50KCIiKQogICAgICwgbV9w b2xpY3lEZWNpc2lvbigwKQogICAgICwgbV9wbHVnaW5WaWV3KDApCkBAIC04NzUsNCArODc2LDE0 IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZEZvck5ld1Bh Z2UoKQogICAgIGZyYW1lLT52aWV3KCktPnNldEd0a0FkanVzdG1lbnRzKHByaXYtPmhvcml6b250 YWxBZGp1c3RtZW50LCBwcml2LT52ZXJ0aWNhbEFkanVzdG1lbnQpOwogfQogCitTb3VwU2Vzc2lv biogRnJhbWVMb2FkZXJDbGllbnQ6OnNlc3Npb24oKQoreworICAgIHJldHVybiBtX3Nlc3Npb247 Cit9CisKK3ZvaWQgRnJhbWVMb2FkZXJDbGllbnQ6OnNldFNlc3Npb24oU291cFNlc3Npb24qIHNl c3Npb24pCit7CisgICAgbV9zZXNzaW9uID0gc2Vzc2lvbjsKK30KKwogfQpkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oIGIvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCmluZGV4IGM2OTUyZGIu LjIzZDI5YzEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuaAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmgKQEAgLTM0LDYgKzM0LDcgQEAKICNpbmNsdWRlICJSZXNvdXJjZVJlc3BvbnNl LmgiCiAjaW5jbHVkZSAiUGx1Z2luVmlldy5oIgogI2luY2x1ZGUgIndlYmtpdHdlYnBvbGljeWRl Y2lzaW9uLmgiCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIHR5cGVkZWYgc3RydWN0IF9X ZWJLaXRXZWJGcmFtZSBXZWJLaXRXZWJGcmFtZTsKIApAQCAtMTY5LDggKzE3MCwxMiBAQCBuYW1l c3BhY2UgV2ViS2l0IHsKIAogICAgICAgICB2aXJ0dWFsIGJvb2wgY2FuQ2FjaGVQYWdlKCkgY29u c3Q7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBkb3dubG9hZChXZWJDb3JlOjpSZXNvdXJjZUhhbmRs ZSosIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291 cmNlUmVxdWVzdCYsIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UmKTsKKworICAgICAg ICB2aXJ0dWFsIFNvdXBTZXNzaW9uKiBzZXNzaW9uKCk7CisgICAgICAgIHZpcnR1YWwgdm9pZCBz ZXRTZXNzaW9uKFNvdXBTZXNzaW9uKik7CiAgICAgcHJpdmF0ZToKICAgICAgICAgV2ViS2l0V2Vi RnJhbWUqIG1fZnJhbWU7CisgICAgICAgIFNvdXBTZXNzaW9uKiBtX3Nlc3Npb247CiAgICAgICAg IFdlYkNvcmU6OlJlc291cmNlUmVzcG9uc2UgbV9yZXNwb25zZTsKICAgICAgICAgV2ViQ29yZTo6 U3RyaW5nIG1fdXNlckFnZW50OwogICAgICAgICBXZWJLaXRXZWJQb2xpY3lEZWNpc2lvbiogbV9w b2xpY3lEZWNpc2lvbjsKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluIGIvV2Vi S2l0L2d0ay93ZWJraXQucGMuaW4KaW5kZXggMGNlNmY3MS4uODRkNjExNSAxMDA2NDQKLS0tIGEv V2ViS2l0L2d0ay93ZWJraXQucGMuaW4KKysrIGIvV2ViS2l0L2d0ay93ZWJraXQucGMuaW4KQEAg LTYsNiArNiw2IEBAIGluY2x1ZGVkaXI9QGluY2x1ZGVkaXJACiBOYW1lOiBXZWJLaXQKIERlc2Ny aXB0aW9uOiBXZWIgY29udGVudCBlbmdpbmUgZm9yIEdUSysKIFZlcnNpb246IEBWRVJTSU9OQAot UmVxdWlyZXM6IGd0aystMi4wCitSZXF1aXJlczogZ3RrKy0yLjAgbGlic291cC0yLjQKIExpYnM6 IC1MJHtsaWJkaXJ9IC1sd2Via2l0LTEuMAogQ2ZsYWdzOiAtSSR7aW5jbHVkZWRpcn0vd2Via2l0 LTEuMApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCAzNThhY2U5Li44MmUyMGVi IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtNTksNiArNTksNyBAQAogI2lu Y2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUtleWJvYXJkRXZl bnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJj ZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFy LmgiCiAjaW5jbHVkZSAiU3Vic3RpdHV0ZURhdGEuaCIKQEAgLTE0Niw3ICsxNDcsOCBAQCBlbnVt IHsKICAgICBQUk9QX1dJTkRPV19GRUFUVVJFUywKICAgICBQUk9QX1RSQU5TUEFSRU5ULAogICAg IFBST1BfWk9PTV9MRVZFTCwKLSAgICBQUk9QX0ZVTExfQ09OVEVOVF9aT09NCisgICAgUFJPUF9G VUxMX0NPTlRFTlRfWk9PTSwKKyAgICBQUk9QX1NFU1NJT04sCiB9OwogCiBzdGF0aWMgZ3VpbnQg d2Via2l0X3dlYl92aWV3X3NpZ25hbHNbTEFTVF9TSUdOQUxdID0geyAwLCB9OwpAQCAtMzA0LDYg KzMwNiw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19nZXRfcHJvcGVydHkoR09iamVj dCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBHVmFsdWUqCiAgICAgY2FzZSBQUk9QX0ZVTExfQ09O VEVOVF9aT09NOgogICAgICAgICBnX3ZhbHVlX3NldF9ib29sZWFuKHZhbHVlLCB3ZWJraXRfd2Vi X3ZpZXdfZ2V0X2Z1bGxfY29udGVudF96b29tKHdlYlZpZXcpKTsKICAgICAgICAgYnJlYWs7Cisg ICAgY2FzZSBQUk9QX1NFU1NJT046CisgICAgICAgIGdfdmFsdWVfc2V0X29iamVjdCh2YWx1ZSwg d2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKHdlYlZpZXcpKTsKKyAgICAgICAgYnJlYWs7CiAg ICAgZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9i amVjdCwgcHJvcF9pZCwgcHNwZWMpOwogICAgIH0KQEAgLTMzMiw2ICszMzcsOSBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQg cHJvcF9pZCwgY29uc3QgRwogICAgIGNhc2UgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTToKICAgICAg ICAgd2Via2l0X3dlYl92aWV3X3NldF9mdWxsX2NvbnRlbnRfem9vbSh3ZWJWaWV3LCBnX3ZhbHVl X2dldF9ib29sZWFuKHZhbHVlKSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9TRVNT SU9OOgorICAgICAgICB3ZWJraXRfd2ViX3ZpZXdfc2V0X3Nlc3Npb24od2ViVmlldywgU09VUF9T RVNTSU9OKGdfdmFsdWVfZ2V0X29iamVjdCh2YWx1ZSkpKTsKKyAgICAgICAgYnJlYWs7CiAgICAg ZGVmYXVsdDoKICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVj dCwgcHJvcF9pZCwgcHNwZWMpOwogICAgIH0KQEAgLTE1NjksNiArMTU3NywyMCBAQCBzdGF0aWMg dm9pZCB3ZWJraXRfd2ViX3ZpZXdfY2xhc3NfaW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdlYlZp ZXdDbGFzcykKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEZBTFNFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOwogCisgICAgLyoqCisg ICAgKiBXZWJLaXRXZWJWaWV3OnNlc3Npb246CisgICAgKgorICAgICogUmV0cmlldmVzIHRoZSBz ZXNzaW9uIG9mIHRoZSB2aWV3LgorICAgICoKKyAgICAqIFNpbmNlOiAxLjEuMQorICAgICovCisg ICAgZ19vYmplY3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJPUF9TRVNT SU9OLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVjX29i amVjdCgic2Vzc2lvbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJTZXNzaW9uIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIlJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUg dmlldyIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFNPVVBfVFlQRV9TRVNTSU9OLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdSSVRFKSk7CisKICAg ICBnX3R5cGVfY2xhc3NfYWRkX3ByaXZhdGUod2ViVmlld0NsYXNzLCBzaXplb2YoV2ViS2l0V2Vi Vmlld1ByaXZhdGUpKTsKIH0KIApAQCAtMjY3Miw0ICsyNjk0LDc0IEBAIHZvaWQgd2Via2l0X3dl Yl92aWV3X3NldF9mdWxsX2NvbnRlbnRfem9vbShXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3LCBnYm9v bGVhbiB6b29tCiAgICAgZ19vYmplY3Rfbm90aWZ5KEdfT0JKRUNUKHdlYlZpZXcpLCAiZnVsbC1j b250ZW50LXpvb20iKTsKIH0KIAorLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb246 CisgKiBAd2ViX3ZpZXc6IGEgI1dlYktpdFdlYlZpZXcKKyAqCisgKiBSZXRyaWV2ZXMgdGhlICNT b3VwU2Vzc2lvbiBvZiB0aGUgdmlldywgY3JlYXRlZCB3aGVuIHRoaXMKKyAqIGZ1bmN0aW9uIGlz IGNhbGxlZCBmb3IgdGhlIGZpcnN0IHRpbWUuCisgKgorICogRG9uJ3QgdXNlIHRoaXMgZnVuY3Rp b24gdW5sZXNzIHlvdSBpbnRlbmQgdG8gbWFuYWdlIHNlc3Npb25zCisgKiBmb3IgeW91ciB3ZWIg dmlld3Mgb24geW91ciBvd24uIFNlZSBhbHNvIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vzc2lvbigp LgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlICNTb3VwU2Vzc2lvbiBvZiB0aGUgdmlldworICoK KyAqIFNpbmNlOiAxLjEuMQorICovCitTb3VwU2Vzc2lvbiogd2Via2l0X3dlYl92aWV3X2dldF9z ZXNzaW9uIChXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KQoreworICAgIFNvdXBTZXNzaW9uKiBzZXNz aW9uOworCisgICAgZ19yZXR1cm5fdmFsX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZp ZXcpLCBOVUxMKTsKKworICAgIHNlc3Npb24gPSBSZXNvdXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbihj b3JlKHdlYlZpZXctPnByaXYtPm1haW5GcmFtZSkpOworICAgIGlmICghc2Vzc2lvbikgeworICAg ICAgICBzZXNzaW9uID0gc291cF9zZXNzaW9uX2FzeW5jX25ldyAoKTsKKyAgICAgICAgUmVzb3Vy Y2VIYW5kbGU6OnNldFNlc3Npb24oY29yZSh3ZWJWaWV3LT5wcml2LT5tYWluRnJhbWUpLCBzZXNz aW9uKTsKKyAgICB9CisgICAgcmV0dXJuIHNlc3Npb247Cit9CisKKy8qKgorICogd2Via2l0X3dl Yl92aWV3X3NldF9zZXNzaW9uOgorICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3CisgKiBA c2Vzc2lvbjogYSAjU291cFNlc3Npb24KKyAqCisgKiBBc3NpZ25zIGEgcGFydGljdWxhciBzZXNz aW9uIHRvIHRoZSB3ZWIgdmlldy4gSXQgaXMgcmVjb21tZW5kZWQKKyAqIHRoYXQgeW91IG9ubHkg dXNlIHNlc3Npb25zIHJldHVybmVkIGJ5IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbigpCisg KiBvciB3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbigpLgorICoKKyAqIERvbid0IHVzZSB0aGlz IGZ1bmN0aW9uIHVubGVzcyB5b3UgaW50ZW5kIHRvIG1hbmFnZSBzZXNzaW9ucworICogZm9yIHlv dXIgd2ViIHZpZXdzIG9uIHlvdXIgb3duLiBTZWUgYWxzbyB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nl c3Npb24oKS4KKyAqCisgKiBTaW5jZTogMS4xLjEKKyAqLwordm9pZCB3ZWJraXRfd2ViX3ZpZXdf c2V0X3Nlc3Npb24gKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgU291cFNlc3Npb24qICAgc2Vzc2lvbikKK3sKKyAgICBnX3JldHVybl9p Zl9mYWlsKFdFQktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSk7CisgICAgZ19yZXR1cm5faWZfZmFp bChTT1VQX0lTX1NFU1NJT05fQVNZTkMoc2Vzc2lvbikpOworCisgICAgUmVzb3VyY2VIYW5kbGU6 OnNldFNlc3Npb24oY29yZSh3ZWJWaWV3LT5wcml2LT5tYWluRnJhbWUpLCBzZXNzaW9uKTsKK30K KworLyoqCisgKiB3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbjoKKyAqCisgKiBSZXRyaWV2ZXMg dGhlIGRlZmF1bHQgI1NvdXBTZXNzaW9uIHVzZWQgYnkgYWxsIHdlYiB2aWV3cyB1bmxlc3MKKyAq IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbigpIGlzIGNhbGxlZC4KKyAqCisgKiBUaGUgc2Vz c2lvbiBpcyBpbml0aWFsbHkgZW1wdHkuIFVwb24gdGhlIGZpcnN0IGxvYWQKKyAqIGEgY29va2ll IGphciB3aWxsIGJlIGFkZGVkLiBIb3dldmVyIHlvdSBjYW4KKyAqIGFkZCB5b3VyIG93biBjb29r aWUgamFyIGFuZCBXZWJLaXQgd2lsbCB1c2UgaXQuCisgKgorICogUmV0dXJuIHZhbHVlOiB0aGUg ZGVmYXVsdCAjU291cFNlc3Npb24KKyAqCisgKiBTaW5jZTogMS4xLjEKKyAqLworU291cFNlc3Np b24qIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uICh2b2lkKQoreworICAgIHJldHVybiBSZXNv dXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbigwKTsKK30KKwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQvd2Via2l0d2Vidmlldy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmll dy5oCmluZGV4IDJiYjhjNjEuLjFhOWJmNTggMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHdlYnZpZXcuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgK QEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2ViYmFja2ZvcndhcmRs aXN0Lmg+CiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmhpc3RvcnlpdGVtLmg+CiAjaW5jbHVk ZSA8d2Via2l0L3dlYmtpdHdlYnNldHRpbmdzLmg+CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+ CiAKIEdfQkVHSU5fREVDTFMKIApAQCAtMjk2LDYgKzI5NywxNiBAQCBXRUJLSVRfQVBJIHZvaWQK IHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250ZW50X3pvb20gICAgICAgICAgIChXZWJLaXRX ZWJWaWV3ICAgICAgICAqd2ViX3ZpZXcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgZ2Jvb2xlYW4gICAgICAgICAgICAgIGZ1bGxfY29udGVudF96b29t KTsKIAorV0VCS0lUX0FQSSBTb3VwU2Vzc2lvbioKK3dlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lv biAgICAgICAgICAgICAgICAgICAgIChXZWJLaXRXZWJWaWV3ICAgICAgICAqd2ViX3ZpZXcpOwor CitXRUJLSVRfQVBJIHZvaWQKK3dlYmtpdF93ZWJfdmlld19zZXRfc2Vzc2lvbiAgICAgICAgICAg ICAgICAgICAgIChXZWJLaXRXZWJWaWV3ICAgICAgICAqd2ViX3ZpZXcsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU291cFNlc3Npb24gICAgICAgICAg KnNlc3Npb24pOworCitXRUJLSVRfQVBJIFNvdXBTZXNzaW9uKgord2Via2l0X2dldF9kZWZhdWx0 X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAgKHZvaWQpOworCiBHX0VORF9ERUNMUwogCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtIGIvV2ViS2l0VG9v bHMvR05VbWFrZWZpbGUuYW0KaW5kZXggMjYyMDBjOC4uNDQxYmMwMiAxMDA2NDQKLS0tIGEvV2Vi S2l0VG9vbHMvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0K QEAgLTIwLDYgKzIwLDcgQEAgUHJvZ3JhbXNfR3RrTGF1bmNoZXJfQ0ZMQUdTID0gXAogCS1mbm8t c3RyaWN0LWFsaWFzaW5nIFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAorCSQoTElCU09V UF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFByb2dyYW1zX0d0a0xhdW5jaGVyX0xEQURE ID0gXApAQCAtNjcsNiArNjgsNyBAQCBQcm9ncmFtc19EdW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBc CiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTE9CQUxERVBTX0NGTEFHUykgXAogCSQoQ0FJUk9f Q0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykKIAogUHJvZ3Jh bXNfRHVtcFJlbmRlclRyZWVfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9HdGtM YXVuY2hlci9tYWluLmMgYi9XZWJLaXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKaW5kZXggOGVk MjY5MC4uMzhjYjVlYyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5j CisrKyBiL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYwpAQCAtMTgyLDYgKzE4Miw4IEBA IGNyZWF0ZV93aW5kb3cgKCkKIGludAogbWFpbiAoaW50IGFyZ2MsIGNoYXIqIGFyZ3ZbXSkKIHsK KyAgICBpZiAoIWdfdGhyZWFkX3N1cHBvcnRlZCAoKSkKKyAgICAgICAgZ190aHJlYWRfaW5pdCAo TlVMTCk7CiAgICAgZ3RrX2luaXQgKCZhcmdjLCAmYXJndik7CiAKICAgICBHdGtXaWRnZXQqIHZi b3ggPSBndGtfdmJveF9uZXcgKEZBTFNFLCAwKTsKZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBi L2NvbmZpZ3VyZS5hYwppbmRleCA2YWM2ZjhiLi43ZjFjNDlmIDEwMDY0NAotLS0gYS9jb25maWd1 cmUuYWMKKysrIGIvY29uZmlndXJlLmFjCkBAIC0yODYsMjAgKzI4Niw2IEBAIGlmIHRlc3QgIiR3 aXRoX2hpbGRvbiIgPSAieWVzIjsgdGhlbgogICAgIEFDX1NVQlNUKFtISUxET05fTElCU10pCiBm aQogCi0jIGRldGVybWluZSB0aGUgaHR0cCBiYWNrZW5kCi1BQ19NU0dfQ0hFQ0tJTkcoW3RoZSBI VFRQIGJhY2tlbmQgdG8gdXNlXSkKLUFDX0FSR19XSVRIKGh0dHBfYmFja2VuZCwKLSAgICAgICAg ICAgIEFDX0hFTFBfU1RSSU5HKFstLXdpdGgtaHR0cC1iYWNrZW5kPUA8OkBjdXJsL3NvdXBAOj5A XSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIFtTZWxlY3QgSFRUUCBiYWNrZW5kIFtkZWZh dWx0PWN1cmxdXSksCi0gICAgICAgICAgICBbXSxbd2l0aF9odHRwX2JhY2tlbmQ9ImN1cmwiXSkK LQotY2FzZSAiJHdpdGhfaHR0cF9iYWNrZW5kIiBpbgotICAgICBjdXJsfHNvdXApIDs7Ci0gICAg ICopIEFDX01TR19FUlJPUihbSW52YWxpZCBIVFRQIGJhY2tlbmQ6IG11c3QgYmUgY3VybCwgc291 cC5dKSA7OwotZXNhYwotCi1BQ19NU0dfUkVTVUxUKFskd2l0aF9odHRwX2JhY2tlbmRdKQotCiAj IG1pbmltdW0gYmFzZSBkZXBlbmRlbmNpZXMKIENBSVJPX1JFUVVJUkVEX1ZFUlNJT049MS4yCiBG T05UQ09ORklHX1JFUVVJUkVEX1ZFUlNJT049Mi40CkBAIC0zMTQsOCArMzAwLDcgQEAgUEFOR09f UkVRVUlSRURfVkVSU0lPTj0xLjAKIEdUS19SRVFVSVJFRF9WRVJTSU9OPTIuOAogCiAjIG9wdGlv bmFsIG1vZHVsZXMKLUxJQkNVUkxfUkVRVUlSRURfVkVSU0lPTj03LjE1Ci1MSUJTT1VQX1JFUVVJ UkVEX1ZFUlNJT049Mi4yMworTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OPTIuMjUuNAogTElCWFNM VF9SRVFVSVJFRF9WRVJTSU9OPTEuMS43CiBTUUxJVEVfUkVRVUlSRURfVkVSU0lPTj0zLjAKIEdT VFJFQU1FUl9SRVFVSVJFRF9WRVJTSU9OPTAuMTAKQEAgLTYyNCwyMyArNjA5LDExIEBAIGVsc2UK ICAgIENGTEFHUz0iJENGTEFHUyAtTzAiCiBmaQogCi0jIGNoZWNrIGlmIGN1cmwgaXMgYXZhaWxh YmxlCi1pZiB0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gImN1cmwiOyB0aGVuCi0gICBQS0df Q0hFQ0tfTU9EVUxFUyhbTElCQ1VSTF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGliY3VybCA+ PSAkTElCQ1VSTF9SRVFVSVJFRF9WRVJTSU9OXSkKLSAgIGlmIHRlc3QgIiRvc193aW4zMiIgPSAi eWVzIjsgdGhlbgotICAgICAgTElCQ1VSTF9MSUJTPSIkTElCQ1VSTF9MSUJTIC1sd3MyXzMyIgot ICAgZmkKLSAgIEFDX1NVQlNUKFtMSUJDVVJMX0NGTEFHU10pCi0gICBBQ19TVUJTVChbTElCQ1VS TF9MSUJTXSkKLWZpCiAKLWlmIHRlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAic291cCI7IHRo ZW4KLSAgIFBLR19DSEVDS19NT0RVTEVTKFtMSUJTT1VQXSwKLSAgICAgICAgICAgICAgICAgICAg IFtsaWJzb3VwLTIuNCA+PSAkTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OXSkKLSAgIEFDX1NVQlNU KFtMSUJTT1VQX0NGTEFHU10pCi0gICBBQ19TVUJTVChbTElCU09VUF9MSUJTXSkKLWZpCitQS0df Q0hFQ0tfTU9EVUxFUyhbTElCU09VUF0sCisgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQg Pj0gJExJQlNPVVBfUkVRVUlSRURfVkVSU0lPTl0pCitBQ19TVUJTVChbTElCU09VUF9DRkxBR1Nd KQorQUNfU1VCU1QoW0xJQlNPVVBfTElCU10pCiAKICMgY2hlY2sgaWYgRnJlZVR5cGUvRm9udENv bmZpZyBhcmUgYXZhaWxhYmxlCiBpZiB0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gImZyZWV0 eXBlIjsgdGhlbgpAQCAtNzEyLDEwICs2ODUsNiBAQCBBTV9DT05ESVRJT05BTChbVEFSR0VUX1dJ TjMyXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAid2luMzIiXSkKIEFNX0NPTkRJVElPTkFMKFtU QVJHRVRfUVVBUlRaXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAicXVhcnR6Il0pCiBBTV9DT05E SVRJT05BTChbVEFSR0VUX0RJUkVDVEZCXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAiZGlyZWN0 ZmIiXSkKIAotIyBIVFRQIGJhY2tlbmQgY29uZGl0aW9uYWxzCi1BTV9DT05ESVRJT05BTChbVVNF X0NVUkxdLCBbdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJjdXJsIl0pCi1BTV9DT05ESVRJ T05BTChbVVNFX1NPVVBdLCBbdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJzb3VwIl0pCi0K ICMgRm9udCBiYWNrZW5kIGNvbmRpdGlvbmFscwogQU1fQ09ORElUSU9OQUwoW1VTRV9GUkVFVFlQ RV0sIFt0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gImZyZWV0eXBlIl0pCiBBTV9DT05ESVRJ T05BTChbVVNFX1BBTkdPXSwgW3Rlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAicGFuZ28iXSkK QEAgLTc2Miw3ICs3MzEsNiBAQCBCdWlsZCBjb25maWd1cmF0aW9uOgogIEVuYWJsZSBHQ0MgYnVp bGQgb3B0aW1pemF0aW9uICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9vcHRp bWl6YXRpb25zCiAgQ29kZSBjb3ZlcmFnZSBzdXBwb3J0ICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgOiAkZW5hYmxlX2NvdmVyYWdlCiAgVW5pY29kZSBiYWNrZW5kICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkdW5pY29kZV9iYWNrZW5kCi0gSFRU UCBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAk d2l0aF9odHRwX2JhY2tlbmQKICBGb250IGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICA6ICR3aXRoX2ZvbnRfYmFja2VuZAogIE9wdGltaXplZCBtZW1v cnkgYWxsb2NhdG9yICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9mYXN0 X21hbGxvYwogRmVhdHVyZXM6Cg== 26836 2009-01-18 14:43:23 -0800 2009-01-24 08:37:11 -0800 API to retrieve and set soup sessions #6 p.diff text/plain 24215 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAzMDMyZDI2Li45Njk0NGVjIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NTUsMzEgKzE3NTUsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xNzkzLDcgKzE3NjgsNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVM b2FkZXJDbGllbnQuaAppbmRleCA0NGFiNGE0Li45M2I0YTc2IDEwMDY0NAotLS0gYS9XZWJDb3Jl L2xvYWRlci9GcmFtZUxvYWRlckNsaWVudC5oCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyQ2xpZW50LmgKQEAgLTM1LDYgKzM1LDEwIEBACiAjaW5jbHVkZSA8d3RmL1BsYXRmb3JtLmg+ CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgogCisjaWYgUExBVEZPUk0oR1RLKQorI2luY2x1ZGUg PGxpYnNvdXAvc291cC5oPgorI2VuZGlmCisKIHR5cGVkZWYgY2xhc3MgX2pvYmplY3QqIGpvYmpl Y3Q7CiAKICNpZiBQTEFURk9STShNQUMpICYmICFkZWZpbmVkKF9fT0JKQ19fKQpAQCAtMjA5LDYg KzIxMywxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjZW5kaWYKICAgICAgICAgdmlydHVhbCBO U0NhY2hlZFVSTFJlc3BvbnNlKiB3aWxsQ2FjaGVSZXNwb25zZShEb2N1bWVudExvYWRlciosIHVu c2lnbmVkIGxvbmcgaWRlbnRpZmllciwgTlNDYWNoZWRVUkxSZXNwb25zZSopIGNvbnN0ID0gMDsK ICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICAgICAgdmlydHVhbCBTb3VwU2Vzc2lvbiog c2Vzc2lvbigpID0gMDsKKyAgICAgICAgdmlydHVhbCB2b2lkIHNldFNlc3Npb24oU291cFNlc3Np b24qKSA9IDA7CisjZW5kaWYKIAogICAgICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkVXNlUGx1Z2lu RG9jdW1lbnQoY29uc3QgU3RyaW5nJiBtaW1lVHlwZSkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0K IApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgg Yi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaAppbmRleCBjOTNhZjIx Li41MTVlMGVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGUuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaApA QCAtMzAsNiArMzAsMTAgQEAKICNpbmNsdWRlICJIVFRQSGVhZGVyTWFwLmgiCiAjaW5jbHVkZSA8 d3RmL093blB0ci5oPgogCisjaWYgVVNFKFNPVVApCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+ CisjZW5kaWYKKwogI2lmIFBMQVRGT1JNKENGKQogdHlwZWRlZiBjb25zdCBzdHJ1Y3QgX19DRkRh dGEgKiBDRkRhdGFSZWY7CiAjZW5kaWYKQEAgLTE1OSw2ICsxNjMsMTIgQEAgcHVibGljOgogICAg IFJlc291cmNlSGFuZGxlSW50ZXJuYWwqIGdldEludGVybmFsKCkgeyByZXR1cm4gZC5nZXQoKTsg fQogI2VuZGlmCiAKKyNpZiBVU0UoU09VUCkKKyAgICBzdGF0aWMgU291cFNlc3Npb24qIGdldERl ZmF1bHRTZXNzaW9uKCk7CisgICAgc3RhdGljIFNvdXBTZXNzaW9uKiBnZXRTZXNzaW9uKGNvbnN0 IEZyYW1lICpmcmFtZSk7CisgICAgc3RhdGljIHZvaWQgc2V0U2Vzc2lvbihjb25zdCBGcmFtZSAq ZnJhbWUsIFNvdXBTZXNzaW9uICpzZXNzaW9uKTsKKyNlbmRpZgorCiAgICAgLy8gVXNlZCB0byB3 b3JrIGFyb3VuZCB0aGUgZmFjdCB0aGF0IHlvdSBkb24ndCBnZXQgYW55IG1vcmUgTlNVUkxDb25u ZWN0aW9uIGNhbGxiYWNrcyB1bnRpbCB5b3UgcmV0dXJuIGZyb20gdGhlIG9uZSB5b3UncmUgaW4u CiAgICAgc3RhdGljIGJvb2wgbG9hZHNCbG9ja2VkKCk7ICAgIAogICAgIApAQCAtMTc4LDcgKzE4 OCw3IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAjaWYgVVNFKFNPVVApCiAgICAgYm9vbCBzdGFydERh dGEoU3RyaW5nIHVybFN0cmluZyk7Ci0gICAgYm9vbCBzdGFydEh0dHAoU3RyaW5nIHVybFN0cmlu Zyk7CisgICAgYm9vbCBzdGFydEh0dHAoU291cFNlc3Npb24qIHNlc3Npb24sIFN0cmluZyB1cmxT dHJpbmcpOwogICAgIGJvb2wgc3RhcnRHaW8oU3RyaW5nIHVybFN0cmluZyk7CiAjZW5kaWYKIApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJu YWwuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgK aW5kZXggNjZhYTRjMS4uNTg0NTQ4ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL1Jlc291cmNlSGFuZGxlSW50ZXJuYWwuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCkBAIC0xNzgsNiArMTc4LDcgQEAgbmFtZXNwYWNl IFdlYkNvcmUgewogICAgICAgICBWZWN0b3I8Y2hhcj4gbV9wb3N0Qnl0ZXM7CiAjZW5kaWYKICNp ZiBVU0UoU09VUCkKKyAgICAgICAgU291cFNlc3Npb24qIG1fc2Vzc2lvbjsKICAgICAgICAgU291 cE1lc3NhZ2UqIG1fbXNnOwogICAgICAgICBSZXNvdXJjZVJlc3BvbnNlIG1fcmVzcG9uc2U7CiAg ICAgICAgIGJvb2wgbV9jYW5jZWxsZWQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL0Nvb2tpZUphclNvdXAuY3BwCmluZGV4IDg4MTA5ZTguLmU2NDdlMjEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCisrKyBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCkBAIC0yMiwxOCAr MjIsMjggQEAKIAogI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJLVVJMLmgiCisjaW5j bHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkZyYW1l TG9hZGVyQ2xpZW50LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotU291cENvb2tpZUphciog Z2V0Q29va2llSmFyKCkKK1NvdXBDb29raWVKYXIqIGdldENvb2tpZUphcihjb25zdCBEb2N1bWVu dCogZG9jdW1lbnQpCiB7Ci0gICAgc3RhdGljIFNvdXBDb29raWVKYXIqIGphciA9IHNvdXBfY29v a2llX2phcl9uZXcoKTsKKyAgICBGcmFtZSAqZnJhbWUgPSBkb2N1bWVudC0+ZnJhbWUoKTsKKyAg ICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm4gMDsKKyAgICBGcmFtZUxvYWRlciAqbG9hZGVy ID0gZnJhbWUtPmxvYWRlcigpOworICAgIGlmICghbG9hZGVyKQorICAgICAgICByZXR1cm4gMDsK KyAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9IHN0YXRpY19jYXN0PEZyYW1lTG9hZGVyQ2xpZW50 Kj4obG9hZGVyLT5jbGllbnQoKSktPnNlc3Npb24oKTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIg PSAoU291cENvb2tpZUphciopc291cF9zZXNzaW9uX2dldF9mZWF0dXJlKHNlc3Npb24sIFNPVVBf VFlQRV9DT09LSUVfSkFSKTsKICAgICByZXR1cm4gamFyOwogfQogCi12b2lkIHNldENvb2tpZXMo RG9jdW1lbnQqIC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBLVVJMJiAvKnBv bGljeVVSTCovLCBjb25zdCBTdHJpbmcmIHZhbHVlKQordm9pZCBzZXRDb29raWVzKERvY3VtZW50 KiBkb2N1bWVudCwgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBLVVJMJiAvKnBvbGljeVVSTCovLCBj b25zdCBTdHJpbmcmIHZhbHVlKQogewotICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tp ZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENvb2tpZUphcihkb2N1bWVudCk7 CiAgICAgaWYgKCFqYXIpCiAgICAgICAgIHJldHVybjsKIApAQCAtNDMsOSArNTMsOSBAQCB2b2lk IHNldENvb2tpZXMoRG9jdW1lbnQqIC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYgdXJsLCBjb25z dCBLVVJMJiAvKnBvbGljeVVSTAogICAgIHNvdXBfdXJpX2ZyZWUob3JpZ2luKTsKIH0KIAotU3Ry aW5nIGNvb2tpZXMoY29uc3QgRG9jdW1lbnQqIC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYgdXJs KQorU3RyaW5nIGNvb2tpZXMoY29uc3QgRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBLVVJMJiB1 cmwpCiB7Ci0gICAgU291cENvb2tpZUphciogamFyID0gZ2V0Q29va2llSmFyKCk7CisgICAgU291 cENvb2tpZUphciogamFyID0gZ2V0Q29va2llSmFyKGRvY3VtZW50KTsKICAgICBpZiAoIWphcikK ICAgICAgICAgcmV0dXJuIFN0cmluZygpOwogCkBAIC01OSw5ICs2OSw5IEBAIFN0cmluZyBjb29r aWVzKGNvbnN0IERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCkKICAgICBy ZXR1cm4gcmVzdWx0OwogfQogCi1ib29sIGNvb2tpZXNFbmFibGVkKGNvbnN0IERvY3VtZW50KiAv KmRvY3VtZW50Ki8pCitib29sIGNvb2tpZXNFbmFibGVkKGNvbnN0IERvY3VtZW50KiBkb2N1bWVu dCkKIHsKLSAgICByZXR1cm4gZ2V0Q29va2llSmFyKCk7CisgICAgcmV0dXJuIGdldENvb2tpZUph cihkb2N1bWVudCk7CiB9CiAKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL0Nvb2tpZUphclNvdXAuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nv b2tpZUphclNvdXAuaAppbmRleCA2MTE3OWFlLi42ZTUxNjkyIDEwMDY0NAotLS0gYS9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKKysrIGIvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oCkBAIC0zMSw3ICszMSw3IEBACiAjaW5j bHVkZSA8bGlic291cC9zb3VwLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKLSAgICBTb3VwQ29v a2llSmFyKiBnZXRDb29raWVKYXIoKTsKKyAgICBTb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIo Y29uc3QgRG9jdW1lbnQqIGRvY3VtZW50KTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCA4MmFk MzZhLi5jMjdjYzNlIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9S ZXNvdXJjZUhhbmRsZVNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3Vw L1Jlc291cmNlSGFuZGxlU291cC5jcHAKQEAgLTI4LDYgKzI4LDggQEAKICNpbmNsdWRlICJDb29r aWVKYXJTb3VwLmgiCiAjaW5jbHVkZSAiRG9jTG9hZGVyLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIK KyNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyQ2xpZW50Lmgi CiAjaW5jbHVkZSAiSFRUUFBhcnNlcnMuaCIKICNpbmNsdWRlICJNSU1FVHlwZVJlZ2lzdHJ5Lmgi CiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKQEAgLTQ5LDggKzUxLDYgQEAKIAogbmFtZXNw YWNlIFdlYkNvcmUgewogCi1zdGF0aWMgU291cFNlc3Npb24qIHNlc3Npb24gPSAwOwotCiBlbnVt CiB7CiAgICAgRVJST1JfVFJBTlNQT1JULApAQCAtMTczLDYgKzE3Myw4IEBAIHN0YXRpYyB2b2lk IGZpbmlzaGVkQ2FsbGJhY2soU291cFNlc3Npb24gKnNlc3Npb24sIFNvdXBNZXNzYWdlKiBtc2cs IGdwb2ludGVyIGRhCiAgICAgICAgIHJldHVybjsKIAogICAgIFJlc291cmNlSGFuZGxlSW50ZXJu YWwqIGQgPSBoYW5kbGUtPmdldEludGVybmFsKCk7CisgICAgZ19vYmplY3RfdW5yZWYoZC0+bV9z ZXNzaW9uKTsKKyAgICBkLT5tX3Nlc3Npb24gPSBOVUxMOwogCiAgICAgUmVzb3VyY2VIYW5kbGVD bGllbnQqIGNsaWVudCA9IGhhbmRsZS0+Y2xpZW50KCk7CiAgICAgaWYgKCFjbGllbnQpCkBAIC0y ODIsMjIgKzI4NCwzMiBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFydERhdGEoU3RyaW5nIHVy bFN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3Rh cnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCitzdGF0aWMgdm9pZCBlbnN1cmVTZXNzaW9uKFNvdXBT ZXNzaW9uKiBzZXNzaW9uKQogewotICAgIGlmICghc2Vzc2lvbikgewotICAgICAgICBzZXNzaW9u ID0gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworICAgIGlmICghc2Vzc2lvbikKKyAgICAgICAg cmV0dXJuOwogCi0gICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQ X1NFU1NJT05fRkVBVFVSRShnZXRDb29raWVKYXIoKSkpOworICAgIFNvdXBDb29raWVKYXIqIGph ciA9IDA7CisgICAgY29uc3QgY2hhciogd2Via2l0X2RlYnVnID0gZ19nZXRlbnYoIldFQktJVF9E RUJVRyIpOwogCi0gICAgICAgIGNvbnN0IGNoYXIqIHNvdXBfZGVidWcgPSBnX2dldGVudigiV0VC S0lUX1NPVVBfTE9HR0lORyIpOwotICAgICAgICBpZiAoc291cF9kZWJ1ZykgewotICAgICAgICAg ICAgaW50IHNvdXBfZGVidWdfbGV2ZWwgPSBhdG9pKHNvdXBfZGVidWcpOworICAgIGphciA9IChT b3VwQ29va2llSmFyKilzb3VwX3Nlc3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBF X0NPT0tJRV9KQVIpOworICAgIGlmICghamFyKSB7CisgICAgICAgIGphciA9IHNvdXBfY29va2ll X2phcl9uZXcoKTsKKyAgICAgICAgc291cF9zZXNzaW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNP VVBfU0VTU0lPTl9GRUFUVVJFKGphcikpOworICAgICAgICBnX29iamVjdF91bnJlZihqYXIpOwor ICAgIH0KIAotICAgICAgICAgICAgU291cExvZ2dlciogbG9nZ2VyID0gc291cF9sb2dnZXJfbmV3 KHN0YXRpY19jYXN0PFNvdXBMb2dnZXJMb2dMZXZlbD4oc291cF9kZWJ1Z19sZXZlbCksIC0xKTsK LSAgICAgICAgICAgIHNvdXBfbG9nZ2VyX2F0dGFjaChsb2dnZXIsIHNlc3Npb24pOwotICAgICAg ICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsKLSAgICAgICAgfQorICAgIGlmIChzb3VwX3Nl c3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0xPR0dFUikgPT0gTlVMTAorICAg ICAgICAmJiB3ZWJraXRfZGVidWcgJiYgIXN0cmNtcCh3ZWJraXRfZGVidWcsICJuZXR3b3JrIikp IHsKKyAgICAgICAgU291cExvZ2dlciogbG9nZ2VyID0gc291cF9sb2dnZXJfbmV3KHN0YXRpY19j YXN0PFNvdXBMb2dnZXJMb2dMZXZlbD4oU09VUF9MT0dHRVJfTE9HX0JPRFkpLCAtMSk7CisgICAg ICAgIHNvdXBfbG9nZ2VyX2F0dGFjaChsb2dnZXIsIHNlc3Npb24pOworICAgICAgICBnX29iamVj dF91bnJlZihsb2dnZXIpOwogICAgIH0KK30KKworYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRI dHRwKFNvdXBTZXNzaW9uKiBzZXNzaW9uLCBTdHJpbmcgdXJsU3RyaW5nKQoreworICAgIGVuc3Vy ZVNlc3Npb24oc2Vzc2lvbik7CiAKICAgICBTb3VwTWVzc2FnZSogbXNnOwogICAgIG1zZyA9IHNv dXBfbWVzc2FnZV9uZXcocmVxdWVzdCgpLmh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCB1cmxT dHJpbmcudXRmOCgpLmRhdGEoKSk7CkBAIC0zMjgsOCArMzQwLDkgQEAgYm9vbCBSZXNvdXJjZUhh bmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBTT1VQX01FTU9SWV9DT1BZLCBib2R5LmRhdGEoKSwgYm9keS5zaXplKCkpOwog ICAgIH0KIAorICAgIGQtPm1fc2Vzc2lvbiA9IHN0YXRpY19jYXN0PFNvdXBTZXNzaW9uKj4oZ19v YmplY3RfcmVmKHNlc3Npb24pKTsKICAgICBkLT5tX21zZyA9IHN0YXRpY19jYXN0PFNvdXBNZXNz YWdlKj4oZ19vYmplY3RfcmVmKG1zZykpOwotICAgIHNvdXBfc2Vzc2lvbl9xdWV1ZV9tZXNzYWdl KHNlc3Npb24sIGQtPm1fbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKKyAgICBzb3VwX3Nl c3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBtc2csIGZpbmlzaGVkQ2FsbGJhY2ssIHRoaXMp OwogCiAgICAgcmV0dXJuIHRydWU7CiB9CkBAIC0zNTAsNyArMzYzLDcgQEAgYm9vbCBSZXNvdXJj ZUhhbmRsZTo6c3RhcnQoRnJhbWUqIGZyYW1lKQogICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZShw cm90b2NvbCwgImRhdGEiKSkKICAgICAgICAgcmV0dXJuIHN0YXJ0RGF0YSh1cmxTdHJpbmcpOwog ICAgIGVsc2UgaWYgKChlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImh0dHAiKSB8fCBlcXVh bElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImh0dHBzIikpICYmIFNPVVBfVVJJX1ZBTElEX0ZPUl9I VFRQKHNvdXBfdXJpX25ldyh1cmxTdHJpbmcudXRmOCgpLmRhdGEoKSkpKQotICAgICAgICByZXR1 cm4gc3RhcnRIdHRwKHVybFN0cmluZyk7CisgICAgICAgIHJldHVybiBzdGFydEh0dHAoZ2V0U2Vz c2lvbihmcmFtZSksIHVybFN0cmluZyk7CiAgICAgZWxzZSBpZiAoZXF1YWxJZ25vcmluZ0Nhc2Uo cHJvdG9jb2wsICJmaWxlIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJmdHAiKSB8 fCBlcXVhbElnbm9yaW5nQ2FzZShwcm90b2NvbCwgImZ0cHMiKSkKICAgICAgICAgLy8gRklYTUU6 IHNob3VsZCB3ZSBiZSBkb2luZyBhbnkgb3RoZXIgcHJvdG9jb2xzIGhlcmU/CiAgICAgICAgIHJl dHVybiBzdGFydEdpbyh1cmxTdHJpbmcpOwpAQCAtMzY4LDcgKzM4MSw3IEBAIHZvaWQgUmVzb3Vy Y2VIYW5kbGU6OmNhbmNlbCgpCiB7CiAgICAgZC0+bV9jYW5jZWxsZWQgPSB0cnVlOwogICAgIGlm IChkLT5tX21zZykgewotICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2Uoc2Vzc2lv biwgZC0+bV9tc2csIFNPVVBfU1RBVFVTX0NBTkNFTExFRCk7CisgICAgICAgIHNvdXBfc2Vzc2lv bl9jYW5jZWxfbWVzc2FnZShkLT5tX3Nlc3Npb24sIGQtPm1fbXNnLCBTT1VQX1NUQVRVU19DQU5D RUxMRUQpOwogICAgICAgICAvLyBGb3IgcmUtZW50cmFuY3kgdHJvdWJsZXMgd2UgY2FsbCBkaWRG aW5pc2hMb2FkaW5nIHdoZW4gdGhlIG1lc3NhZ2UgaGFzbid0IGJlZW4gaGFuZGxlZCB5ZXQuCiAg ICAgICAgIGQtPmNsaWVudCgpLT5kaWRGaW5pc2hMb2FkaW5nKHRoaXMpOwogICAgIH0gZWxzZSBp ZiAoZC0+bV9jYW5jZWxsYWJsZSkgewpAQCAtNjE3LDUgKzYzMCwzMiBAQCBib29sIFJlc291cmNl SGFuZGxlOjpzdGFydEdpbyhTdHJpbmcgdXJsU3RyaW5nKQogICAgIHJldHVybiB0cnVlOwogfQog CitTb3VwU2Vzc2lvbiogUmVzb3VyY2VIYW5kbGU6OmdldERlZmF1bHRTZXNzaW9uKCkKK3sKKyAg ICBzdGF0aWMgU291cFNlc3Npb24qIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3KCk7 CisgICAgcmV0dXJuIHNlc3Npb247Cit9CisKK1NvdXBTZXNzaW9uKiBSZXNvdXJjZUhhbmRsZTo6 Z2V0U2Vzc2lvbihjb25zdCBGcmFtZSAqZnJhbWUpCit7CisgICAgaWYgKCFmcmFtZSkKKyAgICAg ICAgcmV0dXJuIDA7CisgICAgRnJhbWVMb2FkZXIgKmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsK KyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0dXJuIDA7CisgICAgU291cFNlc3Npb24qIHNl c3Npb24gPSBzdGF0aWNfY2FzdDxGcmFtZUxvYWRlckNsaWVudCo+KGxvYWRlci0+Y2xpZW50KCkp LT5zZXNzaW9uKCk7CisgICAgcmV0dXJuIHNlc3Npb24gPyBzZXNzaW9uIDogZ2V0RGVmYXVsdFNl c3Npb24oKTsKK30KKwordm9pZCBSZXNvdXJjZUhhbmRsZTo6c2V0U2Vzc2lvbihjb25zdCBGcmFt ZSAqZnJhbWUsIFNvdXBTZXNzaW9uICpzZXNzaW9uKQoreworICAgIGlmICghZnJhbWUpCisgICAg ICAgIHJldHVybjsKKyAgICBGcmFtZUxvYWRlciAqbG9hZGVyID0gZnJhbWUtPmxvYWRlcigpOwor ICAgIGlmICghbG9hZGVyKQorICAgICAgICByZXR1cm47CisgICAgc3RhdGljX2Nhc3Q8RnJhbWVM b2FkZXJDbGllbnQqPihsb2FkZXItPmNsaWVudCgpKS0+c2V0U2Vzc2lvbihzZXNzaW9uKTsKK30K KwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVu dEd0ay5oIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaAppbmRl eCAyOTlkMDIzLi5lYTU0YmY3IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0 L0Nocm9tZUNsaWVudEd0ay5oCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21l Q2xpZW50R3RrLmgKQEAgLTIyLDYgKzIyLDcgQEAKIAogI2luY2x1ZGUgIkNocm9tZUNsaWVudC5o IgogI2luY2x1ZGUgIktVUkwuaCIKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogdHlwZWRl ZiBzdHJ1Y3QgX1dlYktpdFdlYlZpZXcgV2ViS2l0V2ViVmlldzsKIApAQCAtMzEsNiArMzIsNyBA QCBuYW1lc3BhY2UgV2ViS2l0IHsKICAgICBwdWJsaWM6CiAgICAgICAgIENocm9tZUNsaWVudChX ZWJLaXRXZWJWaWV3Kik7CiAgICAgICAgIFdlYktpdFdlYlZpZXcqIHdlYlZpZXcoKSBjb25zdCB7 IHJldHVybiBtX3dlYlZpZXc7IH0KKyAgICAgICAgU291cFNlc3Npb24qIHNlc3Npb24oKTsKIAog ICAgICAgICB2aXJ0dWFsIHZvaWQgY2hyb21lRGVzdHJveWVkKCk7CiAKZGlmZiAtLWdpdCBhL1dl YktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwIGIvV2ViS2l0 L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5jcHAKaW5kZXggMWI0MTBj Ny4uNjUwYTNlNiAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5jcHAKKysrIGIvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9GcmFtZUxv YWRlckNsaWVudEd0ay5jcHAKQEAgLTY0LDYgKzY0LDcgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAK IEZyYW1lTG9hZGVyQ2xpZW50OjpGcmFtZUxvYWRlckNsaWVudChXZWJLaXRXZWJGcmFtZSogZnJh bWUpCiAgICAgOiBtX2ZyYW1lKGZyYW1lKQorICAgICwgbV9zZXNzaW9uKDApCiAgICAgLCBtX3Vz ZXJBZ2VudCgiIikKICAgICAsIG1fcG9saWN5RGVjaXNpb24oMCkKICAgICAsIG1fcGx1Z2luVmll dygwKQpAQCAtODc1LDQgKzg3NiwxNCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50Ojp0cmFuc2l0 aW9uVG9Db21taXR0ZWRGb3JOZXdQYWdlKCkKICAgICBmcmFtZS0+dmlldygpLT5zZXRHdGtBZGp1 c3RtZW50cyhwcml2LT5ob3Jpem9udGFsQWRqdXN0bWVudCwgcHJpdi0+dmVydGljYWxBZGp1c3Rt ZW50KTsKIH0KIAorU291cFNlc3Npb24qIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXNzaW9uKCkKK3sK KyAgICByZXR1cm4gbV9zZXNzaW9uOworfQorCit2b2lkIEZyYW1lTG9hZGVyQ2xpZW50OjpzZXRT ZXNzaW9uKFNvdXBTZXNzaW9uKiBzZXNzaW9uKQoreworICAgIG1fc2Vzc2lvbiA9IHNlc3Npb247 Cit9CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2Fk ZXJDbGllbnRHdGsuaCBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuaAppbmRleCBjNjk1MmRiLi4yM2QyOWMxIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL1dl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmgKKysrIGIvV2ViS2l0L2d0ay9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCkBAIC0zNCw2ICszNCw3IEBACiAjaW5j bHVkZSAiUmVzb3VyY2VSZXNwb25zZS5oIgogI2luY2x1ZGUgIlBsdWdpblZpZXcuaCIKICNpbmNs dWRlICJ3ZWJraXR3ZWJwb2xpY3lkZWNpc2lvbi5oIgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5o PgogCiB0eXBlZGVmIHN0cnVjdCBfV2ViS2l0V2ViRnJhbWUgV2ViS2l0V2ViRnJhbWU7CiAKQEAg LTE2OSw4ICsxNzAsMTIgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAKICAgICAgICAgdmlydHVhbCBi b29sIGNhbkNhY2hlUGFnZSgpIGNvbnN0OwogICAgICAgICB2aXJ0dWFsIHZvaWQgZG93bmxvYWQo V2ViQ29yZTo6UmVzb3VyY2VIYW5kbGUqLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm LCBjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmLCBjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlc3BvbnNlJik7CisKKyAgICAgICAgdmlydHVhbCBTb3VwU2Vzc2lvbiogc2Vzc2lvbigpOwor ICAgICAgICB2aXJ0dWFsIHZvaWQgc2V0U2Vzc2lvbihTb3VwU2Vzc2lvbiopOwogICAgIHByaXZh dGU6CiAgICAgICAgIFdlYktpdFdlYkZyYW1lKiBtX2ZyYW1lOworICAgICAgICBTb3VwU2Vzc2lv biogbV9zZXNzaW9uOwogICAgICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlc3BvbnNlIG1fcmVzcG9u c2U7CiAgICAgICAgIFdlYkNvcmU6OlN0cmluZyBtX3VzZXJBZ2VudDsKICAgICAgICAgV2ViS2l0 V2ViUG9saWN5RGVjaXNpb24qIG1fcG9saWN5RGVjaXNpb247CmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCmluZGV4IDBjZTZmNzEu Ljg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCisrKyBiL1dlYktp dC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRlZGlyPUBpbmNsdWRlZGly QAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQgZW5naW5lIGZvciBHVEsr CiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAorUmVxdWlyZXM6IGd0ayst Mi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtpdC0xLjAKIENmbGFnczog LUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0 L3dlYmtpdHdlYnZpZXcuY3BwIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAK aW5kZXggMzU4YWNlOS4uN2FlZDhjOCAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Vi a2l0d2Vidmlldy5jcHAKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAK QEAgLTU5LDYgKzU5LDcgQEAKICNpbmNsdWRlICJQYXN0ZWJvYXJkSGVscGVyLmgiCiAjaW5jbHVk ZSAiUGxhdGZvcm1LZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiUGxhdGZvcm1XaGVlbEV2ZW50 LmgiCisjaW5jbHVkZSAiUmVzb3VyY2VIYW5kbGUuaCIKICNpbmNsdWRlICJTY3JpcHRWYWx1ZS5o IgogI2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlN1YnN0aXR1dGVEYXRhLmgiCkBA IC0xNDYsNyArMTQ3LDggQEAgZW51bSB7CiAgICAgUFJPUF9XSU5ET1dfRkVBVFVSRVMsCiAgICAg UFJPUF9UUkFOU1BBUkVOVCwKICAgICBQUk9QX1pPT01fTEVWRUwsCi0gICAgUFJPUF9GVUxMX0NP TlRFTlRfWk9PTQorICAgIFBST1BfRlVMTF9DT05URU5UX1pPT00sCisgICAgUFJPUF9TRVNTSU9O LAogfTsKIAogc3RhdGljIGd1aW50IHdlYmtpdF93ZWJfdmlld19zaWduYWxzW0xBU1RfU0lHTkFM XSA9IHsgMCwgfTsKQEAgLTMwNCw2ICszMDYsOSBAQCBzdGF0aWMgdm9pZCB3ZWJraXRfd2ViX3Zp ZXdfZ2V0X3Byb3BlcnR5KEdPYmplY3QqIG9iamVjdCwgZ3VpbnQgcHJvcF9pZCwgR1ZhbHVlKgog ICAgIGNhc2UgUFJPUF9GVUxMX0NPTlRFTlRfWk9PTToKICAgICAgICAgZ192YWx1ZV9zZXRfYm9v bGVhbih2YWx1ZSwgd2Via2l0X3dlYl92aWV3X2dldF9mdWxsX2NvbnRlbnRfem9vbSh3ZWJWaWV3 KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgUFJPUF9TRVNTSU9OOgorICAgICAgICBnX3Zh bHVlX3NldF9vYmplY3QodmFsdWUsIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbih3ZWJWaWV3 KSk7CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JKRUNUX1dBUk5f SU5WQUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAgICB9CkBAIC0z MzIsNiArMzM3LDkgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X3NldF9wcm9wZXJ0eShH T2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIGNvbnN0IEcKICAgICBjYXNlIFBST1BfRlVM TF9DT05URU5UX1pPT006CiAgICAgICAgIHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250ZW50 X3pvb20od2ViVmlldywgZ192YWx1ZV9nZXRfYm9vbGVhbih2YWx1ZSkpOwogICAgICAgICBicmVh azsKKyAgICBjYXNlIFBST1BfU0VTU0lPTjoKKyAgICAgICAgd2Via2l0X3dlYl92aWV3X3NldF9z ZXNzaW9uKHdlYlZpZXcsIFNPVVBfU0VTU0lPTihnX3ZhbHVlX2dldF9vYmplY3QodmFsdWUpKSk7 CisgICAgICAgIGJyZWFrOwogICAgIGRlZmF1bHQ6CiAgICAgICAgIEdfT0JKRUNUX1dBUk5fSU5W QUxJRF9QUk9QRVJUWV9JRChvYmplY3QsIHByb3BfaWQsIHBzcGVjKTsKICAgICB9CkBAIC0xNTY5 LDYgKzE1NzcsMjAgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2NsYXNzX2luaXQoV2Vi S2l0V2ViVmlld0NsYXNzKiB3ZWJWaWV3Q2xhc3MpCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGQUxTRSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJBTV9SRUFE V1JJVEUpKTsKIAorICAgIC8qKgorICAgICogV2ViS2l0V2ViVmlldzpzZXNzaW9uOgorICAgICoK KyAgICAqIFJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUgdmlldy4KKyAgICAqCisgICAgKiBT aW5jZTogMS4xLjEKKyAgICAqLworICAgIGdfb2JqZWN0X2NsYXNzX2luc3RhbGxfcHJvcGVydHko b2JqZWN0Q2xhc3MsIFBST1BfU0VTU0lPTiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGdfcGFyYW1fc3BlY19vYmplY3QoInNlc3Npb24iLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiU2Vzc2lvbiIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJSZXRyaWV2 ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXciLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTT1VQX1RZUEVfU0VTU0lPTiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0VCS0lUX1BB UkFNX1JFQURXUklURSkpOworCiAgICAgZ190eXBlX2NsYXNzX2FkZF9wcml2YXRlKHdlYlZpZXdD bGFzcywgc2l6ZW9mKFdlYktpdFdlYlZpZXdQcml2YXRlKSk7CiB9CiAKQEAgLTI2NzIsNCArMjY5 NCw3NCBAQCB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250ZW50X3pvb20oV2ViS2l0 V2ViVmlldyogd2ViVmlldywgZ2Jvb2xlYW4gem9vbQogICAgIGdfb2JqZWN0X25vdGlmeShHX09C SkVDVCh3ZWJWaWV3KSwgImZ1bGwtY29udGVudC16b29tIik7CiB9CiAKKy8qKgorICogd2Via2l0 X3dlYl92aWV3X2dldF9zZXNzaW9uOgorICogQHdlYl92aWV3OiBhICNXZWJLaXRXZWJWaWV3Cisg KgorICogUmV0cmlldmVzIHRoZSAjU291cFNlc3Npb24gb2YgdGhlIHZpZXcsIGNyZWF0ZWQgd2hl biB0aGlzCisgKiBmdW5jdGlvbiBpcyBjYWxsZWQgZm9yIHRoZSBmaXJzdCB0aW1lLgorICoKKyAq IERvbid0IHVzZSB0aGlzIGZ1bmN0aW9uIHVubGVzcyB5b3UgaW50ZW5kIHRvIG1hbmFnZSBzZXNz aW9ucworICogZm9yIHlvdXIgd2ViIHZpZXdzIG9uIHlvdXIgb3duLiBTZWUgYWxzbyB3ZWJraXRf d2ViX3ZpZXdfc2V0X3Nlc3Npb24oKS4KKyAqCisgKiBSZXR1cm4gdmFsdWU6IHRoZSAjU291cFNl c3Npb24gb2YgdGhlIHZpZXcKKyAqCisgKiBTaW5jZTogMS4xLjEKKyAqLworU291cFNlc3Npb24q IHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbiAoV2ViS2l0V2ViVmlldyogd2ViVmlldykKK3sK KyAgICBTb3VwU2Vzc2lvbiogc2Vzc2lvbjsKKworICAgIGdfcmV0dXJuX3ZhbF9pZl9mYWlsKFdF QktJVF9JU19XRUJfVklFVyh3ZWJWaWV3KSwgTlVMTCk7CisKKyAgICBzZXNzaW9uID0gUmVzb3Vy Y2VIYW5kbGU6OmdldFNlc3Npb24oY29yZSh3ZWJWaWV3LT5wcml2LT5tYWluRnJhbWUpKTsKKyAg ICBpZiAoIXNlc3Npb24pIHsKKyAgICAgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19u ZXcgKCk7CisgICAgICAgIFJlc291cmNlSGFuZGxlOjpzZXRTZXNzaW9uKGNvcmUod2ViVmlldy0+ cHJpdi0+bWFpbkZyYW1lKSwgc2Vzc2lvbik7CisgICAgfQorICAgIHJldHVybiBzZXNzaW9uOwor fQorCisvKioKKyAqIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vzc2lvbjoKKyAqIEB3ZWJfdmlldzog YSAjV2ViS2l0V2ViVmlldworICogQHNlc3Npb246IGEgI1NvdXBTZXNzaW9uCisgKgorICogQXNz aWducyBhIHBhcnRpY3VsYXIgc2Vzc2lvbiB0byB0aGUgd2ViIHZpZXcuIEl0IGlzIHJlY29tbWVu ZGVkCisgKiB0aGF0IHlvdSBvbmx5IHVzZSBzZXNzaW9ucyByZXR1cm5lZCBieSB3ZWJraXRfd2Vi X3ZpZXdfZ2V0X3Nlc3Npb24oKQorICogb3Igd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Npb24oKS4K KyAqCisgKiBEb24ndCB1c2UgdGhpcyBmdW5jdGlvbiB1bmxlc3MgeW91IGludGVuZCB0byBtYW5h Z2Ugc2Vzc2lvbnMKKyAqIGZvciB5b3VyIHdlYiB2aWV3cyBvbiB5b3VyIG93bi4gU2VlIGFsc28g d2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKCkuCisgKgorICogU2luY2U6IDEuMS4xCisgKi8K K3ZvaWQgd2Via2l0X3dlYl92aWV3X3NldF9zZXNzaW9uIChXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3 LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNvdXBTZXNzaW9uKiAgIHNlc3Np b24pCit7CisgICAgZ19yZXR1cm5faWZfZmFpbChXRUJLSVRfSVNfV0VCX1ZJRVcod2ViVmlldykp OworICAgIGdfcmV0dXJuX2lmX2ZhaWwoU09VUF9JU19TRVNTSU9OX0FTWU5DKHNlc3Npb24pKTsK KworICAgIFJlc291cmNlSGFuZGxlOjpzZXRTZXNzaW9uKGNvcmUod2ViVmlldy0+cHJpdi0+bWFp bkZyYW1lKSwgc2Vzc2lvbik7Cit9CisKKy8qKgorICogd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Np b246CisgKgorICogUmV0cmlldmVzIHRoZSBkZWZhdWx0ICNTb3VwU2Vzc2lvbiB1c2VkIGJ5IGFs bCB3ZWIgdmlld3MgdW5sZXNzCisgKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24oKSBpcyBj YWxsZWQuCisgKgorICogVGhlIHNlc3Npb24gaXMgaW5pdGlhbGx5IGVtcHR5LiBVcG9uIHRoZSBm aXJzdCBsb2FkCisgKiBhIGNvb2tpZSBqYXIgd2lsbCBiZSBhZGRlZC4gSG93ZXZlciB5b3UgY2Fu CisgKiBhZGQgeW91ciBvd24gY29va2llIGphciBhbmQgV2ViS2l0IHdpbGwgdXNlIGl0LgorICoK KyAqIFJldHVybiB2YWx1ZTogdGhlIGRlZmF1bHQgI1NvdXBTZXNzaW9uCisgKgorICogU2luY2U6 IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAodm9p ZCkKK3sKKyAgICByZXR1cm4gUmVzb3VyY2VIYW5kbGU6OmdldERlZmF1bHRTZXNzaW9uKCk7Cit9 CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaAppbmRleCAyYmI4YzYxLi4xYTliZjU4IDEw MDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKKysrIGIvV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8 d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR3ZWJoaXN0b3J5aXRlbS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXR3ZWJzZXR0aW5ncy5o PgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBHX0JFR0lOX0RFQ0xTCiAKQEAgLTI5Niw2 ICsyOTcsMTYgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29u dGVudF96b29tICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAg ICAgICAgICAgICBmdWxsX2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24q Cit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2ViS2l0 V2ViVmlldyAgICAgICAgKndlYl92aWV3KTsKKworV0VCS0lUX0FQSSB2b2lkCit3ZWJraXRfd2Vi X3ZpZXdfc2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAg ICAgKndlYl92aWV3LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFNvdXBTZXNzaW9uICAgICAgICAgICpzZXNzaW9uKTsKKworV0VCS0lUX0FQSSBTb3Vw U2Vzc2lvbioKK3dlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uICAgICAgICAgICAgICAgICAgICAg ICh2b2lkKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9HTlVtYWtlZmlsZS5hbSBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCmluZGV4IDI2MjAw YzguLjQ0MWJjMDIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCisrKyBi L1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCkBAIC0yMCw2ICsyMCw3IEBAIFByb2dyYW1zX0d0 a0xhdW5jaGVyX0NGTEFHUyA9IFwKIAktZm5vLXN0cmljdC1hbGlhc2luZyBcCiAJLU8yIFwKIAkk KGdsb2JhbF9jZmxhZ3MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQog CiBQcm9ncmFtc19HdGtMYXVuY2hlcl9MREFERCA9IFwKQEAgLTY3LDYgKzY4LDcgQEAgUHJvZ3Jh bXNfRHVtcFJlbmRlclRyZWVfQ0ZMQUdTID0gXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xP QkFMREVQU19DRkxBR1MpIFwKIAkkKENBSVJPX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1Mp IFwKIAkkKEdUS19DRkxBR1MpCiAKIFByb2dyYW1zX0R1bXBSZW5kZXJUcmVlX0xEQUREID0gXApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jIGIvV2ViS2l0VG9vbHMv R3RrTGF1bmNoZXIvbWFpbi5jCmluZGV4IDhlZDI2OTAuLjM4Y2I1ZWMgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYworKysgYi9XZWJLaXRUb29scy9HdGtMYXVuY2hl ci9tYWluLmMKQEAgLTE4Miw2ICsxODIsOCBAQCBjcmVhdGVfd2luZG93ICgpCiBpbnQKIG1haW4g KGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiB7CisgICAgaWYgKCFnX3RocmVhZF9zdXBwb3J0ZWQg KCkpCisgICAgICAgIGdfdGhyZWFkX2luaXQgKE5VTEwpOwogICAgIGd0a19pbml0ICgmYXJnYywg JmFyZ3YpOwogCiAgICAgR3RrV2lkZ2V0KiB2Ym94ID0gZ3RrX3Zib3hfbmV3IChGQUxTRSwgMCk7 CmRpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMKaW5kZXggNmFjNmY4Yi4u N2YxYzQ5ZiAxMDA2NDQKLS0tIGEvY29uZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAt Mjg2LDIwICsyODYsNiBAQCBpZiB0ZXN0ICIkd2l0aF9oaWxkb24iID0gInllcyI7IHRoZW4KICAg ICBBQ19TVUJTVChbSElMRE9OX0xJQlNdKQogZmkKIAotIyBkZXRlcm1pbmUgdGhlIGh0dHAgYmFj a2VuZAotQUNfTVNHX0NIRUNLSU5HKFt0aGUgSFRUUCBiYWNrZW5kIHRvIHVzZV0pCi1BQ19BUkdf V0lUSChodHRwX2JhY2tlbmQsCi0gICAgICAgICAgICBBQ19IRUxQX1NUUklORyhbLS13aXRoLWh0 dHAtYmFja2VuZD1APDpAY3VybC9zb3VwQDo+QF0sCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICBbU2VsZWN0IEhUVFAgYmFja2VuZCBbZGVmYXVsdD1jdXJsXV0pLAotICAgICAgICAgICAgW10s W3dpdGhfaHR0cF9iYWNrZW5kPSJjdXJsIl0pCi0KLWNhc2UgIiR3aXRoX2h0dHBfYmFja2VuZCIg aW4KLSAgICAgY3VybHxzb3VwKSA7OwotICAgICAqKSBBQ19NU0dfRVJST1IoW0ludmFsaWQgSFRU UCBiYWNrZW5kOiBtdXN0IGJlIGN1cmwsIHNvdXAuXSkgOzsKLWVzYWMKLQotQUNfTVNHX1JFU1VM VChbJHdpdGhfaHR0cF9iYWNrZW5kXSkKLQogIyBtaW5pbXVtIGJhc2UgZGVwZW5kZW5jaWVzCiBD QUlST19SRVFVSVJFRF9WRVJTSU9OPTEuMgogRk9OVENPTkZJR19SRVFVSVJFRF9WRVJTSU9OPTIu NApAQCAtMzE0LDggKzMwMCw3IEBAIFBBTkdPX1JFUVVJUkVEX1ZFUlNJT049MS4wCiBHVEtfUkVR VUlSRURfVkVSU0lPTj0yLjgKIAogIyBvcHRpb25hbCBtb2R1bGVzCi1MSUJDVVJMX1JFUVVJUkVE X1ZFUlNJT049Ny4xNQotTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OPTIuMjMKK0xJQlNPVVBfUkVR VUlSRURfVkVSU0lPTj0yLjI1LjQKIExJQlhTTFRfUkVRVUlSRURfVkVSU0lPTj0xLjEuNwogU1FM SVRFX1JFUVVJUkVEX1ZFUlNJT049My4wCiBHU1RSRUFNRVJfUkVRVUlSRURfVkVSU0lPTj0wLjEw CkBAIC02MjQsMjMgKzYwOSwxMSBAQCBlbHNlCiAgICBDRkxBR1M9IiRDRkxBR1MgLU8wIgogZmkK IAotIyBjaGVjayBpZiBjdXJsIGlzIGF2YWlsYWJsZQotaWYgdGVzdCAiJHdpdGhfaHR0cF9iYWNr ZW5kIiA9ICJjdXJsIjsgdGhlbgotICAgUEtHX0NIRUNLX01PRFVMRVMoW0xJQkNVUkxdLAotICAg ICAgICAgICAgICAgICAgICAgW2xpYmN1cmwgPj0gJExJQkNVUkxfUkVRVUlSRURfVkVSU0lPTl0p Ci0gICBpZiB0ZXN0ICIkb3Nfd2luMzIiID0gInllcyI7IHRoZW4KLSAgICAgIExJQkNVUkxfTElC Uz0iJExJQkNVUkxfTElCUyAtbHdzMl8zMiIKLSAgIGZpCi0gICBBQ19TVUJTVChbTElCQ1VSTF9D RkxBR1NdKQotICAgQUNfU1VCU1QoW0xJQkNVUkxfTElCU10pCi1maQogCi1pZiB0ZXN0ICIkd2l0 aF9odHRwX2JhY2tlbmQiID0gInNvdXAiOyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElC U09VUF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVR VUlSRURfVkVSU0lPTl0pCi0gICBBQ19TVUJTVChbTElCU09VUF9DRkxBR1NdKQotICAgQUNfU1VC U1QoW0xJQlNPVVBfTElCU10pCi1maQorUEtHX0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAorICAg ICAgICAgICAgICAgICAgW2xpYnNvdXAtMi40ID49ICRMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT05d KQorQUNfU1VCU1QoW0xJQlNPVVBfQ0ZMQUdTXSkKK0FDX1NVQlNUKFtMSUJTT1VQX0xJQlNdKQog CiAjIGNoZWNrIGlmIEZyZWVUeXBlL0ZvbnRDb25maWcgYXJlIGF2YWlsYWJsZQogaWYgdGVzdCAi JHdpdGhfZm9udF9iYWNrZW5kIiA9ICJmcmVldHlwZSI7IHRoZW4KQEAgLTcxMiwxMCArNjg1LDYg QEAgQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9XSU4zMl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0g IndpbjMyIl0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VUX1FVQVJUWl0sIFt0ZXN0ICIkd2l0aF90 YXJnZXQiID0gInF1YXJ0eiJdKQogQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9ESVJFQ1RGQl0sIFt0 ZXN0ICIkd2l0aF90YXJnZXQiID0gImRpcmVjdGZiIl0pCiAKLSMgSFRUUCBiYWNrZW5kIGNvbmRp dGlvbmFscwotQU1fQ09ORElUSU9OQUwoW1VTRV9DVVJMXSwgW3Rlc3QgIiR3aXRoX2h0dHBfYmFj a2VuZCIgPSAiY3VybCJdKQotQU1fQ09ORElUSU9OQUwoW1VTRV9TT1VQXSwgW3Rlc3QgIiR3aXRo X2h0dHBfYmFja2VuZCIgPSAic291cCJdKQotCiAjIEZvbnQgYmFja2VuZCBjb25kaXRpb25hbHMK IEFNX0NPTkRJVElPTkFMKFtVU0VfRlJFRVRZUEVdLCBbdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5k IiA9ICJmcmVldHlwZSJdKQogQU1fQ09ORElUSU9OQUwoW1VTRV9QQU5HT10sIFt0ZXN0ICIkd2l0 aF9mb250X2JhY2tlbmQiID0gInBhbmdvIl0pCkBAIC03NjIsNyArNzMxLDYgQEAgQnVpbGQgY29u ZmlndXJhdGlvbjoKICBFbmFibGUgR0NDIGJ1aWxkIG9wdGltaXphdGlvbiAgICAgICAgICAgICAg ICAgICAgICAgICAgICA6ICRlbmFibGVfb3B0aW1pemF0aW9ucwogIENvZGUgY292ZXJhZ2Ugc3Vw cG9ydCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9jb3ZlcmFn ZQogIFVuaWNvZGUgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIDogJHVuaWNvZGVfYmFja2VuZAotIEhUVFAgYmFja2VuZCAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDogJHdpdGhfaHR0cF9iYWNrZW5kCiAgRm9udCBiYWNr ZW5kICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9m b250X2JhY2tlbmQKICBPcHRpbWl6ZWQgbWVtb3J5IGFsbG9jYXRvciAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICA6ICRlbmFibGVfZmFzdF9tYWxsb2MKIEZlYXR1cmVzOgo= 26996 2009-01-24 08:37:11 -0800 2009-01-24 16:29:00 -0800 API to retrieve and set soup sessions #7 p.diff text/plain 24840 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAyYjJlMzIyLi4wZmRjZDliIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NzYsMzEgKzE3NzYsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xODE0LDcgKzE3ODksNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmgKLWVuZGlmCiAKICMgLS0tCiAjIEZyZWV0eXBlIGZvbnQgYmFja2VuZApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaCBiL1dlYkNvcmUvbG9hZGVy L0ZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggYjkwY2VjZC4uMmYxYzQxYSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAorKysgYi9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlckNsaWVudC5oCkBAIC0zNSw2ICszNSwxMCBAQAogI2luY2x1ZGUgPHd0Zi9QbGF0 Zm9ybS5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAorI2lmIFBMQVRGT1JNKEdUSykKKyNp bmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRpZgorCiB0eXBlZGVmIGNsYXNzIF9qb2JqZWN0 KiBqb2JqZWN0OwogCiAjaWYgUExBVEZPUk0oTUFDKSAmJiAhZGVmaW5lZChfX09CSkNfXykKQEAg LTIwOSw2ICsyMTMsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAgICAgICAgIHZp cnR1YWwgTlNDYWNoZWRVUkxSZXNwb25zZSogd2lsbENhY2hlUmVzcG9uc2UoRG9jdW1lbnRMb2Fk ZXIqLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIE5TQ2FjaGVkVVJMUmVzcG9uc2UqKSBjb25z dCA9IDA7CiAjZW5kaWYKKyNpZiBQTEFURk9STShHVEspCisgICAgICAgIHZpcnR1YWwgU291cFNl c3Npb24qIHNlc3Npb24oKSA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzZXRTZXNzaW9uKFNv dXBTZXNzaW9uKikgPSAwOworI2VuZGlmCiAKICAgICAgICAgdmlydHVhbCBib29sIHNob3VsZFVz ZVBsdWdpbkRvY3VtZW50KGNvbnN0IFN0cmluZyYgLyptaW1lVHlwZSovKSBjb25zdCB7IHJldHVy biBmYWxzZTsgfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmlu ZGV4IGM5M2FmMjEuLjUxNWUwZWUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIK ICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJz b3VwL3NvdXAuaD4KKyNlbmRpZgorCiAjaWYgUExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0 cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsKICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMiBAQCBw dWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVy biBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lmIFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vz c2lvbiogZ2V0RGVmYXVsdFNlc3Npb24oKTsKKyAgICBzdGF0aWMgU291cFNlc3Npb24qIGdldFNl c3Npb24oY29uc3QgRnJhbWUgKmZyYW1lKTsKKyAgICBzdGF0aWMgdm9pZCBzZXRTZXNzaW9uKGNv bnN0IEZyYW1lICpmcmFtZSwgU291cFNlc3Npb24gKnNlc3Npb24pOworI2VuZGlmCisKICAgICAv LyBVc2VkIHRvIHdvcmsgYXJvdW5kIHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdldCBhbnkgbW9y ZSBOU1VSTENvbm5lY3Rpb24gY2FsbGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJvbSB0aGUgb25l IHlvdSdyZSBpbi4KICAgICBzdGF0aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAgCiAgICAgCkBA IC0xNzgsNyArMTg4LDcgQEAgcHVibGljOgogcHJpdmF0ZToKICNpZiBVU0UoU09VUCkKICAgICBi b29sIHN0YXJ0RGF0YShTdHJpbmcgdXJsU3RyaW5nKTsKLSAgICBib29sIHN0YXJ0SHR0cChTdHJp bmcgdXJsU3RyaW5nKTsKKyAgICBib29sIHN0YXJ0SHR0cChTb3VwU2Vzc2lvbiogc2Vzc2lvbiwg U3RyaW5nIHVybFN0cmluZyk7CiAgICAgYm9vbCBzdGFydEdpbyhTdHJpbmcgdXJsU3RyaW5nKTsK ICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGVJbnRlcm5hbC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl SW50ZXJuYWwuaAppbmRleCA2NmFhNGMxLi41ODQ1NDhmIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgKQEAgLTE3OCw2ICsxNzgsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFZlY3RvcjxjaGFyPiBtX3Bvc3RCeXRlczsK ICNlbmRpZgogI2lmIFVTRShTT1VQKQorICAgICAgICBTb3VwU2Vzc2lvbiogbV9zZXNzaW9uOwog ICAgICAgICBTb3VwTWVzc2FnZSogbV9tc2c7CiAgICAgICAgIFJlc291cmNlUmVzcG9uc2UgbV9y ZXNwb25zZTsKICAgICAgICAgYm9vbCBtX2NhbmNlbGxlZDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAKaW5kZXggODgxMDllOC4uZTY0N2UyMSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5j cHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAK QEAgLTIyLDE4ICsyMiwyOCBAQAogCiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIktV UkwuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5j bHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1Tb3Vw Q29va2llSmFyKiBnZXRDb29raWVKYXIoKQorU291cENvb2tpZUphciogZ2V0Q29va2llSmFyKGNv bnN0IERvY3VtZW50KiBkb2N1bWVudCkKIHsKLSAgICBzdGF0aWMgU291cENvb2tpZUphciogamFy ID0gc291cF9jb29raWVfamFyX25ldygpOworICAgIEZyYW1lICpmcmFtZSA9IGRvY3VtZW50LT5m cmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIEZyYW1lTG9h ZGVyICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAgICAg IHJldHVybiAwOworICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gc3RhdGljX2Nhc3Q8RnJhbWVM b2FkZXJDbGllbnQqPihsb2FkZXItPmNsaWVudCgpKS0+c2Vzc2lvbigpOworICAgIFNvdXBDb29r aWVKYXIqIGphciA9IChTb3VwQ29va2llSmFyKilzb3VwX3Nlc3Npb25fZ2V0X2ZlYXR1cmUoc2Vz c2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpOwogICAgIHJldHVybiBqYXI7CiB9CiAKLXZvaWQg c2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0 IEtVUkwmIC8qcG9saWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCit2b2lkIHNldENvb2tp ZXMoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IEtVUkwmIC8qcG9s aWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCiB7Ci0gICAgU291cENvb2tpZUphciogamFy ID0gZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogamFyID0gZ2V0Q29va2llSmFy KGRvY3VtZW50KTsKICAgICBpZiAoIWphcikKICAgICAgICAgcmV0dXJuOwogCkBAIC00Myw5ICs1 Myw5IEBAIHZvaWQgc2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJM JiB1cmwsIGNvbnN0IEtVUkwmIC8qcG9saWN5VVJMCiAgICAgc291cF91cmlfZnJlZShvcmlnaW4p OwogfQogCi1TdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25z dCBLVVJMJiB1cmwpCitTdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogZG9jdW1lbnQsIGNv bnN0IEtVUkwmIHVybCkKIHsKLSAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIo KTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIoZG9jdW1lbnQpOwogICAg IGlmICghamFyKQogICAgICAgICByZXR1cm4gU3RyaW5nKCk7CiAKQEAgLTU5LDkgKzY5LDkgQEAg U3RyaW5nIGNvb2tpZXMoY29uc3QgRG9jdW1lbnQqIC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYg dXJsKQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKLWJvb2wgY29va2llc0VuYWJsZWQoY29uc3Qg RG9jdW1lbnQqIC8qZG9jdW1lbnQqLykKK2Jvb2wgY29va2llc0VuYWJsZWQoY29uc3QgRG9jdW1l bnQqIGRvY3VtZW50KQogewotICAgIHJldHVybiBnZXRDb29raWVKYXIoKTsKKyAgICByZXR1cm4g Z2V0Q29va2llSmFyKGRvY3VtZW50KTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvQ29va2llSmFyU291cC5oCmluZGV4IDYxMTc5YWUuLjZlNTE2OTIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaAorKysgYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKQEAgLTMxLDcgKzMx LDcgQEAKICNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewot ICAgIFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGdl dENvb2tpZUphcihjb25zdCBEb2N1bWVudCogZG9jdW1lbnQpOwogfQogCiAjZW5kaWYKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5j cHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3Bw CmluZGV4IGRhOTY4NzMuLmQ5NzRlZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtMjgsNiArMjgsOCBAQAogI2lu Y2x1ZGUgIkNvb2tpZUphclNvdXAuaCIKICNpbmNsdWRlICJEb2NMb2FkZXIuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiRnJhbWVMb2Fk ZXJDbGllbnQuaCIKICNpbmNsdWRlICJIVFRQUGFyc2Vycy5oIgogI2luY2x1ZGUgIk1JTUVUeXBl UmVnaXN0cnkuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgpAQCAtNDksOCArNTEsNiBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLXN0YXRpYyBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9 IDA7Ci0KIGVudW0KIHsKICAgICBFUlJPUl9UUkFOU1BPUlQsCkBAIC0xNzMsNiArMTczLDggQEAg c3RhdGljIHZvaWQgZmluaXNoZWRDYWxsYmFjayhTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwgU291cE1l c3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGEKICAgICAgICAgcmV0dXJuOwogCiAgICAgUmVzb3VyY2VI YW5kbGVJbnRlcm5hbCogZCA9IGhhbmRsZS0+Z2V0SW50ZXJuYWwoKTsKKyAgICBnX29iamVjdF91 bnJlZihkLT5tX3Nlc3Npb24pOworICAgIGQtPm1fc2Vzc2lvbiA9IE5VTEw7CiAKICAgICBSZXNv dXJjZUhhbmRsZUNsaWVudCogY2xpZW50ID0gaGFuZGxlLT5jbGllbnQoKTsKICAgICBpZiAoIWNs aWVudCkKQEAgLTI4MiwyMyArMjg0LDM4IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0RGF0 YShTdHJpbmcgdXJsU3RyaW5nKQogICAgIHJldHVybiB0cnVlOwogfQogCi1ib29sIFJlc291cmNl SGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmluZykKK3N0YXRpYyB2b2lkIGVuc3VyZVNl c3Npb24oU291cFNlc3Npb24qIHNlc3Npb24pCiB7Ci0gICAgaWYgKCFzZXNzaW9uKSB7Ci0gICAg ICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3KCk7CisgICAgaWYgKGdfb2JqZWN0 X2dldF9kYXRhKEdfT0JKRUNUKHNlc3Npb24pLCAid2Via2l0LWluaXQiKSkKKyAgICAgICAgcmV0 dXJuOwogCi0gICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1NF U1NJT05fRkVBVFVSRShnZXRDb29raWVKYXIoKSkpOworICAgIFNvdXBDb29raWVKYXIqIGphcjsK KyAgICBjb25zdCBjaGFyKiB3ZWJraXRfZGVidWcgPSBnX2dldGVudigiV0VCS0lUX0RFQlVHIik7 CiAKLSAgICAgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfU09V UF9MT0dHSU5HIik7Ci0gICAgICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0gICAgICAgICAgICBpbnQg c291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAgamFyID0gKFNvdXBDb29r aWVKYXIqKXNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfQ09PS0lF X0pBUik7CisgICAgaWYgKCFqYXIpIHsKKyAgICAgICAgamFyID0gc291cF9jb29raWVfamFyX25l dygpOworICAgICAgICBzb3VwX3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNT SU9OX0ZFQVRVUkUoamFyKSk7CisgICAgICAgIGdfb2JqZWN0X3VucmVmKGphcik7CisgICAgfQog Ci0gICAgICAgICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGlj X2Nhc3Q8U291cExvZ2dlckxvZ0xldmVsPihzb3VwX2RlYnVnX2xldmVsKSwgLTEpOwotICAgICAg ICAgICAgc291cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7Ci0gICAgICAgICAgICBn X29iamVjdF91bnJlZihsb2dnZXIpOwotICAgICAgICB9CisgICAgaWYgKHNvdXBfc2Vzc2lvbl9n ZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfTE9HR0VSKSA9PSBOVUxMCisgICAgICAgICYm IHdlYmtpdF9kZWJ1ZyAmJiAhc3RyY21wKHdlYmtpdF9kZWJ1ZywgIm5ldHdvcmsiKSkgeworICAg ICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291 cExvZ2dlckxvZ0xldmVsPihTT1VQX0xPR0dFUl9MT0dfQk9EWSksIC0xKTsKKyAgICAgICAgc291 cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7CisgICAgICAgIGdfb2JqZWN0X3VucmVm KGxvZ2dlcik7CiAgICAgfQogCisgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1Qoc2Vzc2lv biksICJ3ZWJraXQtaW5pdCIsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KDB4ZGVhZGJlZWYpKTsK K30KKworYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFNvdXBTZXNzaW9uKiBzZXNzaW9u LCBTdHJpbmcgdXJsU3RyaW5nKQoreworICAgIGlmKCFzZXNzaW9uKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisKKyAgICBlbnN1cmVTZXNzaW9uKHNlc3Npb24pOworCiAgICAgU291cE1lc3NhZ2Uq IG1zZzsKICAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVlc3QoKS5odHRwTWV0aG9kKCku dXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOwogICAgIGdfc2lnbmFsX2Nv bm5lY3QobXNnLCAicmVzdGFydGVkIiwgR19DQUxMQkFDSyhyZXN0YXJ0ZWRDYWxsYmFjayksIHRo aXMpOwpAQCAtMzI4LDggKzM0NSw5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChT dHJpbmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9N RU1PUllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICB9CiAKKyAgICBkLT5t X3Nlc3Npb24gPSBzdGF0aWNfY2FzdDxTb3VwU2Vzc2lvbio+KGdfb2JqZWN0X3JlZihzZXNzaW9u KSk7CiAgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2JqZWN0X3Jl Zihtc2cpKTsKLSAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBkLT5tX21z ZywgZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CisgICAgc291cF9zZXNzaW9uX3F1ZXVlX21lc3Nh Z2Uoc2Vzc2lvbiwgbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKIAogICAgIHJldHVybiB0 cnVlOwogfQpAQCAtMzUwLDcgKzM2OCw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0KEZy YW1lKiBmcmFtZSkKICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJkYXRhIikp CiAgICAgICAgIHJldHVybiBzdGFydERhdGEodXJsU3RyaW5nKTsKICAgICBlbHNlIGlmICgoZXF1 YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJv dG9jb2wsICJodHRwcyIpKSAmJiBTT1VQX1VSSV9WQUxJRF9GT1JfSFRUUChzb3VwX3VyaV9uZXco dXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpKSkKLSAgICAgICAgcmV0dXJuIHN0YXJ0SHR0cCh1cmxT dHJpbmcpOworICAgICAgICByZXR1cm4gc3RhcnRIdHRwKGdldFNlc3Npb24oZnJhbWUpLCB1cmxT dHJpbmcpOwogICAgIGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZmlsZSIp IHx8IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwIikgfHwgZXF1YWxJZ25vcmluZ0Nh c2UocHJvdG9jb2wsICJmdHBzIikpCiAgICAgICAgIC8vIEZJWE1FOiBzaG91bGQgd2UgYmUgZG9p bmcgYW55IG90aGVyIHByb3RvY29scyBoZXJlPwogICAgICAgICByZXR1cm4gc3RhcnRHaW8odXJs U3RyaW5nKTsKQEAgLTM2OCw3ICszODYsNyBAQCB2b2lkIFJlc291cmNlSGFuZGxlOjpjYW5jZWwo KQogewogICAgIGQtPm1fY2FuY2VsbGVkID0gdHJ1ZTsKICAgICBpZiAoZC0+bV9tc2cpIHsKLSAg ICAgICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKHNlc3Npb24sIGQtPm1fbXNnLCBTT1VQ X1NUQVRVU19DQU5DRUxMRUQpOworICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2Uo ZC0+bV9zZXNzaW9uLCBkLT5tX21zZywgU09VUF9TVEFUVVNfQ0FOQ0VMTEVEKTsKICAgICAgICAg Ly8gRm9yIHJlLWVudHJhbmN5IHRyb3VibGVzIHdlIGNhbGwgZGlkRmluaXNoTG9hZGluZyB3aGVu IHRoZSBtZXNzYWdlIGhhc24ndCBiZWVuIGhhbmRsZWQgeWV0LgogICAgICAgICBpZiAoY2xpZW50 KCkpCiAgICAgICAgICAgICBjbGllbnQoKS0+ZGlkRmluaXNoTG9hZGluZyh0aGlzKTsKQEAgLTYx OSw1ICs2MzcsMzMgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3RyaW5nIHVybFN0 cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291cmNlSGFuZGxl OjpnZXREZWZhdWx0U2Vzc2lvbigpCit7CisgICAgc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9u ID0gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworICAgIHJldHVybiBzZXNzaW9uOworfQorCitT b3VwU2Vzc2lvbiogUmVzb3VyY2VIYW5kbGU6OmdldFNlc3Npb24oY29uc3QgRnJhbWUgKmZyYW1l KQoreworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIEZyYW1lTG9hZGVy ICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAgICAgIHJl dHVybiAwOworICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gc3RhdGljX2Nhc3Q8RnJhbWVMb2Fk ZXJDbGllbnQqPihsb2FkZXItPmNsaWVudCgpKS0+c2Vzc2lvbigpOworICAgIHJldHVybiBzZXNz aW9uID8gc2Vzc2lvbiA6IGdldERlZmF1bHRTZXNzaW9uKCk7Cit9CisKK3ZvaWQgUmVzb3VyY2VI YW5kbGU6OnNldFNlc3Npb24oY29uc3QgRnJhbWUgKmZyYW1lLCBTb3VwU2Vzc2lvbiAqc2Vzc2lv bikKK3sKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm47CisgICAgRnJhbWVMb2FkZXIg KmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0 dXJuOworICAgIGxvYWRlci0+c3RvcCgpOworICAgIHN0YXRpY19jYXN0PEZyYW1lTG9hZGVyQ2xp ZW50Kj4obG9hZGVyLT5jbGllbnQoKSktPnNldFNlc3Npb24oc2Vzc2lvbik7Cit9CisKIH0KIApk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaCBi L1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmgKaW5kZXggMjk5ZDAy My4uZWE1NGJmNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVD bGllbnRHdGsuaAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0 ay5oCkBAIC0yMiw2ICsyMiw3IEBACiAKICNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNs dWRlICJLVVJMLmgiCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIHR5cGVkZWYgc3RydWN0 IF9XZWJLaXRXZWJWaWV3IFdlYktpdFdlYlZpZXc7CiAKQEAgLTMxLDYgKzMyLDcgQEAgbmFtZXNw YWNlIFdlYktpdCB7CiAgICAgcHVibGljOgogICAgICAgICBDaHJvbWVDbGllbnQoV2ViS2l0V2Vi VmlldyopOwogICAgICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KCkgY29uc3QgeyByZXR1cm4g bV93ZWJWaWV3OyB9CisgICAgICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uKCk7CiAKICAgICAgICAg dmlydHVhbCB2b2lkIGNocm9tZURlc3Ryb3llZCgpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDFiNDEwYzcuLjlhYmU3 ODAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCkBAIC02NCw2ICs2NCw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiBGcmFtZUxv YWRlckNsaWVudDo6RnJhbWVMb2FkZXJDbGllbnQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogICAg IDogbV9mcmFtZShmcmFtZSkKKyAgICAsIG1fc2Vzc2lvbigwKQogICAgICwgbV91c2VyQWdlbnQo IiIpCiAgICAgLCBtX3BvbGljeURlY2lzaW9uKDApCiAgICAgLCBtX3BsdWdpblZpZXcoMCkKQEAg LTc0LDYgKzc1LDggQEAgRnJhbWVMb2FkZXJDbGllbnQ6OkZyYW1lTG9hZGVyQ2xpZW50KFdlYktp dFdlYkZyYW1lKiBmcmFtZSkKIAogRnJhbWVMb2FkZXJDbGllbnQ6On5GcmFtZUxvYWRlckNsaWVu dCgpCiB7CisgICAgaWYgKG1fc2Vzc2lvbikKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobV9zZXNz aW9uKTsKICAgICBpZiAobV9wb2xpY3lEZWNpc2lvbikKICAgICAgICAgZ19vYmplY3RfdW5yZWYo bV9wb2xpY3lEZWNpc2lvbik7CiB9CkBAIC04NzUsNCArODc4LDE2IEBAIHZvaWQgRnJhbWVMb2Fk ZXJDbGllbnQ6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZEZvck5ld1BhZ2UoKQogICAgIGZyYW1lLT52 aWV3KCktPnNldEd0a0FkanVzdG1lbnRzKHByaXYtPmhvcml6b250YWxBZGp1c3RtZW50LCBwcml2 LT52ZXJ0aWNhbEFkanVzdG1lbnQpOwogfQogCitTb3VwU2Vzc2lvbiogRnJhbWVMb2FkZXJDbGll bnQ6OnNlc3Npb24oKQoreworICAgIHJldHVybiBtX3Nlc3Npb247Cit9CisKK3ZvaWQgRnJhbWVM b2FkZXJDbGllbnQ6OnNldFNlc3Npb24oU291cFNlc3Npb24qIHNlc3Npb24pCit7CisgICAgaWYg KG1fc2Vzc2lvbikKKyAgICAgICAgZ19vYmplY3RfdW5yZWYoc2Vzc2lvbik7CisgICAgbV9zZXNz aW9uID0gc3RhdGljX2Nhc3Q8U291cFNlc3Npb24qPihnX29iamVjdF9yZWYoc2Vzc2lvbikpOwor fQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmggYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 R3RrLmgKaW5kZXggYzY5NTJkYi4uMjNkMjljMSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCisrKyBiL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1 ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJQbHVnaW5WaWV3LmgiCiAjaW5jbHVk ZSAid2Via2l0d2VicG9saWN5ZGVjaXNpb24uaCIKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4K IAogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkZyYW1lIFdlYktpdFdlYkZyYW1lOwogCkBAIC0x NjksOCArMTcwLDEyIEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgICAgIHZpcnR1YWwgYm9v bCBjYW5DYWNoZVBhZ2UoKSBjb25zdDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRvd25sb2FkKFdl YkNvcmU6OlJlc291cmNlSGFuZGxlKiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VS ZXNwb25zZSYpOworCisgICAgICAgIHZpcnR1YWwgU291cFNlc3Npb24qIHNlc3Npb24oKTsKKyAg ICAgICAgdmlydHVhbCB2b2lkIHNldFNlc3Npb24oU291cFNlc3Npb24qKTsKICAgICBwcml2YXRl OgogICAgICAgICBXZWJLaXRXZWJGcmFtZSogbV9mcmFtZTsKKyAgICAgICAgU291cFNlc3Npb24q IG1fc2Vzc2lvbjsKICAgICAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBtX3Jlc3BvbnNl OwogICAgICAgICBXZWJDb3JlOjpTdHJpbmcgbV91c2VyQWdlbnQ7CiAgICAgICAgIFdlYktpdFdl YlBvbGljeURlY2lzaW9uKiBtX3BvbGljeURlY2lzaW9uOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQucGMuaW4gYi9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbgppbmRleCAwY2U2ZjcxLi44 NGQ2MTE1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbgorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC5wYy5pbgpAQCAtNiw2ICs2LDYgQEAgaW5jbHVkZWRpcj1AaW5jbHVkZWRpckAK IE5hbWU6IFdlYktpdAogRGVzY3JpcHRpb246IFdlYiBjb250ZW50IGVuZ2luZSBmb3IgR1RLKwog VmVyc2lvbjogQFZFUlNJT05ACi1SZXF1aXJlczogZ3RrKy0yLjAKK1JlcXVpcmVzOiBndGsrLTIu MCBsaWJzb3VwLTIuNAogTGliczogLUwke2xpYmRpcn0gLWx3ZWJraXQtMS4wCiBDZmxhZ3M6IC1J JHtpbmNsdWRlZGlyfS93ZWJraXQtMS4wCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmlu ZGV4IDM1OGFjZTkuLjdhZWQ4YzggMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBA IC01OSw2ICs1OSw3IEBACiAjaW5jbHVkZSAiUGFzdGVib2FyZEhlbHBlci5oIgogI2luY2x1ZGUg IlBsYXRmb3JtS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtV2hlZWxFdmVudC5o IgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2NyaXB0VmFsdWUuaCIK ICNpbmNsdWRlICJTY3JvbGxiYXIuaCIKICNpbmNsdWRlICJTdWJzdGl0dXRlRGF0YS5oIgpAQCAt MTQ2LDcgKzE0Nyw4IEBAIGVudW0gewogICAgIFBST1BfV0lORE9XX0ZFQVRVUkVTLAogICAgIFBS T1BfVFJBTlNQQVJFTlQsCiAgICAgUFJPUF9aT09NX0xFVkVMLAotICAgIFBST1BfRlVMTF9DT05U RU5UX1pPT00KKyAgICBQUk9QX0ZVTExfQ09OVEVOVF9aT09NLAorICAgIFBST1BfU0VTU0lPTiwK IH07CiAKIHN0YXRpYyBndWludCB3ZWJraXRfd2ViX3ZpZXdfc2lnbmFsc1tMQVNUX1NJR05BTF0g PSB7IDAsIH07CkBAIC0zMDQsNiArMzA2LDkgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3 X2dldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSoKICAg ICBjYXNlIFBST1BfRlVMTF9DT05URU5UX1pPT006CiAgICAgICAgIGdfdmFsdWVfc2V0X2Jvb2xl YW4odmFsdWUsIHdlYmtpdF93ZWJfdmlld19nZXRfZnVsbF9jb250ZW50X3pvb20od2ViVmlldykp OwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfU0VTU0lPTjoKKyAgICAgICAgZ192YWx1 ZV9zZXRfb2JqZWN0KHZhbHVlLCB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24od2ViVmlldykp OworICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBHX09CSkVDVF9XQVJOX0lO VkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CiAgICAgfQpAQCAtMzMy LDYgKzMzNyw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfcHJvcGVydHkoR09i amVjdCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBjb25zdCBHCiAgICAgY2FzZSBQUk9QX0ZVTExf Q09OVEVOVF9aT09NOgogICAgICAgICB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96 b29tKHdlYlZpZXcsIGdfdmFsdWVfZ2V0X2Jvb2xlYW4odmFsdWUpKTsKICAgICAgICAgYnJlYWs7 CisgICAgY2FzZSBQUk9QX1NFU1NJT046CisgICAgICAgIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vz c2lvbih3ZWJWaWV3LCBTT1VQX1NFU1NJT04oZ192YWx1ZV9nZXRfb2JqZWN0KHZhbHVlKSkpOwor ICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFM SURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CiAgICAgfQpAQCAtMTU2OSw2 ICsxNTc3LDIwIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktp dFdlYlZpZXdDbGFzcyogd2ViVmlld0NsYXNzKQogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRkFMU0UsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdS SVRFKSk7CiAKKyAgICAvKioKKyAgICAqIFdlYktpdFdlYlZpZXc6c2Vzc2lvbjoKKyAgICAqCisg ICAgKiBSZXRyaWV2ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXcuCisgICAgKgorICAgICogU2lu Y2U6IDEuMS4xCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9i amVjdENsYXNzLCBQUk9QX1NFU1NJT04sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBnX3BhcmFtX3NwZWNfb2JqZWN0KCJzZXNzaW9uIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlNlc3Npb24iLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiUmV0cmlldmVz IHRoZSBzZXNzaW9uIG9mIHRoZSB2aWV3IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9UWVBFX1NFU1NJT04sCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJB TV9SRUFEV1JJVEUpKTsKKwogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZSh3ZWJWaWV3Q2xh c3MsIHNpemVvZihXZWJLaXRXZWJWaWV3UHJpdmF0ZSkpOwogfQogCkBAIC0yNjcyLDQgKzI2OTQs NzQgQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdl YlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpvb20KICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpF Q1Qod2ViVmlldyksICJmdWxsLWNvbnRlbnQtem9vbSIpOwogfQogCisvKioKKyAqIHdlYmtpdF93 ZWJfdmlld19nZXRfc2Vzc2lvbjoKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICoK KyAqIFJldHJpZXZlcyB0aGUgI1NvdXBTZXNzaW9uIG9mIHRoZSB2aWV3LCBjcmVhdGVkIHdoZW4g dGhpcworICogZnVuY3Rpb24gaXMgY2FsbGVkIGZvciB0aGUgZmlyc3QgdGltZS4KKyAqCisgKiBE b24ndCB1c2UgdGhpcyBmdW5jdGlvbiB1bmxlc3MgeW91IGludGVuZCB0byBtYW5hZ2Ugc2Vzc2lv bnMKKyAqIGZvciB5b3VyIHdlYiB2aWV3cyBvbiB5b3VyIG93bi4gU2VlIGFsc28gd2Via2l0X3dl Yl92aWV3X3NldF9zZXNzaW9uKCkuCisgKgorICogUmV0dXJuIHZhbHVlOiB0aGUgI1NvdXBTZXNz aW9uIG9mIHRoZSB2aWV3CisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3 ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24gKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7Cisg ICAgU291cFNlc3Npb24qIHNlc3Npb247CisKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJL SVRfSVNfV0VCX1ZJRVcod2ViVmlldyksIE5VTEwpOworCisgICAgc2Vzc2lvbiA9IFJlc291cmNl SGFuZGxlOjpnZXRTZXNzaW9uKGNvcmUod2ViVmlldy0+cHJpdi0+bWFpbkZyYW1lKSk7CisgICAg aWYgKCFzZXNzaW9uKSB7CisgICAgICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3 ICgpOworICAgICAgICBSZXNvdXJjZUhhbmRsZTo6c2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnBy aXYtPm1haW5GcmFtZSksIHNlc3Npb24pOworICAgIH0KKyAgICByZXR1cm4gc2Vzc2lvbjsKK30K KworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfc2V0X3Nlc3Npb246CisgKiBAd2ViX3ZpZXc6IGEg I1dlYktpdFdlYlZpZXcKKyAqIEBzZXNzaW9uOiBhICNTb3VwU2Vzc2lvbgorICoKKyAqIEFzc2ln bnMgYSBwYXJ0aWN1bGFyIHNlc3Npb24gdG8gdGhlIHdlYiB2aWV3LiBJdCBpcyByZWNvbW1lbmRl ZAorICogdGhhdCB5b3Ugb25seSB1c2Ugc2Vzc2lvbnMgcmV0dXJuZWQgYnkgd2Via2l0X3dlYl92 aWV3X2dldF9zZXNzaW9uKCkKKyAqIG9yIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uKCkuCisg KgorICogRG9uJ3QgdXNlIHRoaXMgZnVuY3Rpb24gdW5sZXNzIHlvdSBpbnRlbmQgdG8gbWFuYWdl IHNlc3Npb25zCisgKiBmb3IgeW91ciB3ZWIgdmlld3Mgb24geW91ciBvd24uIFNlZSBhbHNvIHdl YmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbigpLgorICoKKyAqIFNpbmNlOiAxLjEuMQorICovCit2 b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vzc2lvbiAoV2ViS2l0V2ViVmlldyogd2ViVmlldywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTb3VwU2Vzc2lvbiogICBzZXNzaW9u KQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVXKHdlYlZpZXcpKTsK KyAgICBnX3JldHVybl9pZl9mYWlsKFNPVVBfSVNfU0VTU0lPTl9BU1lOQyhzZXNzaW9uKSk7CisK KyAgICBSZXNvdXJjZUhhbmRsZTo6c2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnByaXYtPm1haW5G cmFtZSksIHNlc3Npb24pOworfQorCisvKioKKyAqIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9u OgorICoKKyAqIFJldHJpZXZlcyB0aGUgZGVmYXVsdCAjU291cFNlc3Npb24gdXNlZCBieSBhbGwg d2ViIHZpZXdzIHVubGVzcworICogd2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uKCkgaXMgY2Fs bGVkLgorICoKKyAqIFRoZSBzZXNzaW9uIGlzIGluaXRpYWxseSBlbXB0eS4gVXBvbiB0aGUgZmly c3QgbG9hZAorICogYSBjb29raWUgamFyIHdpbGwgYmUgYWRkZWQuIEhvd2V2ZXIgeW91IGNhbgor ICogYWRkIHlvdXIgb3duIGNvb2tpZSBqYXIgYW5kIFdlYktpdCB3aWxsIHVzZSBpdC4KKyAqCisg KiBSZXR1cm4gdmFsdWU6IHRoZSBkZWZhdWx0ICNTb3VwU2Vzc2lvbgorICoKKyAqIFNpbmNlOiAx LjEuMQorICovCitTb3VwU2Vzc2lvbiogd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Npb24gKHZvaWQp Cit7CisgICAgcmV0dXJuIFJlc291cmNlSGFuZGxlOjpnZXREZWZhdWx0U2Vzc2lvbigpOworfQor CiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmggYi9XZWJL aXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKaW5kZXggMmJiOGM2MS4uMWE5YmY1OCAxMDA2 NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dlYktpdC9n dGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaApAQCAtMjksNiArMjksNyBAQAogI2luY2x1ZGUgPHdl YmtpdC93ZWJraXR3ZWJiYWNrZm9yd2FyZGxpc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0 d2ViaGlzdG9yeWl0ZW0uaD4KICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0d2Vic2V0dGluZ3MuaD4K KyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogR19CRUdJTl9ERUNMUwogCkBAIC0yOTYsNiAr Mjk3LDE2IEBAIFdFQktJVF9BUEkgdm9pZAogd2Via2l0X3dlYl92aWV3X3NldF9mdWxsX2NvbnRl bnRfem9vbSAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICp3ZWJfdmlldywKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICAg ICAgICAgICAgZnVsbF9jb250ZW50X3pvb20pOwogCitXRUJLSVRfQVBJIFNvdXBTZXNzaW9uKgor d2Via2l0X3dlYl92aWV3X2dldF9zZXNzaW9uICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdl YlZpZXcgICAgICAgICp3ZWJfdmlldyk7CisKK1dFQktJVF9BUEkgdm9pZAord2Via2l0X3dlYl92 aWV3X3NldF9zZXNzaW9uICAgICAgICAgICAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAg ICp3ZWJfdmlldywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBTb3VwU2Vzc2lvbiAgICAgICAgICAqc2Vzc2lvbik7CisKK1dFQktJVF9BUEkgU291cFNl c3Npb24qCit3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAgICAgICAgICAgICAgICAgICAgICAo dm9pZCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv R05VbWFrZWZpbGUuYW0gYi9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbQppbmRleCAyNjIwMGM4 Li40NDFiYzAyIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbQorKysgYi9X ZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbQpAQCAtMjAsNiArMjAsNyBAQCBQcm9ncmFtc19HdGtM YXVuY2hlcl9DRkxBR1MgPSBcCiAJLWZuby1zdHJpY3QtYWxpYXNpbmcgXAogCS1PMiBcCiAJJChn bG9iYWxfY2ZsYWdzKSBcCisJJChMSUJTT1VQX0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykKIAog UHJvZ3JhbXNfR3RrTGF1bmNoZXJfTERBREQgPSBcCkBAIC02Nyw2ICs2OCw3IEBAIFByb2dyYW1z X0R1bXBSZW5kZXJUcmVlX0NGTEFHUyA9IFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwKIAkkKEdMT0JB TERFUFNfQ0ZMQUdTKSBcCiAJJChDQUlST19DRkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBc CiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFtc19EdW1wUmVuZGVyVHJlZV9MREFERCA9IFwKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYyBiL1dlYktpdFRvb2xzL0d0 a0xhdW5jaGVyL21haW4uYwppbmRleCA4ZWQyNjkwLi4zOGNiNWVjIDEwMDY0NAotLS0gYS9XZWJL aXRUb29scy9HdGtMYXVuY2hlci9tYWluLmMKKysrIGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIv bWFpbi5jCkBAIC0xODIsNiArMTgyLDggQEAgY3JlYXRlX3dpbmRvdyAoKQogaW50CiBtYWluIChp bnQgYXJnYywgY2hhciogYXJndltdKQogeworICAgIGlmICghZ190aHJlYWRfc3VwcG9ydGVkICgp KQorICAgICAgICBnX3RocmVhZF9pbml0IChOVUxMKTsKICAgICBndGtfaW5pdCAoJmFyZ2MsICZh cmd2KTsKIAogICAgIEd0a1dpZGdldCogdmJveCA9IGd0a192Ym94X25ldyAoRkFMU0UsIDApOwpk aWZmIC0tZ2l0IGEvY29uZmlndXJlLmFjIGIvY29uZmlndXJlLmFjCmluZGV4IDZhYzZmOGIuLjdm MWM0OWYgMTAwNjQ0Ci0tLSBhL2NvbmZpZ3VyZS5hYworKysgYi9jb25maWd1cmUuYWMKQEAgLTI4 NiwyMCArMjg2LDYgQEAgaWYgdGVzdCAiJHdpdGhfaGlsZG9uIiA9ICJ5ZXMiOyB0aGVuCiAgICAg QUNfU1VCU1QoW0hJTERPTl9MSUJTXSkKIGZpCiAKLSMgZGV0ZXJtaW5lIHRoZSBodHRwIGJhY2tl bmQKLUFDX01TR19DSEVDS0lORyhbdGhlIEhUVFAgYmFja2VuZCB0byB1c2VdKQotQUNfQVJHX1dJ VEgoaHR0cF9iYWNrZW5kLAotICAgICAgICAgICAgQUNfSEVMUF9TVFJJTkcoWy0td2l0aC1odHRw LWJhY2tlbmQ9QDw6QGN1cmwvc291cEA6PkBdLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg W1NlbGVjdCBIVFRQIGJhY2tlbmQgW2RlZmF1bHQ9Y3VybF1dKSwKLSAgICAgICAgICAgIFtdLFt3 aXRoX2h0dHBfYmFja2VuZD0iY3VybCJdKQotCi1jYXNlICIkd2l0aF9odHRwX2JhY2tlbmQiIGlu Ci0gICAgIGN1cmx8c291cCkgOzsKLSAgICAgKikgQUNfTVNHX0VSUk9SKFtJbnZhbGlkIEhUVFAg YmFja2VuZDogbXVzdCBiZSBjdXJsLCBzb3VwLl0pIDs7Ci1lc2FjCi0KLUFDX01TR19SRVNVTFQo WyR3aXRoX2h0dHBfYmFja2VuZF0pCi0KICMgbWluaW11bSBiYXNlIGRlcGVuZGVuY2llcwogQ0FJ Uk9fUkVRVUlSRURfVkVSU0lPTj0xLjIKIEZPTlRDT05GSUdfUkVRVUlSRURfVkVSU0lPTj0yLjQK QEAgLTMxNCw4ICszMDAsNyBAQCBQQU5HT19SRVFVSVJFRF9WRVJTSU9OPTEuMAogR1RLX1JFUVVJ UkVEX1ZFUlNJT049Mi44CiAKICMgb3B0aW9uYWwgbW9kdWxlcwotTElCQ1VSTF9SRVFVSVJFRF9W RVJTSU9OPTcuMTUKLUxJQlNPVVBfUkVRVUlSRURfVkVSU0lPTj0yLjIzCitMSUJTT1VQX1JFUVVJ UkVEX1ZFUlNJT049Mi4yNS40CiBMSUJYU0xUX1JFUVVJUkVEX1ZFUlNJT049MS4xLjcKIFNRTElU RV9SRVFVSVJFRF9WRVJTSU9OPTMuMAogR1NUUkVBTUVSX1JFUVVJUkVEX1ZFUlNJT049MC4xMApA QCAtNjI0LDIzICs2MDksMTEgQEAgZWxzZQogICAgQ0ZMQUdTPSIkQ0ZMQUdTIC1PMCIKIGZpCiAK LSMgY2hlY2sgaWYgY3VybCBpcyBhdmFpbGFibGUKLWlmIHRlc3QgIiR3aXRoX2h0dHBfYmFja2Vu ZCIgPSAiY3VybCI7IHRoZW4KLSAgIFBLR19DSEVDS19NT0RVTEVTKFtMSUJDVVJMXSwKLSAgICAg ICAgICAgICAgICAgICAgIFtsaWJjdXJsID49ICRMSUJDVVJMX1JFUVVJUkVEX1ZFUlNJT05dKQot ICAgaWYgdGVzdCAiJG9zX3dpbjMyIiA9ICJ5ZXMiOyB0aGVuCi0gICAgICBMSUJDVVJMX0xJQlM9 IiRMSUJDVVJMX0xJQlMgLWx3czJfMzIiCi0gICBmaQotICAgQUNfU1VCU1QoW0xJQkNVUkxfQ0ZM QUdTXSkKLSAgIEFDX1NVQlNUKFtMSUJDVVJMX0xJQlNdKQotZmkKIAotaWYgdGVzdCAiJHdpdGhf aHR0cF9iYWNrZW5kIiA9ICJzb3VwIjsgdGhlbgotICAgUEtHX0NIRUNLX01PRFVMRVMoW0xJQlNP VVBdLAotICAgICAgICAgICAgICAgICAgICAgW2xpYnNvdXAtMi40ID49ICRMSUJTT1VQX1JFUVVJ UkVEX1ZFUlNJT05dKQotICAgQUNfU1VCU1QoW0xJQlNPVVBfQ0ZMQUdTXSkKLSAgIEFDX1NVQlNU KFtMSUJTT1VQX0xJQlNdKQotZmkKK1BLR19DSEVDS19NT0RVTEVTKFtMSUJTT1VQXSwKKyAgICAg ICAgICAgICAgICAgIFtsaWJzb3VwLTIuNCA+PSAkTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OXSkK K0FDX1NVQlNUKFtMSUJTT1VQX0NGTEFHU10pCitBQ19TVUJTVChbTElCU09VUF9MSUJTXSkKIAog IyBjaGVjayBpZiBGcmVlVHlwZS9Gb250Q29uZmlnIGFyZSBhdmFpbGFibGUKIGlmIHRlc3QgIiR3 aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5cGUiOyB0aGVuCkBAIC03MTIsMTAgKzY4NSw2IEBA IEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfV0lOMzJdLCBbdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJ3 aW4zMiJdKQogQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9RVUFSVFpdLCBbdGVzdCAiJHdpdGhfdGFy Z2V0IiA9ICJxdWFydHoiXSkKIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfRElSRUNURkJdLCBbdGVz dCAiJHdpdGhfdGFyZ2V0IiA9ICJkaXJlY3RmYiJdKQogCi0jIEhUVFAgYmFja2VuZCBjb25kaXRp b25hbHMKLUFNX0NPTkRJVElPTkFMKFtVU0VfQ1VSTF0sIFt0ZXN0ICIkd2l0aF9odHRwX2JhY2tl bmQiID0gImN1cmwiXSkKLUFNX0NPTkRJVElPTkFMKFtVU0VfU09VUF0sIFt0ZXN0ICIkd2l0aF9o dHRwX2JhY2tlbmQiID0gInNvdXAiXSkKLQogIyBGb250IGJhY2tlbmQgY29uZGl0aW9uYWxzCiBB TV9DT05ESVRJT05BTChbVVNFX0ZSRUVUWVBFXSwgW3Rlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIg PSAiZnJlZXR5cGUiXSkKIEFNX0NPTkRJVElPTkFMKFtVU0VfUEFOR09dLCBbdGVzdCAiJHdpdGhf Zm9udF9iYWNrZW5kIiA9ICJwYW5nbyJdKQpAQCAtNzYyLDcgKzczMSw2IEBAIEJ1aWxkIGNvbmZp Z3VyYXRpb246CiAgRW5hYmxlIEdDQyBidWlsZCBvcHRpbWl6YXRpb24gICAgICAgICAgICAgICAg ICAgICAgICAgICAgOiAkZW5hYmxlX29wdGltaXphdGlvbnMKICBDb2RlIGNvdmVyYWdlIHN1cHBv cnQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVfY292ZXJhZ2UK ICBVbmljb2RlIGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICA6ICR1bmljb2RlX2JhY2tlbmQKLSBIVFRQIGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICA6ICR3aXRoX2h0dHBfYmFja2VuZAogIEZvbnQgYmFja2Vu ZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJHdpdGhfZm9u dF9iYWNrZW5kCiAgT3B0aW1pemVkIG1lbW9yeSBhbGxvY2F0b3IgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgOiAkZW5hYmxlX2Zhc3RfbWFsbG9jCiBGZWF0dXJlczoK 27002 2009-01-24 16:29:00 -0800 2010-06-10 19:35:03 -0700 API to retrieve and set soup sessions #8 soupsession.diff text/plain 25085 christian ZGlmZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggN2FlYzA2 MS4uNDIyMDc2YyAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUu YW0KQEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdP X0NGTEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJM X0NGTEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAog CSQoU1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMCw3ICsxOTksNiBAQCBsaWJXZWJDb3JlX2xhX0xJ QkFERCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBc Ci0JJChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElC UykgXAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODEsNiArNDc5LDcgQEAgUHJvZ3JhbXNfVW5p dFRlc3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9D RkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJJChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFt IGIvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQppbmRleCAyYjJlMzIyLi4wZmRjZDliIDEwMDY0NAot LS0gYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0K QEAgLTE3NzYsMzEgKzE3NzYsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUv cGxhdGZvcm0vaW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3Jl L3BsYXRmb3JtL3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAK LSMgLS0tLQotIyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJj b3JlX2NwcGZsYWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJD b3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9jdXJsL1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvUmVzb3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3Vy bC9SZXNvdXJjZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NP VVAKIHdlYmNvcmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNk aXIpL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xODE0LDcgKzE3ODksNiBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlSGFuZGxlU291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVxdWVzdC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJl c3BvbnNlLmgKLWVuZGlmCiAKICMgLS0tCiAjIEZyZWV0eXBlIGZvbnQgYmFja2VuZApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaCBiL1dlYkNvcmUvbG9hZGVy L0ZyYW1lTG9hZGVyQ2xpZW50LmgKaW5kZXggYjkwY2VjZC4uMmYxYzQxYSAxMDA2NDQKLS0tIGEv V2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXJDbGllbnQuaAorKysgYi9XZWJDb3JlL2xvYWRlci9G cmFtZUxvYWRlckNsaWVudC5oCkBAIC0zNSw2ICszNSwxMCBAQAogI2luY2x1ZGUgPHd0Zi9QbGF0 Zm9ybS5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAorI2lmIFBMQVRGT1JNKEdUSykKKyNp bmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KKyNlbmRpZgorCiB0eXBlZGVmIGNsYXNzIF9qb2JqZWN0 KiBqb2JqZWN0OwogCiAjaWYgUExBVEZPUk0oTUFDKSAmJiAhZGVmaW5lZChfX09CSkNfXykKQEAg LTIwOSw2ICsyMTMsMTAgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAgICAgICAgIHZp cnR1YWwgTlNDYWNoZWRVUkxSZXNwb25zZSogd2lsbENhY2hlUmVzcG9uc2UoRG9jdW1lbnRMb2Fk ZXIqLCB1bnNpZ25lZCBsb25nIGlkZW50aWZpZXIsIE5TQ2FjaGVkVVJMUmVzcG9uc2UqKSBjb25z dCA9IDA7CiAjZW5kaWYKKyNpZiBQTEFURk9STShHVEspCisgICAgICAgIHZpcnR1YWwgU291cFNl c3Npb24qIHNlc3Npb24oKSA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBzZXRTZXNzaW9uKFNv dXBTZXNzaW9uKikgPSAwOworI2VuZGlmCiAKICAgICAgICAgdmlydHVhbCBib29sIHNob3VsZFVz ZVBsdWdpbkRvY3VtZW50KGNvbnN0IFN0cmluZyYgLyptaW1lVHlwZSovKSBjb25zdCB7IHJldHVy biBmYWxzZTsgfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmlu ZGV4IGM5M2FmMjEuLjUxNWUwZWUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIK ICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJz b3VwL3NvdXAuaD4KKyNlbmRpZgorCiAjaWYgUExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0 cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsKICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMiBAQCBw dWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVy biBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lmIFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vz c2lvbiogZ2V0RGVmYXVsdFNlc3Npb24oKTsKKyAgICBzdGF0aWMgU291cFNlc3Npb24qIGdldFNl c3Npb24oY29uc3QgRnJhbWUgKmZyYW1lKTsKKyAgICBzdGF0aWMgdm9pZCBzZXRTZXNzaW9uKGNv bnN0IEZyYW1lICpmcmFtZSwgU291cFNlc3Npb24gKnNlc3Npb24pOworI2VuZGlmCisKICAgICAv LyBVc2VkIHRvIHdvcmsgYXJvdW5kIHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdldCBhbnkgbW9y ZSBOU1VSTENvbm5lY3Rpb24gY2FsbGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJvbSB0aGUgb25l IHlvdSdyZSBpbi4KICAgICBzdGF0aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAgCiAgICAgCkBA IC0xNzgsNyArMTg4LDcgQEAgcHVibGljOgogcHJpdmF0ZToKICNpZiBVU0UoU09VUCkKICAgICBi b29sIHN0YXJ0RGF0YShTdHJpbmcgdXJsU3RyaW5nKTsKLSAgICBib29sIHN0YXJ0SHR0cChTdHJp bmcgdXJsU3RyaW5nKTsKKyAgICBib29sIHN0YXJ0SHR0cChTb3VwU2Vzc2lvbiogc2Vzc2lvbiwg U3RyaW5nIHVybFN0cmluZyk7CiAgICAgYm9vbCBzdGFydEdpbyhTdHJpbmcgdXJsU3RyaW5nKTsK ICNlbmRpZgogCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGVJbnRlcm5hbC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl SW50ZXJuYWwuaAppbmRleCA2NmFhNGMxLi41ODQ1NDhmIDEwMDY0NAotLS0gYS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGVJbnRlcm5hbC5oCisrKyBiL1dlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZUludGVybmFsLmgKQEAgLTE3OCw2ICsxNzgsNyBA QCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgICAgIFZlY3RvcjxjaGFyPiBtX3Bvc3RCeXRlczsK ICNlbmRpZgogI2lmIFVTRShTT1VQKQorICAgICAgICBTb3VwU2Vzc2lvbiogbV9zZXNzaW9uOwog ICAgICAgICBTb3VwTWVzc2FnZSogbV9tc2c7CiAgICAgICAgIFJlc291cmNlUmVzcG9uc2UgbV9y ZXNwb25zZTsKICAgICAgICAgYm9vbCBtX2NhbmNlbGxlZDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAKaW5kZXggODgxMDllOC4uZTY0N2UyMSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5j cHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAK QEAgLTIyLDE4ICsyMiwyOCBAQAogCiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIktV UkwuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5j bHVkZSAiRnJhbWVMb2FkZXJDbGllbnQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1Tb3Vw Q29va2llSmFyKiBnZXRDb29raWVKYXIoKQorU291cENvb2tpZUphciogZ2V0Q29va2llSmFyKGNv bnN0IERvY3VtZW50KiBkb2N1bWVudCkKIHsKLSAgICBzdGF0aWMgU291cENvb2tpZUphciogamFy ID0gc291cF9jb29raWVfamFyX25ldygpOworICAgIEZyYW1lICpmcmFtZSA9IGRvY3VtZW50LT5m cmFtZSgpOworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIEZyYW1lTG9h ZGVyICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAgICAg IHJldHVybiAwOworICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gc3RhdGljX2Nhc3Q8RnJhbWVM b2FkZXJDbGllbnQqPihsb2FkZXItPmNsaWVudCgpKS0+c2Vzc2lvbigpOworICAgIFNvdXBDb29r aWVKYXIqIGphciA9IChTb3VwQ29va2llSmFyKilzb3VwX3Nlc3Npb25fZ2V0X2ZlYXR1cmUoc2Vz c2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpOwogICAgIHJldHVybiBqYXI7CiB9CiAKLXZvaWQg c2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0 IEtVUkwmIC8qcG9saWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCit2b2lkIHNldENvb2tp ZXMoRG9jdW1lbnQqIGRvY3VtZW50LCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IEtVUkwmIC8qcG9s aWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCiB7Ci0gICAgU291cENvb2tpZUphciogamFy ID0gZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogamFyID0gZ2V0Q29va2llSmFy KGRvY3VtZW50KTsKICAgICBpZiAoIWphcikKICAgICAgICAgcmV0dXJuOwogCkBAIC00Myw5ICs1 Myw5IEBAIHZvaWQgc2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJM JiB1cmwsIGNvbnN0IEtVUkwmIC8qcG9saWN5VVJMCiAgICAgc291cF91cmlfZnJlZShvcmlnaW4p OwogfQogCi1TdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25z dCBLVVJMJiB1cmwpCitTdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogZG9jdW1lbnQsIGNv bnN0IEtVUkwmIHVybCkKIHsKLSAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIo KTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBnZXRDb29raWVKYXIoZG9jdW1lbnQpOwogICAg IGlmICghamFyKQogICAgICAgICByZXR1cm4gU3RyaW5nKCk7CiAKQEAgLTU5LDkgKzY5LDkgQEAg U3RyaW5nIGNvb2tpZXMoY29uc3QgRG9jdW1lbnQqIC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYg dXJsKQogICAgIHJldHVybiByZXN1bHQ7CiB9CiAKLWJvb2wgY29va2llc0VuYWJsZWQoY29uc3Qg RG9jdW1lbnQqIC8qZG9jdW1lbnQqLykKK2Jvb2wgY29va2llc0VuYWJsZWQoY29uc3QgRG9jdW1l bnQqIGRvY3VtZW50KQogewotICAgIHJldHVybiBnZXRDb29raWVKYXIoKTsKKyAgICByZXR1cm4g Z2V0Q29va2llSmFyKGRvY3VtZW50KTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0 Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvQ29va2llSmFyU291cC5oCmluZGV4IDYxMTc5YWUuLjZlNTE2OTIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaAorKysgYi9X ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKQEAgLTMxLDcgKzMx LDcgQEAKICNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewot ICAgIFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGdl dENvb2tpZUphcihjb25zdCBEb2N1bWVudCogZG9jdW1lbnQpOwogfQogCiAjZW5kaWYKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5j cHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3Bw CmluZGV4IGRhOTY4NzMuLmQ5NzRlZWYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcApAQCAtMjgsNiArMjgsOCBAQAogI2lu Y2x1ZGUgIkNvb2tpZUphclNvdXAuaCIKICNpbmNsdWRlICJEb2NMb2FkZXIuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCisjaW5jbHVkZSAiRnJhbWVMb2Fk ZXJDbGllbnQuaCIKICNpbmNsdWRlICJIVFRQUGFyc2Vycy5oIgogI2luY2x1ZGUgIk1JTUVUeXBl UmVnaXN0cnkuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgpAQCAtNDksOCArNTEsNiBA QAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLXN0YXRpYyBTb3VwU2Vzc2lvbiogc2Vzc2lvbiA9 IDA7Ci0KIGVudW0KIHsKICAgICBFUlJPUl9UUkFOU1BPUlQsCkBAIC0xNzMsNiArMTczLDggQEAg c3RhdGljIHZvaWQgZmluaXNoZWRDYWxsYmFjayhTb3VwU2Vzc2lvbiAqc2Vzc2lvbiwgU291cE1l c3NhZ2UqIG1zZywgZ3BvaW50ZXIgZGEKICAgICAgICAgcmV0dXJuOwogCiAgICAgUmVzb3VyY2VI YW5kbGVJbnRlcm5hbCogZCA9IGhhbmRsZS0+Z2V0SW50ZXJuYWwoKTsKKyAgICBnX29iamVjdF91 bnJlZihkLT5tX3Nlc3Npb24pOworICAgIGQtPm1fc2Vzc2lvbiA9IE5VTEw7CiAKICAgICBSZXNv dXJjZUhhbmRsZUNsaWVudCogY2xpZW50ID0gaGFuZGxlLT5jbGllbnQoKTsKICAgICBpZiAoIWNs aWVudCkKQEAgLTI4MiwyMyArMjg0LDM4IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0RGF0 YShTdHJpbmcgdXJsU3RyaW5nKQogICAgIHJldHVybiB0cnVlOwogfQogCi1ib29sIFJlc291cmNl SGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmluZykKK3N0YXRpYyB2b2lkIGVuc3VyZVNl c3Npb24oU291cFNlc3Npb24qIHNlc3Npb24pCiB7Ci0gICAgaWYgKCFzZXNzaW9uKSB7Ci0gICAg ICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3KCk7CisgICAgaWYgKGdfb2JqZWN0 X2dldF9kYXRhKEdfT0JKRUNUKHNlc3Npb24pLCAid2Via2l0LWluaXQiKSkKKyAgICAgICAgcmV0 dXJuOwogCi0gICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1NF U1NJT05fRkVBVFVSRShnZXRDb29raWVKYXIoKSkpOworICAgIFNvdXBDb29raWVKYXIqIGphcjsK KyAgICBjb25zdCBjaGFyKiB3ZWJraXRfZGVidWcgPSBnX2dldGVudigiV0VCS0lUX0RFQlVHIik7 CiAKLSAgICAgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfU09V UF9MT0dHSU5HIik7Ci0gICAgICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0gICAgICAgICAgICBpbnQg c291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAgamFyID0gKFNvdXBDb29r aWVKYXIqKXNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfQ09PS0lF X0pBUik7CisgICAgaWYgKCFqYXIpIHsKKyAgICAgICAgamFyID0gc291cF9jb29raWVfamFyX25l dygpOworICAgICAgICBzb3VwX3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNT SU9OX0ZFQVRVUkUoamFyKSk7CisgICAgICAgIGdfb2JqZWN0X3VucmVmKGphcik7CisgICAgfQog Ci0gICAgICAgICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGlj X2Nhc3Q8U291cExvZ2dlckxvZ0xldmVsPihzb3VwX2RlYnVnX2xldmVsKSwgLTEpOwotICAgICAg ICAgICAgc291cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7Ci0gICAgICAgICAgICBn X29iamVjdF91bnJlZihsb2dnZXIpOwotICAgICAgICB9CisgICAgaWYgKHNvdXBfc2Vzc2lvbl9n ZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfTE9HR0VSKSA9PSBOVUxMCisgICAgICAgICYm IHdlYmtpdF9kZWJ1ZyAmJiAhc3RyY21wKHdlYmtpdF9kZWJ1ZywgIm5ldHdvcmsiKSkgeworICAg ICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291 cExvZ2dlckxvZ0xldmVsPihTT1VQX0xPR0dFUl9MT0dfQk9EWSksIC0xKTsKKyAgICAgICAgc291 cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7CisgICAgICAgIGdfb2JqZWN0X3VucmVm KGxvZ2dlcik7CiAgICAgfQogCisgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1Qoc2Vzc2lv biksICJ3ZWJraXQtaW5pdCIsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KDB4ZGVhZGJlZWYpKTsK K30KKworYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFNvdXBTZXNzaW9uKiBzZXNzaW9u LCBTdHJpbmcgdXJsU3RyaW5nKQoreworICAgIGlmKCFzZXNzaW9uKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisKKyAgICBlbnN1cmVTZXNzaW9uKHNlc3Npb24pOworCiAgICAgU291cE1lc3NhZ2Uq IG1zZzsKICAgICBtc2cgPSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVlc3QoKS5odHRwTWV0aG9kKCku dXRmOCgpLmRhdGEoKSwgdXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOwogICAgIGdfc2lnbmFsX2Nv bm5lY3QobXNnLCAicmVzdGFydGVkIiwgR19DQUxMQkFDSyhyZXN0YXJ0ZWRDYWxsYmFjayksIHRo aXMpOwpAQCAtMzI4LDggKzM0NSw5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChT dHJpbmcgdXJsU3RyaW5nKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9N RU1PUllfQ09QWSwgYm9keS5kYXRhKCksIGJvZHkuc2l6ZSgpKTsKICAgICB9CiAKKyAgICBkLT5t X3Nlc3Npb24gPSBzdGF0aWNfY2FzdDxTb3VwU2Vzc2lvbio+KGdfb2JqZWN0X3JlZihzZXNzaW9u KSk7CiAgICAgZC0+bV9tc2cgPSBzdGF0aWNfY2FzdDxTb3VwTWVzc2FnZSo+KGdfb2JqZWN0X3Jl Zihtc2cpKTsKLSAgICBzb3VwX3Nlc3Npb25fcXVldWVfbWVzc2FnZShzZXNzaW9uLCBkLT5tX21z ZywgZmluaXNoZWRDYWxsYmFjaywgdGhpcyk7CisgICAgc291cF9zZXNzaW9uX3F1ZXVlX21lc3Nh Z2Uoc2Vzc2lvbiwgbXNnLCBmaW5pc2hlZENhbGxiYWNrLCB0aGlzKTsKIAogICAgIHJldHVybiB0 cnVlOwogfQpAQCAtMzUwLDcgKzM2OCw3IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0KEZy YW1lKiBmcmFtZSkKICAgICBpZiAoZXF1YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJkYXRhIikp CiAgICAgICAgIHJldHVybiBzdGFydERhdGEodXJsU3RyaW5nKTsKICAgICBlbHNlIGlmICgoZXF1 YWxJZ25vcmluZ0Nhc2UocHJvdG9jb2wsICJodHRwIikgfHwgZXF1YWxJZ25vcmluZ0Nhc2UocHJv dG9jb2wsICJodHRwcyIpKSAmJiBTT1VQX1VSSV9WQUxJRF9GT1JfSFRUUChzb3VwX3VyaV9uZXco dXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpKSkKLSAgICAgICAgcmV0dXJuIHN0YXJ0SHR0cCh1cmxT dHJpbmcpOworICAgICAgICByZXR1cm4gc3RhcnRIdHRwKGdldFNlc3Npb24oZnJhbWUpLCB1cmxT dHJpbmcpOwogICAgIGVsc2UgaWYgKGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZmlsZSIp IHx8IGVxdWFsSWdub3JpbmdDYXNlKHByb3RvY29sLCAiZnRwIikgfHwgZXF1YWxJZ25vcmluZ0Nh c2UocHJvdG9jb2wsICJmdHBzIikpCiAgICAgICAgIC8vIEZJWE1FOiBzaG91bGQgd2UgYmUgZG9p bmcgYW55IG90aGVyIHByb3RvY29scyBoZXJlPwogICAgICAgICByZXR1cm4gc3RhcnRHaW8odXJs U3RyaW5nKTsKQEAgLTM2OCw3ICszODYsNyBAQCB2b2lkIFJlc291cmNlSGFuZGxlOjpjYW5jZWwo KQogewogICAgIGQtPm1fY2FuY2VsbGVkID0gdHJ1ZTsKICAgICBpZiAoZC0+bV9tc2cpIHsKLSAg ICAgICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKHNlc3Npb24sIGQtPm1fbXNnLCBTT1VQ X1NUQVRVU19DQU5DRUxMRUQpOworICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2Uo ZC0+bV9zZXNzaW9uLCBkLT5tX21zZywgU09VUF9TVEFUVVNfQ0FOQ0VMTEVEKTsKICAgICAgICAg Ly8gRm9yIHJlLWVudHJhbmN5IHRyb3VibGVzIHdlIGNhbGwgZGlkRmluaXNoTG9hZGluZyB3aGVu IHRoZSBtZXNzYWdlIGhhc24ndCBiZWVuIGhhbmRsZWQgeWV0LgogICAgICAgICBpZiAoY2xpZW50 KCkpCiAgICAgICAgICAgICBjbGllbnQoKS0+ZGlkRmluaXNoTG9hZGluZyh0aGlzKTsKQEAgLTYx OSw1ICs2MzcsMzMgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRHaW8oU3RyaW5nIHVybFN0 cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorU291cFNlc3Npb24qIFJlc291cmNlSGFuZGxl OjpnZXREZWZhdWx0U2Vzc2lvbigpCit7CisgICAgc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9u ID0gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworICAgIHJldHVybiBzZXNzaW9uOworfQorCitT b3VwU2Vzc2lvbiogUmVzb3VyY2VIYW5kbGU6OmdldFNlc3Npb24oY29uc3QgRnJhbWUgKmZyYW1l KQoreworICAgIGlmICghZnJhbWUpCisgICAgICAgIHJldHVybiAwOworICAgIEZyYW1lTG9hZGVy ICpsb2FkZXIgPSBmcmFtZS0+bG9hZGVyKCk7CisgICAgaWYgKCFsb2FkZXIpCisgICAgICAgIHJl dHVybiAwOworICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uID0gc3RhdGljX2Nhc3Q8RnJhbWVMb2Fk ZXJDbGllbnQqPihsb2FkZXItPmNsaWVudCgpKS0+c2Vzc2lvbigpOworICAgIHJldHVybiBzZXNz aW9uID8gc2Vzc2lvbiA6IGdldERlZmF1bHRTZXNzaW9uKCk7Cit9CisKK3ZvaWQgUmVzb3VyY2VI YW5kbGU6OnNldFNlc3Npb24oY29uc3QgRnJhbWUgKmZyYW1lLCBTb3VwU2Vzc2lvbiAqc2Vzc2lv bikKK3sKKyAgICBpZiAoIWZyYW1lKQorICAgICAgICByZXR1cm47CisgICAgRnJhbWVMb2FkZXIg KmxvYWRlciA9IGZyYW1lLT5sb2FkZXIoKTsKKyAgICBpZiAoIWxvYWRlcikKKyAgICAgICAgcmV0 dXJuOworICAgIGxvYWRlci0+c3RvcCgpOworICAgIHN0YXRpY19jYXN0PEZyYW1lTG9hZGVyQ2xp ZW50Kj4obG9hZGVyLT5jbGllbnQoKSktPnNldFNlc3Npb24oc2Vzc2lvbik7Cit9CisKIH0KIApk aWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVDbGllbnRHdGsuaCBi L1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvQ2hyb21lQ2xpZW50R3RrLmgKaW5kZXggMjk5ZDAy My4uZWE1NGJmNyAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJDb3JlU3VwcG9ydC9DaHJvbWVD bGllbnRHdGsuaAorKysgYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0Nocm9tZUNsaWVudEd0 ay5oCkBAIC0yMiw2ICsyMiw3IEBACiAKICNpbmNsdWRlICJDaHJvbWVDbGllbnQuaCIKICNpbmNs dWRlICJLVVJMLmgiCisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAKIHR5cGVkZWYgc3RydWN0 IF9XZWJLaXRXZWJWaWV3IFdlYktpdFdlYlZpZXc7CiAKQEAgLTMxLDYgKzMyLDcgQEAgbmFtZXNw YWNlIFdlYktpdCB7CiAgICAgcHVibGljOgogICAgICAgICBDaHJvbWVDbGllbnQoV2ViS2l0V2Vi VmlldyopOwogICAgICAgICBXZWJLaXRXZWJWaWV3KiB3ZWJWaWV3KCkgY29uc3QgeyByZXR1cm4g bV93ZWJWaWV3OyB9CisgICAgICAgIFNvdXBTZXNzaW9uKiBzZXNzaW9uKCk7CiAKICAgICAgICAg dmlydHVhbCB2b2lkIGNocm9tZURlc3Ryb3llZCgpOwogCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3Rr L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50R3RrLmNwcCBiL1dlYktpdC9ndGsvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuY3BwCmluZGV4IDFiNDEwYzcuLjlhYmU3 ODAgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCisrKyBiL1dlYktpdC9ndGsvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRHdGsuY3BwCkBAIC02NCw2ICs2NCw3IEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiBGcmFtZUxv YWRlckNsaWVudDo6RnJhbWVMb2FkZXJDbGllbnQoV2ViS2l0V2ViRnJhbWUqIGZyYW1lKQogICAg IDogbV9mcmFtZShmcmFtZSkKKyAgICAsIG1fc2Vzc2lvbigwKQogICAgICwgbV91c2VyQWdlbnQo IiIpCiAgICAgLCBtX3BvbGljeURlY2lzaW9uKDApCiAgICAgLCBtX3BsdWdpblZpZXcoMCkKQEAg LTc0LDYgKzc1LDggQEAgRnJhbWVMb2FkZXJDbGllbnQ6OkZyYW1lTG9hZGVyQ2xpZW50KFdlYktp dFdlYkZyYW1lKiBmcmFtZSkKIAogRnJhbWVMb2FkZXJDbGllbnQ6On5GcmFtZUxvYWRlckNsaWVu dCgpCiB7CisgICAgaWYgKG1fc2Vzc2lvbikKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobV9zZXNz aW9uKTsKICAgICBpZiAobV9wb2xpY3lEZWNpc2lvbikKICAgICAgICAgZ19vYmplY3RfdW5yZWYo bV9wb2xpY3lEZWNpc2lvbik7CiB9CkBAIC04NzUsNCArODc4LDE2IEBAIHZvaWQgRnJhbWVMb2Fk ZXJDbGllbnQ6OnRyYW5zaXRpb25Ub0NvbW1pdHRlZEZvck5ld1BhZ2UoKQogICAgIGZyYW1lLT52 aWV3KCktPnNldEd0a0FkanVzdG1lbnRzKHByaXYtPmhvcml6b250YWxBZGp1c3RtZW50LCBwcml2 LT52ZXJ0aWNhbEFkanVzdG1lbnQpOwogfQogCitTb3VwU2Vzc2lvbiogRnJhbWVMb2FkZXJDbGll bnQ6OnNlc3Npb24oKQoreworICAgIHJldHVybiBtX3Nlc3Npb247Cit9CisKK3ZvaWQgRnJhbWVM b2FkZXJDbGllbnQ6OnNldFNlc3Npb24oU291cFNlc3Npb24qIHNlc3Npb24pCit7CisgICAgaWYg KG1fc2Vzc2lvbikKKyAgICAgICAgZ19vYmplY3RfdW5yZWYoc2Vzc2lvbik7CisgICAgbV9zZXNz aW9uID0gc3RhdGljX2Nhc3Q8U291cFNlc3Npb24qPihnX29iamVjdF9yZWYoc2Vzc2lvbikpOwor fQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVy Q2xpZW50R3RrLmggYi9XZWJLaXQvZ3RrL1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 R3RrLmgKaW5kZXggYzY5NTJkYi4uMjNkMjljMSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9XZWJD b3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudEd0ay5oCisrKyBiL1dlYktpdC9ndGsvV2ViQ29y ZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRHdGsuaApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1 ZGUgIlJlc291cmNlUmVzcG9uc2UuaCIKICNpbmNsdWRlICJQbHVnaW5WaWV3LmgiCiAjaW5jbHVk ZSAid2Via2l0d2VicG9saWN5ZGVjaXNpb24uaCIKKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4K IAogdHlwZWRlZiBzdHJ1Y3QgX1dlYktpdFdlYkZyYW1lIFdlYktpdFdlYkZyYW1lOwogCkBAIC0x NjksOCArMTcwLDEyIEBAIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgICAgIHZpcnR1YWwgYm9v bCBjYW5DYWNoZVBhZ2UoKSBjb25zdDsKICAgICAgICAgdmlydHVhbCB2b2lkIGRvd25sb2FkKFdl YkNvcmU6OlJlc291cmNlSGFuZGxlKiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jiwg Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VS ZXNwb25zZSYpOworCisgICAgICAgIHZpcnR1YWwgU291cFNlc3Npb24qIHNlc3Npb24oKTsKKyAg ICAgICAgdmlydHVhbCB2b2lkIHNldFNlc3Npb24oU291cFNlc3Npb24qKTsKICAgICBwcml2YXRl OgogICAgICAgICBXZWJLaXRXZWJGcmFtZSogbV9mcmFtZTsKKyAgICAgICAgU291cFNlc3Npb24q IG1fc2Vzc2lvbjsKICAgICAgICAgV2ViQ29yZTo6UmVzb3VyY2VSZXNwb25zZSBtX3Jlc3BvbnNl OwogICAgICAgICBXZWJDb3JlOjpTdHJpbmcgbV91c2VyQWdlbnQ7CiAgICAgICAgIFdlYktpdFdl YlBvbGljeURlY2lzaW9uKiBtX3BvbGljeURlY2lzaW9uOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0 ay93ZWJraXQucGMuaW4gYi9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbgppbmRleCAwY2U2ZjcxLi44 NGQ2MTE1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbgorKysgYi9XZWJLaXQv Z3RrL3dlYmtpdC5wYy5pbgpAQCAtNiw2ICs2LDYgQEAgaW5jbHVkZWRpcj1AaW5jbHVkZWRpckAK IE5hbWU6IFdlYktpdAogRGVzY3JpcHRpb246IFdlYiBjb250ZW50IGVuZ2luZSBmb3IgR1RLKwog VmVyc2lvbjogQFZFUlNJT05ACi1SZXF1aXJlczogZ3RrKy0yLjAKK1JlcXVpcmVzOiBndGsrLTIu MCBsaWJzb3VwLTIuNAogTGliczogLUwke2xpYmRpcn0gLWx3ZWJraXQtMS4wCiBDZmxhZ3M6IC1J JHtpbmNsdWRlZGlyfS93ZWJraXQtMS4wCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93 ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmlu ZGV4IDM1OGFjZTkuLjA2YjJlZmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBA IC01OSw2ICs1OSw3IEBACiAjaW5jbHVkZSAiUGFzdGVib2FyZEhlbHBlci5oIgogI2luY2x1ZGUg IlBsYXRmb3JtS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtV2hlZWxFdmVudC5o IgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2NyaXB0VmFsdWUuaCIK ICNpbmNsdWRlICJTY3JvbGxiYXIuaCIKICNpbmNsdWRlICJTdWJzdGl0dXRlRGF0YS5oIgpAQCAt MTQ2LDcgKzE0Nyw4IEBAIGVudW0gewogICAgIFBST1BfV0lORE9XX0ZFQVRVUkVTLAogICAgIFBS T1BfVFJBTlNQQVJFTlQsCiAgICAgUFJPUF9aT09NX0xFVkVMLAotICAgIFBST1BfRlVMTF9DT05U RU5UX1pPT00KKyAgICBQUk9QX0ZVTExfQ09OVEVOVF9aT09NLAorICAgIFBST1BfU0VTU0lPTiwK IH07CiAKIHN0YXRpYyBndWludCB3ZWJraXRfd2ViX3ZpZXdfc2lnbmFsc1tMQVNUX1NJR05BTF0g PSB7IDAsIH07CkBAIC0zMDQsNiArMzA2LDkgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3 X2dldF9wcm9wZXJ0eShHT2JqZWN0KiBvYmplY3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSoKICAg ICBjYXNlIFBST1BfRlVMTF9DT05URU5UX1pPT006CiAgICAgICAgIGdfdmFsdWVfc2V0X2Jvb2xl YW4odmFsdWUsIHdlYmtpdF93ZWJfdmlld19nZXRfZnVsbF9jb250ZW50X3pvb20od2ViVmlldykp OwogICAgICAgICBicmVhazsKKyAgICBjYXNlIFBST1BfU0VTU0lPTjoKKyAgICAgICAgZ192YWx1 ZV9zZXRfb2JqZWN0KHZhbHVlLCB3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24od2ViVmlldykp OworICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBHX09CSkVDVF9XQVJOX0lO VkFMSURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CiAgICAgfQpAQCAtMzMy LDYgKzMzNyw5IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfcHJvcGVydHkoR09i amVjdCogb2JqZWN0LCBndWludCBwcm9wX2lkLCBjb25zdCBHCiAgICAgY2FzZSBQUk9QX0ZVTExf Q09OVEVOVF9aT09NOgogICAgICAgICB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96 b29tKHdlYlZpZXcsIGdfdmFsdWVfZ2V0X2Jvb2xlYW4odmFsdWUpKTsKICAgICAgICAgYnJlYWs7 CisgICAgY2FzZSBQUk9QX1NFU1NJT046CisgICAgICAgIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vz c2lvbih3ZWJWaWV3LCBTT1VQX1NFU1NJT04oZ192YWx1ZV9nZXRfb2JqZWN0KHZhbHVlKSkpOwor ICAgICAgICBicmVhazsKICAgICBkZWZhdWx0OgogICAgICAgICBHX09CSkVDVF9XQVJOX0lOVkFM SURfUFJPUEVSVFlfSUQob2JqZWN0LCBwcm9wX2lkLCBwc3BlYyk7CiAgICAgfQpAQCAtMTU2OSw2 ICsxNTc3LDIwIEBAIHN0YXRpYyB2b2lkIHdlYmtpdF93ZWJfdmlld19jbGFzc19pbml0KFdlYktp dFdlYlZpZXdDbGFzcyogd2ViVmlld0NsYXNzKQogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRkFMU0UsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBRFdS SVRFKSk7CiAKKyAgICAvKioKKyAgICAqIFdlYktpdFdlYlZpZXc6c2Vzc2lvbjoKKyAgICAqCisg ICAgKiBSZXRyaWV2ZXMgdGhlIHNlc3Npb24gb2YgdGhlIHZpZXcuCisgICAgKgorICAgICogU2lu Y2U6IDEuMS4xCisgICAgKi8KKyAgICBnX29iamVjdF9jbGFzc19pbnN0YWxsX3Byb3BlcnR5KG9i amVjdENsYXNzLCBQUk9QX1NFU1NJT04sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBnX3BhcmFtX3NwZWNfb2JqZWN0KCJzZXNzaW9uIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlNlc3Npb24iLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiUmV0cmlldmVz IHRoZSBzZXNzaW9uIG9mIHRoZSB2aWV3IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgU09VUF9UWVBFX1NFU1NJT04sCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdFQktJVF9QQVJB TV9SRUFEV1JJVEUpKTsKKwogICAgIGdfdHlwZV9jbGFzc19hZGRfcHJpdmF0ZSh3ZWJWaWV3Q2xh c3MsIHNpemVvZihXZWJLaXRXZWJWaWV3UHJpdmF0ZSkpOwogfQogCkBAIC0yNjcyLDQgKzI2OTQs ODAgQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdl YlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpvb20KICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpF Q1Qod2ViVmlldyksICJmdWxsLWNvbnRlbnQtem9vbSIpOwogfQogCisvKioKKyAqIHdlYmtpdF93 ZWJfdmlld19nZXRfc2Vzc2lvbjoKKyAqIEB3ZWJfdmlldzogYSAjV2ViS2l0V2ViVmlldworICoK KyAqIFJldHJpZXZlcyB0aGUgI1NvdXBTZXNzaW9uIG9mIHRoZSB2aWV3LCBjcmVhdGVkIHdoZW4g dGhpcworICogZnVuY3Rpb24gaXMgY2FsbGVkIGZvciB0aGUgZmlyc3QgdGltZS4KKyAqCisgKiBE b24ndCB1c2UgdGhpcyBmdW5jdGlvbiB1bmxlc3MgeW91IGludGVuZCB0byBtYW5hZ2Ugc2Vzc2lv bnMKKyAqIGZvciB5b3VyIHdlYiB2aWV3cyBvbiB5b3VyIG93bi4gU2VlIGFsc28gd2Via2l0X3dl Yl92aWV3X3NldF9zZXNzaW9uKCkuCisgKgorICogUmV0dXJuIHZhbHVlOiB0aGUgI1NvdXBTZXNz aW9uIG9mIHRoZSB2aWV3CisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3 ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24gKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcpCit7Cisg ICAgU291cFNlc3Npb24qIHNlc3Npb247CisKKyAgICBnX3JldHVybl92YWxfaWZfZmFpbChXRUJL SVRfSVNfV0VCX1ZJRVcod2ViVmlldyksIE5VTEwpOworCisgICAgc2Vzc2lvbiA9IFJlc291cmNl SGFuZGxlOjpnZXRTZXNzaW9uKGNvcmUod2ViVmlldy0+cHJpdi0+bWFpbkZyYW1lKSk7CisgICAg aWYgKCFzZXNzaW9uKSB7CisgICAgICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3 ICgpOworICAgICAgICBSZXNvdXJjZUhhbmRsZTo6c2V0U2Vzc2lvbihjb3JlKHdlYlZpZXctPnBy aXYtPm1haW5GcmFtZSksIHNlc3Npb24pOworICAgIH0KKyAgICByZXR1cm4gc2Vzc2lvbjsKK30K KworLyoqCisgKiB3ZWJraXRfd2ViX3ZpZXdfc2V0X3Nlc3Npb246CisgKiBAd2ViX3ZpZXc6IGEg I1dlYktpdFdlYlZpZXcKKyAqIEBzZXNzaW9uOiBhICNTb3VwU2Vzc2lvbgorICoKKyAqIEFzc2ln bnMgYSBwYXJ0aWN1bGFyIHNlc3Npb24gdG8gdGhlIHdlYiB2aWV3LiBJdCBpcyByZWNvbW1lbmRl ZAorICogdGhhdCB5b3Ugb25seSB1c2Ugc2Vzc2lvbnMgcmV0dXJuZWQgYnkgd2Via2l0X3dlYl92 aWV3X2dldF9zZXNzaW9uKCkKKyAqIG9yIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uKCkuCisg KgorICogV2ViS2l0IG9ubHkgc3VwcG9ydHMgc2Vzc2lvbnMgb2YgdGhlIHR5cGUgI1NvdXBTZXNz aW9uQXN5bmMuCisgKgorICogRG9uJ3QgdXNlIHRoaXMgZnVuY3Rpb24gdW5sZXNzIHlvdSBpbnRl bmQgdG8gbWFuYWdlIHNlc3Npb25zCisgKiBmb3IgeW91ciB3ZWIgdmlld3Mgb24geW91ciBvd24u IFNlZSBhbHNvIHdlYmtpdF93ZWJfdmlld19nZXRfc2Vzc2lvbigpLgorICoKKyAqIFNpbmNlOiAx LjEuMQorICovCit2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfc2Vzc2lvbiAoV2ViS2l0V2ViVmll dyogd2ViVmlldywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTb3VwU2Vzc2lv biogICBzZXNzaW9uKQoreworICAgIGdfcmV0dXJuX2lmX2ZhaWwoV0VCS0lUX0lTX1dFQl9WSUVX KHdlYlZpZXcpKTsKKyAgICBpZiAoIVNPVVBfSVNfU0VTU0lPTl9BU1lOQyhzZXNzaW9uKSkgewor ICAgICAgICBnX2NyaXRpY2FsKCJZb3UgYXJlIHRyeWluZyB0byBhc3NpZ24gYSBTb3VwU2Vzc2lv blN5bmMgdG8gdGhlIHdlYiB2aWV3ICIKKyAgICAgICAgICAgICAgICAgICAiYnV0IFdlYktpdCBy ZXF1aXJlcyBhIFNvdXBTZXNzaW9uQXN5bmMgdG8gd29yayBwcm9wZXJseS4iKTsKKyAgICAgICAg cmV0dXJuOworICAgIH0KKworICAgIFJlc291cmNlSGFuZGxlOjpzZXRTZXNzaW9uKGNvcmUod2Vi Vmlldy0+cHJpdi0+bWFpbkZyYW1lKSwgc2Vzc2lvbik7Cit9CisKKy8qKgorICogd2Via2l0X2dl dF9kZWZhdWx0X3Nlc3Npb246CisgKgorICogUmV0cmlldmVzIHRoZSBkZWZhdWx0ICNTb3VwU2Vz c2lvbiB1c2VkIGJ5IGFsbCB3ZWIgdmlld3MgdW5sZXNzCisgKiB3ZWJraXRfd2ViX3ZpZXdfZ2V0 X3Nlc3Npb24oKSBpcyBjYWxsZWQuCisgKgorICogVGhlIHNlc3Npb24gaXMgaW5pdGlhbGx5IGVt cHR5LiBVcG9uIHRoZSBmaXJzdCBsb2FkCisgKiBhIGNvb2tpZSBqYXIgd2lsbCBiZSBhZGRlZC4g SG93ZXZlciB5b3UgY2FuCisgKiBhZGQgeW91ciBvd24gY29va2llIGphciBhbmQgV2ViS2l0IHdp bGwgdXNlIGl0LgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlIGRlZmF1bHQgI1NvdXBTZXNzaW9u CisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfZ2V0X2RlZmF1 bHRfc2Vzc2lvbiAodm9pZCkKK3sKKyAgICByZXR1cm4gUmVzb3VyY2VIYW5kbGU6OmdldERlZmF1 bHRTZXNzaW9uKCk7Cit9CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaAppbmRleCAyYmI4 YzYxLi4xYTliZjU4IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3 LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCkBAIC0yOSw2ICsyOSw3 IEBACiAjaW5jbHVkZSA8d2Via2l0L3dlYmtpdHdlYmJhY2tmb3J3YXJkbGlzdC5oPgogI2luY2x1 ZGUgPHdlYmtpdC93ZWJraXR3ZWJoaXN0b3J5aXRlbS5oPgogI2luY2x1ZGUgPHdlYmtpdC93ZWJr aXR3ZWJzZXR0aW5ncy5oPgorI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBHX0JFR0lOX0RF Q0xTCiAKQEAgLTI5Niw2ICsyOTcsMTYgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3Zp ZXdfc2V0X2Z1bGxfY29udGVudF96b29tICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAg KndlYl92aWV3LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGdib29sZWFuICAgICAgICAgICAgICBmdWxsX2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9B UEkgU291cFNlc3Npb24qCit3ZWJraXRfd2ViX3ZpZXdfZ2V0X3Nlc3Npb24gICAgICAgICAgICAg ICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3KTsKKworV0VCS0lUX0FQSSB2 b2lkCit3ZWJraXRfd2ViX3ZpZXdfc2V0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAoV2Vi S2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFNvdXBTZXNzaW9uICAgICAgICAgICpzZXNzaW9uKTsKKwor V0VCS0lUX0FQSSBTb3VwU2Vzc2lvbioKK3dlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uICAgICAg ICAgICAgICAgICAgICAgICh2b2lkKTsKKwogR19FTkRfREVDTFMKIAogI2VuZGlmCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxl LmFtCmluZGV4IDI2MjAwYzguLjQ0MWJjMDIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0dOVW1h a2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCkBAIC0yMCw2ICsyMCw3 IEBAIFByb2dyYW1zX0d0a0xhdW5jaGVyX0NGTEFHUyA9IFwKIAktZm5vLXN0cmljdC1hbGlhc2lu ZyBcCiAJLU8yIFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKSBcCiAJ JChHVEtfQ0ZMQUdTKQogCiBQcm9ncmFtc19HdGtMYXVuY2hlcl9MREFERCA9IFwKQEAgLTY3LDYg KzY4LDcgQEAgUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfQ0ZMQUdTID0gXAogCSQoZ2xvYmFsX2Nm bGFncykgXAogCSQoR0xPQkFMREVQU19DRkxBR1MpIFwKIAkkKENBSVJPX0NGTEFHUykgXAorCSQo TElCU09VUF9DRkxBR1MpIFwKIAkkKEdUS19DRkxBR1MpCiAKIFByb2dyYW1zX0R1bXBSZW5kZXJU cmVlX0xEQUREID0gXApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5j IGIvV2ViS2l0VG9vbHMvR3RrTGF1bmNoZXIvbWFpbi5jCmluZGV4IDhlZDI2OTAuLjM4Y2I1ZWMg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0d0a0xhdW5jaGVyL21haW4uYworKysgYi9XZWJLaXRU b29scy9HdGtMYXVuY2hlci9tYWluLmMKQEAgLTE4Miw2ICsxODIsOCBAQCBjcmVhdGVfd2luZG93 ICgpCiBpbnQKIG1haW4gKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiB7CisgICAgaWYgKCFnX3Ro cmVhZF9zdXBwb3J0ZWQgKCkpCisgICAgICAgIGdfdGhyZWFkX2luaXQgKE5VTEwpOwogICAgIGd0 a19pbml0ICgmYXJnYywgJmFyZ3YpOwogCiAgICAgR3RrV2lkZ2V0KiB2Ym94ID0gZ3RrX3Zib3hf bmV3IChGQUxTRSwgMCk7CmRpZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMK aW5kZXggNmFjNmY4Yi4uN2YxYzQ5ZiAxMDA2NDQKLS0tIGEvY29uZmlndXJlLmFjCisrKyBiL2Nv bmZpZ3VyZS5hYwpAQCAtMjg2LDIwICsyODYsNiBAQCBpZiB0ZXN0ICIkd2l0aF9oaWxkb24iID0g InllcyI7IHRoZW4KICAgICBBQ19TVUJTVChbSElMRE9OX0xJQlNdKQogZmkKIAotIyBkZXRlcm1p bmUgdGhlIGh0dHAgYmFja2VuZAotQUNfTVNHX0NIRUNLSU5HKFt0aGUgSFRUUCBiYWNrZW5kIHRv IHVzZV0pCi1BQ19BUkdfV0lUSChodHRwX2JhY2tlbmQsCi0gICAgICAgICAgICBBQ19IRUxQX1NU UklORyhbLS13aXRoLWh0dHAtYmFja2VuZD1APDpAY3VybC9zb3VwQDo+QF0sCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICBbU2VsZWN0IEhUVFAgYmFja2VuZCBbZGVmYXVsdD1jdXJsXV0pLAot ICAgICAgICAgICAgW10sW3dpdGhfaHR0cF9iYWNrZW5kPSJjdXJsIl0pCi0KLWNhc2UgIiR3aXRo X2h0dHBfYmFja2VuZCIgaW4KLSAgICAgY3VybHxzb3VwKSA7OwotICAgICAqKSBBQ19NU0dfRVJS T1IoW0ludmFsaWQgSFRUUCBiYWNrZW5kOiBtdXN0IGJlIGN1cmwsIHNvdXAuXSkgOzsKLWVzYWMK LQotQUNfTVNHX1JFU1VMVChbJHdpdGhfaHR0cF9iYWNrZW5kXSkKLQogIyBtaW5pbXVtIGJhc2Ug ZGVwZW5kZW5jaWVzCiBDQUlST19SRVFVSVJFRF9WRVJTSU9OPTEuMgogRk9OVENPTkZJR19SRVFV SVJFRF9WRVJTSU9OPTIuNApAQCAtMzE0LDggKzMwMCw3IEBAIFBBTkdPX1JFUVVJUkVEX1ZFUlNJ T049MS4wCiBHVEtfUkVRVUlSRURfVkVSU0lPTj0yLjgKIAogIyBvcHRpb25hbCBtb2R1bGVzCi1M SUJDVVJMX1JFUVVJUkVEX1ZFUlNJT049Ny4xNQotTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OPTIu MjMKK0xJQlNPVVBfUkVRVUlSRURfVkVSU0lPTj0yLjI1LjQKIExJQlhTTFRfUkVRVUlSRURfVkVS U0lPTj0xLjEuNwogU1FMSVRFX1JFUVVJUkVEX1ZFUlNJT049My4wCiBHU1RSRUFNRVJfUkVRVUlS RURfVkVSU0lPTj0wLjEwCkBAIC02MjQsMjMgKzYwOSwxMSBAQCBlbHNlCiAgICBDRkxBR1M9IiRD RkxBR1MgLU8wIgogZmkKIAotIyBjaGVjayBpZiBjdXJsIGlzIGF2YWlsYWJsZQotaWYgdGVzdCAi JHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJjdXJsIjsgdGhlbgotICAgUEtHX0NIRUNLX01PRFVMRVMo W0xJQkNVUkxdLAotICAgICAgICAgICAgICAgICAgICAgW2xpYmN1cmwgPj0gJExJQkNVUkxfUkVR VUlSRURfVkVSU0lPTl0pCi0gICBpZiB0ZXN0ICIkb3Nfd2luMzIiID0gInllcyI7IHRoZW4KLSAg ICAgIExJQkNVUkxfTElCUz0iJExJQkNVUkxfTElCUyAtbHdzMl8zMiIKLSAgIGZpCi0gICBBQ19T VUJTVChbTElCQ1VSTF9DRkxBR1NdKQotICAgQUNfU1VCU1QoW0xJQkNVUkxfTElCU10pCi1maQog Ci1pZiB0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gInNvdXAiOyB0aGVuCi0gICBQS0dfQ0hF Q0tfTU9EVUxFUyhbTElCU09VUF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQg Pj0gJExJQlNPVVBfUkVRVUlSRURfVkVSU0lPTl0pCi0gICBBQ19TVUJTVChbTElCU09VUF9DRkxB R1NdKQotICAgQUNfU1VCU1QoW0xJQlNPVVBfTElCU10pCi1maQorUEtHX0NIRUNLX01PRFVMRVMo W0xJQlNPVVBdLAorICAgICAgICAgICAgICAgICAgW2xpYnNvdXAtMi40ID49ICRMSUJTT1VQX1JF UVVJUkVEX1ZFUlNJT05dKQorQUNfU1VCU1QoW0xJQlNPVVBfQ0ZMQUdTXSkKK0FDX1NVQlNUKFtM SUJTT1VQX0xJQlNdKQogCiAjIGNoZWNrIGlmIEZyZWVUeXBlL0ZvbnRDb25maWcgYXJlIGF2YWls YWJsZQogaWYgdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5kIiA9ICJmcmVldHlwZSI7IHRoZW4KQEAg LTcxMiwxMCArNjg1LDYgQEAgQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9XSU4zMl0sIFt0ZXN0ICIk d2l0aF90YXJnZXQiID0gIndpbjMyIl0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VUX1FVQVJUWl0s IFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gInF1YXJ0eiJdKQogQU1fQ09ORElUSU9OQUwoW1RBUkdF VF9ESVJFQ1RGQl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gImRpcmVjdGZiIl0pCiAKLSMgSFRU UCBiYWNrZW5kIGNvbmRpdGlvbmFscwotQU1fQ09ORElUSU9OQUwoW1VTRV9DVVJMXSwgW3Rlc3Qg IiR3aXRoX2h0dHBfYmFja2VuZCIgPSAiY3VybCJdKQotQU1fQ09ORElUSU9OQUwoW1VTRV9TT1VQ XSwgW3Rlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAic291cCJdKQotCiAjIEZvbnQgYmFja2Vu ZCBjb25kaXRpb25hbHMKIEFNX0NPTkRJVElPTkFMKFtVU0VfRlJFRVRZUEVdLCBbdGVzdCAiJHdp dGhfZm9udF9iYWNrZW5kIiA9ICJmcmVldHlwZSJdKQogQU1fQ09ORElUSU9OQUwoW1VTRV9QQU5H T10sIFt0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gInBhbmdvIl0pCkBAIC03NjIsNyArNzMx LDYgQEAgQnVpbGQgY29uZmlndXJhdGlvbjoKICBFbmFibGUgR0NDIGJ1aWxkIG9wdGltaXphdGlv biAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVfb3B0aW1pemF0aW9ucwogIENv ZGUgY292ZXJhZ2Ugc3VwcG9ydCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDog JGVuYWJsZV9jb3ZlcmFnZQogIFVuaWNvZGUgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIDogJHVuaWNvZGVfYmFja2VuZAotIEhUVFAgYmFja2VuZCAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJHdpdGhfaHR0cF9iYWNr ZW5kCiAgRm9udCBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgOiAkd2l0aF9mb250X2JhY2tlbmQKICBPcHRpbWl6ZWQgbWVtb3J5IGFsbG9jYXRvciAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVfZmFzdF9tYWxsb2MKIEZlYXR1 cmVzOgo= 27783 2009-02-19 02:52:29 -0800 2009-02-19 03:38:31 -0800 removecurl.patch removecurl.patch text/plain 9192 xan.lopez RnJvbSA1NjYwZDVkNWY3OTk2MzA4NWQ3ZWMxZjkzMDcyOTI1NzNmZjU2NGY5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFRodSwg MTkgRmViIDIwMDkgMTI6NTA6NDAgKzAyMDAKU3ViamVjdDogW1BBVENIXSAyMDA5LTAyLTE5ICBY YW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KCiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIy NjI0CiAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20g V2ViS2l0LgoKICAgICAgICBSZW1vdmUgQ1VSTCBzdXBwb3J0LCB0aGUgb25seSBzdXBwb3J0ZWQg SFRUUCBiYWNrZW5kIGlzIFNPVVAgbm93LgoKICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgogICAg ICAgICogY29uZmlndXJlLmFjOgotLS0KIENoYW5nZUxvZyAgICAgICAgICAgICAgICAgIHwgICAx MiArKysrKysrKysrKysKIEdOVW1ha2VmaWxlLmFtICAgICAgICAgICAgIHwgICAgNSArKy0tLQog V2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgfCAgIDEzICsrKysrKysrKysrKysKIFdlYkNvcmUv R05VbWFrZWZpbGUuYW0gICAgIHwgICAyNiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgfCAgIDExICsrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dl YmtpdC5wYy5pbiAgICB8ICAgIDIgKy0KIFdlYktpdFRvb2xzL0NoYW5nZUxvZyAgICAgIHwgICAx MSArKysrKysrKysrKwogV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0gfCAgICA2ICsrKystLQog Y29uZmlndXJlLmFjICAgICAgICAgICAgICAgfCAgIDQzICsrKysrLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIDkgZmlsZXMgY2hhbmdlZCwgNTkgaW5zZXJ0aW9ucygrKSwg NzAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4 IDYyNWQ0ZmIuLmMwMzgzY2QgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNSBAQAorMjAwOS0wMi0xOSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI2MjQKKyAgICAgICAgW1NPVVBdW0dU S10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgorCisgICAgICAgIFJl bW92ZSBDVVJMIHN1cHBvcnQsIHRoZSBvbmx5IHN1cHBvcnRlZCBIVFRQIGJhY2tlbmQgaXMgU09V UCBub3cuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBjb25maWd1cmUu YWM6CisKIDIwMDktMDItMTggIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvR05V bWFrZWZpbGUuYW0gYi9HTlVtYWtlZmlsZS5hbQppbmRleCAwOTQwZDI2Li5iMTBjZGYwIDEwMDY0 NAotLS0gYS9HTlVtYWtlZmlsZS5hbQorKysgYi9HTlVtYWtlZmlsZS5hbQpAQCAtMTc0LDcgKzE3 NCw2IEBAIGxpYldlYkNvcmVfbGFfQ0ZMQUdTID0gXAogCSQoUEFOR09fQ0ZMQUdTKSBcCiAJJChH VEtfQ0ZMQUdTKSBcCiAJJChYVF9DRkxBR1MpIFwKLQkkKExJQkNVUkxfQ0ZMQUdTKSBcCiAJJChM SUJTT1VQX0NGTEFHUykgXAogCSQoRlJFRVRZUEVfQ0ZMQUdTKSBcCiAJJChTUUxJVEUzX0NGTEFH UykgXApAQCAtMjAxLDcgKzIwMCw2IEBAIGxpYldlYkNvcmVfbGFfTElCQUREID0gXAogCSQoUEFO R09fTElCUykgXAogCSQoR1RLX0xJQlMpIFwKIAkkKFhUX0xJQlMpIFwKLQkkKExJQkNVUkxfTElC UykgXAogCSQoTElCU09VUF9MSUJTKSBcCiAJJChGUkVFVFlQRV9MSUJTKSBcCiAJJChVTklDT0RF X0xJQlMpIFwKQEAgLTQ4Myw3ICs0ODEsOCBAQCBQcm9ncmFtc19Vbml0VGVzdHNfQ0ZMQUdTID0g XAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTElCX0NGTEFHUykgXAotCSQoR1RL X0NGTEFHUykKKwkkKEdUS19DRkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCiAJbGlid2Via2l0LTEuMC5sYSBcCmRpZmYgLS1naXQgYS9X ZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDAxOTQ5NjEuLjFjMTRi MjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTYgQEAKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV0FSTklO RzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5l ZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKworICAgICAgICBSZW1vdmUg Q1VSTCBzdXBwb3J0LgorCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisKIDIwMDktMDItMTgg IERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBC cmFkeSBFaWRzb24uCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbQppbmRleCBiODRiOGFhLi41NjJhYjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTE3OTQs MzEgKzE3OTQsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0v aW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3JlL3BsYXRmb3Jt L3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAKLSMgLS0tLQot IyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJjb3JlX2NwcGZs YWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJs L1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVzb3Vy Y2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVzb3Vy Y2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVz b3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL1Jl c291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9SZXNvdXJj ZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NPVVAKIHdlYmNv cmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNkaXIpL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xODMyLDcgKzE4MDcsNiBAQCB3ZWJjb3JlX3Nv dXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxl U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVz dC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgK LWVuZGlmCiAKICMgLS0tCiAjIEZyZWV0eXBlIGZvbnQgYmFja2VuZApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAzYWQxYTQzLi41 OGJiMWVmIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5A Z25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAorICAgICAg ICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCisK KyAgICAgICAgQWRkIHNvdXAgZGVwZW5kZW5jeSB0byBwYyBmaWxlLgorCisgICAgICAgICogd2Vi a2l0LnBjLmluOgorCiAyMDA5LTAyLTE3ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgogCiAg ICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEFsZXhleSBQcm9za3VyeWFrb3YuCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCmluZGV4 IDBjZTZmNzEuLjg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCisr KyBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRlZGlyPUBp bmNsdWRlZGlyQAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQgZW5naW5l IGZvciBHVEsrCiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAorUmVxdWly ZXM6IGd0aystMi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtpdC0xLjAK IENmbGFnczogLUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCBjNmU5NDAwLi5iNzg2 ZTllIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBn bm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAg IFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKwor ICAgICAgICBBZGQgc291cCBmbGFncy9saWJzIG5vdyB0aGF0IGRlcGVuZGVuY3kgaXMgZXhwbGlj aXQuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKwogMjAwOS0wMi0xMyAgRXJpYyBTZWlk ZWwgIDxlcmljQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgQWxleGV5 IFByb3NrdXJ5YWtvdi4gCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBi L1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCmluZGV4IDI2MjAwYzguLjMyNzBjNTkgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1h a2VmaWxlLmFtCkBAIC02NywxMyArNjcsMTUgQEAgUHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfQ0ZM QUdTID0gXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xPQkFMREVQU19DRkxBR1MpIFwKIAkk KENBSVJPX0NGTEFHUykgXAotCSQoR1RLX0NGTEFHUykKKwkkKEdUS19DRkxBR1MpIFwKKwkkKExJ QlNPVVBfQ0ZMQUdTKQogCiBQcm9ncmFtc19EdW1wUmVuZGVyVHJlZV9MREFERCA9IFwKIAlsaWJ3 ZWJraXQtMS4wLmxhIFwKIAkkKEdMT0JBTERFUFNfTElCUykgXAogCSQoQ0FJUk9fTElCUykgXAot CSQoR1RLX0xJQlMpCisJJChHVEtfTElCUykgXAorCSQoTElCU09VUF9MSUJTKQogCiAjIFRlc3RO ZXRzY2FwZVBsdWdpbgogVGVzdE5ldHNjYXBlUGx1Z2luX2xpYnRlc3RuZXRzY2FwZXBsdWdpbl9s YV9DUFBGTEFHUyA9IFwKZGlmZiAtLWdpdCBhL2NvbmZpZ3VyZS5hYyBiL2NvbmZpZ3VyZS5hYwpp bmRleCAyODc3MWRmLi5mMTNkOWZhIDEwMDY0NAotLS0gYS9jb25maWd1cmUuYWMKKysrIGIvY29u ZmlndXJlLmFjCkBAIC0xNzUsMjAgKzE3NSw2IEBAIGlmIHRlc3QgIiR3aXRoX2hpbGRvbiIgPSAi eWVzIjsgdGhlbgogICAgIEFDX1NVQlNUKFtISUxET05fTElCU10pCiBmaQogCi0jIGRldGVybWlu ZSB0aGUgaHR0cCBiYWNrZW5kCi1BQ19NU0dfQ0hFQ0tJTkcoW3RoZSBIVFRQIGJhY2tlbmQgdG8g dXNlXSkKLUFDX0FSR19XSVRIKGh0dHBfYmFja2VuZCwKLSAgICAgICAgICAgIEFDX0hFTFBfU1RS SU5HKFstLXdpdGgtaHR0cC1iYWNrZW5kPUA8OkBjdXJsL3NvdXBAOj5AXSwKLSAgICAgICAgICAg ICAgICAgICAgICAgICAgIFtTZWxlY3QgSFRUUCBiYWNrZW5kIFtkZWZhdWx0PXNvdXBdXSksCi0g ICAgICAgICAgICBbXSxbd2l0aF9odHRwX2JhY2tlbmQ9InNvdXAiXSkKLQotY2FzZSAiJHdpdGhf aHR0cF9iYWNrZW5kIiBpbgotICAgICBjdXJsfHNvdXApIDs7Ci0gICAgICopIEFDX01TR19FUlJP UihbSW52YWxpZCBIVFRQIGJhY2tlbmQ6IG11c3QgYmUgY3VybCwgc291cC5dKSA7OwotZXNhYwot Ci1BQ19NU0dfUkVTVUxUKFskd2l0aF9odHRwX2JhY2tlbmRdKQotCiAjIG1pbmltdW0gYmFzZSBk ZXBlbmRlbmNpZXMKIENBSVJPX1JFUVVJUkVEX1ZFUlNJT049MS4yCiBGT05UQ09ORklHX1JFUVVJ UkVEX1ZFUlNJT049Mi40CkBAIC0yMDAsOCArMTg2LDcgQEAgUEFOR09fUkVRVUlSRURfVkVSU0lP Tj0xLjAKIEdUS19SRVFVSVJFRF9WRVJTSU9OPTIuOAogCiAjIG9wdGlvbmFsIG1vZHVsZXMKLUxJ QkNVUkxfUkVRVUlSRURfVkVSU0lPTj03LjE1Ci1MSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT049Mi4y MworTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OPTIuMjUuNAogTElCWFNMVF9SRVFVSVJFRF9WRVJT SU9OPTEuMS43CiBTUUxJVEVfUkVRVUlSRURfVkVSU0lPTj0zLjAKIEdTVFJFQU1FUl9SRVFVSVJF RF9WRVJTSU9OPTAuMTAKQEAgLTUxMSwyMyArNDk2LDEwIEBAIGVsc2UKICAgIENGTEFHUz0iJENG TEFHUyAtTzAiCiBmaQogCi0jIGNoZWNrIGlmIGN1cmwgaXMgYXZhaWxhYmxlCi1pZiB0ZXN0ICIk d2l0aF9odHRwX2JhY2tlbmQiID0gImN1cmwiOyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhb TElCQ1VSTF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGliY3VybCA+PSAkTElCQ1VSTF9SRVFV SVJFRF9WRVJTSU9OXSkKLSAgIGlmIHRlc3QgIiRvc193aW4zMiIgPSAieWVzIjsgdGhlbgotICAg ICAgTElCQ1VSTF9MSUJTPSIkTElCQ1VSTF9MSUJTIC1sd3MyXzMyIgotICAgZmkKLSAgIEFDX1NV QlNUKFtMSUJDVVJMX0NGTEFHU10pCi0gICBBQ19TVUJTVChbTElCQ1VSTF9MSUJTXSkKLWZpCi0K LWlmIHRlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAic291cCI7IHRoZW4KLSAgIFBLR19DSEVD S19NT0RVTEVTKFtMSUJTT1VQXSwKLSAgICAgICAgICAgICAgICAgICAgIFtsaWJzb3VwLTIuNCA+ PSAkTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OXSkKLSAgIEFDX1NVQlNUKFtMSUJTT1VQX0NGTEFH U10pCi0gICBBQ19TVUJTVChbTElCU09VUF9MSUJTXSkKLWZpCitQS0dfQ0hFQ0tfTU9EVUxFUyhb TElCU09VUF0sCisgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVR VUlSRURfVkVSU0lPTl0pCitBQ19TVUJTVChbTElCU09VUF9DRkxBR1NdKQorQUNfU1VCU1QoW0xJ QlNPVVBfTElCU10pCiAKICMgY2hlY2sgaWYgRnJlZVR5cGUvRm9udENvbmZpZyBhcmUgYXZhaWxh YmxlCiBpZiB0ZXN0ICIkd2l0aF9mb250X2JhY2tlbmQiID0gImZyZWV0eXBlIjsgdGhlbgpAQCAt NjA3LDEwICs1NzksNiBAQCBBTV9DT05ESVRJT05BTChbVEFSR0VUX1dJTjMyXSwgW3Rlc3QgIiR3 aXRoX3RhcmdldCIgPSAid2luMzIiXSkKIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfUVVBUlRaXSwg W3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAicXVhcnR6Il0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VU X0RJUkVDVEZCXSwgW3Rlc3QgIiR3aXRoX3RhcmdldCIgPSAiZGlyZWN0ZmIiXSkKIAotIyBIVFRQ IGJhY2tlbmQgY29uZGl0aW9uYWxzCi1BTV9DT05ESVRJT05BTChbVVNFX0NVUkxdLCBbdGVzdCAi JHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJjdXJsIl0pCi1BTV9DT05ESVRJT05BTChbVVNFX1NPVVBd LCBbdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5kIiA9ICJzb3VwIl0pCi0KICMgRm9udCBiYWNrZW5k IGNvbmRpdGlvbmFscwogQU1fQ09ORElUSU9OQUwoW1VTRV9GUkVFVFlQRV0sIFt0ZXN0ICIkd2l0 aF9mb250X2JhY2tlbmQiID0gImZyZWV0eXBlIl0pCiBBTV9DT05ESVRJT05BTChbVVNFX1BBTkdP XSwgW3Rlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAicGFuZ28iXSkKQEAgLTY1Nyw3ICs2MjUs NiBAQCBCdWlsZCBjb25maWd1cmF0aW9uOgogIEVuYWJsZSBHQ0MgYnVpbGQgb3B0aW1pemF0aW9u ICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9vcHRpbWl6YXRpb25zCiAgQ29k ZSBjb3ZlcmFnZSBzdXBwb3J0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAk ZW5hYmxlX2NvdmVyYWdlCiAgVW5pY29kZSBiYWNrZW5kICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgOiAkdW5pY29kZV9iYWNrZW5kCi0gSFRUUCBiYWNrZW5kICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9odHRwX2JhY2tl bmQKICBGb250IGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICA6ICR3aXRoX2ZvbnRfYmFja2VuZAogIE9wdGltaXplZCBtZW1vcnkgYWxsb2NhdG9yICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9mYXN0X21hbGxvYwogRmVhdHVy ZXM6Ci0tIAoxLjYuMQoK 27787 2009-02-19 03:38:31 -0800 2009-02-23 01:48:04 -0800 removecurl.patch removecurl.patch text/plain 9232 xan.lopez RnJvbSBhODVlZjQ1NGJmNjgxMmVlMDIxMWJiZDg3NWFmYzA0ZGMyZTE1MWJkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFRodSwg MTkgRmViIDIwMDkgMTI6NTA6NDAgKzAyMDAKU3ViamVjdDogW1BBVENIXSAyMDA5LTAyLTE5ICBY YW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KCiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIy NjI0CiAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20g V2ViS2l0LgoKICAgICAgICBSZW1vdmUgQ1VSTCBzdXBwb3J0LCB0aGUgb25seSBzdXBwb3J0ZWQg SFRUUCBiYWNrZW5kIGlzIFNPVVAgbm93LgoKICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgogICAg ICAgICogY29uZmlndXJlLmFjOgotLS0KIENoYW5nZUxvZyAgICAgICAgICAgICAgICAgIHwgICAx MiArKysrKysrKysrKysKIEdOVW1ha2VmaWxlLmFtICAgICAgICAgICAgIHwgICAgNSArKy0tLQog V2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgfCAgIDEzICsrKysrKysrKysrKysKIFdlYkNvcmUv R05VbWFrZWZpbGUuYW0gICAgIHwgICAyNiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgfCAgIDExICsrKysrKysrKysrCiBXZWJLaXQvZ3RrL3dl YmtpdC5wYy5pbiAgICB8ICAgIDIgKy0KIFdlYktpdFRvb2xzL0NoYW5nZUxvZyAgICAgIHwgICAx MSArKysrKysrKysrKwogV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0gfCAgICA2ICsrKystLQog Y29uZmlndXJlLmFjICAgICAgICAgICAgICAgfCAgIDQzICsrKysrLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIDkgZmlsZXMgY2hhbmdlZCwgNTkgaW5zZXJ0aW9ucygrKSwg NzAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4 IDYyNWQ0ZmIuLmMwMzgzY2QgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNSBAQAorMjAwOS0wMi0xOSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI2MjQKKyAgICAgICAgW1NPVVBdW0dU S10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgorCisgICAgICAgIFJl bW92ZSBDVVJMIHN1cHBvcnQsIHRoZSBvbmx5IHN1cHBvcnRlZCBIVFRQIGJhY2tlbmQgaXMgU09V UCBub3cuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBjb25maWd1cmUu YWM6CisKIDIwMDktMDItMTggIEd1c3Rhdm8gTm9yb25oYSBTaWx2YSAgPGduc0Bnbm9tZS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSG9sZ2VyIEZyZXl0aGVyLgpkaWZmIC0tZ2l0IGEvR05V bWFrZWZpbGUuYW0gYi9HTlVtYWtlZmlsZS5hbQppbmRleCAwOTQwZDI2Li5iMTBjZGYwIDEwMDY0 NAotLS0gYS9HTlVtYWtlZmlsZS5hbQorKysgYi9HTlVtYWtlZmlsZS5hbQpAQCAtMTc0LDcgKzE3 NCw2IEBAIGxpYldlYkNvcmVfbGFfQ0ZMQUdTID0gXAogCSQoUEFOR09fQ0ZMQUdTKSBcCiAJJChH VEtfQ0ZMQUdTKSBcCiAJJChYVF9DRkxBR1MpIFwKLQkkKExJQkNVUkxfQ0ZMQUdTKSBcCiAJJChM SUJTT1VQX0NGTEFHUykgXAogCSQoRlJFRVRZUEVfQ0ZMQUdTKSBcCiAJJChTUUxJVEUzX0NGTEFH UykgXApAQCAtMjAxLDcgKzIwMCw2IEBAIGxpYldlYkNvcmVfbGFfTElCQUREID0gXAogCSQoUEFO R09fTElCUykgXAogCSQoR1RLX0xJQlMpIFwKIAkkKFhUX0xJQlMpIFwKLQkkKExJQkNVUkxfTElC UykgXAogCSQoTElCU09VUF9MSUJTKSBcCiAJJChGUkVFVFlQRV9MSUJTKSBcCiAJJChVTklDT0RF X0xJQlMpIFwKQEAgLTQ4Myw3ICs0ODEsOCBAQCBQcm9ncmFtc19Vbml0VGVzdHNfQ0ZMQUdTID0g XAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCiAJJChHTElCX0NGTEFHUykgXAotCSQoR1RL X0NGTEFHUykKKwkkKEdUS19DRkxBR1MpIFwKKwkkKExJQlNPVVBfQ0ZMQUdTKQogCiBQcm9ncmFt c19Vbml0VGVzdHNfTERBREQgPSBcCiAJbGlid2Via2l0LTEuMC5sYSBcCmRpZmYgLS1naXQgYS9X ZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDAxOTQ5NjEuLjFjMTRi MjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTYgQEAKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV0FSTklO RzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFOR0VECisKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5l ZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKworICAgICAgICBSZW1vdmUg Q1VSTCBzdXBwb3J0LgorCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisKIDIwMDktMDItMTgg IERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBC cmFkeSBFaWRzb24uCmRpZmYgLS1naXQgYS9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtIGIvV2ViQ29y ZS9HTlVtYWtlZmlsZS5hbQppbmRleCBiODRiOGFhLi41NjJhYjU1IDEwMDY0NAotLS0gYS9XZWJD b3JlL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KQEAgLTE3OTQs MzEgKzE3OTQsNiBAQCB3ZWJjb3JlZ3RrX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0v aW1hZ2UtZGVjb2RlcnMveGJtL1hCTUltYWdlRGVjb2Rlci5oIFwKIAlXZWJDb3JlL3BsYXRmb3Jt L3RleHQvZ3RrL1RleHRCcmVha0l0ZXJhdG9ySW50ZXJuYWxJQ1VHdGsuY3BwCiAKLSMgLS0tLQot IyBjdXJsIGh0dHAgYmFja2VuZAotIyAtLS0tCi1pZiBVU0VfQ1VSTAotCi13ZWJjb3JlX2NwcGZs YWdzICs9IFwKLQktRFdURl9VU0VfQ1VSTD0xIFwKLQktSSQoc3JjZGlyKS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybAotCi13ZWJjb3JlX3NvdXJjZXMgKz0gXAotCVdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9jdXJsL0F1dGhlbnRpY2F0aW9uQ2hhbGxlbmdlLmggXAotCVdlYkNvcmUvcGxh dGZvcm0vbmV0d29yay9jdXJsL0Nvb2tpZUphckN1cmwuY3BwIFwKLQlXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvY3VybC9ETlNDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvRm9ybURhdGFTdHJlYW1DdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1 cmwvRm9ybURhdGFTdHJlYW1DdXJsLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJs L1Jlc291cmNlRXJyb3IuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVzb3Vy Y2VIYW5kbGVDdXJsLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVzb3Vy Y2VIYW5kbGVNYW5hZ2VyLmNwcCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvUmVz b3VyY2VIYW5kbGVNYW5hZ2VyLmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL1Jl c291cmNlUmVxdWVzdC5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9SZXNvdXJj ZVJlc3BvbnNlLmgKLQotZW5kaWYgIyBFTkQgVVNFX0NVUkwKLQotaWYgVVNFX1NPVVAKIHdlYmNv cmVfY3BwZmxhZ3MgKz0gXAogCS1EV1RGX1VTRV9TT1VQPTEgXAogCS1JJChzcmNkaXIpL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwCkBAIC0xODMyLDcgKzE4MDcsNiBAQCB3ZWJjb3JlX3Nv dXJjZXMgKz0gXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxl U291cC5jcHAgXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlUmVxdWVz dC5oIFwKIAlXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZVJlc3BvbnNlLmgK LWVuZGlmCiAKICMgLS0tCiAjIEZyZWV0eXBlIGZvbnQgYmFja2VuZApkaWZmIC0tZ2l0IGEvV2Vi S2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAzYWQxYTQzLi41 OGJiMWVmIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5A Z25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAorICAgICAg ICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCisK KyAgICAgICAgQWRkIHNvdXAgZGVwZW5kZW5jeSB0byBwYyBmaWxlLgorCisgICAgICAgICogd2Vi a2l0LnBjLmluOgorCiAyMDA5LTAyLTE3ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgogCiAg ICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEFsZXhleSBQcm9za3VyeWFrb3YuCmRpZmYgLS1naXQg YS9XZWJLaXQvZ3RrL3dlYmtpdC5wYy5pbiBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCmluZGV4 IDBjZTZmNzEuLjg0ZDYxMTUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCisr KyBiL1dlYktpdC9ndGsvd2Via2l0LnBjLmluCkBAIC02LDYgKzYsNiBAQCBpbmNsdWRlZGlyPUBp bmNsdWRlZGlyQAogTmFtZTogV2ViS2l0CiBEZXNjcmlwdGlvbjogV2ViIGNvbnRlbnQgZW5naW5l IGZvciBHVEsrCiBWZXJzaW9uOiBAVkVSU0lPTkAKLVJlcXVpcmVzOiBndGsrLTIuMAorUmVxdWly ZXM6IGd0aystMi4wIGxpYnNvdXAtMi40CiBMaWJzOiAtTCR7bGliZGlyfSAtbHdlYmtpdC0xLjAK IENmbGFnczogLUkke2luY2x1ZGVkaXJ9L3dlYmtpdC0xLjAKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwppbmRleCBjNmU5NDAwLi5iNzg2 ZTllIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBn bm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAg IFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKwor ICAgICAgICBBZGQgc291cCBmbGFncy9saWJzIG5vdyB0aGF0IGRlcGVuZGVuY3kgaXMgZXhwbGlj aXQuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKwogMjAwOS0wMi0xMyAgRXJpYyBTZWlk ZWwgIDxlcmljQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgQWxleGV5 IFByb3NrdXJ5YWtvdi4gCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbSBi L1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCmluZGV4IDI2MjAwYzguLjFjMWJlZTMgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtCisrKyBiL1dlYktpdFRvb2xzL0dOVW1h a2VmaWxlLmFtCkBAIC0yMCw3ICsyMCw4IEBAIFByb2dyYW1zX0d0a0xhdW5jaGVyX0NGTEFHUyA9 IFwKIAktZm5vLXN0cmljdC1hbGlhc2luZyBcCiAJLU8yIFwKIAkkKGdsb2JhbF9jZmxhZ3MpIFwK LQkkKEdUS19DRkxBR1MpCisJJChHVEtfQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykKIAog UHJvZ3JhbXNfR3RrTGF1bmNoZXJfTERBREQgPSBcCiAJbGlid2Via2l0LTEuMC5sYSBcCkBAIC02 Nyw3ICs2OCw4IEBAIFByb2dyYW1zX0R1bXBSZW5kZXJUcmVlX0NGTEFHUyA9IFwKIAkkKGdsb2Jh bF9jZmxhZ3MpIFwKIAkkKEdMT0JBTERFUFNfQ0ZMQUdTKSBcCiAJJChDQUlST19DRkxBR1MpIFwK LQkkKEdUS19DRkxBR1MpCisJJChHVEtfQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFHUykKIAog UHJvZ3JhbXNfRHVtcFJlbmRlclRyZWVfTERBREQgPSBcCiAJbGlid2Via2l0LTEuMC5sYSBcCmRp ZmYgLS1naXQgYS9jb25maWd1cmUuYWMgYi9jb25maWd1cmUuYWMKaW5kZXggMjg3NzFkZi4uZjEz ZDlmYSAxMDA2NDQKLS0tIGEvY29uZmlndXJlLmFjCisrKyBiL2NvbmZpZ3VyZS5hYwpAQCAtMTc1 LDIwICsxNzUsNiBAQCBpZiB0ZXN0ICIkd2l0aF9oaWxkb24iID0gInllcyI7IHRoZW4KICAgICBB Q19TVUJTVChbSElMRE9OX0xJQlNdKQogZmkKIAotIyBkZXRlcm1pbmUgdGhlIGh0dHAgYmFja2Vu ZAotQUNfTVNHX0NIRUNLSU5HKFt0aGUgSFRUUCBiYWNrZW5kIHRvIHVzZV0pCi1BQ19BUkdfV0lU SChodHRwX2JhY2tlbmQsCi0gICAgICAgICAgICBBQ19IRUxQX1NUUklORyhbLS13aXRoLWh0dHAt YmFja2VuZD1APDpAY3VybC9zb3VwQDo+QF0sCi0gICAgICAgICAgICAgICAgICAgICAgICAgICBb U2VsZWN0IEhUVFAgYmFja2VuZCBbZGVmYXVsdD1zb3VwXV0pLAotICAgICAgICAgICAgW10sW3dp dGhfaHR0cF9iYWNrZW5kPSJzb3VwIl0pCi0KLWNhc2UgIiR3aXRoX2h0dHBfYmFja2VuZCIgaW4K LSAgICAgY3VybHxzb3VwKSA7OwotICAgICAqKSBBQ19NU0dfRVJST1IoW0ludmFsaWQgSFRUUCBi YWNrZW5kOiBtdXN0IGJlIGN1cmwsIHNvdXAuXSkgOzsKLWVzYWMKLQotQUNfTVNHX1JFU1VMVChb JHdpdGhfaHR0cF9iYWNrZW5kXSkKLQogIyBtaW5pbXVtIGJhc2UgZGVwZW5kZW5jaWVzCiBDQUlS T19SRVFVSVJFRF9WRVJTSU9OPTEuMgogRk9OVENPTkZJR19SRVFVSVJFRF9WRVJTSU9OPTIuNApA QCAtMjAwLDggKzE4Niw3IEBAIFBBTkdPX1JFUVVJUkVEX1ZFUlNJT049MS4wCiBHVEtfUkVRVUlS RURfVkVSU0lPTj0yLjgKIAogIyBvcHRpb25hbCBtb2R1bGVzCi1MSUJDVVJMX1JFUVVJUkVEX1ZF UlNJT049Ny4xNQotTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OPTIuMjMKK0xJQlNPVVBfUkVRVUlS RURfVkVSU0lPTj0yLjI1LjQKIExJQlhTTFRfUkVRVUlSRURfVkVSU0lPTj0xLjEuNwogU1FMSVRF X1JFUVVJUkVEX1ZFUlNJT049My4wCiBHU1RSRUFNRVJfUkVRVUlSRURfVkVSU0lPTj0wLjEwCkBA IC01MTEsMjMgKzQ5NiwxMCBAQCBlbHNlCiAgICBDRkxBR1M9IiRDRkxBR1MgLU8wIgogZmkKIAot IyBjaGVjayBpZiBjdXJsIGlzIGF2YWlsYWJsZQotaWYgdGVzdCAiJHdpdGhfaHR0cF9iYWNrZW5k IiA9ICJjdXJsIjsgdGhlbgotICAgUEtHX0NIRUNLX01PRFVMRVMoW0xJQkNVUkxdLAotICAgICAg ICAgICAgICAgICAgICAgW2xpYmN1cmwgPj0gJExJQkNVUkxfUkVRVUlSRURfVkVSU0lPTl0pCi0g ICBpZiB0ZXN0ICIkb3Nfd2luMzIiID0gInllcyI7IHRoZW4KLSAgICAgIExJQkNVUkxfTElCUz0i JExJQkNVUkxfTElCUyAtbHdzMl8zMiIKLSAgIGZpCi0gICBBQ19TVUJTVChbTElCQ1VSTF9DRkxB R1NdKQotICAgQUNfU1VCU1QoW0xJQkNVUkxfTElCU10pCi1maQotCi1pZiB0ZXN0ICIkd2l0aF9o dHRwX2JhY2tlbmQiID0gInNvdXAiOyB0aGVuCi0gICBQS0dfQ0hFQ0tfTU9EVUxFUyhbTElCU09V UF0sCi0gICAgICAgICAgICAgICAgICAgICBbbGlic291cC0yLjQgPj0gJExJQlNPVVBfUkVRVUlS RURfVkVSU0lPTl0pCi0gICBBQ19TVUJTVChbTElCU09VUF9DRkxBR1NdKQotICAgQUNfU1VCU1Qo W0xJQlNPVVBfTElCU10pCi1maQorUEtHX0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAorICAgICAg ICAgICAgICAgICAgW2xpYnNvdXAtMi40ID49ICRMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJT05dKQor QUNfU1VCU1QoW0xJQlNPVVBfQ0ZMQUdTXSkKK0FDX1NVQlNUKFtMSUJTT1VQX0xJQlNdKQogCiAj IGNoZWNrIGlmIEZyZWVUeXBlL0ZvbnRDb25maWcgYXJlIGF2YWlsYWJsZQogaWYgdGVzdCAiJHdp dGhfZm9udF9iYWNrZW5kIiA9ICJmcmVldHlwZSI7IHRoZW4KQEAgLTYwNywxMCArNTc5LDYgQEAg QU1fQ09ORElUSU9OQUwoW1RBUkdFVF9XSU4zMl0sIFt0ZXN0ICIkd2l0aF90YXJnZXQiID0gIndp bjMyIl0pCiBBTV9DT05ESVRJT05BTChbVEFSR0VUX1FVQVJUWl0sIFt0ZXN0ICIkd2l0aF90YXJn ZXQiID0gInF1YXJ0eiJdKQogQU1fQ09ORElUSU9OQUwoW1RBUkdFVF9ESVJFQ1RGQl0sIFt0ZXN0 ICIkd2l0aF90YXJnZXQiID0gImRpcmVjdGZiIl0pCiAKLSMgSFRUUCBiYWNrZW5kIGNvbmRpdGlv bmFscwotQU1fQ09ORElUSU9OQUwoW1VTRV9DVVJMXSwgW3Rlc3QgIiR3aXRoX2h0dHBfYmFja2Vu ZCIgPSAiY3VybCJdKQotQU1fQ09ORElUSU9OQUwoW1VTRV9TT1VQXSwgW3Rlc3QgIiR3aXRoX2h0 dHBfYmFja2VuZCIgPSAic291cCJdKQotCiAjIEZvbnQgYmFja2VuZCBjb25kaXRpb25hbHMKIEFN X0NPTkRJVElPTkFMKFtVU0VfRlJFRVRZUEVdLCBbdGVzdCAiJHdpdGhfZm9udF9iYWNrZW5kIiA9 ICJmcmVldHlwZSJdKQogQU1fQ09ORElUSU9OQUwoW1VTRV9QQU5HT10sIFt0ZXN0ICIkd2l0aF9m b250X2JhY2tlbmQiID0gInBhbmdvIl0pCkBAIC02NTcsNyArNjI1LDYgQEAgQnVpbGQgY29uZmln dXJhdGlvbjoKICBFbmFibGUgR0NDIGJ1aWxkIG9wdGltaXphdGlvbiAgICAgICAgICAgICAgICAg ICAgICAgICAgICA6ICRlbmFibGVfb3B0aW1pemF0aW9ucwogIENvZGUgY292ZXJhZ2Ugc3VwcG9y dCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJGVuYWJsZV9jb3ZlcmFnZQog IFVuaWNvZGUgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDogJHVuaWNvZGVfYmFja2VuZAotIEhUVFAgYmFja2VuZCAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIDogJHdpdGhfaHR0cF9iYWNrZW5kCiAgRm9udCBiYWNrZW5k ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOiAkd2l0aF9mb250 X2JhY2tlbmQKICBPcHRpbWl6ZWQgbWVtb3J5IGFsbG9jYXRvciAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICA6ICRlbmFibGVfZmFzdF9tYWxsb2MKIEZlYXR1cmVzOgotLSAKMS42LjEKCg== 27788 2009-02-19 03:44:54 -0800 2009-02-19 06:38:38 -0800 getsession.patch getsession.patch text/plain 12914 xan.lopez RnJvbSAxMGRlMWFhZDIzMGYxYTdmYzdlYWI5ZjQ1MTY5MThlZjJhZDFkZWIyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFRodSwg MTkgRmViIDIwMDkgMTM6NDM6MjUgKzAyMDAKU3ViamVjdDogW1BBVENIXSBXZWJDb3JlOgoKMjAw OS0wMi0xOSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgogICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQgT1Ig Q0hBTkdFRAoKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjI2MjQKICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJv bSBXZWJLaXQuCgogICAgICAgIEFsbG93IHRvIHJldHJpZXZlIHRoZSBTb3VwIHNlc3Npb24gYW5k IG1vZGlmeSB0aGUgY29kZSB0byB0YWtlCiAgICAgICAgaW50byBhY2NvdW50IHVzZXJzIGNoYW5n aW5nIGZlYXR1cmVzIG9uIGl0LgoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGUuaDoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNw cDoKICAgICAgICAoV2ViQ29yZTo6Z2V0Q29va2llSmFyKToKICAgICAgICAoV2ViQ29yZTo6c2V0 Q29va2llSmFyKToKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3Vw Lmg6CiAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNw cDoKICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlU291cFNlc3Npb24pOgogICAgICAgIChXZWJDb3Jl OjplbnN1cmVTZXNzaW9uKToKICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0 SHR0cCk6CiAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpnZXRTZXNzaW9uKToKCldl YktpdC9ndGs6CgoyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgoKICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CiAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBBUEkg dG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgoKICAgICAgICBBZGQgQVBJIHRvIGdldCB0 aGUgZGVmYXVsdCBzb3VwIHNlc3Npb24uCgogICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcu Y3BwOgogICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuaDoKLS0tCiBXZWJDb3JlL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjMgKysrKysrKysrCiBX ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCAgICAgICAgICB8ICAgIDgg KysrCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcCAgICB8 ICAgMjAgKysrKysrKy0KIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNv dXAuaCAgICAgIHwgICAgMSArCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAgICB8ICAgNTEgKysrKysrKysrKysrKysrLS0tLS0KIFdlYktpdC9ndGsvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMiArKysrKwogV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAgICAgICAgICAgICAgfCAgIDQwICsrKysr KysrKysrKysrKy0KIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaCAgICAgICAgICAg ICAgICAgIHwgICAgNCArKwogOCBmaWxlcyBjaGFuZ2VkLCAxNDMgaW5zZXJ0aW9ucygrKSwgMTYg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAxYzE0YjIyLi42N2Y3MjU4IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtNyw2ICs3LDI5IEBACiAgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAogICAgICAgICBbU09V UF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCiAKKyAgICAg ICAgQWxsb3cgdG8gcmV0cmlldmUgdGhlIFNvdXAgc2Vzc2lvbiBhbmQgbW9kaWZ5IHRoZSBjb2Rl IHRvIHRha2UKKyAgICAgICAgaW50byBhY2NvdW50IHVzZXJzIGNoYW5naW5nIGZlYXR1cmVzIG9u IGl0LgorCisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oOgorICAg ICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OmdldENvb2tpZUphcik6CisgICAgICAgIChXZWJDb3JlOjpzZXRDb29raWVKYXIp OgorICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmg6CisgICAg ICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpjcmVhdGVTb3VwU2Vzc2lvbik6CisgICAgICAgIChXZWJDb3JlOjplbnN1 cmVTZXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAp OgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OmdldFNlc3Npb24pOgorCisyMDA5 LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQg T1IgQ0hBTkdFRAorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMjYyNAorICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Np b24gZnJvbSBXZWJLaXQuCisKICAgICAgICAgUmVtb3ZlIENVUkwgc3VwcG9ydC4KIAogICAgICAg ICAqIEdOVW1ha2VmaWxlLmFtOgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L1Jlc291cmNlSGFuZGxlLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5k bGUuaAppbmRleCBlZTkzN2YxLi4zNGFkMjhjIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv UmVzb3VyY2VIYW5kbGUuaApAQCAtMzAsNiArMzAsMTAgQEAKICNpbmNsdWRlICJIVFRQSGVhZGVy TWFwLmgiCiAjaW5jbHVkZSA8d3RmL093blB0ci5oPgogCisjaWYgVVNFKFNPVVApCisjaW5jbHVk ZSA8bGlic291cC9zb3VwLmg+CisjZW5kaWYKKwogI2lmIFBMQVRGT1JNKENGKQogdHlwZWRlZiBj b25zdCBzdHJ1Y3QgX19DRkRhdGEgKiBDRkRhdGFSZWY7CiAjZW5kaWYKQEAgLTE1OSw2ICsxNjMs MTAgQEAgcHVibGljOgogICAgIFJlc291cmNlSGFuZGxlSW50ZXJuYWwqIGdldEludGVybmFsKCkg eyByZXR1cm4gZC5nZXQoKTsgfQogI2VuZGlmCiAKKyNpZiBVU0UoU09VUCkKKyAgICBzdGF0aWMg U291cFNlc3Npb24qIGdldFNlc3Npb24oKTsKKyNlbmRpZgorCiAgICAgLy8gVXNlZCB0byB3b3Jr IGFyb3VuZCB0aGUgZmFjdCB0aGF0IHlvdSBkb24ndCBnZXQgYW55IG1vcmUgTlNVUkxDb25uZWN0 aW9uIGNhbGxiYWNrcyB1bnRpbCB5b3UgcmV0dXJuIGZyb20gdGhlIG9uZSB5b3UncmUgaW4uCiAg ICAgc3RhdGljIGJvb2wgbG9hZHNCbG9ja2VkKCk7ICAgIAogICAgIApkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHAgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRleCA4ODEwOWU4Li4xNmI3 ZmViIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJT b3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3Vw LmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4IFhhbiBMb3Bl eiA8eGFuQGdub21lLm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDkgSWdhbGlhIFMuTC4sIEF1 dGhvcjogWGFuIExvcGV6IDx4bG9wZXpAaWdhbGlhLmNvbT4KICAqICBDb3B5cmlnaHQgKEMpIDIw MDggQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgogICoKICAqICBUaGlzIGxpYnJhcnkg aXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0yNSwx MCArMjYsMjUgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCitzdGF0aWMgU291cENvb2tpZUph ciogY29va2llSmFyOworCiBTb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIoKQogewotICAgIHN0 YXRpYyBTb3VwQ29va2llSmFyKiBqYXIgPSBzb3VwX2Nvb2tpZV9qYXJfbmV3KCk7Ci0gICAgcmV0 dXJuIGphcjsKKyAgICBpZiAoIWNvb2tpZUphcikKKyAgICAgICAgY29va2llSmFyID0gc291cF9j b29raWVfamFyX25ldygpOworCisgICAgcmV0dXJuIGNvb2tpZUphcjsKK30KKwordm9pZCBzZXRD b29raWVKYXIoU291cENvb2tpZUphciogamFyKQoreworICAgIGlmIChjb29raWVKYXIpCisgICAg ICAgIGdfb2JqZWN0X3VucmVmKGNvb2tpZUphcik7CisKKyAgICBjb29raWVKYXIgPSBqYXI7CisK KyAgICBpZiAoY29va2llSmFyKQorICAgICAgICBnX29iamVjdF9yZWYoY29va2llSmFyKTsKIH0K IAogdm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVy bCwgY29uc3QgS1VSTCYgLypwb2xpY3lVUkwqLywgY29uc3QgU3RyaW5nJiB2YWx1ZSkKZGlmZiAt LWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaCBiL1dl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaAppbmRleCA2MTE3OWFl Li5iNjU4OGQxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29r aWVKYXJTb3VwLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFy U291cC5oCkBAIC0zMiw2ICszMiw3IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAgICBTb3Vw Q29va2llSmFyKiBnZXRDb29raWVKYXIoKTsKKyAgICB2b2lkIHNldENvb2tpZUphcihTb3VwQ29v a2llSmFyKiBqYXIpOwogfQogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDk1YzgzODUuLjFiYTE4NzAg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxl U291cC5jcHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5k bGVTb3VwLmNwcApAQCAtNCw2ICs0LDggQEAKICAqIENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJv cmEgTHRkLgogICogQ29weXJpZ2h0IChDKSAyMDA5IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVy CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhIDxnbnNAZ25vbWUu b3JnPgorICogQ29weXJpZ2h0IChDKSAyMDA5IENocmlzdGlhbiBEeXdhbiA8Y2hyaXN0aWFuQGlt ZW5kaW8uY29tPgorICogQ29weXJpZ2h0IChDKSAyMDA5IElnYWxpYSBTLkwuLCBBdXRob3I6IFhh biBMb3BleiA8eGxvcGV6QGlnYWxpYS5jb20+CiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTU1LDcg KzU3LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1zdGF0aWMgU291cFNlc3Npb24qIHNl c3Npb24gPSAwOworc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9uOwogCiBjbGFzcyBXZWJDb3Jl U3luY2hyb25vdXNMb2FkZXIgOiBwdWJsaWMgUmVzb3VyY2VIYW5kbGVDbGllbnQsIE5vbmNvcHlh YmxlIHsKIHB1YmxpYzoKQEAgLTM2NSwyMiArMzY3LDM5IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6 OnN0YXJ0RGF0YShTdHJpbmcgdXJsU3RyaW5nKQogICAgIHJldHVybiB0cnVlOwogfQogCi1ib29s IFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAoU3RyaW5nIHVybFN0cmluZykKK3N0YXRpYyB2b2lk IGNyZWF0ZVNvdXBTZXNzaW9uKCkKIHsKLSAgICBpZiAoIXNlc3Npb24pIHsKLSAgICAgICAgc2Vz c2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKKyAgICBzZXNzaW9uID0gc291cF9zZXNz aW9uX2FzeW5jX25ldygpOworfQogCitzdGF0aWMgdm9pZCBlbnN1cmVTZXNzaW9uKFNvdXBTZXNz aW9uKiBzZXNzaW9uKQoreworICAgIGlmIChnX29iamVjdF9nZXRfZGF0YShHX09CSkVDVChzZXNz aW9uKSwgIndlYmtpdC1pbml0IikpCisgICAgICAgIHJldHVybjsKKyAKKyAgICBTb3VwQ29va2ll SmFyKiBqYXIgPSByZWludGVycHJldF9jYXN0PFNvdXBDb29raWVKYXIqPihzb3VwX3Nlc3Npb25f Z2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0NPT0tJRV9KQVIpKTsKKyAgICBpZiAoIWph cikKICAgICAgICAgc291cF9zZXNzaW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfU0VTU0lP Tl9GRUFUVVJFKGdldENvb2tpZUphcigpKSk7CisgICAgZWxzZQorICAgICAgICBzZXRDb29raWVK YXIoamFyKTsKKworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJL SVRfREVCVUciKTsgCisgICAgaWYgKHNvdXBfc2Vzc2lvbl9nZXRfZmVhdHVyZShzZXNzaW9uLCBT T1VQX1RZUEVfTE9HR0VSKSA9PSBOVUxMCisgICAgICAgICYmIHdlYmtpdF9kZWJ1ZyAmJiAhc3Ry Y21wKHdlYmtpdF9kZWJ1ZywgIm5ldHdvcmsiKSkgeworICAgICAgICBTb3VwTG9nZ2VyKiBsb2dn ZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291cExvZ2dlckxvZ0xldmVsPihTT1VQ X0xPR0dFUl9MT0dfQk9EWSksIC0xKTsKKyAgICAgICAgc291cF9sb2dnZXJfYXR0YWNoKGxvZ2dl ciwgc2Vzc2lvbik7CisgICAgICAgIGdfb2JqZWN0X3VucmVmKGxvZ2dlcik7CisgICAgfQorIAor ICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKHNlc3Npb24pLCAid2Via2l0LWluaXQiLCBy ZWludGVycHJldF9jYXN0PHZvaWQqPigweGRlYWRiZWVmKSk7Cit9CiAKLSAgICAgICAgY29uc3Qg Y2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfU09VUF9MT0dHSU5HIik7Ci0gICAg ICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0gICAgICAgICAgICBpbnQgc291cF9kZWJ1Z19sZXZlbCA9 IGF0b2koc291cF9kZWJ1Zyk7Citib29sIFJlc291cmNlSGFuZGxlOjpzdGFydEh0dHAoU3RyaW5n IHVybFN0cmluZykKK3sKKyAgICBpZiAoIXNlc3Npb24pCisgICAgICAgIGNyZWF0ZVNvdXBTZXNz aW9uKCk7CiAKLSAgICAgICAgICAgIFNvdXBMb2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25l dyhzdGF0aWNfY2FzdDxTb3VwTG9nZ2VyTG9nTGV2ZWw+KHNvdXBfZGVidWdfbGV2ZWwpLCAtMSk7 Ci0gICAgICAgICAgICBzb3VwX2xvZ2dlcl9hdHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKLSAgICAg ICAgICAgIGdfb2JqZWN0X3VucmVmKGxvZ2dlcik7Ci0gICAgICAgIH0KLSAgICB9CisgICAgZW5z dXJlU2Vzc2lvbihzZXNzaW9uKTsKIAogICAgIFNvdXBNZXNzYWdlKiBtc2c7CiAgICAgbXNnID0g c291cF9tZXNzYWdlX25ldyhyZXF1ZXN0KCkuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVy bFN0cmluZy51dGY4KCkuZGF0YSgpKTsKQEAgLTc2MSw1ICs3ODAsMTMgQEAgYm9vbCBSZXNvdXJj ZUhhbmRsZTo6c3RhcnRHaW8oS1VSTCB1cmwpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKK1NvdXBT ZXNzaW9uKiBSZXNvdXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbigpCit7CisgICAgaWYgKCFzZXNzaW9u KQorICAgICAgICBjcmVhdGVTb3VwU2Vzc2lvbigpOworCisgICAgcmV0dXJuIHNlc3Npb247Cit9 CisKIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0No YW5nZUxvZwppbmRleCA1OGJiMWVmLi42YjBjZjg1IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0No YW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtNSw2ICs1LDE4IEBACiAgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAogICAgICAg ICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCiAK KyAgICAgICAgQWRkIEFQSSB0byBnZXQgdGhlIGRlZmF1bHQgc291cCBzZXNzaW9uLgorCisgICAg ICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3 ZWJ2aWV3Lmg6CisKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5l ZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKwogICAgICAgICBBZGQgc291 cCBkZXBlbmRlbmN5IHRvIHBjIGZpbGUuCiAKICAgICAgICAgKiB3ZWJraXQucGMuaW46CmRpZmYg LS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDQ5NGEyNmYuLmE0N2I5NDggMTAwNjQ0Ci0t LSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0xLDEyICsxLDEzIEBACiAvKgogICogIENvcHly aWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgotICogIENvcHly aWdodCAoQykgMjAwNywgMjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNv bT4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlh bkBpbWVuZGlvLmNvbT4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDcgWGFuIExvcGV6IDx4YW5AZ25v bWUub3JnPgogICogIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBBbHAgVG9rZXIgPGFscEBhdG9r ZXIuY29tPgogICogIENvcHlyaWdodCAoQykgMjAwOCBKYW4gQWxvbnpvIDxqbWFsb256b0B1bnBs dWdnYWJsZS5jb20+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4IEd1c3Rhdm8gTm9yb25oYSBTaWx2 YSA8Z25zQGdub21lLm9yZz4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDggTnVhbnRpIEx0ZC4KICAq ICBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4KKyAqICBDb3B5cmlnaHQgKEMpIDIw MDkgSWdhbGlhIFMuTC4sIEF1dGhvcjogWGFuIExvcGV6IDx4bG9wZXpAaWdhbGlhLmNvbT4KICAq CiAgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgogICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNz ZXIgR2VuZXJhbCBQdWJsaWMKQEAgLTU2LDEwICs1NywxMCBAQAogI2luY2x1ZGUgIkluc3BlY3Rv ckNsaWVudEd0ay5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCiAjaW5jbHVkZSAiRnJhbWVW aWV3LmgiCi0jaW5jbHVkZSAiRWRpdG9yLmgiCiAjaW5jbHVkZSAiUGFzdGVib2FyZEhlbHBlci5o IgogI2luY2x1ZGUgIlBsYXRmb3JtS2V5Ym9hcmRFdmVudC5oIgogI2luY2x1ZGUgIlBsYXRmb3Jt V2hlZWxFdmVudC5oIgorI2luY2x1ZGUgIlJlc291cmNlSGFuZGxlLmgiCiAjaW5jbHVkZSAiU2Ny aXB0VmFsdWUuaCIKICNpbmNsdWRlICJTY3JvbGxiYXIuaCIKICNpbmNsdWRlIDx3dGYvR093blB0 ci5oPgpAQCAtMTQ2LDYgKzE0Nyw3IEBAIGVudW0gewogICAgIFBST1BfV0lORE9XX0ZFQVRVUkVT LAogICAgIFBST1BfVFJBTlNQQVJFTlQsCiAgICAgUFJPUF9aT09NX0xFVkVMLAorICAgIFBST1Bf U0VTU0lPTiwKICAgICBQUk9QX0ZVTExfQ09OVEVOVF9aT09NCiB9OwogCkBAIC0zMDQsNiArMzA2 LDkgQEAgc3RhdGljIHZvaWQgd2Via2l0X3dlYl92aWV3X2dldF9wcm9wZXJ0eShHT2JqZWN0KiBv YmplY3QsIGd1aW50IHByb3BfaWQsIEdWYWx1ZSoKICAgICBjYXNlIFBST1BfRlVMTF9DT05URU5U X1pPT006CiAgICAgICAgIGdfdmFsdWVfc2V0X2Jvb2xlYW4odmFsdWUsIHdlYmtpdF93ZWJfdmll d19nZXRfZnVsbF9jb250ZW50X3pvb20od2ViVmlldykpOwogICAgICAgICBicmVhazsKKyAgICBj YXNlIFBST1BfU0VTU0lPTjoKKyAgICAgICAgZ192YWx1ZV9zZXRfb2JqZWN0KHZhbHVlLCB3ZWJr aXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbigpKTsKKyAgICAgICAgYnJlYWs7CiAgICAgZGVmYXVsdDoK ICAgICAgICAgR19PQkpFQ1RfV0FSTl9JTlZBTElEX1BST1BFUlRZX0lEKG9iamVjdCwgcHJvcF9p ZCwgcHNwZWMpOwogICAgIH0KQEAgLTE1NjksNiArMTU3NCwyMCBAQCBzdGF0aWMgdm9pZCB3ZWJr aXRfd2ViX3ZpZXdfY2xhc3NfaW5pdChXZWJLaXRXZWJWaWV3Q2xhc3MqIHdlYlZpZXdDbGFzcykK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IEZBTFNFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgV0VCS0lUX1BBUkFNX1JFQURXUklURSkpOwogCisgICAgLyoqCisgICAgKiBXZWJL aXRXZWJWaWV3OnNlc3Npb246CisgICAgKgorICAgICogUmV0cmlldmVzIHRoZSBzZXNzaW9uIG9m IHRoZSB2aWV3LgorICAgICoKKyAgICAqIFNpbmNlOiAxLjEuMQorICAgICovCisgICAgZ19vYmpl Y3RfY2xhc3NfaW5zdGFsbF9wcm9wZXJ0eShvYmplY3RDbGFzcywgUFJPUF9TRVNTSU9OLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ19wYXJhbV9zcGVjX29iamVjdCgic2Vz c2lvbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJTZXNzaW9uIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIlJldHJpZXZlcyB0aGUgc2Vzc2lvbiBvZiB0aGUgdmlldyIsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFNP VVBfVFlQRV9TRVNTSU9OLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBXRUJLSVRfUEFSQU1fUkVBREFCTEUpKTsKKwogICAgIGdfdHlwZV9j bGFzc19hZGRfcHJpdmF0ZSh3ZWJWaWV3Q2xhc3MsIHNpemVvZihXZWJLaXRXZWJWaWV3UHJpdmF0 ZSkpOwogfQogCkBAIC0yNzM4LDQgKzI3NTcsMjEgQEAgdm9pZCB3ZWJraXRfd2ViX3ZpZXdfc2V0 X2Z1bGxfY29udGVudF96b29tKFdlYktpdFdlYlZpZXcqIHdlYlZpZXcsIGdib29sZWFuIHpvb20K ICAgICBnX29iamVjdF9ub3RpZnkoR19PQkpFQ1Qod2ViVmlldyksICJmdWxsLWNvbnRlbnQtem9v bSIpOwogfQogCisvKioKKyAqIHdlYmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uOgorICoKKyAqIFJl dHJpZXZlcyB0aGUgZGVmYXVsdCAjU291cFNlc3Npb24gdXNlZCBieSBhbGwgd2ViIHZpZXdzLgor ICogTm90ZSB0aGF0IHRoZSBzZXNzaW9uIGZlYXR1cmVzIGFyZSBhZGRlZCBieSBXZWJLaXQgb24g ZGVtYW5kLAorICogc28gaWYgeW91IGluc2VydCBmb3IgeW91ciBvd24gI1NvdXBDb29raWVKYXIg YmVmb3JlIGFueSBuZXR3b3JrCisgKiB0cmFmZmljIG9jY3VycywgV2ViS2l0IHdpbGwgdXNlIGl0 IGluc3RlYWQgb2YgdGhlIGRlZmF1bHQuCisgKgorICogUmV0dXJuIHZhbHVlOiB0aGUgZGVmYXVs dCAjU291cFNlc3Npb24KKyAqCisgKiBTaW5jZTogMS4xLjEKKyAqLworU291cFNlc3Npb24qIHdl YmtpdF9nZXRfZGVmYXVsdF9zZXNzaW9uICgpCit7CisgICAgcmV0dXJuIFJlc291cmNlSGFuZGxl OjpnZXRTZXNzaW9uKCk7Cit9CisKIH0KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0L3dl YmtpdHdlYnZpZXcuaCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaAppbmRleCA4 NjBjMGQwLi40Y2MzNTY5IDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2 aWV3LmgKKysrIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCkBAIC0yMyw2ICsy Myw3IEBACiAjZGVmaW5lIFdFQktJVF9XRUJfVklFV19ICiAKICNpbmNsdWRlIDxndGsvZ3RrLmg+ CisjaW5jbHVkZSA8bGlic291cC9zb3VwLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNC YXNlLmg+CiAKICNpbmNsdWRlIDx3ZWJraXQvd2Via2l0ZGVmaW5lcy5oPgpAQCAtMzA0LDYgKzMw NSw5IEBAIFdFQktJVF9BUEkgdm9pZAogd2Via2l0X3dlYl92aWV3X3NldF9mdWxsX2NvbnRlbnRf em9vbSAgICAgICAgICAgKFdlYktpdFdlYlZpZXcgICAgICAgICp3ZWJfdmlldywKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnYm9vbGVhbiAgICAgICAg ICAgICAgZnVsbF9jb250ZW50X3pvb20pOwogCitXRUJLSVRfQVBJIFNvdXBTZXNzaW9uKgord2Vi a2l0X2dldF9kZWZhdWx0X3Nlc3Npb24gICAgICAgICAgICAgICAgICAgICAgKHZvaWQpOworCiBH X0VORF9ERUNMUwogCiAjZW5kaWYKLS0gCjEuNi4xCgo= 27790 2009-02-19 06:38:38 -0800 2009-02-23 01:48:31 -0800 getsession.patch getsession.patch text/plain 11418 xan.lopez RnJvbSBlYTYxNzQ1MjkxZjZkNmVmZDkyMjZhMjk0ODYyNTE4ZDk5MmE4ZWU0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFRodSwg MTkgRmViIDIwMDkgMTM6NDM6MjUgKzAyMDAKU3ViamVjdDogW1BBVENIXSBXZWJDb3JlOgoKMjAw OS0wMi0xOSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgogICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQgT1Ig Q0hBTkdFRAoKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjI2MjQKICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJv bSBXZWJLaXQuCgogICAgICAgIEFsbG93IHRvIHJldHJpZXZlIHRoZSBTb3VwIHNlc3Npb24gYW5k IG1vZGlmeSB0aGUgY29kZSB0byB0YWtlCiAgICAgICAgaW50byBhY2NvdW50IHVzZXJzIGNoYW5n aW5nIGZlYXR1cmVzIG9uIGl0LgoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VI YW5kbGUuaDoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNw cDoKICAgICAgICAoV2ViQ29yZTo6Z2V0Q29va2llSmFyKToKICAgICAgICAoV2ViQ29yZTo6c2V0 Q29va2llSmFyKToKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3Vw Lmg6CiAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNw cDoKICAgICAgICAoV2ViQ29yZTo6Y3JlYXRlU291cFNlc3Npb24pOgogICAgICAgIChXZWJDb3Jl OjplbnN1cmVTZXNzaW9uKToKICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0 SHR0cCk6CiAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpnZXRTZXNzaW9uKToKCldl YktpdC9ndGs6CgoyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgoKICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CiAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBBUEkg dG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgoKICAgICAgICBBZGQgQVBJIHRvIGdldCB0 aGUgZGVmYXVsdCBzb3VwIHNlc3Npb24uCgogICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcu Y3BwOgogICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuaDoKLS0tCiBXZWJDb3JlL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjMgKysrKysrKysrCiBX ZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaCAgICAgICAgICB8ICAgIDgg KysrCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcCAgICB8 ICAgMjAgKysrKysrKy0KIFdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNv dXAuaCAgICAgIHwgICAgMSArCiAuLi4vcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFu ZGxlU291cC5jcHAgICB8ICAgNTEgKysrKysrKysrKysrKysrLS0tLS0KIFdlYktpdC9ndGsvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxMiArKysrKwogV2ViS2l0 L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgICAgICAgICAgICAgICAgfCAgIDIyICsrKysr KysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oICAgICAgICAgICAgICAgICAg fCAgICA0ICsrCiA4IGZpbGVzIGNoYW5nZWQsIDEyNSBpbnNlcnRpb25zKCspLCAxNiBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9n CmluZGV4IDFjMTRiMjIuLjY3ZjcyNTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisr KyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC03LDYgKzcsMjkgQEAKICAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CiAgICAgICAgIFtTT1VQXVtHVEtd IE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KIAorICAgICAgICBBbGxv dyB0byByZXRyaWV2ZSB0aGUgU291cCBzZXNzaW9uIGFuZCBtb2RpZnkgdGhlIGNvZGUgdG8gdGFr ZQorICAgICAgICBpbnRvIGFjY291bnQgdXNlcnMgY2hhbmdpbmcgZmVhdHVyZXMgb24gaXQuCisK KyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmg6CisgICAgICAgICog cGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6Z2V0Q29va2llSmFyKToKKyAgICAgICAgKFdlYkNvcmU6OnNldENvb2tpZUphcik6CisgICAg ICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaDoKKyAgICAgICAgKiBw bGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OmNyZWF0ZVNvdXBTZXNzaW9uKToKKyAgICAgICAgKFdlYkNvcmU6OmVuc3VyZVNlc3Np b24pOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cCk6CisgICAg ICAgIChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbik6CisKKzIwMDktMDItMTkg IFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgV0FSTklORzogTk8gVEVTVCBDQVNFUyBBRERFRCBPUiBDSEFO R0VECisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIy NjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9t IFdlYktpdC4KKwogICAgICAgICBSZW1vdmUgQ1VSTCBzdXBwb3J0LgogCiAgICAgICAgICogR05V bWFrZWZpbGUuYW06CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3Vy Y2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5oCmlu ZGV4IGVlOTM3ZjEuLjM0YWQyOGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJj ZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAuaCIK ICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKKyNpbmNsdWRlIDxsaWJz b3VwL3NvdXAuaD4KKyNlbmRpZgorCiAjaWYgUExBVEZPUk0oQ0YpCiB0eXBlZGVmIGNvbnN0IHN0 cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsKICNlbmRpZgpAQCAtMTU5LDYgKzE2MywxMCBAQCBw dWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZ2V0SW50ZXJuYWwoKSB7IHJldHVy biBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lmIFVTRShTT1VQKQorICAgIHN0YXRpYyBTb3VwU2Vz c2lvbiogZ2V0U2Vzc2lvbigpOworI2VuZGlmCisKICAgICAvLyBVc2VkIHRvIHdvcmsgYXJvdW5k IHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdldCBhbnkgbW9yZSBOU1VSTENvbm5lY3Rpb24gY2Fs bGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJvbSB0aGUgb25lIHlvdSdyZSBpbi4KICAgICBzdGF0 aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAgCiAgICAgCmRpZmYgLS1naXQgYS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0v bmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCmluZGV4IDg4MTA5ZTguLmZiZTQyODYgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3Bw CisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCkBA IC0xLDUgKzEsNiBAQAogLyoKICAqICBDb3B5cmlnaHQgKEMpIDIwMDggWGFuIExvcGV6IDx4YW5A Z25vbWUub3JnPgorICogIENvcHlyaWdodCAoQykgMjAwOSBJZ2FsaWEgUy5MLiwgQXV0aG9yOiBY YW4gTG9wZXogPHhsb3BlekBpZ2FsaWEuY29tPgogICogIENvcHlyaWdodCAoQykgMjAwOCBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCiAgKgogICogIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTI1LDEwICsyNiwy NSBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3N0YXRpYyBTb3VwQ29va2llSmFyKiBjb29r aWVKYXI7CisKIFNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpCiB7Ci0gICAgc3RhdGljIFNv dXBDb29raWVKYXIqIGphciA9IHNvdXBfY29va2llX2phcl9uZXcoKTsKLSAgICByZXR1cm4gamFy OworICAgIGlmICghY29va2llSmFyKQorICAgICAgICBzZXRDb29raWVKYXIoc291cF9jb29raWVf amFyX25ldygpKTsKKworICAgIHJldHVybiBjb29raWVKYXI7Cit9CisKK3ZvaWQgc2V0Q29va2ll SmFyKFNvdXBDb29raWVKYXIqIGphcikKK3sKKyAgICBpZiAoY29va2llSmFyKQorICAgICAgICBn X29iamVjdF91bnJlZihjb29raWVKYXIpOworCisgICAgY29va2llSmFyID0gamFyOworCisgICAg aWYgKGNvb2tpZUphcikKKyAgICAgICAgZ19vYmplY3RfcmVmKGNvb2tpZUphcik7CiB9CiAKIHZv aWQgc2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNv bnN0IEtVUkwmIC8qcG9saWN5VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCmRpZmYgLS1naXQg YS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3Jl L3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uYjY1 ODhkMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFy U291cC5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAu aApAQCAtMzIsNiArMzIsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAgU291cENvb2tp ZUphciogZ2V0Q29va2llSmFyKCk7CisgICAgdm9pZCBzZXRDb29raWVKYXIoU291cENvb2tpZUph ciogamFyKTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCA5NWM4Mzg1Li4xYmExODcwIDEwMDY0 NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAu Y3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291 cC5jcHAKQEAgLTQsNiArNCw4IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0 ZC4KICAqIENvcHlyaWdodCAoQykgMjAwOSBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgogICog Q29weXJpZ2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSA8Z25zQGdub21lLm9yZz4K KyAqIENvcHlyaWdodCAoQykgMjAwOSBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlv LmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAwOSBJZ2FsaWEgUy5MLiwgQXV0aG9yOiBYYW4gTG9w ZXogPHhsb3BlekBpZ2FsaWEuY29tPgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlmeSBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBAIC01NSw3ICs1Nyw3 IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIFNvdXBTZXNzaW9uKiBzZXNzaW9u ID0gMDsKK3N0YXRpYyBTb3VwU2Vzc2lvbiogc2Vzc2lvbjsKIAogY2xhc3MgV2ViQ29yZVN5bmNo cm9ub3VzTG9hZGVyIDogcHVibGljIFJlc291cmNlSGFuZGxlQ2xpZW50LCBOb25jb3B5YWJsZSB7 CiBwdWJsaWM6CkBAIC0zNjUsMjIgKzM2NywzOSBAQCBib29sIFJlc291cmNlSGFuZGxlOjpzdGFy dERhdGEoU3RyaW5nIHVybFN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotYm9vbCBSZXNv dXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCitzdGF0aWMgdm9pZCBjcmVh dGVTb3VwU2Vzc2lvbigpCiB7Ci0gICAgaWYgKCFzZXNzaW9uKSB7Ci0gICAgICAgIHNlc3Npb24g PSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3KCk7CisgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9h c3luY19uZXcoKTsKK30KIAorc3RhdGljIHZvaWQgZW5zdXJlU2Vzc2lvbihTb3VwU2Vzc2lvbiog c2Vzc2lvbikKK3sKKyAgICBpZiAoZ19vYmplY3RfZ2V0X2RhdGEoR19PQkpFQ1Qoc2Vzc2lvbiks ICJ3ZWJraXQtaW5pdCIpKQorICAgICAgICByZXR1cm47CisgCisgICAgU291cENvb2tpZUphciog amFyID0gcmVpbnRlcnByZXRfY2FzdDxTb3VwQ29va2llSmFyKj4oc291cF9zZXNzaW9uX2dldF9m ZWF0dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9DT09LSUVfSkFSKSk7CisgICAgaWYgKCFqYXIpCiAg ICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1NFU1NJT05fRkVB VFVSRShnZXRDb29raWVKYXIoKSkpOworICAgIGVsc2UKKyAgICAgICAgc2V0Q29va2llSmFyKGph cik7CisKKyAgICBjb25zdCBjaGFyKiB3ZWJraXRfZGVidWcgPSBnX2dldGVudigiV0VCS0lUX0RF QlVHIik7IAorICAgIGlmIChzb3VwX3Nlc3Npb25fZ2V0X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9U WVBFX0xPR0dFUikgPT0gTlVMTAorICAgICAgICAmJiB3ZWJraXRfZGVidWcgJiYgIXN0cmNtcCh3 ZWJraXRfZGVidWcsICJuZXR3b3JrIikpIHsKKyAgICAgICAgU291cExvZ2dlciogbG9nZ2VyID0g c291cF9sb2dnZXJfbmV3KHN0YXRpY19jYXN0PFNvdXBMb2dnZXJMb2dMZXZlbD4oU09VUF9MT0dH RVJfTE9HX0JPRFkpLCAtMSk7CisgICAgICAgIHNvdXBfbG9nZ2VyX2F0dGFjaChsb2dnZXIsIHNl c3Npb24pOworICAgICAgICBnX29iamVjdF91bnJlZihsb2dnZXIpOworICAgIH0KKyAKKyAgICBn X29iamVjdF9zZXRfZGF0YShHX09CSkVDVChzZXNzaW9uKSwgIndlYmtpdC1pbml0IiwgcmVpbnRl cnByZXRfY2FzdDx2b2lkKj4oMHhkZWFkYmVlZikpOworfQogCi0gICAgICAgIGNvbnN0IGNoYXIq IHNvdXBfZGVidWcgPSBnX2dldGVudigiV0VCS0lUX1NPVVBfTE9HR0lORyIpOwotICAgICAgICBp ZiAoc291cF9kZWJ1ZykgewotICAgICAgICAgICAgaW50IHNvdXBfZGVidWdfbGV2ZWwgPSBhdG9p KHNvdXBfZGVidWcpOworYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxT dHJpbmcpCit7CisgICAgaWYgKCFzZXNzaW9uKQorICAgICAgICBjcmVhdGVTb3VwU2Vzc2lvbigp OwogCi0gICAgICAgICAgICBTb3VwTG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3Rh dGljX2Nhc3Q8U291cExvZ2dlckxvZ0xldmVsPihzb3VwX2RlYnVnX2xldmVsKSwgLTEpOwotICAg ICAgICAgICAgc291cF9sb2dnZXJfYXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7Ci0gICAgICAgICAg ICBnX29iamVjdF91bnJlZihsb2dnZXIpOwotICAgICAgICB9Ci0gICAgfQorICAgIGVuc3VyZVNl c3Npb24oc2Vzc2lvbik7CiAKICAgICBTb3VwTWVzc2FnZSogbXNnOwogICAgIG1zZyA9IHNvdXBf bWVzc2FnZV9uZXcocmVxdWVzdCgpLmh0dHBNZXRob2QoKS51dGY4KCkuZGF0YSgpLCB1cmxTdHJp bmcudXRmOCgpLmRhdGEoKSk7CkBAIC03NjEsNSArNzgwLDEzIEBAIGJvb2wgUmVzb3VyY2VIYW5k bGU6OnN0YXJ0R2lvKEtVUkwgdXJsKQogICAgIHJldHVybiB0cnVlOwogfQogCitTb3VwU2Vzc2lv biogUmVzb3VyY2VIYW5kbGU6OmdldFNlc3Npb24oKQoreworICAgIGlmICghc2Vzc2lvbikKKyAg ICAgICAgY3JlYXRlU291cFNlc3Npb24oKTsKKworICAgIHJldHVybiBzZXNzaW9uOworfQorCiB9 CiAKZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nIGIvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKaW5kZXggNThiYjFlZi4uNmIwY2Y4NSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L2d0ay9DaGFuZ2VMb2cKQEAgLTUsNiArNSwxOCBAQAogICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI2MjQKICAgICAgICAgW1NP VVBdW0dUS10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgogCisgICAg ICAgIEFkZCBBUEkgdG8gZ2V0IHRoZSBkZWZhdWx0IHNvdXAgc2Vzc2lvbi4KKworICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKKyAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vidmll dy5oOgorCisyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAorICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQ SSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCisKICAgICAgICAgQWRkIHNvdXAgZGVw ZW5kZW5jeSB0byBwYyBmaWxlLgogCiAgICAgICAgICogd2Via2l0LnBjLmluOgpkaWZmIC0tZ2l0 IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcAppbmRleCA0OTRhMjZmLi40MWIzYzczIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmNwcApAQCAtMSwxMiArMSwxMyBAQAogLyoKICAqICBDb3B5cmlnaHQg KEMpIDIwMDcsIDIwMDggSG9sZ2VyIEhhbnMgUGV0ZXIgRnJleXRoZXIKLSAqICBDb3B5cmlnaHQg KEMpIDIwMDcsIDIwMDggQ2hyaXN0aWFuIER5d2FuIDxjaHJpc3RpYW5AaW1lbmRpby5jb20+Cisg KiAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgQ2hyaXN0aWFuIER5d2FuIDxjaHJpc3RpYW5AaW1l bmRpby5jb20+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA3IFhhbiBMb3BleiA8eGFuQGdub21lLm9y Zz4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggQWxwIFRva2VyIDxhbHBAYXRva2VyLmNv bT4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDggSmFuIEFsb256byA8am1hbG9uem9AdW5wbHVnZ2Fi bGUuY29tPgogICogIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGdu c0Bnbm9tZS5vcmc+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4IE51YW50aSBMdGQuCiAgKiAgQ29w eXJpZ2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCisgKiAgQ29weXJpZ2h0IChDKSAyMDA5IEln YWxpYSBTLkwuLCBBdXRob3I6IFhhbiBMb3BleiA8eGxvcGV6QGlnYWxpYS5jb20+CiAgKgogICog IFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBh bmQvb3IKICAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdl bmVyYWwgUHVibGljCkBAIC01NiwxMCArNTcsMTAgQEAKICNpbmNsdWRlICJJbnNwZWN0b3JDbGll bnRHdGsuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5o IgotI2luY2x1ZGUgIkVkaXRvci5oIgogI2luY2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKICNp bmNsdWRlICJQbGF0Zm9ybUtleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVs RXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNjcmlwdFZh bHVlLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFyLmgiCiAjaW5jbHVkZSA8d3RmL0dPd25QdHIuaD4K QEAgLTI3MzgsNCArMjczOSwyMSBAQCB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250 ZW50X3pvb20oV2ViS2l0V2ViVmlldyogd2ViVmlldywgZ2Jvb2xlYW4gem9vbQogICAgIGdfb2Jq ZWN0X25vdGlmeShHX09CSkVDVCh3ZWJWaWV3KSwgImZ1bGwtY29udGVudC16b29tIik7CiB9CiAK Ky8qKgorICogd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Npb246CisgKgorICogUmV0cmlldmVzIHRo ZSBkZWZhdWx0ICNTb3VwU2Vzc2lvbiB1c2VkIGJ5IGFsbCB3ZWIgdmlld3MuCisgKiBOb3RlIHRo YXQgdGhlIHNlc3Npb24gZmVhdHVyZXMgYXJlIGFkZGVkIGJ5IFdlYktpdCBvbiBkZW1hbmQsCisg KiBzbyBpZiB5b3UgaW5zZXJ0IHlvdXIgb3duICNTb3VwQ29va2llSmFyIGJlZm9yZSBhbnkgbmV0 d29yaworICogdHJhZmZpYyBvY2N1cnMsIFdlYktpdCB3aWxsIHVzZSBpdCBpbnN0ZWFkIG9mIHRo ZSBkZWZhdWx0LgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlIGRlZmF1bHQgI1NvdXBTZXNzaW9u CisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfZ2V0X2RlZmF1 bHRfc2Vzc2lvbiAoKQoreworICAgIHJldHVybiBSZXNvdXJjZUhhbmRsZTo6Z2V0U2Vzc2lvbigp OworfQorCiB9CmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3Lmgg Yi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKaW5kZXggODYwYzBkMC4uNGNjMzU2 OSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCisrKyBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaApAQCAtMjMsNiArMjMsNyBAQAogI2RlZmlu ZSBXRUJLSVRfV0VCX1ZJRVdfSAogCiAjaW5jbHVkZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPGxp YnNvdXAvc291cC5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTQmFzZS5oPgogCiAjaW5j bHVkZSA8d2Via2l0L3dlYmtpdGRlZmluZXMuaD4KQEAgLTMwNCw2ICszMDUsOSBAQCBXRUJLSVRf QVBJIHZvaWQKIHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250ZW50X3pvb20gICAgICAgICAg IChXZWJLaXRXZWJWaWV3ICAgICAgICAqd2ViX3ZpZXcsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2Jvb2xlYW4gICAgICAgICAgICAgIGZ1bGxfY29u dGVudF96b29tKTsKIAorV0VCS0lUX0FQSSBTb3VwU2Vzc2lvbioKK3dlYmtpdF9nZXRfZGVmYXVs dF9zZXNzaW9uICAgICAgICAgICAgICAgICAgICAgICh2b2lkKTsKKwogR19FTkRfREVDTFMKIAog I2VuZGlmCi0tIAoxLjYuMQoK 27873 2009-02-23 01:48:04 -0800 2009-02-23 03:28:02 -0800 removecurl.patch removecurl.patch text/plain 9224 xan.lopez RnJvbSBhOGRiYjFmODBhYzc3ZWE2OTJjN2IwY2Q1OWJjY2ZjYTI0YWQ1MWU2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IFRodSwg MTkgRmViIDIwMDkgMTI6NTA6NDAgKzAyMDAKU3ViamVjdDogW1BBVENIIDEvMl0gMjAwOS0wMi0x OSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCgogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMjYyNAogICAgICAgIFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBm cm9tIFdlYktpdC4KCiAgICAgICAgUmVtb3ZlIENVUkwgc3VwcG9ydCwgdGhlIG9ubHkgc3VwcG9y dGVkIEhUVFAgYmFja2VuZCBpcyBTT1VQIG5vdy4KCiAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToK ICAgICAgICAqIGNvbmZpZ3VyZS5hYzoKLS0tCiBDaGFuZ2VMb2cgICAgICAgICAgICAgICAgICB8 ICAgMTIgKysrKysrKysrKysrCiBHTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICB8ICAgIDUgKyst LS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgIHwgICAxMyArKysrKysrKysrKysrCiBXZWJD b3JlL0dOVW1ha2VmaWxlLmFtICAgICB8ICAgMjYgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K IFdlYktpdC9ndGsvQ2hhbmdlTG9nICAgICAgIHwgICAxMSArKysrKysrKysrKwogV2ViS2l0L2d0 ay93ZWJraXQucGMuaW4gICAgfCAgICAyICstCiBXZWJLaXRUb29scy9DaGFuZ2VMb2cgICAgICB8 ICAgMTEgKysrKysrKysrKysKIFdlYktpdFRvb2xzL0dOVW1ha2VmaWxlLmFtIHwgICAgNiArKysr LS0KIGNvbmZpZ3VyZS5hYyAgICAgICAgICAgICAgIHwgICA0MyArKysrKy0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiA5IGZpbGVzIGNoYW5nZWQsIDU5IGluc2VydGlvbnMo KyksIDcwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwpp bmRleCBhZDM1ODc4Li41YTBjYTI3IDEwMDY0NAotLS0gYS9DaGFuZ2VMb2cKKysrIGIvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAgIFtTT1VQ XVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKworICAgICAg ICBSZW1vdmUgQ1VSTCBzdXBwb3J0LCB0aGUgb25seSBzdXBwb3J0ZWQgSFRUUCBiYWNrZW5kIGlz IFNPVVAgbm93LgorCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogY29uZmln dXJlLmFjOgorCiAyMDA5LTAyLTE5ICBDaHJpc3RpYW4gRHl3YW4gIDxjaHJpc3RpYW5AdHdvdG9h c3RzLmRlPgogCiAgICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEhvbGdlciBGcmV5dGhlci4KZGlm ZiAtLWdpdCBhL0dOVW1ha2VmaWxlLmFtIGIvR05VbWFrZWZpbGUuYW0KaW5kZXggZGJiYjE1Ny4u ZmIyZGViNSAxMDA2NDQKLS0tIGEvR05VbWFrZWZpbGUuYW0KKysrIGIvR05VbWFrZWZpbGUuYW0K QEAgLTE3NCw3ICsxNzQsNiBAQCBsaWJXZWJDb3JlX2xhX0NGTEFHUyA9IFwKIAkkKFBBTkdPX0NG TEFHUykgXAogCSQoR1RLX0NGTEFHUykgXAogCSQoWFRfQ0ZMQUdTKSBcCi0JJChMSUJDVVJMX0NG TEFHUykgXAogCSQoTElCU09VUF9DRkxBR1MpIFwKIAkkKEZSRUVUWVBFX0NGTEFHUykgXAogCSQo U1FMSVRFM19DRkxBR1MpIFwKQEAgLTIwMSw3ICsyMDAsNiBAQCBsaWJXZWJDb3JlX2xhX0xJQkFE RCA9IFwKIAkkKFBBTkdPX0xJQlMpIFwKIAkkKEdUS19MSUJTKSBcCiAJJChYVF9MSUJTKSBcCi0J JChMSUJDVVJMX0xJQlMpIFwKIAkkKExJQlNPVVBfTElCUykgXAogCSQoRlJFRVRZUEVfTElCUykg XAogCSQoVU5JQ09ERV9MSUJTKSBcCkBAIC00ODMsNyArNDgxLDggQEAgUHJvZ3JhbXNfVW5pdFRl c3RzX0NGTEFHUyA9IFwKIAktTzIgXAogCSQoZ2xvYmFsX2NmbGFncykgXAogCSQoR0xJQl9DRkxB R1MpIFwKLQkkKEdUS19DRkxBR1MpCisJJChHVEtfQ0ZMQUdTKSBcCisJJChMSUJTT1VQX0NGTEFH UykKIAogUHJvZ3JhbXNfVW5pdFRlc3RzX0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBl ZDA1OTQwLi40ZDk4NDQ5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJD b3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDA5LTAyLTE5ICBYYW4gTG9wZXogIDx4 YW5AZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFdBUk5JTkc6IE5PIFRFU1QgQ0FTRVMgQURERUQgT1IgQ0hBTkdFRAorCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAorICAgICAgICBb U09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQuCisKKyAg ICAgICAgUmVtb3ZlIENVUkwgc3VwcG9ydC4KKworICAgICAgICAqIEdOVW1ha2VmaWxlLmFtOgor CiAyMDA5LTAyLTIwICBHZW9mZnJleSBHYXJlbiAgPGdnYXJlbkBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvR05VbWFrZWZp bGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IGU2ZjUwMmQuLmU1N2UwODUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2ViQ29yZS9HTlVtYWtlZmls ZS5hbQpAQCAtMTc5NiwzMSArMTc5Niw2IEBAIHdlYmNvcmVndGtfc291cmNlcyArPSBcCiAJV2Vi Q29yZS9wbGF0Zm9ybS9pbWFnZS1kZWNvZGVycy94Ym0vWEJNSW1hZ2VEZWNvZGVyLmggXAogCVdl YkNvcmUvcGxhdGZvcm0vdGV4dC9ndGsvVGV4dEJyZWFrSXRlcmF0b3JJbnRlcm5hbElDVUd0ay5j cHAKIAotIyAtLS0tCi0jIGN1cmwgaHR0cCBiYWNrZW5kCi0jIC0tLS0KLWlmIFVTRV9DVVJMCi0K LXdlYmNvcmVfY3BwZmxhZ3MgKz0gXAotCS1EV1RGX1VTRV9DVVJMPTEgXAotCS1JJChzcmNkaXIp L1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsCi0KLXdlYmNvcmVfc291cmNlcyArPSBcCi0J V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQXV0aGVudGljYXRpb25DaGFsbGVuZ2UuaCBc Ci0JV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ29va2llSmFyQ3VybC5jcHAgXAotCVdl YkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0ROU0N1cmwuY3BwIFwKLQlXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybC9Gb3JtRGF0YVN0cmVhbUN1cmwuY3BwIFwKLQlXZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybC9Gb3JtRGF0YVN0cmVhbUN1cmwuaCBcCi0JV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL2N1cmwvUmVzb3VyY2VFcnJvci5oIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvY3VybC9SZXNvdXJjZUhhbmRsZUN1cmwuY3BwIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvY3VybC9SZXNvdXJjZUhhbmRsZU1hbmFnZXIuY3BwIFwKLQlXZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvY3VybC9SZXNvdXJjZUhhbmRsZU1hbmFnZXIuaCBcCi0JV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvUmVzb3VyY2VSZXF1ZXN0LmggXAotCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9jdXJsL1Jlc291cmNlUmVzcG9uc2UuaAotCi1lbmRpZiAjIEVORCBVU0VfQ1VSTAotCi1pZiBV U0VfU09VUAogd2ViY29yZV9jcHBmbGFncyArPSBcCiAJLURXVEZfVVNFX1NPVVA9MSBcCiAJLUkk KHNyY2RpcikvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAKQEAgLTE4MzQsNyArMTgwOSw2 IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VIYW5kbGVTb3VwLmNwcCBcCiAJV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VSZXF1ZXN0LmggXAogCVdlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291 cmNlUmVzcG9uc2UuaAotZW5kaWYKIAogIyAtLS0KICMgRnJlZXR5cGUgZm9udCBiYWNrZW5kCmRp ZmYgLS1naXQgYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCmlu ZGV4IDNhZDFhNDMuLjU4YmIxZWYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvQ2hhbmdlTG9nCisr KyBiL1dlYktpdC9ndGsvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDItMTkgIFhh biBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIyNjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBm cm9tIFdlYktpdC4KKworICAgICAgICBBZGQgc291cCBkZXBlbmRlbmN5IHRvIHBjIGZpbGUuCisK KyAgICAgICAgKiB3ZWJraXQucGMuaW46CisKIDIwMDktMDItMTcgIFhhbiBMb3BleiAgPHhhbkBn bm9tZS5vcmc+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgQWxleGV5IFByb3NrdXJ5YWtv di4KZGlmZiAtLWdpdCBhL1dlYktpdC9ndGsvd2Via2l0LnBjLmluIGIvV2ViS2l0L2d0ay93ZWJr aXQucGMuaW4KaW5kZXggMGNlNmY3MS4uODRkNjExNSAxMDA2NDQKLS0tIGEvV2ViS2l0L2d0ay93 ZWJraXQucGMuaW4KKysrIGIvV2ViS2l0L2d0ay93ZWJraXQucGMuaW4KQEAgLTYsNiArNiw2IEBA IGluY2x1ZGVkaXI9QGluY2x1ZGVkaXJACiBOYW1lOiBXZWJLaXQKIERlc2NyaXB0aW9uOiBXZWIg Y29udGVudCBlbmdpbmUgZm9yIEdUSysKIFZlcnNpb246IEBWRVJTSU9OQAotUmVxdWlyZXM6IGd0 aystMi4wCitSZXF1aXJlczogZ3RrKy0yLjAgbGlic291cC0yLjQKIExpYnM6IC1MJHtsaWJkaXJ9 IC1sd2Via2l0LTEuMAogQ2ZsYWdzOiAtSSR7aW5jbHVkZWRpcn0vd2Via2l0LTEuMApkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCmluZGV4 IDFjN2Y5MjcuLjRlNjBjYzUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZworKysg Yi9XZWJLaXRUb29scy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAwOS0wMi0xOSAgWGFu IExvcGV6ICA8eGFuQGdub21lLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjI2MjQKKyAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBBUEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZy b20gV2ViS2l0LgorCisgICAgICAgIEFkZCBzb3VwIGZsYWdzIG5vdyB0aGF0IGRlcGVuZGVuY3kg aXMgZXhwbGljaXQuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKwogMjAwOS0wMi0yMiAg TWFyayBSb3dlICA8bXJvd2VAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE9saXZl ciBIdW50LgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvR05VbWFrZWZpbGUuYW0gYi9XZWJLaXRU b29scy9HTlVtYWtlZmlsZS5hbQppbmRleCAyNjIwMGM4Li4xYzFiZWUzIDEwMDY0NAotLS0gYS9X ZWJLaXRUb29scy9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJLaXRUb29scy9HTlVtYWtlZmlsZS5h bQpAQCAtMjAsNyArMjAsOCBAQCBQcm9ncmFtc19HdGtMYXVuY2hlcl9DRkxBR1MgPSBcCiAJLWZu by1zdHJpY3QtYWxpYXNpbmcgXAogCS1PMiBcCiAJJChnbG9iYWxfY2ZsYWdzKSBcCi0JJChHVEtf Q0ZMQUdTKQorCSQoR1RLX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1MpCiAKIFByb2dyYW1z X0d0a0xhdW5jaGVyX0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXApAQCAtNjcsNyArNjgs OCBAQCBQcm9ncmFtc19EdW1wUmVuZGVyVHJlZV9DRkxBR1MgPSBcCiAJJChnbG9iYWxfY2ZsYWdz KSBcCiAJJChHTE9CQUxERVBTX0NGTEFHUykgXAogCSQoQ0FJUk9fQ0ZMQUdTKSBcCi0JJChHVEtf Q0ZMQUdTKQorCSQoR1RLX0NGTEFHUykgXAorCSQoTElCU09VUF9DRkxBR1MpCiAKIFByb2dyYW1z X0R1bXBSZW5kZXJUcmVlX0xEQUREID0gXAogCWxpYndlYmtpdC0xLjAubGEgXApkaWZmIC0tZ2l0 IGEvY29uZmlndXJlLmFjIGIvY29uZmlndXJlLmFjCmluZGV4IDI4NzcxZGYuLmYxM2Q5ZmEgMTAw NjQ0Ci0tLSBhL2NvbmZpZ3VyZS5hYworKysgYi9jb25maWd1cmUuYWMKQEAgLTE3NSwyMCArMTc1 LDYgQEAgaWYgdGVzdCAiJHdpdGhfaGlsZG9uIiA9ICJ5ZXMiOyB0aGVuCiAgICAgQUNfU1VCU1Qo W0hJTERPTl9MSUJTXSkKIGZpCiAKLSMgZGV0ZXJtaW5lIHRoZSBodHRwIGJhY2tlbmQKLUFDX01T R19DSEVDS0lORyhbdGhlIEhUVFAgYmFja2VuZCB0byB1c2VdKQotQUNfQVJHX1dJVEgoaHR0cF9i YWNrZW5kLAotICAgICAgICAgICAgQUNfSEVMUF9TVFJJTkcoWy0td2l0aC1odHRwLWJhY2tlbmQ9 QDw6QGN1cmwvc291cEA6PkBdLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgW1NlbGVjdCBI VFRQIGJhY2tlbmQgW2RlZmF1bHQ9c291cF1dKSwKLSAgICAgICAgICAgIFtdLFt3aXRoX2h0dHBf YmFja2VuZD0ic291cCJdKQotCi1jYXNlICIkd2l0aF9odHRwX2JhY2tlbmQiIGluCi0gICAgIGN1 cmx8c291cCkgOzsKLSAgICAgKikgQUNfTVNHX0VSUk9SKFtJbnZhbGlkIEhUVFAgYmFja2VuZDog bXVzdCBiZSBjdXJsLCBzb3VwLl0pIDs7Ci1lc2FjCi0KLUFDX01TR19SRVNVTFQoWyR3aXRoX2h0 dHBfYmFja2VuZF0pCi0KICMgbWluaW11bSBiYXNlIGRlcGVuZGVuY2llcwogQ0FJUk9fUkVRVUlS RURfVkVSU0lPTj0xLjIKIEZPTlRDT05GSUdfUkVRVUlSRURfVkVSU0lPTj0yLjQKQEAgLTIwMCw4 ICsxODYsNyBAQCBQQU5HT19SRVFVSVJFRF9WRVJTSU9OPTEuMAogR1RLX1JFUVVJUkVEX1ZFUlNJ T049Mi44CiAKICMgb3B0aW9uYWwgbW9kdWxlcwotTElCQ1VSTF9SRVFVSVJFRF9WRVJTSU9OPTcu MTUKLUxJQlNPVVBfUkVRVUlSRURfVkVSU0lPTj0yLjIzCitMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJ T049Mi4yNS40CiBMSUJYU0xUX1JFUVVJUkVEX1ZFUlNJT049MS4xLjcKIFNRTElURV9SRVFVSVJF RF9WRVJTSU9OPTMuMAogR1NUUkVBTUVSX1JFUVVJUkVEX1ZFUlNJT049MC4xMApAQCAtNTExLDIz ICs0OTYsMTAgQEAgZWxzZQogICAgQ0ZMQUdTPSIkQ0ZMQUdTIC1PMCIKIGZpCiAKLSMgY2hlY2sg aWYgY3VybCBpcyBhdmFpbGFibGUKLWlmIHRlc3QgIiR3aXRoX2h0dHBfYmFja2VuZCIgPSAiY3Vy bCI7IHRoZW4KLSAgIFBLR19DSEVDS19NT0RVTEVTKFtMSUJDVVJMXSwKLSAgICAgICAgICAgICAg ICAgICAgIFtsaWJjdXJsID49ICRMSUJDVVJMX1JFUVVJUkVEX1ZFUlNJT05dKQotICAgaWYgdGVz dCAiJG9zX3dpbjMyIiA9ICJ5ZXMiOyB0aGVuCi0gICAgICBMSUJDVVJMX0xJQlM9IiRMSUJDVVJM X0xJQlMgLWx3czJfMzIiCi0gICBmaQotICAgQUNfU1VCU1QoW0xJQkNVUkxfQ0ZMQUdTXSkKLSAg IEFDX1NVQlNUKFtMSUJDVVJMX0xJQlNdKQotZmkKLQotaWYgdGVzdCAiJHdpdGhfaHR0cF9iYWNr ZW5kIiA9ICJzb3VwIjsgdGhlbgotICAgUEtHX0NIRUNLX01PRFVMRVMoW0xJQlNPVVBdLAotICAg ICAgICAgICAgICAgICAgICAgW2xpYnNvdXAtMi40ID49ICRMSUJTT1VQX1JFUVVJUkVEX1ZFUlNJ T05dKQotICAgQUNfU1VCU1QoW0xJQlNPVVBfQ0ZMQUdTXSkKLSAgIEFDX1NVQlNUKFtMSUJTT1VQ X0xJQlNdKQotZmkKK1BLR19DSEVDS19NT0RVTEVTKFtMSUJTT1VQXSwKKyAgICAgICAgICAgICAg ICAgIFtsaWJzb3VwLTIuNCA+PSAkTElCU09VUF9SRVFVSVJFRF9WRVJTSU9OXSkKK0FDX1NVQlNU KFtMSUJTT1VQX0NGTEFHU10pCitBQ19TVUJTVChbTElCU09VUF9MSUJTXSkKIAogIyBjaGVjayBp ZiBGcmVlVHlwZS9Gb250Q29uZmlnIGFyZSBhdmFpbGFibGUKIGlmIHRlc3QgIiR3aXRoX2ZvbnRf YmFja2VuZCIgPSAiZnJlZXR5cGUiOyB0aGVuCkBAIC02MDcsMTAgKzU3OSw2IEBAIEFNX0NPTkRJ VElPTkFMKFtUQVJHRVRfV0lOMzJdLCBbdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJ3aW4zMiJdKQog QU1fQ09ORElUSU9OQUwoW1RBUkdFVF9RVUFSVFpdLCBbdGVzdCAiJHdpdGhfdGFyZ2V0IiA9ICJx dWFydHoiXSkKIEFNX0NPTkRJVElPTkFMKFtUQVJHRVRfRElSRUNURkJdLCBbdGVzdCAiJHdpdGhf dGFyZ2V0IiA9ICJkaXJlY3RmYiJdKQogCi0jIEhUVFAgYmFja2VuZCBjb25kaXRpb25hbHMKLUFN X0NPTkRJVElPTkFMKFtVU0VfQ1VSTF0sIFt0ZXN0ICIkd2l0aF9odHRwX2JhY2tlbmQiID0gImN1 cmwiXSkKLUFNX0NPTkRJVElPTkFMKFtVU0VfU09VUF0sIFt0ZXN0ICIkd2l0aF9odHRwX2JhY2tl bmQiID0gInNvdXAiXSkKLQogIyBGb250IGJhY2tlbmQgY29uZGl0aW9uYWxzCiBBTV9DT05ESVRJ T05BTChbVVNFX0ZSRUVUWVBFXSwgW3Rlc3QgIiR3aXRoX2ZvbnRfYmFja2VuZCIgPSAiZnJlZXR5 cGUiXSkKIEFNX0NPTkRJVElPTkFMKFtVU0VfUEFOR09dLCBbdGVzdCAiJHdpdGhfZm9udF9iYWNr ZW5kIiA9ICJwYW5nbyJdKQpAQCAtNjU3LDcgKzYyNSw2IEBAIEJ1aWxkIGNvbmZpZ3VyYXRpb246 CiAgRW5hYmxlIEdDQyBidWlsZCBvcHRpbWl6YXRpb24gICAgICAgICAgICAgICAgICAgICAgICAg ICAgOiAkZW5hYmxlX29wdGltaXphdGlvbnMKICBDb2RlIGNvdmVyYWdlIHN1cHBvcnQgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICRlbmFibGVfY292ZXJhZ2UKICBVbmljb2Rl IGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6ICR1bmlj b2RlX2JhY2tlbmQKLSBIVFRQIGJhY2tlbmQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICA6ICR3aXRoX2h0dHBfYmFja2VuZAogIEZvbnQgYmFja2VuZCAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDogJHdpdGhfZm9udF9iYWNrZW5k CiAgT3B0aW1pemVkIG1lbW9yeSBhbGxvY2F0b3IgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgOiAkZW5hYmxlX2Zhc3RfbWFsbG9jCiBGZWF0dXJlczoKLS0gCjEuNi4xCgo= 27874 2009-02-23 01:48:31 -0800 2009-02-23 02:08:11 -0800 defaultsession.patch defaultsession.patch text/plain 12577 xan.lopez RnJvbSAwNTJkYTZjZjE4MjcyNmQ3ZGY2ZDA2MTVlOGE4NzkzYzIxYjg4YjM0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IE1vbiwg MjMgRmViIDIwMDkgMTE6NDQ6MDEgKzAyMDAKU3ViamVjdDogW1BBVENIIDIvMl0gV2ViQ29yZToK CjIwMDktMDItMjMgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CgogICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjI2MjQKICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291 cFNlc3Npb24gZnJvbSBXZWJLaXQuCgogICAgICAgIEFsbG93IHRvIHJldHJpZXZlIHRoZSBTb3Vw IHNlc3Npb24gYW5kIG1vZGlmeSB0aGUgY29kZSB0byB0YWtlCiAgICAgICAgaW50byBhY2NvdW50 IHVzZXJzIGNoYW5naW5nIGZlYXR1cmVzIG9uIGl0LgoKICAgICAgICAqIHBsYXRmb3JtL25ldHdv cmsvUmVzb3VyY2VIYW5kbGUuaDoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29r aWVKYXJTb3VwLmNwcDoKICAgICAgICAoV2ViQ29yZTo6ZGVmYXVsdENvb2tpZUphcik6CiAgICAg ICAgKFdlYkNvcmU6OnNldERlZmF1bHRDb29raWVKYXIpOgogICAgICAgICogcGxhdGZvcm0vbmV0 d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaDoKICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgogICAgICAgIChXZWJDb3JlOjpjcmVhdGVTb3VwU2Vz c2lvbik6CiAgICAgICAgKFdlYkNvcmU6OmVuc3VyZVNlc3Npb25Jc0luaXRpYWxpemVkKToKICAg ICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cCk6CiAgICAgICAgKFdlYkNv cmU6OlJlc291cmNlSGFuZGxlOjpjYW5jZWwpOgogICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUhh bmRsZTo6ZGVmYXVsdFNlc3Npb24pOgoKV2ViS2l0L2d0azoKCjIwMDktMDItMjMgIFhhbiBMb3Bl eiAgPHhhbkBnbm9tZS5vcmc+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoK ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI2MjQKICAg ICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQu CgogICAgICAgIEFkZCBBUEkgdG8gZ2V0IHRoZSBkZWZhdWx0IHNvdXAgc2Vzc2lvbi4KCiAgICAg ICAgKiB3ZWJraXQvd2Via2l0d2Vidmlldy5jcHA6CiAgICAgICAgKiB3ZWJraXQvd2Via2l0d2Vi dmlldy5oOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAyMiArKysrKysrKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNl SGFuZGxlLmggICAgICAgICAgfCAgICA4ICsrKwogV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3Nv dXAvQ29va2llSmFyU291cC5jcHAgICAgfCAgIDI4ICsrKysrKysrLS0KIFdlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaCAgICAgIHwgICAgMyArLQogLi4uL3BsYXRm b3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwICAgfCAgIDU3ICsrKysrKysr KysrKysrLS0tLS0tCiBXZWJLaXQvZ3RrL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAgMTIgKysrKwogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5jcHAg ICAgICAgICAgICAgICAgfCAgIDIyICsrKysrKystCiBXZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3 ZWJ2aWV3LmggICAgICAgICAgICAgICAgICB8ICAgIDQgKysKIDggZmlsZXMgY2hhbmdlZCwgMTMx IGluc2VydGlvbnMoKyksIDI1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hh bmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGQ5ODQ0OS4uODJkNDFjZCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyAr MSwyNSBAQAorMjAwOS0wMi0yMyAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI2MjQKKyAgICAgICAgW1NPVVBdW0dUS10gTmVlZCBB UEkgdG8gZ2V0IFNvdXBTZXNzaW9uIGZyb20gV2ViS2l0LgorCisgICAgICAgIEFsbG93IHRvIHJl dHJpZXZlIHRoZSBTb3VwIHNlc3Npb24gYW5kIG1vZGlmeSB0aGUgY29kZSB0byB0YWtlCisgICAg ICAgIGludG8gYWNjb3VudCB1c2VycyBjaGFuZ2luZyBmZWF0dXJlcyBvbiBpdC4KKworICAgICAg ICAqIHBsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5kbGUuaDoKKyAgICAgICAgKiBwbGF0Zm9y bS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpkZWZh dWx0Q29va2llSmFyKToKKyAgICAgICAgKFdlYkNvcmU6OnNldERlZmF1bHRDb29raWVKYXIpOgor ICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmg6CisgICAgICAg ICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpjcmVhdGVTb3VwU2Vzc2lvbik6CisgICAgICAgIChXZWJDb3JlOjplbnN1cmVT ZXNzaW9uSXNJbml0aWFsaXplZCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6 c3RhcnRIdHRwKToKKyAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpjYW5jZWwpOgor ICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OmRlZmF1bHRTZXNzaW9uKToKKwogMjAw OS0wMi0xOSAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUhhbmRsZS5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxl LmgKaW5kZXggZWU5MzdmMS4uMTRmNTBjZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL1Jlc291cmNlSGFuZGxlLmgKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL1Jl c291cmNlSGFuZGxlLmgKQEAgLTMwLDYgKzMwLDEwIEBACiAjaW5jbHVkZSAiSFRUUEhlYWRlck1h cC5oIgogI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KIAorI2lmIFVTRShTT1VQKQordHlwZWRlZiBz dHJ1Y3QgX1NvdXBTZXNzaW9uIFNvdXBTZXNzaW9uOworI2VuZGlmCisKICNpZiBQTEFURk9STShD RikKIHR5cGVkZWYgY29uc3Qgc3RydWN0IF9fQ0ZEYXRhICogQ0ZEYXRhUmVmOwogI2VuZGlmCkBA IC0xNTksNiArMTYzLDEwIEBAIHB1YmxpYzoKICAgICBSZXNvdXJjZUhhbmRsZUludGVybmFsKiBn ZXRJbnRlcm5hbCgpIHsgcmV0dXJuIGQuZ2V0KCk7IH0KICNlbmRpZgogCisjaWYgVVNFKFNPVVAp CisgICAgc3RhdGljIFNvdXBTZXNzaW9uKiBkZWZhdWx0U2Vzc2lvbigpOworI2VuZGlmCisKICAg ICAvLyBVc2VkIHRvIHdvcmsgYXJvdW5kIHRoZSBmYWN0IHRoYXQgeW91IGRvbid0IGdldCBhbnkg bW9yZSBOU1VSTENvbm5lY3Rpb24gY2FsbGJhY2tzIHVudGlsIHlvdSByZXR1cm4gZnJvbSB0aGUg b25lIHlvdSdyZSBpbi4KICAgICBzdGF0aWMgYm9vbCBsb2Fkc0Jsb2NrZWQoKTsgICAgCiAgICAg CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3Vw LmNwcCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCmlu ZGV4IDg4MTA5ZTguLmJlMzkyZjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9z b3VwL0Nvb2tpZUphclNvdXAuY3BwCkBAIC0xLDUgKzEsNiBAQAogLyoKICAqICBDb3B5cmlnaHQg KEMpIDIwMDggWGFuIExvcGV6IDx4YW5AZ25vbWUub3JnPgorICogIENvcHlyaWdodCAoQykgMjAw OSBJZ2FsaWEgUy5MLgogICogIENvcHlyaWdodCAoQykgMjAwOCBBcHBsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCiAgKgogICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTI1LDE1ICsyNiwzMCBAQAogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKLVNvdXBDb29raWVKYXIqIGdldENvb2tpZUphcigpCitzdGF0aWMgU291 cENvb2tpZUphciogY29va2llSmFyOworCitTb3VwQ29va2llSmFyKiBkZWZhdWx0Q29va2llSmFy KCkKIHsKLSAgICBzdGF0aWMgU291cENvb2tpZUphciogamFyID0gc291cF9jb29raWVfamFyX25l dygpOwotICAgIHJldHVybiBqYXI7CisgICAgaWYgKCFjb29raWVKYXIpCisgICAgICAgIHNldERl ZmF1bHRDb29raWVKYXIoc291cF9jb29raWVfamFyX25ldygpKTsKKworICAgIHJldHVybiBjb29r aWVKYXI7Cit9CisKK3ZvaWQgc2V0RGVmYXVsdENvb2tpZUphcihTb3VwQ29va2llSmFyKiBqYXIp Cit7CisgICAgaWYgKGNvb2tpZUphcikKKyAgICAgICAgZ19vYmplY3RfdW5yZWYoY29va2llSmFy KTsKKworICAgIGNvb2tpZUphciA9IGphcjsKKworICAgIGlmIChjb29raWVKYXIpCisgICAgICAg IGdfb2JqZWN0X3JlZihjb29raWVKYXIpOwogfQogCiB2b2lkIHNldENvb2tpZXMoRG9jdW1lbnQq IC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYgdXJsLCBjb25zdCBLVVJMJiAvKnBvbGljeVVSTCov LCBjb25zdCBTdHJpbmcmIHZhbHVlKQogewotICAgIFNvdXBDb29raWVKYXIqIGphciA9IGdldENv b2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGphciA9IGRlZmF1bHRDb29raWVKYXIoKTsK ICAgICBpZiAoIWphcikKICAgICAgICAgcmV0dXJuOwogCkBAIC00NSw3ICs2MSw3IEBAIHZvaWQg c2V0Q29va2llcyhEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0 IEtVUkwmIC8qcG9saWN5VVJMCiAKIFN0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiAvKmRv Y3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCkKIHsKLSAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBn ZXRDb29raWVKYXIoKTsKKyAgICBTb3VwQ29va2llSmFyKiBqYXIgPSBkZWZhdWx0Q29va2llSmFy KCk7CiAgICAgaWYgKCFqYXIpCiAgICAgICAgIHJldHVybiBTdHJpbmcoKTsKIApAQCAtNjEsNyAr NzcsNyBAQCBTdHJpbmcgY29va2llcyhjb25zdCBEb2N1bWVudCogLypkb2N1bWVudCovLCBjb25z dCBLVVJMJiB1cmwpCiAKIGJvb2wgY29va2llc0VuYWJsZWQoY29uc3QgRG9jdW1lbnQqIC8qZG9j dW1lbnQqLykKIHsKLSAgICByZXR1cm4gZ2V0Q29va2llSmFyKCk7CisgICAgcmV0dXJuIGRlZmF1 bHRDb29raWVKYXIoKTsKIH0KIAogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3 b3JrL3NvdXAvQ29va2llSmFyU291cC5oIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv Q29va2llSmFyU291cC5oCmluZGV4IDYxMTc5YWUuLmFiMWY5NWMgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaAorKysgYi9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmgKQEAgLTMxLDcgKzMxLDggQEAKICNp bmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewotICAgIFNvdXBD b29raWVKYXIqIGdldENvb2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGRlZmF1bHRDb29r aWVKYXIoKTsKKyAgICB2b2lkIHNldERlZmF1bHRDb29raWVKYXIoU291cENvb2tpZUphciogamFy KTsKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAv UmVzb3VyY2VIYW5kbGVTb3VwLmNwcAppbmRleCAzYzQ4MDUyLi5iNDlhZjYwIDEwMDY0NAotLS0g YS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCisr KyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAK QEAgLTQsNiArNCw4IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQ29sbGFib3JhIEx0ZC4KICAq IENvcHlyaWdodCAoQykgMjAwOSBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgogICogQ29weXJp Z2h0IChDKSAyMDA5IEd1c3Rhdm8gTm9yb25oYSBTaWx2YSA8Z25zQGdub21lLm9yZz4KKyAqIENv cHlyaWdodCAoQykgMjAwOSBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNvbT4K KyAqIENvcHlyaWdodCAoQykgMjAwOSBJZ2FsaWEgUy5MLgogICoKICAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCkBA IC01NSw4ICs1Nyw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotc3RhdGljIFNvdXBTZXNz aW9uKiBzZXNzaW9uID0gMDsKLQogY2xhc3MgV2ViQ29yZVN5bmNocm9ub3VzTG9hZGVyIDogcHVi bGljIFJlc291cmNlSGFuZGxlQ2xpZW50LCBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgV2Vi Q29yZVN5bmNocm9ub3VzTG9hZGVyKFJlc291cmNlRXJyb3ImLCBSZXNvdXJjZVJlc3BvbnNlICYs IFZlY3RvcjxjaGFyPiYpOwpAQCAtMzY1LDIyICszNjUsMzcgQEAgYm9vbCBSZXNvdXJjZUhhbmRs ZTo6c3RhcnREYXRhKFN0cmluZyB1cmxTdHJpbmcpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJv b2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQorc3RhdGljIFNv dXBTZXNzaW9uKiBjcmVhdGVTb3VwU2Vzc2lvbigpCiB7Ci0gICAgaWYgKCFzZXNzaW9uKSB7Ci0g ICAgICAgIHNlc3Npb24gPSBzb3VwX3Nlc3Npb25fYXN5bmNfbmV3KCk7Ci0KLSAgICAgICAgc291 cF9zZXNzaW9uX2FkZF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfU0VTU0lPTl9GRUFUVVJFKGdldENv b2tpZUphcigpKSk7Ci0KLSAgICAgICAgY29uc3QgY2hhciogc291cF9kZWJ1ZyA9IGdfZ2V0ZW52 KCJXRUJLSVRfU09VUF9MT0dHSU5HIik7Ci0gICAgICAgIGlmIChzb3VwX2RlYnVnKSB7Ci0gICAg ICAgICAgICBpbnQgc291cF9kZWJ1Z19sZXZlbCA9IGF0b2koc291cF9kZWJ1Zyk7CisgICAgcmV0 dXJuIHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKK30KIAotICAgICAgICAgICAgU291cExvZ2dl ciogbG9nZ2VyID0gc291cF9sb2dnZXJfbmV3KHN0YXRpY19jYXN0PFNvdXBMb2dnZXJMb2dMZXZl bD4oc291cF9kZWJ1Z19sZXZlbCksIC0xKTsKLSAgICAgICAgICAgIHNvdXBfbG9nZ2VyX2F0dGFj aChsb2dnZXIsIHNlc3Npb24pOwotICAgICAgICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsK LSAgICAgICAgfQorc3RhdGljIHZvaWQgZW5zdXJlU2Vzc2lvbklzSW5pdGlhbGl6ZWQoU291cFNl c3Npb24qIHNlc3Npb24pCit7CisgICAgaWYgKGdfb2JqZWN0X2dldF9kYXRhKEdfT0JKRUNUKHNl c3Npb24pLCAid2Via2l0LWluaXQiKSkKKyAgICAgICAgcmV0dXJuOworIAorICAgIFNvdXBDb29r aWVKYXIqIGphciA9IHJlaW50ZXJwcmV0X2Nhc3Q8U291cENvb2tpZUphcio+KHNvdXBfc2Vzc2lv bl9nZXRfZmVhdHVyZShzZXNzaW9uLCBTT1VQX1RZUEVfQ09PS0lFX0pBUikpOworICAgIGlmICgh amFyKQorICAgICAgICBzb3VwX3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNT SU9OX0ZFQVRVUkUoZGVmYXVsdENvb2tpZUphcigpKSk7CisgICAgZWxzZQorICAgICAgICBzZXRE ZWZhdWx0Q29va2llSmFyKGphcik7CisKKyAgICBjb25zdCBjaGFyKiB3ZWJraXRfZGVidWcgPSBn X2dldGVudigiV0VCS0lUX0RFQlVHIik7IAorICAgIGlmICghc291cF9zZXNzaW9uX2dldF9mZWF0 dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9MT0dHRVIpCisgICAgICAgICYmIHdlYmtpdF9kZWJ1ZyAm JiAhc3RyY21wKHdlYmtpdF9kZWJ1ZywgIm5ldHdvcmsiKSkgeworICAgICAgICBTb3VwTG9nZ2Vy KiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291cExvZ2dlckxvZ0xldmVs PihTT1VQX0xPR0dFUl9MT0dfQk9EWSksIC0xKTsKKyAgICAgICAgc291cF9sb2dnZXJfYXR0YWNo KGxvZ2dlciwgc2Vzc2lvbik7CisgICAgICAgIGdfb2JqZWN0X3VucmVmKGxvZ2dlcik7CiAgICAg fQorIAorICAgIGdfb2JqZWN0X3NldF9kYXRhKEdfT0JKRUNUKHNlc3Npb24pLCAid2Via2l0LWlu aXQiLCByZWludGVycHJldF9jYXN0PHZvaWQqPigweGRlYWRiZWVmKSk7Cit9CisKK2Jvb2wgUmVz b3VyY2VIYW5kbGU6OnN0YXJ0SHR0cChTdHJpbmcgdXJsU3RyaW5nKQoreworICAgIFNvdXBTZXNz aW9uKiBzZXNzaW9uID0gZGVmYXVsdFNlc3Npb24oKTsKKyAgICBlbnN1cmVTZXNzaW9uSXNJbml0 aWFsaXplZChzZXNzaW9uKTsKIAogICAgIFNvdXBNZXNzYWdlKiBtc2c7CiAgICAgbXNnID0gc291 cF9tZXNzYWdlX25ldyhyZXF1ZXN0KCkuaHR0cE1ldGhvZCgpLnV0ZjgoKS5kYXRhKCksIHVybFN0 cmluZy51dGY4KCkuZGF0YSgpKTsKQEAgLTUwNSw3ICs1MjAsNyBAQCB2b2lkIFJlc291cmNlSGFu ZGxlOjpjYW5jZWwoKQogewogICAgIGQtPm1fY2FuY2VsbGVkID0gdHJ1ZTsKICAgICBpZiAoZC0+ bV9tc2cpIHsKLSAgICAgICAgc291cF9zZXNzaW9uX2NhbmNlbF9tZXNzYWdlKHNlc3Npb24sIGQt Pm1fbXNnLCBTT1VQX1NUQVRVU19DQU5DRUxMRUQpOworICAgICAgICBzb3VwX3Nlc3Npb25fY2Fu Y2VsX21lc3NhZ2UoZGVmYXVsdFNlc3Npb24oKSwgZC0+bV9tc2csIFNPVVBfU1RBVFVTX0NBTkNF TExFRCk7CiAgICAgICAgIC8vIEZvciByZS1lbnRyYW5jeSB0cm91YmxlcyB3ZSBjYWxsIGRpZEZp bmlzaExvYWRpbmcgd2hlbiB0aGUgbWVzc2FnZSBoYXNuJ3QgYmVlbiBoYW5kbGVkIHlldC4KICAg ICAgICAgaWYgKGNsaWVudCgpKQogICAgICAgICAgICAgY2xpZW50KCktPmRpZEZpbmlzaExvYWRp bmcodGhpcyk7CkBAIC03NzMsNSArNzg4LDE1IEBAIGJvb2wgUmVzb3VyY2VIYW5kbGU6OnN0YXJ0 R2lvKEtVUkwgdXJsKQogICAgIHJldHVybiB0cnVlOwogfQogCitTb3VwU2Vzc2lvbiogUmVzb3Vy Y2VIYW5kbGU6OmRlZmF1bHRTZXNzaW9uKCkKK3sKKyAgICBzdGF0aWMgU291cFNlc3Npb24qIHNl c3Npb247CisKKyAgICBpZiAoIXNlc3Npb24pCisgICAgICAgIHNlc3Npb24gPSBjcmVhdGVTb3Vw U2Vzc2lvbigpOworCisgICAgcmV0dXJuIHNlc3Npb247Cit9CisKIH0KIApkaWZmIC0tZ2l0IGEv V2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCA1OGJiMWVm Li42ZGZlYjVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQv Z3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDA5LTAyLTIzICBYYW4gTG9wZXogIDx4 YW5AZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAorICAg ICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQgU291cFNlc3Npb24gZnJvbSBXZWJLaXQu CisKKyAgICAgICAgQWRkIEFQSSB0byBnZXQgdGhlIGRlZmF1bHQgc291cCBzZXNzaW9uLgorCisg ICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwOgorICAgICAgICAqIHdlYmtpdC93ZWJr aXR3ZWJ2aWV3Lmg6CisKIDIwMDktMDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJLaXQv Z3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YnZpZXcuY3BwCmluZGV4IDQ5NGEyNmYuLmIwNGVmMDUgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsv d2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdl YnZpZXcuY3BwCkBAIC0xLDEyICsxLDEzIEBACiAvKgogICogIENvcHlyaWdodCAoQykgMjAwNywg MjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgotICogIENvcHlyaWdodCAoQykgMjAwNywg MjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBpbWVuZGlvLmNvbT4KKyAqICBDb3B5cmln aHQgKEMpIDIwMDcsIDIwMDgsIDIwMDkgQ2hyaXN0aWFuIER5d2FuIDxjaHJpc3RpYW5AaW1lbmRp by5jb20+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA3IFhhbiBMb3BleiA8eGFuQGdub21lLm9yZz4K ICAqICBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggQWxwIFRva2VyIDxhbHBAYXRva2VyLmNvbT4K ICAqICBDb3B5cmlnaHQgKEMpIDIwMDggSmFuIEFsb256byA8am1hbG9uem9AdW5wbHVnZ2FibGUu Y29tPgogICogIENvcHlyaWdodCAoQykgMjAwOCBHdXN0YXZvIE5vcm9uaGEgU2lsdmEgPGduc0Bn bm9tZS5vcmc+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4IE51YW50aSBMdGQuCiAgKiAgQ29weXJp Z2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCisgKiAgQ29weXJpZ2h0IChDKSAyMDA5IElnYWxp YSBTLkwuCiAgKgogICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkBAIC01NiwxMCArNTcsMTAgQEAKICNpbmNsdWRl ICJJbnNwZWN0b3JDbGllbnRHdGsuaCIKICNpbmNsdWRlICJGcmFtZUxvYWRlci5oIgogI2luY2x1 ZGUgIkZyYW1lVmlldy5oIgotI2luY2x1ZGUgIkVkaXRvci5oIgogI2luY2x1ZGUgIlBhc3RlYm9h cmRIZWxwZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUtleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRl ICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKKyNpbmNsdWRlICJSZXNvdXJjZUhhbmRsZS5oIgogI2lu Y2x1ZGUgIlNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFyLmgiCiAjaW5jbHVkZSA8 d3RmL0dPd25QdHIuaD4KQEAgLTI3MzgsNCArMjczOSwyMSBAQCB2b2lkIHdlYmtpdF93ZWJfdmll d19zZXRfZnVsbF9jb250ZW50X3pvb20oV2ViS2l0V2ViVmlldyogd2ViVmlldywgZ2Jvb2xlYW4g em9vbQogICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVDVCh3ZWJWaWV3KSwgImZ1bGwtY29udGVu dC16b29tIik7CiB9CiAKKy8qKgorICogd2Via2l0X2dldF9kZWZhdWx0X3Nlc3Npb246CisgKgor ICogUmV0cmlldmVzIHRoZSBkZWZhdWx0ICNTb3VwU2Vzc2lvbiB1c2VkIGJ5IGFsbCB3ZWIgdmll d3MuCisgKiBOb3RlIHRoYXQgdGhlIHNlc3Npb24gZmVhdHVyZXMgYXJlIGFkZGVkIGJ5IFdlYktp dCBvbiBkZW1hbmQsCisgKiBzbyBpZiB5b3UgaW5zZXJ0IHlvdXIgb3duICNTb3VwQ29va2llSmFy IGJlZm9yZSBhbnkgbmV0d29yaworICogdHJhZmZpYyBvY2N1cnMsIFdlYktpdCB3aWxsIHVzZSBp dCBpbnN0ZWFkIG9mIHRoZSBkZWZhdWx0LgorICoKKyAqIFJldHVybiB2YWx1ZTogdGhlIGRlZmF1 bHQgI1NvdXBTZXNzaW9uCisgKgorICogU2luY2U6IDEuMS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3 ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAoKQoreworICAgIHJldHVybiBSZXNvdXJjZUhhbmRs ZTo6ZGVmYXVsdFNlc3Npb24oKTsKK30KKwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJr aXQvd2Via2l0d2Vidmlldy5oIGIvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oCmlu ZGV4IDg2MGMwZDAuLjRjYzM1NjkgMTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtp dHdlYnZpZXcuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmgKQEAgLTIz LDYgKzIzLDcgQEAKICNkZWZpbmUgV0VCS0lUX1dFQl9WSUVXX0gKIAogI2luY2x1ZGUgPGd0ay9n dGsuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9KU0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93ZWJraXRkZWZpbmVzLmg+CkBAIC0zMDQs NiArMzA1LDkgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJraXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29u dGVudF96b29tICAgICAgICAgICAoV2ViS2l0V2ViVmlldyAgICAgICAgKndlYl92aWV3LAogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGdib29sZWFuICAg ICAgICAgICAgICBmdWxsX2NvbnRlbnRfem9vbSk7CiAKK1dFQktJVF9BUEkgU291cFNlc3Npb24q Cit3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAgICAgICAgICAgICAgICAgICAgICAodm9pZCk7 CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgotLSAKMS42LjEKCg== 27875 2009-02-23 02:08:11 -0800 2009-02-23 03:28:51 -0800 defaultsession2.patch defaultsession2.patch text/plain 12658 xan.lopez RnJvbSBlODBjYTMxNzQwNGMxZGEyYzkzMjliMWI0NDIzZjg3MzI2YWY1MzBhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBYYW4gTG9wZXogPHhhbkBnbm9tZS5vcmc+CkRhdGU6IE1vbiwg MjMgRmViIDIwMDkgMTE6NDQ6MDEgKzAyMDAKU3ViamVjdDogW1BBVENIXSBXZWJDb3JlOgoKMjAw OS0wMi0yMyAgWGFuIExvcGV6ICA8eGFuQGdub21lLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCgogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMjYyNAogICAgICAgIFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vz c2lvbiBmcm9tIFdlYktpdC4KCiAgICAgICAgQWxsb3cgdG8gcmV0cmlldmUgdGhlIFNvdXAgc2Vz c2lvbiBhbmQgbW9kaWZ5IHRoZSBjb2RlIHRvIHRha2UKICAgICAgICBpbnRvIGFjY291bnQgdXNl cnMgY2hhbmdpbmcgZmVhdHVyZXMgb24gaXQuCgogICAgICAgICogcGxhdGZvcm0vbmV0d29yay9S ZXNvdXJjZUhhbmRsZS5oOgogICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUph clNvdXAuY3BwOgogICAgICAgIChXZWJDb3JlOjpkZWZhdWx0Q29va2llSmFyKToKICAgICAgICAo V2ViQ29yZTo6c2V0RGVmYXVsdENvb2tpZUphcik6CiAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3Jr L3NvdXAvQ29va2llSmFyU291cC5oOgogICAgICAgICogcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jl c291cmNlSGFuZGxlU291cC5jcHA6CiAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZVNvdXBTZXNzaW9u KToKICAgICAgICAoV2ViQ29yZTo6ZW5zdXJlU2Vzc2lvbklzSW5pdGlhbGl6ZWQpOgogICAgICAg IChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKToKICAgICAgICAoV2ViQ29yZTo6 UmVzb3VyY2VIYW5kbGU6OmNhbmNlbCk6CiAgICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxl OjpkZWZhdWx0U2Vzc2lvbik6CgpXZWJLaXQvZ3RrOgoKMjAwOS0wMi0yMyAgWGFuIExvcGV6ICA8 eGFuQGdub21lLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjYyNAogICAgICAg IFtTT1VQXVtHVEtdIE5lZWQgQVBJIHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KCiAg ICAgICAgQWRkIEFQSSB0byBnZXQgdGhlIGRlZmF1bHQgc291cCBzZXNzaW9uLgoKICAgICAgICAq IHdlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcDoKICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3 Lmg6Ci0tLQogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDIyICsrKysrKysrCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVzb3VyY2VIYW5k bGUuaCAgICAgICAgICB8ICAgIDggKysrCiBXZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9D b29raWVKYXJTb3VwLmNwcCAgICB8ICAgMzMgKysrKysrKysrKy0tCiBXZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggICAgICB8ICAgIDMgKy0KIC4uLi9wbGF0Zm9y bS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3VwLmNwcCAgIHwgICA1NCArKysrKysrKysr KysrKy0tLS0tLQogV2ViS2l0L2d0ay9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgIDEyICsrKysKIFdlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwICAg ICAgICAgICAgICAgIHwgICAyMiArKysrKysrLQogV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vi dmlldy5oICAgICAgICAgICAgICAgICAgfCAgICA0ICsrCiA4IGZpbGVzIGNoYW5nZWQsIDEzMyBp bnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5n ZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDRkOTg0NDkuLjgyZDQxY2QgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs MjUgQEAKKzIwMDktMDItMjMgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNjI0CisgICAgICAgIFtTT1VQXVtHVEtdIE5lZWQgQVBJ IHRvIGdldCBTb3VwU2Vzc2lvbiBmcm9tIFdlYktpdC4KKworICAgICAgICBBbGxvdyB0byByZXRy aWV2ZSB0aGUgU291cCBzZXNzaW9uIGFuZCBtb2RpZnkgdGhlIGNvZGUgdG8gdGFrZQorICAgICAg ICBpbnRvIGFjY291bnQgdXNlcnMgY2hhbmdpbmcgZmVhdHVyZXMgb24gaXQuCisKKyAgICAgICAg KiBwbGF0Zm9ybS9uZXR3b3JrL1Jlc291cmNlSGFuZGxlLmg6CisgICAgICAgICogcGxhdGZvcm0v bmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZGVmYXVs dENvb2tpZUphcik6CisgICAgICAgIChXZWJDb3JlOjpzZXREZWZhdWx0Q29va2llSmFyKToKKyAg ICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oOgorICAgICAgICAq IHBsYXRmb3JtL25ldHdvcmsvc291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwOgorICAgICAgICAo V2ViQ29yZTo6Y3JlYXRlU291cFNlc3Npb24pOgorICAgICAgICAoV2ViQ29yZTo6ZW5zdXJlU2Vz c2lvbklzSW5pdGlhbGl6ZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVzb3VyY2VIYW5kbGU6OnN0 YXJ0SHR0cCk6CisgICAgICAgIChXZWJDb3JlOjpSZXNvdXJjZUhhbmRsZTo6Y2FuY2VsKToKKyAg ICAgICAgKFdlYkNvcmU6OlJlc291cmNlSGFuZGxlOjpkZWZhdWx0U2Vzc2lvbik6CisKIDIwMDkt MDItMTkgIFhhbiBMb3BleiAgPHhhbkBnbm9tZS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvUmVz b3VyY2VIYW5kbGUuaCBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNvdXJjZUhhbmRsZS5o CmluZGV4IGVlOTM3ZjEuLjE0ZjUwY2QgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0 d29yay9SZXNvdXJjZUhhbmRsZS5oCisrKyBiL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9SZXNv dXJjZUhhbmRsZS5oCkBAIC0zMCw2ICszMCwxMCBAQAogI2luY2x1ZGUgIkhUVFBIZWFkZXJNYXAu aCIKICNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CiAKKyNpZiBVU0UoU09VUCkKK3R5cGVkZWYgc3Ry dWN0IF9Tb3VwU2Vzc2lvbiBTb3VwU2Vzc2lvbjsKKyNlbmRpZgorCiAjaWYgUExBVEZPUk0oQ0Yp CiB0eXBlZGVmIGNvbnN0IHN0cnVjdCBfX0NGRGF0YSAqIENGRGF0YVJlZjsKICNlbmRpZgpAQCAt MTU5LDYgKzE2MywxMCBAQCBwdWJsaWM6CiAgICAgUmVzb3VyY2VIYW5kbGVJbnRlcm5hbCogZ2V0 SW50ZXJuYWwoKSB7IHJldHVybiBkLmdldCgpOyB9CiAjZW5kaWYKIAorI2lmIFVTRShTT1VQKQor ICAgIHN0YXRpYyBTb3VwU2Vzc2lvbiogZGVmYXVsdFNlc3Npb24oKTsKKyNlbmRpZgorCiAgICAg Ly8gVXNlZCB0byB3b3JrIGFyb3VuZCB0aGUgZmFjdCB0aGF0IHlvdSBkb24ndCBnZXQgYW55IG1v cmUgTlNVUkxDb25uZWN0aW9uIGNhbGxiYWNrcyB1bnRpbCB5b3UgcmV0dXJuIGZyb20gdGhlIG9u ZSB5b3UncmUgaW4uCiAgICAgc3RhdGljIGJvb2wgbG9hZHNCbG9ja2VkKCk7ICAgIAogICAgIApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5j cHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmNwcAppbmRl eCA4ODEwOWU4Li5lMzA2NGUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9Db29raWVKYXJTb3VwLmNwcAorKysgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvc291 cC9Db29raWVKYXJTb3VwLmNwcApAQCAtMSw1ICsxLDYgQEAKIC8qCiAgKiAgQ29weXJpZ2h0IChD KSAyMDA4IFhhbiBMb3BleiA8eGFuQGdub21lLm9yZz4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDkg SWdhbGlhIFMuTC4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDggQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgogICoKICAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0yNSwxNSArMjYsMzUgQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCi1Tb3VwQ29va2llSmFyKiBnZXRDb29raWVKYXIoKQorc3RhdGljIGJvb2wg Y29va2llc0luaXRpYWxpemVkOworc3RhdGljIFNvdXBDb29raWVKYXIqIGNvb2tpZUphcjsKKwor U291cENvb2tpZUphciogZGVmYXVsdENvb2tpZUphcigpCit7CisgICAgaWYgKCFjb29raWVzSW5p dGlhbGl6ZWQpIHsKKyAgICAgICAgY29va2llc0luaXRpYWxpemVkID0gdHJ1ZTsKKyAgICAgICAg c2V0RGVmYXVsdENvb2tpZUphcihzb3VwX2Nvb2tpZV9qYXJfbmV3KCkpOworICAgIH0KKworICAg IHJldHVybiBjb29raWVKYXI7Cit9CisKK3ZvaWQgc2V0RGVmYXVsdENvb2tpZUphcihTb3VwQ29v a2llSmFyKiBqYXIpCiB7Ci0gICAgc3RhdGljIFNvdXBDb29raWVKYXIqIGphciA9IHNvdXBfY29v a2llX2phcl9uZXcoKTsKLSAgICByZXR1cm4gamFyOworICAgIGNvb2tpZXNJbml0aWFsaXplZCA9 IHRydWU7CisKKyAgICBpZiAoY29va2llSmFyKQorICAgICAgICBnX29iamVjdF91bnJlZihjb29r aWVKYXIpOworCisgICAgY29va2llSmFyID0gamFyOworCisgICAgaWYgKGNvb2tpZUphcikKKyAg ICAgICAgZ19vYmplY3RfcmVmKGNvb2tpZUphcik7CiB9CiAKIHZvaWQgc2V0Q29va2llcyhEb2N1 bWVudCogLypkb2N1bWVudCovLCBjb25zdCBLVVJMJiB1cmwsIGNvbnN0IEtVUkwmIC8qcG9saWN5 VVJMKi8sIGNvbnN0IFN0cmluZyYgdmFsdWUpCiB7Ci0gICAgU291cENvb2tpZUphciogamFyID0g Z2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogamFyID0gZGVmYXVsdENvb2tpZUph cigpOwogICAgIGlmICghamFyKQogICAgICAgICByZXR1cm47CiAKQEAgLTQ1LDcgKzY2LDcgQEAg dm9pZCBzZXRDb29raWVzKERvY3VtZW50KiAvKmRvY3VtZW50Ki8sIGNvbnN0IEtVUkwmIHVybCwg Y29uc3QgS1VSTCYgLypwb2xpY3lVUkwKIAogU3RyaW5nIGNvb2tpZXMoY29uc3QgRG9jdW1lbnQq IC8qZG9jdW1lbnQqLywgY29uc3QgS1VSTCYgdXJsKQogewotICAgIFNvdXBDb29raWVKYXIqIGph ciA9IGdldENvb2tpZUphcigpOworICAgIFNvdXBDb29raWVKYXIqIGphciA9IGRlZmF1bHRDb29r aWVKYXIoKTsKICAgICBpZiAoIWphcikKICAgICAgICAgcmV0dXJuIFN0cmluZygpOwogCkBAIC02 MSw3ICs4Miw3IEBAIFN0cmluZyBjb29raWVzKGNvbnN0IERvY3VtZW50KiAvKmRvY3VtZW50Ki8s IGNvbnN0IEtVUkwmIHVybCkKIAogYm9vbCBjb29raWVzRW5hYmxlZChjb25zdCBEb2N1bWVudCog Lypkb2N1bWVudCovKQogewotICAgIHJldHVybiBnZXRDb29raWVKYXIoKTsKKyAgICByZXR1cm4g ZGVmYXVsdENvb2tpZUphcigpOwogfQogCiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BsYXRmb3Jt L25ldHdvcmsvc291cC9Db29raWVKYXJTb3VwLmggYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9Db29raWVKYXJTb3VwLmgKaW5kZXggNjExNzlhZS4uYWIxZjk1YyAxMDA2NDQKLS0tIGEv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvQ29va2llSmFyU291cC5oCisrKyBiL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL0Nvb2tpZUphclNvdXAuaApAQCAtMzEsNyArMzEsOCBA QAogI2luY2x1ZGUgPGxpYnNvdXAvc291cC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7Ci0gICAg U291cENvb2tpZUphciogZ2V0Q29va2llSmFyKCk7CisgICAgU291cENvb2tpZUphciogZGVmYXVs dENvb2tpZUphcigpOworICAgIHZvaWQgc2V0RGVmYXVsdENvb2tpZUphcihTb3VwQ29va2llSmFy KiBqYXIpOwogfQogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29y ay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5jcHAgYi9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsv c291cC9SZXNvdXJjZUhhbmRsZVNvdXAuY3BwCmluZGV4IDNjNDgwNTIuLjg4MmZiMTkgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9zb3VwL1Jlc291cmNlSGFuZGxlU291cC5j cHAKKysrIGIvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL3NvdXAvUmVzb3VyY2VIYW5kbGVTb3Vw LmNwcApAQCAtNCw2ICs0LDggQEAKICAqIENvcHlyaWdodCAoQykgMjAwOCBDb2xsYWJvcmEgTHRk LgogICogQ29weXJpZ2h0IChDKSAyMDA5IEhvbGdlciBIYW5zIFBldGVyIEZyZXl0aGVyCiAgKiBD b3B5cmlnaHQgKEMpIDIwMDkgR3VzdGF2byBOb3JvbmhhIFNpbHZhIDxnbnNAZ25vbWUub3JnPgor ICogQ29weXJpZ2h0IChDKSAyMDA5IENocmlzdGlhbiBEeXdhbiA8Y2hyaXN0aWFuQGltZW5kaW8u Y29tPgorICogQ29weXJpZ2h0IChDKSAyMDA5IElnYWxpYSBTLkwuCiAgKgogICogVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICog bW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMKQEAgLTU1LDggKzU3LDYgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1zdGF0aWMgU291 cFNlc3Npb24qIHNlc3Npb24gPSAwOwotCiBjbGFzcyBXZWJDb3JlU3luY2hyb25vdXNMb2FkZXIg OiBwdWJsaWMgUmVzb3VyY2VIYW5kbGVDbGllbnQsIE5vbmNvcHlhYmxlIHsKIHB1YmxpYzoKICAg ICBXZWJDb3JlU3luY2hyb25vdXNMb2FkZXIoUmVzb3VyY2VFcnJvciYsIFJlc291cmNlUmVzcG9u c2UgJiwgVmVjdG9yPGNoYXI+Jik7CkBAIC0zNjUsMjIgKzM2NSwzNyBAQCBib29sIFJlc291cmNl SGFuZGxlOjpzdGFydERhdGEoU3RyaW5nIHVybFN0cmluZykKICAgICByZXR1cm4gdHJ1ZTsKIH0K IAotYm9vbCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCitzdGF0 aWMgU291cFNlc3Npb24qIGNyZWF0ZVNvdXBTZXNzaW9uKCkKIHsKLSAgICBpZiAoIXNlc3Npb24p IHsKLSAgICAgICAgc2Vzc2lvbiA9IHNvdXBfc2Vzc2lvbl9hc3luY19uZXcoKTsKLQotICAgICAg ICBzb3VwX3Nlc3Npb25fYWRkX2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9TRVNTSU9OX0ZFQVRVUkUo Z2V0Q29va2llSmFyKCkpKTsKLQotICAgICAgICBjb25zdCBjaGFyKiBzb3VwX2RlYnVnID0gZ19n ZXRlbnYoIldFQktJVF9TT1VQX0xPR0dJTkciKTsKLSAgICAgICAgaWYgKHNvdXBfZGVidWcpIHsK LSAgICAgICAgICAgIGludCBzb3VwX2RlYnVnX2xldmVsID0gYXRvaShzb3VwX2RlYnVnKTsKKyAg ICByZXR1cm4gc291cF9zZXNzaW9uX2FzeW5jX25ldygpOworfQogCi0gICAgICAgICAgICBTb3Vw TG9nZ2VyKiBsb2dnZXIgPSBzb3VwX2xvZ2dlcl9uZXcoc3RhdGljX2Nhc3Q8U291cExvZ2dlckxv Z0xldmVsPihzb3VwX2RlYnVnX2xldmVsKSwgLTEpOwotICAgICAgICAgICAgc291cF9sb2dnZXJf YXR0YWNoKGxvZ2dlciwgc2Vzc2lvbik7Ci0gICAgICAgICAgICBnX29iamVjdF91bnJlZihsb2dn ZXIpOwotICAgICAgICB9CitzdGF0aWMgdm9pZCBlbnN1cmVTZXNzaW9uSXNJbml0aWFsaXplZChT b3VwU2Vzc2lvbiogc2Vzc2lvbikKK3sKKyAgICBpZiAoZ19vYmplY3RfZ2V0X2RhdGEoR19PQkpF Q1Qoc2Vzc2lvbiksICJ3ZWJraXQtaW5pdCIpKQorICAgICAgICByZXR1cm47CisgCisgICAgU291 cENvb2tpZUphciogamFyID0gcmVpbnRlcnByZXRfY2FzdDxTb3VwQ29va2llSmFyKj4oc291cF9z ZXNzaW9uX2dldF9mZWF0dXJlKHNlc3Npb24sIFNPVVBfVFlQRV9DT09LSUVfSkFSKSk7CisgICAg aWYgKCFqYXIpCisgICAgICAgIHNvdXBfc2Vzc2lvbl9hZGRfZmVhdHVyZShzZXNzaW9uLCBTT1VQ X1NFU1NJT05fRkVBVFVSRShkZWZhdWx0Q29va2llSmFyKCkpKTsKKyAgICBlbHNlCisgICAgICAg IHNldERlZmF1bHRDb29raWVKYXIoamFyKTsKKworICAgIGNvbnN0IGNoYXIqIHdlYmtpdF9kZWJ1 ZyA9IGdfZ2V0ZW52KCJXRUJLSVRfREVCVUciKTsgCisgICAgaWYgKCFzb3VwX3Nlc3Npb25fZ2V0 X2ZlYXR1cmUoc2Vzc2lvbiwgU09VUF9UWVBFX0xPR0dFUikKKyAgICAgICAgJiYgd2Via2l0X2Rl YnVnICYmICFzdHJjbXAod2Via2l0X2RlYnVnLCAibmV0d29yayIpKSB7CisgICAgICAgIFNvdXBM b2dnZXIqIGxvZ2dlciA9IHNvdXBfbG9nZ2VyX25ldyhzdGF0aWNfY2FzdDxTb3VwTG9nZ2VyTG9n TGV2ZWw+KFNPVVBfTE9HR0VSX0xPR19CT0RZKSwgLTEpOworICAgICAgICBzb3VwX2xvZ2dlcl9h dHRhY2gobG9nZ2VyLCBzZXNzaW9uKTsKKyAgICAgICAgZ19vYmplY3RfdW5yZWYobG9nZ2VyKTsK ICAgICB9CisgCisgICAgZ19vYmplY3Rfc2V0X2RhdGEoR19PQkpFQ1Qoc2Vzc2lvbiksICJ3ZWJr aXQtaW5pdCIsIHJlaW50ZXJwcmV0X2Nhc3Q8dm9pZCo+KDB4ZGVhZGJlZWYpKTsKK30KKworYm9v bCBSZXNvdXJjZUhhbmRsZTo6c3RhcnRIdHRwKFN0cmluZyB1cmxTdHJpbmcpCit7CisgICAgU291 cFNlc3Npb24qIHNlc3Npb24gPSBkZWZhdWx0U2Vzc2lvbigpOworICAgIGVuc3VyZVNlc3Npb25J c0luaXRpYWxpemVkKHNlc3Npb24pOwogCiAgICAgU291cE1lc3NhZ2UqIG1zZzsKICAgICBtc2cg PSBzb3VwX21lc3NhZ2VfbmV3KHJlcXVlc3QoKS5odHRwTWV0aG9kKCkudXRmOCgpLmRhdGEoKSwg dXJsU3RyaW5nLnV0ZjgoKS5kYXRhKCkpOwpAQCAtNTA1LDcgKzUyMCw3IEBAIHZvaWQgUmVzb3Vy Y2VIYW5kbGU6OmNhbmNlbCgpCiB7CiAgICAgZC0+bV9jYW5jZWxsZWQgPSB0cnVlOwogICAgIGlm IChkLT5tX21zZykgewotICAgICAgICBzb3VwX3Nlc3Npb25fY2FuY2VsX21lc3NhZ2Uoc2Vzc2lv biwgZC0+bV9tc2csIFNPVVBfU1RBVFVTX0NBTkNFTExFRCk7CisgICAgICAgIHNvdXBfc2Vzc2lv bl9jYW5jZWxfbWVzc2FnZShkZWZhdWx0U2Vzc2lvbigpLCBkLT5tX21zZywgU09VUF9TVEFUVVNf Q0FOQ0VMTEVEKTsKICAgICAgICAgLy8gRm9yIHJlLWVudHJhbmN5IHRyb3VibGVzIHdlIGNhbGwg ZGlkRmluaXNoTG9hZGluZyB3aGVuIHRoZSBtZXNzYWdlIGhhc24ndCBiZWVuIGhhbmRsZWQgeWV0 LgogICAgICAgICBpZiAoY2xpZW50KCkpCiAgICAgICAgICAgICBjbGllbnQoKS0+ZGlkRmluaXNo TG9hZGluZyh0aGlzKTsKQEAgLTc3Myw1ICs3ODgsMTIgQEAgYm9vbCBSZXNvdXJjZUhhbmRsZTo6 c3RhcnRHaW8oS1VSTCB1cmwpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKK1NvdXBTZXNzaW9uKiBS ZXNvdXJjZUhhbmRsZTo6ZGVmYXVsdFNlc3Npb24oKQoreworICAgIHN0YXRpYyBTb3VwU2Vzc2lv biogc2Vzc2lvbiA9IGNyZWF0ZVNvdXBTZXNzaW9uKCk7OworCisgICAgcmV0dXJuIHNlc3Npb247 Cit9CisKIH0KIApkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9XZWJLaXQvZ3Rr L0NoYW5nZUxvZwppbmRleCA1OGJiMWVmLi42ZGZlYjVlIDEwMDY0NAotLS0gYS9XZWJLaXQvZ3Rr L0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisy MDA5LTAyLTIzICBYYW4gTG9wZXogIDx4YW5AZ25vbWUub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMjYyNAorICAgICAgICBbU09VUF1bR1RLXSBOZWVkIEFQSSB0byBnZXQg U291cFNlc3Npb24gZnJvbSBXZWJLaXQuCisKKyAgICAgICAgQWRkIEFQSSB0byBnZXQgdGhlIGRl ZmF1bHQgc291cCBzZXNzaW9uLgorCisgICAgICAgICogd2Via2l0L3dlYmtpdHdlYnZpZXcuY3Bw OgorICAgICAgICAqIHdlYmtpdC93ZWJraXR3ZWJ2aWV3Lmg6CisKIDIwMDktMDItMTkgIFhhbiBM b3BleiAgPHhhbkBnbm9tZS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3dlYmtpdC93ZWJraXR3ZWJ2aWV3LmNwcCBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCmluZGV4IDQ5NGEyNmYuLmIwNGVmMDUg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCisrKyBiL1dl YktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuY3BwCkBAIC0xLDEyICsxLDEzIEBACiAvKgog ICogIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBIb2xnZXIgSGFucyBQZXRlciBGcmV5dGhlcgot ICogIENvcHlyaWdodCAoQykgMjAwNywgMjAwOCBDaHJpc3RpYW4gRHl3YW4gPGNocmlzdGlhbkBp bWVuZGlvLmNvbT4KKyAqICBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDgsIDIwMDkgQ2hyaXN0aWFu IER5d2FuIDxjaHJpc3RpYW5AaW1lbmRpby5jb20+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA3IFhh biBMb3BleiA8eGFuQGdub21lLm9yZz4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDcsIDIwMDggQWxw IFRva2VyIDxhbHBAYXRva2VyLmNvbT4KICAqICBDb3B5cmlnaHQgKEMpIDIwMDggSmFuIEFsb256 byA8am1hbG9uem9AdW5wbHVnZ2FibGUuY29tPgogICogIENvcHlyaWdodCAoQykgMjAwOCBHdXN0 YXZvIE5vcm9uaGEgU2lsdmEgPGduc0Bnbm9tZS5vcmc+CiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4 IE51YW50aSBMdGQuCiAgKiAgQ29weXJpZ2h0IChDKSAyMDA4IENvbGxhYm9yYSBMdGQuCisgKiAg Q29weXJpZ2h0IChDKSAyMDA5IElnYWxpYSBTLkwuCiAgKgogICogIFRoaXMgbGlicmFyeSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICAqICBtb2RpZnkg aXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkBAIC01 NiwxMCArNTcsMTAgQEAKICNpbmNsdWRlICJJbnNwZWN0b3JDbGllbnRHdGsuaCIKICNpbmNsdWRl ICJGcmFtZUxvYWRlci5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgotI2luY2x1ZGUgIkVkaXRv ci5oIgogI2luY2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUtl eWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybVdoZWVsRXZlbnQuaCIKKyNpbmNsdWRl ICJSZXNvdXJjZUhhbmRsZS5oIgogI2luY2x1ZGUgIlNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSAi U2Nyb2xsYmFyLmgiCiAjaW5jbHVkZSA8d3RmL0dPd25QdHIuaD4KQEAgLTI3MzgsNCArMjczOSwy MSBAQCB2b2lkIHdlYmtpdF93ZWJfdmlld19zZXRfZnVsbF9jb250ZW50X3pvb20oV2ViS2l0V2Vi Vmlldyogd2ViVmlldywgZ2Jvb2xlYW4gem9vbQogICAgIGdfb2JqZWN0X25vdGlmeShHX09CSkVD VCh3ZWJWaWV3KSwgImZ1bGwtY29udGVudC16b29tIik7CiB9CiAKKy8qKgorICogd2Via2l0X2dl dF9kZWZhdWx0X3Nlc3Npb246CisgKgorICogUmV0cmlldmVzIHRoZSBkZWZhdWx0ICNTb3VwU2Vz c2lvbiB1c2VkIGJ5IGFsbCB3ZWIgdmlld3MuCisgKiBOb3RlIHRoYXQgdGhlIHNlc3Npb24gZmVh dHVyZXMgYXJlIGFkZGVkIGJ5IFdlYktpdCBvbiBkZW1hbmQsCisgKiBzbyBpZiB5b3UgaW5zZXJ0 IHlvdXIgb3duICNTb3VwQ29va2llSmFyIGJlZm9yZSBhbnkgbmV0d29yaworICogdHJhZmZpYyBv Y2N1cnMsIFdlYktpdCB3aWxsIHVzZSBpdCBpbnN0ZWFkIG9mIHRoZSBkZWZhdWx0LgorICoKKyAq IFJldHVybiB2YWx1ZTogdGhlIGRlZmF1bHQgI1NvdXBTZXNzaW9uCisgKgorICogU2luY2U6IDEu MS4xCisgKi8KK1NvdXBTZXNzaW9uKiB3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAoKQorewor ICAgIHJldHVybiBSZXNvdXJjZUhhbmRsZTo6ZGVmYXVsdFNlc3Npb24oKTsKK30KKwogfQpkaWZm IC0tZ2l0IGEvV2ViS2l0L2d0ay93ZWJraXQvd2Via2l0d2Vidmlldy5oIGIvV2ViS2l0L2d0ay93 ZWJraXQvd2Via2l0d2Vidmlldy5oCmluZGV4IDg2MGMwZDAuLjRjYzM1NjkgMTAwNjQ0Ci0tLSBh L1dlYktpdC9ndGsvd2Via2l0L3dlYmtpdHdlYnZpZXcuaAorKysgYi9XZWJLaXQvZ3RrL3dlYmtp dC93ZWJraXR3ZWJ2aWV3LmgKQEAgLTIzLDYgKzIzLDcgQEAKICNkZWZpbmUgV0VCS0lUX1dFQl9W SUVXX0gKIAogI2luY2x1ZGUgPGd0ay9ndGsuaD4KKyNpbmNsdWRlIDxsaWJzb3VwL3NvdXAuaD4K ICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU0Jhc2UuaD4KIAogI2luY2x1ZGUgPHdlYmtpdC93 ZWJraXRkZWZpbmVzLmg+CkBAIC0zMDQsNiArMzA1LDkgQEAgV0VCS0lUX0FQSSB2b2lkCiB3ZWJr aXRfd2ViX3ZpZXdfc2V0X2Z1bGxfY29udGVudF96b29tICAgICAgICAgICAoV2ViS2l0V2ViVmll dyAgICAgICAgKndlYl92aWV3LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGdib29sZWFuICAgICAgICAgICAgICBmdWxsX2NvbnRlbnRfem9vbSk7CiAK K1dFQktJVF9BUEkgU291cFNlc3Npb24qCit3ZWJraXRfZ2V0X2RlZmF1bHRfc2Vzc2lvbiAgICAg ICAgICAgICAgICAgICAgICAodm9pZCk7CisKIEdfRU5EX0RFQ0xTCiAKICNlbmRpZgotLSAKMS42 LjEKCg==