29248 2009-09-14 11:08:13 -0700 [Qt] [API] Make it possible to have 'invisible' loads 2009-10-28 08:11:28 -0700 1 1 1 Unclassified WebKit WebKit Qt 528+ (Nightly build) PC All RESOLVED FIXED Qt P2 Normal --- 29731 1 tonikitoo tonikitoo ariya.hidayat beidson eric fishd hausmann kenneth vestbo oldest_to_newest 147115 0 tonikitoo 2009-09-14 11:08:13 -0700 For substitution loads (e.g. setHtml, setContent and friends) it could be a nice add to the API to make it possible to have what we've calling 'invisible' loads. Feature basically consists in loading a given HTML content (for now lets consider it a QString): 1) w/o necessarely changing WebCore's backforward and global history content. 2) w/o getting loading signals emitted ========== * Use case * ========== 1) user enter a valid url (http://www.google.com) then enters any non-existent url (e.g. http://xxx.yyy). The client browser might want to feedback the user about the loading error, maybe by calling setHtml() passing in some loading error template page. The problem is that currently setHtml starts a completely new load. so in our backforward history content one would end up w/ -> google.com -> xxx.yyy -> baseUrl passed in to setHtml, if any. Desired backforward content is: -> google.com -> xxx.yyy (the error page shown). So calling RELOAD, back or forward would work as user expect. ================== * Proposed solution * ================== A working solution (not ready yet for a final review) I would like to request comments for is attached (patch v0.1). It basically overloads the existenting QWebFrame::setHtml method, extending the way it works if some parameters are passed in. If the approach is good, it could get into setContent() method too in the same way. Some points are still to be properly defined, for example: About (2), I am sure if not emitting all load signals is good, or just 'urlChanged' (as currently in the patch). please comments are welcome. ps: not autotests yet, but existent tests passed. ps: no difference in layout-test results after the changes in webcore. 147116 1 39556 tonikitoo 2009-09-14 11:12:14 -0700 Created attachment 39556 patch v0.1 - basic invisible load impl first implementation draft 147133 2 kenneth 2009-09-14 12:23:37 -0700 So basically I didn't like this API very much. It is hard to use and provides more power than I think the users need. Your MainFrameLoadMode (ugly name) is a flag, but that is not obvious. Actually I would prefer a LoadMode enum (NormalLoad, SubstitutionLoad) and the substitution load would do the following exclude global/session history and not modify the internal url, thus still making url() and requestedUrl() return the previous url. Thus the substitution is transparent. Maybe this is hard to implement and because of this you decided to block some events, but at least this doesn't have to be exposed in the API. 147134 3 kenneth 2009-09-14 12:25:23 -0700 + void setHtml(const QString &html, const QUrl &baseUrl, const QUrl &substituteUrl, LoadMode mode); setHtml taking a substitution url? That just seems wrong, a load() method should be used for this, thus implement a load(..) that takes a LoadMode as well. 147218 4 39578 tonikitoo 2009-09-14 15:53:11 -0700 Created attachment 39578 patch v0.1.1 - basic invisible load impl cleaner patch 147238 5 kenneth 2009-09-14 18:25:27 -0700 (In reply to comment #4) > Created an attachment (id=39578) [details] > patch v0.1.1 - basic invisible load impl > > cleaner patch You ought to tell what you have changed, so we don't have to diff the patches. Basically it doesn't seem to fix any of my concerns. Looking at the patch I see +/* + \since 4.6 + Returns if a given url \a url is in the history. +*/ +int QWebHistory::contains(const QUrl& url) cons I guess this could/should be separate bug. Maybe it should even be called something like findUrl, to indicate that it might be an expensive function call. + void setEnabled(bool status); A setEnabled method taking a bool called status? status is a very bad variable name not indicating whether it will be enabled or disabled. Qt normally uses 'on'. You should always look at the Qt class libraries for creating similar API. +/* + \since 4.6 + Returns if the history is in 'locked' state or not. + \sa setEnabled() +*/ +bool QWebHistory::isEnabled() const This comment leds to be think that the name "enabled" might not be a good fit. Try not to make unnecessary changes: - m_loadError = ResourceError(); // clears the previous error + // clears the previous load data + m_loadError = ResourceError(); You made it possible to enable/disable history, but in the FrameLoaderClientQt I found a line where you always enable it! regarding on what the current state is. That seems like a bug: @@ -376,7 +376,10 @@ void FrameLoaderClientQt::dispatchDidFinishLoad() + m_webFrame->d->page->history()->setEnabled(true); Regarding +++ b/WebCore/loader/FrameLoader.cpp @@ -3379,7 +3379,7 @@ void FrameLoader::checkLoadCompleteForThisFrame() - if (shouldReset && item) + if (shouldReset && item && (item == m_currentHistoryItem)) This affects all ports, and it is not clear for me what effect it will have. Maybe make it another bug? This as well: - void setEnabled(bool); + void setEnabled(bool enabled, bool clear = true); 147241 6 kenneth 2009-09-14 18:44:42 -0700 To me + void setEnabled(bool enabled, bool clear = true); seems a bit backward. So the WebCore setEnabled always clears history. So maybe it would be better to separate our the clear code of setEnabled to a clear() method (many webcore classes have clear() members) and make setEnabled() call clear() and enable the history. If very little code is using the setEnabled method, you can change that to call clear() and then setEnabled(true) If that is not the case, I would suggest that you make another method called setLocked() or so, and make setEnabled(true) call clear() + setLocked(false). This might be less desirable though. 147242 7 kenneth 2009-09-14 18:47:10 -0700 > ps: no difference in layout-test results after the changes in webcore. Running with Qt or mac? We [Qt] only checks like 50% of the tests available. 147243 8 kenneth 2009-09-14 18:51:16 -0700 (In reply to comment #7) > > ps: no difference in layout-test results after the changes in webcore. > > Running with Qt or mac? We [Qt] only checks like 50% of the tests available. I know you don't have a mac :-), so what I'm trying to say is that if you were making a Qt specific change (let's say to FontQt.cpp) then this would be a sufficient test for us, but this is a cross platform change. If it breaks mac or so, it will just get reverted. Keep that in mind. This is really the reason why I would like you to commit the WebCore required changes first in a separate patch. 147244 9 kenneth 2009-09-14 18:56:41 -0700 Eric, do you know what Chrome does for showing error pages etc and not touch the session/global history? I'm wondering why we need WebCore changes for this, when Google Chome and Safari obviously don't. 147254 10 eric 2009-09-14 21:39:23 -0700 Bradey or Darin Fisher would know. 147255 11 beidson 2009-09-14 21:45:28 -0700 This is what SubstituteData is fore 147256 12 beidson 2009-09-14 21:46:03 -0700 *sigh* s/fore/for/ 147452 13 39629 tonikitoo 2009-09-15 19:51:55 -0700 Created attachment 39629 patch 0.2 - same functionality, but no touch to WebCore or qwebhistory 147453 14 tonikitoo 2009-09-15 19:55:39 -0700 thanks for the comments. this patch v0.2 does not make changes in WebCore and qwebhistory any more, but keeps the same functionality, so it might easier to understand (In reply to comment #2) > Your MainFrameLoadMode (ugly name) is a flag, but that is not obvious. > > Actually I would prefer a LoadMode enum (NormalLoad, SubstitutionLoad) and the > substitution load would do the following Done. actually I did it as following: * NormalLoad. * SubstitutionLoad -> no back/forward or global history change. use case: a custom home page, that after user navigates ways, it is not desired it to leave any footprint. * NoGlobalHistoryChange -> no global history change for the load. use case: a ErrorPage set maybe we do not need the later flag: we could make 'substitutionLoad' not to block session history but the global, but instead add API for locking the session history as in the previous patches (another bug). > setHtml taking a substitution url? That just seems wrong, a load() method > should be used for this, thus implement a load(..) that takes a LoadMode as > well. /me thinks about it ... > exclude global/session history and not modify the internal url, thus still > making url() and requestedUrl() return the previous url. Thus the substitution is transparent. i am also tending to leave the substituteUrl parameter out (but kept it for this patch version) (In reply to comment #11) > This is what SubstituteData is fore thanks. I was making use of it. but realized that no passing failingUrl to SubstituteData() make history not get changed. 147454 15 kenneth 2009-09-15 19:56:41 -0700 Mid-air collision, reposting! So what about the concerns that I have raised? like setHtml taking an url etc. Are you going to solve these? If you disagree (or are uncertain) with any of them, let's have the discussion here so that everyone can join. 147455 16 39630 tonikitoo 2009-09-15 19:57:12 -0700 Created attachment 39630 patch 0.2.1 - same functionality as 0.2, but right changelog 147456 17 kenneth 2009-09-15 20:02:13 -0700 > Done. actually I did it as following: > > * NormalLoad. > * SubstitutionLoad -> no back/forward or global history change. > use case: a custom home page, that after user navigates ways, it is not desired > it to leave any footprint. > * NoGlobalHistoryChange -> no global history change for the load. > use case: a ErrorPage set Ah, I like that more. > maybe we do not need the later flag: we could make 'substitutionLoad' not to > block session history but the global, but instead add API for locking the > session history as in the previous patches (another bug). Yes, I dont think the latter is needed, thought I didn't really understand what you said above. Can you explain the differences between the two usecases a bit more clear, please? > > setHtml taking a substitution url? That just seems wrong, a load() method > > should be used for this, thus implement a load(..) that takes a LoadMode as > > well. > > /me thinks about it ... load methods takes urls, setHtml methods takes "data". So let's not mix those two :-) > i am also tending to leave the substituteUrl parameter out (but kept it for > this patch version) Please do. > (In reply to comment #11) > > This is what SubstituteData is for > > thanks. I was making use of it. but realized that no passing failingUrl to > SubstituteData() make history not get changed. Can you enlighten me on, why it changes the history (session? global?) when you give it a failingUrl? What is that failing url for? showing error pages, maybe? :-) 147458 18 kenneth 2009-09-15 20:04:10 -0700 + if (mode == StandardLoad) + return setHtml(html, baseUrl); Don't you think you should modify the original setHtml to call this one? now that you cannot modify it due to binary compatibility. It just seems more right to me. 147459 19 kenneth 2009-09-15 20:07:18 -0700 Another thing that I stumbled on. + enum LoadMode { + NoGlobalHistoryChange = 0x2, + SubstitutionLoad = 0x4, + StandardLoad = 0x8 + }; Why the 0x2 etc? This isn't supposed to be a flag right? If so I would also have preferred it to be called LoadModeFlag or so. 147461 20 kenneth 2009-09-15 20:14:06 -0700 Maybe a stupid question, but why does the void setHtml(const QString &html, const QUrl &baseUrl = QUrl()); function modify the session and global history? and emit urlChanged(). It really does that? or is that a bug? I still like the idea of specifying a load type when calling load(...) 147467 21 tonikitoo 2009-09-15 21:22:14 -0700 > load methods takes urls, setHtml methods takes "data". So let's not mix those > two :-) in my mind, that is what substituteUrl would stands for here. case_1) -> suppose we want to load a "about:plugins" url via setHtml. how to do it ? since current setHtml implementation does not let one to pass the Url being loaded (but only data and baseUrl), WebCore would never know that "about:plugins" is being loaded. What people do is to abuse the meaning of 'baseUrl', and pass the Url to be referred internally by WebCore as the baseUrl. so w/ current API we would do this: frame->setHtml("<html> about:plugin data</hmtl>", "about:plugins"); in the case the html data has relative paths to be resolved, then the "baseUrl" meaning can not be "abused" and will have to be the the real "baseUrl". method call would change to frame->setHtml("<html> about:plugin data</hmtl>", "/path/to/data"); case_2) looking at arora's code we see (it is setting a html error page): (...) html = tr("any html code here"); notFoundFrame->setHtml(html, replyUrl); (...) it also does not use baseUrl as baseUrl. Instead it passes the "replyUrl" it is willing to set the page error for, so WebCore can refer to it. That way, RELOADs will try to load "replyUrl". But what is the html data string had relative paths to be resolved ? imho, it might be a dangerious thing. w/ the substitutionUrl parameter, it'd be (...) notFoundFrame->setHtml(html, baseUrl, replyUrl); (...) > Can you enlighten me on, why it changes the history (session? global?) when you > give it a failingUrl? What is that failing url for? showing error pages, maybe? > :-) so when a valid SubstituteData is passed to FrameLoader::load(), a 'StandardFrameLoadType' is happenning (history is touched and blablabla). However, while the documentLoader is getting committed, it calls FrameLoader::updateHistoryForStandardLoad(). In the method body there is a check const KURL& historyURL = documentLoader()->urlForHistory(); if (!historyURL.isEmpty()) { addBackForwardItemClippedAtTarget(true); <--- session history m_client->updateGlobalHistory(); <--- global history for valid substituteData, urlForHistory calls unreachableURL() that called substitute.failingUrl . so if we pass no failingUrl to substitute data, there is no URL to be added to history. was it clear ? > + enum LoadMode { > + NoGlobalHistoryChange = 0x2, > + SubstitutionLoad = 0x4, > + StandardLoad = 0x8 > + }; > > Why the 0x2 etc? This isn't supposed to be a flag right? If so I would also > have preferred it to be called LoadModeFlag or so. they are not flags but simple enum's now. > void setHtml(const QString &html, const QUrl &baseUrl = QUrl()); > > function modify the session and global history? and emit urlChanged(). It > really does that? or is that a bug? yes ; yes ; yes ; not sure if it is a bug. maybe a LACK in WebCore. 147471 22 kenneth 2009-09-15 22:09:49 -0700 (In reply to comment #21) > > load methods takes urls, setHtml methods takes "data". So let's not mix those > > two :-) > > in my mind, that is what substituteUrl would stands for here. I disagree... more comments below > frame->setHtml("<html> about:plugin data</hmtl>", "about:plugins"); > (...) > html = tr("any html code here"); > notFoundFrame->setHtml(html, replyUrl); > (...) To me the above is abusing the API like using a trick. And we could provide a better API for this and not make our current one even worse this could clearly be html = "some html error message"; frame->setHtml(html, QUrl(), SubstitutionLoad); But as I said before, to me it seems like a bug that setHtml changes the url/history. > w/ the substitutionUrl parameter, it'd be > > (...) > notFoundFrame->setHtml(html, baseUrl, replyUrl); > (...) notFoundFrame->setHtml(html, baseUrl, SubstitutionLoad) should do. Actually when looking at the method, "Load" seems wrong. Maybe we should use Data instead SubstituteData, NormalData ... This even seems very similar to what WebCore apted for. > so when a valid SubstituteData is passed to FrameLoader::load(), a > 'StandardFrameLoadType' is happenning (history is touched and blablabla). > However, while the documentLoader is getting committed, it calls > FrameLoader::updateHistoryForStandardLoad(). In the method body there is a > check > > const KURL& historyURL = documentLoader()->urlForHistory(); > if (!historyURL.isEmpty()) { > addBackForwardItemClippedAtTarget(true); <--- session history > m_client->updateGlobalHistory(); <--- global history > > for valid substituteData, urlForHistory calls unreachableURL() that called > substitute.failingUrl . so if we pass no failingUrl to substitute data, there > is no URL to be added to history. > > was it clear ? So the failingUrl is more or less like your substituteUrl. > they are not flags but simple enum's now. Then please remove the = 0x2 etc. > > void setHtml(const QString &html, const QUrl &baseUrl = QUrl()); > > > > function modify the session and global history? and emit urlChanged(). It > > really does that? or is that a bug? > > yes ; yes ; yes ; not sure if it is a bug. maybe a LACK in WebCore. It depends on the behaviour we expect from the method. Personally I believe that the method should not touch session or global history, though there might be situations you want to to clear the internally url. If that behaviour could be fixed, I would be happy, and I think that will serve for many of our situations. Then we could try to make load(...) more powerful by allowing to specify LoadType and maybe a failingUrl. 148056 23 39630 hausmann 2009-09-18 06:25:43 -0700 Comment on attachment 39630 patch 0.2.1 - same functionality as 0.2, but right changelog I'm going to say r-, but I agree with the concept and the need to have this functionality. First of all this patch is lacking an autotest. For changes in the loader, etc. we really need an automated test for this. I also admit that I'm not happy about the API. setHtml becomes inconsistent to setContent and with four arguments it becomes quite ugly. If we decide not to change setHtml's behaviour, then I wonder if it would be easier to have a dedicated function for the job needed, instead of trying to merge this into the setHtml function. Does the error message that you'd like to display as substitute need to be generated dynamically? Could it be a property on the QWebPage? Would it make sense to have an extension in QWebPage that allows the application to provide substitute content in case loading of a url fails? 148058 24 kenneth 2009-09-18 06:30:24 -0700 > I also admit that I'm not happy about the API. setHtml becomes inconsistent to > setContent and with four arguments > it becomes quite ugly. as I said in my comments, I believe that the behaviour of that function is wrong. Why does it make sense for it to insert the baseUrl in the history? That just doesnt seem right to me. As far as I understood it, the base url, is for relative urls inside the html provided. > Does the error message that you'd like to display as substitute need to be > generated dynamically? Could it be a property > on the QWebPage? Most of the time dynamically, yes. On the other hand, this is not just for error pages. It can be used for webcome pages etc (on open new tab etc) > Would it make sense to have an extension in QWebPage that allows the > application to provide substitute content > in case loading of a url fails? I don't think that is the best idea, as that would be a restriction and not work for special pages such as welcome pages. 148061 25 hausmann 2009-09-18 06:41:09 -0700 (In reply to comment #24) > > I also admit that I'm not happy about the API. setHtml becomes inconsistent to > > setContent and with four arguments > > it becomes quite ugly. > > as I said in my comments, I believe that the behaviour of that function is > wrong. Why does it make sense for it to insert the baseUrl in the history? That > just doesnt seem right to me. > > As far as I understood it, the base url, is for relative urls inside the html > provided. > > > Does the error message that you'd like to display as substitute need to be > > generated dynamically? Could it be a property > > on the QWebPage? > > Most of the time dynamically, yes. On the other hand, this is not just for > error pages. It can be used for webcome pages etc (on open new tab etc) Ok, that is another good use-case :) Alternate idea: If all we want to be able to is to disable the history, is it a state we can have on QWebPAge perhaps? (setHistoryEnabled(...)) 148068 26 tonikitoo 2009-09-18 06:55:29 -0700 simon, thanks for looking at it. i have not requested for review yet because i knew these problems w/ the current approach. > As far as I understood it, the base url, is for relative urls inside the html > provided. exactly. as i ponted out previously, arora for example makes use of this fragilily in the API: setHtml("any string error page w/o external resources", requestedUrl) ... it passes the requestedUrl as baseUrl just because the baseUrl goes to history and not because it is needed to resolved relative paths i also agree that sethtml and setcontents need to have the same (similar) method signature/behaviour. simon, in one of the obsolete patches i've added the setEnable method you mentioned about ... although it also required some changes in WebCore/history/BackForwardList.cpp since calling setEnabled(false) method cleans the list. also, after studying and understanding webcore/loader/frameloader.cpp behaviour, i know how the right approach is now. i will detail it here in another comment or post to the -dev mailing list (so maybe brady can give a opnion here) 148073 27 kenneth 2009-09-18 06:58:58 -0700 The setHtml documentation has no info on it changing the url and touching the history KURL kurl(baseUrl); WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), WebCore::String("utf-8"), kurl); The whole problem here is the kurl, as it is being called as failing url The problem is that documentLoader()->urlForHistory(); calls unreachableURL() which returns the failingUrl (according to Antonio) thus we run into this const KURL& historyURL = documentLoader()->urlForHistory(); if (!historyURL.isEmpty()) { addBackForwardItemClippedAtTarget(true); <--- session history m_client->updateGlobalHistory(); <--- global history WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), WebCore::String("utf-8"), KURL()); would fix it. It seems that currently webcore make it possible for you to add an url to the history for the substitute data. For instance I want to show a page but add "about:plugins" to the history. This could be acomplished by adding another setHtml function with another url argument void QWebFrame::setHtml(const QString &html, const QUrl &baseUrl, const QUrl &historyUrl) Example: setHtml("<html><body><img src="kenneth/image.png"></body></html>", QUrl("file:///home")); This will show a page with an image /home/kenneth/image.png and it will add file:///home to the history That seems like unintended behaviour On the other hand I might want the ability to do setHtml("<html><body><img src="kenneth/image.png"></body></html>", QUrl("file:///home"), QUrl("about:arora")); So it will add about:arora to the history and forward/back history 148074 28 tonikitoo 2009-09-18 07:03:27 -0700 exactly, good points. the most important at the moment is to refine the API and decide about the desired behaviour ... and i can adapt the implement for it. (In reply to comment #27) > The setHtml documentation has no info on it changing the url and touching the > history > > KURL kurl(baseUrl); > WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), > WebCore::String("utf-8"), kurl); > > The whole problem here is the kurl, as it is being called as failing url > > The problem is that documentLoader()->urlForHistory(); calls unreachableURL() > which returns the failingUrl (according to Antonio) > > > thus we run into this > const KURL& historyURL = documentLoader()->urlForHistory(); > if (!historyURL.isEmpty()) { > addBackForwardItemClippedAtTarget(true); <--- session history > m_client->updateGlobalHistory(); <--- global history > > WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), > WebCore::String("utf-8"), KURL()); would fix it. > > It seems that currently webcore make it possible for you to add an url to the > history for the substitute data. For instance I want to show a page but add > "about:plugins" to the history. This could be acomplished by adding another > setHtml function with another url argument > > void QWebFrame::setHtml(const QString &html, const QUrl &baseUrl, const QUrl > &historyUrl) > > Example: > > setHtml("<html><body><img src="kenneth/image.png"></body></html>", > QUrl("file:///home")); > > This will show a page with an image /home/kenneth/image.png and it will add > file:///home to the history > > That seems like unintended behaviour > > > On the other hand I might want the ability to do setHtml("<html><body><img > src="kenneth/image.png"></body></html>", QUrl("file:///home"), > QUrl("about:arora")); > > So it will add about:arora to the history and forward/back history 148076 29 kenneth 2009-09-18 07:04:27 -0700 After talking to Simon, we agree that it is questionable whether the setHtml() should add the base url to the history or not, but it is another discussion that can take place on another bug report. 148079 30 hausmann 2009-09-18 07:05:12 -0700 Discussing this with Kent just gave me an alternate idea to fix the API: setHtml("<html>...", QUrl("file://..."), QUrl("..."); is not very readable. I don't know what the difference between the second and third argument is. I would prefer something slightly more readable: QWebLoadRequest request; request.baseUrl = "file://...."; request.mimeType = "text/html"; request.contentData = "<html>.."; request.historyURl = "about:foo"; webFrame->load(request); 148085 31 kenneth 2009-09-18 07:11:55 -0700 (In reply to comment #30) > Discussing this with Kent just gave me an alternate idea to fix the API: Kenneth you mean ;-) > setHtml("<html>...", QUrl("file://..."), QUrl("..."); > > is not very readable. I don't know what the difference between the second and > third argument is. I would prefer something slightly more readable: > > QWebLoadRequest request; > request.baseUrl = "file://...."; > request.mimeType = "text/html"; > request.contentData = "<html>.."; > request.historyURl = "about:foo"; > webFrame->load(request); We could even make QWebLoadRequest inherit from QNetworkRequest! It is a good idea and it is quite extensible. 148086 32 tonikitoo 2009-09-18 07:13:25 -0700 (In reply to comment #31) > (In reply to comment #30) > > Discussing this with Kent just gave me an alternate idea to fix the API: > > Kenneth you mean ;-) > > > setHtml("<html>...", QUrl("file://..."), QUrl("..."); > > > > is not very readable. I don't know what the difference between the second and > > third argument is. I would prefer something slightly more readable: > > > > QWebLoadRequest request; > > request.baseUrl = "file://...."; > > request.mimeType = "text/html"; > > request.contentData = "<html>.."; > > request.historyURl = "about:foo"; > > webFrame->load(request); > > We could even make QWebLoadRequest inherit from QNetworkRequest! > > It is a good idea and it is quite extensible. seconded. i will try out something in that sense. 149215 33 39950 tonikitoo 2009-09-22 15:09:21 -0700 Created attachment 39950 patch 0.3 - make setHtml and setContent to not change history as per API review on IRC, it was decided to make setHtml and setContent not to change session and global history at all. patch 0.3 implements so and adds an autotest that it by calling qwebframe::setHtml in which an image is loaded (baseUrl used) and checks if history has changed (page()->history()->count == 0). patches for other features/improvements in followup bugs. 149653 34 40045 tonikitoo 2009-09-23 21:42:46 -0700 Created attachment 40045 patch 0.3.1 - make setHtml and setContent to not change history * updated to tot. * fixed typo in a method header block. 149741 35 40063 tonikitoo 2009-09-24 06:12:16 -0700 Created attachment 40063 patch 0.3.2 - make setHtml and setContent to not change history (2 same as previous patch, but fixed another typo. 149973 36 hausmann 2009-09-25 04:19:52 -0700 (In reply to comment #35) > Created an attachment (id=40063) [details] > patch 0.3.2 - make setHtml and setContent to not change history (2 > > same as previous patch, but fixed another typo. I think this patch looks good, but I heard concerns that this change might break Arora. Kenneth? 149977 37 tonikitoo 2009-09-25 04:53:25 -0700 (In reply to comment #36) > (In reply to comment #35) > > Created an attachment (id=40063) [details] [details] > > patch 0.3.2 - make setHtml and setContent to not change history (2 > > > > same as previous patch, but fixed another typo. > > I think this patch looks good, but I heard concerns that this change might > break Arora. Kenneth? simon, this change alone will break Arora, yeah. The "fix" for Arora would be make use of stuff in bug 29731 , which this one is a blocker of. 150020 38 40063 vestbo 2009-09-25 08:42:10 -0700 Comment on attachment 40063 patch 0.3.2 - make setHtml and setContent to not change history (2 > + \note Any call to setHtml will not change neither session nor global history for this frame. > + Move this below the next block > When using this method WebKit assumes that external resources such as JavaScript programs or style > sheets are encoded in UTF-8 unless otherwise specified. For example, the encoding of an external > script can be specified through the charset attribute of the HTML script tag. It is also possible > for the encoding to be specified by web server. <Here> :) And word it something like: \note This method will not affect session or global history for the frame. > > - \sa toHtml() > + \sa toHtml(), setContent() > */ > void QWebFrame::setHtml(const QString &html, const QUrl &baseUrl) > { > @@ -718,7 +720,7 @@ void QWebFrame::setHtml(const QString &html, const QUrl &baseUrl) > WebCore::ResourceRequest request(kurl); > const QByteArray utf8 = html.toUtf8(); > WTF::RefPtr<WebCore::SharedBuffer> data = WebCore::SharedBuffer::create(utf8.constData(), utf8.length()); > - WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), WebCore::String("utf-8"), kurl); > + WebCore::SubstituteData substituteData(data, WebCore::String("text/html"), WebCore::String("utf-8"), KURL()); > d->frame->loader()->load(request, substituteData, false); > } > > @@ -731,7 +733,9 @@ void QWebFrame::setHtml(const QString &html, const QUrl &baseUrl) > > The \a data is loaded immediately; external objects are loaded asynchronously. > > - \sa toHtml() > + \note Any call to setContent will not change neither session nor global history for this frame. > + > + \sa toHtml(), setHtml() same > +DEFINES += RESOURCES_PATH=$$PWD/resources Is this really needed? 150040 39 40115 tonikitoo 2009-09-25 09:50:09 -0700 Created attachment 40115 committed r48972: patch 0.3.3 - make setHtml and setContent to not change history comments addressed > > +DEFINES += RESOURCES_PATH=$$PWD/resources > > Is this really needed? as you suggested, i changed this to be as qtextbrowser in qt. 150085 40 kenneth 2009-09-25 11:33:24 -0700 I have a new idea for an API that would solve our problems. On IRC we had a discussion today, following my making some tests. The conclusion was that we should use the infrastructure of WebCore. Adding a QWebHistory::addUrl(...) would *not* solve our problems as - the setHtml would send en emit urlChanged(QUrl("about:blank") - the constructed history item would need to set valid "lastVisitedDate", etc as well as the title which is supplied with the HTML in the forms of the <title> tag. - it might break with WebCore changes - all other ports use the fallbackUrl supplied by SubstituteData. The Qt developers have expressed the dislike of adding a historyUrl or fallbackUrl to the setHtml as two followed QUrl arguments make it hard to read code using it. Instead I suggest the following API: /*! Loads a new page with the specified \a html. This method is meant for dealing with failed loads and similar situations, where alternative \a html is shown, but when revisited or reloaded the \a fallbackUrl should be loaded instead. External objects such as stylesheets or images referenced in the HTML document are located relative to baseUrl which is optional. The \a html is loaded immediately; external objects are loaded asynchronously. When using this method, WebKit assumes that external resources such as JavaScript programs or style sheets are encoded in UTF-8 unless otherwise specified. For example, the encoding of an external script can be specified through the charset attribute of the HTML script tag. Alternatively, the encoding can also be specified by the web server. \sa load(), setContent(), setHtml(), QWebFrame::toHtml() */ loadAlternativeHtml(const QUrl& fallbackUrl, const QString& html, const QUrl& baseUrl = QUrl()) { ... } Comments? 150123 41 40139 tonikitoo 2009-09-25 13:21:35 -0700 Created attachment 40139 implemented loadAlternativeHtml + autotest patch on top of patch 0.3.3 150409 42 kenneth 2009-09-27 12:47:31 -0700 (In reply to comment #41) > Created an attachment (id=40139) [details] > implemented loadAlternativeHtml + autotest About the method name: I chose using "load" to indicate that it creates a new page in history etc, as all other load methods, and in contract to setHtml that just "sets" (substitutes) the DOM with the new HTML. As it is kind of specialized it was only added to QWebFrame, The "alternative" makes it clear to the developer that this function is meant for special cases. The name is also very similar to what Apple uses in their API. 150454 43 tonikitoo 2009-09-27 21:11:14 -0700 it might also worth to mention the fact that MAC port also adopts similar naming for similar methods: loadData loadHTMLString loadAlternateHTMLString <--------- 150991 44 kenneth 2009-09-29 12:16:30 -0700 (In reply to comment #39) > Created an attachment (id=40115) [details] > patch 0.3.3 - make setHtml and setContent to not change history > > comments addressed > > > > +DEFINES += RESOURCES_PATH=$$PWD/resources > > > > Is this really needed? > > as you suggested, i changed this to be as qtextbrowser in qt. As all comments have been fixed and since we have agreed that this is the right change (see below) I believe this should be simple to r+ by any reviewer. We found out earlier that the Arora browser was depending on the broken behaviour, but a recent commit by me, has made it possible to obtain the same behaviour using an error page extension to QWebPage. > On Friday 18 September 2009 Hausmann Simon (Nokia-D-Qt/Oslo), wrote: >> * https://bugs.webkit.org/show_bug.cgi?id=29248 (setHtml behaviour, >> invisible loads) > > We determined that the current behaviour of QWebFrame::setHtml() is broken in > the sense that _if_ a base url is specified then an entry is added to the > back/forward history. If no base url is specified then the history remains > unchanged. > > So we decided to change setHtml() to _never_ change the history and clarify > this in the docs. > > Antonio is looking into making auto tests for the various issues he found, > including the current setHtml() problem. Autotests will make it easier to > understand and distinguish the issues :) 150993 45 kenneth 2009-09-29 12:19:22 -0700 (In reply to comment #43) > it might also worth to mention the fact that MAC port also adopts similar > naming for similar methods: > > loadData > loadHTMLString > loadAlternateHTMLString <--------- We have decided against adding this method. 150995 46 40139 kenneth 2009-09-29 12:20:05 -0700 Comment on attachment 40139 implemented loadAlternativeHtml + autotest This has been implemented in another way, using a QWebPage ErrorPage extension. 151537 47 tonikitoo 2009-10-01 07:32:36 -0700 fixed. r48972 151538 48 40115 tonikitoo 2009-10-01 07:33:24 -0700 Comment on attachment 40115 committed r48972: patch 0.3.3 - make setHtml and setContent to not change history clearing r+ flag since patch has landed. 158562 49 tonikitoo 2009-10-28 08:11:28 -0700 and missing resource late committed r50217 A WebKit/qt/tests/qwebframe/resources/image2.png M WebKit/qt/ChangeLog this should make autotests to pass again 39556 2009-09-14 11:12:14 -0700 2009-09-14 15:53:11 -0700 patch v0.1 - basic invisible load impl BUG_29248_v0.1.diff text/plain 17955 tonikitoo RnJvbSA1YTMyNTZhNTZkNzJjZTEyOWVhMDE0MTg3MTBiYzQ2NWFiYjA5NTFjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IE1vbiwgMTQgU2VwIDIwMDkgMTI6MDg6MTMgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTE0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIEludHJvZHVjZXMgYSB3YXkgdGhhdCBtYWtlcyBpdCBwb3NzaWJsZSBmb3Igc3Vi c3RpdHV0ZSBsb2FkcwogICAgICAgIHRvIG5vdCBjaGFuZ2UgdGhlIGdsb2JhbCBvciBzZXNzaW9u IGhpc3RvcnkgY29udGVudCwgYW5kIG5vdAogICAgICAgIGVtaXQgbG9hZGluZyByZWxhdGVkIHNp Z25hbHMuCgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgKFFXZWJGcmFtZTo6 bG9hZCk6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0SHRtbCk6CiAgICAgICAgKiBBcGkvcXdlYmZy YW1lLmg6CiAgICAgICAgKiBBcGkvcXdlYmZyYW1lX3AuaDoKICAgICAgICAoUVdlYkZyYW1lUHJp dmF0ZTo6UVdlYkZyYW1lUHJpdmF0ZSk6CiAgICAgICAgKiBBcGkvcXdlYmhpc3RvcnkuY3BwOgog ICAgICAgIChRV2ViSGlzdG9yeTo6c2V0RW5hYmxlZCk6CiAgICAgICAgKFFXZWJIaXN0b3J5Ojpp c0VuYWJsZWQpOgogICAgICAgIChRV2ViSGlzdG9yeTo6Y29udGFpbnMpOgogICAgICAgICogQXBp L3F3ZWJoaXN0b3J5Lmg6CiAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVu dFF0LmNwcDoKICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hE aWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UpOgogICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRl ckNsaWVudFF0OjpkaXNwYXRjaERpZENvbW1pdExvYWQpOgogICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZEZpbmlzaExvYWQpOgogICAgICAgIChXZWJDb3Jl OjpGcmFtZUxvYWRlckNsaWVudFF0Ojpwb3N0UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9uKToK ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRSZWNlaXZl SWNvbik6CiAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OnVwZGF0ZUdsb2Jh bEhpc3RvcnkpOgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI5MjQ4CiAgICAgICAgW1F0 XSBbQVBJXSBNYWtlIGl0IHBvc3NpYmxlIHRvIGhhdmUgJ2ludmlzaWJsZScgbG9hZHMKCiAgICAg ICAgV2ViQ29yZSBtaW5vciBjaGFuZ2VzIHRvIG1ha2UgaW52aXNpYmxlIGxvYWRzIHBvc3NpYmxl LgoKICAgICAgICBObyBuZXcgdGVzdHMuIChPT1BTISkKCiAgICAgICAgKiBoaXN0b3J5L0JhY2tG b3J3YXJkTGlzdC5jcHA6CiAgICAgICAgTWFrZSBpcyBwb3NzaWJsZSB0byBkaXNhYmxlIHRoZSBC YWNrRm9yd2FyZExpc3Qgd2l0aG91dCBuZWNlc3NhcmVseQogICAgICAgIGNsZWFyaW5nIGl0Lgog ICAgICAgIChXZWJDb3JlOjpCYWNrRm9yd2FyZExpc3Q6OnNldEVuYWJsZWQpOiBkaXR0by4KICAg ICAgICAqIGhpc3RvcnkvQmFja0ZvcndhcmRMaXN0Lmg6IGRpdHRvLgogICAgICAgICogbG9hZGVy L0ZyYW1lTG9hZGVyLmNwcDoKICAgICAgICBPbmx5IGFjdGl2YXRlIHRoZSBiYWNrZm93YXJkOjpn b1RvSXRlbSBpZiBtX2N1cnJlbnRIaXN0b3J5SXRlbQogICAgICAgIGhhdmUgbm90IGNoYW5nZWQg aW4gdGhlIG1lYW53aGlsZS4KICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9h ZENvbXBsZXRlRm9yVGhpc0ZyYW1lKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDIyICsrKysrKysKIFdlYkNvcmUvaGlzdG9yeS9CYWNr Rm9yd2FyZExpc3QuY3BwICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYkNvcmUvaGlzdG9yeS9C YWNrRm9yd2FyZExpc3QuaCAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYkNvcmUvbG9hZGVy L0ZyYW1lTG9hZGVyLmNwcCAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcCAgICAgICAgICAgICAgICAgICAgICB8ICAgNjYgKysrKysrKysrKysr KysrKysrKystCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oICAgICAgICAgICAgICAgICAgICAg ICAgfCAgIDE2ICsrKysrCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggICAgICAgICAgICAg ICAgICAgICAgfCAgICAzICsKIFdlYktpdC9xdC9BcGkvcXdlYmhpc3RvcnkuY3BwICAgICAgICAg ICAgICAgICAgICB8ICAgNDAgKysrKysrKysrKysrKy0KIFdlYktpdC9xdC9BcGkvcXdlYmhpc3Rv cnkuaCAgICAgICAgICAgICAgICAgICAgICB8ICAgIDMgKwogV2ViS2l0L3F0L0NoYW5nZUxvZyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzMSArKysrKysrKysrCiBXZWJLaXQvcXQv V2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAgfCAgIDIyICsrKystLS0KIDEx IGZpbGVzIGNoYW5nZWQsIDE5MyBpbnNlcnRpb25zKCspLCAxOCBkZWxldGlvbnMoLSkKCmRpZmYg LS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGQ4YzIx M2EuLjcxNzc0MDEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMDktMDktMTQgIEFudG9uaW8gR29tZXMgICA8 YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yOTI0OAorCisgICAgICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZl ICdpbnZpc2libGUnIGxvYWRzCisKKyAgICAgICAgV2ViQ29yZSBtaW5vciBjaGFuZ2VzIHRvIG1h a2UgaW52aXNpYmxlIGxvYWRzIHBvc3NpYmxlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9P UFMhKQorCisgICAgICAgICogaGlzdG9yeS9CYWNrRm9yd2FyZExpc3QuY3BwOgorICAgICAgICBN YWtlIGlzIHBvc3NpYmxlIHRvIGRpc2FibGUgdGhlIEJhY2tGb3J3YXJkTGlzdCB3aXRob3V0IG5l Y2Vzc2FyZWx5CisgICAgICAgIGNsZWFyaW5nIGl0LgorICAgICAgICAoV2ViQ29yZTo6QmFja0Zv cndhcmRMaXN0OjpzZXRFbmFibGVkKTogZGl0dG8uCisgICAgICAgICogaGlzdG9yeS9CYWNrRm9y d2FyZExpc3QuaDogZGl0dG8uCisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAg ICAgICAgT25seSBhY3RpdmF0ZSB0aGUgYmFja2Zvd2FyZDo6Z29Ub0l0ZW0gaWYgbV9jdXJyZW50 SGlzdG9yeUl0ZW0KKyAgICAgICAgaGF2ZSBub3QgY2hhbmdlZCBpbiB0aGUgbWVhbndoaWxlLgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0Zy YW1lKToKKwogMjAwOS0wOS0xMyAgS2V2aW4gT2xsaXZpZXIgIDxrZXZpbm9AdGhlb2xsaXZpZXJz LmNvbT4KIAogICAgICAgICB3eCBidWlsZCBmaXgsIGZpbGUgd2FzIG1pc3NlZCBkdXJpbmcgVExT LmNwcCByZW1vdmFsLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkTGlz dC5jcHAgYi9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcAppbmRleCBkMTBlNjFj Li42MGVmMzA1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNw cAorKysgYi9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcApAQCAtMTg1LDEwICsx ODUsMTAgQEAgYm9vbCBCYWNrRm9yd2FyZExpc3Q6OmVuYWJsZWQoKQogICAgIHJldHVybiBtX2Vu YWJsZWQ7CiB9CiAKLXZvaWQgQmFja0ZvcndhcmRMaXN0OjpzZXRFbmFibGVkKGJvb2wgZW5hYmxl ZCkKK3ZvaWQgQmFja0ZvcndhcmRMaXN0OjpzZXRFbmFibGVkKGJvb2wgZW5hYmxlZCwgYm9vbCBj bGVhcikKIHsKICAgICBtX2VuYWJsZWQgPSBlbmFibGVkOwotICAgIGlmICghZW5hYmxlZCkgewor ICAgIGlmICghZW5hYmxlZCAmJiBjbGVhcikgewogICAgICAgICBpbnQgY2FwYWNpdHkgPSBtX2Nh cGFjaXR5OwogICAgICAgICBzZXRDYXBhY2l0eSgwKTsKICAgICAgICAgc2V0Q2FwYWNpdHkoY2Fw YWNpdHkpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkTGlzdC5oIGIv V2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkTGlzdC5oCmluZGV4IGZkYzMzNjAuLjA0OThhMmUg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaGlzdG9yeS9CYWNrRm9yd2FyZExpc3QuaAorKysgYi9XZWJD b3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmgKQEAgLTg1LDcgKzg1LDcgQEAgcHVibGljOgog ICAgIGludCBjYXBhY2l0eSgpOwogICAgIHZvaWQgc2V0Q2FwYWNpdHkoaW50KTsKICAgICBib29s IGVuYWJsZWQoKTsKLSAgICB2b2lkIHNldEVuYWJsZWQoYm9vbCk7CisgICAgdm9pZCBzZXRFbmFi bGVkKGJvb2wgZW5hYmxlZCwgYm9vbCBjbGVhciA9IHRydWUpOwogICAgIGludCBiYWNrTGlzdENv dW50KCk7CiAgICAgaW50IGZvcndhcmRMaXN0Q291bnQoKTsKICAgICBib29sIGNvbnRhaW5zSXRl bShIaXN0b3J5SXRlbSopOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIu Y3BwIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCmluZGV4IDk3YjdmZTguLmY0NjZl NWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcAorKysgYi9XZWJD b3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTMzNzksNyArMzM3OSw3IEBAIHZvaWQgRnJh bWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKCkKICAgICAgICAgICAgICAg ICAgICAgICAgIHNob3VsZFJlc2V0ID0gZmFsc2U7CiAgICAgICAgICAgICAgICAgfQogICAgICAg ICAgICAgfQotICAgICAgICAgICAgaWYgKHNob3VsZFJlc2V0ICYmIGl0ZW0pCisgICAgICAgICAg ICBpZiAoc2hvdWxkUmVzZXQgJiYgaXRlbSAmJiAoaXRlbSA9PSBtX2N1cnJlbnRIaXN0b3J5SXRl bSkpCiAgICAgICAgICAgICAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBtX2ZyYW1lLT5wYWdlKCkpIHsK ICAgICAgICAgICAgICAgICAgICAgcGFnZS0+YmFja0ZvcndhcmRMaXN0KCktPmdvVG9JdGVtKGl0 ZW0uZ2V0KCkpOwogICAgICAgICAgICAgICAgICAgICBTZXR0aW5ncyogc2V0dGluZ3MgPSBtX2Zy YW1lLT5zZXR0aW5ncygpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3Bw IGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCmluZGV4IGY1NjM1MTguLmVhMzFiZDEgMTAw NjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvcXQvQXBp L3F3ZWJmcmFtZS5jcHAKQEAgLTYzNiw2ICs2MzYsOCBAQCB2b2lkIFFXZWJGcmFtZTo6bG9hZChj b25zdCBRV2ViTmV0d29ya1JlcXVlc3QgJnJlcSkKICAgICBpZiAoIXBvc3REYXRhLmlzRW1wdHko KSkKICAgICAgICAgcmVxdWVzdC5zZXRIVFRQQm9keShXZWJDb3JlOjpGb3JtRGF0YTo6Y3JlYXRl KHBvc3REYXRhLmNvbnN0RGF0YSgpLCBwb3N0RGF0YS5zaXplKCkpKTsKIAorICAgIGQtPmxvYWRN b2RlID0gU3RhbmRhcmRMb2FkOworCiAgICAgZC0+ZnJhbWUtPmxvYWRlcigpLT5sb2FkKHJlcXVl c3QsIGZhbHNlKTsKIAogICAgIGlmIChkLT5wYXJlbnRGcmFtZSgpKQpAQCAtNjkyLDYgKzY5NCw4 IEBAIHZvaWQgUVdlYkZyYW1lOjpsb2FkKGNvbnN0IFFOZXR3b3JrUmVxdWVzdCAmcmVxLAogICAg IGlmICghYm9keS5pc0VtcHR5KCkpCiAgICAgICAgIHJlcXVlc3Quc2V0SFRUUEJvZHkoV2ViQ29y ZTo6Rm9ybURhdGE6OmNyZWF0ZShib2R5LmNvbnN0RGF0YSgpLCBib2R5LnNpemUoKSkpOwogCisg ICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFyZExvYWQ7CisKICAgICBkLT5mcmFtZS0+bG9hZGVyKCkt PmxvYWQocmVxdWVzdCwgZmFsc2UpOwogCiAgICAgaWYgKGQtPnBhcmVudEZyYW1lKCkpCkBAIC03 MTQsMTEgKzcxOCw2NSBAQCB2b2lkIFFXZWJGcmFtZTo6bG9hZChjb25zdCBRTmV0d29ya1JlcXVl c3QgJnJlcSwKICovCiB2b2lkIFFXZWJGcmFtZTo6c2V0SHRtbChjb25zdCBRU3RyaW5nICZodG1s LCBjb25zdCBRVXJsICZiYXNlVXJsKQogewotICAgIEtVUkwga3VybChiYXNlVXJsKTsKLSAgICBX ZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsKKyAgICBzZXRIdG1sKGh0bWws IGJhc2VVcmwsIFFVcmwoKSwgU3RhbmRhcmRMb2FkKTsKK30KKworLyohCisgIFxzaW5jZSA0LjYK KyAgU2V0cyB0aGUgY29udGVudCBvZiB0aGlzIGZyYW1lIHRvIFxhIGh0bWwuIFxhIGJhc2VVcmwg aXMgb3B0aW9uYWwgYW5kIHVzZWQgdG8gcmVzb2x2ZSByZWxhdGl2ZQorICBVUkxzIGluIHRoZSBk b2N1bWVudCwgc3VjaCBhcyByZWZlcmVuY2VkIGltYWdlcyBvciBzdHlsZXNoZWV0cy4gRGVwZW5k aW5nIG9uIHRoZSBsb2FkaW5nIGZsYWdzCisgIFxhIHR5cGUgcGFzc2VkIGluLCBnbG9iYWwgb3Ig c2Vzc2lvbiAoYmFjay9mb3J3YXJkKSBoaXN0b3JpZXMgY2FuIGdldCB0aGVpciBjb250ZW50cyB1 cGRhdGVkCisgIG9yIG5vdC4gQWxzbyBzaWduYWwgZW1pc3Npb24gY2FuIGdldCBibG9ja2VkIG9y IG5vdC4KKworICBUaGUgXGEgaHRtbCBpcyBsb2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9i amVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25vdXNseS4KKworICBXaGVuIHVzaW5nIHRoaXMgbWV0 aG9kIFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwgcmVzb3VyY2VzIHN1Y2ggYXMgSmF2YVNj cmlwdCBwcm9ncmFtcyBvciBzdHlsZQorICBzaGVldHMgYXJlIGVuY29kZWQgaW4gVVRGLTggdW5s ZXNzIG90aGVyd2lzZSBzcGVjaWZpZWQuIEZvciBleGFtcGxlLCB0aGUgZW5jb2Rpbmcgb2YgYW4g ZXh0ZXJuYWwKKyAgc2NyaXB0IGNhbiBiZSBzcGVjaWZpZWQgdGhyb3VnaCB0aGUgY2hhcnNldCBh dHRyaWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRhZy4gSXQgaXMgYWxzbyBwb3NzaWJsZQorICBm b3IgdGhlIGVuY29kaW5nIHRvIGJlIHNwZWNpZmllZCBieSB3ZWIgc2VydmVyLgorCisgIFxzYSB0 b0h0bWwoKQorKi8KK3ZvaWQgUVdlYkZyYW1lOjpzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWws IGNvbnN0IFFVcmwgJmJhc2VVcmwsCisgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBRVXJs ICZzdWJzdGl0dXRlVXJsLCBMb2FkTW9kZSBtb2RlKQorCit7CisgICAgS1VSTCBrdXJsID0gS1VS TChiYXNlVXJsKTsKKyAgICBkLT5sb2FkTW9kZSA9IG1vZGU7CisKKyAgICBpZiAoIXN1YnN0aXR1 dGVVcmwudG9TdHJpbmcoKS5pc0VtcHR5KCkpCisgICAgICAgIGt1cmwgPSBLVVJMKHN1YnN0aXR1 dGVVcmwpOworICAgIC8vIElmIGxvYWQgdHlwZSBpcyBub3QgInN0YW5kYXJkIiBhbmQgbm8gc3Vi c3RpdHV0ZSB1cmwgaXMgcGFzc2VkIGluCisgICAgLy8gd2UgYXNzdW1lIGNhbGxlciB3YW50cyB0 byBzZXQgdGhlIEhUTUwgb2YgdGhlIHBhZ2UgYnV0IG5vdCBjaGFuZ2UKKyAgICAvLyB0aGUgY3Vy cmVudCB1cmwgKGUuZy4gd2hlbiBjYWxsZXIgaXMgc2V0dGluZyBhIEhUTUwgZXJyb3IgcGFnZQor ICAgIC8vIG9mIGEgZmFpbGluZyBsb2FkKS4KKyAgICBlbHNlIGlmICghKG1vZGUgJiBTdGFuZGFy ZExvYWQpKSB7CisgICAgICAgIC8vIEFmdGVyIGEgbG9hZCBoYXMgc3VjY2Vzc2Z1bGx5IGZpbmlz aGVkLCB0aGUgbG9hZGVkIFVybCBpcyBhdmFpbGFibGUKKyAgICAgICAgLy8gdGhyb3VnaCB0aGUg dXJsKCkgY2xhc3MgbWV0aG9kLiBXaGVuIHRoZSBsb2FkIGlzIG5vdCBzdWNjZXNzZnVsbHkKKyAg ICAgICAgLy8gdGhvdWdoLCB0aGUgZnJhbWUgbG9hZGVyIGRvZXMgbm90IGdldCBjb21taXR0ZWQs IGFuZAorICAgICAgICAvLyBhbnkgY2FsbCB0byB1cmwoKSBtZXRob2Qgd2lsbCBzdGlsbCByZXR1 cm4gdGhlIGxhc3Qgc3VjY2Vzc2Z1bCBVcmwKKyAgICAgICAgLy8gbG9hZGVkLiBJbiBzdWNoIGNh c2VzLCB0aGUgZmFpbGluZyBVcmwgY2FuIGJlIHJldHJpZXZlZCBieSB1c2luZworICAgICAgICAv LyBmcmFtZUxvYWRlckNsaWVudCdzIG1fbG9hZEVycm9yIGNsYXNzIG1lbWJlciwgd2hpY2gga2Vl cHMgdHJhY2sgb2YKKyAgICAgICAgLy8gZXJyb3JzIGR1cmluZyB1bnN1Y2Nlc3NmdWwgbG9hZHMu CisgICAgICAgIGlmICghZC0+ZnJhbWVMb2FkZXJDbGllbnQtPm1fbG9hZEVycm9yLmZhaWxpbmdV UkwoKS5pc0VtcHR5KCkpCisgICAgICAgICAgICBrdXJsID0gS1VSTChRVXJsKGQtPmZyYW1lTG9h ZGVyQ2xpZW50LT5tX2xvYWRFcnJvci5mYWlsaW5nVVJMKCkpKTsKKyAgICAgICAgZWxzZSBpZiAo IXVybCgpLnRvU3RyaW5nKCkuaXNFbXB0eSgpKQorICAgICAgICAgICAga3VybCA9IEtVUkwodXJs KCkpOworCisgICAgICAgIGlmIChkLT5wYWdlLT5oaXN0b3J5KCktPmNvbnRhaW5zKGt1cmwpICE9 IC0xKQorICAgICAgICAgICBtb2RlIHw9IE5vU2Vzc2lvbkhpc3RvcnlDaGFuZ2U7CisgICAgfQor CisgICAgLy8gSWYgb25seSBzZXNzaW9uIGhpc3RvcnkgaXMgdG8gYmUgJ2xvY2tlZCcsIHdlIGNh biBqdXN0ICBkaXNhYmxlIGl0IGFuZAorICAgIC8vIHJlLWVuYWJsZSBsYXRlciBvbiAoKS4KKyAg ICAvLyBOT1RFOiBHbG9iYWwgaGlzdG9yeSBvbmx5IGxvY2tzIGFyZSBoYW5kbGVkIGluIEZyYW1l TG9hZENsaWVudCBzaWRlLgorICAgIGlmIChtb2RlICYgTm9TZXNzaW9uSGlzdG9yeUNoYW5nZSkK KyAgICAgICAgZC0+cGFnZS0+aGlzdG9yeSgpLT5zZXRFbmFibGVkKGZhbHNlKTsKKworICAgIFJl c291cmNlUmVxdWVzdCByZXF1ZXN0KGt1cmwpOwogICAgIGNvbnN0IFFCeXRlQXJyYXkgdXRmOCA9 IGh0bWwudG9VdGY4KCk7Ci0gICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6U2hhcmVkQnVmZmVyPiBk YXRhID0gV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGUodXRmOC5jb25zdERhdGEoKSwgdXRm OC5sZW5ndGgoKSk7Ci0gICAgV2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vic3RpdHV0ZURhdGEo ZGF0YSwgV2ViQ29yZTo6U3RyaW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6U3RyaW5nKCJ1dGYt OCIpLCBrdXJsKTsKKyAgICBXVEY6OlJlZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGEgPSBTaGFyZWRC dWZmZXI6OmNyZWF0ZSh1dGY4LmNvbnN0RGF0YSgpLCB1dGY4Lmxlbmd0aCgpKTsKKyAgICBTdWJz dGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShkYXRhLCBTdHJpbmcoInRleHQvaHRtbCIpLCBTdHJp bmcoInV0Zi04IiksIGt1cmwsIGt1cmwpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChy ZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCmRpZmYgLS1naXQgYS9XZWJLaXQv cXQvQXBpL3F3ZWJmcmFtZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAppbmRleCA1NWM3 M2I0Li4yZmMwMGM4IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oCisrKyBi L1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKQEAgLTEyMiw2ICsxMjIsMTggQEAgcHJpdmF0ZToK IHB1YmxpYzoKICAgICBRV2ViUGFnZSAqcGFnZSgpIGNvbnN0OwogCisgICAgZW51bSBNYWluRnJh bWVMb2FkTW9kZSB7CisgICAgICAgIE5vU2lnbmFsRW1pc3Npb24gPSAweDEsCisgICAgICAgIE5v U2Vzc2lvbkhpc3RvcnlDaGFuZ2UgPSAweDIsCisgICAgICAgIE5vR2xvYmFsSGlzdG9yeUNoYW5n ZSA9IDB4NCwKKyAgICAgICAgU3RhbmRhcmRMb2FkID0gMHg4CisgICAgfTsKKworICAgIFFfREVD TEFSRV9GTEFHUyhNYWluRnJhbWVMb2FkTW9kZXMsIE1haW5GcmFtZUxvYWRNb2RlKQorICAgIFFf RkxBR1MoTWFpbkZyYW1lTG9hZEZsYWdzKQorCisgICAgdHlwZWRlZiBNYWluRnJhbWVMb2FkTW9k ZXMgTG9hZE1vZGU7CisKICAgICB2b2lkIGxvYWQoY29uc3QgUVVybCAmdXJsKTsKICNpZiBRVF9W RVJTSU9OIDwgMHgwNDA0MDAKICAgICB2b2lkIGxvYWQoY29uc3QgUVdlYk5ldHdvcmtSZXF1ZXN0 ICZyZXF1ZXN0KTsKQEAgLTEzMSw2ICsxNDMsOCBAQCBwdWJsaWM6CiAgICAgICAgICAgICAgIGNv bnN0IFFCeXRlQXJyYXkgJmJvZHkgPSBRQnl0ZUFycmF5KCkpOwogI2VuZGlmCiAgICAgdm9pZCBz ZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwgPSBRVXJsKCkp OworICAgIHZvaWQgc2V0SHRtbChjb25zdCBRU3RyaW5nICZodG1sLCBjb25zdCBRVXJsICZiYXNl VXJsLCBjb25zdCBRVXJsICZzdWJzdGl0dXRlVXJsLCBMb2FkTW9kZSBtb2RlKTsKKwogICAgIHZv aWQgc2V0Q29udGVudChjb25zdCBRQnl0ZUFycmF5ICZkYXRhLCBjb25zdCBRU3RyaW5nICZtaW1l VHlwZSA9IFFTdHJpbmcoKSwgY29uc3QgUVVybCAmYmFzZVVybCA9IFFVcmwoKSk7CiAKICAgICB2 b2lkIGFkZFRvSmF2YVNjcmlwdFdpbmRvd09iamVjdChjb25zdCBRU3RyaW5nICZuYW1lLCBRT2Jq ZWN0ICpvYmplY3QpOwpAQCAtMjI1LDQgKzIzOSw2IEBAIHByaXZhdGU6CiAgICAgUVdlYkZyYW1l UHJpdmF0ZSAqZDsKIH07CiAKK1FfREVDTEFSRV9PUEVSQVRPUlNfRk9SX0ZMQUdTKFFXZWJGcmFt ZTo6TWFpbkZyYW1lTG9hZE1vZGVzKQorCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lX3AuaCBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaAppbmRleCA2MzJm ODNhLi45M2Y5NzJhIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmgKKysr IGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVk ZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5jbHVkZSAicXdlYmVs ZW1lbnQuaCIKKyNpbmNsdWRlICJxd2ViZnJhbWUuaCIKICNpbmNsdWRlICJ3dGYvUmVmUHRyLmgi CiAjaW5jbHVkZSAiRnJhbWUuaCIKIApAQCAtNzEsNiArNzIsNyBAQCBwdWJsaWM6CiAgICAgICAg ICwgbWFyZ2luV2lkdGgoLTEpCiAgICAgICAgICwgbWFyZ2luSGVpZ2h0KC0xKQogICAgICAgICAs IGNsaXBSZW5kZXJUb1ZpZXdwb3J0KHRydWUpCisgICAgICAgICwgbG9hZE1vZGUoUVdlYkZyYW1l OjpTdGFuZGFyZExvYWQpCiAgICAgICAgIHt9CiAgICAgdm9pZCBpbml0KFFXZWJGcmFtZSogcWZy YW1lLCBRV2ViRnJhbWVEYXRhKiBmcmFtZURhdGEpOwogCkBAIC05NSw2ICs5Nyw3IEBAIHB1Ymxp YzoKICAgICBpbnQgbWFyZ2luV2lkdGg7CiAgICAgaW50IG1hcmdpbkhlaWdodDsKICAgICBib29s IGNsaXBSZW5kZXJUb1ZpZXdwb3J0OworICAgIFFXZWJGcmFtZTo6TG9hZE1vZGUgbG9hZE1vZGU7 CiB9OwogCiBjbGFzcyBRV2ViSGl0VGVzdFJlc3VsdFByaXZhdGUgewpkaWZmIC0tZ2l0IGEvV2Vi S2l0L3F0L0FwaS9xd2ViaGlzdG9yeS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmNw cAppbmRleCBiNTcyNzJkLi4zZGYzYTM2IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJo aXN0b3J5LmNwcAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmNwcApAQCAtNDY3LDYg KzQ2Nyw0NSBAQCB2b2lkIFFXZWJIaXN0b3J5OjpzZXRNYXhpbXVtSXRlbUNvdW50KGludCBjb3Vu dCkKICAgICBkLT5sc3QtPnNldENhcGFjaXR5KGNvdW50KTsKIH0KIAorLyoKKyAgIFxzaW5jZSA0 LjYKKworICAgIExvY2sgQmFjay9Gb3J3YXJkIGhpc3RvcnkuCisqLwordm9pZCBRV2ViSGlzdG9y eTo6c2V0RW5hYmxlZChib29sIHN0YXR1cykKK3sKKyAgICBpZiAoZC0+bHN0LT5lbmFibGVkKCkg IT0gc3RhdHVzKQorICAgICAgICBkLT5sc3QtPnNldEVuYWJsZWQoc3RhdHVzLCAvKiBjbGVhciBv biBkaXNhYmxpbmcgKi8gZmFsc2UpOworfQorCisvKgorICBcc2luY2UgNC42CisKKyAgIFJldHVy bnMgaWYgdGhlIGhpc3RvcnkgaXMgaW4gJ2xvY2tlZCcgc3RhdGUgb3Igbm90LgorKi8KK2Jvb2wg UVdlYkhpc3Rvcnk6OmlzRW5hYmxlZCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGQtPmxzdC0+ZW5h YmxlZCgpOworfQorCisvKgorICBcc2luY2UgNC42CisKKyAgIFhYWAorKi8KK2ludCBRV2ViSGlz dG9yeTo6Y29udGFpbnMoY29uc3QgUVVybCYgdXJsKSBjb25zdAoreworICAgIGNvbnN0IFdlYkNv cmU6Okhpc3RvcnlJdGVtVmVjdG9yICZpdGVtcyA9IGQtPmxzdC0+ZW50cmllcygpOworCisgICAg Zm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGl0ZW1zLnNpemUoKTsgKytpKSB7CisgICAgICAgIFdl YkNvcmU6Okhpc3RvcnlJdGVtKiBpdGVtID0gZC0+bHN0LT5pdGVtQXRJbmRleChpKTsKKyAgICAg ICAgaWYgKGl0ZW0gJiYgKGl0ZW0tPnVybCgpID09IHVybCB8fCBpdGVtLT5vcmlnaW5hbFVSTCgp ID09IHVybCkpCisgICAgICAgICAgICByZXR1cm4gaTsKKyAgICB9CisKKyAgICByZXR1cm4gLTE7 Cit9CisKIC8qIQogICAgXGVudW0gUVdlYkhpc3Rvcnk6Okhpc3RvcnlTdGF0ZVZlcnNpb24KIApA QCAtNTkyLDQgKzYzMSwzIEBAIFFEYXRhU3RyZWFtJiBvcGVyYXRvcj4+KFFEYXRhU3RyZWFtJiBz dHJlYW0sIFFXZWJIaXN0b3J5JiBoaXN0b3J5KQogICAgIHJldHVybiBzdHJlYW07CiB9CiAKLQpk aWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViaGlzdG9yeS5oIGIvV2ViS2l0L3F0L0FwaS9x d2ViaGlzdG9yeS5oCmluZGV4IGU0NmYxMjQuLjAyNDRhMDcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9x dC9BcGkvcXdlYmhpc3RvcnkuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmgKQEAg LTg2LDYgKzg2LDggQEAgcHVibGljOgogICAgIFFCeXRlQXJyYXkgc2F2ZVN0YXRlKEhpc3RvcnlT dGF0ZVZlcnNpb24gdmVyc2lvbiA9IERlZmF1bHRIaXN0b3J5VmVyc2lvbikgY29uc3Q7CiAKICAg ICB2b2lkIGNsZWFyKCk7CisgICAgdm9pZCBzZXRFbmFibGVkKGJvb2wgc3RhdHVzKTsKKyAgICBi b29sIGlzRW5hYmxlZCgpIGNvbnN0OwogCiAgICAgUUxpc3Q8UVdlYkhpc3RvcnlJdGVtPiBpdGVt cygpIGNvbnN0OwogICAgIFFMaXN0PFFXZWJIaXN0b3J5SXRlbT4gYmFja0l0ZW1zKGludCBtYXhJ dGVtcykgY29uc3Q7CkBAIC0xMDYsNiArMTA4LDcgQEAgcHVibGljOgogICAgIGludCBjdXJyZW50 SXRlbUluZGV4KCkgY29uc3Q7CiAKICAgICBpbnQgY291bnQoKSBjb25zdDsKKyAgICBpbnQgY29u dGFpbnMoY29uc3QgUVVybCYgdXJsKSBjb25zdDsKIAogICAgIGludCBtYXhpbXVtSXRlbUNvdW50 KCkgY29uc3Q7CiAgICAgdm9pZCBzZXRNYXhpbXVtSXRlbUNvdW50KGludCBjb3VudCk7CmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRleCBm ODY0YmNjLi5jODMwZjQ3IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBiL1dl YktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNCBAQAorMjAwOS0wOS0xNCAgQW50b25pbyBH b21lcyAgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI5MjQ4CisKKyAgICAgICAgW1F0XSBbQVBJXSBNYWtlIGl0IHBvc3NpYmxl IHRvIGhhdmUgJ2ludmlzaWJsZScgbG9hZHMgCisKKyAgICAgICAgSW50cm9kdWNlcyBhIHdheSB0 aGF0IG1ha2VzIGl0IHBvc3NpYmxlIGZvciBzdWJzdGl0dXRlIGxvYWRzCisgICAgICAgIHRvIG5v dCBjaGFuZ2UgdGhlIGdsb2JhbCBvciBzZXNzaW9uIGhpc3RvcnkgY29udGVudCwgYW5kIG5vdAor ICAgICAgICBlbWl0IGxvYWRpbmcgcmVsYXRlZCBzaWduYWxzLgorCisgICAgICAgICogQXBpL3F3 ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2ViRnJhbWU6OmxvYWQpOgorICAgICAgICAoUVdlYkZy YW1lOjpzZXRIdG1sKToKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmg6CisgICAgICAgICogQXBp L3F3ZWJmcmFtZV9wLmg6CisgICAgICAgIChRV2ViRnJhbWVQcml2YXRlOjpRV2ViRnJhbWVQcml2 YXRlKToKKyAgICAgICAgKiBBcGkvcXdlYmhpc3RvcnkuY3BwOgorICAgICAgICAoUVdlYkhpc3Rv cnk6OnNldEVuYWJsZWQpOgorICAgICAgICAoUVdlYkhpc3Rvcnk6OmlzRW5hYmxlZCk6CisgICAg ICAgIChRV2ViSGlzdG9yeTo6Y29udGFpbnMpOgorICAgICAgICAqIEFwaS9xd2ViaGlzdG9yeS5o OgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRDaGFuZ2VMb2Nh dGlvbldpdGhpblBhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6 ZGlzcGF0Y2hEaWRDb21taXRMb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xp ZW50UXQ6OmRpc3BhdGNoRGlkRmluaXNoTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxv YWRlckNsaWVudFF0Ojpwb3N0UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9uKToKKyAgICAgICAg KFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkUmVjZWl2ZUljb24pOgor ICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6dXBkYXRlR2xvYmFsSGlzdG9y eSk6CisKIDIwMDktMDktMTEgIERhdmlkIEJvZGRpZSAgPGRib2RkaWVAdHJvbGx0ZWNoLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL1dlYktp dC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCBiL1dlYktpdC9xdC9X ZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcAppbmRleCAxMDcxYTI2Li5hNDM5 NTEzIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGll bnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuY3BwCkBAIC0yOTgsNyArMjk4LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNw YXRjaERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZSgpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRl ckNhbGxiYWNrcykKICAgICAgICAgcHJpbnRmKCIlcyAtIGRpZENoYW5nZUxvY2F0aW9uV2l0aGlu UGFnZUZvckZyYW1lXG4iLCBxUHJpbnRhYmxlKGRydERlc2NyaXB0aW9uU3VpdGFibGVGb3JUZXN0 UmVzdWx0KG1fZnJhbWUpKSk7CiAKLSAgICBpZiAoIW1fd2ViRnJhbWUpCisgICAgaWYgKCFtX3dl YkZyYW1lIHx8ICEobV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJhbWU6OlN0YW5kYXJk TG9hZCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGVtaXQgbV93ZWJGcmFtZS0+dXJsQ2hhbmdl ZChtX3dlYkZyYW1lLT51cmwoKSk7CkBAIC0zNDAsNyArMzQwLDcgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudFF0OjpkaXNwYXRjaERpZENvbW1pdExvYWQoKQogICAgIGlmIChkdW1wRnJhbWVMb2Fk ZXJDYWxsYmFja3MpCiAgICAgICAgIHByaW50ZigiJXMgLSBkaWRDb21taXRMb2FkRm9yRnJhbWVc biIsIHFQcmludGFibGUoZHJ0RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFt ZSkpKTsKIAotICAgIGlmIChtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpIHx8ICFtX3dlYkZyYW1l KQorICAgIGlmIChtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpIHx8ICFtX3dlYkZyYW1lIHx8ICEo bV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJhbWU6OlN0YW5kYXJkTG9hZCkpCiAgICAg ICAgIHJldHVybjsKIAogICAgIGVtaXQgbV93ZWJGcmFtZS0+dXJsQ2hhbmdlZChtX3dlYkZyYW1l LT51cmwoKSk7CkBAIC0zNzYsNyArMzc2LDEwIEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6 ZGlzcGF0Y2hEaWRGaW5pc2hMb2FkKCkKICAgICBpZiAoZHVtcEZyYW1lTG9hZGVyQ2FsbGJhY2tz KQogICAgICAgICBwcmludGYoIiVzIC0gZGlkRmluaXNoTG9hZEZvckZyYW1lXG4iLCBxUHJpbnRh YmxlKGRydERlc2NyaXB0aW9uU3VpdGFibGVGb3JUZXN0UmVzdWx0KG1fZnJhbWUpKSk7CiAKLSAg ICBtX2xvYWRFcnJvciA9IFJlc291cmNlRXJyb3IoKTsgLy8gY2xlYXJzIHRoZSBwcmV2aW91cyBl cnJvcgorICAgIC8vIGNsZWFycyB0aGUgcHJldmlvdXMgbG9hZCBkYXRhCisgICAgbV9sb2FkRXJy b3IgPSBSZXNvdXJjZUVycm9yKCk7CisgICAgbV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgPSBRV2Vi RnJhbWU6OlN0YW5kYXJkTG9hZDsKKyAgICBtX3dlYkZyYW1lLT5kLT5wYWdlLT5oaXN0b3J5KCkt PnNldEVuYWJsZWQodHJ1ZSk7CiAKICAgICBpZiAoIW1fd2ViRnJhbWUpCiAgICAgICAgIHJldHVy bjsKQEAgLTQyOSwxMiArNDMyLDE0IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6cmV2ZXJ0 VG9Qcm92aXNpb25hbFN0YXRlKERvY3VtZW50TG9hZGVyKikKIAogdm9pZCBGcmFtZUxvYWRlckNs aWVudFF0Ojpwb3N0UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9uKCkKIHsKLSAgICBpZiAobV93 ZWJGcmFtZSAmJiBtX2ZyYW1lLT5wYWdlKCkpIHsKKyAgICBpZiAobV9mcmFtZS0+dHJlZSgpLT5w YXJlbnQoKSB8fCAhbV93ZWJGcmFtZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG1fZnJh bWUtPnBhZ2UoKSkgewogICAgICAgICBlbWl0IGxvYWRTdGFydGVkKCk7CiAgICAgICAgIHBvc3RQ cm9ncmVzc0VzdGltYXRlQ2hhbmdlZE5vdGlmaWNhdGlvbigpOwogICAgIH0KLSAgICBpZiAobV9m cmFtZS0+dHJlZSgpLT5wYXJlbnQoKSB8fCAhbV93ZWJGcmFtZSkKLSAgICAgICAgcmV0dXJuOwor CiAgICAgbV93ZWJGcmFtZS0+cGFnZSgpLT5kLT51cGRhdGVOYXZpZ2F0aW9uQWN0aW9ucygpOwog fQogCkBAIC01NzYsOSArNTgxLDggQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRj aERpZFJlY2VpdmVJY29uKCkKICAgICBpZiAoZHVtcEZyYW1lTG9hZGVyQ2FsbGJhY2tzKQogICAg ICAgICBwcmludGYoIiVzIC0gZGlkUmVjZWl2ZUljb25Gb3JGcmFtZVxuIiwgcVByaW50YWJsZShk cnREZXNjcmlwdGlvblN1aXRhYmxlRm9yVGVzdFJlc3VsdChtX2ZyYW1lKSkpOwogCi0gICAgaWYg KG1fd2ViRnJhbWUpIHsKKyAgICBpZiAobV93ZWJGcmFtZSkKICAgICAgICAgZW1pdCBtX3dlYkZy YW1lLT5pY29uQ2hhbmdlZCgpOwotICAgIH0KIH0KIAogdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0 OjpmcmFtZUxvYWRlckRlc3Ryb3llZCgpCkBAIC02MjQsNyArNjI4LDcgQEAgdm9pZCBGcmFtZUxv YWRlckNsaWVudFF0OjpyZWdpc3RlckZvckljb25Ob3RpZmljYXRpb24oYm9vbCkKIHZvaWQgRnJh bWVMb2FkZXJDbGllbnRRdDo6dXBkYXRlR2xvYmFsSGlzdG9yeSgpCiB7CiAgICAgUVdlYkhpc3Rv cnlJbnRlcmZhY2UgKmhpc3RvcnkgPSBRV2ViSGlzdG9yeUludGVyZmFjZTo6ZGVmYXVsdEludGVy ZmFjZSgpOwotICAgIGlmIChoaXN0b3J5KQorICAgIGlmIChoaXN0b3J5ICYmICEobV93ZWJGcmFt ZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJhbWU6Ok5vR2xvYmFsSGlzdG9yeUNoYW5nZSkpCiAgICAg ICAgIGhpc3RvcnktPmFkZEhpc3RvcnlFbnRyeShtX2ZyYW1lLT5sb2FkZXIoKS0+ZG9jdW1lbnRM b2FkZXIoKS0+dXJsRm9ySGlzdG9yeSgpLnByZXR0eVVSTCgpKTsKIH0KIAotLSAKMS42LjAuNAoK 39578 2009-09-14 15:53:11 -0700 2009-09-15 19:51:55 -0700 patch v0.1.1 - basic invisible load impl BUG_29248_v0.1.1.diff text/plain 18979 tonikitoo RnJvbSAzYmMyZjJmMGM3YzcxZDJmNDM3ODE4NDM3MTVlN2I5YzFhMmI1NTg2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IE1vbiwgMTQgU2VwIDIwMDkgMTI6MDg6MTMgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTE0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIEludHJvZHVjZXMgYSB3YXkgdGhhdCBtYWtlcyBpdCBwb3NzaWJsZSBmb3Igc3Vi c3RpdHV0ZSBsb2FkcwogICAgICAgIChlLmcuIFFXZWJGcmFtZTo6c2V0SHRtbCBhbmQgUVdlYkZy YW1lOjpzZXRDb250ZW50cykgdG8gbm90CiAgICAgICAgY2hhbmdlIGdsb2JhbCBhbmQvb3Igc2Vz c2lvbiBoaXN0b3J5IGNvbnRlbnRzLCBhbmQgdG8gbm90CiAgICAgICAgZW1pdCBzaWduYWxzIHJl bGF0ZWQgdG8gdGhlIGxvYWRpbmcgcHJvY2Vzcy4KCiAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNw cDoKICAgICAgICAoUVdlYkZyYW1lOjpsb2FkKToKICAgICAgICAoUVdlYkZyYW1lOjpzZXRIdG1s KToKICAgICAgICAqIEFwaS9xd2ViZnJhbWUuaDoKICAgICAgICAqIEFwaS9xd2ViZnJhbWVfcC5o OgogICAgICAgIChRV2ViRnJhbWVQcml2YXRlOjpRV2ViRnJhbWVQcml2YXRlKToKICAgICAgICAq IEFwaS9xd2ViaGlzdG9yeS5jcHA6CiAgICAgICAgKFFXZWJIaXN0b3J5OjpzZXRFbmFibGVkKToK ICAgICAgICAoUVdlYkhpc3Rvcnk6OmlzRW5hYmxlZCk6CiAgICAgICAgKFFXZWJIaXN0b3J5Ojpj b250YWlucyk6CiAgICAgICAgKiBBcGkvcXdlYmhpc3RvcnkuaDoKICAgICAgICAqIFdlYkNvcmVT dXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgogICAgICAgIChXZWJDb3JlOjpGcmFtZUxv YWRlckNsaWVudFF0OjpkaXNwYXRjaERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZSk6CiAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkQ29tbWl0TG9hZCk6 CiAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkRmluaXNo TG9hZCk6CiAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OnBvc3RQcm9ncmVz c1N0YXJ0ZWROb3RpZmljYXRpb24pOgogICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVu dFF0OjpkaXNwYXRjaERpZFJlY2VpdmVJY29uKToKICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2Fk ZXJDbGllbnRRdDo6dXBkYXRlR2xvYmFsSGlzdG9yeSk6CgogICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgoKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjkyNDgKICAgICAgICBbUXRdIFtBUEldIE1ha2UgaXQgcG9zc2libGUgdG8gaGF2ZSAn aW52aXNpYmxlJyBsb2FkcwoKICAgICAgICBXZWJDb3JlIG1pbm9yIGNoYW5nZXMgdG8gbWFrZSBp bnZpc2libGUgbG9hZHMgcG9zc2libGUuCgogICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQoK ICAgICAgICAqIGhpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcDoKICAgICAgICBNYWtlcyBpdCBw b3NzaWJsZSB0byBkaXNhYmxlIHRoZSBCYWNrRm9yd2FyZExpc3Qgd2l0aG91dCBuZWNlc3Nhcmls eQogICAgICAgIGNsZWFyaW5nIGl0LgogICAgICAgIChXZWJDb3JlOjpCYWNrRm9yd2FyZExpc3Q6 OnNldEVuYWJsZWQpOiBkaXR0by4KICAgICAgICAqIGhpc3RvcnkvQmFja0ZvcndhcmRMaXN0Lmg6 IGRpdHRvLgogICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKToKICAgICAgICBT YWZlIGd1YXJkIGFkZDogT25seSB0cmlnZ2VycyB0aGUgQmFja2Zvd2FyZExpc3Q6OmdvVG9JdGVt KCkgZnJvbQogICAgICAgIEZyYW1lTG9hZGVyOjpjaGVja0xvYWRDb21wbGV0ZUZvclRoaXNGcmFt ZSBpZiBtX2N1cnJlbnRIaXN0b3J5SXRlbQogICAgICAgIGhhdmUgbm90IGNoYW5nZWQgaW4gdGhl IG1lYW53aGlsZS4KLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDIyICsrKysrKysKIFdlYkNvcmUvaGlzdG9yeS9CYWNrRm9yd2FyZExpc3Qu Y3BwICAgICAgICAgICAgICB8ICAgIDQgKy0KIFdlYkNvcmUvaGlzdG9yeS9CYWNrRm9yd2FyZExp c3QuaCAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVy LmNwcCAgICAgICAgICAgICAgICAgICB8ICAgIDIgKy0KIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1l LmNwcCAgICAgICAgICAgICAgICAgICAgICB8ICAgNzIgKysrKysrKysrKysrKysrKysrKystCiBX ZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsr KysrCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggICAgICAgICAgICAgICAgICAgICAgfCAg ICAzICsKIFdlYktpdC9xdC9BcGkvcXdlYmhpc3RvcnkuY3BwICAgICAgICAgICAgICAgICAgICB8 ICAgNDAgKysrKysrKysrKysrLQogV2ViS2l0L3F0L0FwaS9xd2ViaGlzdG9yeS5oICAgICAgICAg ICAgICAgICAgICAgIHwgICAgMyArCiBXZWJLaXQvcXQvQ2hhbmdlTG9nICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgfCAgIDMzICsrKysrKysrKysKIFdlYktpdC9xdC9XZWJDb3JlU3VwcG9y dC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCB8ICAgMjIgKysrKy0tLQogMTEgZmlsZXMgY2hhbmdl ZCwgMjAxIGluc2VydGlvbnMoKyksIDE4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNv cmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDhjMjEzYS4uZmQwYjJhYyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwyNSBAQAorMjAwOS0wOS0xNCAgQW50b25pbyBHb21lcyAodG9uaWtpdG9vKSA8YW50 b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yOTI0OAorICAgICAgICBbUXRdIFtBUEldIE1ha2UgaXQgcG9zc2libGUgdG8gaGF2ZSAnaW52 aXNpYmxlJyBsb2FkcworCisgICAgICAgIFdlYkNvcmUgbWlub3IgY2hhbmdlcyB0byBtYWtlIGlu dmlzaWJsZSBsb2FkcyBwb3NzaWJsZS4KKworICAgICAgICBObyBuZXcgdGVzdHMuIChPT1BTISkK KworICAgICAgICAqIGhpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmNwcDoKKyAgICAgICAgTWFrZXMg aXQgcG9zc2libGUgdG8gZGlzYWJsZSB0aGUgQmFja0ZvcndhcmRMaXN0IHdpdGhvdXQgbmVjZXNz YXJpbHkKKyAgICAgICAgY2xlYXJpbmcgaXQuCisgICAgICAgIChXZWJDb3JlOjpCYWNrRm9yd2Fy ZExpc3Q6OnNldEVuYWJsZWQpOiBkaXR0by4KKyAgICAgICAgKiBoaXN0b3J5L0JhY2tGb3J3YXJk TGlzdC5oOiBkaXR0by4KKyAgICAgICAgKiBsb2FkZXIvRnJhbWVMb2FkZXIuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6RnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1lKToK KyAgICAgICAgU2FmZSBndWFyZCBhZGQ6IE9ubHkgdHJpZ2dlcnMgdGhlIEJhY2tmb3dhcmRMaXN0 Ojpnb1RvSXRlbSgpIGZyb20KKyAgICAgICAgRnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRl Rm9yVGhpc0ZyYW1lIGlmIG1fY3VycmVudEhpc3RvcnlJdGVtCisgICAgICAgIGhhdmUgbm90IGNo YW5nZWQgaW4gdGhlIG1lYW53aGlsZS4KKwogMjAwOS0wOS0xMyAgS2V2aW4gT2xsaXZpZXIgIDxr ZXZpbm9AdGhlb2xsaXZpZXJzLmNvbT4KIAogICAgICAgICB3eCBidWlsZCBmaXgsIGZpbGUgd2Fz IG1pc3NlZCBkdXJpbmcgVExTLmNwcCByZW1vdmFsLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9oaXN0 b3J5L0JhY2tGb3J3YXJkTGlzdC5jcHAgYi9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0 LmNwcAppbmRleCBkMTBlNjFjLi42MGVmMzA1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2hpc3Rvcnkv QmFja0ZvcndhcmRMaXN0LmNwcAorKysgYi9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0 LmNwcApAQCAtMTg1LDEwICsxODUsMTAgQEAgYm9vbCBCYWNrRm9yd2FyZExpc3Q6OmVuYWJsZWQo KQogICAgIHJldHVybiBtX2VuYWJsZWQ7CiB9CiAKLXZvaWQgQmFja0ZvcndhcmRMaXN0OjpzZXRF bmFibGVkKGJvb2wgZW5hYmxlZCkKK3ZvaWQgQmFja0ZvcndhcmRMaXN0OjpzZXRFbmFibGVkKGJv b2wgZW5hYmxlZCwgYm9vbCBjbGVhcikKIHsKICAgICBtX2VuYWJsZWQgPSBlbmFibGVkOwotICAg IGlmICghZW5hYmxlZCkgeworICAgIGlmICghZW5hYmxlZCAmJiBjbGVhcikgewogICAgICAgICBp bnQgY2FwYWNpdHkgPSBtX2NhcGFjaXR5OwogICAgICAgICBzZXRDYXBhY2l0eSgwKTsKICAgICAg ICAgc2V0Q2FwYWNpdHkoY2FwYWNpdHkpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9oaXN0b3J5L0Jh Y2tGb3J3YXJkTGlzdC5oIGIvV2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkTGlzdC5oCmluZGV4 IGZkYzMzNjAuLjA0OThhMmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaGlzdG9yeS9CYWNrRm9yd2Fy ZExpc3QuaAorKysgYi9XZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRMaXN0LmgKQEAgLTg1LDcg Kzg1LDcgQEAgcHVibGljOgogICAgIGludCBjYXBhY2l0eSgpOwogICAgIHZvaWQgc2V0Q2FwYWNp dHkoaW50KTsKICAgICBib29sIGVuYWJsZWQoKTsKLSAgICB2b2lkIHNldEVuYWJsZWQoYm9vbCk7 CisgICAgdm9pZCBzZXRFbmFibGVkKGJvb2wgZW5hYmxlZCwgYm9vbCBjbGVhciA9IHRydWUpOwog ICAgIGludCBiYWNrTGlzdENvdW50KCk7CiAgICAgaW50IGZvcndhcmRMaXN0Q291bnQoKTsKICAg ICBib29sIGNvbnRhaW5zSXRlbShIaXN0b3J5SXRlbSopOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9s b2FkZXIvRnJhbWVMb2FkZXIuY3BwIGIvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCmlu ZGV4IDk3YjdmZTguLmY0NjZlNWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9h ZGVyLmNwcAorKysgYi9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAKQEAgLTMzNzksNyAr MzM3OSw3IEBAIHZvaWQgRnJhbWVMb2FkZXI6OmNoZWNrTG9hZENvbXBsZXRlRm9yVGhpc0ZyYW1l KCkKICAgICAgICAgICAgICAgICAgICAgICAgIHNob3VsZFJlc2V0ID0gZmFsc2U7CiAgICAgICAg ICAgICAgICAgfQogICAgICAgICAgICAgfQotICAgICAgICAgICAgaWYgKHNob3VsZFJlc2V0ICYm IGl0ZW0pCisgICAgICAgICAgICBpZiAoc2hvdWxkUmVzZXQgJiYgaXRlbSAmJiAoaXRlbSA9PSBt X2N1cnJlbnRIaXN0b3J5SXRlbSkpCiAgICAgICAgICAgICAgICAgaWYgKFBhZ2UqIHBhZ2UgPSBt X2ZyYW1lLT5wYWdlKCkpIHsKICAgICAgICAgICAgICAgICAgICAgcGFnZS0+YmFja0ZvcndhcmRM aXN0KCktPmdvVG9JdGVtKGl0ZW0uZ2V0KCkpOwogICAgICAgICAgICAgICAgICAgICBTZXR0aW5n cyogc2V0dGluZ3MgPSBtX2ZyYW1lLT5zZXR0aW5ncygpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0 L0FwaS9xd2ViZnJhbWUuY3BwIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCmluZGV4IGY1 NjM1MTguLjM4MTNhZmQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcAor KysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKQEAgLTYzNiw2ICs2MzYsOCBAQCB2b2lk IFFXZWJGcmFtZTo6bG9hZChjb25zdCBRV2ViTmV0d29ya1JlcXVlc3QgJnJlcSkKICAgICBpZiAo IXBvc3REYXRhLmlzRW1wdHkoKSkKICAgICAgICAgcmVxdWVzdC5zZXRIVFRQQm9keShXZWJDb3Jl OjpGb3JtRGF0YTo6Y3JlYXRlKHBvc3REYXRhLmNvbnN0RGF0YSgpLCBwb3N0RGF0YS5zaXplKCkp KTsKIAorICAgIGQtPmxvYWRNb2RlID0gU3RhbmRhcmRMb2FkOworCiAgICAgZC0+ZnJhbWUtPmxv YWRlcigpLT5sb2FkKHJlcXVlc3QsIGZhbHNlKTsKIAogICAgIGlmIChkLT5wYXJlbnRGcmFtZSgp KQpAQCAtNjkyLDYgKzY5NCw4IEBAIHZvaWQgUVdlYkZyYW1lOjpsb2FkKGNvbnN0IFFOZXR3b3Jr UmVxdWVzdCAmcmVxLAogICAgIGlmICghYm9keS5pc0VtcHR5KCkpCiAgICAgICAgIHJlcXVlc3Qu c2V0SFRUUEJvZHkoV2ViQ29yZTo6Rm9ybURhdGE6OmNyZWF0ZShib2R5LmNvbnN0RGF0YSgpLCBi b2R5LnNpemUoKSkpOwogCisgICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFyZExvYWQ7CisKICAgICBk LT5mcmFtZS0+bG9hZGVyKCktPmxvYWQocmVxdWVzdCwgZmFsc2UpOwogCiAgICAgaWYgKGQtPnBh cmVudEZyYW1lKCkpCkBAIC03MTQsMTEgKzcxOCw3MSBAQCB2b2lkIFFXZWJGcmFtZTo6bG9hZChj b25zdCBRTmV0d29ya1JlcXVlc3QgJnJlcSwKICovCiB2b2lkIFFXZWJGcmFtZTo6c2V0SHRtbChj b25zdCBRU3RyaW5nICZodG1sLCBjb25zdCBRVXJsICZiYXNlVXJsKQogewotICAgIEtVUkwga3Vy bChiYXNlVXJsKTsKLSAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsK KyAgICBzZXRIdG1sKGh0bWwsIGJhc2VVcmwsIFFVcmwoKSwgU3RhbmRhcmRMb2FkKTsKK30KKwor LyohCisgIFxzaW5jZSA0LjYKKyAgU2V0cyB0aGUgY29udGVudCBvZiB0aGlzIGZyYW1lIHRvIFxh IGh0bWwuIFxhIGJhc2VVcmwgaXMgb3B0aW9uYWwgYW5kIHVzZWQgdG8gcmVzb2x2ZSByZWxhdGl2 ZQorICBVUkxzIGluIHRoZSBkb2N1bWVudCwgc3VjaCBhcyByZWZlcmVuY2VkIGltYWdlcyBvciBz dHlsZXNoZWV0cy4gVGhlIHN1YnN0aXR1dGUgdXJsIFxhIHN1YnN0aXR1dGVVcmwKKyAgaXMgYWxz byBvcHRpb25hbCBhbmQgaXMgdGhlIFVybCB0aGF0IGlzIGdvaW5nIHRvIGJlIHJlZmVycmVkIGZv ciB0aGlzIGxvYWQgKG5vIG1hdHRlciB0aGUgaHRtbAorICBzdHJpbmcgXGh0bWwgcGFzc2VkIGlu KS4gVGhlIFxhIG1vZGUgbXVzdCBiZSBRV2ViRnJhbWU6OlN0YW5kYXJkTG9hZCAoZGVmYXVsdCks IFFXZWJGcmFtZTo6Tm9TaWduYWxFbWlzc2lvbiwKKyAgUVdlYkZyYW1lOjpOb1Nlc3Npb25IaXN0 b3J5Q2hhbmdlLCBRV2ViRnJhbWU6Ok5vR2xvYmFsSGlzdG9yeUNoYW5nZSBvciBhbnkgYSBjb21i aW5hdGlvbiBvZiB0aGVtLgorCisgIFxub3RlIElmIFxse1FXZWJGcmFtZTo6fXtTdGFuZGFyZExv YWR9IGlzIHBhc3NlZCBhcyBhIGxvYWQgZmxhZywgYWxsIG90aGVyIHZhbHVlcyBwb3NzaWJseQor ICBjb21iaW5lZCBhcmUgaWdub3JlZC4KKworICBUaGUgXGEgaHRtbCBpcyBsb2FkZWQgaW1tZWRp YXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25vdXNseS4KKworICBX aGVuIHVzaW5nIHRoaXMgbWV0aG9kIFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwgcmVzb3Vy Y2VzIHN1Y2ggYXMgSmF2YVNjcmlwdCBwcm9ncmFtcyBvciBzdHlsZQorICBzaGVldHMgYXJlIGVu Y29kZWQgaW4gVVRGLTggdW5sZXNzIG90aGVyd2lzZSBzcGVjaWZpZWQuIEZvciBleGFtcGxlLCB0 aGUgZW5jb2Rpbmcgb2YgYW4gZXh0ZXJuYWwKKyAgc2NyaXB0IGNhbiBiZSBzcGVjaWZpZWQgdGhy b3VnaCB0aGUgY2hhcnNldCBhdHRyaWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRhZy4gSXQgaXMg YWxzbyBwb3NzaWJsZQorICBmb3IgdGhlIGVuY29kaW5nIHRvIGJlIHNwZWNpZmllZCBieSB3ZWIg c2VydmVyLgorCisgIFxzYSBzZXRIdG1sKCksIHRvSHRtbCgpCisqLwordm9pZCBRV2ViRnJhbWU6 OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCwKKyAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IFFVcmwgJnN1YnN0aXR1dGVVcmwsIExvYWRNb2RlIG1v ZGUpCisKK3sKKyAgICBLVVJMIGt1cmwgPSBLVVJMKGJhc2VVcmwpOworICAgIGQtPmxvYWRNb2Rl ID0gbW9kZTsKKworICAgIGlmICghc3Vic3RpdHV0ZVVybC50b1N0cmluZygpLmlzRW1wdHkoKSkK KyAgICAgICAga3VybCA9IEtVUkwoc3Vic3RpdHV0ZVVybCk7CisgICAgLy8gSWYgbG9hZCB0eXBl IGlzIG5vdCAic3RhbmRhcmQiIGFuZCBubyBzdWJzdGl0dXRlIHVybCBpcyBwYXNzZWQgaW4KKyAg ICAvLyB3ZSBhc3N1bWUgY2FsbGVyIHdhbnRzIHRvIHNldCB0aGUgSFRNTCBvZiB0aGUgcGFnZSBi dXQgbm90IGNoYW5nZQorICAgIC8vIHRoZSBjdXJyZW50IHVybCAoZS5nLiB3aGVuIGNhbGxlciBp cyBzZXR0aW5nIGEgSFRNTCBlcnJvciBwYWdlCisgICAgLy8gb2YgYSBmYWlsaW5nIGxvYWQpLgor ICAgIGVsc2UgaWYgKCEobW9kZSAmIFN0YW5kYXJkTG9hZCkpIHsKKyAgICAgICAgLy8gQWZ0ZXIg YSBsb2FkIGhhcyBzdWNjZXNzZnVsbHkgZmluaXNoZWQsIHRoZSBsb2FkZWQgVXJsIGlzIGF2YWls YWJsZQorICAgICAgICAvLyB0aHJvdWdoIHRoZSB1cmwoKSBjbGFzcyBtZXRob2QuIFdoZW4gdGhl IGxvYWQgaXMgbm90IHN1Y2Nlc3NmdWxseQorICAgICAgICAvLyB0aG91Z2gsIHRoZSBmcmFtZSBs b2FkZXIgZG9lcyBub3QgZ2V0IGNvbW1pdHRlZCwgYW5kCisgICAgICAgIC8vIGFueSBjYWxsIHRv IHVybCgpIG1ldGhvZCB3aWxsIHN0aWxsIHJldHVybiB0aGUgbGFzdCBzdWNjZXNzZnVsIFVybAor ICAgICAgICAvLyBsb2FkZWQuIEluIHN1Y2ggY2FzZXMsIHRoZSBmYWlsaW5nIFVybCBjYW4gYmUg cmV0cmlldmVkIGJ5IHVzaW5nCisgICAgICAgIC8vIGZyYW1lTG9hZGVyQ2xpZW50J3MgbV9sb2Fk RXJyb3IgY2xhc3MgbWVtYmVyLCB3aGljaCBrZWVwcyB0cmFjayBvZgorICAgICAgICAvLyBlcnJv cnMgZHVyaW5nIHVuc3VjY2Vzc2Z1bCBsb2Fkcy4KKyAgICAgICAgaWYgKCFkLT5mcmFtZUxvYWRl ckNsaWVudC0+bV9sb2FkRXJyb3IuZmFpbGluZ1VSTCgpLmlzRW1wdHkoKSkKKyAgICAgICAgICAg IGt1cmwgPSBLVVJMKFFVcmwoZC0+ZnJhbWVMb2FkZXJDbGllbnQtPm1fbG9hZEVycm9yLmZhaWxp bmdVUkwoKSkpOworICAgICAgICBlbHNlIGlmICghdXJsKCkudG9TdHJpbmcoKS5pc0VtcHR5KCkp CisgICAgICAgICAgICBrdXJsID0gS1VSTCh1cmwoKSk7CisKKyAgICAgICAgLy8gaWYgVXJsIGlz IGFscmVhZHkgaW4gdGhlIGJhY2svZm9yd2FyZCBoaXN0b3J5IGxldHMga2VlcCBpdAorICAgICAg ICAvLyB1bmNoYW5nZWQuCisgICAgICAgIGlmIChkLT5wYWdlLT5oaXN0b3J5KCktPmNvbnRhaW5z KGt1cmwpICE9IC0xKQorICAgICAgICAgICBtb2RlIHw9IE5vU2Vzc2lvbkhpc3RvcnlDaGFuZ2U7 CisgICAgfQorCisgICAgLy8gSWYgb25seSBzZXNzaW9uIGhpc3RvcnkgaXMgdG8gYmUgJ2xvY2tl ZCcsIHdlIGNhbiBqdXN0ICBkaXNhYmxlIGl0IGFuZAorICAgIC8vIHJlLWVuYWJsZSBsYXRlciBv biAoKS4KKyAgICAvLyBOT1RFOiBHbG9iYWwgaGlzdG9yeSBvbmx5IGxvY2tzIGFyZSBoYW5kbGVk IGluIEZyYW1lTG9hZENsaWVudCBzaWRlLgorICAgIGlmIChtb2RlICYgTm9TZXNzaW9uSGlzdG9y eUNoYW5nZSkKKyAgICAgICAgZC0+cGFnZS0+aGlzdG9yeSgpLT5zZXRFbmFibGVkKGZhbHNlKTsK KworICAgIFJlc291cmNlUmVxdWVzdCByZXF1ZXN0KGt1cmwpOwogICAgIGNvbnN0IFFCeXRlQXJy YXkgdXRmOCA9IGh0bWwudG9VdGY4KCk7Ci0gICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6U2hhcmVk QnVmZmVyPiBkYXRhID0gV2ViQ29yZTo6U2hhcmVkQnVmZmVyOjpjcmVhdGUodXRmOC5jb25zdERh dGEoKSwgdXRmOC5sZW5ndGgoKSk7Ci0gICAgV2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vic3Rp dHV0ZURhdGEoZGF0YSwgV2ViQ29yZTo6U3RyaW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6U3Ry aW5nKCJ1dGYtOCIpLCBrdXJsKTsKKyAgICBXVEY6OlJlZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGEg PSBTaGFyZWRCdWZmZXI6OmNyZWF0ZSh1dGY4LmNvbnN0RGF0YSgpLCB1dGY4Lmxlbmd0aCgpKTsK KyAgICBTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShkYXRhLCBTdHJpbmcoInRleHQvaHRt bCIpLCBTdHJpbmcoInV0Zi04IiksIGt1cmwsIGt1cmwpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIo KS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCmRpZmYgLS1naXQg YS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaApp bmRleCA1NWM3M2I0Li43MjAwNDU2IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFt ZS5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKQEAgLTEyMiw2ICsxMjIsMTggQEAg cHJpdmF0ZToKIHB1YmxpYzoKICAgICBRV2ViUGFnZSAqcGFnZSgpIGNvbnN0OwogCisgICAgZW51 bSBNYWluRnJhbWVMb2FkRmxhZyB7CisgICAgICAgIE5vU2lnbmFsRW1pc3Npb24gPSAweDEsCisg ICAgICAgIE5vU2Vzc2lvbkhpc3RvcnlDaGFuZ2UgPSAweDIsCisgICAgICAgIE5vR2xvYmFsSGlz dG9yeUNoYW5nZSA9IDB4NCwKKyAgICAgICAgU3RhbmRhcmRMb2FkID0gMHg4CisgICAgfTsKKwor ICAgIFFfREVDTEFSRV9GTEFHUyhMb2FkRmxhZ3MsIE1haW5GcmFtZUxvYWRGbGFnKQorICAgIFFf RkxBR1MoTG9hZEZsYWdzKQorCisgICAgdHlwZWRlZiBMb2FkRmxhZ3MgTG9hZE1vZGU7CisKICAg ICB2b2lkIGxvYWQoY29uc3QgUVVybCAmdXJsKTsKICNpZiBRVF9WRVJTSU9OIDwgMHgwNDA0MDAK ICAgICB2b2lkIGxvYWQoY29uc3QgUVdlYk5ldHdvcmtSZXF1ZXN0ICZyZXF1ZXN0KTsKQEAgLTEz MSw2ICsxNDMsOCBAQCBwdWJsaWM6CiAgICAgICAgICAgICAgIGNvbnN0IFFCeXRlQXJyYXkgJmJv ZHkgPSBRQnl0ZUFycmF5KCkpOwogI2VuZGlmCiAgICAgdm9pZCBzZXRIdG1sKGNvbnN0IFFTdHJp bmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwgPSBRVXJsKCkpOworICAgIHZvaWQgc2V0SHRt bChjb25zdCBRU3RyaW5nICZodG1sLCBjb25zdCBRVXJsICZiYXNlVXJsLCBjb25zdCBRVXJsICZz dWJzdGl0dXRlVXJsLCBMb2FkTW9kZSBtb2RlKTsKKwogICAgIHZvaWQgc2V0Q29udGVudChjb25z dCBRQnl0ZUFycmF5ICZkYXRhLCBjb25zdCBRU3RyaW5nICZtaW1lVHlwZSA9IFFTdHJpbmcoKSwg Y29uc3QgUVVybCAmYmFzZVVybCA9IFFVcmwoKSk7CiAKICAgICB2b2lkIGFkZFRvSmF2YVNjcmlw dFdpbmRvd09iamVjdChjb25zdCBRU3RyaW5nICZuYW1lLCBRT2JqZWN0ICpvYmplY3QpOwpAQCAt MjI1LDQgKzIzOSw2IEBAIHByaXZhdGU6CiAgICAgUVdlYkZyYW1lUHJpdmF0ZSAqZDsKIH07CiAK K1FfREVDTEFSRV9PUEVSQVRPUlNfRk9SX0ZMQUdTKFFXZWJGcmFtZTo6TG9hZEZsYWdzKQorCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3AuaCBiL1dlYktpdC9x dC9BcGkvcXdlYmZyYW1lX3AuaAppbmRleCA2MzJmODNhLi45M2Y5NzJhIDEwMDY0NAotLS0gYS9X ZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWVf cC5oCkBAIC0yOCw2ICsyOCw3IEBACiAjaW5jbHVkZSAiS1VSTC5oIgogI2luY2x1ZGUgIlBsYXRm b3JtU3RyaW5nLmgiCiAjaW5jbHVkZSAicXdlYmVsZW1lbnQuaCIKKyNpbmNsdWRlICJxd2ViZnJh bWUuaCIKICNpbmNsdWRlICJ3dGYvUmVmUHRyLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKIApAQCAt NzEsNiArNzIsNyBAQCBwdWJsaWM6CiAgICAgICAgICwgbWFyZ2luV2lkdGgoLTEpCiAgICAgICAg ICwgbWFyZ2luSGVpZ2h0KC0xKQogICAgICAgICAsIGNsaXBSZW5kZXJUb1ZpZXdwb3J0KHRydWUp CisgICAgICAgICwgbG9hZE1vZGUoUVdlYkZyYW1lOjpTdGFuZGFyZExvYWQpCiAgICAgICAgIHt9 CiAgICAgdm9pZCBpbml0KFFXZWJGcmFtZSogcWZyYW1lLCBRV2ViRnJhbWVEYXRhKiBmcmFtZURh dGEpOwogCkBAIC05NSw2ICs5Nyw3IEBAIHB1YmxpYzoKICAgICBpbnQgbWFyZ2luV2lkdGg7CiAg ICAgaW50IG1hcmdpbkhlaWdodDsKICAgICBib29sIGNsaXBSZW5kZXJUb1ZpZXdwb3J0OworICAg IFFXZWJGcmFtZTo6TG9hZE1vZGUgbG9hZE1vZGU7CiB9OwogCiBjbGFzcyBRV2ViSGl0VGVzdFJl c3VsdFByaXZhdGUgewpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViaGlzdG9yeS5jcHAg Yi9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmNwcAppbmRleCBiNTcyNzJkLi41NDZiMTJjIDEw MDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmNwcAorKysgYi9XZWJLaXQvcXQv QXBpL3F3ZWJoaXN0b3J5LmNwcApAQCAtNDY3LDYgKzQ2Nyw0NSBAQCB2b2lkIFFXZWJIaXN0b3J5 OjpzZXRNYXhpbXVtSXRlbUNvdW50KGludCBjb3VudCkKICAgICBkLT5sc3QtPnNldENhcGFjaXR5 KGNvdW50KTsKIH0KIAorLyoKKyAgIFxzaW5jZSA0LjYKKyAgIFNldHMgdGhlIGhpc3Rvcnkgc3Rh dHVzIGFjY29yZGluZyB0byBcYSBzdGF0dXMuIElmIGZhbHNlIGlzIHBhc3NlZCBpbiwKKyAgIGhp c3RvcnkgY29udGVudCByZW1haW5zIHVuY2hhbmdlZCB1bnRpbCBpdCBpcyBlbmFibGVkIGJhY2su CisgICBcc2EgaXNFbmFibGVkKCksIGNvbnRhaW5zKCkKKyovCit2b2lkIFFXZWJIaXN0b3J5Ojpz ZXRFbmFibGVkKGJvb2wgc3RhdHVzKQoreworICAgIGlmIChkLT5sc3QtPmVuYWJsZWQoKSAhPSBz dGF0dXMpCisgICAgICAgIGQtPmxzdC0+c2V0RW5hYmxlZChzdGF0dXMsIC8qIGNsZWFyIG9uIGRp c2FibGluZyAqLyBmYWxzZSk7Cit9CisKKy8qCisgICBcc2luY2UgNC42CisgICBSZXR1cm5zIGlm IHRoZSBoaXN0b3J5IGlzIGluICdsb2NrZWQnIHN0YXRlIG9yIG5vdC4KKyAgIFxzYSBzZXRFbmFi bGVkKCkKKyovCitib29sIFFXZWJIaXN0b3J5Ojppc0VuYWJsZWQoKSBjb25zdAoreworICAgIHJl dHVybiBkLT5sc3QtPmVuYWJsZWQoKTsKK30KKworLyoKKyAgIFxzaW5jZSA0LjYKKyAgIFJldHVy bnMgaWYgYSBnaXZlbiB1cmwgXGEgdXJsIGlzIGluIHRoZSBoaXN0b3J5LgorKi8KK2ludCBRV2Vi SGlzdG9yeTo6Y29udGFpbnMoY29uc3QgUVVybCYgdXJsKSBjb25zdAoreworICAgIGNvbnN0IFdl YkNvcmU6Okhpc3RvcnlJdGVtVmVjdG9yICZpdGVtcyA9IGQtPmxzdC0+ZW50cmllcygpOworCisg ICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGl0ZW1zLnNpemUoKTsgKytpKSB7CisgICAgICAg IFdlYkNvcmU6Okhpc3RvcnlJdGVtKiBpdGVtID0gZC0+bHN0LT5pdGVtQXRJbmRleChpKTsKKyAg ICAgICAgaWYgKGl0ZW0gJiYgKGl0ZW0tPnVybCgpID09IHVybCB8fCBpdGVtLT5vcmlnaW5hbFVS TCgpID09IHVybCkpCisgICAgICAgICAgICByZXR1cm4gaTsKKyAgICB9CisKKyAgICByZXR1cm4g LTE7Cit9CisKIC8qIQogICAgXGVudW0gUVdlYkhpc3Rvcnk6Okhpc3RvcnlTdGF0ZVZlcnNpb24K IApAQCAtNTkyLDQgKzYzMSwzIEBAIFFEYXRhU3RyZWFtJiBvcGVyYXRvcj4+KFFEYXRhU3RyZWFt JiBzdHJlYW0sIFFXZWJIaXN0b3J5JiBoaXN0b3J5KQogICAgIHJldHVybiBzdHJlYW07CiB9CiAK LQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0FwaS9xd2ViaGlzdG9yeS5oIGIvV2ViS2l0L3F0L0Fw aS9xd2ViaGlzdG9yeS5oCmluZGV4IGU0NmYxMjQuLjAyNDRhMDcgMTAwNjQ0Ci0tLSBhL1dlYktp dC9xdC9BcGkvcXdlYmhpc3RvcnkuaAorKysgYi9XZWJLaXQvcXQvQXBpL3F3ZWJoaXN0b3J5LmgK QEAgLTg2LDYgKzg2LDggQEAgcHVibGljOgogICAgIFFCeXRlQXJyYXkgc2F2ZVN0YXRlKEhpc3Rv cnlTdGF0ZVZlcnNpb24gdmVyc2lvbiA9IERlZmF1bHRIaXN0b3J5VmVyc2lvbikgY29uc3Q7CiAK ICAgICB2b2lkIGNsZWFyKCk7CisgICAgdm9pZCBzZXRFbmFibGVkKGJvb2wgc3RhdHVzKTsKKyAg ICBib29sIGlzRW5hYmxlZCgpIGNvbnN0OwogCiAgICAgUUxpc3Q8UVdlYkhpc3RvcnlJdGVtPiBp dGVtcygpIGNvbnN0OwogICAgIFFMaXN0PFFXZWJIaXN0b3J5SXRlbT4gYmFja0l0ZW1zKGludCBt YXhJdGVtcykgY29uc3Q7CkBAIC0xMDYsNiArMTA4LDcgQEAgcHVibGljOgogICAgIGludCBjdXJy ZW50SXRlbUluZGV4KCkgY29uc3Q7CiAKICAgICBpbnQgY291bnQoKSBjb25zdDsKKyAgICBpbnQg Y29udGFpbnMoY29uc3QgUVVybCYgdXJsKSBjb25zdDsKIAogICAgIGludCBtYXhpbXVtSXRlbUNv dW50KCkgY29uc3Q7CiAgICAgdm9pZCBzZXRNYXhpbXVtSXRlbUNvdW50KGludCBjb3VudCk7CmRp ZmYgLS1naXQgYS9XZWJLaXQvcXQvQ2hhbmdlTG9nIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwppbmRl eCBmODY0YmNjLi5jMGU4NTRkIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQ2hhbmdlTG9nCisrKyBi L1dlYktpdC9xdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAorMjAwOS0wOS0xNCAgQW50b25p byBHb21lcyAgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI5MjQ4CisgICAgICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJs ZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRzCisKKyAgICAgICAgSW50cm9kdWNlcyBhIHdheSB0 aGF0IG1ha2VzIGl0IHBvc3NpYmxlIGZvciBzdWJzdGl0dXRlIGxvYWRzCisgICAgICAgIChlLmcu IFFXZWJGcmFtZTo6c2V0SHRtbCBhbmQgUVdlYkZyYW1lOjpzZXRDb250ZW50cykgdG8gbm90Cisg ICAgICAgIGNoYW5nZSBnbG9iYWwgYW5kL29yIHNlc3Npb24gaGlzdG9yeSBjb250ZW50cywgYW5k IHRvIG5vdAorICAgICAgICBlbWl0IHNpZ25hbHMgcmVsYXRlZCB0byB0aGUgbG9hZGluZyBwcm9j ZXNzLgorCisgICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2ViRnJhbWU6 OmxvYWQpOgorICAgICAgICAoUVdlYkZyYW1lOjpzZXRIdG1sKToKKyAgICAgICAgKiBBcGkvcXdl YmZyYW1lLmg6CisgICAgICAgICogQXBpL3F3ZWJmcmFtZV9wLmg6CisgICAgICAgIChRV2ViRnJh bWVQcml2YXRlOjpRV2ViRnJhbWVQcml2YXRlKToKKyAgICAgICAgKiBBcGkvcXdlYmhpc3Rvcnku Y3BwOgorICAgICAgICAoUVdlYkhpc3Rvcnk6OnNldEVuYWJsZWQpOiBzZXRzIHRoZSBiYWNrL2Zv cndhcmQgaGlzdG9yeQorICAgICAgICBzdGF0dXMKKyAgICAgICAgKFFXZWJIaXN0b3J5Ojppc0Vu YWJsZWQpOiByZXR1cm4gYmFjay9mb3J3YXJkIGhpc3Rvcnkgc3RhdHVzCisgICAgICAgIChRV2Vi SGlzdG9yeTo6Y29udGFpbnMpOiByZXR1cm5zIGlmIGEgZ2l2ZW4gVXJsIGlzIGluIHRoZQorICAg ICAgICBiYWNrIGZvcndhcmQgaGlzdG9yeS4KKyAgICAgICAgKiBBcGkvcXdlYmhpc3RvcnkuaDoK KyAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkQ2hhbmdlTG9jYXRp b25XaXRoaW5QYWdlKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRp c3BhdGNoRGlkQ29tbWl0TG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVu dFF0OjpkaXNwYXRjaERpZEZpbmlzaExvYWQpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2Fk ZXJDbGllbnRRdDo6cG9zdFByb2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbik6CisgICAgICAgIChX ZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZFJlY2VpdmVJY29uKToKKyAg ICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OnVwZGF0ZUdsb2JhbEhpc3Rvcnkp OgorCiAyMDA5LTA5LTExICBEYXZpZCBCb2RkaWUgIDxkYm9kZGllQHRyb2xsdGVjaC5jb20+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1c21hbm4uCmRpZmYgLS1naXQgYS9XZWJLaXQv cXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAgYi9XZWJLaXQvcXQvV2Vi Q29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKaW5kZXggMTA3MWEyNi4uYTQzOTUx MyAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuY3BwCisrKyBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0 LmNwcApAQCAtMjk4LDcgKzI5OCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0 Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UoKQogICAgIGlmIChkdW1wRnJhbWVMb2FkZXJD YWxsYmFja3MpCiAgICAgICAgIHByaW50ZigiJXMgLSBkaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBh Z2VGb3JGcmFtZVxuIiwgcVByaW50YWJsZShkcnREZXNjcmlwdGlvblN1aXRhYmxlRm9yVGVzdFJl c3VsdChtX2ZyYW1lKSkpOwogCi0gICAgaWYgKCFtX3dlYkZyYW1lKQorICAgIGlmICghbV93ZWJG cmFtZSB8fCAhKG1fd2ViRnJhbWUtPmQtPmxvYWRNb2RlICYgUVdlYkZyYW1lOjpTdGFuZGFyZExv YWQpKQogICAgICAgICByZXR1cm47CiAKICAgICBlbWl0IG1fd2ViRnJhbWUtPnVybENoYW5nZWQo bV93ZWJGcmFtZS0+dXJsKCkpOwpAQCAtMzQwLDcgKzM0MCw3IEBAIHZvaWQgRnJhbWVMb2FkZXJD bGllbnRRdDo6ZGlzcGF0Y2hEaWRDb21taXRMb2FkKCkKICAgICBpZiAoZHVtcEZyYW1lTG9hZGVy Q2FsbGJhY2tzKQogICAgICAgICBwcmludGYoIiVzIC0gZGlkQ29tbWl0TG9hZEZvckZyYW1lXG4i LCBxUHJpbnRhYmxlKGRydERlc2NyaXB0aW9uU3VpdGFibGVGb3JUZXN0UmVzdWx0KG1fZnJhbWUp KSk7CiAKLSAgICBpZiAobV9mcmFtZS0+dHJlZSgpLT5wYXJlbnQoKSB8fCAhbV93ZWJGcmFtZSkK KyAgICBpZiAobV9mcmFtZS0+dHJlZSgpLT5wYXJlbnQoKSB8fCAhbV93ZWJGcmFtZSB8fCAhKG1f d2ViRnJhbWUtPmQtPmxvYWRNb2RlICYgUVdlYkZyYW1lOjpTdGFuZGFyZExvYWQpKQogICAgICAg ICByZXR1cm47CiAKICAgICBlbWl0IG1fd2ViRnJhbWUtPnVybENoYW5nZWQobV93ZWJGcmFtZS0+ dXJsKCkpOwpAQCAtMzc2LDcgKzM3NiwxMCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRp c3BhdGNoRGlkRmluaXNoTG9hZCgpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRlckNhbGxiYWNrcykK ICAgICAgICAgcHJpbnRmKCIlcyAtIGRpZEZpbmlzaExvYWRGb3JGcmFtZVxuIiwgcVByaW50YWJs ZShkcnREZXNjcmlwdGlvblN1aXRhYmxlRm9yVGVzdFJlc3VsdChtX2ZyYW1lKSkpOwogCi0gICAg bV9sb2FkRXJyb3IgPSBSZXNvdXJjZUVycm9yKCk7IC8vIGNsZWFycyB0aGUgcHJldmlvdXMgZXJy b3IKKyAgICAvLyBjbGVhcnMgdGhlIHByZXZpb3VzIGxvYWQgZGF0YQorICAgIG1fbG9hZEVycm9y ID0gUmVzb3VyY2VFcnJvcigpOworICAgIG1fd2ViRnJhbWUtPmQtPmxvYWRNb2RlID0gUVdlYkZy YW1lOjpTdGFuZGFyZExvYWQ7CisgICAgbV93ZWJGcmFtZS0+ZC0+cGFnZS0+aGlzdG9yeSgpLT5z ZXRFbmFibGVkKHRydWUpOwogCiAgICAgaWYgKCFtX3dlYkZyYW1lKQogICAgICAgICByZXR1cm47 CkBAIC00MjksMTIgKzQzMiwxNCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnJldmVydFRv UHJvdmlzaW9uYWxTdGF0ZShEb2N1bWVudExvYWRlciopCiAKIHZvaWQgRnJhbWVMb2FkZXJDbGll bnRRdDo6cG9zdFByb2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbigpCiB7Ci0gICAgaWYgKG1fd2Vi RnJhbWUgJiYgbV9mcmFtZS0+cGFnZSgpKSB7CisgICAgaWYgKG1fZnJhbWUtPnRyZWUoKS0+cGFy ZW50KCkgfHwgIW1fd2ViRnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX2ZyYW1l LT5wYWdlKCkpIHsKICAgICAgICAgZW1pdCBsb2FkU3RhcnRlZCgpOwogICAgICAgICBwb3N0UHJv Z3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmljYXRpb24oKTsKICAgICB9Ci0gICAgaWYgKG1fZnJh bWUtPnRyZWUoKS0+cGFyZW50KCkgfHwgIW1fd2ViRnJhbWUpCi0gICAgICAgIHJldHVybjsKKwog ICAgIG1fd2ViRnJhbWUtPnBhZ2UoKS0+ZC0+dXBkYXRlTmF2aWdhdGlvbkFjdGlvbnMoKTsKIH0K IApAQCAtNTc2LDkgKzU4MSw4IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hE aWRSZWNlaXZlSWNvbigpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRlckNhbGxiYWNrcykKICAgICAg ICAgcHJpbnRmKCIlcyAtIGRpZFJlY2VpdmVJY29uRm9yRnJhbWVcbiIsIHFQcmludGFibGUoZHJ0 RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFtZSkpKTsKIAotICAgIGlmICht X3dlYkZyYW1lKSB7CisgICAgaWYgKG1fd2ViRnJhbWUpCiAgICAgICAgIGVtaXQgbV93ZWJGcmFt ZS0+aWNvbkNoYW5nZWQoKTsKLSAgICB9CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6 ZnJhbWVMb2FkZXJEZXN0cm95ZWQoKQpAQCAtNjI0LDcgKzYyOCw3IEBAIHZvaWQgRnJhbWVMb2Fk ZXJDbGllbnRRdDo6cmVnaXN0ZXJGb3JJY29uTm90aWZpY2F0aW9uKGJvb2wpCiB2b2lkIEZyYW1l TG9hZGVyQ2xpZW50UXQ6OnVwZGF0ZUdsb2JhbEhpc3RvcnkoKQogewogICAgIFFXZWJIaXN0b3J5 SW50ZXJmYWNlICpoaXN0b3J5ID0gUVdlYkhpc3RvcnlJbnRlcmZhY2U6OmRlZmF1bHRJbnRlcmZh Y2UoKTsKLSAgICBpZiAoaGlzdG9yeSkKKyAgICBpZiAoaGlzdG9yeSAmJiAhKG1fd2ViRnJhbWUt PmQtPmxvYWRNb2RlICYgUVdlYkZyYW1lOjpOb0dsb2JhbEhpc3RvcnlDaGFuZ2UpKQogICAgICAg ICBoaXN0b3J5LT5hZGRIaXN0b3J5RW50cnkobV9mcmFtZS0+bG9hZGVyKCktPmRvY3VtZW50TG9h ZGVyKCktPnVybEZvckhpc3RvcnkoKS5wcmV0dHlVUkwoKSk7CiB9CiAKLS0gCjEuNi4wLjQKCg== 39629 2009-09-15 19:51:55 -0700 2009-09-15 19:57:12 -0700 patch 0.2 - same functionality, but no touch to WebCore or qwebhistory BUG_29248_v0.2.diff text/plain 12189 tonikitoo Y29tbWl0IDZlOTE1Y2FhZDNkZTg5N2EzNTdlOThmNmNiNTRiZjAzY2Q1Y2EyZWMKQXV0aG9yOiBB bnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CkRh dGU6ICAgTW9uIFNlcCAxNCAxMjowODoxMyAyMDA5IC0wNDAwCgogICAgMjAwOS0wOS0xNCAgQW50 b25pbyBHb21lcyAgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CiAgICAKICAgICAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCiAgICAKICAgICAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI5MjQ4CiAgICAgICAgICAgIFtRdF0gW0FQ SV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRzCiAgICAKICAgICAg ICAgICAgSW50cm9kdWNlcyBhIHdheSB0aGF0IG1ha2VzIGl0IHBvc3NpYmxlIGZvciBzdWJzdGl0 dXRlIGxvYWRzCiAgICAgICAgICAgIChlLmcuIFFXZWJGcmFtZTo6c2V0SHRtbCBhbmQgUVdlYkZy YW1lOjpzZXRDb250ZW50cykgdG8gbm90CiAgICAgICAgICAgIGNoYW5nZSBnbG9iYWwgYW5kL29y IHNlc3Npb24gaGlzdG9yeSBjb250ZW50cywgYW5kIHRvIG5vdAogICAgICAgICAgICBlbWl0IHNp Z25hbHMgcmVsYXRlZCB0byB0aGUgbG9hZGluZyBwcm9jZXNzLgogICAgCiAgICAgICAgICAgICog QXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgICAgIChRV2ViRnJhbWU6OmxvYWQpOgogICAgICAg ICAgICAoUVdlYkZyYW1lOjpzZXRIdG1sKToKICAgICAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmg6 CiAgICAgICAgICAgICogQXBpL3F3ZWJmcmFtZV9wLmg6CiAgICAgICAgICAgIChRV2ViRnJhbWVQ cml2YXRlOjpRV2ViRnJhbWVQcml2YXRlKToKICAgICAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFF0LmNwcDoKICAgICAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVy Q2xpZW50UXQ6OmRpc3BhdGNoRGlkQ2hhbmdlTG9jYXRpb25XaXRoaW5QYWdlKToKICAgICAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkQ29tbWl0TG9hZCk6 CiAgICAgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZEZp bmlzaExvYWQpOgogICAgICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6cG9z dFByb2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbik6CiAgICAgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlckNsaWVudFF0Ojp1cGRhdGVHbG9iYWxIaXN0b3J5KToKCmRpZmYgLS1naXQgYS9XZWJL aXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5k ZXggZjU2MzUxOC4uMzAzZGExZiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNjM2LDYgKzYzNiw4IEBA IHZvaWQgUVdlYkZyYW1lOjpsb2FkKGNvbnN0IFFXZWJOZXR3b3JrUmVxdWVzdCAmcmVxKQogICAg IGlmICghcG9zdERhdGEuaXNFbXB0eSgpKQogICAgICAgICByZXF1ZXN0LnNldEhUVFBCb2R5KFdl YkNvcmU6OkZvcm1EYXRhOjpjcmVhdGUocG9zdERhdGEuY29uc3REYXRhKCksIHBvc3REYXRhLnNp emUoKSkpOwogCisgICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFyZExvYWQ7CisKICAgICBkLT5mcmFt ZS0+bG9hZGVyKCktPmxvYWQocmVxdWVzdCwgZmFsc2UpOwogCiAgICAgaWYgKGQtPnBhcmVudEZy YW1lKCkpCkBAIC02OTIsNiArNjk0LDggQEAgdm9pZCBRV2ViRnJhbWU6OmxvYWQoY29uc3QgUU5l dHdvcmtSZXF1ZXN0ICZyZXEsCiAgICAgaWYgKCFib2R5LmlzRW1wdHkoKSkKICAgICAgICAgcmVx dWVzdC5zZXRIVFRQQm9keShXZWJDb3JlOjpGb3JtRGF0YTo6Y3JlYXRlKGJvZHkuY29uc3REYXRh KCksIGJvZHkuc2l6ZSgpKSk7CiAKKyAgICBkLT5sb2FkTW9kZSA9IFN0YW5kYXJkTG9hZDsKKwog ICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBmYWxzZSk7CiAKICAgICBpZiAo ZC0+cGFyZW50RnJhbWUoKSkKQEAgLTcxOSw2ICs3MjMsNjcgQEAgdm9pZCBRV2ViRnJhbWU6OnNl dEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAgICBjb25z dCBRQnl0ZUFycmF5IHV0ZjggPSBodG1sLnRvVXRmOCgpOwogICAgIFdURjo6UmVmUHRyPFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcj4gZGF0YSA9IFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0 ZjguY29uc3REYXRhKCksIHV0ZjgubGVuZ3RoKCkpOwogICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVE YXRhIHN1YnN0aXR1dGVEYXRhKGRhdGEsIFdlYkNvcmU6OlN0cmluZygidGV4dC9odG1sIiksIFdl YkNvcmU6OlN0cmluZygidXRmLTgiKSwga3VybCk7CisgICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFy ZExvYWQ7CisgICAgZC0+ZnJhbWUtPmxvYWRlcigpLT5sb2FkKHJlcXVlc3QsIHN1YnN0aXR1dGVE YXRhLCBmYWxzZSk7Cit9CisKKy8qIQorICBcc2luY2UgNC42CisgIFNldHMgdGhlIGNvbnRlbnQg b2YgdGhpcyBmcmFtZSB0byBcYSBodG1sLiBcYSBiYXNlVXJsIGlzIHVzZWQgdG8gcmVzb2x2ZSBy ZWxhdGl2ZQorICBVUkxzIGluIHRoZSBkb2N1bWVudCwgc3VjaCBhcyByZWZlcmVuY2VkIGltYWdl cyBvciBzdHlsZXNoZWV0cy4gSWYgdGhlcmUgaXMgbm8KKyAgcmVsYXRpdmUgVXJscyB0byBiZSBy ZXNvbHZlZCwgYW4gZW1wdHkgVXJsIChRVXJsKCkpIGlzIHRvIGJlIHBhc3NlZCBpbi4gVGhlIHN1 YnN0aXR1dGUKKyAgdXJsIFxhIHN1YnN0aXR1dGVVcmwgaXMgdGhlIFVybCB0aGF0IGlzIGdvaW5n IHRvIGJlIHJlZmVycmVkIGZvciB0aGlzIGxvYWQgKG5vIG1hdHRlcgorICB0aGUgaHRtbCBzdHJp bmcgXGh0bWwgcGFzc2VkIGluKS4gSWYgbm8gdmFsaWQgc3Vic3RpdHV0ZVVybCBpcyBwYXNzZWQs IGl0cyB2YWx1ZSB3aWxsCisgIGJlIGFzc3VtZWQgdG8gYmUgdGhlIGxhdGVzdCBsb2FkZWQgdXJs IChiZWluZyB0aGUgbG9hZCBzdWNjZXNzZnVsIG9yIG5vdCksIG9yIHRoZSBiYXNlVXJsCisgIFxh IGJhc2VVcmwgaW4gdGhhdCBvcmRlci4gVGhlIFxhIG1vZGUgbXVzdCBiZSBRV2ViRnJhbWU6OlN0 YW5kYXJkTG9hZCAoZGVmYXVsdCksCisgIFFXZWJGcmFtZTo6U3Vic3RpdHV0aW9uTG9hZCBvciBR V2ViRnJhbWU6Ok5vR2xvYmFsSGlzdG9yeUNoYW5nZS4KKworICBcbm90ZSBJZiBcbHtRV2ViRnJh bWU6On17U3RhbmRhcmRMb2FkfSBpcyBwYXNzZWQgYXMgYSBsb2FkIHR5cGUsIHRoZSBkZWZhdWx0 IHNldEh0bWwoKQorICBpbXBsZW1lbnRhdGlvbiB3aWxsIGJlIGNhbGxlZCwgaWdub3JpbmcgYW55 IHN1YnN0aXR1dGVVcmwgdmFsdWUuCisKKyAgVGhlIFxhIGh0bWwgaXMgbG9hZGVkIGltbWVkaWF0 ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5bmNocm9ub3VzbHkuCisKKyAgV2hl biB1c2luZyB0aGlzIG1ldGhvZCBXZWJLaXQgYXNzdW1lcyB0aGF0IGV4dGVybmFsIHJlc291cmNl cyBzdWNoIGFzIEphdmFTY3JpcHQgcHJvZ3JhbXMgb3Igc3R5bGUKKyAgc2hlZXRzIGFyZSBlbmNv ZGVkIGluIFVURi04IHVubGVzcyBvdGhlcndpc2Ugc3BlY2lmaWVkLiBGb3IgZXhhbXBsZSwgdGhl IGVuY29kaW5nIG9mIGFuIGV4dGVybmFsCisgIHNjcmlwdCBjYW4gYmUgc3BlY2lmaWVkIHRocm91 Z2ggdGhlIGNoYXJzZXQgYXR0cmlidXRlIG9mIHRoZSBIVE1MIHNjcmlwdCB0YWcuIEl0IGlzIGFs c28gcG9zc2libGUKKyAgZm9yIHRoZSBlbmNvZGluZyB0byBiZSBzcGVjaWZpZWQgYnkgd2ViIHNl cnZlci4KKworICBcc2Egc2V0SHRtbCgpLCB0b0h0bWwoKQorKi8KK3ZvaWQgUVdlYkZyYW1lOjpz ZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwsCisgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBRVXJsICZzdWJzdGl0dXRlVXJsLCBMb2FkTW9kZSBtb2Rl KQorCit7CisgICAgaWYgKG1vZGUgPT0gU3RhbmRhcmRMb2FkKQorICAgICAgICByZXR1cm4gc2V0 SHRtbChodG1sLCBiYXNlVXJsKTsKKworICAgIEtVUkwga3VybCA9IEtVUkwoYmFzZVVybCk7Cisg ICAgZC0+bG9hZE1vZGUgPSBtb2RlOworCisgICAgaWYgKCFzdWJzdGl0dXRlVXJsLnRvU3RyaW5n KCkuaXNFbXB0eSgpKQorICAgICAgICBrdXJsID0gS1VSTChzdWJzdGl0dXRlVXJsKTsKKyAgICAv LyBJZiBubyBzdWJzdGl0dXRlIHVybCBpcyBwYXNzZWQgaW4gd2UgYXNzdW1lIGNhbGxlciB3YW50 cyB0byBzZXQgdGhlIEhUTUwKKyAgICAvLyBvZiB0aGUgcGFnZSBidXQgbm90IGNoYW5nZSB0aGUg Y3VycmVudCB1cmwgKGkuZS4gZWl0aGVyIGZyYW1lTG9hZGVyQ2xpZW50J3MKKyAgICAvLyBtX2xv YWRFcnJvci5mYWlsaW5nVXJsKCkgb3IgdXJsKCkpLgorICAgIGVsc2UgeworICAgICAgICAvLyBB ZnRlciBhIGxvYWQgaGFzIHN1Y2Nlc3NmdWxseSBmaW5pc2hlZCwgdGhlIGxvYWRlZCBVcmwgaXMg YXZhaWxhYmxlCisgICAgICAgIC8vIHRocm91Z2ggdGhlIHVybCgpIGNsYXNzIG1ldGhvZC4gV2hl biB0aGUgbG9hZCBpcyBub3Qgc3VjY2Vzc2Z1bGx5CisgICAgICAgIC8vIHRob3VnaCwgdGhlIGZy YW1lIGxvYWRlciBkb2VzIG5vdCBnZXQgY29tbWl0dGVkLCBhbmQgYW55IGNhbGwgdG8gdXJsKCkK KyAgICAgICAgLy8gbWV0aG9kIHdpbGwgc3RpbGwgcmV0dXJucyB0aGUgbGFzdCBzdWNjZXNzZnVs IFVybCBsb2FkZWQuIEluIHN1Y2ggY2FzZXMsCisgICAgICAgIC8vIHRoZSBmYWlsaW5nIFVybCBj YW4gYmUgcmV0cmlldmVkIGJ5IHVzaW5nIGZyYW1lTG9hZGVyQ2xpZW50J3MgbV9sb2FkRXJyb3IK KyAgICAgICAgLy8gY2xhc3MgbWVtYmVyLCB3aGljaCBrZWVwcyB0cmFjayBvZiBlcnJvcnMgZHVy aW5nIHVuc3VjY2Vzc2Z1bCBsb2Fkcy4KKyAgICAgICAgaWYgKCFkLT5mcmFtZUxvYWRlckNsaWVu dC0+bV9sb2FkRXJyb3IuZmFpbGluZ1VSTCgpLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGt1cmwg PSBLVVJMKFFVcmwoZC0+ZnJhbWVMb2FkZXJDbGllbnQtPm1fbG9hZEVycm9yLmZhaWxpbmdVUkwo KSkpOworICAgICAgICBlbHNlIGlmICghdXJsKCkudG9TdHJpbmcoKS5pc0VtcHR5KCkpCisgICAg ICAgICAgICBrdXJsID0gS1VSTCh1cmwoKSk7CisgICAgfQorCisgICAgS1VSTCBmYWlsaW5nVXJs ID0gKG1vZGUgPT0gU3Vic3RpdHV0aW9uTG9hZCkgPyBLVVJMKCkgOiBrdXJsOworCisgICAgUmVz b3VyY2VSZXF1ZXN0IHJlcXVlc3Qoa3VybCk7CisgICAgY29uc3QgUUJ5dGVBcnJheSB1dGY4ID0g aHRtbC50b1V0ZjgoKTsKKyAgICBXVEY6OlJlZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGEgPSBTaGFy ZWRCdWZmZXI6OmNyZWF0ZSh1dGY4LmNvbnN0RGF0YSgpLCB1dGY4Lmxlbmd0aCgpKTsKKyAgICBT dWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShkYXRhLCBTdHJpbmcoInRleHQvaHRtbCIpLCBT dHJpbmcoInV0Zi04IiksIGZhaWxpbmdVcmwpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9h ZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCkBAIC03NDIsNiArODA3LDcg QEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRlbnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29u c3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMKICAgICBpZiAoYWN0dWFsTWltZVR5cGUuaXNFbXB0 eSgpKQogICAgICAgICBhY3R1YWxNaW1lVHlwZSA9IFFMYXRpbjFTdHJpbmcoInRleHQvaHRtbCIp OwogICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGJ1ZmZlciwgV2Vi Q29yZTo6U3RyaW5nKGFjdHVhbE1pbWVUeXBlKSwgV2ViQ29yZTo6U3RyaW5nKCksIGt1cmwpOwor ICAgIGQtPmxvYWRNb2RlID0gU3RhbmRhcmRMb2FkOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+ bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCmRpZmYgLS1naXQgYS9X ZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAppbmRl eCA1NWM3M2I0Li5lMWZiYzkyIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5o CisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKQEAgLTEyMiw2ICsxMjIsMTIgQEAgcHJp dmF0ZToKIHB1YmxpYzoKICAgICBRV2ViUGFnZSAqcGFnZSgpIGNvbnN0OwogCisgICAgZW51bSBM b2FkTW9kZSB7CisgICAgICAgIE5vR2xvYmFsSGlzdG9yeUNoYW5nZSA9IDB4MiwKKyAgICAgICAg U3Vic3RpdHV0aW9uTG9hZCA9IDB4NCwKKyAgICAgICAgU3RhbmRhcmRMb2FkID0gMHg4CisgICAg fTsKKwogICAgIHZvaWQgbG9hZChjb25zdCBRVXJsICZ1cmwpOwogI2lmIFFUX1ZFUlNJT04gPCAw eDA0MDQwMAogICAgIHZvaWQgbG9hZChjb25zdCBRV2ViTmV0d29ya1JlcXVlc3QgJnJlcXVlc3Qp OwpAQCAtMTMxLDYgKzEzNyw4IEBAIHB1YmxpYzoKICAgICAgICAgICAgICAgY29uc3QgUUJ5dGVB cnJheSAmYm9keSA9IFFCeXRlQXJyYXkoKSk7CiAjZW5kaWYKICAgICB2b2lkIHNldEh0bWwoY29u c3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCA9IFFVcmwoKSk7CisgICAgdm9p ZCBzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwsIGNvbnN0 IFFVcmwgJnN1YnN0aXR1dGVVcmwsIExvYWRNb2RlIG1vZGUpOworCiAgICAgdm9pZCBzZXRDb250 ZW50KGNvbnN0IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0IFFTdHJpbmcgJm1pbWVUeXBlID0gUVN0 cmluZygpLCBjb25zdCBRVXJsICZiYXNlVXJsID0gUVVybCgpKTsKIAogICAgIHZvaWQgYWRkVG9K YXZhU2NyaXB0V2luZG93T2JqZWN0KGNvbnN0IFFTdHJpbmcgJm5hbWUsIFFPYmplY3QgKm9iamVj dCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQv QXBpL3F3ZWJmcmFtZV9wLmgKaW5kZXggNjMyZjgzYS4uOTNmOTcyYSAxMDA2NDQKLS0tIGEvV2Vi S2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3Au aApAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgogI2luY2x1ZGUgInF3ZWJlbGVtZW50LmgiCisjaW5jbHVkZSAicXdlYmZyYW1l LmgiCiAjaW5jbHVkZSAid3RmL1JlZlB0ci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAKQEAgLTcx LDYgKzcyLDcgQEAgcHVibGljOgogICAgICAgICAsIG1hcmdpbldpZHRoKC0xKQogICAgICAgICAs IG1hcmdpbkhlaWdodCgtMSkKICAgICAgICAgLCBjbGlwUmVuZGVyVG9WaWV3cG9ydCh0cnVlKQor ICAgICAgICAsIGxvYWRNb2RlKFFXZWJGcmFtZTo6U3RhbmRhcmRMb2FkKQogICAgICAgICB7fQog ICAgIHZvaWQgaW5pdChRV2ViRnJhbWUqIHFmcmFtZSwgUVdlYkZyYW1lRGF0YSogZnJhbWVEYXRh KTsKIApAQCAtOTUsNiArOTcsNyBAQCBwdWJsaWM6CiAgICAgaW50IG1hcmdpbldpZHRoOwogICAg IGludCBtYXJnaW5IZWlnaHQ7CiAgICAgYm9vbCBjbGlwUmVuZGVyVG9WaWV3cG9ydDsKKyAgICBR V2ViRnJhbWU6OkxvYWRNb2RlIGxvYWRNb2RlOwogfTsKIAogY2xhc3MgUVdlYkhpdFRlc3RSZXN1 bHRQcml2YXRlIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQv Q2hhbmdlTG9nCmluZGV4IGY4NjRiY2MuLmMwZTg1NGQgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDA5 LTA5LTE0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjkyNDgKKyAgICAgICAgW1F0XSBbQVBJXSBN YWtlIGl0IHBvc3NpYmxlIHRvIGhhdmUgJ2ludmlzaWJsZScgbG9hZHMKKworICAgICAgICBJbnRy b2R1Y2VzIGEgd2F5IHRoYXQgbWFrZXMgaXQgcG9zc2libGUgZm9yIHN1YnN0aXR1dGUgbG9hZHMK KyAgICAgICAgKGUuZy4gUVdlYkZyYW1lOjpzZXRIdG1sIGFuZCBRV2ViRnJhbWU6OnNldENvbnRl bnRzKSB0byBub3QKKyAgICAgICAgY2hhbmdlIGdsb2JhbCBhbmQvb3Igc2Vzc2lvbiBoaXN0b3J5 IGNvbnRlbnRzLCBhbmQgdG8gbm90CisgICAgICAgIGVtaXQgc2lnbmFscyByZWxhdGVkIHRvIHRo ZSBsb2FkaW5nIHByb2Nlc3MuCisKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNwcDoKKyAgICAg ICAgKFFXZWJGcmFtZTo6bG9hZCk6CisgICAgICAgIChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAg ICAgICAqIEFwaS9xd2ViZnJhbWUuaDoKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lX3AuaDoKKyAg ICAgICAgKFFXZWJGcmFtZVByaXZhdGU6OlFXZWJGcmFtZVByaXZhdGUpOgorICAgICAgICAqIEFw aS9xd2ViaGlzdG9yeS5jcHA6CisgICAgICAgIChRV2ViSGlzdG9yeTo6c2V0RW5hYmxlZCk6IHNl dHMgdGhlIGJhY2svZm9yd2FyZCBoaXN0b3J5CisgICAgICAgIHN0YXR1cworICAgICAgICAoUVdl Ykhpc3Rvcnk6OmlzRW5hYmxlZCk6IHJldHVybiBiYWNrL2ZvcndhcmQgaGlzdG9yeSBzdGF0dXMK KyAgICAgICAgKFFXZWJIaXN0b3J5Ojpjb250YWlucyk6IHJldHVybnMgaWYgYSBnaXZlbiBVcmwg aXMgaW4gdGhlCisgICAgICAgIGJhY2sgZm9yd2FyZCBoaXN0b3J5LgorICAgICAgICAqIEFwaS9x d2ViaGlzdG9yeS5oOgorICAgICAgICAqIFdlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50 UXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hE aWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2UpOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2Fk ZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRDb21taXRMb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkZy YW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkRmluaXNoTG9hZCk6CisgICAgICAgIChXZWJD b3JlOjpGcmFtZUxvYWRlckNsaWVudFF0Ojpwb3N0UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9u KToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkUmVj ZWl2ZUljb24pOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6dXBkYXRl R2xvYmFsSGlzdG9yeSk6CisKIDIwMDktMDktMTEgIERhdmlkIEJvZGRpZSAgPGRib2RkaWVAdHJv bGx0ZWNoLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAt LWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCBi L1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcAppbmRleCAx MDcxYTI2Li5hMTcwZmQxIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJh bWVMb2FkZXJDbGllbnRRdC5jcHAKKysrIGIvV2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1l TG9hZGVyQ2xpZW50UXQuY3BwCkBAIC0yOTgsNyArMjk4LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNs aWVudFF0OjpkaXNwYXRjaERpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZSgpCiAgICAgaWYgKGR1 bXBGcmFtZUxvYWRlckNhbGxiYWNrcykKICAgICAgICAgcHJpbnRmKCIlcyAtIGRpZENoYW5nZUxv Y2F0aW9uV2l0aGluUGFnZUZvckZyYW1lXG4iLCBxUHJpbnRhYmxlKGRydERlc2NyaXB0aW9uU3Vp dGFibGVGb3JUZXN0UmVzdWx0KG1fZnJhbWUpKSk7CiAKLSAgICBpZiAoIW1fd2ViRnJhbWUpCisg ICAgaWYgKCFtX3dlYkZyYW1lIHx8ICEobV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJh bWU6OlN0YW5kYXJkTG9hZCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGVtaXQgbV93ZWJGcmFt ZS0+dXJsQ2hhbmdlZChtX3dlYkZyYW1lLT51cmwoKSk7CkBAIC0zNDAsNyArMzQwLDcgQEAgdm9p ZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZENvbW1pdExvYWQoKQogICAgIGlmIChk dW1wRnJhbWVMb2FkZXJDYWxsYmFja3MpCiAgICAgICAgIHByaW50ZigiJXMgLSBkaWRDb21taXRM b2FkRm9yRnJhbWVcbiIsIHFQcmludGFibGUoZHJ0RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RS ZXN1bHQobV9mcmFtZSkpKTsKIAotICAgIGlmIChtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpIHx8 ICFtX3dlYkZyYW1lKQorICAgIGlmIChtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpIHx8ICFtX3dl YkZyYW1lIHx8ICEobV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJhbWU6OlN0YW5kYXJk TG9hZCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGVtaXQgbV93ZWJGcmFtZS0+dXJsQ2hhbmdl ZChtX3dlYkZyYW1lLT51cmwoKSk7CkBAIC0zNzYsNyArMzc2LDkgQEAgdm9pZCBGcmFtZUxvYWRl ckNsaWVudFF0OjpkaXNwYXRjaERpZEZpbmlzaExvYWQoKQogICAgIGlmIChkdW1wRnJhbWVMb2Fk ZXJDYWxsYmFja3MpCiAgICAgICAgIHByaW50ZigiJXMgLSBkaWRGaW5pc2hMb2FkRm9yRnJhbWVc biIsIHFQcmludGFibGUoZHJ0RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFt ZSkpKTsKIAotICAgIG1fbG9hZEVycm9yID0gUmVzb3VyY2VFcnJvcigpOyAvLyBjbGVhcnMgdGhl IHByZXZpb3VzIGVycm9yCisgICAgLy8gY2xlYXJzIHRoZSBwcmV2aW91cyBsb2FkIGRhdGEKKyAg ICBtX2xvYWRFcnJvciA9IFJlc291cmNlRXJyb3IoKTsKKyAgICBtX3dlYkZyYW1lLT5kLT5sb2Fk TW9kZSA9IFFXZWJGcmFtZTo6U3RhbmRhcmRMb2FkOwogCiAgICAgaWYgKCFtX3dlYkZyYW1lKQog ICAgICAgICByZXR1cm47CkBAIC00MjksMTIgKzQzMSwxNCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xp ZW50UXQ6OnJldmVydFRvUHJvdmlzaW9uYWxTdGF0ZShEb2N1bWVudExvYWRlciopCiAKIHZvaWQg RnJhbWVMb2FkZXJDbGllbnRRdDo6cG9zdFByb2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbigpCiB7 Ci0gICAgaWYgKG1fd2ViRnJhbWUgJiYgbV9mcmFtZS0+cGFnZSgpKSB7CisgICAgaWYgKG1fZnJh bWUtPnRyZWUoKS0+cGFyZW50KCkgfHwgIW1fd2ViRnJhbWUpCisgICAgICAgIHJldHVybjsKKwor ICAgIGlmIChtX2ZyYW1lLT5wYWdlKCkpIHsKICAgICAgICAgZW1pdCBsb2FkU3RhcnRlZCgpOwog ICAgICAgICBwb3N0UHJvZ3Jlc3NFc3RpbWF0ZUNoYW5nZWROb3RpZmljYXRpb24oKTsKICAgICB9 Ci0gICAgaWYgKG1fZnJhbWUtPnRyZWUoKS0+cGFyZW50KCkgfHwgIW1fd2ViRnJhbWUpCi0gICAg ICAgIHJldHVybjsKKwogICAgIG1fd2ViRnJhbWUtPnBhZ2UoKS0+ZC0+dXBkYXRlTmF2aWdhdGlv bkFjdGlvbnMoKTsKIH0KIApAQCAtNTc2LDkgKzU4MCw4IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGll bnRRdDo6ZGlzcGF0Y2hEaWRSZWNlaXZlSWNvbigpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRlckNh bGxiYWNrcykKICAgICAgICAgcHJpbnRmKCIlcyAtIGRpZFJlY2VpdmVJY29uRm9yRnJhbWVcbiIs IHFQcmludGFibGUoZHJ0RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFtZSkp KTsKIAotICAgIGlmIChtX3dlYkZyYW1lKSB7CisgICAgaWYgKG1fd2ViRnJhbWUpCiAgICAgICAg IGVtaXQgbV93ZWJGcmFtZS0+aWNvbkNoYW5nZWQoKTsKLSAgICB9CiB9CiAKIHZvaWQgRnJhbWVM b2FkZXJDbGllbnRRdDo6ZnJhbWVMb2FkZXJEZXN0cm95ZWQoKQpAQCAtNjI0LDcgKzYyNyw3IEBA IHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6cmVnaXN0ZXJGb3JJY29uTm90aWZpY2F0aW9uKGJv b2wpCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnVwZGF0ZUdsb2JhbEhpc3RvcnkoKQogewog ICAgIFFXZWJIaXN0b3J5SW50ZXJmYWNlICpoaXN0b3J5ID0gUVdlYkhpc3RvcnlJbnRlcmZhY2U6 OmRlZmF1bHRJbnRlcmZhY2UoKTsKLSAgICBpZiAoaGlzdG9yeSkKKyAgICBpZiAoaGlzdG9yeSAm JiAobV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgPT0gUVdlYkZyYW1lOjpTdGFuZGFyZExvYWQpKQog ICAgICAgICBoaXN0b3J5LT5hZGRIaXN0b3J5RW50cnkobV9mcmFtZS0+bG9hZGVyKCktPmRvY3Vt ZW50TG9hZGVyKCktPnVybEZvckhpc3RvcnkoKS5wcmV0dHlVUkwoKSk7CiB9CiAK 39630 2009-09-15 19:57:12 -0700 2009-09-22 15:09:21 -0700 patch 0.2.1 - same functionality as 0.2, but right changelog BUG_29248_v0.2.1diff text/plain 11877 tonikitoo Y29tbWl0IGM2YTY1ZjdjNjFhOGQ4NGJkYmEyYjVjMmNiZmY1NWY5N2U3MmQwNzMKQXV0aG9yOiBB bnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CkRh dGU6ICAgTW9uIFNlcCAxNCAxMjowODoxMyAyMDA5IC0wNDAwCgogICAgMjAwOS0wOS0xNCAgQW50 b25pbyBHb21lcyAgIDxhbnRvbmlvLmdvbWVzQG9wZW5ib3NzYS5vcmc+CiAgICAKICAgICAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCiAgICAKICAgICAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI5MjQ4CiAgICAgICAgICAgIFtRdF0gW0FQ SV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRzCiAgICAKICAgICAg ICAgICAgSW50cm9kdWNlcyBhIHdheSB0aGF0IG1ha2VzIGl0IHBvc3NpYmxlIGZvciBzdWJzdGl0 dXRlIGxvYWRzCiAgICAgICAgICAgIChlLmcuIFFXZWJGcmFtZTo6c2V0SHRtbCBhbmQgUVdlYkZy YW1lOjpzZXRDb250ZW50cykgdG8gbm90CiAgICAgICAgICAgIGNoYW5nZSBnbG9iYWwgYW5kL29y IHNlc3Npb24gaGlzdG9yeSBjb250ZW50cywgYW5kIHRvIG5vdAogICAgICAgICAgICBlbWl0IHNp Z25hbHMgcmVsYXRlZCB0byB0aGUgbG9hZGluZyBwcm9jZXNzLgogICAgCiAgICAgICAgICAgICog QXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgICAgIChRV2ViRnJhbWU6OmxvYWQpOgogICAgICAg ICAgICAoUVdlYkZyYW1lOjpzZXRIdG1sKToKICAgICAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmg6 CiAgICAgICAgICAgICogQXBpL3F3ZWJmcmFtZV9wLmg6CiAgICAgICAgICAgIChRV2ViRnJhbWVQ cml2YXRlOjpRV2ViRnJhbWVQcml2YXRlKToKICAgICAgICAgICAgKiBXZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFF0LmNwcDoKICAgICAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVy Q2xpZW50UXQ6OmRpc3BhdGNoRGlkQ2hhbmdlTG9jYXRpb25XaXRoaW5QYWdlKToKICAgICAgICAg ICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkQ29tbWl0TG9hZCk6 CiAgICAgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZEZp bmlzaExvYWQpOgogICAgICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6cG9z dFByb2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbik6CiAgICAgICAgICAgIChXZWJDb3JlOjpGcmFt ZUxvYWRlckNsaWVudFF0Ojp1cGRhdGVHbG9iYWxIaXN0b3J5KToKCmRpZmYgLS1naXQgYS9XZWJL aXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5k ZXggZjU2MzUxOC4uMzAzZGExZiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUu Y3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNjM2LDYgKzYzNiw4IEBA IHZvaWQgUVdlYkZyYW1lOjpsb2FkKGNvbnN0IFFXZWJOZXR3b3JrUmVxdWVzdCAmcmVxKQogICAg IGlmICghcG9zdERhdGEuaXNFbXB0eSgpKQogICAgICAgICByZXF1ZXN0LnNldEhUVFBCb2R5KFdl YkNvcmU6OkZvcm1EYXRhOjpjcmVhdGUocG9zdERhdGEuY29uc3REYXRhKCksIHBvc3REYXRhLnNp emUoKSkpOwogCisgICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFyZExvYWQ7CisKICAgICBkLT5mcmFt ZS0+bG9hZGVyKCktPmxvYWQocmVxdWVzdCwgZmFsc2UpOwogCiAgICAgaWYgKGQtPnBhcmVudEZy YW1lKCkpCkBAIC02OTIsNiArNjk0LDggQEAgdm9pZCBRV2ViRnJhbWU6OmxvYWQoY29uc3QgUU5l dHdvcmtSZXF1ZXN0ICZyZXEsCiAgICAgaWYgKCFib2R5LmlzRW1wdHkoKSkKICAgICAgICAgcmVx dWVzdC5zZXRIVFRQQm9keShXZWJDb3JlOjpGb3JtRGF0YTo6Y3JlYXRlKGJvZHkuY29uc3REYXRh KCksIGJvZHkuc2l6ZSgpKSk7CiAKKyAgICBkLT5sb2FkTW9kZSA9IFN0YW5kYXJkTG9hZDsKKwog ICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBmYWxzZSk7CiAKICAgICBpZiAo ZC0+cGFyZW50RnJhbWUoKSkKQEAgLTcxOSw2ICs3MjMsNjcgQEAgdm9pZCBRV2ViRnJhbWU6OnNl dEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAgICBjb25z dCBRQnl0ZUFycmF5IHV0ZjggPSBodG1sLnRvVXRmOCgpOwogICAgIFdURjo6UmVmUHRyPFdlYkNv cmU6OlNoYXJlZEJ1ZmZlcj4gZGF0YSA9IFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0 ZjguY29uc3REYXRhKCksIHV0ZjgubGVuZ3RoKCkpOwogICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVE YXRhIHN1YnN0aXR1dGVEYXRhKGRhdGEsIFdlYkNvcmU6OlN0cmluZygidGV4dC9odG1sIiksIFdl YkNvcmU6OlN0cmluZygidXRmLTgiKSwga3VybCk7CisgICAgZC0+bG9hZE1vZGUgPSBTdGFuZGFy ZExvYWQ7CisgICAgZC0+ZnJhbWUtPmxvYWRlcigpLT5sb2FkKHJlcXVlc3QsIHN1YnN0aXR1dGVE YXRhLCBmYWxzZSk7Cit9CisKKy8qIQorICBcc2luY2UgNC42CisgIFNldHMgdGhlIGNvbnRlbnQg b2YgdGhpcyBmcmFtZSB0byBcYSBodG1sLiBcYSBiYXNlVXJsIGlzIHVzZWQgdG8gcmVzb2x2ZSBy ZWxhdGl2ZQorICBVUkxzIGluIHRoZSBkb2N1bWVudCwgc3VjaCBhcyByZWZlcmVuY2VkIGltYWdl cyBvciBzdHlsZXNoZWV0cy4gSWYgdGhlcmUgaXMgbm8KKyAgcmVsYXRpdmUgVXJscyB0byBiZSBy ZXNvbHZlZCwgYW4gZW1wdHkgVXJsIChRVXJsKCkpIGlzIHRvIGJlIHBhc3NlZCBpbi4gVGhlIHN1 YnN0aXR1dGUKKyAgdXJsIFxhIHN1YnN0aXR1dGVVcmwgaXMgdGhlIFVybCB0aGF0IGlzIGdvaW5n IHRvIGJlIHJlZmVycmVkIGZvciB0aGlzIGxvYWQgKG5vIG1hdHRlcgorICB0aGUgaHRtbCBzdHJp bmcgXGh0bWwgcGFzc2VkIGluKS4gSWYgbm8gdmFsaWQgc3Vic3RpdHV0ZVVybCBpcyBwYXNzZWQs IGl0cyB2YWx1ZSB3aWxsCisgIGJlIGFzc3VtZWQgdG8gYmUgdGhlIGxhdGVzdCBsb2FkZWQgdXJs IChiZWluZyB0aGUgbG9hZCBzdWNjZXNzZnVsIG9yIG5vdCksIG9yIHRoZSBiYXNlVXJsCisgIFxh IGJhc2VVcmwgaW4gdGhhdCBvcmRlci4gVGhlIFxhIG1vZGUgbXVzdCBiZSBRV2ViRnJhbWU6OlN0 YW5kYXJkTG9hZCAoZGVmYXVsdCksCisgIFFXZWJGcmFtZTo6U3Vic3RpdHV0aW9uTG9hZCBvciBR V2ViRnJhbWU6Ok5vR2xvYmFsSGlzdG9yeUNoYW5nZS4KKworICBcbm90ZSBJZiBcbHtRV2ViRnJh bWU6On17U3RhbmRhcmRMb2FkfSBpcyBwYXNzZWQgYXMgYSBsb2FkIHR5cGUsIHRoZSBkZWZhdWx0 IHNldEh0bWwoKQorICBpbXBsZW1lbnRhdGlvbiB3aWxsIGJlIGNhbGxlZCwgaWdub3JpbmcgYW55 IHN1YnN0aXR1dGVVcmwgdmFsdWUuCisKKyAgVGhlIFxhIGh0bWwgaXMgbG9hZGVkIGltbWVkaWF0 ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5bmNocm9ub3VzbHkuCisKKyAgV2hl biB1c2luZyB0aGlzIG1ldGhvZCBXZWJLaXQgYXNzdW1lcyB0aGF0IGV4dGVybmFsIHJlc291cmNl cyBzdWNoIGFzIEphdmFTY3JpcHQgcHJvZ3JhbXMgb3Igc3R5bGUKKyAgc2hlZXRzIGFyZSBlbmNv ZGVkIGluIFVURi04IHVubGVzcyBvdGhlcndpc2Ugc3BlY2lmaWVkLiBGb3IgZXhhbXBsZSwgdGhl IGVuY29kaW5nIG9mIGFuIGV4dGVybmFsCisgIHNjcmlwdCBjYW4gYmUgc3BlY2lmaWVkIHRocm91 Z2ggdGhlIGNoYXJzZXQgYXR0cmlidXRlIG9mIHRoZSBIVE1MIHNjcmlwdCB0YWcuIEl0IGlzIGFs c28gcG9zc2libGUKKyAgZm9yIHRoZSBlbmNvZGluZyB0byBiZSBzcGVjaWZpZWQgYnkgd2ViIHNl cnZlci4KKworICBcc2Egc2V0SHRtbCgpLCB0b0h0bWwoKQorKi8KK3ZvaWQgUVdlYkZyYW1lOjpz ZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwsCisgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBRVXJsICZzdWJzdGl0dXRlVXJsLCBMb2FkTW9kZSBtb2Rl KQorCit7CisgICAgaWYgKG1vZGUgPT0gU3RhbmRhcmRMb2FkKQorICAgICAgICByZXR1cm4gc2V0 SHRtbChodG1sLCBiYXNlVXJsKTsKKworICAgIEtVUkwga3VybCA9IEtVUkwoYmFzZVVybCk7Cisg ICAgZC0+bG9hZE1vZGUgPSBtb2RlOworCisgICAgaWYgKCFzdWJzdGl0dXRlVXJsLnRvU3RyaW5n KCkuaXNFbXB0eSgpKQorICAgICAgICBrdXJsID0gS1VSTChzdWJzdGl0dXRlVXJsKTsKKyAgICAv LyBJZiBubyBzdWJzdGl0dXRlIHVybCBpcyBwYXNzZWQgaW4gd2UgYXNzdW1lIGNhbGxlciB3YW50 cyB0byBzZXQgdGhlIEhUTUwKKyAgICAvLyBvZiB0aGUgcGFnZSBidXQgbm90IGNoYW5nZSB0aGUg Y3VycmVudCB1cmwgKGkuZS4gZWl0aGVyIGZyYW1lTG9hZGVyQ2xpZW50J3MKKyAgICAvLyBtX2xv YWRFcnJvci5mYWlsaW5nVXJsKCkgb3IgdXJsKCkpLgorICAgIGVsc2UgeworICAgICAgICAvLyBB ZnRlciBhIGxvYWQgaGFzIHN1Y2Nlc3NmdWxseSBmaW5pc2hlZCwgdGhlIGxvYWRlZCBVcmwgaXMg YXZhaWxhYmxlCisgICAgICAgIC8vIHRocm91Z2ggdGhlIHVybCgpIGNsYXNzIG1ldGhvZC4gV2hl biB0aGUgbG9hZCBpcyBub3Qgc3VjY2Vzc2Z1bGx5CisgICAgICAgIC8vIHRob3VnaCwgdGhlIGZy YW1lIGxvYWRlciBkb2VzIG5vdCBnZXQgY29tbWl0dGVkLCBhbmQgYW55IGNhbGwgdG8gdXJsKCkK KyAgICAgICAgLy8gbWV0aG9kIHdpbGwgc3RpbGwgcmV0dXJucyB0aGUgbGFzdCBzdWNjZXNzZnVs IFVybCBsb2FkZWQuIEluIHN1Y2ggY2FzZXMsCisgICAgICAgIC8vIHRoZSBmYWlsaW5nIFVybCBj YW4gYmUgcmV0cmlldmVkIGJ5IHVzaW5nIGZyYW1lTG9hZGVyQ2xpZW50J3MgbV9sb2FkRXJyb3IK KyAgICAgICAgLy8gY2xhc3MgbWVtYmVyLCB3aGljaCBrZWVwcyB0cmFjayBvZiBlcnJvcnMgZHVy aW5nIHVuc3VjY2Vzc2Z1bCBsb2Fkcy4KKyAgICAgICAgaWYgKCFkLT5mcmFtZUxvYWRlckNsaWVu dC0+bV9sb2FkRXJyb3IuZmFpbGluZ1VSTCgpLmlzRW1wdHkoKSkKKyAgICAgICAgICAgIGt1cmwg PSBLVVJMKFFVcmwoZC0+ZnJhbWVMb2FkZXJDbGllbnQtPm1fbG9hZEVycm9yLmZhaWxpbmdVUkwo KSkpOworICAgICAgICBlbHNlIGlmICghdXJsKCkudG9TdHJpbmcoKS5pc0VtcHR5KCkpCisgICAg ICAgICAgICBrdXJsID0gS1VSTCh1cmwoKSk7CisgICAgfQorCisgICAgS1VSTCBmYWlsaW5nVXJs ID0gKG1vZGUgPT0gU3Vic3RpdHV0aW9uTG9hZCkgPyBLVVJMKCkgOiBrdXJsOworCisgICAgUmVz b3VyY2VSZXF1ZXN0IHJlcXVlc3Qoa3VybCk7CisgICAgY29uc3QgUUJ5dGVBcnJheSB1dGY4ID0g aHRtbC50b1V0ZjgoKTsKKyAgICBXVEY6OlJlZlB0cjxTaGFyZWRCdWZmZXI+IGRhdGEgPSBTaGFy ZWRCdWZmZXI6OmNyZWF0ZSh1dGY4LmNvbnN0RGF0YSgpLCB1dGY4Lmxlbmd0aCgpKTsKKyAgICBT dWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShkYXRhLCBTdHJpbmcoInRleHQvaHRtbCIpLCBT dHJpbmcoInV0Zi04IiksIGZhaWxpbmdVcmwpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9h ZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCkBAIC03NDIsNiArODA3LDcg QEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRlbnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29u c3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMKICAgICBpZiAoYWN0dWFsTWltZVR5cGUuaXNFbXB0 eSgpKQogICAgICAgICBhY3R1YWxNaW1lVHlwZSA9IFFMYXRpbjFTdHJpbmcoInRleHQvaHRtbCIp OwogICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGJ1ZmZlciwgV2Vi Q29yZTo6U3RyaW5nKGFjdHVhbE1pbWVUeXBlKSwgV2ViQ29yZTo6U3RyaW5nKCksIGt1cmwpOwor ICAgIGQtPmxvYWRNb2RlID0gU3RhbmRhcmRMb2FkOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+ bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCmRpZmYgLS1naXQgYS9X ZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5oIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaAppbmRl eCA1NWM3M2I0Li5lMWZiYzkyIDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5o CisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmgKQEAgLTEyMiw2ICsxMjIsMTIgQEAgcHJp dmF0ZToKIHB1YmxpYzoKICAgICBRV2ViUGFnZSAqcGFnZSgpIGNvbnN0OwogCisgICAgZW51bSBM b2FkTW9kZSB7CisgICAgICAgIE5vR2xvYmFsSGlzdG9yeUNoYW5nZSA9IDB4MiwKKyAgICAgICAg U3Vic3RpdHV0aW9uTG9hZCA9IDB4NCwKKyAgICAgICAgU3RhbmRhcmRMb2FkID0gMHg4CisgICAg fTsKKwogICAgIHZvaWQgbG9hZChjb25zdCBRVXJsICZ1cmwpOwogI2lmIFFUX1ZFUlNJT04gPCAw eDA0MDQwMAogICAgIHZvaWQgbG9hZChjb25zdCBRV2ViTmV0d29ya1JlcXVlc3QgJnJlcXVlc3Qp OwpAQCAtMTMxLDYgKzEzNyw4IEBAIHB1YmxpYzoKICAgICAgICAgICAgICAgY29uc3QgUUJ5dGVB cnJheSAmYm9keSA9IFFCeXRlQXJyYXkoKSk7CiAjZW5kaWYKICAgICB2b2lkIHNldEh0bWwoY29u c3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCA9IFFVcmwoKSk7CisgICAgdm9p ZCBzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwsIGNvbnN0 IFFVcmwgJnN1YnN0aXR1dGVVcmwsIExvYWRNb2RlIG1vZGUpOworCiAgICAgdm9pZCBzZXRDb250 ZW50KGNvbnN0IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0IFFTdHJpbmcgJm1pbWVUeXBlID0gUVN0 cmluZygpLCBjb25zdCBRVXJsICZiYXNlVXJsID0gUVVybCgpKTsKIAogICAgIHZvaWQgYWRkVG9K YXZhU2NyaXB0V2luZG93T2JqZWN0KGNvbnN0IFFTdHJpbmcgJm5hbWUsIFFPYmplY3QgKm9iamVj dCk7CmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZV9wLmggYi9XZWJLaXQvcXQv QXBpL3F3ZWJmcmFtZV9wLmgKaW5kZXggNjMyZjgzYS4uOTNmOTcyYSAxMDA2NDQKLS0tIGEvV2Vi S2l0L3F0L0FwaS9xd2ViZnJhbWVfcC5oCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lX3Au aApAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgIktVUkwuaCIKICNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgogI2luY2x1ZGUgInF3ZWJlbGVtZW50LmgiCisjaW5jbHVkZSAicXdlYmZyYW1l LmgiCiAjaW5jbHVkZSAid3RmL1JlZlB0ci5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCiAKQEAgLTcx LDYgKzcyLDcgQEAgcHVibGljOgogICAgICAgICAsIG1hcmdpbldpZHRoKC0xKQogICAgICAgICAs IG1hcmdpbkhlaWdodCgtMSkKICAgICAgICAgLCBjbGlwUmVuZGVyVG9WaWV3cG9ydCh0cnVlKQor ICAgICAgICAsIGxvYWRNb2RlKFFXZWJGcmFtZTo6U3RhbmRhcmRMb2FkKQogICAgICAgICB7fQog ICAgIHZvaWQgaW5pdChRV2ViRnJhbWUqIHFmcmFtZSwgUVdlYkZyYW1lRGF0YSogZnJhbWVEYXRh KTsKIApAQCAtOTUsNiArOTcsNyBAQCBwdWJsaWM6CiAgICAgaW50IG1hcmdpbldpZHRoOwogICAg IGludCBtYXJnaW5IZWlnaHQ7CiAgICAgYm9vbCBjbGlwUmVuZGVyVG9WaWV3cG9ydDsKKyAgICBR V2ViRnJhbWU6OkxvYWRNb2RlIGxvYWRNb2RlOwogfTsKIAogY2xhc3MgUVdlYkhpdFRlc3RSZXN1 bHRQcml2YXRlIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQv Q2hhbmdlTG9nCmluZGV4IGY4NjRiY2MuLjgzYzA3ZmEgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9D aGFuZ2VMb2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDA5 LTA5LTE0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjkyNDgKKyAgICAgICAgW1F0XSBbQVBJXSBN YWtlIGl0IHBvc3NpYmxlIHRvIGhhdmUgJ2ludmlzaWJsZScgbG9hZHMKKworICAgICAgICBJbnRy b2R1Y2VzIGEgd2F5IHRoYXQgbWFrZXMgaXQgcG9zc2libGUgZm9yIHN1YnN0aXR1dGUgbG9hZHMK KyAgICAgICAgKGUuZy4gUVdlYkZyYW1lOjpzZXRIdG1sIGFuZCBRV2ViRnJhbWU6OnNldENvbnRl bnRzKSB0byBub3QKKyAgICAgICAgY2hhbmdlIGdsb2JhbCBhbmQvb3Igc2Vzc2lvbiBoaXN0b3J5 IGNvbnRlbnRzLCBhbmQgdG8gbm90CisgICAgICAgIGVtaXQgc2lnbmFscyByZWxhdGVkIHRvIHRo ZSBsb2FkaW5nIHByb2Nlc3MuCisKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmNwcDoKKyAgICAg ICAgKFFXZWJGcmFtZTo6bG9hZCk6CisgICAgICAgIChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAg ICAgICAqIEFwaS9xd2ViZnJhbWUuaDoKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lX3AuaDoKKyAg ICAgICAgKFFXZWJGcmFtZVByaXZhdGU6OlFXZWJGcmFtZVByaXZhdGUpOgorICAgICAgICAqIFdl YkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRDaGFuZ2VMb2NhdGlvbldpdGhpblBhZ2Up OgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRDb21t aXRMb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lTG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNo RGlkRmluaXNoTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZUxvYWRlckNsaWVudFF0Ojpw b3N0UHJvZ3Jlc3NTdGFydGVkTm90aWZpY2F0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1l TG9hZGVyQ2xpZW50UXQ6OmRpc3BhdGNoRGlkUmVjZWl2ZUljb24pOgorICAgICAgICAoV2ViQ29y ZTo6RnJhbWVMb2FkZXJDbGllbnRRdDo6dXBkYXRlR2xvYmFsSGlzdG9yeSk6CisKIDIwMDktMDkt MTEgIERhdmlkIEJvZGRpZSAgPGRib2RkaWVAdHJvbGx0ZWNoLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9XZWJDb3JlU3Vw cG9ydC9GcmFtZUxvYWRlckNsaWVudFF0LmNwcCBiL1dlYktpdC9xdC9XZWJDb3JlU3VwcG9ydC9G cmFtZUxvYWRlckNsaWVudFF0LmNwcAppbmRleCAxMDcxYTI2Li5hMTcwZmQxIDEwMDY0NAotLS0g YS9XZWJLaXQvcXQvV2ViQ29yZVN1cHBvcnQvRnJhbWVMb2FkZXJDbGllbnRRdC5jcHAKKysrIGIv V2ViS2l0L3F0L1dlYkNvcmVTdXBwb3J0L0ZyYW1lTG9hZGVyQ2xpZW50UXQuY3BwCkBAIC0yOTgs NyArMjk4LDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZENoYW5nZUxv Y2F0aW9uV2l0aGluUGFnZSgpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRlckNhbGxiYWNrcykKICAg ICAgICAgcHJpbnRmKCIlcyAtIGRpZENoYW5nZUxvY2F0aW9uV2l0aGluUGFnZUZvckZyYW1lXG4i LCBxUHJpbnRhYmxlKGRydERlc2NyaXB0aW9uU3VpdGFibGVGb3JUZXN0UmVzdWx0KG1fZnJhbWUp KSk7CiAKLSAgICBpZiAoIW1fd2ViRnJhbWUpCisgICAgaWYgKCFtX3dlYkZyYW1lIHx8ICEobV93 ZWJGcmFtZS0+ZC0+bG9hZE1vZGUgJiBRV2ViRnJhbWU6OlN0YW5kYXJkTG9hZCkpCiAgICAgICAg IHJldHVybjsKIAogICAgIGVtaXQgbV93ZWJGcmFtZS0+dXJsQ2hhbmdlZChtX3dlYkZyYW1lLT51 cmwoKSk7CkBAIC0zNDAsNyArMzQwLDcgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNw YXRjaERpZENvbW1pdExvYWQoKQogICAgIGlmIChkdW1wRnJhbWVMb2FkZXJDYWxsYmFja3MpCiAg ICAgICAgIHByaW50ZigiJXMgLSBkaWRDb21taXRMb2FkRm9yRnJhbWVcbiIsIHFQcmludGFibGUo ZHJ0RGVzY3JpcHRpb25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFtZSkpKTsKIAotICAgIGlm IChtX2ZyYW1lLT50cmVlKCktPnBhcmVudCgpIHx8ICFtX3dlYkZyYW1lKQorICAgIGlmIChtX2Zy YW1lLT50cmVlKCktPnBhcmVudCgpIHx8ICFtX3dlYkZyYW1lIHx8ICEobV93ZWJGcmFtZS0+ZC0+ bG9hZE1vZGUgJiBRV2ViRnJhbWU6OlN0YW5kYXJkTG9hZCkpCiAgICAgICAgIHJldHVybjsKIAog ICAgIGVtaXQgbV93ZWJGcmFtZS0+dXJsQ2hhbmdlZChtX3dlYkZyYW1lLT51cmwoKSk7CkBAIC0z NzYsNyArMzc2LDkgQEAgdm9pZCBGcmFtZUxvYWRlckNsaWVudFF0OjpkaXNwYXRjaERpZEZpbmlz aExvYWQoKQogICAgIGlmIChkdW1wRnJhbWVMb2FkZXJDYWxsYmFja3MpCiAgICAgICAgIHByaW50 ZigiJXMgLSBkaWRGaW5pc2hMb2FkRm9yRnJhbWVcbiIsIHFQcmludGFibGUoZHJ0RGVzY3JpcHRp b25TdWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFtZSkpKTsKIAotICAgIG1fbG9hZEVycm9yID0g UmVzb3VyY2VFcnJvcigpOyAvLyBjbGVhcnMgdGhlIHByZXZpb3VzIGVycm9yCisgICAgLy8gY2xl YXJzIHRoZSBwcmV2aW91cyBsb2FkIGRhdGEKKyAgICBtX2xvYWRFcnJvciA9IFJlc291cmNlRXJy b3IoKTsKKyAgICBtX3dlYkZyYW1lLT5kLT5sb2FkTW9kZSA9IFFXZWJGcmFtZTo6U3RhbmRhcmRM b2FkOwogCiAgICAgaWYgKCFtX3dlYkZyYW1lKQogICAgICAgICByZXR1cm47CkBAIC00MjksMTIg KzQzMSwxNCBAQCB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50UXQ6OnJldmVydFRvUHJvdmlzaW9uYWxT dGF0ZShEb2N1bWVudExvYWRlciopCiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6cG9zdFBy b2dyZXNzU3RhcnRlZE5vdGlmaWNhdGlvbigpCiB7Ci0gICAgaWYgKG1fd2ViRnJhbWUgJiYgbV9m cmFtZS0+cGFnZSgpKSB7CisgICAgaWYgKG1fZnJhbWUtPnRyZWUoKS0+cGFyZW50KCkgfHwgIW1f d2ViRnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX2ZyYW1lLT5wYWdlKCkpIHsK ICAgICAgICAgZW1pdCBsb2FkU3RhcnRlZCgpOwogICAgICAgICBwb3N0UHJvZ3Jlc3NFc3RpbWF0 ZUNoYW5nZWROb3RpZmljYXRpb24oKTsKICAgICB9Ci0gICAgaWYgKG1fZnJhbWUtPnRyZWUoKS0+ cGFyZW50KCkgfHwgIW1fd2ViRnJhbWUpCi0gICAgICAgIHJldHVybjsKKwogICAgIG1fd2ViRnJh bWUtPnBhZ2UoKS0+ZC0+dXBkYXRlTmF2aWdhdGlvbkFjdGlvbnMoKTsKIH0KIApAQCAtNTc2LDkg KzU4MCw4IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6ZGlzcGF0Y2hEaWRSZWNlaXZlSWNv bigpCiAgICAgaWYgKGR1bXBGcmFtZUxvYWRlckNhbGxiYWNrcykKICAgICAgICAgcHJpbnRmKCIl cyAtIGRpZFJlY2VpdmVJY29uRm9yRnJhbWVcbiIsIHFQcmludGFibGUoZHJ0RGVzY3JpcHRpb25T dWl0YWJsZUZvclRlc3RSZXN1bHQobV9mcmFtZSkpKTsKIAotICAgIGlmIChtX3dlYkZyYW1lKSB7 CisgICAgaWYgKG1fd2ViRnJhbWUpCiAgICAgICAgIGVtaXQgbV93ZWJGcmFtZS0+aWNvbkNoYW5n ZWQoKTsKLSAgICB9CiB9CiAKIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6ZnJhbWVMb2FkZXJE ZXN0cm95ZWQoKQpAQCAtNjI0LDcgKzYyNyw3IEBAIHZvaWQgRnJhbWVMb2FkZXJDbGllbnRRdDo6 cmVnaXN0ZXJGb3JJY29uTm90aWZpY2F0aW9uKGJvb2wpCiB2b2lkIEZyYW1lTG9hZGVyQ2xpZW50 UXQ6OnVwZGF0ZUdsb2JhbEhpc3RvcnkoKQogewogICAgIFFXZWJIaXN0b3J5SW50ZXJmYWNlICpo aXN0b3J5ID0gUVdlYkhpc3RvcnlJbnRlcmZhY2U6OmRlZmF1bHRJbnRlcmZhY2UoKTsKLSAgICBp ZiAoaGlzdG9yeSkKKyAgICBpZiAoaGlzdG9yeSAmJiAobV93ZWJGcmFtZS0+ZC0+bG9hZE1vZGUg PT0gUVdlYkZyYW1lOjpTdGFuZGFyZExvYWQpKQogICAgICAgICBoaXN0b3J5LT5hZGRIaXN0b3J5 RW50cnkobV9mcmFtZS0+bG9hZGVyKCktPmRvY3VtZW50TG9hZGVyKCktPnVybEZvckhpc3Rvcnko KS5wcmV0dHlVUkwoKSk7CiB9CiAK 39950 2009-09-22 15:09:21 -0700 2009-09-23 21:42:46 -0700 patch 0.3 - make setHtml and setContent to not change history 0001-2009-09-22-Antonio-Gomes-antonio.gomes-openbossa.patch text/plain 25890 tonikitoo RnJvbSA3MDJkYTI2ZDMwZmE1ODAwMjQ1MmUyZTBiZTZhZGYxY2NiODQwNzQ4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IFR1ZSwgMjIgU2VwIDIwMDkgMDk6MzM6NDYgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTIyICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2Rz IHRvIG5vdCBjaGFuZ2UKICAgICAgICBzZXNzaW9uIGFuZCBnbG9iYWwgaGlzdG9yeSBhdCBhbGwu CgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0SHRt bCk6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0Q29udGVudCk6CiAgICAgICAgKiB0ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybzoKICAgICAgICAqIHRlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZy YW1lLmNwcDoKLS0tCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgICAgICAgICAgICAgICAg ICAgIHwgICAxMyArKysrKysrLS0tLQogV2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTYgKysrKysrKysrKysrKysKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybyAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcmVzb3VyY2VzL2ltYWdlMi5wbmcgfCAgQmluIDAgLT4gMTQ3NDMgYnl0ZXMKIFdlYktp dC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgICAgfCAgIDI3ICsrKysrKysr KysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA1MiBpbnNlcnRpb25zKCspLCA1IGRl bGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUv cmVzb3VyY2VzL2ltYWdlMi5wbmcKCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggZmU4MTNiOC4uN2E5Njgy YSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9x dC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNzA1LDEyICs3MDUsMTQgQEAgdm9pZCBRV2ViRnJhbWU6 OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0ICZyZXEsCiAKICAgVGhlIFxhIGh0bWwgaXMgbG9h ZGVkIGltbWVkaWF0ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5bmNocm9ub3Vz bHkuCiAKKyAgXG5vdGUgQW55IGNhbGwgdG8gc2V0SHRtbCB3aWxsIG5vdCBjaGFuZ2UgbmVpdGhl ciBzZXNzaW9uIG5vciBnbG9iYWwgaGlzdG9yeS4KKwogICBXaGVuIHVzaW5nIHRoaXMgbWV0aG9k IFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwgcmVzb3VyY2VzIHN1Y2ggYXMgSmF2YVNjcmlw dCBwcm9ncmFtcyBvciBzdHlsZQogICBzaGVldHMgYXJlIGVuY29kZWQgaW4gVVRGLTggdW5sZXNz IG90aGVyd2lzZSBzcGVjaWZpZWQuIEZvciBleGFtcGxlLCB0aGUgZW5jb2Rpbmcgb2YgYW4gZXh0 ZXJuYWwKICAgc2NyaXB0IGNhbiBiZSBzcGVjaWZpZWQgdGhyb3VnaCB0aGUgY2hhcnNldCBhdHRy aWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRhZy4gSXQgaXMgYWxzbyBwb3NzaWJsZQogICBmb3Ig dGhlIGVuY29kaW5nIHRvIGJlIHNwZWNpZmllZCBieSB3ZWIgc2VydmVyLgogCi0gIFxzYSB0b0h0 bWwoKQorICBcc2EgdG9IdG1sKCksIHNldENvbnRlbnQoKQogKi8KIHZvaWQgUVdlYkZyYW1lOjpz ZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwpCiB7CkBAIC03 MTgsNyArNzIwLDcgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRt bCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVx dWVzdChrdXJsKTsKICAgICBjb25zdCBRQnl0ZUFycmF5IHV0ZjggPSBodG1sLnRvVXRmOCgpOwog ICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcj4gZGF0YSA9IFdlYkNvcmU6OlNo YXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0ZjguY29uc3REYXRhKCksIHV0ZjgubGVuZ3RoKCkpOwotICAg IFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGRhdGEsIFdlYkNvcmU6OlN0 cmluZygidGV4dC9odG1sIiksIFdlYkNvcmU6OlN0cmluZygidXRmLTgiKSwga3VybCk7CisgICAg V2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vic3RpdHV0ZURhdGEoZGF0YSwgV2ViQ29yZTo6U3Ry aW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6U3RyaW5nKCJ1dGYtOCIpLCBLVVJMKCkpOwogICAg IGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2Up OwogfQogCkBAIC03MzEsNyArNzMzLDkgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3Qg UVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKIAogICBUaGUgXGEgZGF0YSBpcyBs b2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25v dXNseS4KIAotICBcc2EgdG9IdG1sKCkKKyAgXG5vdGUgQW55IGNhbGwgdG8gc2V0SHRtbCB3aWxs IG5vdCBjaGFuZ2UgbmVpdGhlciBzZXNzaW9uIG5vciBnbG9iYWwgaGlzdG9yeS4KKworICBcc2Eg dG9IdG1sKCksIHNldEh0bWwoKQogKi8KIHZvaWQgUVdlYkZyYW1lOjpzZXRDb250ZW50KGNvbnN0 IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0IFFTdHJpbmcgJm1pbWVUeXBlLCBjb25zdCBRVXJsICZi YXNlVXJsKQogewpAQCAtNzQxLDExICs3NDUsMTAgQEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRl bnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29uc3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMK ICAgICBRU3RyaW5nIGFjdHVhbE1pbWVUeXBlID0gbWltZVR5cGU7CiAgICAgaWYgKGFjdHVhbE1p bWVUeXBlLmlzRW1wdHkoKSkKICAgICAgICAgYWN0dWFsTWltZVR5cGUgPSBRTGF0aW4xU3RyaW5n KCJ0ZXh0L2h0bWwiKTsKLSAgICBXZWJDb3JlOjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0 YShidWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmlu ZygpLCBrdXJsKTsKKyAgICBXZWJDb3JlOjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShi dWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygp LCBLVVJMKCkpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0 dXRlRGF0YSwgZmFsc2UpOwogfQogCi0KIC8qIQogICBSZXR1cm5zIHRoZSBwYXJlbnQgZnJhbWUg b2YgdGhpcyBmcmFtZSwgb3IgMCBpZiB0aGUgZnJhbWUgaXMgdGhlIHdlYiBwYWdlcwogICBtYWlu IGZyYW1lLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFu Z2VMb2cKaW5kZXggYWE3ODk1Mi4uNTIzYmU5YyAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5n ZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDkt MjIgIEFudG9uaW8gR29tZXMgICA8YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAorICAgICAgICBbUXRdIFtBUEldIE1ha2Ug aXQgcG9zc2libGUgdG8gaGF2ZSAnaW52aXNpYmxlJyBsb2FkcworCisgICAgICAgIE1ha2UgUVdl YkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2RzIHRvIG5vdCBjaGFuZ2UKKyAg ICAgICAgc2Vzc2lvbiBhbmQgZ2xvYmFsIGhpc3RvcnkgYXQgYWxsLgorCisgICAgICAgICogQXBp L3F3ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAgICAgICAo UVdlYkZyYW1lOjpzZXRDb250ZW50KToKKyAgICAgICAgKiB0ZXN0cy9xd2ViZnJhbWUvcXdlYmZy YW1lLnBybzoKKyAgICAgICAgKiB0ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHA6CisK IDIwMDktMDktMjIgIEpvY2VseW4gVHVyY290dGUgIDxqb2NlbHluLnR1cmNvdHRlQG5va2lhLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBIYXVzbWFubi4KZGlmZiAtLWdpdCBhL1dl YktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBybyBiL1dlYktpdC9xdC90ZXN0cy9x d2ViZnJhbWUvcXdlYmZyYW1lLnBybwppbmRleCA4MTAzN2MzLi43MDc4ZDY3IDEwMDY0NAotLS0g YS9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3F3ZWJmcmFtZS5wcm8KKysrIGIvV2ViS2l0L3F0 L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJhbWUucHJvCkBAIC01LDUgKzUsNiBAQCBTT1VSQ0VTICAr PSB0c3RfcXdlYmZyYW1lLmNwcAogUkVTT1VSQ0VTICs9IHF3ZWJmcmFtZS5xcmMKIFFUICs9IHRl c3RsaWIgbmV0d29yawogUU1BS0VfUlBBVEhESVIgPSAkJE9VVFBVVF9ESVIvbGliICQkUU1BS0Vf UlBBVEhESVIKK0RFRklORVMgKz0gUkVTT1VSQ0VTX1BBVEg9JCRQV0QvcmVzb3VyY2VzCiAKIHN5 bWJpYW46VEFSR0VULlVJRDMgPSAweEEwMDBFNTNECmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvdGVz dHMvcXdlYmZyYW1lL3Jlc291cmNlcy9pbWFnZTIucG5nIGIvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJm cmFtZS9yZXNvdXJjZXMvaW1hZ2UyLnBuZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZDcwMzY0MGMxNDgzMjU2ODky NzNlZjAzMWQzNmNlZDAyMzY5ZmY5CkdJVCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCAxNDc0Mwp6Y21W O0lJY1VhLVApPGg7M0t8TGswMDBlMU5KTFRxMDA0amgwMDRqcDFeQHM2ISMtaWwwMDAwNFhGKkx0 MDA3d28KekxlQHtBMDAwMDlhN2JCbTAwMFhVMDAwWFUwUldudTd5dGtPQnk+ZXNiVz85O2JhIUVM V2RLb2lYPTdfdFg+RGE3CnpIWkM8VEYoND5TVlBoYXFReV5GPTA4MW5JJF5aWlcyWHNrSU1GLVJn OVNpXjtaVkslPzAwMjFsTmtsPFpjLXJsfgp6ZDV8UjZlYyQ9WCUofDwpdEZQKGw4TyM4SzBXY1dj MVdBQShpNnRxNTZpPUBSKzJYYTdOaF8+eT9BcUxyY1A7SUkKejg/bXlybDVCXj5SY3R1Q0d9bmhE aXdhOXppUHt5aDdRR1k/ZmRAcH56K2VFKGd9SU51PiZvbEJ3fH41c25Yal80CnpzPUhAO0srO0E+ V01vISNSZHJXPmY0fWVWZTgxPUwjP1J+Vjw1KmAwYURtP2h7JGNXaE0/WmN5fEt6dG1NNz5AQAp6 REc1anZGLW48KDImcURwM1h2KjZEeFgrfWwkQjVPTldralozWGFvOWk0WX1ZbCNIeWkwM31nTXBy ay00ZztGMz8Kel9LJl5zXlpKN1M+JWprKnl4P2EpYVN5LSNnJTRBJXhaNEs1ZWs1ZT1XQ2dkPCVZ bU49ei1hSj1QO1VzcGp7eUFOCnowUkQmTTElTENDX3dYQ1BeSERzSFpHbTReSzl2X14pPSFuTDho b2tyS2xIfVdqfGx1bktZbG09JVJsP3p3IXpuJAp6QUo5R0xVSzk5SXpGYDdoUHdAWEtASmx4QnxK cllWaC0lZl9MRTdLaz1HKS1NO3RjYCNrPWd2O3tHRV5CbTdFPTwKentxMkp2enJnXm5La2ZnbVB1 PEl9fDhGMDtkWWdaeWd6SEAhP0krK3p2M2tQP2NwWEIkb1ghOGgpIUY9KTEyKWNpCnpJfF9hanpy Z19pTVRCfnp6ejBkYDRlV2s9TCVyKD56Q2FOfnlkZU91TX4zZmVMY01CMmApQUE3TWV+Q1F6VnYo aAp6LXc9UXcqSEV1fEJ4TDFlXzQ7Vk80YDJOOWpVMnNGYC12MypYQTk1Z1UhejdgdnhWb2tZViZ7 VGBxRjs5MUdLT0IKejs9a1h8KFdNJDVLTihKNzkjcDNRZmMpY2UwLXlANk0/RWVRaXQ4SGNSZ1or TW92c3ZrYCZTcHwrcUI8eztFVFZ6CnpwQ2UwayU3OC1yU1RldlV6fTxwdHg4UWVNNiN4YXU1JEY4 MXZPWkk3WDdoamJwWFk3OSptOWAxYT1OPFg7M3AyPgp6bXdyIWNlZ2VNd0ZeVTNndTx9NEJrM0Ru a1M8aWQ5LWBucFdNZSkqSDMrdTVrWFp6YXp6MDModV4xdURCSHUlTSUKem88T04rT1BZVEBZPH1Z S2VldzZUJkcjKHVlO2ZxQik+YnpNeCgjP0tjUD17ZTAlTCFeJF9ZVEMtRDFRTT1nIUpICnpDaiMo bTFLQHdzcTwxfU0rblFmX0Y9cCpsPEB6fiV8OShHNW1afTRxdWd3MmZgWjNYVjh9dE98MW5qYzhF P2R1Kwp6M3RuZWBoQkx3aHJ+Kyt8RXViVW9hZ19VPXUtXk5SZnpKPW57eStPYkc1Qm9LJTwpUlY+ YmM3RzMtJGhCS1MhNHUKemx1PCtBRTlDM3kxUXQxTmNgWXZHMEl5Z18qKmNlVjAlMD5sQV96cWNV O31UMXA4JWQ1VlprfGgmO0pEY3tTXkY5CnorezNUYF9KXm5wZ25BYkVEIWRBWkZXTTFyfDRZQk9w Q2VhbGNzUGFOem4mKCokIVVCTT0qZHd2S3F1IX4hRT0/SQp6Rnl1e3huX35mJHYtaD9EKnF8cHpV fHN2eEBCZSQ/P2AlJXshaGp6a1JiK3U1NDgtfUBGVDx6ITtfdlJ+PXUmO2kKej1HKWg9TT1IMW9j c0VEbzYkeyomYipgSXAmM2NedCZLOERJTFFyR14jKF5KTGZDdUtCOTNrLVl6e2lzaGBgRkxqCnoj anBPO3BUPWAtWntHayRXRXtVSldkSUYra2tTNng+cVBzME0qSDNmK0UyajAtVkJpVTxjb2w+PTBJ KihOND87Mgp6QXs1b0I4UnE4cUZ1U21xKX4tRUYlcT4hJVU3JEtXT1MjI2kpTSg7V1lQY3V9ZH1P YlNYczs4bUZCN2ReQXl+UmQKenxIPWhBU0kpNyViZGk8ejhwe14mZVJKLWE+a2s3VCV4d04ke012 N1FoKzNePVpsKkhlJDV5LV9yTkFvLXtROGtfCnpNNXduangmMUh3S3w9ZVJnUmkoZ0olT1g+LVVk RG9kZWJeam40QFZRdmtOVFZiY25AK2NRQU1KOVpjUE43WmRlewp6NCppcys8MF99fnNyIz0rQ2s2 VCkjRUY7YW9QM0ZtUSU2fW9lVDw4JW0kXyZKVkJYZ0pNP1l+Rnp3dzArUSEyWnUKeldmYFA+K3dT e1heT2E5WT5OYytIUm48JDlKWEBqdDFiblc4ME9TKWp3aWo8fWU0X3lITnBxZWB0ezMqUUA2ZGho Cnp6eCVFMXk4Q1RSUGZiJSZJUnZqMmVFVXR3PigqQ15Vd25lS3FmZkUpISo4LWJqJWNSZnxNckxS Sk8+SDVqc3ojVQp6ITh6fj1qbDxfX29CdSslcW4kajFwYFBONFUlcnRlbSNkVj1JREMyVisyS15N NFpmfVEzR2hgNV5yaSlQJVlaJXcKenY/XjhSNCZUcGhaK2JnN0puJFo3cnteZHVoUVlwT0Bia31g JEl7I3pDRT5+aV9ANihrcFAhd2I7bUlSXiFUanpYCnpmPlhxdEFuZHA0Yl83eXI+Yz10Um98OEN5 OHZOUmU1b0BQQnltQWpJZn1JQ0gmRnlhd3tGdlUzX3lHQjJQNyZRRgp6X0kkenUtOUR4I1RJe3t8 QXIzd0MyeiYyOzJoKVl4bmdoUjR4cS0+ckVpfGgpUUxwVHdSLVVLZ1AyOyZXVChednIKekZfRypO I3EwUmRHSmRwI0E2PSMhVCVaP1RwY2g9dzZ0MFJIO3JuMER1MFE7ZDUzcTBkVkhgWipFanBFMDUx NmZBCnpBbVMoPyZsQWZOVCk3az87fUdRcilDZWcqOD8kentnamVxRkpvdSl0VzlSbV8xQWY1akg4 WCYxQEFLZzJaVHpJcwp6QEBXSjVFSEdWZnZnZ2VZYkxXNWNBQDwkJTA4O34kb0lCU195T15qUXEq PVgqJD1XVHslRFpzZzhsRj9aYjt+JUUKemFVOTJKdk91YUJETU4oeGlEaSNpXm9UP2NBJHZya0xs fCQrM29hUHBTakc9bV8xfXtrZk01UHU9eSZ6c2UoZFhpCnohWHhpe0h4Mz55SEMhcX5IJCYxemFF NkhJNSZRYGt6SUtZdnhlOUslcXJuJV5qKSF7SjB6TzxATHI0KyR3cyY4Kgp6WTwhfldHdj01RFg3 Nzg1YGAtT2c0bXxLdiU7eEtFJHp7RUExRzV3Tkd1TTB6R3RLKWJkc0JGQjcxeWJ2a1Z0OTUKekVF eXNhJnMjPUZsfnYhcyFGNEs+VG5FcHNBPU1PQjYoZVFETUQtPmoqJn5pU151akIyYClCQ31tLXls MXQxMCsqCnotRiprfGRpT2hWc3BDLV9jfCU7OXhFIVg7VmFgMGhPIzlyY2MkRjl4P181YlkzSDd3 KipSQmN0WVl+N3ZfJEFCVQp6QypmTSsqdEtsWGYlIWMqYUApSDshV3wjfTZua0NJZTNre2k8Q0t9 N2NxPEY3Y2U2MHtGdHlTeVQmRTA8Z0hrYTwKemhRelhtbHAlXihZckU3MTdvajVreW8hLTNHQ35v aExYbHB9Jl4oVERhNEM1V253N20meWN3RitnWiNoMF9lflE3Cnp6XjZYX05nQ3h7PExgKiZSSyNK QT94azx5ZEotaUJRcFFJNmNjIVlCZiR2LXNfYHJxSTR1Tm1tYD07ZzFDbUtJegp6IW0wVE9lflB6 IUBEbSg3YlBwNEd5SSU0cG40ZiQqYCh7N04hc05xdlVSfmNMQkBBJH0wYWhPZ189JTxgVUBKcmwK enpFVXcjIylJSWlERSRtIWdoanxpRmErJiYkO25xVl8+RCRgUHlGMWNIdzlsd29vSUJ0NjhgRS1f LW5fKFE1Tm1UCnpKNSR2d3E8dmNtd2hsaDwpdklOSUpvckAke0tWRiQ4Vn5INnA1eCRxQUxVSnRl dmJXKUd3OVRuK3k9OWc0eyVgcQp6USFHcnFsYWU9cTVJdipTIVRfMkJVJmNzc255PldEdyFzJnZy ZCF9ayF3ZlA+KXlDPUxTY1pLNCZyWVVhXiFATEQKektleWdgPnNZTjwoaTloc1lJTSMjanVjJlJK cUB9ZzFsTH5HdEwrJjB6eyUxemhJKngoPTEqQTstVzskQyptZDkjCnpfazglJS0xVXo0R2lTNUNx ZypFSXd7aCQ0enN1dEVCaDxAX001MFlCeDw+T2ckbXcrb2VxXjR7WD9+KkJxcmtVbAp6ZSprPT1v dzFBJmFtPTU2YEJlSWFLbHxDd2o/c0FZWjUkSSpJfVRGeCp0cWI3KV8oSzM3IzYkTVA7WiNfdU53 UzYKejF4XjlvKGx2bHpFJnpZcCgpdEJwO29iKiUlZ183KmhpfGAhMl47KmYrdjNMZ3pzYiQ+cEp1 dnc1MyVlS2l1SUs4CnpsQGVwWUFFZmR2WVFDbEVnUEx6JUZKcTI4eVR0UDQwRHVEcjQpREpCeXt8 eXl0dEtIeWZnXkUqMD1HPG08cnd8ZAp6N2pheVdRUmVzfCNTVnZoKkE3MD1EX3hgSipEY3lsRz1H LT9mQUBwJDwhdkFUZG1MS2FyKE5kK3tIZlhANCk2VVgKejdGJi17XzlscUxoTjFYR3RBKFpFQWBS KTMleHJmaTZqeDlDaTc2Mz0xKkN9aCpJIyUhe25EVEsjM3pgWG9FKzQ4CnpDKTBRd3JTKHhyOUhu cXdtKElFRzZaUDlUWmFIKU9hKyl1ZFBCPG10M2pAOT0oKXsxdyZ5blQmUFNTbn57JnBFNAp6QUxt eXNaK3xNTWBISyZLZk9tWkFeVzReJnBeVE15K3x6bkxoeGRHKnh5aVNzQHd1KF93JnFKMlhaQW5R ezU8VXMKemZnZzxsS09BXyFydX5FZ0I3ent+KnBXNT5sfWQkQWVlI285Pnk1XjA7OGhBZFFYLXwh ckBJT2VKPVJZQGoqQ1JmCnpOSz9OUXNxPmVERkcwdmJATThneU5TMTNRWkN2e352Yj9pNC12KW9I M3thSFl1TjhubG11VVhPQUspRklgRyp7dQp6bkFCbVcwejl8TSZHVm4oKjRAOXpNQ3x+dj59cTtV Tn5pXzJLTHF7PWhjNStuNlYxMkhOdXY0RTNlRW9WdT95KiEKemUpeWRhYktpYVU0UWhSMj54RHc5 VD5vZ2ZPdDV5Rz8kVjFXck5oKyRyIU5QLWtmY1c+QWRaempEPWheN0BePXEjCnpiaCo2YUhzMXor RC00a0QtcE08Q2xVOXRzM3Ngdll5fWEjSHBYVzlre0YyKz9fUWlqfCFRRyN1Ozxib0hGWCFNNQp6 SSgkLV5QfGc1ODIhNUQ3emlGSHc4SVQ4VXo2TCkrMj1mXi1DS2VIMntyeGxQN3l0UjZ8QlNCbEpE SD5CMiEoSkkKemo+Pmg3eUFta1RJczRiZHskKDdlbHNiUz9Na3B4fUdOYihqXyZDKm1NSHF1bmla RTlFdEtZd29xZX5VNWpjWDhpCnp7YTZfUnhPKHRgZXJYJWpaIyNWckU1a1JGZ25JV3IkWGg9Q19j K3Y9JHFHMG51Z1JUent0KldrSzh4ZCY1WW9AUwp6JFl6P0szV1pKa0BpeVo4T21HU3tLTTV5USUq antSeHAya0BVfTBmX2tBQ3pjTWc/QD1vUnBAMUUpIyl9SUYxMjgKekQzQ3JJPU4/Qno1PXdVNUZO dE5ieV5uPn5gWH5rfEI2P3dvZkFpKTJ5dEdfMztMOCEoemgmXmhJdTg4SjFpJmZDCnpAIUtpaG1Y K2skYj5JOzl7TEMrS2N5Uy1LMWJva31iTFpZKT05WSFlMGdtcEYkcE4zbGBOUTZSSm1CeVorNUFH eQp6OX4wKiVucnxuUlZpX1RYOzdrOEppflMjY15rZEE7JkVZN0NSTUkmQXJvYHhJPlVXZD9yRXNM ZUBqT0tURWJVOEEKenFlQHh3TUBvQHV4SV8/MzJ0JFI4VzVSXjtXOEllJSk4Sm8hY141flF0Q1Vq a1dyNm5aak9IZ3pGUXFNM2AwVFE3CnpCakAkY1B0UzRpIT1MN14rcFgtTD1oaXZBXzwwV1FgcjhL bEkwZkpLXyoyPisoOSpvYTdoMW1gcXhtRF57SmlHdAp6KjkoJmdqRVEyd0U2O2IqU3BNZmZeQkUw KFQzMHI5LVR9dnZ4Pn1URXsjKmZHbTVtRn0mfGcxO3QwYldha1lQWD0KejNIfHhmTHJNP25SQj56 NWxxWTdXKVRWSyZ5UC1hWlNEUiZKdDt8eUkyXjEkJGNxI0IpTkFTbDl6JG1aM2t4VFE9CnowYHU+ RWxzQ1FPe21pOGE5O2R8M15QbEZILUc5ZkZXeTFwUyNkej5ARGNqO3VGQiQrX3MrZzZQSHRxRTtP SU8rYAp6VnVUVlAxPGZnayMteippdGNPeTxxPCYraDZnPV9HclN3WmJAVzVNbjtETlVvQ29rKEti c1UqQjNrYW93UG5IKm0KemglMnU/TXlLN1Eqe0QhMVJaJGFyc1p8IUN2ND1geUgqUzNxdz8ycEtI VjlPaWgkPXpvNlppcHMmITtsMiptcU4lCnpPR2hLfjdtRk9kb3VQZloqUml5VDxMNEdRZWlKNilH bjNAQEFOP0hyWk1TR34+Yj1+JGB4aHlEUT5vMV9qYEl0Xgp6Rk4qVT1JREJDZ3Zid3klYEUkISR6 UFFmWFlMX1NzaUE3OHRZYWFrWjxCbHRGVTVRKFFkSU1UPkMxd3t+Q1I7OUYKemBMfigofExJU0Rs OUswVHpgSyQoWWxGZ1pnbyppZEg7X2Fqe2RII2MtTiglU0gmTENxMGEyTWx4KXM4KExMXkU9CnpR QThCX2drY3Z5XmE7V3FWWCM1eTJsem9pNVFnfTFpRzJxZXtQMVcte2J7ZV5fUHteNlJxI2clMDZE TH1vVTd8Ngp6clFPKipIKih0dEtmeXR9dDYtdmZHbCV6bFVXYTwzUzdgSWNkaSRIaWBFZTkqPkMh NSVveElHNlMxKy0kK300UX0Kek0zISh0N0ZeNEw+KEA/NT9WIWJpdm5SQ2sqSmAhKyp2RWNHK2oj e0pMVGtPbSg3am4hOzMlWmYwNjgrSVJGPj96CnpeRTFSayhlSmhxS153cEM2WiMjKEFSclBVVkhe K3o1bTZpdmBhMChqZ2N8JUg0RGtieGBRMSsxKXF+eys9PEEpTQp6ZVhIZD8taWlSJnAxKkRUWFcj Vl4/enFqUWNtWFFqRzxWK2MlZ2p4X09+PzZgLTdsbmxHTHh7Q0lSRSZ1YkcmQHkKejk0QyVsTE1F eHowcjJIV3o9eTlEUVlsYDNwX19pYDR9SXtiKj87MytXOU8zPGZocSZ1PXBqO1FDb3U1PVB7aVJI CnplWk5QKSkySDl7MzhSb09qMGktSiY8fX5ATkkmUTZhfWI3dlFBRlNlU2BZJWsleDxXPVF9cEJ0 NChAaXF8TFdDJQp6VW5CdGVwMXlwZ0ZBNHBvP3xYPipLSitRfVdeZVNeS2w+PCl0dyVLTnJ2O2xX I1E2aT57JjFYcztvSzVXZUQ3dD4Kem9tblExPDFLM1lDUEU8PE4ocWo/KnZrcShlX0swJEQzaEBQ MUhKfTlOcn5nY0FQcE9zXiNITDU+OSlKe2BoRUp7CnpLMHk+ezRVY0BIQVJ2bEVxOTcpV3FFcy0j Qz9lPHZnbUZMK15hLU4/JEFqNks1KnkxJnpyTU9Jdn5NcVlEe1Z2agp6KTZTbEhsUmZZSEM8aT5O blBha2tEK2hMY256QT5rd1NQO1JVcXQmXm9aaz1ue1A2cClAWjhmVWlKfnxRaU1GbG4KekluOUB2 VU40O3MybV5nezQ8QTBuZCoxelVuKT1uaWdLfHVObjJjfjdyT2txP0tuWlhKdV4tV0NjaiRLZV4h azFMCnp1I2V5RzVrP19Wb00/UWN7ZVU8b2l+XzxTQ2lEWnNGZCZUamdyUUZxZ0BscEF7RyNDMHZl YzImKUBjOHYwZXN1dwp6PUxLTjFZRzMwMFB2OEdBY1JweWZhZH5jP1RYKzltV301ZEIjcH1hJUtr eDlGdzUrcm95P2tOazsteksye2YrMGoKemFCanVZWGk9Y3krdEdaTFVRNEFvQD5IaCVwWmZVRVFM VTc8bFZ7U3ROKmQyIT5nT0NNU3MpeVA1SlhXI3JgQEk3Cno/Yjd3VGJvKlVgek5ZanI0MloobTAz USlYRjx9ckFgNXxFeDVKZHJEKyM/RD8hWjA5P0JPPldDenVTY3VHMnBXbQp6QERzNE40TCtic0JO eyNPXnE8KU9zZmlZUS19TkUoKl99TGRsVyR7amBWbkgkOVptYlR4MVpEZXl0allpI0NnOD8Kel8y KzR+eVRoT2swSn5qQSZeZGYxQn5jKClUYUUjIVI7enNjPDNGb3l6aGhgdU4pNWQyezNTflpWP2gq enZeeU8tCnpvdF81Mik1Wl5je0pfdCZKYE0/Xm0/I1dRQm9HcUM4dkgycTNIXlhyWHJfcHhtXmha fis3KGx3TW9mUytwN3V9Vgp6R3szKUhAQnZ4Y2hXOUBLd0M7VX5MdzVKQj1RVE1ufDRIaVEjZ1g7 PUxDcjdkPGRMRUEyfHx0XkpJYFBJYEJRe1oKeklCZXN1TiVLfHV5aXwoVWpzQHdMZSh6N2NpXkkx YylPNFJ9eXYqVyVCc2VpOXIlTTxIdzBtdGotNSV9ITJFOSY/CnpVZjsqPmBDOXY8ZyFXX05DP1g2 Mzt5NXFAOzFoPS1RNTAoTSE7bn0raCZWPF9MOCg/fHMhP0w4KkdKKiEhTXx3MAp6S1ZDcmwkPkRE bWU0N0VCNSF5ZUh7SGF1I2QqfjdOK1AoUl5DZn51cilIe2hwZC1GS0kkbDxkeGU4LVFTPDFmRFUK enY7a2loZldJfShGT3tLR2M1cHF7XztWODlTSHopcXshb2UmRlp0PFJ7b0xuMXRxVlZpXkpudD44 aEJIeWxAZ1I3CnoybSg2JjRqWXtmSXZaV095KU5CT2tHfTdsa1Mtd2ZXOD9UbSM2b0wpRVZLWmBW TXJfXjt3VkpLazxNNGgqYzdIPgp6bDtiaXo2TDdLREJXQiRPe31TK0wjQHB9ajFvLSlgVjVnd04q TERDVzU4dXlpJClYS3FHSmdBSktUNjQpdS1kckIKeiRON25hbXRecGckRVF3Ujs2Rlh+M31GfSFZ cjR1Nms4KjxHSUVzYjZSaTxXMk90dWBGUXg0U3psdThtUTEoNlc2CnoqOCtPSW42PjRJU0R4P0Q+ dTR1JC1AZCo0XmRzLWQ/N1M7OEoxPio4WndDSEdlfnRFZmhmY1JjcmB4NjVIcU1fKAp6PSE4TTI5 WTgtTW1IfjA+Njlwa2NMYDBFMyQ4bjRocld6QC1scn5iWnlkS2JWUil9ZmE7OW15NTJBc34+YG1W S3IKendRbnRNLTRnaERBSFcmV0BSOWNTenY9RFZWMFpTK1BkdmNGPGlpTmorZzY7UHhBe3Y7dE5m P09wMX1gLTUjU2ZvCnp6VCt3bS1QTDBNJXszLXhUd0c3MlJYe0MoM1pXRjlSRnRiT0UkT2opQU49 dlolQUNLdUA0bERtKSlZI2BuYnU+PAp6Yjs4Xj9NLVlTbzh+cUo3KjRsTFk5WGpuVW9sYylfdVNk YEtAJXgob3FhYUUoSzheejdDXkRkajJ3e01hJXs+dE0Kei10X3djcl9RYyg/QnA4ZkZMZT1PVkJP aj5ARDFSTVchcFBEMGx2KXVjQHQye0YrZykrRlomKk41M31+YXckT1N2CnpvPncyI0BUQW1RNWEk PHBgJDZSTT9aMTQxWm5yLU17NlExb2RYZlcmQ09MZjFCK1YlJkUmRkVSPm0wdk94KVZvOAp6a3Vw ZFcyfkhqaik1MUBgLXspVV5AaGtqeXxMdm43TEpocHBfezBTQ2dBU2NgTT5+RChGNn5hMlBPblMx K28jKjwKelkzPVVeZ3BwNGVgTlVERTBnb2J0ajhmcFd3dT58aHhfRGBXbXlmUy0+ZykhY1pkODx6 VExKekdJQig0Xj12IXgtCnpfSmkkJHA5c0xYQEdsakJMLSg9MkhLKklWa2ArNChReDZ3dHo4RCRq N3huTnheVFhxdWRGeyQzbnhCQ2BIQ15JTwp6Wj1ZayZ6TiEoWkpvdihadWlMUj8hV3ZRX2d5NHk5 V1NQSXw+MW5GZkR1NFd5RlZwRkNgSVVlNE5yLSQ2ekFJM0sKel99eEQzdF9GVCVxZk5XcHJQSitj QDR3cmwtfVVpPjl6b2RHbmpoKGBwOVdrWTs/Ukp1KkQ8V0dfYz9pSGx+KyUhCnphUGV9dEZiIUwt NT1RfD9qaTxrcTgpREo3SnBNIXchbTl5NCZqMyEme0BXcDdeUkJuRCVVO0paSjg/Zz8oeXNBdwp6 ZSFpSypUQ3BRbCU7aWhWSm8mYDJFenx6NEp5amxoJmpPN0pHSiVxJkBuWnp8KGc7djJfMiloSWhu YTJOeT9aeWwKej8tUGIwVTtlez8kTktzUHp4SiFZMDh4TTwhdGVFSF91OH5LeTBxSX0rVDlOQVBF V2BGeSZrPTg0P29hfXBDfUhyCnp0KE9gMiVGdWkpViRQbWo8TEhTaW9JMH5jNVFyaHJzfH5wTVBT fEAzRU1GcGNfTTNGOXNWMiFabGwlWStUbDFzcwp6Zl5RMnpLSyl5Xm13Qy1EdXoxaGdHVXBGcXVL NTtSciN4NykmQnl1cSs8dlp9fElgITUzQnpjRiEjND4yP2kqQDYKentRbGpQJUY1Rkd4UGJQQlgo cXtOVXIxZmxJZGRaNTt1IyhMbSY7e1p0cm91VDxOSDRTZXhIQilAQlItflNKd0MhCnp8Tkd5a3py STNlcXN2QzhMJVpGaCk5dXBrXmt7RSU9eXA0RitnPHVXbW11KFUhTilqd3k0Z2Y4OERDbE5hT31o dAp6VU9sbkcobkBiUTw/NnVWT3xiaFdtfGxRTjRheWJSK28xbUhRIzUpVERRTmlfTXF6SDhqWGwt T3MjQXsjenNMbFgKejNmQT0zWiN1LUhKKUVJaG5yRWhZRkV9bnoyM3dFd3Qte1chNkJqc257TCps UyZqUVpZe0M3T0VuXklYMHcwYWZPCnp7eEpBVE5gI1g5IVM4SU9Vd21kfWhCJUgxZiZrejVidkNj dDx6SWdCMyNfaUpAckI/MU1jVW15P1QhSnktOE54Zwp6aGk8UCEtYENuN15uRCUyOH1SKnAkZj5p LXluTzV1cl9aZXUkOHpZVipCWT5SME9zfldyM3omT2U1REhJRHdMfFkKemI5PE9IMCs0djdfRG16 Ji1zZCVjJWkhaylWQnsjNWdMaD1qOXc/WnMtOXApR25LP0xIa01rMkloQCpoeCQxVn5ACnooUXJK VTFIVW9oQCEtMzVRSz40YytzRlBwViEreygpX1lALV4jZXE0JSF3bkpxY3RAKE1aZSFxd1pHSHAo Q0t0Zwp6TzdWdyhebCNZY1oxN00xQHFhXm1McHkpbmpWfDQ4bntJIURleUAtM19YekA+JSF4KEYj Znhoa0okOUw2Q3pzZjAKemBAYEtlOV8rcG1XKjREYTJpRkMhcT5vWmIzcWFXakwjWUQwWmVaZmYl anN4Wm5LSzJrVyQmWmg0OHR2aFp3bypeCnoye2JVaD4qaE97dk9sVT55JUVvP3IzKSohNjZhQGFU b0cmUVpDKldrSzQ8NkVQQE0wJGxLYkRqaS17PkdyVHdnaQp6RnZqNmFYa1NTcjUtQkI1ZUpjWntS OyVIPEYxPW9sZSFvd3oqR3NgcWUhbGtEU0xrKit7S35LVjRTTC1UcXhCdjkKem99djlQcHh5MjhA fmFtKWBwUEJGVVJYb1E7ZHxZZmdkMSp3c1gweWdqIWAkKTEtR09SdUxORWh5aDxocmkjSm9aCnpU Snd0TDhgX3s+NzVHSkFwcUYzZ0tRK1ZMdCM+aERYYTZRXng4Z2IjViVnbk5vUyRFQGJNbnxGWlRw QXZgLTVAKgp6NEw4PT1jYzUtUVhMRH5+RCgmfE8oPD5tNTJxRSElZjxPSH5HbXBGM1leSnQ5cTVo KHVaKyspSygmPXBRYEc0PnAKens5Yz5EPy03Sk9qLVJeM2JJK2dRKXN2VSRiYzNQeVJqUCpLX2g+ K0lFYnpfVWMza2owQEdMPG5tN3J3SXp9fHkyCno4azA9Kys5XlpKNXB4YyY4dkh5MTxqMXNAZnko P0lYNjxRUWptbG9DPCN7dWxBczdGVFNnViZUP1VwSmM3TG02Nwp6TiheV0RFYSVURiErajZWU1p1 TzY/U283O1VuczVsS35NMWJWP0xgKCs3YFI2T1N4Ujgrd0c+PktrbnpyckB6TjwKenskYGlJXnwz PWR7cD4zfF5+QFIwVXNeNEVaTDxZODlmcW1kJSpuJHdIYTBmey1FcCo4YTlxcz5qJEBkPmdSKjc9 Cnp3PjhnWHVSWEFfbXR1SUB4aCgrTzApSkU8eiFyZT0hZF9iVENyO0ZFI2RHVWZOTFFyIXhpJjZv XzQ7KyVVNnc5eQp6ak1hUkY8aT4tT0ckeCRfWi00OHc/e0BgSGVKa0xGQyZFbFNFMHhzbz4tWU94 eD1BbStAKktiWlRRM3NGIXtKLTAKejQzamVzJjZaLX0yQkAyKmdwUWxoeWB3LW04UHpIQD1zNGgq OFJ5QWsmalk4VntlYWRrQ043KkRudE5PeyZSIVBHCnohRDcxJVAkJmV1X0dHUXpPMklfK0NPbyVf a1V7WWg/Y0EhfWVDemd3XkREWiEhdj8qZXUoUigjRXpLczVpfVJEJAp6N2xIcnVjTEo2IzNyQFdw WFU+P2h7WHIwSFloQW56elQ/MjszXmItM0QlRTY+c0lEMjYke1BIRXsoNlVqS34oQTUKelFwWnx1 OzIwMkdWLV81a1MpanIyKnhVVTBxXmt4JD8qcnJ+WmhKcyFaanJoQDBpfEJxZ0cpKEEwR2tZRkN8 YjAhCnp5M3tUVl8zWSUmKVU/T3N0VUVUbkpGTkslWC1xKVM3ZC1QPDBaVyR6dENzfnFVIX55M2Fa REo3UzJZISpUIXJhKgp6aHglaiZ0ZHFfTCZ+Pjl5I2lEcnd1MkxHJVdVcFNPMWAlfTNVQEdaa3so PFgzWWs/WlkpNmJvJnJUbFJ3ZkMyJlYKelcqNGExT1d8dGVjXnMjbElkJnVCe05qYjBBPE42e3Y2 YD14V09gU1BUM3YwTV9KdEpxVUNDNDUpfCMpUjspTmQkCno9R2VDamV6XmtzND57QilwdHFyXkpv VikpQERuQlJhdmNeKjhVfk9XUkFwdW0rUiNaO1pNSnRLYTlvKDByTlp6fAp6RDdNXk9eSDFJZiRa eW8od1B2JllLVDNFMEkqeC0+O2g0IUJCYklCKW1gPU9EWCowKUUlaVJMX2FzPkZrMjQ1KXgKelUo I085cSpxRzA8cn53UWdGfG4ybkF4VDh3JS1CMlhXeDMyMC13QDZuRTtzOUxMQW9zP2l2PFZtSXx3 XitNRn5YCnpEYSQtZSUldUF3PGNEcEsrN15lYUgzM0JuTFJgUmBYciZGUlgzMUMwRVJHMldHPUo9 aDlUXzUoVX1kPiZ4X1U9OQp6YjJ5SG8rRil6eFVDWlZOe21rWW9zb1QwJUYzV0Eqak9HKl55NUN7 JUw4R2xRMTUhMEx4WEMmfSQwbE1jVUV7aSQKem9scEJxWSMrZTlFP3MxVlVSKjRhXzUoOSZOSUI1 ZEUzOXEqakdZMzBsbktiTTMjOEcrdnZVQmhRYFI/cU9xYCNCCnpaeXBPMTAhQzNfYHVSdDxhZ3sx aXBLISorYDcofDNaU2JHXm1iVXIyXi1KSH5uTyQ0RVBZZTZ0dD96U2IlXyY0PQp6RCNFZDBXU01F VVMzKU95KUw+WXJSMGZhWlc8c0cxXyk9d2BnKjVLRjBvJW94MEZqeDNXRiRlUWs/dz0hNndyUT0K elh9QmZeJGI7X3lQTmt+OVRDenFgPUhtV0ErUnZ9bU9GVmRVTztSNCNLbyt1cVFmNkpmOFhNO2ln bkhpfCljai15CnpQcV8tVy0wZ0F2aDJpalJhdDBweXB1XjJ+SSFGbW9WRVI5RkMjS2U5SEYmdExM REJ8VVchXmtpcmNhN287STZWWQp6ckRuT0pDSm17RENUVHVPNHlwWip0P1kpelA3MSpBS3I5UDwx d151fFNGSUZJPEJFckR6Tz8qPXErYnZsXmRVaDIKenNxe2RGdGlORCVvUyYhdGRfOzhmb2VxMCVF XitwUldjYFhfYXUoKG45ajE0fmpmV2djV2tuUn5SQlZEfDs/YnZyCnpxbXxadCpSd1JmMno8aTtO fEBCMCU3OVA3d2B7Jmp6JkR5Tj8zSE1XKlg1XkZmY0pwbGhDWl5eeilPQSsjVCQ1VAp6Nj50alV7 MCNnLTtIQT1hYVhuflplRGBofkNuSHJ4JE43b1BBRWJUSyZxJUlPUF5sXm8tMG1RNmJDNjBRMUB6 aSoKej5eYTUzeVA7WjNnal5lNyQyZW9qTl5uaG1DWV9zcll9dE5XTEZ9cEhpNFVOSmJyeDJlcTMl TFFkWVMhQ2Q8M04rCnozSmRveCspPmVSOE5FfWMwX2IlWj11aXV5V24kU01ydXFXI2xTMyV8VCh6 cTI+Yk1YdjJuNDtac1VvSkQ5fWpAdgp6QDVWZyZPJCZUJGR8VCNoc25sVzF6Rl84cEozIUReOURp UW5gYH4jPjdpSylvMkNpcVdPSXFffm5BdnpgZWExanMKelg2fmt4Z1d3QkcyIXQ+V3BLYkdIPGBk WFIxVSpDJUNJeEJYWVo4RT40QD9VVz9HMGw0NGdLZn12Rkh1PGBCfm42CnprPikyWFFKKDxVOW4t Z09wNmhuOSUzcXE+TV8+MjVAdTFET3ZfMDlzVitqMUBkTFY0bSs4KkBiKmZXYTA5Xyo8UAp6UT5i eDByS0AlPjFpbDVkIXw8TDM9PVVVbTNaV2d6UjB1NUsoYHlfMm9HMGMweV5Wbz0zKn1DTUs4Z1d+ Y0ZxKioKeiVTNSg+X3xhdHwoKjt9PD1NUU1UKFI/WWhEUDhwbXd8S2Roa3x9cl9Zakw1Jjd4Wk1J JX0pU1ZoS0gzPUM2IXpvCno7VFVqZT9CcX1ZQ3RsRV87VDw8USlJZEpKLXg7Pn4lSkxCc2R2NW9Y Til0YHchNV5ec1JfTnpBU3EodH1vJU53dwp6enJFKy1qdER+RDFQcWxOU0ZhRyp4MnpqbiZgWkZF O3sxNFVCdWpwVGk8I0lwSXByMzN7QEcodHRTdj0hK1IqXmAKemt1VWhgWn1eKF8yZlRmaTA/dlRf Q2xkbVA7VDxRZTFQK2VZQER0QzItXztwRHlMUnNZLUY3YWdaYCp2TSFMRGIoCnpqV1klaVIpfVhg QyUhOzNoJEkydWIrVHhweV5gKSU4MFd5PmFUOEZxcW94NGpySGwwS1ZvKSE8cCEpIWxJTnhaIwp6 TlhOMW51eWROOSliblJ8ZCY5Smt3UjgpfiMjK3FVUWp+KFBscHFRZUIzYWdMVFhtJnxaTjNEcnRo blZLaGkxIX4KejxnVX5wM0ZNNDsoMSNOKnNDMXV6PFRhZlFFZn5xSW0keztCNjQjZj8he0NlOTlF bExiZ0RoYURlbSQhXjQ2dzA4Cnp6bzdaVS1xKDE/T25Ad0NKJkorbyRefC1oRnttRzJCI2hRQUNv ZGtqUnp0T1dKKTl8RmhVcXlNKkhlWD5qfVppdgp6O2BFNy1TUzBneDcxYXNGbjskT0crUWxIZj1m UEx0bUtCSEo7JjgqUWFLfkY2WUtfY0NOTyg+O25LTmd6Z1dyYn0KeiZxMSR+QzIhVzNBZFV5VXtE SFhNRmhJRjdVaGBBQ1ohPHRyMntaKkQqR2tRO1VaenZmPlJyX1F2MTJ+SzBRZiszCno8czlwRkYt Uz5DRlQ3fFJLezEmNiYxdD9wczhOYCpabj4oTStnJSMpMGtWRGY1X18jVWU9MV9fTntvYGElQk9e Kwp6KHVEaW87bkE5TmhNZDB5ZTgqR1ZAcW9rSjkofVZMbFdeQXF4KUMkazNgIU4xUlVET0wwPEhD ZDR7TWgjVFIkU00Kel9ndE5Ma3xWU3wwWThsWmt9IzAwSjxLYSpnNVdyP2M4UFZYNXd1N00pSmAm aEM9aF5mPV5gdXJ0X2VwfTtzYERnCnpuTWsxNj1FckZwU0s3e0h0czM1UVY+elkkYm96emBlKTlZ KSZ4V1M2TX57WDhNWGU1WktqYm5zWWlZaFlkdTYhJAp6WjRQc2I+M3xRVVAmNmp0QExUbklMQSNL ZTxAKGhDeEZgc0VhUG1kQ18/bVZTKD5UMlZkP2xlJEgrdjBqMSQ7flUKelpUZmU7T2JFZ052OWBw QG40YlJ+ViptPC1BWUY7bFVTcypoT0xYazUqISp5WFNhYiRAMG1mXjdDTGx0XyVyQ2xCCno+JGN8 MDBxflhhc3hGX2AlXmI7R1VNMktlenhvOCtgJWFJa3hsSHJER1RpWTElPE9pdUk5JXg4TnVWKkl4 YyR3Iwp6QmlFKyNmcHsqTCNPWmZvPC0rRlJFMlJyYlRoO3ZKeipHeDh0MSZjYjZGWXk1UEghWEsl YF9hKntreCsrZlY5QjMKejdhe35Ga0ZhNG9mfXZRKWtDcVRKK0M9bD8wbkpafUlRMG93KytQfT9l TytMWkRmb0lPa0spem1BfnNlZU82WnxaCnpwaHZ0XllLbldfP2xMdjItU29xNmgxdVBYOXsqeTR1 UnozbE9seTQtNCF6bEF7dTBmJWJNUl5+QmJTMV8zSFgobwp6YVI5ZlZgMilAJFMkbFk/VnpqQGM+ SHAjaCtQVEdea3RHQj43N0Uldkt6PnVAV2FXdX0+U2ROMGFEWElqe3xyTDwKeiopWm1gSjgwMTZD c248fnBfNTd2VSUydE1HRn5aOWB3VzF1UD12blgkUCpGJG8tfUQoVyRPQmhZRTVoWG84Ukx3Cnp4 MG5Nek55eC0xMXkpTSEzKjM0aVJCRDU/S0xFYm1JYH5TJCNCPkpxcnJfSm9wUnhCfFNzJGdjNGco enImWXhnOAp6eDdJJUBTb1hFIVBHRD47SXRZQCpoXkxRbmFicT5oMnI4Zi1VTHEzUmJmJDBLK3Qy RnhXPW9jSXFiRDhLUDBobGQKejglcU49S05XXnRvV0Y4S142ZDl3Zn1UdCNjPFFPIWw0PTdjcnF2 TW1MYUhJfjY5OCZXI1Z2UjFfVSVIPVM2Y19hCnpRckZKa1J5OTlPYEkzUU9IdFBaMGw1UF8xYiUt eVc9QXlPaUpJRi0/Skwme2RWRSs+YT1tWSlMJVVwYyV1VVdJeAp6RDFsZ343aEtHQy01UjAhbilV fUIhTmU1WWMzKzg3U3E7JkNRSmxZV1FTI0tjVzdieWBMTVkyfFEtZH0/Kl5FSUAKejIpO0RHdDJO PX55WSkoKHREKmcqKW9ZP1A/RUgtYUtrZktZU3NRbyl6RXs/ZDlTPV51eio+N2I2QFkkJDJAdHR2 CnomPmU5Q1JSSUdlVGN+JUJLRTspUlFsU1k0Nk5rXnZgd3dlPWFYcjc8UCNrYDlzU3kwNElEY2JC QCRAJCg9VEF4RQp6Km5wVj4tQGVmVTtMOG1CQnNRPHM7cFYldjRjeypLTnIramxaViZ2VmlzKldw XjM3VTZFZChZNGM8bCZGVyhZKHQKencqb2w5TkEwdXxzQiV0Vlh4WDEwJl5gNzdYViNhQT57Tk9g eW8/XyVUTVojKlhfKFBgeGspYEFDQXJ+JSRGM1drCnpAIShyPWVpJGZAezZPKkk0PHhIc2FeQWp+ JVVgSlpWaTBfM3dQOTZpK1hvLT9gP2Q8Y3ZfOVcpakxvbTsmIzJUZwp6QyRRSGhJe1B3YnRPKzFf S1ZWMW0wQTgqZUN8TUtXPHlRI3orUEwkMypuaTttWSY1Sj82MzF+VmRzOVFTRkxVZXMKemlvalA9 cDxHRjgtcj5weEteUVBMITxYallmJGohZUpgMF5TZ15WMjIoNGpgdHpSYlhuQlVydHgtKyRxUj8p S2RkCnpfe3B7M0dpfjUlNll4ZCR6ZE1lOFBwdGAhRGVYV3VUMlA8UloxQjwjU1UmUHlvJj5JLSRI U312Wk5tc1E2WVBpeQp6RENLZnVgQyRiMUc+WG8xLXthaTd8NyYqSjVrVzd5TFp2aUskKnJmZktN MX1eMG5jKiNHUl5Rd3NpLXktY2ZZTn4KemxpdiZwezk/XmRzKG1TcURpRCQ0QClAeyVTfnJyYEMt bX5IVDJyc0goeypAbDhvfmZOPnBJMlRTPHtJZzVwVTFvCnpsZXVkbGJlPj5wJmckJGIwTj5WcCpV aE5FVDhCeV8zbk5fKmp6NyZnMUdxaSZGVVVtIUo1fjxQM3FVPitOSzhObgp6WHV0WCN1Uml5RTQl KSphbG5DakVtdVhoXzRyc3BKej9zelpaT3haUnElZk5AcGxIcClUQFFMWl9xfmBYRVlOJnEKeikl RlhyY2ZGM1QqaitocTY9ezshJGxTb01haVFOOSFCNEpaMGpybUVrRD1ZKG1HfUlVVylqYVYwSWst YytTS1FBCnpSaHh2OSYjYHZxRDZkKT8tP1FqSDl8NXFfUEdDTTZsIVBDTjBCbDQ3JVROOSM9Z0Yx VGdKPX4kVEY7aHZrNyhkYgp6X1RKMEQmb1g+Y0RkelMlLTJJU0N4ak5fekQ4X0BZODF+fFlNZihH N1NYVEBGN3kqaFNTWCtZNzl8a301ezFlQm8KenE3elpvcmU+O1ktR3FRMXl6flB1IzM5U1RoOXYt aiNRXnl2NUlnTXlJM3JkSXJ+Ymd8R1ZjRHsqZ0w7UyklRkR4CnpMYSFOc2txJSFUZH1WZX02aUgx JERyeXNvPT4+PD9EPj99QFA8T1klbXhERVZtQ3g7dTFOJjtnQU4zajViTERETQp6ZTs1UW1xNWc2 T1lRe2BXJlQ5SyNwVllhOHZvRXZwZ0ZvbFZJT0dnXkZ3fX4lfERCdX14R29HcEt8QEhDM2tCUTIK ek1zSWBqLX5XJUN3Ul8/ZjVYTm5TWGliQiEySylBdGxJe1RROGBPbEEtaiY5Jm19dFRNP3tiKmk+ LUA7VVBybDxnCnpAUk96Q3VEZU9oVSk3biZgaC01Sk9gVksjSiRVaFAmaU5oQTh8YG9CTGNwaz9B JXZZfjBHa1F5ckFZYXE1dFdybwp6JGJ9bk5UKWRJYEskb0o1YW9qUXZ1MzB1LXRvZXk0N3l3QDsq QlY1fSllQVBmbDZLblM9PUI5M1V9OG9XZDRpc0gKel8ocDwxV3B4OXxmP0JfKTlsaVJiKjgwZz0/ SzlMVHY7WjdgbWVuVnwjdUZtdVk9UVBDZilISH5BSFhYQi14O3g5CnpGZFpOak40UzJVc3Ilb31x VSZhVEhOdmRyY2J0LTBgKGBGfFp2d3RqOFRlQWxSMHlQbSQhVWt5eXM2SCQ0R2BCRQp6e1E4OVU/ Q1ZZS3hSb2xwSHoxJFJiO2cwT0VieXpeLVohVVZhIXcwQ1ZAbGg5dVl+JmNBOH5afjk1MCZDPytV T0EKenRYcSpsY3M7LSQjUT9UPkM+a0E4MX1hejEpMzRONnhhQlRBS1BjJnw1SzFTaVQmSEJiYUFg SlokWGQ1WVg/fks9CnpQdCZ7UnhwRDwmN0t8WDY5S1psKllMbWp3N1F3R0tefC1jWE9Ne21yY35G Qnd1JkwlLXgmQ3JoJmo0KDt3QU4xPAp6K2gzY3x0bmxSNXgkeHthXyUzPUxAUmI3WDUzWk4/azIz K3pDUWhMVGx2bDZkP1oxX1U9Pjtsd3prclNlYmxmeDAKel9iMHxfekRqclZ1KSl0KChrTXo1bkJF MlJIfFBjbW9wQDIwV2Rxdj1LV1c2Nm4xPFFpSTxAUDEjZjY9dT1PRjBvCnpfY21NTyFCM2NAVDhI fFNxNVV+U3tnWVpLRX1mJER5fDQwMnpyI3VOSDFLN2t7VHJgYF9LeT5RYWdsKipTZkpHMQp6QW9o RHF6VWc2aFdBKXJpVyVqJlA0bz1kN0JNMG1HZENnQyZjP0lDLSk0UHItIXAhZWd3QzEyT3BeR3x8 K1RpRmwKenVWVCgrR2tlRXFXMzhkPmR1dDlfXkV4YnAlfWNzVD98LT5FOHZKQlFjJlRpX3BWV1ZB JUEpPlNMO3dDO2Y1Z2pZCnpVKjtMM3tZeXB3WSR3cHh7X0M8PllANylnPU1OLTlDQjJLTT5FYmVm K3I2e35TLT5PfjlWY0I1dHkwYUc9PyN9cwp6VEFIZGgxd1d0T2J6TDFzTy15VTtZUnlBeW11ODl0 O0hsWStkSzIldlRzRGgxPEVeKUdOcythTjQtfXBYel5+TGEKenFmQVVeOzVVPCRady1GJT1iVX0h fEtvQT00akA7STBJWFRzP19aREh8NWdSUyReRWUrS31nTlFyTClBWDhScXhnCnpPZTRTNFB6c1Qo clo+KTt2QH41Qk4qPDx0QT1KUFVzfEBfWDFXJiVPR1lVWHExNjxJenp0d3Vhb200OE17aiVscAp6 OD1GNWxyeWFvaHIyZ0hqUHFPbFp8QSlWaGR8dERfVSRxaUljSkAhfmJtKF9BNDNHfkcyTHZKUDZF OSFIVFJnenIKel5nTlkoJEYyNE90Yzg9cFdDWFZqS0k2ZlUzIWRLdXtRUWE/NWYzbG1DYCN7YzI3 YT87bX1reHVkP3ZMP3hPOXJuCnpjbUlVdlJ4ZmVYcVc7OXxBQz5lYFdCZkRjZEk+PGB6PSNuLTtj bCRiVFUoLWIpOXVWUXJ6a28zck4mQlNWXk5aagp6NExldF91U2JHa1B8cSZ9ZjE4Pj11NVo2az0q K1MmeVE/PSVAeiNmRmVffWViYHxVTT8/fGctJD1VKEFpMztaSWwKektRM3RkYXorUk4qQ0coITdR cjlLNHIjYyFlMVoxSER2ZXcyVnp5R3hoRCM+WEc/STJNckpSOTZPJWxmQykyPkNHCnpKZmsjeHlQ Q2dVKzgrU2xuJlhvP20tUV5zbFdQOHFpVDR7MmBvIVApVn4hbnJpWUdeQ2VwMl8oX3g/S3Q/Q1dl bgp6Rn1FWlAtV0NQTCszTll5WTFUSlpZMkk9Vkd2I1dRWUYxVy1FYDV1fDAqUVVrNF4xa249ZkI9 SUtrZWtUKllUUDMKelpwQjB2XihvOFNwVVg3QSh0dFFkZUNJIUs7LSZCTCE8XlB7NmpjMWdDSn5z TSVoOE16MnNSVDBaeVJoO0deakFZCnp6Nk84YHImd0tJcmc4SGZPanFsOE5tZmkqKHZWajFsSCFU VmhrK0xEVGRRbWZIVUR+b0ZTQig1aUxIMHR0ZWRDUwp6JSEpZ3l4MVpTajIxR3ZiY205WXxGRnd4 R1ItQ19YTGNKbjtaJStmV15EYldRY2Bxamp3cVQ0ND45Ml9hI3tDU0cKejF1bVJvVyVWLUV5JDVN RXJ6b1hNc354KXVRRE5wZzQ8dX1vdEB+Nkc0KF5jVlpgYXtkSHQ8I3RmNE1TOWBJOXB5CnooVVhM RnJvemAqQm1BcWNAWTwyQEBfZiRBP14pZUZCRy17K1hJJTN+JHZQNkAkY05gUFlaTCtSVHJDNVAw KTVvZgp6M1Ulbzt0NT9vWm4lVHxOJXF8QHI2c149JiN4Rj42MTNGYDt2VG9haTZ+O3ZZUnt7UXpY UD5WTmtnZU5LZlVuZHwKek4hUFM8UDBwRTYmbT8pMElSRENOYHJyTShJUD1QcnlrZj1uSHI8UHkj d1dtNXV9MVk8TjV2fTBqU2A0RjZGOGZoCnowYEQ1WkY5UDBQeSgqVjR1ekxQRHZmNXhgJnJMTSE2 fWU4NDwrNTc3aE42S0g7b3g/YDl9NEEpTXpsRURxPnpOfQp6dDQmU3EmNmMrSk5vcUgjPig/NGtz PTxrOz4zcmBgSWVZcU95M2IkVihzLTJ2LXJrJWUqezcqU3dxPjlGZHxuX2IKeklZSUQ3Mm0oOWQx OGtLSWxxS0Ipa25MNEFQUTY0WUBNIz5saSZpPjVKcUxhXmZ8YkUwUCZxdHMkKiM8YVQ+RihRCnpu OHE+R290cHphWnt3NVlUOXZ4Q15MMzszJkZQSHBDeWtlMW49cUJWM094QjJ0b2A4cz1JcWpXbUtm YUFNX1MrMwp6LWtaX2hwUnFDR3NPT0dhMFc7KFVWVm9JQXtrRSRTZlA5RzAyPDt5akg1Mjt1UFEx WHklY3Q+TF5FOVhEc257Z3QKenNMWj1vd3R4KG5pUSF8USpIMEVXYUg2MTRCeSptVFlpWWFIdSRj aGduOXtYfWlKNDV9bkBMKV51R3dNZjlNUil7CnohcGFYSDw5eUprU0NHVEVvd19ReVVEKyhLbzdT O2FMQ0NXfi1YOXByLWxlUDViak9uRHhXRkc2d2I7fnV7PTRgVwp6VSpxeXlBS3tMN3t0U0N2UHRS Ty15ekV+c2smUnJwPWpObmBKMjs/T05wTXYqbmJaRS0xTWYtaGlhbi0xUyl5JWIKel9qfnFvdCFt YntVdWw+fCZibGMpbk1PfDZnPWZBKz99Y3glYXJyYkdXVFBZI3BkSVZGWHBmKSNeYmM5XnlPYGxV CnpnOWFBeEdRNmMrLSFjaSM7S0YhaF4zfGAhMVVMbEBrWiYrOG9JQjhLdnZLVE0mWXdNb0R3bkEp PzVGTm5eVTcxTwp6VG4mbkF6KTJRVXkwJWJRdVhuOFpJdGlXSXVkJWhmV05wJTlZa1BndFBgI28x aUkobyRaJSFGSS1fJk5JUkRzdXkKejVkR0RrKCo1Q010YXNONWIyUlZmZE1ZY0haTGo2RCtTZDV5 MnYpRlAtPmBnekpPa3ZsVXlWMipIIUlfNmdAQSgyCnpwKSRGaE19YkxUM1laMzN6JGBGYllxMDA9 MUtqIU1fcHRCYWVXdG1AZ2tWWUxFdzw5VUI4RGdlNW9QQiUpU2JDZQp6czl6aDAqPXpIanowQztl IyFhNXR1Y3drfWV7d0QqTT4oNn5hcWJ4NjxzVDNwZUZER1ZQSnk+cT92OSU1Qj99WnAKejYrQWE7 ZjF2IVhWZko+aWVYRH56SWc8NFM5ZzcrNDl6KEdjYjchM3FRZVZ6VmVYPE1yZ2JASnltfktxNl9x T3t2CnpibmlSWmQ7MEBTT0tZbU9aUXBIZ1VzenpMIVZwPkRvN1dHLV5UfmNhVys8Zk5Tdj49IyFD PylfYnV2SGoldSZRRQp6UFpHY1NCdkVIfFhvakVNMVpaO1NRSVY1a3swMzFHZ1psXkNgdmBaZmV1 NTNfeH1BJGdnNSkhSWFgNW5gRSMpflUKelhWTWFlRFJaPlM3M0wxeSNjajkwZyZYZDhrbEJlRCU4 OStVQ3ZWRH14MVVicSUyZm8xb0lYcVlvc3lwSWxZKDUqCno9RVdeI1gyYjhJUENrITNgNWZaLXYm M1ApUDs9RWJrNVFxcyRfYkZvQnQ7QmgzcVlkajNHbk9ZKnMkc2l6NUZgRQp6OWkyUX5QYEwwYyZv c1h1YVV1KX1EPGxGam0wWnY2WDVXbz51PmFRa1NVN2t1dDtWRnpEQkE1XkJKY2dAcFUqY14Kenhy Ml5tRzh4byVIMlhjJnhtUXFVanZgT0xndCZacXBmYX1ecHFwS0AkIUNvZDA1TClVZFhAa3JwcyFp PWhJT21VCnpzQmVYKUBsRmRzLVkqIXRCV1hieFdEQ1RFWjhsby1FYmg2UCNsNSNNZjVXWHo/ekAj e3hyUkh+OEp3ayhsU0duVAp6aF9hMjk/ZnU2UVR6VTw4PUBqejlOcXd4Rzl8QzxHZmFDVj9EY2FR T0tXaE9mVmdyfUt5QHxeP015VGJPQSU2XmMKeiM/Mk9VdiU4c19TenV+cmshRVdid2FGUkUmMXAp dENUXnZNVGheSGRxNXV7NnNEMjA0LTlVOSRRU0JBdis3O3g9CnpDRkpUdzxpPkwwVX1tKyY9VjFJ bVhFcVV7fDc9WGFSQGs2TzVHdUtKWEZlNjBnaTg2ZDlVM0o8bHpkalhwbytHWQp6JUA/KTt2SyYo dFdnQ0xAQlg8SHoqSTU5SFprV1VIWDJeKiZfcFB8TFRFR3hSRGJyPzdTWmNXeFgoP0FWYjJpRDYK empqTUF3WSUqU2Q4LWdINVEyJFBhZnhUUH1xSHdefV4lajdsPzRlYFBuYGVFdyhFTDleRT8xdGZp ckktMlRPZzlfCno8VFhXUSlOJDNhUVQre2g7RzhqRms5KFpZbCNXV0R0QWI0Nkh+fFEoWmxiPGJi P2pPflV7NHR2aCstVUd7fnVAMgp6Q20oNyNfaXt5emQ+T1JKWj5aJnRzJH5YQklkZjFYMVFnZEwy bVdWeWpWeEcxYDs1ezJvayNgdXQ+OzR1PF8hRU8KejFZbGVlWTFJMElrYCtxWWVuVFpeYClkVWl2 aHBUMV5DQ2V8cXBEe2tkPFcrJDEpeWxKMkRPTyojNXB6eWI0UVJuCnpeMXUmRjh+c3JXeiZLVllU N3pJfmJHYmt1TW0wPjczdEZsZSF2diNQQXp4bHFUV0clQUVjcWl4KUs2czJTMUt8Rwp6YW4zMT5h Plh+QkZeWTsje0owMUpvQWp9Yit9cWQheEhSVlF3JFdJYlo+ZUduOVg4dXgwTEVreiNUWjlXN1N0 TXcKelNSbyFFRnRSOVhgUXM9Nm8zVFM0SlRHVDFeMzlaXmZjRl5ELWFaMkthU0psR0FePmNYezI5 ZHRxa015TCFaRTR7CnpISSV7cE5mM1poMzhxbk43ajJlcyMhIUNWPU9ffH1hbG1oOUJnZ0hnZntU UGZqVkwmWUY7eng2Q1QtMTZzc01+Swp6Nk5+fEc5S2Y1SWZVVk5MdngpWXpnPDY1IUxAM21sTkBD Ry1qTEJSNEw8Xyh1TDRmVHFxMXg7QHd5NT02NXJFQjcKbCRaOEJyWjEqYGYkeVdnSXt7dl5Kc3hU ODdLZVllPTAwMm92UERITGtWMWxUfWlBKD9oCgpsaXRlcmFsIDAKSGNtVj9kMDAwMDEKCmRpZmYg LS1naXQgYS9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3RzdF9xd2ViZnJhbWUuY3BwIGIvV2Vi S2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZyYW1lLmNwcAppbmRleCA3MjliOTcxLi43 Y2NjYjU3IDEwMDY0NAotLS0gYS9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3RzdF9xd2ViZnJh bWUuY3BwCisrKyBiL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAK QEAgLTM2LDYgKzM2LDkgQEAKICNpbmNsdWRlIDxxc3NsZXJyb3IuaD4KICNpbmNsdWRlICIuLi91 dGlsLmgiCiAKKyNkZWZpbmUgWFNUUihzKSBTVFIocykKKyNkZWZpbmUgU1RSKHMpICNzCisKIC8v VEVTVEVEX0NMQVNTPQogLy9URVNURURfRklMRVM9CiAKQEAgLTU4NCw2ICs1ODcsNyBAQCBwcml2 YXRlIHNsb3RzOgogICAgIHZvaWQgamF2YVNjcmlwdFdpbmRvd09iamVjdENsZWFyZWRPbkV2YWx1 YXRlKCk7CiAgICAgdm9pZCBzZXRIdG1sKCk7CiAgICAgdm9pZCBzZXRIdG1sV2l0aFJlc291cmNl KCk7CisgICAgdm9pZCBzZXRIdG1sV2l0aEJhc2VVUkwoKTsKICAgICB2b2lkIGlwdjZIb3N0RW5j b2RpbmcoKTsKICAgICB2b2lkIG1ldGFEYXRhKCk7CiAgICAgdm9pZCBwb3B1cEZvY3VzKCk7CkBA IC0yMzU5LDYgKzIzNjMsMjkgQEAgdm9pZCB0c3RfUVdlYkZyYW1lOjpzZXRIdG1sV2l0aFJlc291 cmNlKCkKICAgICBRQ09NUEFSRShwLnN0eWxlUHJvcGVydHkoImNvbG9yIiwgUVdlYkVsZW1lbnQ6 OlJlc3BlY3RDYXNjYWRpbmdTdHlsZXMpLCBRTGF0aW4xU3RyaW5nKCJyZWQiKSk7CiB9CiAKK3Zv aWQgdHN0X1FXZWJGcmFtZTo6c2V0SHRtbFdpdGhCYXNlVVJMKCkKK3sKKyAgICBRU3RyaW5nIGh0 bWwoIjxodG1sPjxib2R5PjxwPmhlbGxvIHdvcmxkPC9wPjxpbWcgc3JjPSdyZXNvdXJjZXMvaW1h Z2UyLnBuZycvPjwvYm9keT48L2h0bWw+Iik7CisKKyAgICBRV2ViUGFnZSBwYWdlOworICAgIFFX ZWJGcmFtZSogZnJhbWUgPSBwYWdlLm1haW5GcmFtZSgpOworCisgICAgLy8gaW4gZmV3IHNlY29u ZHMsIHRoZSBpbWFnZSBzaG91bGQgYmUgY29tcGxldGV5IGxvYWRlZAorICAgIFFTaWduYWxTcHkg c3B5KCZwYWdlLCBTSUdOQUwobG9hZEZpbmlzaGVkKGJvb2wpKSk7CisKKyAgICBRU3RyaW5nIHJl c291cmNlRGlyID0gWFNUUihSRVNPVVJDRVNfUEFUSCk7CisgICAgZnJhbWUtPnNldEh0bWwoaHRt bCwgUVVybDo6ZnJvbUxvY2FsRmlsZShyZXNvdXJjZURpcikpOworICAgIFFUZXN0OjpxV2FpdCgy MDApOworICAgIFFDT01QQVJFKHNweS5jb3VudCgpLCAxKTsKKworICAgIFFDT01QQVJFKGZyYW1l LT5ldmFsdWF0ZUphdmFTY3JpcHQoImRvY3VtZW50LmltYWdlcy5sZW5ndGgiKS50b0ludCgpLCAx KTsKKyAgICBRQ09NUEFSRShmcmFtZS0+ZXZhbHVhdGVKYXZhU2NyaXB0KCJkb2N1bWVudC5pbWFn ZXNbMF0ud2lkdGgiKS50b0ludCgpLCAxMjgpOworICAgIFFDT01QQVJFKGZyYW1lLT5ldmFsdWF0 ZUphdmFTY3JpcHQoImRvY3VtZW50LmltYWdlc1swXS5oZWlnaHQiKS50b0ludCgpLCAxMjgpOwor CisgICAgLy8gbm8gaGlzdG9yeSBpdGVtIGhhcyB0byBiZSBhZGRlZC4KKyAgICBRQ09NUEFSRSht X3ZpZXctPnBhZ2UoKS0+aGlzdG9yeSgpLT5jb3VudCgpLCAwKTsKK30KKwogY2xhc3MgVGVzdE5l dHdvcmtNYW5hZ2VyIDogcHVibGljIFFOZXR3b3JrQWNjZXNzTWFuYWdlcgogewogcHVibGljOgot LSAKMS42LjAuNAoK 40045 2009-09-23 21:42:46 -0700 2009-09-24 06:12:16 -0700 patch 0.3.1 - make setHtml and setContent to not change history 0001-2009-09-24-Antonio-Gomes-antonio.gomes-openbossa.patch text/plain 25874 tonikitoo RnJvbSA2MDhkMTM3MTY0NDk2OTFjYTgzNTdmMDRiM2U2MTcxMWI5MDQxOTAxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IFR1ZSwgMjIgU2VwIDIwMDkgMDk6MzM6NDYgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTI0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2Rz IHRvIG5vdCBjaGFuZ2UKICAgICAgICBzZXNzaW9uIGFuZCBnbG9iYWwgaGlzdG9yeSBhdCBhbGwu CgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0SHRt bCk6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0Q29udGVudCk6CiAgICAgICAgKiB0ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybzoKICAgICAgICAqIHRlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZy YW1lLmNwcDoKLS0tCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgICAgICAgICAgICAgICAg ICAgIHwgICAxMyArKysrKysrLS0tLQogV2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTYgKysrKysrKysrKysrKysKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybyAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcmVzb3VyY2VzL2ltYWdlMi5wbmcgfCAgQmluIDAgLT4gMTQ3NDMgYnl0ZXMKIFdlYktp dC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgICAgfCAgIDI3ICsrKysrKysr KysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA1MiBpbnNlcnRpb25zKCspLCA1IGRl bGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUv cmVzb3VyY2VzL2ltYWdlMi5wbmcKCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggZmU4MTNiOC4uN2E5Njgy YSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9x dC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNzA1LDEyICs3MDUsMTQgQEAgdm9pZCBRV2ViRnJhbWU6 OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0ICZyZXEsCiAKICAgVGhlIFxhIGh0bWwgaXMgbG9h ZGVkIGltbWVkaWF0ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5bmNocm9ub3Vz bHkuCiAKKyAgXG5vdGUgQW55IGNhbGwgdG8gc2V0SHRtbCB3aWxsIG5vdCBjaGFuZ2UgbmVpdGhl ciBzZXNzaW9uIG5vciBnbG9iYWwgaGlzdG9yeS4KKwogICBXaGVuIHVzaW5nIHRoaXMgbWV0aG9k IFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwgcmVzb3VyY2VzIHN1Y2ggYXMgSmF2YVNjcmlw dCBwcm9ncmFtcyBvciBzdHlsZQogICBzaGVldHMgYXJlIGVuY29kZWQgaW4gVVRGLTggdW5sZXNz IG90aGVyd2lzZSBzcGVjaWZpZWQuIEZvciBleGFtcGxlLCB0aGUgZW5jb2Rpbmcgb2YgYW4gZXh0 ZXJuYWwKICAgc2NyaXB0IGNhbiBiZSBzcGVjaWZpZWQgdGhyb3VnaCB0aGUgY2hhcnNldCBhdHRy aWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRhZy4gSXQgaXMgYWxzbyBwb3NzaWJsZQogICBmb3Ig dGhlIGVuY29kaW5nIHRvIGJlIHNwZWNpZmllZCBieSB3ZWIgc2VydmVyLgogCi0gIFxzYSB0b0h0 bWwoKQorICBcc2EgdG9IdG1sKCksIHNldENvbnRlbnQoKQogKi8KIHZvaWQgUVdlYkZyYW1lOjpz ZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwpCiB7CkBAIC03 MTgsNyArNzIwLDcgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRt bCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAgICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVx dWVzdChrdXJsKTsKICAgICBjb25zdCBRQnl0ZUFycmF5IHV0ZjggPSBodG1sLnRvVXRmOCgpOwog ICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcj4gZGF0YSA9IFdlYkNvcmU6OlNo YXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0ZjguY29uc3REYXRhKCksIHV0ZjgubGVuZ3RoKCkpOwotICAg IFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGRhdGEsIFdlYkNvcmU6OlN0 cmluZygidGV4dC9odG1sIiksIFdlYkNvcmU6OlN0cmluZygidXRmLTgiKSwga3VybCk7CisgICAg V2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vic3RpdHV0ZURhdGEoZGF0YSwgV2ViQ29yZTo6U3Ry aW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6U3RyaW5nKCJ1dGYtOCIpLCBLVVJMKCkpOwogICAg IGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2Up OwogfQogCkBAIC03MzEsNyArNzMzLDkgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3Qg UVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKIAogICBUaGUgXGEgZGF0YSBpcyBs b2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25v dXNseS4KIAotICBcc2EgdG9IdG1sKCkKKyAgXG5vdGUgQW55IGNhbGwgdG8gc2V0SHRtbCB3aWxs IG5vdCBjaGFuZ2UgbmVpdGhlciBzZXNzaW9uIG5vciBnbG9iYWwgaGlzdG9yeS4KKworICBcc2Eg dG9IdG1sKCksIHNldEh0bWwoKQogKi8KIHZvaWQgUVdlYkZyYW1lOjpzZXRDb250ZW50KGNvbnN0 IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0IFFTdHJpbmcgJm1pbWVUeXBlLCBjb25zdCBRVXJsICZi YXNlVXJsKQogewpAQCAtNzQxLDExICs3NDUsMTAgQEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRl bnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29uc3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMK ICAgICBRU3RyaW5nIGFjdHVhbE1pbWVUeXBlID0gbWltZVR5cGU7CiAgICAgaWYgKGFjdHVhbE1p bWVUeXBlLmlzRW1wdHkoKSkKICAgICAgICAgYWN0dWFsTWltZVR5cGUgPSBRTGF0aW4xU3RyaW5n KCJ0ZXh0L2h0bWwiKTsKLSAgICBXZWJDb3JlOjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0 YShidWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmlu ZygpLCBrdXJsKTsKKyAgICBXZWJDb3JlOjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShi dWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygp LCBLVVJMKCkpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0 dXRlRGF0YSwgZmFsc2UpOwogfQogCi0KIC8qIQogICBSZXR1cm5zIHRoZSBwYXJlbnQgZnJhbWUg b2YgdGhpcyBmcmFtZSwgb3IgMCBpZiB0aGUgZnJhbWUgaXMgdGhlIHdlYiBwYWdlcwogICBtYWlu IGZyYW1lLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFu Z2VMb2cKaW5kZXggMzYwM2U4Ni4uZDA5NzYyZSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5n ZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDkt MjQgIEFudG9uaW8gR29tZXMgICA8YW50b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAorICAgICAgICBbUXRdIFtBUEldIE1ha2Ug aXQgcG9zc2libGUgdG8gaGF2ZSAnaW52aXNpYmxlJyBsb2FkcworCisgICAgICAgIE1ha2UgUVdl YkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2RzIHRvIG5vdCBjaGFuZ2UKKyAg ICAgICAgc2Vzc2lvbiBhbmQgZ2xvYmFsIGhpc3RvcnkgYXQgYWxsLgorCisgICAgICAgICogQXBp L3F3ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAgICAgICAo UVdlYkZyYW1lOjpzZXRDb250ZW50KToKKyAgICAgICAgKiB0ZXN0cy9xd2ViZnJhbWUvcXdlYmZy YW1lLnBybzoKKyAgICAgICAgKiB0ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHA6CisK IDIwMDktMDktMjMgIEotUCBOdXJtaSAgPGpwbnVybWlAZ21haWwuY29tPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IFNpbW9uIEhhdXNtYW5uLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L3Rlc3RzL3F3 ZWJmcmFtZS9xd2ViZnJhbWUucHJvIGIvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJh bWUucHJvCmluZGV4IDgxMDM3YzMuLjcwNzhkNjcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC90ZXN0 cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBybworKysgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1l L3F3ZWJmcmFtZS5wcm8KQEAgLTUsNSArNSw2IEBAIFNPVVJDRVMgICs9IHRzdF9xd2ViZnJhbWUu Y3BwCiBSRVNPVVJDRVMgKz0gcXdlYmZyYW1lLnFyYwogUVQgKz0gdGVzdGxpYiBuZXR3b3JrCiBR TUFLRV9SUEFUSERJUiA9ICQkT1VUUFVUX0RJUi9saWIgJCRRTUFLRV9SUEFUSERJUgorREVGSU5F UyArPSBSRVNPVVJDRVNfUEFUSD0kJFBXRC9yZXNvdXJjZXMKIAogc3ltYmlhbjpUQVJHRVQuVUlE MyA9IDB4QTAwMEU1M0QKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcmVz b3VyY2VzL2ltYWdlMi5wbmcgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3Jlc291cmNlcy9p bWFnZTIucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhkNzAzNjQwYzE0ODMyNTY4OTI3M2VmMDMxZDM2Y2VkMDIz NjlmZjkKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDE0NzQzCnpjbVY7SUljVWEtUCk8aDszS3xM azAwMGUxTkpMVHEwMDRqaDAwNGpwMV5AczYhIy1pbDAwMDA0WEYqTHQwMDd3bwp6TGVAe0EwMDAw OWE3YkJtMDAwWFUwMDBYVTBSV251N3l0a09CeT5lc2JXPzk7YmEhRUxXZEtvaVg9N190WD5EYTcK ekhaQzxURig0PlNWUGhhcVF5XkY9MDgxbkkkXlpaVzJYc2tJTUYtUmc5U2leO1pWSyU/MDAyMWxO a2w8WmMtcmx+CnpkNXxSNmVjJD1YJSh8PCl0RlAobDhPIzhLMFdjV2MxV0FBKGk2dHE1Nmk9QFIr MlhhN05oXz55P0FxTHJjUDtJSQp6OD9teXJsNUJePlJjdHVDR31uaERpd2E5emlQe3loN1FHWT9m ZEBwfnorZUUoZ31JTnU+Jm9sQnd8fjVzblhqXzQKenM9SEA7Sys7QT5XTW8hI1Jkclc+ZjR9ZVZl ODE9TCM/Un5WPDUqYDBhRG0/aHskY1doTT9aY3l8S3p0bU03PkBACnpERzVqdkYtbjwoMiZxRHAz WHYqNkR4WCt9bCRCNU9OV2tqWjNYYW85aTRZfVlsI0h5aTAzfWdNcHJrLTRnO0YzPwp6X0smXnNe Wko3Uz4lamsqeXg/YSlhU3ktI2clNEEleFo0SzVlazVlPVdDZ2Q8JVltTj16LWFKPVA7VXNwant5 QU4KejBSRCZNMSVMQ0Nfd1hDUF5IRHNIWkdtNF5LOXZfXik9IW5MOGhva3JLbEh9V2p8bHVuS1ls bT0lUmw/enchem4kCnpBSjlHTFVLOTlJekZgN2hQd0BYS0BKbHhCfEpyWVZoLSVmX0xFN0trPUcp LU07dGNgI2s9Z3Y7e0dFXkJtN0U9PAp6e3EySnZ6cmdebktrZmdtUHU8SX18OEYwO2RZZ1p5Z3pI QCE/SSsrenYza1A/Y3BYQiRvWCE4aCkhRj0pMTIpY2kKekl8X2FqenJnX2lNVEJ+enp6MGRgNGVX az1MJXIoPnpDYU5+eWRlT3VNfjNmZUxjTUIyYClBQTdNZX5DUXpWdihoCnotdz1RdypIRXV8QnhM MWVfNDtWTzRgMk45alUyc0ZgLXYzKlhBOTVnVSF6N2B2eFZva1lWJntUYHFGOzkxR0tPQgp6Oz1r WHwoV00kNUtOKEo3OSNwM1FmYyljZTAteUA2TT9FZVFpdDhIY1JnWitNb3ZzdmtgJlNwfCtxQjx7 O0VUVnoKenBDZTBrJTc4LXJTVGV2VXp9PHB0eDhRZU02I3hhdTUkRjgxdk9aSTdYN2hqYnBYWTc5 Km05YDFhPU48WDszcDI+Cnptd3IhY2VnZU13Rl5VM2d1PH00QmszRG5rUzxpZDktYG5wV01lKSpI Myt1NWtYWnphenowMyh1XjF1REJIdSVNJQp6bzxPTitPUFlUQFk8fVlLZWV3NlQmRyModWU7ZnFC KT5iek14KCM/S2NQPXtlMCVMIV4kX1lUQy1EMVFNPWchSkgKekNqIyhtMUtAd3NxPDF9TStuUWZf Rj1wKmw8QHp+JXw5KEc1bVp9NHF1Z3cyZmBaM1hWOH10T3wxbmpjOEU/ZHUrCnozdG5lYGhCTHdo cn4rK3xFdWJVb2FnX1U9dS1eTlJmeko9bnt5K09iRzVCb0slPClSVj5iYzdHMy0kaEJLUyE0dQp6 bHU8K0FFOUMzeTFRdDFOY2BZdkcwSXlnXyoqY2VWMCUwPmxBX3pxY1U7fVQxcDglZDVWWmt8aCY7 SkRje1NeRjkKeit7M1RgX0pebnBnbkFiRUQhZEFaRldNMXJ8NFlCT3BDZWFsY3NQYU56biYoKiQh VUJNPSpkd3ZLcXUhfiFFPT9JCnpGeXV7eG5ffmYkdi1oP0QqcXxwelV8c3Z4QEJlJD8/YCUleyFo anprUmIrdTU0OC19QEZUPHohO192Un49dSY7aQp6PUcpaD1NPUgxb2NzRURvNiR7KiZiKmBJcCYz Y150Jks4RElMUXJHXiMoXkpMZkN1S0I5M2stWXp7aXNoYGBGTGoKeiNqcE87cFQ9YC1ae0drJFdF e1VKV2RJRitra1M2eD5xUHMwTSpIM2YrRTJqMC1WQmlVPGNvbD49MEkqKE40PzsyCnpBezVvQjhS cThxRnVTbXEpfi1FRiVxPiElVTckS1dPUyMjaSlNKDtXWVBjdX1kfU9iU1hzOzhtRkI3ZF5BeX5S ZAp6fEg9aEFTSSk3JWJkaTx6OHB7XiZlUkotYT5razdUJXh3TiR7TXY3UWgrM149WmwqSGUkNXkt X3JOQW8te1E4a18Kek01d25qeCYxSHdLfD1lUmdSaShnSiVPWD4tVWREb2RlYl5qbjRAVlF2a05U VmJjbkArY1FBTUo5WmNQTjdaZGV7Cno0KmlzKzwwX31+c3IjPStDazZUKSNFRjthb1AzRm1RJTZ9 b2VUPDglbSRfJkpWQlhnSk0/WX5Gend3MCtRITJadQp6V2ZgUD4rd1N7WF5PYTlZPk5jK0hSbjwk OUpYQGp0MWJuVzgwT1Mpandpajx9ZTRfeUhOcHFlYHR7MypRQDZkaGgKenp4JUUxeThDVFJQZmIl JklSdmoyZUVVdHc+KCpDXlV3bmVLcWZmRSkhKjgtYmolY1JmfE1yTFJKTz5INWpzeiNVCnohOHp+ PWpsPF9fb0J1KyVxbiRqMXBgUE40VSVydGVtI2RWPUlEQzJWKzJLXk00WmZ9UTNHaGA1XnJpKVAl WVoldwp6dj9eOFI0JlRwaForYmc3Sm4kWjdye15kdWhRWXBPQGJrfWAkSXsjekNFPn5pX0A2KGtw UCF3YjttSVJeIVRqelgKemY+WHF0QW5kcDRiXzd5cj5jPXRSb3w4Q3k4dk5SZTVvQFBCeW1Baklm fUlDSCZGeWF3e0Z2VTNfeUdCMlA3JlFGCnpfSSR6dS05RHgjVEl7e3xBcjN3QzJ6JjI7MmgpWXhu Z2hSNHhxLT5yRWl8aClRTHBUd1ItVUtnUDI7JldUKF52cgp6Rl9HKk4jcTBSZEdKZHAjQTY9IyFU JVo/VHBjaD13NnQwUkg7cm4wRHUwUTtkNTNxMGRWSGBaKkVqcEUwNTE2ZkEKekFtUyg/JmxBZk5U KTdrPzt9R1FyKUNlZyo4PyR6e2dqZXFGSm91KXRXOVJtXzFBZjVqSDhYJjFAQUtnMlpUeklzCnpA QFdKNUVIR1ZmdmdnZVliTFc1Y0FAPCQlMDg7fiRvSUJTX3lPXmpRcSo9WCokPVdUeyVEWnNnOGxG P1piO34lRQp6YVU5Mkp2T3VhQkRNTih4aURpI2leb1Q/Y0EkdnJrTGx8JCszb2FQcFNqRz1tXzF9 e2tmTTVQdT15JnpzZShkWGkKeiFYeGl7SHgzPnlIQyFxfkgkJjF6YUU2SEk1JlFga3pJS1l2eGU5 SyVxcm4lXmopIXtKMHpPPEBMcjQrJHdzJjgqCnpZPCF+V0d2PTVEWDc3ODVgYC1PZzRtfEt2JTt4 S0UkentFQTFHNXdOR3VNMHpHdEspYmRzQkZCNzF5YnZrVnQ5NQp6RUV5c2EmcyM9Rmx+diFzIUY0 Sz5UbkVwc0E9TU9CNihlUURNRC0+aiomfmlTXnVqQjJgKUJDfW0teWwxdDEwKyoKei1GKmt8ZGlP aFZzcEMtX2N8JTs5eEUhWDtWYWAwaE8jOXJjYyRGOXg/XzViWTNIN3cqKlJCY3RZWX43dl8kQUJV CnpDKmZNKyp0S2xYZiUhYyphQClIOyFXfCN9Nm5rQ0llM2t7aTxDS303Y3E8RjdjZTYwe0Z0eVN5 VCZFMDxnSGthPAp6aFF6WG1scCVeKFlyRTcxN29qNWt5byEtM0dDfm9oTFhscH0mXihURGE0QzVX bnc3bSZ5Y3dGK2daI2gwX2V+UTcKenpeNlhfTmdDeHs8TGAqJlJLI0pBP3hrPHlkSi1pQlFwUUk2 Y2MhWUJmJHYtc19gcnFJNHVObW1gPTtnMUNtS0l6CnohbTBUT2V+UHohQERtKDdiUHA0R3lJJTRw bjRmJCpgKHs3TiFzTnF2VVJ+Y0xCQEEkfTBhaE9nXz0lPGBVQEpybAp6ekVVdyMjKUlJaURFJG0h Z2hqfGlGYSsmJiQ7bnFWXz5EJGBQeUYxY0h3OWx3b29JQnQ2OGBFLV8tbl8oUTVObVQKeko1JHZ3 cTx2Y213aGxoPCl2SU5JSm9yQCR7S1ZGJDhWfkg2cDV4JHFBTFVKdGV2YlcpR3c5VG4reT05ZzR7 JWBxCnpRIUdycWxhZT1xNUl2KlMhVF8yQlUmY3Nzbnk+V0R3IXMmdnJkIX1rIXdmUD4peUM9TFNj Wks0JnJZVWFeIUBMRAp6S2V5Z2A+c1lOPChpOWhzWUlNIyNqdWMmUkpxQH1nMWxMfkd0TCsmMHp7 JTF6aEkqeCg9MSpBOy1XOyRDKm1kOSMKel9rOCUlLTFVejRHaVM1Q3FnKkVJd3toJDR6c3V0RUJo PEBfTTUwWUJ4PD5PZyRtdytvZXFeNHtYP34qQnFya1VsCnplKms9PW93MUEmYW09NTZgQmVJYUts fEN3aj9zQVlaNSRJKkl9VEZ4KnRxYjcpXyhLMzcjNiRNUDtaI191TndTNgp6MXheOW8obHZsekUm ellwKCl0QnA7b2IqJSVnXzcqaGl8YCEyXjsqZit2M0xnenNiJD5wSnV2dzUzJWVLaXVJSzgKemxA ZXBZQUVmZHZZUUNsRWdQTHolRkpxMjh5VHRQNDBEdURyNClESkJ5e3x5eXR0S0h5ZmdeRSowPUc8 bTxyd3xkCno3amF5V1FSZXN8I1NWdmgqQTcwPURfeGBKKkRjeWxHPUctP2ZBQHAkPCF2QVRkbUxL YXIoTmQre0hmWEA0KTZVWAp6N0YmLXtfOWxxTGhOMVhHdEEoWkVBYFIpMyV4cmZpNmp4OUNpNzYz PTEqQ31oKkkjJSF7bkRUSyMzemBYb0UrNDgKekMpMFF3clMoeHI5SG5xd20oSUVHNlpQOVRaYUgp T2ErKXVkUEI8bXQzakA5PSgpezF3JnluVCZQU1NufnsmcEU0CnpBTG15c1orfE1NYEhLJktmT21a QV5XNF4mcF5UTXkrfHpuTGh4ZEcqeHlpU3NAd3UoX3cmcUoyWFpBblF7NTxVcwp6ZmdnPGxLT0Ff IXJ1fkVnQjd6e34qcFc1Pmx9ZCRBZWUjbzk+eTVeMDs4aEFkUVgtfCFyQElPZUo9UllAaipDUmYK ek5LP05Rc3E+ZURGRzB2YkBNOGd5TlMxM1FaQ3Z7fnZiP2k0LXYpb0gze2FIWXVOOG5sbXVVWE9B SylGSWBHKnt1CnpuQUJtVzB6OXxNJkdWbigqNEA5ek1DfH52Pn1xO1VOfmlfMktMcXs9aGM1K242 VjEySE51djRFM2VFb1Z1P3kqIQp6ZSl5ZGFiS2lhVTRRaFIyPnhEdzlUPm9nZk90NXlHPyRWMVdy TmgrJHIhTlAta2ZjVz5BZFp6akQ9aF43QF49cSMKemJoKjZhSHMxeitELTRrRC1wTTxDbFU5dHMz c2B2WXl9YSNIcFhXOWt7RjIrP19RaWp8IVFHI3U7PGJvSEZYIU01CnpJKCQtXlB8ZzU4MiE1RDd6 aUZIdzhJVDhVejZMKSsyPWZeLUNLZUgye3J4bFA3eXRSNnxCU0JsSkRIPkIyIShKSQp6aj4+aDd5 QW1rVElzNGJkeyQoN2Vsc2JTP01rcHh9R05iKGpfJkMqbU1IcXVuaVpFOUV0S1l3b3FlflU1amNY OGkKenthNl9SeE8odGBlclglalojI1ZyRTVrUkZnbklXciRYaD1DX2Mrdj0kcUcwbnVnUlR6e3Qq V2tLOHhkJjVZb0BTCnokWXo/SzNXWkprQGl5WjhPbUdTe0tNNXlRJSpqe1J4cDJrQFV9MGZfa0FD emNNZz9APW9ScEAxRSkjKX1JRjEyOAp6RDNDckk9Tj9CejU9d1U1Rk50TmJ5Xm4+fmBYfmt8QjY/ d29mQWkpMnl0R18zO0w4ISh6aCZeaEl1ODhKMWkmZkMKekAhS2lobVgrayRiPkk7OXtMQytLY3lT LUsxYm9rfWJMWlkpPTlZIWUwZ21wRiRwTjNsYE5RNlJKbUJ5Wis1QUd5Cno5fjAqJW5yfG5SVmlf VFg7N2s4Sml+UyNjXmtkQTsmRVk3Q1JNSSZBcm9geEk+VVdkP3JFc0xlQGpPS1RFYlU4QQp6cWVA eHdNQG9AdXhJXz8zMnQkUjhXNVJeO1c4SWUlKThKbyFjXjV+UXRDVWprV3I2blpqT0hnekZRcU0z YDBUUTcKekJqQCRjUHRTNGkhPUw3XitwWC1MPWhpdkFfPDBXUWByOEtsSTBmSktfKjI+Kyg5Km9h N2gxbWBxeG1EXntKaUd0CnoqOSgmZ2pFUTJ3RTY7YipTcE1mZl5CRTAoVDMwcjktVH12dng+fVRF eyMqZkdtNW1GfSZ8ZzE7dDBiV2FrWVBYPQp6M0h8eGZMck0/blJCPno1bHFZN1cpVFZLJnlQLWFa U0RSJkp0O3x5STJeMSQkY3EjQilOQVNsOXokbVoza3hUUT0KejBgdT5FbHNDUU97bWk4YTk7ZHwz XlBsRkgtRzlmRld5MXBTI2R6PkBEY2o7dUZCJCtfcytnNlBIdHFFO09JTytgCnpWdVRWUDE8Zmdr Iy16Kml0Y095PHE8JitoNmc9X0dyU3daYkBXNU1uO0ROVW9Db2soS2JzVSpCM2thb3dQbkgqbQp6 aCUydT9NeUs3USp7RCExUlokYXJzWnwhQ3Y0PWB5SCpTM3F3PzJwS0hWOU9paCQ9em82WmlwcyYh O2wyKm1xTiUKek9HaEt+N21GT2RvdVBmWipSaXlUPEw0R1FlaUo2KUduM0BAQU4/SHJaTVNHfj5i PX4kYHhoeURRPm8xX2pgSXReCnpGTipVPUlEQkNndmJ3eSVgRSQhJHpQUWZYWUxfU3NpQTc4dFlh YWtaPEJsdEZVNVEoUWRJTVQ+QzF3e35DUjs5Rgp6YEx+KCh8TElTRGw5SzBUemBLJChZbEZnWmdv KmlkSDtfYWp7ZEgjYy1OKCVTSCZMQ3EwYTJNbHgpczgoTExeRT0KelFBOEJfZ2tjdnleYTtXcVZY IzV5Mmx6b2k1UWd9MWlHMnFle1AxVy17YntlXl9Qe142UnEjZyUwNkRMfW9VN3w2CnpyUU8qKkgq KHR0S2Z5dH10Ni12ZkdsJXpsVVdhPDNTN2BJY2RpJEhpYEVlOSo+QyE1JW94SUc2UzErLSQrfTRR fQp6TTMhKHQ3Rl40TD4oQD81P1YhYml2blJDaypKYCErKnZFY0craiN7SkxUa09tKDdqbiE7MyVa ZjA2OCtJUkY+P3oKel5FMVJrKGVKaHFLXndwQzZaIyMoQVJyUFVWSF4rejVtNml2YGEwKGpnY3wl SDREa2J4YFExKzEpcX57Kz08QSlNCnplWEhkPy1paVImcDEqRFRYVyNWXj96cWpRY21YUWpHPFYr YyVnanhfT34/NmAtN2xubEdMeHtDSVJFJnViRyZAeQp6OTRDJWxMTUV4ejByMkhXej15OURRWWxg M3BfX2lgNH1Je2IqPzszK1c5TzM8ZmhxJnU9cGo7UUNvdTU9UHtpUkgKemVaTlApKTJIOXszOFJv T2owaS1KJjx9fkBOSSZRNmF9Yjd2UUFGU2VTYFklayV4PFc9UX1wQnQ0KEBpcXxMV0MlCnpVbkJ0 ZXAxeXBnRkE0cG8/fFg+KktKK1F9V15lU15LbD48KXR3JUtOcnY7bFcjUTZpPnsmMVhzO29LNVdl RDd0Pgp6b21uUTE8MUszWUNQRTw8Tihxaj8qdmtxKGVfSzAkRDNoQFAxSEp9OU5yfmdjQVBwT3Ne I0hMNT45KUp7YGhFSnsKeksweT57NFVjQEhBUnZsRXE5NylXcUVzLSNDP2U8dmdtRkwrXmEtTj8k QWo2SzUqeTEmenJNT0l2fk1xWUR7VnZqCnopNlNsSGxSZllIQzxpPk5uUGFra0QraExjbnpBPmt3 U1A7UlVxdCZeb1prPW57UDZwKUBaOGZVaUp+fFFpTUZsbgp6SW45QHZVTjQ7czJtXmd7NDxBMG5k KjF6VW4pPW5pZ0t8dU5uMmN+N3JPa3E/S25aWEp1Xi1XQ2NqJEtlXiFrMUwKenUjZXlHNWs/X1Zv TT9RY3tlVTxvaX5fPFNDaURac0ZkJlRqZ3JRRnFnQGxwQXtHI0MwdmVjMiYpQGM4djBlc3V3Cno9 TEtOMVlHMzAwUHY4R0FjUnB5ZmFkfmM/VFgrOW1XfTVkQiNwfWElS2t4OUZ3NStyb3k/a05rOy16 SzJ7Ziswagp6YUJqdVlYaT1jeSt0R1pMVVE0QW9APkhoJXBaZlVFUUxVNzxsVntTdE4qZDIhPmdP Q01Tcyl5UDVKWFcjcmBASTcKej9iN3dUYm8qVWB6TllqcjQyWihtMDNRKVhGPH1yQWA1fEV4NUpk ckQrIz9EPyFaMDk/Qk8+V0N6dVNjdUcycFdtCnpARHM0TjRMK2JzQk57I09ecTwpT3NmaVlRLX1O RSgqX31MZGxXJHtqYFZuSCQ5Wm1iVHgxWkRleXRqWWkjQ2c4Pwp6XzIrNH55VGhPazBKfmpBJl5k ZjFCfmMoKVRhRSMhUjt6c2M8M0ZveXpoaGB1Tik1ZDJ7M1N+WlY/aCp6dl55Ty0Kem90XzUyKTVa XmN7Sl90JkpgTT9ebT8jV1FCb0dxQzh2SDJxM0heWHJYcl9weG1eaFp+KzcobHdNb2ZTK3A3dX1W CnpHezMpSEBCdnhjaFc5QEt3QztVfkx3NUpCPVFUTW58NEhpUSNnWDs9TENyN2Q8ZExFQTJ8fHRe SklgUElgQlF7Wgp6SUJlc3VOJUt8dXlpfChVanNAd0xlKHo3Y2leSTFjKU80Un15dipXJUJzZWk5 ciVNPEh3MG10ai01JX0hMkU5Jj8KelVmOyo+YEM5djxnIVdfTkM/WDYzO3k1cUA7MWg9LVE1MChN ITtufStoJlY8X0w4KD98cyE/TDgqR0oqISFNfHcwCnpLVkNybCQ+RERtZTQ3RUI1IXllSHtIYXUj ZCp+N04rUChSXkNmfnVyKUh7aHBkLUZLSSRsPGR4ZTgtUVM8MWZEVQp6djtraWhmV0l9KEZPe0tH YzVwcXtfO1Y4OVNIeilxeyFvZSZGWnQ8UntvTG4xdHFWVmleSm50PjhoQkh5bEBnUjcKejJtKDYm NGpZe2ZJdlpXT3kpTkJPa0d9N2xrUy13Zlc4P1RtIzZvTClFVktaYFZNcl9eO3dWSktrPE00aCpj N0g+CnpsO2JpejZMN0tEQldCJE97fVMrTCNAcH1qMW8tKWBWNWd3TipMRENXNTh1eWkkKVhLcUdK Z0FKS1Q2NCl1LWRyQgp6JE43bmFtdF5wZyRFUXdSOzZGWH4zfUZ9IVlyNHU2azgqPEdJRXNiNlJp PFcyT3R1YEZReDRTemx1OG1RMSg2VzYKeio4K09JbjY+NElTRHg/RD51NHUkLUBkKjReZHMtZD83 Uzs4SjE+Kjhad0NIR2V+dEVmaGZjUmNyYHg2NUhxTV8oCno9IThNMjlZOC1NbUh+MD42OXBrY0xg MEUzJDhuNGhyV3pALWxyfmJaeWRLYlZSKX1mYTs5bXk1MkFzfj5gbVZLcgp6d1FudE0tNGdoREFI VyZXQFI5Y1N6dj1EVlYwWlMrUGR2Y0Y8aWlOaitnNjtQeEF7djt0TmY/T3AxfWAtNSNTZm8KenpU K3dtLVBMME0lezMteFR3RzcyUlh7QygzWldGOVJGdGJPRSRPailBTj12WiVBQ0t1QDRsRG0pKVkj YG5idT48CnpiOzheP00tWVNvOH5xSjcqNGxMWTlYam5Vb2xjKV91U2RgS0AleChvcWFhRShLOF56 N0NeRGRqMnd7TWElez50TQp6LXRfd2NyX1FjKD9CcDhmRkxlPU9WQk9qPkBEMVJNVyFwUEQwbHYp dWNAdDJ7RitnKStGWiYqTjUzfX5hdyRPU3YKem8+dzIjQFRBbVE1YSQ8cGAkNlJNP1oxNDFabnIt TXs2UTFvZFhmVyZDT0xmMUIrViUmRSZGRVI+bTB2T3gpVm84CnprdXBkVzJ+SGpqKTUxQGAteylV XkBoa2p5fEx2bjdMSmhwcF97MFNDZ0FTY2BNPn5EKEY2fmEyUE9uUzErbyMqPAp6WTM9VV5ncHA0 ZWBOVURFMGdvYnRqOGZwV3d1PnxoeF9EYFdteWZTLT5nKSFjWmQ4PHpUTEp6R0lCKDRePXYheC0K el9KaSQkcDlzTFhAR2xqQkwtKD0ySEsqSVZrYCs0KFF4Nnd0ejhEJGo3eG5OeF5UWHF1ZEZ7JDNu eEJDYEhDXklPCnpaPVlrJnpOIShaSm92KFp1aUxSPyFXdlFfZ3k0eTlXU1BJfD4xbkZmRHU0V3lG VnBGQ2BJVWU0TnItJDZ6QUkzSwp6X314RDN0X0ZUJXFmTldwclBKK2NANHdybC19VWk+OXpvZEdu amgoYHA5V2tZOz9SSnUqRDxXR19jP2lIbH4rJSEKemFQZX10RmIhTC01PVF8P2ppPGtxOClESjdK cE0hdyFtOXk0JmozISZ7QFdwN15SQm5EJVU7SlpKOD9nPyh5c0F3CnplIWlLKlRDcFFsJTtpaFZK byZgMkV6fHo0SnlqbGgmak83SkdKJXEmQG5aenwoZzt2Ml8yKWhJaG5hMk55P1p5bAp6Py1QYjBV O2V7PyROS3NQenhKIVkwOHhNPCF0ZUVIX3U4fkt5MHFJfStUOU5BUEVXYEZ5Jms9ODQ/b2F9cEN9 SHIKenQoT2AyJUZ1aSlWJFBtajxMSFNpb0kwfmM1UXJocnN8fnBNUFN8QDNFTUZwY19NM0Y5c1Yy IVpsbCVZK1RsMXNzCnpmXlEyektLKXlebXdDLUR1ejFoZ0dVcEZxdUs1O1JyI3g3KSZCeXVxKzx2 Wn18SWAhNTNCemNGISM0PjI/aSpANgp6e1FsalAlRjVGR3hQYlBCWChxe05VcjFmbElkZFo1O3Uj KExtJjt7WnRyb3VUPE5INFNleEhCKUBCUi1+U0p3QyEKenxOR3lrenJJM2Vxc3ZDOEwlWkZoKTl1 cGtea3tFJT15cDRGK2c8dVdtbXUoVSFOKWp3eTRnZjg4RENsTmFPfWh0CnpVT2xuRyhuQGJRPD82 dVZPfGJoV218bFFONGF5YlIrbzFtSFEjNSlURFFOaV9NcXpIOGpYbC1PcyNBeyN6c0xsWAp6M2ZB PTNaI3UtSEopRUlobnJFaFlGRX1uejIzd0V3dC17VyE2QmpzbntMKmxTJmpRWll7QzdPRW5eSVgw dzBhZk8Kent4SkFUTmAjWDkhUzhJT1V3bWR9aEIlSDFmJmt6NWJ2Q2N0PHpJZ0IzI19pSkByQj8x TWNVbXk/VCFKeS04TnhnCnpoaTxQIS1gQ243Xm5EJTI4fVIqcCRmPmkteW5PNXVyX1pldSQ4ellW KkJZPlIwT3N+V3IzeiZPZTVESElEd0x8WQp6Yjk8T0gwKzR2N19EbXomLXNkJWMlaSFrKVZCeyM1 Z0xoPWo5dz9acy05cClHbks/TEhrTWsySWhAKmh4JDFWfkAKeihRckpVMUhVb2hAIS0zNVFLPjRj K3NGUHBWISt7KClfWUAtXiNlcTQlIXduSnFjdEAoTVplIXF3WkdIcChDS3RnCnpPN1Z3KF5sI1lj WjE3TTFAcWFebUxweSlualZ8NDhue0khRGV5QC0zX1h6QD4lIXgoRiNmeGhrSiQ5TDZDenNmMAp6 YEBgS2U5XytwbVcqNERhMmlGQyFxPm9aYjNxYVdqTCNZRDBaZVpmZiVqc3habktLMmtXJCZaaDQ4 dHZoWndvKl4KejJ7YlVoPipoT3t2T2xVPnklRW8/cjMpKiE2NmFAYVRvRyZRWkMqV2tLNDw2RVBA TTAkbEtiRGppLXs+R3JUd2dpCnpGdmo2YVhrU1NyNS1CQjVlSmNae1I7JUg8RjE9b2xlIW93eipH c2BxZSFsa0RTTGsqK3tLfktWNFNMLVRxeEJ2OQp6b312OVBweHkyOEB+YW0pYHBQQkZVUlhvUTtk fFlmZ2QxKndzWDB5Z2ohYCQpMS1HT1J1TE5FaHloPGhyaSNKb1oKelRKd3RMOGBfez43NUdKQXBx RjNnS1ErVkx0Iz5oRFhhNlFeeDhnYiNWJWduTm9TJEVAYk1ufEZaVHBBdmAtNUAqCno0TDg9PWNj NS1RWExEfn5EKCZ8Tyg8Pm01MnFFISVmPE9IfkdtcEYzWV5KdDlxNWgodVorKylLKCY9cFFgRzQ+ cAp6ezljPkQ/LTdKT2otUl4zYkkrZ1Epc3ZVJGJjM1B5UmpQKktfaD4rSUViel9VYzNrajBAR0w8 bm03cndJen18eTIKejhrMD0rKzleWko1cHhjJjh2SHkxPGoxc0BmeSg/SVg2PFFRam1sb0M8I3t1 bEFzN0ZUU2dWJlQ/VXBKYzdMbTY3CnpOKF5XREVhJVRGIStqNlZTWnVPNj9Tbzc7VW5zNWxLfk0x YlY/TGAoKzdgUjZPU3hSOCt3Rz4+S2tuenJyQHpOPAp6eyRgaUlefDM9ZHtwPjN8Xn5AUjBVc140 RVpMPFk4OWZxbWQlKm4kd0hhMGZ7LUVwKjhhOXFzPmokQGQ+Z1IqNz0Kenc+OGdYdVJYQV9tdHVJ QHhoKCtPMClKRTx6IXJlPSFkX2JUQ3I7RkUjZEdVZk5MUXIheGkmNm9fNDsrJVU2dzl5CnpqTWFS RjxpPi1PRyR4JF9aLTQ4dz97QGBIZUprTEZDJkVsU0UweHNvPi1ZT3h4PUFtK0AqS2JaVFEzc0Yh e0otMAp6NDNqZXMmNlotfTJCQDIqZ3BRbGh5YHctbThQekhAPXM0aCo4UnlBayZqWThWe2VhZGtD TjcqRG50Tk97JlIhUEcKeiFENzElUCQmZXVfR0dRek8ySV8rQ09vJV9rVXtZaD9jQSF9ZUN6Z3de RERaISF2PypldShSKCNFektzNWl9UkQkCno3bEhydWNMSjYjM3JAV3BYVT4/aHtYcjBIWWhBbnp6 VD8yOzNeYi0zRCVFNj5zSUQyNiR7UEhFeyg2VWpLfihBNQp6UXBafHU7MjAyR1YtXzVrUylqcjIq eFVVMHFea3gkPypycn5aaEpzIVpqcmhAMGl8QnFnRykoQTBHa1lGQ3xiMCEKenkze1RWXzNZJSYp VT9Pc3RVRVRuSkZOSyVYLXEpUzdkLVA8MFpXJHp0Q3N+cVUhfnkzYVpESjdTMlkhKlQhcmEqCnpo eCVqJnRkcV9MJn4+OXkjaURyd3UyTEclV1VwU08xYCV9M1VAR1preyg8WDNZaz9aWSk2Ym8mclRs UndmQzImVgp6Vyo0YTFPV3x0ZWNecyNsSWQmdUJ7TmpiMEE8TjZ7djZgPXhXT2BTUFQzdjBNX0p0 SnFVQ0M0NSl8IylSOylOZCQKej1HZUNqZXpea3M0PntCKXB0cXJeSm9WKSlARG5CUmF2Y14qOFV+ T1dSQXB1bStSI1o7Wk1KdEthOW8oMHJOWnp8CnpEN01eT15IMUlmJFp5byh3UHYmWUtUM0UwSSp4 LT47aDQhQkJiSUIpbWA9T0RYKjApRSVpUkxfYXM+RmsyNDUpeAp6VSgjTzlxKnFHMDxyfndRZ0Z8 bjJuQXhUOHclLUIyWFd4MzIwLXdANm5FO3M5TExBb3M/aXY8Vm1JfHdeK01GflgKekRhJC1lJSV1 QXc8Y0RwSys3XmVhSDMzQm5MUmBSYFhyJkZSWDMxQzBFUkcyV0c9Sj1oOVRfNShVfWQ+JnhfVT05 CnpiMnlIbytGKXp4VUNaVk57bWtZb3NvVDAlRjNXQSpqT0cqXnk1Q3slTDhHbFExNSEwTHhYQyZ9 JDBsTWNVRXtpJAp6b2xwQnFZIytlOUU/czFWVVIqNGFfNSg5Jk5JQjVkRTM5cSpqR1kzMGxuS2JN MyM4Ryt2dlVCaFFgUj9xT3FgI0IKelp5cE8xMCFDM19gdVJ0PGFnezFpcEshKitgNyh8M1pTYkde bWJVcjJeLUpIfm5PJDRFUFllNnR0P3pTYiVfJjQ9CnpEI0VkMFdTTUVVUzMpT3kpTD5ZclIwZmFa VzxzRzFfKT13YGcqNUtGMG8lb3gwRmp4M1dGJGVRaz93PSE2d3JRPQp6WH1CZl4kYjtfeVBOa345 VEN6cWA9SG1XQStSdn1tT0ZWZFVPO1I0I0tvK3VxUWY2SmY4WE07aWduSGl8KWNqLXkKelBxXy1X LTBnQXZoMmlqUmF0MHB5cHVeMn5JIUZtb1ZFUjlGQyNLZTlIRiZ0TExEQnxVVyFea2lyY2E3bztJ NlZZCnpyRG5PSkNKbXtEQ1RUdU80eXBaKnQ/WSl6UDcxKkFLcjlQPDF3XnV8U0ZJRkk8QkVyRHpP Pyo9cStidmxeZFVoMgp6c3F7ZEZ0aU5EJW9TJiF0ZF87OGZvZXEwJUVeK3BSV2NgWF9hdSgobjlq MTR+amZXZ2NXa25SflJCVkR8Oz9idnIKenFtfFp0KlJ3UmYyejxpO058QEIwJTc5UDd3YHsmanom RHlOPzNITVcqWDVeRmZjSnBsaENaXl56KU9BKyNUJDVUCno2PnRqVXswI2ctO0hBPWFhWG5+WmVE YGh+Q25IcngkTjdvUEFFYlRLJnElSU9QXmxeby0wbVE2YkM2MFExQHppKgp6Pl5hNTN5UDtaM2dq XmU3JDJlb2pOXm5obUNZX3NyWX10TldMRn1wSGk0VU5KYnJ4MmVxMyVMUWRZUyFDZDwzTisKejNK ZG94Kyk+ZVI4TkV9YzBfYiVaPXVpdXlXbiRTTXJ1cVcjbFMzJXxUKHpxMj5iTVh2Mm40O1pzVW9K RDl9akB2CnpANVZnJk8kJlQkZHxUI2hzbmxXMXpGXzhwSjMhRF45RGlRbmBgfiM+N2lLKW8yQ2lx V09JcV9+bkF2emBlYTFqcwp6WDZ+a3hnV3dCRzIhdD5XcEtiR0g8YGRYUjFVKkMlQ0l4QlhZWjhF PjRAP1VXP0cwbDQ0Z0tmfXZGSHU8YEJ+bjYKems+KTJYUUooPFU5bi1nT3A2aG45JTNxcT5NXz4y NUB1MURPdl8wOXNWK2oxQGRMVjRtKzgqQGIqZldhMDlfKjxQCnpRPmJ4MHJLQCU+MWlsNWQhfDxM Mz09VVVtM1pXZ3pSMHU1SyhgeV8yb0cwYzB5XlZvPTMqfUNNSzhnV35jRnEqKgp6JVM1KD5ffGF0 fCgqO308PU1RTVQoUj9ZaERQOHBtd3xLZGhrfH1yX1lqTDUmN3haTUklfSlTVmhLSDM9QzYhem8K ejtUVWplP0JxfVlDdGxFXztUPDxRKUlkSkoteDs+fiVKTEJzZHY1b1hOKXRgdyE1Xl5zUl9OekFT cSh0fW8lTnd3Cnp6ckUrLWp0RH5EMVBxbE5TRmFHKngyempuJmBaRkU7ezE0VUJ1anBUaTwjSXBJ cHIzM3tARyh0dFN2PSErUipeYAp6a3VVaGBafV4oXzJmVGZpMD92VF9DbGRtUDtUPFFlMVArZVlA RHRDMi1fO3BEeUxSc1ktRjdhZ1pgKnZNIUxEYigKempXWSVpUil9WGBDJSE7M2gkSTJ1YitUeHB5 XmApJTgwV3k+YVQ4RnFxb3g0anJIbDBLVm8pITxwISkhbElOeFojCnpOWE4xbnV5ZE45KWJuUnxk JjlKa3dSOCl+IyMrcVVRan4oUGxwcVFlQjNhZ0xUWG0mfFpOM0RydGhuVktoaTEhfgp6PGdVfnAz Rk00OygxI04qc0MxdXo8VGFmUUVmfnFJbSR7O0I2NCNmPyF7Q2U5OUVsTGJnRGhhRGVtJCFeNDZ3 MDgKenpvN1pVLXEoMT9PbkB3Q0omSitvJF58LWhGe21HMkIjaFFBQ29ka2pSenRPV0opOXxGaFVx eU0qSGVYPmp9Wml2Cno7YEU3LVNTMGd4NzFhc0ZuOyRPRytRbEhmPWZQTHRtS0JISjsmOCpRYUt+ RjZZS19jQ05PKD47bktOZ3pnV3JifQp6JnExJH5DMiFXM0FkVXlVe0RIWE1GaElGN1VoYEFDWiE8 dHIye1oqRCpHa1E7VVp6dmY+UnJfUXYxMn5LMFFmKzMKejxzOXBGRi1TPkNGVDd8Ukt7MSY2JjF0 P3BzOE5gKlpuPihNK2clIykwa1ZEZjVfXyNVZT0xX19Oe29gYSVCT14rCnoodURpbztuQTlOaE1k MHllOCpHVkBxb2tKOSh9VkxsV15BcXgpQyRrM2AhTjFSVURPTDA8SENkNHtNaCNUUiRTTQp6X2d0 TkxrfFZTfDBZOGxaa30jMDBKPEthKmc1V3I/YzhQVlg1d3U3TSlKYCZoQz1oXmY9XmB1cnRfZXB9 O3NgRGcKem5NazE2PUVyRnBTSzd7SHRzMzVRVj56WSRib3p6YGUpOVkpJnhXUzZNfntYOE1YZTVa S2pibnNZaVloWWR1NiEkCnpaNFBzYj4zfFFVUCY2anRATFRuSUxBI0tlPEAoaEN4RmBzRWFQbWRD Xz9tVlMoPlQyVmQ/bGUkSCt2MGoxJDt+VQp6WlRmZTtPYkVnTnY5YHBAbjRiUn5WKm08LUFZRjts VVNzKmhPTFhrNSohKnlYU2FiJEAwbWZeN0NMbHRfJXJDbEIKej4kY3wwMHF+WGFzeEZfYCVeYjtH VU0yS2V6eG84K2AlYUlreGxIckRHVGlZMSU8T2l1STkleDhOdVYqSXhjJHcjCnpCaUUrI2ZweypM I09aZm88LStGUkUyUnJiVGg7dkp6Kkd4OHQxJmNiNkZZeTVQSCFYSyVgX2Eqe2t4KytmVjlCMwp6 N2F7fkZrRmE0b2Z9dlEpa0NxVEorQz1sPzBuSlp9SVEwb3crK1B9P2VPK0xaRGZvSU9rSyl6bUF+ c2VlTzZafFoKenBodnReWUtuV18/bEx2Mi1Tb3E2aDF1UFg5eyp5NHVSejNsT2x5NC00IXpsQXt1 MGYlYk1SXn5CYlMxXzNIWChvCnphUjlmVmAyKUAkUyRsWT9WempAYz5IcCNoK1BUR15rdEdCPjc3 RSV2S3o+dUBXYVd1fT5TZE4wYURYSWp7fHJMPAp6KilabWBKODAxNkNzbjx+cF81N3ZVJTJ0TUdG flo5YHdXMXVQPXZuWCRQKkYkby19RChXJE9CaFlFNWhYbzhSTHcKengwbk16Tnl4LTExeSlNITMq MzRpUkJENT9LTEVibUlgflMkI0I+SnFycl9Kb3BSeEJ8U3MkZ2M0Zyh6ciZZeGc4Cnp4N0klQFNv WEUhUEdEPjtJdFlAKmheTFFuYWJxPmgycjhmLVVMcTNSYmYkMEsrdDJGeFc9b2NJcWJEOEtQMGhs ZAp6OCVxTj1LTldedG9XRjhLXjZkOXdmfVR0I2M8UU8hbDQ9N2NycXZNbUxhSEl+Njk4JlcjVnZS MV9VJUg9UzZjX2EKelFyRkprUnk5OU9gSTNRT0h0UFowbDVQXzFiJS15Vz1BeU9pSklGLT9KTCZ7 ZFZFKz5hPW1ZKUwlVXBjJXVVV0l4CnpEMWxnfjdoS0dDLTVSMCFuKVV9QiFOZTVZYzMrODdTcTsm Q1FKbFlXUVMjS2NXN2J5YExNWTJ8US1kfT8qXkVJQAp6Mik7REd0Mk49fnlZKSgodEQqZyopb1k/ UD9FSC1hS2tmS1lTc1FvKXpFez9kOVM9XnV6Kj43YjZAWSQkMkB0dHYKeiY+ZTlDUlJJR2VUY34l QktFOylSUWxTWTQ2TmtedmB3d2U9YVhyNzxQI2tgOXNTeTA0SURjYkJAJEAkKD1UQXhFCnoqbnBW Pi1AZWZVO0w4bUJCc1E8cztwViV2NGN7KktOcitqbFpWJnZWaXMqV3BeMzdVNkVkKFk0YzxsJkZX KFkodAp6dypvbDlOQTB1fHNCJXRWWHhYMTAmXmA3N1hWI2FBPntOT2B5bz9fJVRNWiMqWF8oUGB4 aylgQUNBcn4lJEYzV2sKekAhKHI9ZWkkZkB7Nk8qSTQ8eEhzYV5Ban4lVWBKWlZpMF8zd1A5Nmkr WG8tP2A/ZDxjdl85VylqTG9tOyYjMlRnCnpDJFFIaEl7UHdidE8rMV9LVlYxbTBBOCplQ3xNS1c8 eVEjeitQTCQzKm5pO21ZJjVKPzYzMX5WZHM5UVNGTFVlcwp6aW9qUD1wPEdGOC1yPnB4S15RUEwh PFhqWWYkaiFlSmAwXlNnXlYyMig0amB0elJiWG5CVXJ0eC0rJHFSPylLZGQKel97cHszR2l+NSU2 WXhkJHpkTWU4UHB0YCFEZVhXdVQyUDxSWjFCPCNTVSZQeW8mPkktJEhTfXZaTm1zUTZZUGl5CnpE Q0tmdWBDJGIxRz5YbzEte2FpN3w3JipKNWtXN3lMWnZpSyQqcmZmS00xfV4wbmMqI0dSXlF3c2kt eS1jZllOfgp6bGl2JnB7OT9eZHMobVNxRGlEJDRAKUB7JVN+cnJgQy1tfkhUMnJzSCh7KkBsOG9+ Zk4+cEkyVFM8e0lnNXBVMW8KemxldWRsYmU+PnAmZyQkYjBOPlZwKlVoTkVUOEJ5XzNuTl8qano3 JmcxR3FpJkZVVW0hSjV+PFAzcVU+K05LOE5uCnpYdXRYI3VSaXlFNCUpKmFsbkNqRW11WGhfNHJz cEp6P3N6WlpPeFpScSVmTkBwbEhwKVRAUUxaX3F+YFhFWU4mcQp6KSVGWHJjZkYzVCpqK2hxNj17 OyEkbFNvTWFpUU45IUI0SlowanJtRWtEPVkobUd9SVVXKWphVjBJay1jK1NLUUEKelJoeHY5JiNg dnFENmQpPy0/UWpIOXw1cV9QR0NNNmwhUENOMEJsNDclVE45Iz1nRjFUZ0o9fiRURjtodms3KGRi CnpfVEowRCZvWD5jRGR6UyUtMklTQ3hqTl96RDhfQFk4MX58WU1mKEc3U1hUQEY3eSpoU1NYK1k3 OXxrfTV7MWVCbwp6cTd6Wm9yZT47WS1HcVExeXp+UHUjMzlTVGg5di1qI1FeeXY1SWdNeUkzcmRJ cn5iZ3xHVmNEeypnTDtTKSVGRHgKekxhIU5za3ElIVRkfVZlfTZpSDEkRHJ5c289Pj48P0Q+P31A UDxPWSVteERFVm1DeDt1MU4mO2dBTjNqNWJMRERNCnplOzVRbXE1ZzZPWVF7YFcmVDlLI3BWWWE4 dm9FdnBnRm9sVklPR2deRnd9fiV8REJ1fXhHb0dwS3xASEMza0JRMgp6TXNJYGotflclQ3dSXz9m NVhOblNYaWJCITJLKUF0bEl7VFE4YE9sQS1qJjkmbX10VE0/e2IqaT4tQDtVUHJsPGcKekBST3pD dURlT2hVKTduJmBoLTVKT2BWSyNKJFVoUCZpTmhBOHxgb0JMY3BrP0Eldll+MEdrUXlyQVlhcTV0 V3JvCnokYn1uTlQpZElgSyRvSjVhb2pRdnUzMHUtdG9leTQ3eXdAOypCVjV9KWVBUGZsNktuUz09 QjkzVX04b1dkNGlzSAp6XyhwPDFXcHg5fGY/Ql8pOWxpUmIqODBnPT9LOUxUdjtaN2BtZW5WfCN1 Rm11WT1RUENmKUhIfkFIWFhCLXg7eDkKekZkWk5qTjRTMlVzciVvfXFVJmFUSE52ZHJjYnQtMGAo YEZ8WnZ3dGo4VGVBbFIweVBtJCFVa3l5czZIJDRHYEJFCnp7UTg5VT9DVllLeFJvbHBIejEkUmI7 ZzBPRWJ5el4tWiFVVmEhdzBDVkBsaDl1WX4mY0E4flp+OTUwJkM/K1VPQQp6dFhxKmxjczstJCNR P1Q+Qz5rQTgxfWF6MSkzNE42eGFCVEFLUGMmfDVLMVNpVCZIQmJhQWBKWiRYZDVZWD9+Sz0KelB0 JntSeHBEPCY3S3xYNjlLWmwqWUxtanc3UXdHS158LWNYT017bXJjfkZCd3UmTCUteCZDcmgmajQo O3dBTjE8CnoraDNjfHRubFI1eCR4e2FfJTM9TEBSYjdYNTNaTj9rMjMrekNRaExUbHZsNmQ/WjFf VT0+O2x3emtyU2VibGZ4MAp6X2IwfF96RGpyVnUpKXQoKGtNejVuQkUyUkh8UGNtb3BAMjBXZHF2 PUtXVzY2bjE8UWlJPEBQMSNmNj11PU9GMG8Kel9jbU1PIUIzY0BUOEh8U3E1VX5Te2dZWktFfWYk RHl8NDAyenIjdU5IMUs3a3tUcmBgX0t5PlFhZ2wqKlNmSkcxCnpBb2hEcXpVZzZoV0EpcmlXJWom UDRvPWQ3Qk0wbUdkQ2dDJmM/SUMtKTRQci0hcCFlZ3dDMTJPcF5HfHwrVGlGbAp6dVZUKCtHa2VF cVczOGQ+ZHV0OV9eRXhicCV9Y3NUP3wtPkU4dkpCUWMmVGlfcFZXVkElQSk+U0w7d0M7ZjVnalkK elUqO0wze1l5cHdZJHdweHtfQzw+WUA3KWc9TU4tOUNCMktNPkViZWYrcjZ7flMtPk9+OVZjQjV0 eTBhRz0/I31zCnpUQUhkaDF3V3RPYnpMMXNPLXlVO1lSeUF5bXU4OXQ7SGxZK2RLMiV2VHNEaDE8 RV4pR05zK2FONC19cFh6Xn5MYQp6cWZBVV47NVU8JFp3LUYlPWJVfSF8S29BPTRqQDtJMElYVHM/ X1pESHw1Z1JTJF5FZStLfWdOUXJMKUFYOFJxeGcKek9lNFM0UHpzVChyWj4pO3ZAfjVCTio8PHRB PUpQVXN8QF9YMVcmJU9HWVVYcTE2PEl6enR3dWFvbTQ4TXtqJWxwCno4PUY1bHJ5YW9ocjJnSGpQ cU9sWnxBKVZoZHx0RF9VJHFpSWNKQCF+Ym0oX0E0M0d+RzJMdkpQNkU5IUhUUmd6cgp6XmdOWSgk RjI0T3RjOD1wV0NYVmpLSTZmVTMhZEt1e1FRYT81ZjNsbUNgI3tjMjdhPzttfWt4dWQ/dkw/eE85 cm4KemNtSVV2UnhmZVhxVzs5fEFDPmVgV0JmRGNkST48YHo9I24tO2NsJGJUVSgtYik5dVZRcnpr bzNyTiZCU1ZeTlpqCno0TGV0X3VTYkdrUHxxJn1mMTg+PXU1WjZrPSorUyZ5UT89JUB6I2ZGZV99 ZWJgfFVNPz98Zy0kPVUoQWkzO1pJbAp6S1EzdGRheitSTipDRyghN1FyOUs0ciNjIWUxWjFIRHZl dzJWenlHeGhEIz5YRz9JMk1ySlI5Nk8lbGZDKTI+Q0cKekpmayN4eVBDZ1UrOCtTbG4mWG8/bS1R XnNsV1A4cWlUNHsyYG8hUClWfiFucmlZR15DZXAyXyhfeD9LdD9DV2VuCnpGfUVaUC1XQ1BMKzNO WXlZMVRKWlkyST1WR3YjV1FZRjFXLUVgNXV8MCpRVWs0XjFrbj1mQj1JS2tla1QqWVRQMwp6WnBC MHZeKG84U3BVWDdBKHR0UWRlQ0khSzstJkJMITxeUHs2amMxZ0NKfnNNJWg4TXoyc1JUMFp5Umg7 R15qQVkKeno2TzhgciZ3S0lyZzhIZk9qcWw4Tm1maSoodlZqMWxIIVRWaGsrTERUZFFtZkhVRH5v RlNCKDVpTEgwdHRlZENTCnolISlneXgxWlNqMjFHdmJjbTlZfEZGd3hHUi1DX1hMY0puO1olK2ZX XkRiV1FjYHFqandxVDQ0PjkyX2Eje0NTRwp6MXVtUm9XJVYtRXkkNU1FcnpvWE1zfngpdVFETnBn NDx1fW90QH42RzQoXmNWWmBhe2RIdDwjdGY0TVM5YEk5cHkKeihVWExGcm96YCpCbUFxY0BZPDJA QF9mJEE/XillRkJHLXsrWEklM34kdlA2QCRjTmBQWVpMK1JUckM1UDApNW9mCnozVSVvO3Q1P29a biVUfE4lcXxAcjZzXj0mI3hGPjYxM0ZgO3ZUb2FpNn47dllSe3tRelhQPlZOa2dlTktmVW5kfAp6 TiFQUzxQMHBFNiZtPykwSVJEQ05gcnJNKElQPVByeWtmPW5IcjxQeSN3V201dX0xWTxONXZ9MGpT YDRGNkY4ZmgKejBgRDVaRjlQMFB5KCpWNHV6TFBEdmY1eGAmckxNITZ9ZTg0PCs1NzdoTjZLSDtv eD9gOX00QSlNemxFRHE+ek59Cnp0NCZTcSY2YytKTm9xSCM+KD80a3M9PGs7PjNyYGBJZVlxT3kz YiRWKHMtMnYtcmslZSp7NypTd3E+OUZkfG5fYgp6SVlJRDcybSg5ZDE4a0tJbHFLQilrbkw0QVBR NjRZQE0jPmxpJmk+NUpxTGFeZnxiRTBQJnF0cyQqIzxhVD5GKFEKem44cT5Hb3RwemFae3c1WVQ5 dnhDXkwzOzMmRlBIcEN5a2Uxbj1xQlYzT3hCMnRvYDhzPUlxaldtS2ZhQU1fUyszCnota1pfaHBS cUNHc09PR2EwVzsoVVZWb0lBe2tFJFNmUDlHMDI8O3lqSDUyO3VQUTFYeSVjdD5MXkU5WERzbntn dAp6c0xaPW93dHgobmlRIXxRKkgwRVdhSDYxNEJ5Km1UWWlZYUh1JGNoZ245e1h9aUo0NX1uQEwp XnVHd01mOU1SKXsKeiFwYVhIPDl5SmtTQ0dURW93X1F5VUQrKEtvN1M7YUxDQ1d+LVg5cHItbGVQ NWJqT25EeFdGRzZ3Yjt+dXs9NGBXCnpVKnF5eUFLe0w3e3RTQ3ZQdFJPLXl6RX5zayZScnA9ak5u YEoyOz9PTnBNdipuYlpFLTFNZi1oaWFuLTFTKXklYgp6X2p+cW90IW1ie1V1bD58JmJsYyluTU98 Nmc9ZkErP31jeCVhcnJiR1dUUFkjcGRJVkZYcGYpI15iYzleeU9gbFUKemc5YUF4R1E2YystIWNp IztLRiFoXjN8YCExVUxsQGtaJis4b0lCOEt2dktUTSZZd01vRHduQSk/NUZObl5VNzFPCnpUbiZu QXopMlFVeTAlYlF1WG44Wkl0aVdJdWQlaGZXTnAlOVlrUGd0UGAjbzFpSShvJFolIUZJLV8mTklS RHN1eQp6NWRHRGsoKjVDTXRhc041YjJSVmZkTVljSFpMajZEK1NkNXkydilGUC0+YGd6Sk9rdmxV eVYyKkghSV82Z0BBKDIKenApJEZoTX1iTFQzWVozM3okYEZiWXEwMD0xS2ohTV9wdEJhZVd0bUBn a1ZZTEV3PDlVQjhEZ2U1b1BCJSlTYkNlCnpzOXpoMCo9ekhqejBDO2UjIWE1dHVjd2t9ZXt3RCpN Pig2fmFxYng2PHNUM3BlRkRHVlBKeT5xP3Y5JTVCP31acAp6NitBYTtmMXYhWFZmSj5pZVhEfnpJ Zzw0UzlnNys0OXooR2NiNyEzcVFlVnpWZVg8TXJnYkBKeW1+S3E2X3FPe3YKemJuaVJaZDswQFNP S1ltT1pRcEhnVXN6ekwhVnA+RG83V0ctXlR+Y2FXKzxmTlN2Pj0jIUM/KV9idXZIaiV1JlFFCnpQ WkdjU0J2RUh8WG9qRU0xWlo7U1FJVjVrezAzMUdnWmxeQ2B2YFpmZXU1M194fUEkZ2c1KSFJYWA1 bmBFIyl+VQp6WFZNYWVEUlo+UzczTDF5I2NqOTBnJlhkOGtsQmVEJTg5K1VDdlZEfXgxVWJxJTJm bzFvSVhxWW9zeXBJbFkoNSoKej1FV14jWDJiOElQQ2shM2A1ZlotdiYzUClQOz1FYms1UXFzJF9i Rm9CdDtCaDNxWWRqM0duT1kqcyRzaXo1RmBFCno5aTJRflBgTDBjJm9zWHVhVXUpfUQ8bEZqbTBa djZYNVdvPnU+YVFrU1U3a3V0O1ZGekRCQTVeQkpjZ0BwVSpjXgp6eHIyXm1HOHhvJUgyWGMmeG1R cVVqdmBPTGd0JlpxcGZhfV5wcXBLQCQhQ29kMDVMKVVkWEBrcnBzIWk9aElPbVUKenNCZVgpQGxG ZHMtWSohdEJXWGJ4V0RDVEVaOGxvLUViaDZQI2w1I01mNVdYej96QCN7eHJSSH44SndrKGxTR25U CnpoX2EyOT9mdTZRVHpVPDg9QGp6OU5xd3hHOXxDPEdmYUNWP0RjYVFPS1doT2ZWZ3J9S3lAfF4/ TXlUYk9BJTZeYwp6Iz8yT1V2JThzX1N6dX5yayFFV2J3YUZSRSYxcCl0Q1Redk1UaF5IZHE1dXs2 c0QyMDQtOVU5JFFTQkF2Kzc7eD0KekNGSlR3PGk+TDBVfW0rJj1WMUltWEVxVXt8Nz1YYVJAazZP NUd1S0pYRmU2MGdpODZkOVUzSjxsemRqWHBvK0dZCnolQD8pO3ZLJih0V2dDTEBCWDxIeipJNTlI WmtXVUhYMl4qJl9wUHxMVEVHeFJEYnI/N1NaY1d4WCg/QVZiMmlENgp6ampNQXdZJSpTZDgtZ0g1 UTIkUGFmeFRQfXFId159XiVqN2w/NGVgUG5gZUV3KEVMOV5FPzF0ZmlySS0yVE9nOV8KejxUWFdR KU4kM2FRVCt7aDtHOGpGazkoWllsI1dXRHRBYjQ2SH58UShabGI8YmI/ak9+VXs0dHZoKy1VR3t+ dUAyCnpDbSg3I19pe3l6ZD5PUkpaPlomdHMkflhCSWRmMVgxUWdkTDJtV1Z5alZ4RzFgOzV7Mm9r I2B1dD47NHU8XyFFTwp6MVlsZWVZMUkwSWtgK3FZZW5UWl5gKWRVaXZocFQxXkNDZXxxcER7a2Q8 VyskMSl5bEoyRE9PKiM1cHp5YjRRUm4Kel4xdSZGOH5zcld6JktWWVQ3ekl+Ykdia3VNbTA+NzN0 RmxlIXZ2I1BBenhscVRXRyVBRWNxaXgpSzZzMlMxS3xHCnphbjMxPmE+WH5CRl5ZOyN7SjAxSm9B an1iK31xZCF4SFJWUXckV0liWj5lR245WDh1eDBMRWt6I1RaOVc3U3RNdwp6U1JvIUVGdFI5WGBR cz02bzNUUzRKVEdUMV4zOVpeZmNGXkQtYVoyS2FTSmxHQV4+Y1h7MjlkdHFrTXlMIVpFNHsKekhJ JXtwTmYzWmgzOHFuTjdqMmVzIyEhQ1Y9T198fWFsbWg5QmdnSGdme1RQZmpWTCZZRjt6eDZDVC0x NnNzTX5LCno2Tn58RzlLZjVJZlVWTkx2eClZemc8NjUhTEAzbWxOQENHLWpMQlI0TDxfKHVMNGZU cXExeDtAd3k1PTY1ckVCNwpsJFo4QnJaMSpgZiR5V2dJe3t2XkpzeFQ4N0tlWWU9MDAyb3ZQREhM a1YxbFR9aUEoP2gKCmxpdGVyYWwgMApIY21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL1dlYktpdC9x dC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvdGVzdHMvcXdl YmZyYW1lL3RzdF9xd2ViZnJhbWUuY3BwCmluZGV4IDcyOWI5NzEuLjdjY2NiNTcgMTAwNjQ0Ci0t LSBhL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAKKysrIGIvV2Vi S2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZyYW1lLmNwcApAQCAtMzYsNiArMzYsOSBA QAogI2luY2x1ZGUgPHFzc2xlcnJvci5oPgogI2luY2x1ZGUgIi4uL3V0aWwuaCIKIAorI2RlZmlu ZSBYU1RSKHMpIFNUUihzKQorI2RlZmluZSBTVFIocykgI3MKKwogLy9URVNURURfQ0xBU1M9CiAv L1RFU1RFRF9GSUxFUz0KIApAQCAtNTg0LDYgKzU4Nyw3IEBAIHByaXZhdGUgc2xvdHM6CiAgICAg dm9pZCBqYXZhU2NyaXB0V2luZG93T2JqZWN0Q2xlYXJlZE9uRXZhbHVhdGUoKTsKICAgICB2b2lk IHNldEh0bWwoKTsKICAgICB2b2lkIHNldEh0bWxXaXRoUmVzb3VyY2UoKTsKKyAgICB2b2lkIHNl dEh0bWxXaXRoQmFzZVVSTCgpOwogICAgIHZvaWQgaXB2Nkhvc3RFbmNvZGluZygpOwogICAgIHZv aWQgbWV0YURhdGEoKTsKICAgICB2b2lkIHBvcHVwRm9jdXMoKTsKQEAgLTIzNTksNiArMjM2Mywy OSBAQCB2b2lkIHRzdF9RV2ViRnJhbWU6OnNldEh0bWxXaXRoUmVzb3VyY2UoKQogICAgIFFDT01Q QVJFKHAuc3R5bGVQcm9wZXJ0eSgiY29sb3IiLCBRV2ViRWxlbWVudDo6UmVzcGVjdENhc2NhZGlu Z1N0eWxlcyksIFFMYXRpbjFTdHJpbmcoInJlZCIpKTsKIH0KIAordm9pZCB0c3RfUVdlYkZyYW1l OjpzZXRIdG1sV2l0aEJhc2VVUkwoKQoreworICAgIFFTdHJpbmcgaHRtbCgiPGh0bWw+PGJvZHk+ PHA+aGVsbG8gd29ybGQ8L3A+PGltZyBzcmM9J3Jlc291cmNlcy9pbWFnZTIucG5nJy8+PC9ib2R5 PjwvaHRtbD4iKTsKKworICAgIFFXZWJQYWdlIHBhZ2U7CisgICAgUVdlYkZyYW1lKiBmcmFtZSA9 IHBhZ2UubWFpbkZyYW1lKCk7CisKKyAgICAvLyBpbiBmZXcgc2Vjb25kcywgdGhlIGltYWdlIHNo b3VsZCBiZSBjb21wbGV0ZXkgbG9hZGVkCisgICAgUVNpZ25hbFNweSBzcHkoJnBhZ2UsIFNJR05B TChsb2FkRmluaXNoZWQoYm9vbCkpKTsKKworICAgIFFTdHJpbmcgcmVzb3VyY2VEaXIgPSBYU1RS KFJFU09VUkNFU19QQVRIKTsKKyAgICBmcmFtZS0+c2V0SHRtbChodG1sLCBRVXJsOjpmcm9tTG9j YWxGaWxlKHJlc291cmNlRGlyKSk7CisgICAgUVRlc3Q6OnFXYWl0KDIwMCk7CisgICAgUUNPTVBB UkUoc3B5LmNvdW50KCksIDEpOworCisgICAgUUNPTVBBUkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNj cmlwdCgiZG9jdW1lbnQuaW1hZ2VzLmxlbmd0aCIpLnRvSW50KCksIDEpOworICAgIFFDT01QQVJF KGZyYW1lLT5ldmFsdWF0ZUphdmFTY3JpcHQoImRvY3VtZW50LmltYWdlc1swXS53aWR0aCIpLnRv SW50KCksIDEyOCk7CisgICAgUUNPTVBBUkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9j dW1lbnQuaW1hZ2VzWzBdLmhlaWdodCIpLnRvSW50KCksIDEyOCk7CisKKyAgICAvLyBubyBoaXN0 b3J5IGl0ZW0gaGFzIHRvIGJlIGFkZGVkLgorICAgIFFDT01QQVJFKG1fdmlldy0+cGFnZSgpLT5o aXN0b3J5KCktPmNvdW50KCksIDApOworfQorCiBjbGFzcyBUZXN0TmV0d29ya01hbmFnZXIgOiBw dWJsaWMgUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyCiB7CiBwdWJsaWM6Ci0tIAoxLjYuMC40Cgo= 40063 2009-09-24 06:12:16 -0700 2009-09-25 13:20:07 -0700 patch 0.3.2 - make setHtml and setContent to not change history (2 0001-2009-09-24-Antonio-Gomes-antonio.gomes-openbossa.patch text/plain 25907 tonikitoo RnJvbSAzMDJjMDg2OGQzZjRkMzY4OTA4YjNhNDIxOGVkYzI1Yzc3NmQxMjcxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IFR1ZSwgMjIgU2VwIDIwMDkgMDk6MzM6NDYgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTI0ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2Rz IHRvIG5vdCBjaGFuZ2UKICAgICAgICBzZXNzaW9uIGFuZCBnbG9iYWwgaGlzdG9yeSBhdCBhbGwu CgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0SHRt bCk6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0Q29udGVudCk6CiAgICAgICAgKiB0ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybzoKICAgICAgICAqIHRlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZy YW1lLmNwcDoKLS0tCiBXZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgICAgICAgICAgICAgICAg ICAgIHwgICAxMyArKysrKysrLS0tLQogV2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8ICAgMTYgKysrKysrKysrKysrKysKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybyAgICAgICAgfCAgICAxICsKIFdlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvcmVzb3VyY2VzL2ltYWdlMi5wbmcgfCAgQmluIDAgLT4gMTQ3NDMgYnl0ZXMKIFdlYktp dC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgICAgfCAgIDI3ICsrKysrKysr KysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA1MiBpbnNlcnRpb25zKCspLCA1IGRl bGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUv cmVzb3VyY2VzL2ltYWdlMi5wbmcKCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFt ZS5jcHAgYi9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggZmU4MTNiOC4uNmE3ZmRk MyAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9x dC9BcGkvcXdlYmZyYW1lLmNwcApAQCAtNzA1LDEyICs3MDUsMTQgQEAgdm9pZCBRV2ViRnJhbWU6 OmxvYWQoY29uc3QgUU5ldHdvcmtSZXF1ZXN0ICZyZXEsCiAKICAgVGhlIFxhIGh0bWwgaXMgbG9h ZGVkIGltbWVkaWF0ZWx5OyBleHRlcm5hbCBvYmplY3RzIGFyZSBsb2FkZWQgYXN5bmNocm9ub3Vz bHkuCiAKKyAgXG5vdGUgQW55IGNhbGwgdG8gc2V0SHRtbCB3aWxsIG5vdCBjaGFuZ2UgbmVpdGhl ciBzZXNzaW9uIG5vciBnbG9iYWwgaGlzdG9yeSBmb3IgdGhpcyBmcmFtZS4KKwogICBXaGVuIHVz aW5nIHRoaXMgbWV0aG9kIFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwgcmVzb3VyY2VzIHN1 Y2ggYXMgSmF2YVNjcmlwdCBwcm9ncmFtcyBvciBzdHlsZQogICBzaGVldHMgYXJlIGVuY29kZWQg aW4gVVRGLTggdW5sZXNzIG90aGVyd2lzZSBzcGVjaWZpZWQuIEZvciBleGFtcGxlLCB0aGUgZW5j b2Rpbmcgb2YgYW4gZXh0ZXJuYWwKICAgc2NyaXB0IGNhbiBiZSBzcGVjaWZpZWQgdGhyb3VnaCB0 aGUgY2hhcnNldCBhdHRyaWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRhZy4gSXQgaXMgYWxzbyBw b3NzaWJsZQogICBmb3IgdGhlIGVuY29kaW5nIHRvIGJlIHNwZWNpZmllZCBieSB3ZWIgc2VydmVy LgogCi0gIFxzYSB0b0h0bWwoKQorICBcc2EgdG9IdG1sKCksIHNldENvbnRlbnQoKQogKi8KIHZv aWQgUVdlYkZyYW1lOjpzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJh c2VVcmwpCiB7CkBAIC03MTgsNyArNzIwLDcgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29u c3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAgICBXZWJDb3JlOjpSZXNv dXJjZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsKICAgICBjb25zdCBRQnl0ZUFycmF5IHV0ZjggPSBo dG1sLnRvVXRmOCgpOwogICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcj4gZGF0 YSA9IFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0ZjguY29uc3REYXRhKCksIHV0Zjgu bGVuZ3RoKCkpOwotICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGRh dGEsIFdlYkNvcmU6OlN0cmluZygidGV4dC9odG1sIiksIFdlYkNvcmU6OlN0cmluZygidXRmLTgi KSwga3VybCk7CisgICAgV2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vic3RpdHV0ZURhdGEoZGF0 YSwgV2ViQ29yZTo6U3RyaW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6U3RyaW5nKCJ1dGYtOCIp LCBLVVJMKCkpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0 dXRlRGF0YSwgZmFsc2UpOwogfQogCkBAIC03MzEsNyArNzMzLDkgQEAgdm9pZCBRV2ViRnJhbWU6 OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKIAogICBU aGUgXGEgZGF0YSBpcyBsb2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFsIG9iamVjdHMgYXJlIGxv YWRlZCBhc3luY2hyb25vdXNseS4KIAotICBcc2EgdG9IdG1sKCkKKyAgXG5vdGUgQW55IGNhbGwg dG8gc2V0Q29udGVudCB3aWxsIG5vdCBjaGFuZ2UgbmVpdGhlciBzZXNzaW9uIG5vciBnbG9iYWwg aGlzdG9yeSBmb3IgdGhpcyBmcmFtZS4KKworICBcc2EgdG9IdG1sKCksIHNldEh0bWwoKQogKi8K IHZvaWQgUVdlYkZyYW1lOjpzZXRDb250ZW50KGNvbnN0IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0 IFFTdHJpbmcgJm1pbWVUeXBlLCBjb25zdCBRVXJsICZiYXNlVXJsKQogewpAQCAtNzQxLDExICs3 NDUsMTAgQEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRlbnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0 YSwgY29uc3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMKICAgICBRU3RyaW5nIGFjdHVhbE1pbWVU eXBlID0gbWltZVR5cGU7CiAgICAgaWYgKGFjdHVhbE1pbWVUeXBlLmlzRW1wdHkoKSkKICAgICAg ICAgYWN0dWFsTWltZVR5cGUgPSBRTGF0aW4xU3RyaW5nKCJ0ZXh0L2h0bWwiKTsKLSAgICBXZWJD b3JlOjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShidWZmZXIsIFdlYkNvcmU6OlN0cmlu ZyhhY3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygpLCBrdXJsKTsKKyAgICBXZWJDb3Jl OjpTdWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShidWZmZXIsIFdlYkNvcmU6OlN0cmluZyhh Y3R1YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygpLCBLVVJMKCkpOwogICAgIGQtPmZyYW1l LT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCi0K IC8qIQogICBSZXR1cm5zIHRoZSBwYXJlbnQgZnJhbWUgb2YgdGhpcyBmcmFtZSwgb3IgMCBpZiB0 aGUgZnJhbWUgaXMgdGhlIHdlYiBwYWdlcwogICBtYWluIGZyYW1lLgpkaWZmIC0tZ2l0IGEvV2Vi S2l0L3F0L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggMzYwM2U4Ni4uZDA5 NzYyZSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDktMjQgIEFudG9uaW8gR29tZXMgICA8YW50 b25pby5nb21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yOTI0OAorICAgICAgICBbUXRdIFtBUEldIE1ha2UgaXQgcG9zc2libGUgdG8gaGF2ZSAnaW52 aXNpYmxlJyBsb2FkcworCisgICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0 Q29udGVudCBtZXRob2RzIHRvIG5vdCBjaGFuZ2UKKyAgICAgICAgc2Vzc2lvbiBhbmQgZ2xvYmFs IGhpc3RvcnkgYXQgYWxsLgorCisgICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CisgICAgICAg IChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAgICAgICAoUVdlYkZyYW1lOjpzZXRDb250ZW50KToK KyAgICAgICAgKiB0ZXN0cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBybzoKKyAgICAgICAgKiB0ZXN0 cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHA6CisKIDIwMDktMDktMjMgIEotUCBOdXJtaSAg PGpwbnVybWlAZ21haWwuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNpbW9uIEhhdXNtYW5u LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJhbWUucHJvIGIv V2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJhbWUucHJvCmluZGV4IDgxMDM3YzMuLjcw NzhkNjcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBy bworKysgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3F3ZWJmcmFtZS5wcm8KQEAgLTUsNSAr NSw2IEBAIFNPVVJDRVMgICs9IHRzdF9xd2ViZnJhbWUuY3BwCiBSRVNPVVJDRVMgKz0gcXdlYmZy YW1lLnFyYwogUVQgKz0gdGVzdGxpYiBuZXR3b3JrCiBRTUFLRV9SUEFUSERJUiA9ICQkT1VUUFVU X0RJUi9saWIgJCRRTUFLRV9SUEFUSERJUgorREVGSU5FUyArPSBSRVNPVVJDRVNfUEFUSD0kJFBX RC9yZXNvdXJjZXMKIAogc3ltYmlhbjpUQVJHRVQuVUlEMyA9IDB4QTAwMEU1M0QKZGlmZiAtLWdp dCBhL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcmVzb3VyY2VzL2ltYWdlMi5wbmcgYi9XZWJL aXQvcXQvdGVzdHMvcXdlYmZyYW1lL3Jlc291cmNlcy9pbWFnZTIucG5nCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhk NzAzNjQwYzE0ODMyNTY4OTI3M2VmMDMxZDM2Y2VkMDIzNjlmZjkKR0lUIGJpbmFyeSBwYXRjaAps aXRlcmFsIDE0NzQzCnpjbVY7SUljVWEtUCk8aDszS3xMazAwMGUxTkpMVHEwMDRqaDAwNGpwMV5A czYhIy1pbDAwMDA0WEYqTHQwMDd3bwp6TGVAe0EwMDAwOWE3YkJtMDAwWFUwMDBYVTBSV251N3l0 a09CeT5lc2JXPzk7YmEhRUxXZEtvaVg9N190WD5EYTcKekhaQzxURig0PlNWUGhhcVF5XkY9MDgx bkkkXlpaVzJYc2tJTUYtUmc5U2leO1pWSyU/MDAyMWxOa2w8WmMtcmx+CnpkNXxSNmVjJD1YJSh8 PCl0RlAobDhPIzhLMFdjV2MxV0FBKGk2dHE1Nmk9QFIrMlhhN05oXz55P0FxTHJjUDtJSQp6OD9t eXJsNUJePlJjdHVDR31uaERpd2E5emlQe3loN1FHWT9mZEBwfnorZUUoZ31JTnU+Jm9sQnd8fjVz blhqXzQKenM9SEA7Sys7QT5XTW8hI1Jkclc+ZjR9ZVZlODE9TCM/Un5WPDUqYDBhRG0/aHskY1do TT9aY3l8S3p0bU03PkBACnpERzVqdkYtbjwoMiZxRHAzWHYqNkR4WCt9bCRCNU9OV2tqWjNYYW85 aTRZfVlsI0h5aTAzfWdNcHJrLTRnO0YzPwp6X0smXnNeWko3Uz4lamsqeXg/YSlhU3ktI2clNEEl eFo0SzVlazVlPVdDZ2Q8JVltTj16LWFKPVA7VXNwant5QU4KejBSRCZNMSVMQ0Nfd1hDUF5IRHNI WkdtNF5LOXZfXik9IW5MOGhva3JLbEh9V2p8bHVuS1lsbT0lUmw/enchem4kCnpBSjlHTFVLOTlJ ekZgN2hQd0BYS0BKbHhCfEpyWVZoLSVmX0xFN0trPUcpLU07dGNgI2s9Z3Y7e0dFXkJtN0U9PAp6 e3EySnZ6cmdebktrZmdtUHU8SX18OEYwO2RZZ1p5Z3pIQCE/SSsrenYza1A/Y3BYQiRvWCE4aCkh Rj0pMTIpY2kKekl8X2FqenJnX2lNVEJ+enp6MGRgNGVXaz1MJXIoPnpDYU5+eWRlT3VNfjNmZUxj TUIyYClBQTdNZX5DUXpWdihoCnotdz1RdypIRXV8QnhMMWVfNDtWTzRgMk45alUyc0ZgLXYzKlhB OTVnVSF6N2B2eFZva1lWJntUYHFGOzkxR0tPQgp6Oz1rWHwoV00kNUtOKEo3OSNwM1FmYyljZTAt eUA2TT9FZVFpdDhIY1JnWitNb3ZzdmtgJlNwfCtxQjx7O0VUVnoKenBDZTBrJTc4LXJTVGV2VXp9 PHB0eDhRZU02I3hhdTUkRjgxdk9aSTdYN2hqYnBYWTc5Km05YDFhPU48WDszcDI+Cnptd3IhY2Vn ZU13Rl5VM2d1PH00QmszRG5rUzxpZDktYG5wV01lKSpIMyt1NWtYWnphenowMyh1XjF1REJIdSVN JQp6bzxPTitPUFlUQFk8fVlLZWV3NlQmRyModWU7ZnFCKT5iek14KCM/S2NQPXtlMCVMIV4kX1lU Qy1EMVFNPWchSkgKekNqIyhtMUtAd3NxPDF9TStuUWZfRj1wKmw8QHp+JXw5KEc1bVp9NHF1Z3cy ZmBaM1hWOH10T3wxbmpjOEU/ZHUrCnozdG5lYGhCTHdocn4rK3xFdWJVb2FnX1U9dS1eTlJmeko9 bnt5K09iRzVCb0slPClSVj5iYzdHMy0kaEJLUyE0dQp6bHU8K0FFOUMzeTFRdDFOY2BZdkcwSXln XyoqY2VWMCUwPmxBX3pxY1U7fVQxcDglZDVWWmt8aCY7SkRje1NeRjkKeit7M1RgX0pebnBnbkFi RUQhZEFaRldNMXJ8NFlCT3BDZWFsY3NQYU56biYoKiQhVUJNPSpkd3ZLcXUhfiFFPT9JCnpGeXV7 eG5ffmYkdi1oP0QqcXxwelV8c3Z4QEJlJD8/YCUleyFoanprUmIrdTU0OC19QEZUPHohO192Un49 dSY7aQp6PUcpaD1NPUgxb2NzRURvNiR7KiZiKmBJcCYzY150Jks4RElMUXJHXiMoXkpMZkN1S0I5 M2stWXp7aXNoYGBGTGoKeiNqcE87cFQ9YC1ae0drJFdFe1VKV2RJRitra1M2eD5xUHMwTSpIM2Yr RTJqMC1WQmlVPGNvbD49MEkqKE40PzsyCnpBezVvQjhScThxRnVTbXEpfi1FRiVxPiElVTckS1dP UyMjaSlNKDtXWVBjdX1kfU9iU1hzOzhtRkI3ZF5BeX5SZAp6fEg9aEFTSSk3JWJkaTx6OHB7XiZl UkotYT5razdUJXh3TiR7TXY3UWgrM149WmwqSGUkNXktX3JOQW8te1E4a18Kek01d25qeCYxSHdL fD1lUmdSaShnSiVPWD4tVWREb2RlYl5qbjRAVlF2a05UVmJjbkArY1FBTUo5WmNQTjdaZGV7Cno0 KmlzKzwwX31+c3IjPStDazZUKSNFRjthb1AzRm1RJTZ9b2VUPDglbSRfJkpWQlhnSk0/WX5Gend3 MCtRITJadQp6V2ZgUD4rd1N7WF5PYTlZPk5jK0hSbjwkOUpYQGp0MWJuVzgwT1Mpandpajx9ZTRf eUhOcHFlYHR7MypRQDZkaGgKenp4JUUxeThDVFJQZmIlJklSdmoyZUVVdHc+KCpDXlV3bmVLcWZm RSkhKjgtYmolY1JmfE1yTFJKTz5INWpzeiNVCnohOHp+PWpsPF9fb0J1KyVxbiRqMXBgUE40VSVy dGVtI2RWPUlEQzJWKzJLXk00WmZ9UTNHaGA1XnJpKVAlWVoldwp6dj9eOFI0JlRwaForYmc3Sm4k Wjdye15kdWhRWXBPQGJrfWAkSXsjekNFPn5pX0A2KGtwUCF3YjttSVJeIVRqelgKemY+WHF0QW5k cDRiXzd5cj5jPXRSb3w4Q3k4dk5SZTVvQFBCeW1BaklmfUlDSCZGeWF3e0Z2VTNfeUdCMlA3JlFG CnpfSSR6dS05RHgjVEl7e3xBcjN3QzJ6JjI7MmgpWXhuZ2hSNHhxLT5yRWl8aClRTHBUd1ItVUtn UDI7JldUKF52cgp6Rl9HKk4jcTBSZEdKZHAjQTY9IyFUJVo/VHBjaD13NnQwUkg7cm4wRHUwUTtk NTNxMGRWSGBaKkVqcEUwNTE2ZkEKekFtUyg/JmxBZk5UKTdrPzt9R1FyKUNlZyo4PyR6e2dqZXFG Sm91KXRXOVJtXzFBZjVqSDhYJjFAQUtnMlpUeklzCnpAQFdKNUVIR1ZmdmdnZVliTFc1Y0FAPCQl MDg7fiRvSUJTX3lPXmpRcSo9WCokPVdUeyVEWnNnOGxGP1piO34lRQp6YVU5Mkp2T3VhQkRNTih4 aURpI2leb1Q/Y0EkdnJrTGx8JCszb2FQcFNqRz1tXzF9e2tmTTVQdT15JnpzZShkWGkKeiFYeGl7 SHgzPnlIQyFxfkgkJjF6YUU2SEk1JlFga3pJS1l2eGU5SyVxcm4lXmopIXtKMHpPPEBMcjQrJHdz JjgqCnpZPCF+V0d2PTVEWDc3ODVgYC1PZzRtfEt2JTt4S0UkentFQTFHNXdOR3VNMHpHdEspYmRz QkZCNzF5YnZrVnQ5NQp6RUV5c2EmcyM9Rmx+diFzIUY0Sz5UbkVwc0E9TU9CNihlUURNRC0+aiom fmlTXnVqQjJgKUJDfW0teWwxdDEwKyoKei1GKmt8ZGlPaFZzcEMtX2N8JTs5eEUhWDtWYWAwaE8j OXJjYyRGOXg/XzViWTNIN3cqKlJCY3RZWX43dl8kQUJVCnpDKmZNKyp0S2xYZiUhYyphQClIOyFX fCN9Nm5rQ0llM2t7aTxDS303Y3E8RjdjZTYwe0Z0eVN5VCZFMDxnSGthPAp6aFF6WG1scCVeKFly RTcxN29qNWt5byEtM0dDfm9oTFhscH0mXihURGE0QzVXbnc3bSZ5Y3dGK2daI2gwX2V+UTcKenpe NlhfTmdDeHs8TGAqJlJLI0pBP3hrPHlkSi1pQlFwUUk2Y2MhWUJmJHYtc19gcnFJNHVObW1gPTtn MUNtS0l6CnohbTBUT2V+UHohQERtKDdiUHA0R3lJJTRwbjRmJCpgKHs3TiFzTnF2VVJ+Y0xCQEEk fTBhaE9nXz0lPGBVQEpybAp6ekVVdyMjKUlJaURFJG0hZ2hqfGlGYSsmJiQ7bnFWXz5EJGBQeUYx Y0h3OWx3b29JQnQ2OGBFLV8tbl8oUTVObVQKeko1JHZ3cTx2Y213aGxoPCl2SU5JSm9yQCR7S1ZG JDhWfkg2cDV4JHFBTFVKdGV2YlcpR3c5VG4reT05ZzR7JWBxCnpRIUdycWxhZT1xNUl2KlMhVF8y QlUmY3Nzbnk+V0R3IXMmdnJkIX1rIXdmUD4peUM9TFNjWks0JnJZVWFeIUBMRAp6S2V5Z2A+c1lO PChpOWhzWUlNIyNqdWMmUkpxQH1nMWxMfkd0TCsmMHp7JTF6aEkqeCg9MSpBOy1XOyRDKm1kOSMK el9rOCUlLTFVejRHaVM1Q3FnKkVJd3toJDR6c3V0RUJoPEBfTTUwWUJ4PD5PZyRtdytvZXFeNHtY P34qQnFya1VsCnplKms9PW93MUEmYW09NTZgQmVJYUtsfEN3aj9zQVlaNSRJKkl9VEZ4KnRxYjcp XyhLMzcjNiRNUDtaI191TndTNgp6MXheOW8obHZsekUmellwKCl0QnA7b2IqJSVnXzcqaGl8YCEy XjsqZit2M0xnenNiJD5wSnV2dzUzJWVLaXVJSzgKemxAZXBZQUVmZHZZUUNsRWdQTHolRkpxMjh5 VHRQNDBEdURyNClESkJ5e3x5eXR0S0h5ZmdeRSowPUc8bTxyd3xkCno3amF5V1FSZXN8I1NWdmgq QTcwPURfeGBKKkRjeWxHPUctP2ZBQHAkPCF2QVRkbUxLYXIoTmQre0hmWEA0KTZVWAp6N0YmLXtf OWxxTGhOMVhHdEEoWkVBYFIpMyV4cmZpNmp4OUNpNzYzPTEqQ31oKkkjJSF7bkRUSyMzemBYb0Ur NDgKekMpMFF3clMoeHI5SG5xd20oSUVHNlpQOVRaYUgpT2ErKXVkUEI8bXQzakA5PSgpezF3Jnlu VCZQU1NufnsmcEU0CnpBTG15c1orfE1NYEhLJktmT21aQV5XNF4mcF5UTXkrfHpuTGh4ZEcqeHlp U3NAd3UoX3cmcUoyWFpBblF7NTxVcwp6ZmdnPGxLT0FfIXJ1fkVnQjd6e34qcFc1Pmx9ZCRBZWUj bzk+eTVeMDs4aEFkUVgtfCFyQElPZUo9UllAaipDUmYKek5LP05Rc3E+ZURGRzB2YkBNOGd5TlMx M1FaQ3Z7fnZiP2k0LXYpb0gze2FIWXVOOG5sbXVVWE9BSylGSWBHKnt1CnpuQUJtVzB6OXxNJkdW bigqNEA5ek1DfH52Pn1xO1VOfmlfMktMcXs9aGM1K242VjEySE51djRFM2VFb1Z1P3kqIQp6ZSl5 ZGFiS2lhVTRRaFIyPnhEdzlUPm9nZk90NXlHPyRWMVdyTmgrJHIhTlAta2ZjVz5BZFp6akQ9aF43 QF49cSMKemJoKjZhSHMxeitELTRrRC1wTTxDbFU5dHMzc2B2WXl9YSNIcFhXOWt7RjIrP19RaWp8 IVFHI3U7PGJvSEZYIU01CnpJKCQtXlB8ZzU4MiE1RDd6aUZIdzhJVDhVejZMKSsyPWZeLUNLZUgy e3J4bFA3eXRSNnxCU0JsSkRIPkIyIShKSQp6aj4+aDd5QW1rVElzNGJkeyQoN2Vsc2JTP01rcHh9 R05iKGpfJkMqbU1IcXVuaVpFOUV0S1l3b3FlflU1amNYOGkKenthNl9SeE8odGBlclglalojI1Zy RTVrUkZnbklXciRYaD1DX2Mrdj0kcUcwbnVnUlR6e3QqV2tLOHhkJjVZb0BTCnokWXo/SzNXWkpr QGl5WjhPbUdTe0tNNXlRJSpqe1J4cDJrQFV9MGZfa0FDemNNZz9APW9ScEAxRSkjKX1JRjEyOAp6 RDNDckk9Tj9CejU9d1U1Rk50TmJ5Xm4+fmBYfmt8QjY/d29mQWkpMnl0R18zO0w4ISh6aCZeaEl1 ODhKMWkmZkMKekAhS2lobVgrayRiPkk7OXtMQytLY3lTLUsxYm9rfWJMWlkpPTlZIWUwZ21wRiRw TjNsYE5RNlJKbUJ5Wis1QUd5Cno5fjAqJW5yfG5SVmlfVFg7N2s4Sml+UyNjXmtkQTsmRVk3Q1JN SSZBcm9geEk+VVdkP3JFc0xlQGpPS1RFYlU4QQp6cWVAeHdNQG9AdXhJXz8zMnQkUjhXNVJeO1c4 SWUlKThKbyFjXjV+UXRDVWprV3I2blpqT0hnekZRcU0zYDBUUTcKekJqQCRjUHRTNGkhPUw3Xitw WC1MPWhpdkFfPDBXUWByOEtsSTBmSktfKjI+Kyg5Km9hN2gxbWBxeG1EXntKaUd0CnoqOSgmZ2pF UTJ3RTY7YipTcE1mZl5CRTAoVDMwcjktVH12dng+fVRFeyMqZkdtNW1GfSZ8ZzE7dDBiV2FrWVBY PQp6M0h8eGZMck0/blJCPno1bHFZN1cpVFZLJnlQLWFaU0RSJkp0O3x5STJeMSQkY3EjQilOQVNs OXokbVoza3hUUT0KejBgdT5FbHNDUU97bWk4YTk7ZHwzXlBsRkgtRzlmRld5MXBTI2R6PkBEY2o7 dUZCJCtfcytnNlBIdHFFO09JTytgCnpWdVRWUDE8ZmdrIy16Kml0Y095PHE8JitoNmc9X0dyU3da YkBXNU1uO0ROVW9Db2soS2JzVSpCM2thb3dQbkgqbQp6aCUydT9NeUs3USp7RCExUlokYXJzWnwh Q3Y0PWB5SCpTM3F3PzJwS0hWOU9paCQ9em82WmlwcyYhO2wyKm1xTiUKek9HaEt+N21GT2RvdVBm WipSaXlUPEw0R1FlaUo2KUduM0BAQU4/SHJaTVNHfj5iPX4kYHhoeURRPm8xX2pgSXReCnpGTipV PUlEQkNndmJ3eSVgRSQhJHpQUWZYWUxfU3NpQTc4dFlhYWtaPEJsdEZVNVEoUWRJTVQ+QzF3e35D Ujs5Rgp6YEx+KCh8TElTRGw5SzBUemBLJChZbEZnWmdvKmlkSDtfYWp7ZEgjYy1OKCVTSCZMQ3Ew YTJNbHgpczgoTExeRT0KelFBOEJfZ2tjdnleYTtXcVZYIzV5Mmx6b2k1UWd9MWlHMnFle1AxVy17 YntlXl9Qe142UnEjZyUwNkRMfW9VN3w2CnpyUU8qKkgqKHR0S2Z5dH10Ni12ZkdsJXpsVVdhPDNT N2BJY2RpJEhpYEVlOSo+QyE1JW94SUc2UzErLSQrfTRRfQp6TTMhKHQ3Rl40TD4oQD81P1YhYml2 blJDaypKYCErKnZFY0craiN7SkxUa09tKDdqbiE7MyVaZjA2OCtJUkY+P3oKel5FMVJrKGVKaHFL XndwQzZaIyMoQVJyUFVWSF4rejVtNml2YGEwKGpnY3wlSDREa2J4YFExKzEpcX57Kz08QSlNCnpl WEhkPy1paVImcDEqRFRYVyNWXj96cWpRY21YUWpHPFYrYyVnanhfT34/NmAtN2xubEdMeHtDSVJF JnViRyZAeQp6OTRDJWxMTUV4ejByMkhXej15OURRWWxgM3BfX2lgNH1Je2IqPzszK1c5TzM8Zmhx JnU9cGo7UUNvdTU9UHtpUkgKemVaTlApKTJIOXszOFJvT2owaS1KJjx9fkBOSSZRNmF9Yjd2UUFG U2VTYFklayV4PFc9UX1wQnQ0KEBpcXxMV0MlCnpVbkJ0ZXAxeXBnRkE0cG8/fFg+KktKK1F9V15l U15LbD48KXR3JUtOcnY7bFcjUTZpPnsmMVhzO29LNVdlRDd0Pgp6b21uUTE8MUszWUNQRTw8Tihx aj8qdmtxKGVfSzAkRDNoQFAxSEp9OU5yfmdjQVBwT3NeI0hMNT45KUp7YGhFSnsKeksweT57NFVj QEhBUnZsRXE5NylXcUVzLSNDP2U8dmdtRkwrXmEtTj8kQWo2SzUqeTEmenJNT0l2fk1xWUR7VnZq CnopNlNsSGxSZllIQzxpPk5uUGFra0QraExjbnpBPmt3U1A7UlVxdCZeb1prPW57UDZwKUBaOGZV aUp+fFFpTUZsbgp6SW45QHZVTjQ7czJtXmd7NDxBMG5kKjF6VW4pPW5pZ0t8dU5uMmN+N3JPa3E/ S25aWEp1Xi1XQ2NqJEtlXiFrMUwKenUjZXlHNWs/X1ZvTT9RY3tlVTxvaX5fPFNDaURac0ZkJlRq Z3JRRnFnQGxwQXtHI0MwdmVjMiYpQGM4djBlc3V3Cno9TEtOMVlHMzAwUHY4R0FjUnB5ZmFkfmM/ VFgrOW1XfTVkQiNwfWElS2t4OUZ3NStyb3k/a05rOy16SzJ7Ziswagp6YUJqdVlYaT1jeSt0R1pM VVE0QW9APkhoJXBaZlVFUUxVNzxsVntTdE4qZDIhPmdPQ01Tcyl5UDVKWFcjcmBASTcKej9iN3dU Ym8qVWB6TllqcjQyWihtMDNRKVhGPH1yQWA1fEV4NUpkckQrIz9EPyFaMDk/Qk8+V0N6dVNjdUcy cFdtCnpARHM0TjRMK2JzQk57I09ecTwpT3NmaVlRLX1ORSgqX31MZGxXJHtqYFZuSCQ5Wm1iVHgx WkRleXRqWWkjQ2c4Pwp6XzIrNH55VGhPazBKfmpBJl5kZjFCfmMoKVRhRSMhUjt6c2M8M0ZveXpo aGB1Tik1ZDJ7M1N+WlY/aCp6dl55Ty0Kem90XzUyKTVaXmN7Sl90JkpgTT9ebT8jV1FCb0dxQzh2 SDJxM0heWHJYcl9weG1eaFp+KzcobHdNb2ZTK3A3dX1WCnpHezMpSEBCdnhjaFc5QEt3QztVfkx3 NUpCPVFUTW58NEhpUSNnWDs9TENyN2Q8ZExFQTJ8fHReSklgUElgQlF7Wgp6SUJlc3VOJUt8dXlp fChVanNAd0xlKHo3Y2leSTFjKU80Un15dipXJUJzZWk5ciVNPEh3MG10ai01JX0hMkU5Jj8KelVm Oyo+YEM5djxnIVdfTkM/WDYzO3k1cUA7MWg9LVE1MChNITtufStoJlY8X0w4KD98cyE/TDgqR0oq ISFNfHcwCnpLVkNybCQ+RERtZTQ3RUI1IXllSHtIYXUjZCp+N04rUChSXkNmfnVyKUh7aHBkLUZL SSRsPGR4ZTgtUVM8MWZEVQp6djtraWhmV0l9KEZPe0tHYzVwcXtfO1Y4OVNIeilxeyFvZSZGWnQ8 UntvTG4xdHFWVmleSm50PjhoQkh5bEBnUjcKejJtKDYmNGpZe2ZJdlpXT3kpTkJPa0d9N2xrUy13 Zlc4P1RtIzZvTClFVktaYFZNcl9eO3dWSktrPE00aCpjN0g+CnpsO2JpejZMN0tEQldCJE97fVMr TCNAcH1qMW8tKWBWNWd3TipMRENXNTh1eWkkKVhLcUdKZ0FKS1Q2NCl1LWRyQgp6JE43bmFtdF5w ZyRFUXdSOzZGWH4zfUZ9IVlyNHU2azgqPEdJRXNiNlJpPFcyT3R1YEZReDRTemx1OG1RMSg2VzYK eio4K09JbjY+NElTRHg/RD51NHUkLUBkKjReZHMtZD83Uzs4SjE+Kjhad0NIR2V+dEVmaGZjUmNy YHg2NUhxTV8oCno9IThNMjlZOC1NbUh+MD42OXBrY0xgMEUzJDhuNGhyV3pALWxyfmJaeWRLYlZS KX1mYTs5bXk1MkFzfj5gbVZLcgp6d1FudE0tNGdoREFIVyZXQFI5Y1N6dj1EVlYwWlMrUGR2Y0Y8 aWlOaitnNjtQeEF7djt0TmY/T3AxfWAtNSNTZm8KenpUK3dtLVBMME0lezMteFR3RzcyUlh7Qygz WldGOVJGdGJPRSRPailBTj12WiVBQ0t1QDRsRG0pKVkjYG5idT48CnpiOzheP00tWVNvOH5xSjcq NGxMWTlYam5Vb2xjKV91U2RgS0AleChvcWFhRShLOF56N0NeRGRqMnd7TWElez50TQp6LXRfd2Ny X1FjKD9CcDhmRkxlPU9WQk9qPkBEMVJNVyFwUEQwbHYpdWNAdDJ7RitnKStGWiYqTjUzfX5hdyRP U3YKem8+dzIjQFRBbVE1YSQ8cGAkNlJNP1oxNDFabnItTXs2UTFvZFhmVyZDT0xmMUIrViUmRSZG RVI+bTB2T3gpVm84CnprdXBkVzJ+SGpqKTUxQGAteylVXkBoa2p5fEx2bjdMSmhwcF97MFNDZ0FT Y2BNPn5EKEY2fmEyUE9uUzErbyMqPAp6WTM9VV5ncHA0ZWBOVURFMGdvYnRqOGZwV3d1PnxoeF9E YFdteWZTLT5nKSFjWmQ4PHpUTEp6R0lCKDRePXYheC0Kel9KaSQkcDlzTFhAR2xqQkwtKD0ySEsq SVZrYCs0KFF4Nnd0ejhEJGo3eG5OeF5UWHF1ZEZ7JDNueEJDYEhDXklPCnpaPVlrJnpOIShaSm92 KFp1aUxSPyFXdlFfZ3k0eTlXU1BJfD4xbkZmRHU0V3lGVnBGQ2BJVWU0TnItJDZ6QUkzSwp6X314 RDN0X0ZUJXFmTldwclBKK2NANHdybC19VWk+OXpvZEduamgoYHA5V2tZOz9SSnUqRDxXR19jP2lI bH4rJSEKemFQZX10RmIhTC01PVF8P2ppPGtxOClESjdKcE0hdyFtOXk0JmozISZ7QFdwN15SQm5E JVU7SlpKOD9nPyh5c0F3CnplIWlLKlRDcFFsJTtpaFZKbyZgMkV6fHo0SnlqbGgmak83SkdKJXEm QG5aenwoZzt2Ml8yKWhJaG5hMk55P1p5bAp6Py1QYjBVO2V7PyROS3NQenhKIVkwOHhNPCF0ZUVI X3U4fkt5MHFJfStUOU5BUEVXYEZ5Jms9ODQ/b2F9cEN9SHIKenQoT2AyJUZ1aSlWJFBtajxMSFNp b0kwfmM1UXJocnN8fnBNUFN8QDNFTUZwY19NM0Y5c1YyIVpsbCVZK1RsMXNzCnpmXlEyektLKXle bXdDLUR1ejFoZ0dVcEZxdUs1O1JyI3g3KSZCeXVxKzx2Wn18SWAhNTNCemNGISM0PjI/aSpANgp6 e1FsalAlRjVGR3hQYlBCWChxe05VcjFmbElkZFo1O3UjKExtJjt7WnRyb3VUPE5INFNleEhCKUBC Ui1+U0p3QyEKenxOR3lrenJJM2Vxc3ZDOEwlWkZoKTl1cGtea3tFJT15cDRGK2c8dVdtbXUoVSFO KWp3eTRnZjg4RENsTmFPfWh0CnpVT2xuRyhuQGJRPD82dVZPfGJoV218bFFONGF5YlIrbzFtSFEj NSlURFFOaV9NcXpIOGpYbC1PcyNBeyN6c0xsWAp6M2ZBPTNaI3UtSEopRUlobnJFaFlGRX1uejIz d0V3dC17VyE2QmpzbntMKmxTJmpRWll7QzdPRW5eSVgwdzBhZk8Kent4SkFUTmAjWDkhUzhJT1V3 bWR9aEIlSDFmJmt6NWJ2Q2N0PHpJZ0IzI19pSkByQj8xTWNVbXk/VCFKeS04TnhnCnpoaTxQIS1g Q243Xm5EJTI4fVIqcCRmPmkteW5PNXVyX1pldSQ4ellWKkJZPlIwT3N+V3IzeiZPZTVESElEd0x8 WQp6Yjk8T0gwKzR2N19EbXomLXNkJWMlaSFrKVZCeyM1Z0xoPWo5dz9acy05cClHbks/TEhrTWsy SWhAKmh4JDFWfkAKeihRckpVMUhVb2hAIS0zNVFLPjRjK3NGUHBWISt7KClfWUAtXiNlcTQlIXdu SnFjdEAoTVplIXF3WkdIcChDS3RnCnpPN1Z3KF5sI1ljWjE3TTFAcWFebUxweSlualZ8NDhue0kh RGV5QC0zX1h6QD4lIXgoRiNmeGhrSiQ5TDZDenNmMAp6YEBgS2U5XytwbVcqNERhMmlGQyFxPm9a YjNxYVdqTCNZRDBaZVpmZiVqc3habktLMmtXJCZaaDQ4dHZoWndvKl4KejJ7YlVoPipoT3t2T2xV PnklRW8/cjMpKiE2NmFAYVRvRyZRWkMqV2tLNDw2RVBATTAkbEtiRGppLXs+R3JUd2dpCnpGdmo2 YVhrU1NyNS1CQjVlSmNae1I7JUg8RjE9b2xlIW93eipHc2BxZSFsa0RTTGsqK3tLfktWNFNMLVRx eEJ2OQp6b312OVBweHkyOEB+YW0pYHBQQkZVUlhvUTtkfFlmZ2QxKndzWDB5Z2ohYCQpMS1HT1J1 TE5FaHloPGhyaSNKb1oKelRKd3RMOGBfez43NUdKQXBxRjNnS1ErVkx0Iz5oRFhhNlFeeDhnYiNW JWduTm9TJEVAYk1ufEZaVHBBdmAtNUAqCno0TDg9PWNjNS1RWExEfn5EKCZ8Tyg8Pm01MnFFISVm PE9IfkdtcEYzWV5KdDlxNWgodVorKylLKCY9cFFgRzQ+cAp6ezljPkQ/LTdKT2otUl4zYkkrZ1Ep c3ZVJGJjM1B5UmpQKktfaD4rSUViel9VYzNrajBAR0w8bm03cndJen18eTIKejhrMD0rKzleWko1 cHhjJjh2SHkxPGoxc0BmeSg/SVg2PFFRam1sb0M8I3t1bEFzN0ZUU2dWJlQ/VXBKYzdMbTY3CnpO KF5XREVhJVRGIStqNlZTWnVPNj9Tbzc7VW5zNWxLfk0xYlY/TGAoKzdgUjZPU3hSOCt3Rz4+S2tu enJyQHpOPAp6eyRgaUlefDM9ZHtwPjN8Xn5AUjBVc140RVpMPFk4OWZxbWQlKm4kd0hhMGZ7LUVw KjhhOXFzPmokQGQ+Z1IqNz0Kenc+OGdYdVJYQV9tdHVJQHhoKCtPMClKRTx6IXJlPSFkX2JUQ3I7 RkUjZEdVZk5MUXIheGkmNm9fNDsrJVU2dzl5CnpqTWFSRjxpPi1PRyR4JF9aLTQ4dz97QGBIZUpr TEZDJkVsU0UweHNvPi1ZT3h4PUFtK0AqS2JaVFEzc0Yhe0otMAp6NDNqZXMmNlotfTJCQDIqZ3BR bGh5YHctbThQekhAPXM0aCo4UnlBayZqWThWe2VhZGtDTjcqRG50Tk97JlIhUEcKeiFENzElUCQm ZXVfR0dRek8ySV8rQ09vJV9rVXtZaD9jQSF9ZUN6Z3deRERaISF2PypldShSKCNFektzNWl9UkQk Cno3bEhydWNMSjYjM3JAV3BYVT4/aHtYcjBIWWhBbnp6VD8yOzNeYi0zRCVFNj5zSUQyNiR7UEhF eyg2VWpLfihBNQp6UXBafHU7MjAyR1YtXzVrUylqcjIqeFVVMHFea3gkPypycn5aaEpzIVpqcmhA MGl8QnFnRykoQTBHa1lGQ3xiMCEKenkze1RWXzNZJSYpVT9Pc3RVRVRuSkZOSyVYLXEpUzdkLVA8 MFpXJHp0Q3N+cVUhfnkzYVpESjdTMlkhKlQhcmEqCnpoeCVqJnRkcV9MJn4+OXkjaURyd3UyTEcl V1VwU08xYCV9M1VAR1preyg8WDNZaz9aWSk2Ym8mclRsUndmQzImVgp6Vyo0YTFPV3x0ZWNecyNs SWQmdUJ7TmpiMEE8TjZ7djZgPXhXT2BTUFQzdjBNX0p0SnFVQ0M0NSl8IylSOylOZCQKej1HZUNq ZXpea3M0PntCKXB0cXJeSm9WKSlARG5CUmF2Y14qOFV+T1dSQXB1bStSI1o7Wk1KdEthOW8oMHJO Wnp8CnpEN01eT15IMUlmJFp5byh3UHYmWUtUM0UwSSp4LT47aDQhQkJiSUIpbWA9T0RYKjApRSVp UkxfYXM+RmsyNDUpeAp6VSgjTzlxKnFHMDxyfndRZ0Z8bjJuQXhUOHclLUIyWFd4MzIwLXdANm5F O3M5TExBb3M/aXY8Vm1JfHdeK01GflgKekRhJC1lJSV1QXc8Y0RwSys3XmVhSDMzQm5MUmBSYFhy JkZSWDMxQzBFUkcyV0c9Sj1oOVRfNShVfWQ+JnhfVT05CnpiMnlIbytGKXp4VUNaVk57bWtZb3Nv VDAlRjNXQSpqT0cqXnk1Q3slTDhHbFExNSEwTHhYQyZ9JDBsTWNVRXtpJAp6b2xwQnFZIytlOUU/ czFWVVIqNGFfNSg5Jk5JQjVkRTM5cSpqR1kzMGxuS2JNMyM4Ryt2dlVCaFFgUj9xT3FgI0IKelp5 cE8xMCFDM19gdVJ0PGFnezFpcEshKitgNyh8M1pTYkdebWJVcjJeLUpIfm5PJDRFUFllNnR0P3pT YiVfJjQ9CnpEI0VkMFdTTUVVUzMpT3kpTD5ZclIwZmFaVzxzRzFfKT13YGcqNUtGMG8lb3gwRmp4 M1dGJGVRaz93PSE2d3JRPQp6WH1CZl4kYjtfeVBOa345VEN6cWA9SG1XQStSdn1tT0ZWZFVPO1I0 I0tvK3VxUWY2SmY4WE07aWduSGl8KWNqLXkKelBxXy1XLTBnQXZoMmlqUmF0MHB5cHVeMn5JIUZt b1ZFUjlGQyNLZTlIRiZ0TExEQnxVVyFea2lyY2E3bztJNlZZCnpyRG5PSkNKbXtEQ1RUdU80eXBa KnQ/WSl6UDcxKkFLcjlQPDF3XnV8U0ZJRkk8QkVyRHpPPyo9cStidmxeZFVoMgp6c3F7ZEZ0aU5E JW9TJiF0ZF87OGZvZXEwJUVeK3BSV2NgWF9hdSgobjlqMTR+amZXZ2NXa25SflJCVkR8Oz9idnIK enFtfFp0KlJ3UmYyejxpO058QEIwJTc5UDd3YHsmanomRHlOPzNITVcqWDVeRmZjSnBsaENaXl56 KU9BKyNUJDVUCno2PnRqVXswI2ctO0hBPWFhWG5+WmVEYGh+Q25IcngkTjdvUEFFYlRLJnElSU9Q Xmxeby0wbVE2YkM2MFExQHppKgp6Pl5hNTN5UDtaM2dqXmU3JDJlb2pOXm5obUNZX3NyWX10TldM Rn1wSGk0VU5KYnJ4MmVxMyVMUWRZUyFDZDwzTisKejNKZG94Kyk+ZVI4TkV9YzBfYiVaPXVpdXlX biRTTXJ1cVcjbFMzJXxUKHpxMj5iTVh2Mm40O1pzVW9KRDl9akB2CnpANVZnJk8kJlQkZHxUI2hz bmxXMXpGXzhwSjMhRF45RGlRbmBgfiM+N2lLKW8yQ2lxV09JcV9+bkF2emBlYTFqcwp6WDZ+a3hn V3dCRzIhdD5XcEtiR0g8YGRYUjFVKkMlQ0l4QlhZWjhFPjRAP1VXP0cwbDQ0Z0tmfXZGSHU8YEJ+ bjYKems+KTJYUUooPFU5bi1nT3A2aG45JTNxcT5NXz4yNUB1MURPdl8wOXNWK2oxQGRMVjRtKzgq QGIqZldhMDlfKjxQCnpRPmJ4MHJLQCU+MWlsNWQhfDxMMz09VVVtM1pXZ3pSMHU1SyhgeV8yb0cw YzB5XlZvPTMqfUNNSzhnV35jRnEqKgp6JVM1KD5ffGF0fCgqO308PU1RTVQoUj9ZaERQOHBtd3xL ZGhrfH1yX1lqTDUmN3haTUklfSlTVmhLSDM9QzYhem8KejtUVWplP0JxfVlDdGxFXztUPDxRKUlk SkoteDs+fiVKTEJzZHY1b1hOKXRgdyE1Xl5zUl9OekFTcSh0fW8lTnd3Cnp6ckUrLWp0RH5EMVBx bE5TRmFHKngyempuJmBaRkU7ezE0VUJ1anBUaTwjSXBJcHIzM3tARyh0dFN2PSErUipeYAp6a3VV aGBafV4oXzJmVGZpMD92VF9DbGRtUDtUPFFlMVArZVlARHRDMi1fO3BEeUxSc1ktRjdhZ1pgKnZN IUxEYigKempXWSVpUil9WGBDJSE7M2gkSTJ1YitUeHB5XmApJTgwV3k+YVQ4RnFxb3g0anJIbDBL Vm8pITxwISkhbElOeFojCnpOWE4xbnV5ZE45KWJuUnxkJjlKa3dSOCl+IyMrcVVRan4oUGxwcVFl QjNhZ0xUWG0mfFpOM0RydGhuVktoaTEhfgp6PGdVfnAzRk00OygxI04qc0MxdXo8VGFmUUVmfnFJ bSR7O0I2NCNmPyF7Q2U5OUVsTGJnRGhhRGVtJCFeNDZ3MDgKenpvN1pVLXEoMT9PbkB3Q0omSitv JF58LWhGe21HMkIjaFFBQ29ka2pSenRPV0opOXxGaFVxeU0qSGVYPmp9Wml2Cno7YEU3LVNTMGd4 NzFhc0ZuOyRPRytRbEhmPWZQTHRtS0JISjsmOCpRYUt+RjZZS19jQ05PKD47bktOZ3pnV3JifQp6 JnExJH5DMiFXM0FkVXlVe0RIWE1GaElGN1VoYEFDWiE8dHIye1oqRCpHa1E7VVp6dmY+UnJfUXYx Mn5LMFFmKzMKejxzOXBGRi1TPkNGVDd8Ukt7MSY2JjF0P3BzOE5gKlpuPihNK2clIykwa1ZEZjVf XyNVZT0xX19Oe29gYSVCT14rCnoodURpbztuQTlOaE1kMHllOCpHVkBxb2tKOSh9VkxsV15BcXgp QyRrM2AhTjFSVURPTDA8SENkNHtNaCNUUiRTTQp6X2d0TkxrfFZTfDBZOGxaa30jMDBKPEthKmc1 V3I/YzhQVlg1d3U3TSlKYCZoQz1oXmY9XmB1cnRfZXB9O3NgRGcKem5NazE2PUVyRnBTSzd7SHRz MzVRVj56WSRib3p6YGUpOVkpJnhXUzZNfntYOE1YZTVaS2pibnNZaVloWWR1NiEkCnpaNFBzYj4z fFFVUCY2anRATFRuSUxBI0tlPEAoaEN4RmBzRWFQbWRDXz9tVlMoPlQyVmQ/bGUkSCt2MGoxJDt+ VQp6WlRmZTtPYkVnTnY5YHBAbjRiUn5WKm08LUFZRjtsVVNzKmhPTFhrNSohKnlYU2FiJEAwbWZe N0NMbHRfJXJDbEIKej4kY3wwMHF+WGFzeEZfYCVeYjtHVU0yS2V6eG84K2AlYUlreGxIckRHVGlZ MSU8T2l1STkleDhOdVYqSXhjJHcjCnpCaUUrI2ZweypMI09aZm88LStGUkUyUnJiVGg7dkp6Kkd4 OHQxJmNiNkZZeTVQSCFYSyVgX2Eqe2t4KytmVjlCMwp6N2F7fkZrRmE0b2Z9dlEpa0NxVEorQz1s PzBuSlp9SVEwb3crK1B9P2VPK0xaRGZvSU9rSyl6bUF+c2VlTzZafFoKenBodnReWUtuV18/bEx2 Mi1Tb3E2aDF1UFg5eyp5NHVSejNsT2x5NC00IXpsQXt1MGYlYk1SXn5CYlMxXzNIWChvCnphUjlm VmAyKUAkUyRsWT9WempAYz5IcCNoK1BUR15rdEdCPjc3RSV2S3o+dUBXYVd1fT5TZE4wYURYSWp7 fHJMPAp6KilabWBKODAxNkNzbjx+cF81N3ZVJTJ0TUdGflo5YHdXMXVQPXZuWCRQKkYkby19RChX JE9CaFlFNWhYbzhSTHcKengwbk16Tnl4LTExeSlNITMqMzRpUkJENT9LTEVibUlgflMkI0I+SnFy cl9Kb3BSeEJ8U3MkZ2M0Zyh6ciZZeGc4Cnp4N0klQFNvWEUhUEdEPjtJdFlAKmheTFFuYWJxPmgy cjhmLVVMcTNSYmYkMEsrdDJGeFc9b2NJcWJEOEtQMGhsZAp6OCVxTj1LTldedG9XRjhLXjZkOXdm fVR0I2M8UU8hbDQ9N2NycXZNbUxhSEl+Njk4JlcjVnZSMV9VJUg9UzZjX2EKelFyRkprUnk5OU9g STNRT0h0UFowbDVQXzFiJS15Vz1BeU9pSklGLT9KTCZ7ZFZFKz5hPW1ZKUwlVXBjJXVVV0l4CnpE MWxnfjdoS0dDLTVSMCFuKVV9QiFOZTVZYzMrODdTcTsmQ1FKbFlXUVMjS2NXN2J5YExNWTJ8US1k fT8qXkVJQAp6Mik7REd0Mk49fnlZKSgodEQqZyopb1k/UD9FSC1hS2tmS1lTc1FvKXpFez9kOVM9 XnV6Kj43YjZAWSQkMkB0dHYKeiY+ZTlDUlJJR2VUY34lQktFOylSUWxTWTQ2TmtedmB3d2U9YVhy NzxQI2tgOXNTeTA0SURjYkJAJEAkKD1UQXhFCnoqbnBWPi1AZWZVO0w4bUJCc1E8cztwViV2NGN7 KktOcitqbFpWJnZWaXMqV3BeMzdVNkVkKFk0YzxsJkZXKFkodAp6dypvbDlOQTB1fHNCJXRWWHhY MTAmXmA3N1hWI2FBPntOT2B5bz9fJVRNWiMqWF8oUGB4aylgQUNBcn4lJEYzV2sKekAhKHI9ZWkk ZkB7Nk8qSTQ8eEhzYV5Ban4lVWBKWlZpMF8zd1A5NmkrWG8tP2A/ZDxjdl85VylqTG9tOyYjMlRn CnpDJFFIaEl7UHdidE8rMV9LVlYxbTBBOCplQ3xNS1c8eVEjeitQTCQzKm5pO21ZJjVKPzYzMX5W ZHM5UVNGTFVlcwp6aW9qUD1wPEdGOC1yPnB4S15RUEwhPFhqWWYkaiFlSmAwXlNnXlYyMig0amB0 elJiWG5CVXJ0eC0rJHFSPylLZGQKel97cHszR2l+NSU2WXhkJHpkTWU4UHB0YCFEZVhXdVQyUDxS WjFCPCNTVSZQeW8mPkktJEhTfXZaTm1zUTZZUGl5CnpEQ0tmdWBDJGIxRz5YbzEte2FpN3w3JipK NWtXN3lMWnZpSyQqcmZmS00xfV4wbmMqI0dSXlF3c2kteS1jZllOfgp6bGl2JnB7OT9eZHMobVNx RGlEJDRAKUB7JVN+cnJgQy1tfkhUMnJzSCh7KkBsOG9+Zk4+cEkyVFM8e0lnNXBVMW8KemxldWRs YmU+PnAmZyQkYjBOPlZwKlVoTkVUOEJ5XzNuTl8qano3JmcxR3FpJkZVVW0hSjV+PFAzcVU+K05L OE5uCnpYdXRYI3VSaXlFNCUpKmFsbkNqRW11WGhfNHJzcEp6P3N6WlpPeFpScSVmTkBwbEhwKVRA UUxaX3F+YFhFWU4mcQp6KSVGWHJjZkYzVCpqK2hxNj17OyEkbFNvTWFpUU45IUI0SlowanJtRWtE PVkobUd9SVVXKWphVjBJay1jK1NLUUEKelJoeHY5JiNgdnFENmQpPy0/UWpIOXw1cV9QR0NNNmwh UENOMEJsNDclVE45Iz1nRjFUZ0o9fiRURjtodms3KGRiCnpfVEowRCZvWD5jRGR6UyUtMklTQ3hq Tl96RDhfQFk4MX58WU1mKEc3U1hUQEY3eSpoU1NYK1k3OXxrfTV7MWVCbwp6cTd6Wm9yZT47WS1H cVExeXp+UHUjMzlTVGg5di1qI1FeeXY1SWdNeUkzcmRJcn5iZ3xHVmNEeypnTDtTKSVGRHgKekxh IU5za3ElIVRkfVZlfTZpSDEkRHJ5c289Pj48P0Q+P31AUDxPWSVteERFVm1DeDt1MU4mO2dBTjNq NWJMRERNCnplOzVRbXE1ZzZPWVF7YFcmVDlLI3BWWWE4dm9FdnBnRm9sVklPR2deRnd9fiV8REJ1 fXhHb0dwS3xASEMza0JRMgp6TXNJYGotflclQ3dSXz9mNVhOblNYaWJCITJLKUF0bEl7VFE4YE9s QS1qJjkmbX10VE0/e2IqaT4tQDtVUHJsPGcKekBST3pDdURlT2hVKTduJmBoLTVKT2BWSyNKJFVo UCZpTmhBOHxgb0JMY3BrP0Eldll+MEdrUXlyQVlhcTV0V3JvCnokYn1uTlQpZElgSyRvSjVhb2pR dnUzMHUtdG9leTQ3eXdAOypCVjV9KWVBUGZsNktuUz09QjkzVX04b1dkNGlzSAp6XyhwPDFXcHg5 fGY/Ql8pOWxpUmIqODBnPT9LOUxUdjtaN2BtZW5WfCN1Rm11WT1RUENmKUhIfkFIWFhCLXg7eDkK ekZkWk5qTjRTMlVzciVvfXFVJmFUSE52ZHJjYnQtMGAoYEZ8WnZ3dGo4VGVBbFIweVBtJCFVa3l5 czZIJDRHYEJFCnp7UTg5VT9DVllLeFJvbHBIejEkUmI7ZzBPRWJ5el4tWiFVVmEhdzBDVkBsaDl1 WX4mY0E4flp+OTUwJkM/K1VPQQp6dFhxKmxjczstJCNRP1Q+Qz5rQTgxfWF6MSkzNE42eGFCVEFL UGMmfDVLMVNpVCZIQmJhQWBKWiRYZDVZWD9+Sz0KelB0JntSeHBEPCY3S3xYNjlLWmwqWUxtanc3 UXdHS158LWNYT017bXJjfkZCd3UmTCUteCZDcmgmajQoO3dBTjE8CnoraDNjfHRubFI1eCR4e2Ff JTM9TEBSYjdYNTNaTj9rMjMrekNRaExUbHZsNmQ/WjFfVT0+O2x3emtyU2VibGZ4MAp6X2IwfF96 RGpyVnUpKXQoKGtNejVuQkUyUkh8UGNtb3BAMjBXZHF2PUtXVzY2bjE8UWlJPEBQMSNmNj11PU9G MG8Kel9jbU1PIUIzY0BUOEh8U3E1VX5Te2dZWktFfWYkRHl8NDAyenIjdU5IMUs3a3tUcmBgX0t5 PlFhZ2wqKlNmSkcxCnpBb2hEcXpVZzZoV0EpcmlXJWomUDRvPWQ3Qk0wbUdkQ2dDJmM/SUMtKTRQ ci0hcCFlZ3dDMTJPcF5HfHwrVGlGbAp6dVZUKCtHa2VFcVczOGQ+ZHV0OV9eRXhicCV9Y3NUP3wt PkU4dkpCUWMmVGlfcFZXVkElQSk+U0w7d0M7ZjVnalkKelUqO0wze1l5cHdZJHdweHtfQzw+WUA3 KWc9TU4tOUNCMktNPkViZWYrcjZ7flMtPk9+OVZjQjV0eTBhRz0/I31zCnpUQUhkaDF3V3RPYnpM MXNPLXlVO1lSeUF5bXU4OXQ7SGxZK2RLMiV2VHNEaDE8RV4pR05zK2FONC19cFh6Xn5MYQp6cWZB VV47NVU8JFp3LUYlPWJVfSF8S29BPTRqQDtJMElYVHM/X1pESHw1Z1JTJF5FZStLfWdOUXJMKUFY OFJxeGcKek9lNFM0UHpzVChyWj4pO3ZAfjVCTio8PHRBPUpQVXN8QF9YMVcmJU9HWVVYcTE2PEl6 enR3dWFvbTQ4TXtqJWxwCno4PUY1bHJ5YW9ocjJnSGpQcU9sWnxBKVZoZHx0RF9VJHFpSWNKQCF+ Ym0oX0E0M0d+RzJMdkpQNkU5IUhUUmd6cgp6XmdOWSgkRjI0T3RjOD1wV0NYVmpLSTZmVTMhZEt1 e1FRYT81ZjNsbUNgI3tjMjdhPzttfWt4dWQ/dkw/eE85cm4KemNtSVV2UnhmZVhxVzs5fEFDPmVg V0JmRGNkST48YHo9I24tO2NsJGJUVSgtYik5dVZRcnprbzNyTiZCU1ZeTlpqCno0TGV0X3VTYkdr UHxxJn1mMTg+PXU1WjZrPSorUyZ5UT89JUB6I2ZGZV99ZWJgfFVNPz98Zy0kPVUoQWkzO1pJbAp6 S1EzdGRheitSTipDRyghN1FyOUs0ciNjIWUxWjFIRHZldzJWenlHeGhEIz5YRz9JMk1ySlI5Nk8l bGZDKTI+Q0cKekpmayN4eVBDZ1UrOCtTbG4mWG8/bS1RXnNsV1A4cWlUNHsyYG8hUClWfiFucmlZ R15DZXAyXyhfeD9LdD9DV2VuCnpGfUVaUC1XQ1BMKzNOWXlZMVRKWlkyST1WR3YjV1FZRjFXLUVg NXV8MCpRVWs0XjFrbj1mQj1JS2tla1QqWVRQMwp6WnBCMHZeKG84U3BVWDdBKHR0UWRlQ0khSzst JkJMITxeUHs2amMxZ0NKfnNNJWg4TXoyc1JUMFp5Umg7R15qQVkKeno2TzhgciZ3S0lyZzhIZk9q cWw4Tm1maSoodlZqMWxIIVRWaGsrTERUZFFtZkhVRH5vRlNCKDVpTEgwdHRlZENTCnolISlneXgx WlNqMjFHdmJjbTlZfEZGd3hHUi1DX1hMY0puO1olK2ZXXkRiV1FjYHFqandxVDQ0PjkyX2Eje0NT Rwp6MXVtUm9XJVYtRXkkNU1FcnpvWE1zfngpdVFETnBnNDx1fW90QH42RzQoXmNWWmBhe2RIdDwj dGY0TVM5YEk5cHkKeihVWExGcm96YCpCbUFxY0BZPDJAQF9mJEE/XillRkJHLXsrWEklM34kdlA2 QCRjTmBQWVpMK1JUckM1UDApNW9mCnozVSVvO3Q1P29abiVUfE4lcXxAcjZzXj0mI3hGPjYxM0Zg O3ZUb2FpNn47dllSe3tRelhQPlZOa2dlTktmVW5kfAp6TiFQUzxQMHBFNiZtPykwSVJEQ05gcnJN KElQPVByeWtmPW5IcjxQeSN3V201dX0xWTxONXZ9MGpTYDRGNkY4ZmgKejBgRDVaRjlQMFB5KCpW NHV6TFBEdmY1eGAmckxNITZ9ZTg0PCs1NzdoTjZLSDtveD9gOX00QSlNemxFRHE+ek59Cnp0NCZT cSY2YytKTm9xSCM+KD80a3M9PGs7PjNyYGBJZVlxT3kzYiRWKHMtMnYtcmslZSp7NypTd3E+OUZk fG5fYgp6SVlJRDcybSg5ZDE4a0tJbHFLQilrbkw0QVBRNjRZQE0jPmxpJmk+NUpxTGFeZnxiRTBQ JnF0cyQqIzxhVD5GKFEKem44cT5Hb3RwemFae3c1WVQ5dnhDXkwzOzMmRlBIcEN5a2Uxbj1xQlYz T3hCMnRvYDhzPUlxaldtS2ZhQU1fUyszCnota1pfaHBScUNHc09PR2EwVzsoVVZWb0lBe2tFJFNm UDlHMDI8O3lqSDUyO3VQUTFYeSVjdD5MXkU5WERzbntndAp6c0xaPW93dHgobmlRIXxRKkgwRVdh SDYxNEJ5Km1UWWlZYUh1JGNoZ245e1h9aUo0NX1uQEwpXnVHd01mOU1SKXsKeiFwYVhIPDl5SmtT Q0dURW93X1F5VUQrKEtvN1M7YUxDQ1d+LVg5cHItbGVQNWJqT25EeFdGRzZ3Yjt+dXs9NGBXCnpV KnF5eUFLe0w3e3RTQ3ZQdFJPLXl6RX5zayZScnA9ak5uYEoyOz9PTnBNdipuYlpFLTFNZi1oaWFu LTFTKXklYgp6X2p+cW90IW1ie1V1bD58JmJsYyluTU98Nmc9ZkErP31jeCVhcnJiR1dUUFkjcGRJ VkZYcGYpI15iYzleeU9gbFUKemc5YUF4R1E2YystIWNpIztLRiFoXjN8YCExVUxsQGtaJis4b0lC OEt2dktUTSZZd01vRHduQSk/NUZObl5VNzFPCnpUbiZuQXopMlFVeTAlYlF1WG44Wkl0aVdJdWQl aGZXTnAlOVlrUGd0UGAjbzFpSShvJFolIUZJLV8mTklSRHN1eQp6NWRHRGsoKjVDTXRhc041YjJS VmZkTVljSFpMajZEK1NkNXkydilGUC0+YGd6Sk9rdmxVeVYyKkghSV82Z0BBKDIKenApJEZoTX1i TFQzWVozM3okYEZiWXEwMD0xS2ohTV9wdEJhZVd0bUBna1ZZTEV3PDlVQjhEZ2U1b1BCJSlTYkNl CnpzOXpoMCo9ekhqejBDO2UjIWE1dHVjd2t9ZXt3RCpNPig2fmFxYng2PHNUM3BlRkRHVlBKeT5x P3Y5JTVCP31acAp6NitBYTtmMXYhWFZmSj5pZVhEfnpJZzw0UzlnNys0OXooR2NiNyEzcVFlVnpW ZVg8TXJnYkBKeW1+S3E2X3FPe3YKemJuaVJaZDswQFNPS1ltT1pRcEhnVXN6ekwhVnA+RG83V0ct XlR+Y2FXKzxmTlN2Pj0jIUM/KV9idXZIaiV1JlFFCnpQWkdjU0J2RUh8WG9qRU0xWlo7U1FJVjVr ezAzMUdnWmxeQ2B2YFpmZXU1M194fUEkZ2c1KSFJYWA1bmBFIyl+VQp6WFZNYWVEUlo+UzczTDF5 I2NqOTBnJlhkOGtsQmVEJTg5K1VDdlZEfXgxVWJxJTJmbzFvSVhxWW9zeXBJbFkoNSoKej1FV14j WDJiOElQQ2shM2A1ZlotdiYzUClQOz1FYms1UXFzJF9iRm9CdDtCaDNxWWRqM0duT1kqcyRzaXo1 RmBFCno5aTJRflBgTDBjJm9zWHVhVXUpfUQ8bEZqbTBadjZYNVdvPnU+YVFrU1U3a3V0O1ZGekRC QTVeQkpjZ0BwVSpjXgp6eHIyXm1HOHhvJUgyWGMmeG1RcVVqdmBPTGd0JlpxcGZhfV5wcXBLQCQh Q29kMDVMKVVkWEBrcnBzIWk9aElPbVUKenNCZVgpQGxGZHMtWSohdEJXWGJ4V0RDVEVaOGxvLUVi aDZQI2w1I01mNVdYej96QCN7eHJSSH44SndrKGxTR25UCnpoX2EyOT9mdTZRVHpVPDg9QGp6OU5x d3hHOXxDPEdmYUNWP0RjYVFPS1doT2ZWZ3J9S3lAfF4/TXlUYk9BJTZeYwp6Iz8yT1V2JThzX1N6 dX5yayFFV2J3YUZSRSYxcCl0Q1Redk1UaF5IZHE1dXs2c0QyMDQtOVU5JFFTQkF2Kzc7eD0KekNG SlR3PGk+TDBVfW0rJj1WMUltWEVxVXt8Nz1YYVJAazZPNUd1S0pYRmU2MGdpODZkOVUzSjxsemRq WHBvK0dZCnolQD8pO3ZLJih0V2dDTEBCWDxIeipJNTlIWmtXVUhYMl4qJl9wUHxMVEVHeFJEYnI/ N1NaY1d4WCg/QVZiMmlENgp6ampNQXdZJSpTZDgtZ0g1UTIkUGFmeFRQfXFId159XiVqN2w/NGVg UG5gZUV3KEVMOV5FPzF0ZmlySS0yVE9nOV8KejxUWFdRKU4kM2FRVCt7aDtHOGpGazkoWllsI1dX RHRBYjQ2SH58UShabGI8YmI/ak9+VXs0dHZoKy1VR3t+dUAyCnpDbSg3I19pe3l6ZD5PUkpaPlom dHMkflhCSWRmMVgxUWdkTDJtV1Z5alZ4RzFgOzV7Mm9rI2B1dD47NHU8XyFFTwp6MVlsZWVZMUkw SWtgK3FZZW5UWl5gKWRVaXZocFQxXkNDZXxxcER7a2Q8VyskMSl5bEoyRE9PKiM1cHp5YjRRUm4K el4xdSZGOH5zcld6JktWWVQ3ekl+Ykdia3VNbTA+NzN0RmxlIXZ2I1BBenhscVRXRyVBRWNxaXgp SzZzMlMxS3xHCnphbjMxPmE+WH5CRl5ZOyN7SjAxSm9Ban1iK31xZCF4SFJWUXckV0liWj5lR245 WDh1eDBMRWt6I1RaOVc3U3RNdwp6U1JvIUVGdFI5WGBRcz02bzNUUzRKVEdUMV4zOVpeZmNGXkQt YVoyS2FTSmxHQV4+Y1h7MjlkdHFrTXlMIVpFNHsKekhJJXtwTmYzWmgzOHFuTjdqMmVzIyEhQ1Y9 T198fWFsbWg5QmdnSGdme1RQZmpWTCZZRjt6eDZDVC0xNnNzTX5LCno2Tn58RzlLZjVJZlVWTkx2 eClZemc8NjUhTEAzbWxOQENHLWpMQlI0TDxfKHVMNGZUcXExeDtAd3k1PTY1ckVCNwpsJFo4QnJa MSpgZiR5V2dJe3t2XkpzeFQ4N0tlWWU9MDAyb3ZQREhMa1YxbFR9aUEoP2gKCmxpdGVyYWwgMApI Y21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3 ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3RzdF9xd2ViZnJhbWUuY3Bw CmluZGV4IDcyOWI5NzEuLjdjY2NiNTcgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC90ZXN0cy9xd2Vi ZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS90 c3RfcXdlYmZyYW1lLmNwcApAQCAtMzYsNiArMzYsOSBAQAogI2luY2x1ZGUgPHFzc2xlcnJvci5o PgogI2luY2x1ZGUgIi4uL3V0aWwuaCIKIAorI2RlZmluZSBYU1RSKHMpIFNUUihzKQorI2RlZmlu ZSBTVFIocykgI3MKKwogLy9URVNURURfQ0xBU1M9CiAvL1RFU1RFRF9GSUxFUz0KIApAQCAtNTg0 LDYgKzU4Nyw3IEBAIHByaXZhdGUgc2xvdHM6CiAgICAgdm9pZCBqYXZhU2NyaXB0V2luZG93T2Jq ZWN0Q2xlYXJlZE9uRXZhbHVhdGUoKTsKICAgICB2b2lkIHNldEh0bWwoKTsKICAgICB2b2lkIHNl dEh0bWxXaXRoUmVzb3VyY2UoKTsKKyAgICB2b2lkIHNldEh0bWxXaXRoQmFzZVVSTCgpOwogICAg IHZvaWQgaXB2Nkhvc3RFbmNvZGluZygpOwogICAgIHZvaWQgbWV0YURhdGEoKTsKICAgICB2b2lk IHBvcHVwRm9jdXMoKTsKQEAgLTIzNTksNiArMjM2MywyOSBAQCB2b2lkIHRzdF9RV2ViRnJhbWU6 OnNldEh0bWxXaXRoUmVzb3VyY2UoKQogICAgIFFDT01QQVJFKHAuc3R5bGVQcm9wZXJ0eSgiY29s b3IiLCBRV2ViRWxlbWVudDo6UmVzcGVjdENhc2NhZGluZ1N0eWxlcyksIFFMYXRpbjFTdHJpbmco InJlZCIpKTsKIH0KIAordm9pZCB0c3RfUVdlYkZyYW1lOjpzZXRIdG1sV2l0aEJhc2VVUkwoKQor eworICAgIFFTdHJpbmcgaHRtbCgiPGh0bWw+PGJvZHk+PHA+aGVsbG8gd29ybGQ8L3A+PGltZyBz cmM9J3Jlc291cmNlcy9pbWFnZTIucG5nJy8+PC9ib2R5PjwvaHRtbD4iKTsKKworICAgIFFXZWJQ YWdlIHBhZ2U7CisgICAgUVdlYkZyYW1lKiBmcmFtZSA9IHBhZ2UubWFpbkZyYW1lKCk7CisKKyAg ICAvLyBpbiBmZXcgc2Vjb25kcywgdGhlIGltYWdlIHNob3VsZCBiZSBjb21wbGV0ZXkgbG9hZGVk CisgICAgUVNpZ25hbFNweSBzcHkoJnBhZ2UsIFNJR05BTChsb2FkRmluaXNoZWQoYm9vbCkpKTsK KworICAgIFFTdHJpbmcgcmVzb3VyY2VEaXIgPSBYU1RSKFJFU09VUkNFU19QQVRIKTsKKyAgICBm cmFtZS0+c2V0SHRtbChodG1sLCBRVXJsOjpmcm9tTG9jYWxGaWxlKHJlc291cmNlRGlyKSk7Cisg ICAgUVRlc3Q6OnFXYWl0KDIwMCk7CisgICAgUUNPTVBBUkUoc3B5LmNvdW50KCksIDEpOworCisg ICAgUUNPTVBBUkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9jdW1lbnQuaW1hZ2VzLmxl bmd0aCIpLnRvSW50KCksIDEpOworICAgIFFDT01QQVJFKGZyYW1lLT5ldmFsdWF0ZUphdmFTY3Jp cHQoImRvY3VtZW50LmltYWdlc1swXS53aWR0aCIpLnRvSW50KCksIDEyOCk7CisgICAgUUNPTVBB UkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9jdW1lbnQuaW1hZ2VzWzBdLmhlaWdodCIp LnRvSW50KCksIDEyOCk7CisKKyAgICAvLyBubyBoaXN0b3J5IGl0ZW0gaGFzIHRvIGJlIGFkZGVk LgorICAgIFFDT01QQVJFKG1fdmlldy0+cGFnZSgpLT5oaXN0b3J5KCktPmNvdW50KCksIDApOwor fQorCiBjbGFzcyBUZXN0TmV0d29ya01hbmFnZXIgOiBwdWJsaWMgUU5ldHdvcmtBY2Nlc3NNYW5h Z2VyCiB7CiBwdWJsaWM6Ci0tIAoxLjYuMC40Cgo= 40115 2009-09-25 09:50:09 -0700 2009-10-01 07:33:24 -0700 committed r48972: patch 0.3.3 - make setHtml and setContent to not change history 0001-2009-09-25-Antonio-Gomes-antonio.gomes-openbossa.patch text/plain 25688 tonikitoo RnJvbSAxZDI2MDk2NjA0MTlkZTQ4NDZmYmM0YWVhMWVmZjFkMTgwYTY0YWU4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IFR1ZSwgMjIgU2VwIDIwMDkgMDk6MzM6NDYgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTI1ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAb3BlbmJvc3NhLm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgog ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OAogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CgogICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVudCBtZXRob2Rz IHRvIG5vdCBjaGFuZ2UKICAgICAgICBzZXNzaW9uIGFuZCBnbG9iYWwgaGlzdG9yeSBhdCBhbGwu CgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0SHRt bCk6CiAgICAgICAgKFFXZWJGcmFtZTo6c2V0Q29udGVudCk6CiAgICAgICAgKiB0ZXN0cy9xd2Vi ZnJhbWUvcXdlYmZyYW1lLnBybzoKICAgICAgICAqIHRlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZy YW1lLmNwcDoKCgltb2RpZmllZDogICBXZWJLaXQvcXQvQ2hhbmdlTG9nCi0tLQogV2ViS2l0L3F0 L0FwaS9xd2ViZnJhbWUuY3BwICAgICAgICAgICAgICAgICAgICB8ICAgMTMgKysrKysrKystLS0t LQogV2ViS2l0L3F0L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTYg KysrKysrKysrKysrKysrKwogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJhbWUucHJv ICAgICAgICB8ICAgIDEgKwogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9yZXNvdXJjZXMvaW1h Z2UyLnBuZyB8ICBCaW4gMCAtPiAxNDc0MyBieXRlcwogV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFt ZS90c3RfcXdlYmZyYW1lLmNwcCAgICB8ICAgMjQgKysrKysrKysrKysrKysrKysrKysrKysrCiA1 IGZpbGVzIGNoYW5nZWQsIDQ5IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCiBjcmVhdGUg bW9kZSAxMDA2NDQgV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9yZXNvdXJjZXMvaW1hZ2UyLnBu ZwoKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC9B cGkvcXdlYmZyYW1lLmNwcAppbmRleCBmZTgxM2I4Li4zZDMxYWU4IDEwMDY0NAotLS0gYS9XZWJL aXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuY3Bw CkBAIC03MTAsNyArNzEwLDkgQEAgdm9pZCBRV2ViRnJhbWU6OmxvYWQoY29uc3QgUU5ldHdvcmtS ZXF1ZXN0ICZyZXEsCiAgIHNjcmlwdCBjYW4gYmUgc3BlY2lmaWVkIHRocm91Z2ggdGhlIGNoYXJz ZXQgYXR0cmlidXRlIG9mIHRoZSBIVE1MIHNjcmlwdCB0YWcuIEl0IGlzIGFsc28gcG9zc2libGUK ICAgZm9yIHRoZSBlbmNvZGluZyB0byBiZSBzcGVjaWZpZWQgYnkgd2ViIHNlcnZlci4KIAotICBc c2EgdG9IdG1sKCkKKyAgXG5vdGUgVGhpcyBtZXRob2Qgd2lsbCBub3QgYWZmZWN0IHNlc3Npb24g b3IgZ2xvYmFsIGhpc3RvcnkgZm9yIHRoZSBmcmFtZS4KKworICBcc2EgdG9IdG1sKCksIHNldENv bnRlbnQoKQogKi8KIHZvaWQgUVdlYkZyYW1lOjpzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWws IGNvbnN0IFFVcmwgJmJhc2VVcmwpCiB7CkBAIC03MTgsNyArNzIwLDcgQEAgdm9pZCBRV2ViRnJh bWU6OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKICAg ICBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsKICAgICBjb25zdCBRQnl0 ZUFycmF5IHV0ZjggPSBodG1sLnRvVXRmOCgpOwogICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OlNo YXJlZEJ1ZmZlcj4gZGF0YSA9IFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0ZjguY29u c3REYXRhKCksIHV0ZjgubGVuZ3RoKCkpOwotICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1 YnN0aXR1dGVEYXRhKGRhdGEsIFdlYkNvcmU6OlN0cmluZygidGV4dC9odG1sIiksIFdlYkNvcmU6 OlN0cmluZygidXRmLTgiKSwga3VybCk7CisgICAgV2ViQ29yZTo6U3Vic3RpdHV0ZURhdGEgc3Vi c3RpdHV0ZURhdGEoZGF0YSwgV2ViQ29yZTo6U3RyaW5nKCJ0ZXh0L2h0bWwiKSwgV2ViQ29yZTo6 U3RyaW5nKCJ1dGYtOCIpLCBLVVJMKCkpOwogICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChy ZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCkBAIC03MzEsNyArNzMzLDkgQEAg dm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3QgUVN0cmluZyAmaHRtbCwgY29uc3QgUVVybCAm YmFzZVVybCkKIAogICBUaGUgXGEgZGF0YSBpcyBsb2FkZWQgaW1tZWRpYXRlbHk7IGV4dGVybmFs IG9iamVjdHMgYXJlIGxvYWRlZCBhc3luY2hyb25vdXNseS4KIAotICBcc2EgdG9IdG1sKCkKKyAg XG5vdGUgVGhpcyBtZXRob2Qgd2lsbCBub3QgYWZmZWN0IHNlc3Npb24gb3IgZ2xvYmFsIGhpc3Rv cnkgZm9yIHRoZSBmcmFtZS4KKworICBcc2EgdG9IdG1sKCksIHNldEh0bWwoKQogKi8KIHZvaWQg UVdlYkZyYW1lOjpzZXRDb250ZW50KGNvbnN0IFFCeXRlQXJyYXkgJmRhdGEsIGNvbnN0IFFTdHJp bmcgJm1pbWVUeXBlLCBjb25zdCBRVXJsICZiYXNlVXJsKQogewpAQCAtNzQxLDExICs3NDUsMTAg QEAgdm9pZCBRV2ViRnJhbWU6OnNldENvbnRlbnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29u c3QgUVN0cmluZyAmbWltZVR5cGUsIGNvbnMKICAgICBRU3RyaW5nIGFjdHVhbE1pbWVUeXBlID0g bWltZVR5cGU7CiAgICAgaWYgKGFjdHVhbE1pbWVUeXBlLmlzRW1wdHkoKSkKICAgICAgICAgYWN0 dWFsTWltZVR5cGUgPSBRTGF0aW4xU3RyaW5nKCJ0ZXh0L2h0bWwiKTsKLSAgICBXZWJDb3JlOjpT dWJzdGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShidWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1 YWxNaW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygpLCBrdXJsKTsKKyAgICBXZWJDb3JlOjpTdWJz dGl0dXRlRGF0YSBzdWJzdGl0dXRlRGF0YShidWZmZXIsIFdlYkNvcmU6OlN0cmluZyhhY3R1YWxN aW1lVHlwZSksIFdlYkNvcmU6OlN0cmluZygpLCBLVVJMKCkpOwogICAgIGQtPmZyYW1lLT5sb2Fk ZXIoKS0+bG9hZChyZXF1ZXN0LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOwogfQogCi0KIC8qIQog ICBSZXR1cm5zIHRoZSBwYXJlbnQgZnJhbWUgb2YgdGhpcyBmcmFtZSwgb3IgMCBpZiB0aGUgZnJh bWUgaXMgdGhlIHdlYiBwYWdlcwogICBtYWluIGZyYW1lLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0 L0NoYW5nZUxvZyBiL1dlYktpdC9xdC9DaGFuZ2VMb2cKaW5kZXggYzk4ODIxZi4uZGJiYTdhZCAx MDA2NDQKLS0tIGEvV2ViS2l0L3F0L0NoYW5nZUxvZworKysgYi9XZWJLaXQvcXQvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDktMjUgIEFudG9uaW8gR29tZXMgICA8YW50b25pby5n b21lc0BvcGVuYm9zc2Eub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0 OAorICAgICAgICBbUXRdIFtBUEldIE1ha2UgaXQgcG9zc2libGUgdG8gaGF2ZSAnaW52aXNpYmxl JyBsb2FkcworCisgICAgICAgIE1ha2UgUVdlYkZyYW1lJ3Mgc2V0SHRtbCBhbmQgc2V0Q29udGVu dCBtZXRob2RzIHRvIG5vdCBjaGFuZ2UKKyAgICAgICAgc2Vzc2lvbiBhbmQgZ2xvYmFsIGhpc3Rv cnkgYXQgYWxsLgorCisgICAgICAgICogQXBpL3F3ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2Vi RnJhbWU6OnNldEh0bWwpOgorICAgICAgICAoUVdlYkZyYW1lOjpzZXRDb250ZW50KToKKyAgICAg ICAgKiB0ZXN0cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBybzoKKyAgICAgICAgKiB0ZXN0cy9xd2Vi ZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHA6CisKIDIwMDktMDktMjUgIENzYWJhIE9zenRyb2dvbmFj ICA8b3N6aUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2ltb24gSGF1 c21hbm4uCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3F3ZWJmcmFtZS5w cm8gYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZyYW1lL3F3ZWJmcmFtZS5wcm8KaW5kZXggODEwMzdj My4uNGM5MmU5MSAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9xd2ViZnJh bWUucHJvCisrKyBiL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcXdlYmZyYW1lLnBybwpAQCAt NSw1ICs1LDYgQEAgU09VUkNFUyAgKz0gdHN0X3F3ZWJmcmFtZS5jcHAKIFJFU09VUkNFUyArPSBx d2ViZnJhbWUucXJjCiBRVCArPSB0ZXN0bGliIG5ldHdvcmsKIFFNQUtFX1JQQVRIRElSID0gJCRP VVRQVVRfRElSL2xpYiAkJFFNQUtFX1JQQVRIRElSCitERUZJTkVTICs9IFNSQ0RJUj1cXFwiJCRQ V0QvcmVzb3VyY2VzXFxcIgogCiBzeW1iaWFuOlRBUkdFVC5VSUQzID0gMHhBMDAwRTUzRApkaWZm IC0tZ2l0IGEvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS9yZXNvdXJjZXMvaW1hZ2UyLnBuZyBi L1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvcmVzb3VyY2VzL2ltYWdlMi5wbmcKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uOGQ3MDM2NDBjMTQ4MzI1Njg5MjczZWYwMzFkMzZjZWQwMjM2OWZmOQpHSVQgYmluYXJ5IHBh dGNoCmxpdGVyYWwgMTQ3NDMKemNtVjtJSWNVYS1QKTxoOzNLfExrMDAwZTFOSkxUcTAwNGpoMDA0 anAxXkBzNiEjLWlsMDAwMDRYRipMdDAwN3dvCnpMZUB7QTAwMDA5YTdiQm0wMDBYVTAwMFhVMFJX bnU3eXRrT0J5PmVzYlc/OTtiYSFFTFdkS29pWD03X3RYPkRhNwp6SFpDPFRGKDQ+U1ZQaGFxUXle Rj0wODFuSSReWlpXMlhza0lNRi1SZzlTaV47WlZLJT8wMDIxbE5rbDxaYy1ybH4KemQ1fFI2ZWMk PVglKHw8KXRGUChsOE8jOEswV2NXYzFXQUEoaTZ0cTU2aT1AUisyWGE3TmhfPnk/QXFMcmNQO0lJ Cno4P215cmw1Ql4+UmN0dUNHfW5oRGl3YTl6aVB7eWg3UUdZP2ZkQHB+eitlRShnfUlOdT4mb2xC d3x+NXNuWGpfNAp6cz1IQDtLKztBPldNbyEjUmRyVz5mNH1lVmU4MT1MIz9SflY8NSpgMGFEbT9o eyRjV2hNP1pjeXxLenRtTTc+QEAKekRHNWp2Ri1uPCgyJnFEcDNYdio2RHhYK31sJEI1T05Xa2pa M1hhbzlpNFl9WWwjSHlpMDN9Z01wcmstNGc7RjM/CnpfSyZec15aSjdTPiVqayp5eD9hKWFTeS0j ZyU0QSV4WjRLNWVrNWU9V0NnZDwlWW1OPXotYUo9UDtVc3Bqe3lBTgp6MFJEJk0xJUxDQ193WENQ XkhEc0haR200Xks5dl9eKT0hbkw4aG9rcktsSH1XanxsdW5LWWxtPSVSbD96dyF6biQKekFKOUdM VUs5OUl6RmA3aFB3QFhLQEpseEJ8SnJZVmgtJWZfTEU3S2s9RyktTTt0Y2Ajaz1ndjt7R0VeQm03 RT08Cnp7cTJKdnpyZ15uS2tmZ21QdTxJfXw4RjA7ZFlnWnlnekhAIT9JKyt6djNrUD9jcFhCJG9Y IThoKSFGPSkxMiljaQp6SXxfYWp6cmdfaU1UQn56enowZGA0ZVdrPUwlcig+ekNhTn55ZGVPdU1+ M2ZlTGNNQjJgKUFBN01lfkNRelZ2KGgKei13PVF3KkhFdXxCeEwxZV80O1ZPNGAyTjlqVTJzRmAt djMqWEE5NWdVIXo3YHZ4Vm9rWVYme1RgcUY7OTFHS09CCno7PWtYfChXTSQ1S04oSjc5I3AzUWZj KWNlMC15QDZNP0VlUWl0OEhjUmdaK01vdnN2a2AmU3B8K3FCPHs7RVRWegp6cENlMGslNzgtclNU ZXZVen08cHR4OFFlTTYjeGF1NSRGODF2T1pJN1g3aGpicFhZNzkqbTlgMWE9TjxYOzNwMj4Kem13 ciFjZWdlTXdGXlUzZ3U8fTRCazNEbmtTPGlkOS1gbnBXTWUpKkgzK3U1a1haemF6ejAzKHVeMXVE Qkh1JU0lCnpvPE9OK09QWVRAWTx9WUtlZXc2VCZHIyh1ZTtmcUIpPmJ6TXgoIz9LY1A9e2UwJUwh XiRfWVRDLUQxUU09ZyFKSAp6Q2ojKG0xS0B3c3E8MX1NK25RZl9GPXAqbDxAen4lfDkoRzVtWn00 cXVndzJmYFozWFY4fXRPfDFuamM4RT9kdSsKejN0bmVgaEJMd2hyfisrfEV1YlVvYWdfVT11LV5O UmZ6Sj1ue3krT2JHNUJvSyU8KVJWPmJjN0czLSRoQktTITR1CnpsdTwrQUU5QzN5MVF0MU5jYFl2 RzBJeWdfKipjZVYwJTA+bEFfenFjVTt9VDFwOCVkNVZaa3xoJjtKRGN7U15GOQp6K3szVGBfSl5u cGduQWJFRCFkQVpGV00xcnw0WUJPcENlYWxjc1BhTnpuJigqJCFVQk09KmR3dktxdSF+IUU9P0kK ekZ5dXt4bl9+ZiR2LWg/RCpxfHB6VXxzdnhAQmUkPz9gJSV7IWhqemtSYit1NTQ4LX1ARlQ8eiE7 X3ZSfj11JjtpCno9RyloPU09SDFvY3NFRG82JHsqJmIqYElwJjNjXnQmSzhESUxRckdeIyheSkxm Q3VLQjkzay1Zentpc2hgYEZMagp6I2pwTztwVD1gLVp7R2skV0V7VUpXZElGK2trUzZ4PnFQczBN KkgzZitFMmowLVZCaVU8Y29sPj0wSSooTjQ/OzIKekF7NW9COFJxOHFGdVNtcSl+LUVGJXE+ISVV NyRLV09TIyNpKU0oO1dZUGN1fWR9T2JTWHM7OG1GQjdkXkF5flJkCnp8SD1oQVNJKTclYmRpPHo4 cHteJmVSSi1hPmtrN1QleHdOJHtNdjdRaCszXj1abCpIZSQ1eS1fck5Bby17UThrXwp6TTV3bmp4 JjFId0t8PWVSZ1JpKGdKJU9YPi1VZERvZGViXmpuNEBWUXZrTlRWYmNuQCtjUUFNSjlaY1BON1pk ZXsKejQqaXMrPDBffX5zciM9K0NrNlQpI0VGO2FvUDNGbVElNn1vZVQ8OCVtJF8mSlZCWGdKTT9Z fkZ6d3cwK1EhMlp1CnpXZmBQPit3U3tYXk9hOVk+TmMrSFJuPCQ5SlhAanQxYm5XODBPUylqd2lq PH1lNF95SE5wcWVgdHszKlFANmRoaAp6englRTF5OENUUlBmYiUmSVJ2ajJlRVV0dz4oKkNeVXdu ZUtxZmZFKSEqOC1iaiVjUmZ8TXJMUkpPPkg1anN6I1UKeiE4en49amw8X19vQnUrJXFuJGoxcGBQ TjRVJXJ0ZW0jZFY9SURDMlYrMkteTTRaZn1RM0doYDVecmkpUCVZWiV3Cnp2P144UjQmVHBoWiti ZzdKbiRaN3J7XmR1aFFZcE9AYmt9YCRJeyN6Q0U+fmlfQDYoa3BQIXdiO21JUl4hVGp6WAp6Zj5Y cXRBbmRwNGJfN3lyPmM9dFJvfDhDeTh2TlJlNW9AUEJ5bUFqSWZ9SUNIJkZ5YXd7RnZVM195R0Iy UDcmUUYKel9JJHp1LTlEeCNUSXt7fEFyM3dDMnomMjsyaClZeG5naFI0eHEtPnJFaXxoKVFMcFR3 Ui1VS2dQMjsmV1QoXnZyCnpGX0cqTiNxMFJkR0pkcCNBNj0jIVQlWj9UcGNoPXc2dDBSSDtybjBE dTBRO2Q1M3EwZFZIYFoqRWpwRTA1MTZmQQp6QW1TKD8mbEFmTlQpN2s/O31HUXIpQ2VnKjg/JHp7 Z2plcUZKb3UpdFc5Um1fMUFmNWpIOFgmMUBBS2cyWlR6SXMKekBAV0o1RUhHVmZ2Z2dlWWJMVzVj QUA8JCUwODt+JG9JQlNfeU9ealFxKj1YKiQ9V1R7JURac2c4bEY/WmI7fiVFCnphVTkySnZPdWFC RE1OKHhpRGkjaV5vVD9jQSR2cmtMbHwkKzNvYVBwU2pHPW1fMX17a2ZNNVB1PXkmenNlKGRYaQp6 IVh4aXtIeDM+eUhDIXF+SCQmMXphRTZISTUmUWBreklLWXZ4ZTlLJXFybiVeaikhe0owek88QExy NCskd3MmOCoKelk8IX5XR3Y9NURYNzc4NWBgLU9nNG18S3YlO3hLRSR6e0VBMUc1d05HdU0wekd0 SyliZHNCRkI3MXlidmtWdDk1CnpFRXlzYSZzIz1GbH52IXMhRjRLPlRuRXBzQT1NT0I2KGVRRE1E LT5qKiZ+aVNedWpCMmApQkN9bS15bDF0MTArKgp6LUYqa3xkaU9oVnNwQy1fY3wlOzl4RSFYO1Zh YDBoTyM5cmNjJEY5eD9fNWJZM0g3dyoqUkJjdFlZfjd2XyRBQlUKekMqZk0rKnRLbFhmJSFjKmFA KUg7IVd8I302bmtDSWUza3tpPENLfTdjcTxGN2NlNjB7RnR5U3lUJkUwPGdIa2E8CnpoUXpYbWxw JV4oWXJFNzE3b2o1a3lvIS0zR0N+b2hMWGxwfSZeKFREYTRDNVdudzdtJnljd0YrZ1ojaDBfZX5R Nwp6el42WF9OZ0N4ezxMYComUksjSkE/eGs8eWRKLWlCUXBRSTZjYyFZQmYkdi1zX2BycUk0dU5t bWA9O2cxQ21LSXoKeiFtMFRPZX5QeiFARG0oN2JQcDRHeUklNHBuNGYkKmAoezdOIXNOcXZVUn5j TEJAQSR9MGFoT2dfPSU8YFVASnJsCnp6RVV3IyMpSUlpREUkbSFnaGp8aUZhKyYmJDtucVZfPkQk YFB5RjFjSHc5bHdvb0lCdDY4YEUtXy1uXyhRNU5tVAp6SjUkdndxPHZjbXdobGg8KXZJTklKb3JA JHtLVkYkOFZ+SDZwNXgkcUFMVUp0ZXZiVylHdzlUbit5PTlnNHslYHEKelEhR3JxbGFlPXE1SXYq UyFUXzJCVSZjc3NueT5XRHchcyZ2cmQhfWshd2ZQPil5Qz1MU2NaSzQmcllVYV4hQExECnpLZXln YD5zWU48KGk5aHNZSU0jI2p1YyZSSnFAfWcxbEx+R3RMKyYwenslMXpoSSp4KD0xKkE7LVc7JEMq bWQ5Iwp6X2s4JSUtMVV6NEdpUzVDcWcqRUl3e2gkNHpzdXRFQmg8QF9NNTBZQng8Pk9nJG13K29l cV40e1g/fipCcXJrVWwKemUqaz09b3cxQSZhbT01NmBCZUlhS2x8Q3dqP3NBWVo1JEkqSX1URngq dHFiNylfKEszNyM2JE1QO1ojX3VOd1M2CnoxeF45byhsdmx6RSZ6WXAoKXRCcDtvYiolJWdfNypo aXxgITJeOypmK3YzTGd6c2IkPnBKdXZ3NTMlZUtpdUlLOAp6bEBlcFlBRWZkdllRQ2xFZ1BMeiVG SnEyOHlUdFA0MER1RHI0KURKQnl7fHl5dHRLSHlmZ15FKjA9RzxtPHJ3fGQKejdqYXlXUVJlc3wj U1Z2aCpBNzA9RF94YEoqRGN5bEc9Ry0/ZkFAcCQ8IXZBVGRtTEthcihOZCt7SGZYQDQpNlVYCno3 RiYte185bHFMaE4xWEd0QShaRUFgUikzJXhyZmk2ang5Q2k3NjM9MSpDfWgqSSMlIXtuRFRLIzN6 YFhvRSs0OAp6QykwUXdyUyh4cjlIbnF3bShJRUc2WlA5VFphSClPYSspdWRQQjxtdDNqQDk9KCl7 MXcmeW5UJlBTU25+eyZwRTQKekFMbXlzWit8TU1gSEsmS2ZPbVpBXlc0XiZwXlRNeSt8em5MaHhk Ryp4eWlTc0B3dShfdyZxSjJYWkFuUXs1PFVzCnpmZ2c8bEtPQV8hcnV+RWdCN3p7fipwVzU+bH1k JEFlZSNvOT55NV4wOzhoQWRRWC18IXJASU9lSj1SWUBqKkNSZgp6Tks/TlFzcT5lREZHMHZiQE04 Z3lOUzEzUVpDdnt+dmI/aTQtdilvSDN7YUhZdU44bmxtdVVYT0FLKUZJYEcqe3UKem5BQm1XMHo5 fE0mR1ZuKCo0QDl6TUN8fnY+fXE7VU5+aV8yS0xxez1oYzUrbjZWMTJITnV2NEUzZUVvVnU/eSoh CnplKXlkYWJLaWFVNFFoUjI+eER3OVQ+b2dmT3Q1eUc/JFYxV3JOaCskciFOUC1rZmNXPkFkWnpq RD1oXjdAXj1xIwp6YmgqNmFIczF6K0QtNGtELXBNPENsVTl0czNzYHZZeX1hI0hwWFc5a3tGMis/ X1FpanwhUUcjdTs8Ym9IRlghTTUKekkoJC1eUHxnNTgyITVEN3ppRkh3OElUOFV6NkwpKzI9Zl4t Q0tlSDJ7cnhsUDd5dFI2fEJTQmxKREg+QjIhKEpJCnpqPj5oN3lBbWtUSXM0YmR7JCg3ZWxzYlM/ TWtweH1HTmIoal8mQyptTUhxdW5pWkU5RXRLWXdvcWV+VTVqY1g4aQp6e2E2X1J4Tyh0YGVyWCVq WiMjVnJFNWtSRmduSVdyJFhoPUNfYyt2PSRxRzBudWdSVHp7dCpXa0s4eGQmNVlvQFMKeiRZej9L M1daSmtAaXlaOE9tR1N7S001eVElKmp7UnhwMmtAVX0wZl9rQUN6Y01nP0A9b1JwQDFFKSMpfUlG MTI4CnpEM0NyST1OP0J6NT13VTVGTnROYnlebj5+YFh+a3xCNj93b2ZBaSkyeXRHXzM7TDghKHpo Jl5oSXU4OEoxaSZmQwp6QCFLaWhtWCtrJGI+STs5e0xDK0tjeVMtSzFib2t9YkxaWSk9OVkhZTBn bXBGJHBOM2xgTlE2UkptQnlaKzVBR3kKejl+MColbnJ8blJWaV9UWDs3azhKaX5TI2Nea2RBOyZF WTdDUk1JJkFyb2B4ST5VV2Q/ckVzTGVAak9LVEViVThBCnpxZUB4d01Ab0B1eElfPzMydCRSOFc1 Ul47VzhJZSUpOEpvIWNeNX5RdENVamtXcjZuWmpPSGd6RlFxTTNgMFRRNwp6QmpAJGNQdFM0aSE9 TDdeK3BYLUw9aGl2QV88MFdRYHI4S2xJMGZKS18qMj4rKDkqb2E3aDFtYHF4bURee0ppR3QKeio5 KCZnakVRMndFNjtiKlNwTWZmXkJFMChUMzByOS1UfXZ2eD59VEV7IypmR201bUZ9JnxnMTt0MGJX YWtZUFg9CnozSHx4ZkxyTT9uUkI+ejVscVk3VylUVksmeVAtYVpTRFImSnQ7fHlJMl4xJCRjcSNC KU5BU2w5eiRtWjNreFRRPQp6MGB1PkVsc0NRT3ttaThhOTtkfDNeUGxGSC1HOWZGV3kxcFMjZHo+ QERjajt1RkIkK19zK2c2UEh0cUU7T0lPK2AKelZ1VFZQMTxmZ2sjLXoqaXRjT3k8cTwmK2g2Zz1f R3JTd1piQFc1TW47RE5Vb0NvayhLYnNVKkIza2Fvd1BuSCptCnpoJTJ1P015SzdRKntEITFSWiRh cnNafCFDdjQ9YHlIKlMzcXc/MnBLSFY5T2loJD16bzZaaXBzJiE7bDIqbXFOJQp6T0doS343bUZP ZG91UGZaKlJpeVQ8TDRHUWVpSjYpR24zQEBBTj9IclpNU0d+PmI9fiRgeGh5RFE+bzFfamBJdF4K ekZOKlU9SURCQ2d2Ynd5JWBFJCEkelBRZlhZTF9Tc2lBNzh0WWFha1o8Qmx0RlU1UShRZElNVD5D MXd7fkNSOzlGCnpgTH4oKHxMSVNEbDlLMFR6YEskKFlsRmdaZ28qaWRIO19hantkSCNjLU4oJVNI JkxDcTBhMk1seClzOChMTF5FPQp6UUE4Ql9na2N2eV5hO1dxVlgjNXkybHpvaTVRZ30xaUcycWV7 UDFXLXtie2VeX1B7XjZScSNnJTA2REx9b1U3fDYKenJRTyoqSCoodHRLZnl0fXQ2LXZmR2wlemxV V2E8M1M3YEljZGkkSGlgRWU5Kj5DITUlb3hJRzZTMSstJCt9NFF9CnpNMyEodDdGXjRMPihAPzU/ ViFiaXZuUkNrKkpgISsqdkVjRytqI3tKTFRrT20oN2puITszJVpmMDY4K0lSRj4/egp6XkUxUmso ZUpocUted3BDNlojIyhBUnJQVVZIXit6NW02aXZgYTAoamdjfCVINERrYnhgUTErMSlxfnsrPTxB KU0KemVYSGQ/LWlpUiZwMSpEVFhXI1ZeP3pxalFjbVhRakc8VitjJWdqeF9Pfj82YC03bG5sR0x4 e0NJUkUmdWJHJkB5Cno5NEMlbExNRXh6MHIySFd6PXk5RFFZbGAzcF9faWA0fUl7Yio/OzMrVzlP MzxmaHEmdT1wajtRQ291NT1Qe2lSSAp6ZVpOUCkpMkg5ezM4Um9PajBpLUomPH1+QE5JJlE2YX1i N3ZRQUZTZVNgWSVrJXg8Vz1RfXBCdDQoQGlxfExXQyUKelVuQnRlcDF5cGdGQTRwbz98WD4qS0or UX1XXmVTXktsPjwpdHclS05ydjtsVyNRNmk+eyYxWHM7b0s1V2VEN3Q+CnpvbW5RMTwxSzNZQ1BF PDxOKHFqPyp2a3EoZV9LMCREM2hAUDFISn05TnJ+Z2NBUHBPc14jSEw1PjkpSntgaEVKewp6SzB5 Pns0VWNASEFSdmxFcTk3KVdxRXMtI0M/ZTx2Z21GTCteYS1OPyRBajZLNSp5MSZ6ck1PSXZ+TXFZ RHtWdmoKeik2U2xIbFJmWUhDPGk+Tm5QYWtrRCtoTGNuekE+a3dTUDtSVXF0Jl5vWms9bntQNnAp QFo4ZlVpSn58UWlNRmxuCnpJbjlAdlVONDtzMm1eZ3s0PEEwbmQqMXpVbik9bmlnS3x1Tm4yY343 ck9rcT9LblpYSnVeLVdDY2okS2VeIWsxTAp6dSNleUc1az9fVm9NP1Fje2VVPG9pfl88U0NpRFpz RmQmVGpnclFGcWdAbHBBe0cjQzB2ZWMyJilAYzh2MGVzdXcKej1MS04xWUczMDBQdjhHQWNScHlm YWR+Yz9UWCs5bVd9NWRCI3B9YSVLa3g5Rnc1K3JveT9rTms7LXpLMntmKzBqCnphQmp1WVhpPWN5 K3RHWkxVUTRBb0A+SGglcFpmVUVRTFU3PGxWe1N0TipkMiE+Z09DTVNzKXlQNUpYVyNyYEBJNwp6 P2I3d1RibypVYHpOWWpyNDJaKG0wM1EpWEY8fXJBYDV8RXg1SmRyRCsjP0Q/IVowOT9CTz5XQ3p1 U2N1RzJwV20KekBEczRONEwrYnNCTnsjT15xPClPc2ZpWVEtfU5FKCpffUxkbFcke2pgVm5IJDla bWJUeDFaRGV5dGpZaSNDZzg/CnpfMis0fnlUaE9rMEp+akEmXmRmMUJ+YygpVGFFIyFSO3pzYzwz Rm95emhoYHVOKTVkMnszU35aVj9oKnp2XnlPLQp6b3RfNTIpNVpeY3tKX3QmSmBNP15tPyNXUUJv R3FDOHZIMnEzSF5YclhyX3B4bV5oWn4rNyhsd01vZlMrcDd1fVYKekd7MylIQEJ2eGNoVzlAS3dD O1V+THc1SkI9UVRNbnw0SGlRI2dYOz1MQ3I3ZDxkTEVBMnx8dF5KSWBQSWBCUXtaCnpJQmVzdU4l S3x1eWl8KFVqc0B3TGUoejdjaV5JMWMpTzRSfXl2KlclQnNlaTlyJU08SHcwbXRqLTUlfSEyRTkm Pwp6VWY7Kj5gQzl2PGchV19OQz9YNjM7eTVxQDsxaD0tUTUwKE0hO259K2gmVjxfTDgoP3xzIT9M OCpHSiohIU18dzAKektWQ3JsJD5ERG1lNDdFQjUheWVIe0hhdSNkKn43TitQKFJeQ2Z+dXIpSHto cGQtRktJJGw8ZHhlOC1RUzwxZkRVCnp2O2tpaGZXSX0oRk97S0djNXBxe187Vjg5U0h6KXF7IW9l JkZadDxSe29MbjF0cVZWaV5KbnQ+OGhCSHlsQGdSNwp6Mm0oNiY0all7Zkl2WldPeSlOQk9rR303 bGtTLXdmVzg/VG0jNm9MKUVWS1pgVk1yX147d1ZKS2s8TTRoKmM3SD4Kemw7Yml6Nkw3S0RCV0Ik T3t9UytMI0BwfWoxby0pYFY1Z3dOKkxEQ1c1OHV5aSQpWEtxR0pnQUpLVDY0KXUtZHJCCnokTjdu YW10XnBnJEVRd1I7NkZYfjN9Rn0hWXI0dTZrOCo8R0lFc2I2Umk8VzJPdHVgRlF4NFN6bHU4bVEx KDZXNgp6KjgrT0luNj40SVNEeD9EPnU0dSQtQGQqNF5kcy1kPzdTOzhKMT4qOFp3Q0hHZX50RWZo ZmNSY3JgeDY1SHFNXygKej0hOE0yOVk4LU1tSH4wPjY5cGtjTGAwRTMkOG40aHJXekAtbHJ+Ylp5 ZEtiVlIpfWZhOzlteTUyQXN+PmBtVktyCnp3UW50TS00Z2hEQUhXJldAUjljU3p2PURWVjBaUytQ ZHZjRjxpaU5qK2c2O1B4QXt2O3ROZj9PcDF9YC01I1Nmbwp6elQrd20tUEwwTSV7My14VHdHNzJS WHtDKDNaV0Y5UkZ0Yk9FJE9qKUFOPXZaJUFDS3VANGxEbSkpWSNgbmJ1PjwKemI7OF4/TS1ZU284 fnFKNyo0bExZOVhqblVvbGMpX3VTZGBLQCV4KG9xYWFFKEs4Xno3Q15EZGoyd3tNYSV7PnRNCnot dF93Y3JfUWMoP0JwOGZGTGU9T1ZCT2o+QEQxUk1XIXBQRDBsdil1Y0B0MntGK2cpK0ZaJipONTN9 fmF3JE9Tdgp6bz53MiNAVEFtUTVhJDxwYCQ2Uk0/WjE0MVpuci1NezZRMW9kWGZXJkNPTGYxQitW JSZFJkZFUj5tMHZPeClWbzgKemt1cGRXMn5IamopNTFAYC17KVVeQGhranl8THZuN0xKaHBwX3sw U0NnQVNjYE0+fkQoRjZ+YTJQT25TMStvIyo8CnpZMz1VXmdwcDRlYE5VREUwZ29idGo4ZnBXd3U+ fGh4X0RgV215ZlMtPmcpIWNaZDg8elRMSnpHSUIoNF49diF4LQp6X0ppJCRwOXNMWEBHbGpCTC0o PTJISypJVmtgKzQoUXg2d3R6OEQkajd4bk54XlRYcXVkRnskM254QkNgSENeSU8Kelo9WWsmek4h KFpKb3YoWnVpTFI/IVd2UV9neTR5OVdTUEl8PjFuRmZEdTRXeUZWcEZDYElVZTROci0kNnpBSTNL CnpffXhEM3RfRlQlcWZOV3ByUEorY0A0d3JsLX1VaT45em9kR25qaChgcDlXa1k7P1JKdSpEPFdH X2M/aUhsfislIQp6YVBlfXRGYiFMLTU9UXw/amk8a3E4KURKN0pwTSF3IW05eTQmajMhJntAV3A3 XlJCbkQlVTtKWko4P2c/KHlzQXcKemUhaUsqVENwUWwlO2loVkpvJmAyRXp8ejRKeWpsaCZqTzdK R0olcSZAblp6fChnO3YyXzIpaElobmEyTnk/WnlsCno/LVBiMFU7ZXs/JE5Lc1B6eEohWTA4eE08 IXRlRUhfdTh+S3kwcUl9K1Q5TkFQRVdgRnkmaz04ND9vYX1wQ31Icgp6dChPYDIlRnVpKVYkUG1q PExIU2lvSTB+YzVRcmhyc3x+cE1QU3xAM0VNRnBjX00zRjlzVjIhWmxsJVkrVGwxc3MKemZeUTJ6 S0speV5td0MtRHV6MWhnR1VwRnF1SzU7UnIjeDcpJkJ5dXErPHZafXxJYCE1M0J6Y0YhIzQ+Mj9p KkA2Cnp7UWxqUCVGNUZHeFBiUEJYKHF7TlVyMWZsSWRkWjU7dSMoTG0mO3tadHJvdVQ8Tkg0U2V4 SEIpQEJSLX5TSndDIQp6fE5HeWt6ckkzZXFzdkM4TCVaRmgpOXVwa15re0UlPXlwNEYrZzx1V21t dShVIU4pand5NGdmODhEQ2xOYU99aHQKelVPbG5HKG5AYlE8PzZ1Vk98YmhXbXxsUU40YXliUitv MW1IUSM1KVREUU5pX01xekg4alhsLU9zI0F7I3pzTGxYCnozZkE9M1ojdS1ISilFSWhuckVoWUZF fW56MjN3RXd0LXtXITZCanNue0wqbFMmalFaWXtDN09Fbl5JWDB3MGFmTwp6e3hKQVROYCNYOSFT OElPVXdtZH1oQiVIMWYma3o1YnZDY3Q8eklnQjMjX2lKQHJCPzFNY1VteT9UIUp5LThOeGcKemhp PFAhLWBDbjdebkQlMjh9UipwJGY+aS15bk81dXJfWmV1JDh6WVYqQlk+UjBPc35XcjN6Jk9lNURI SUR3THxZCnpiOTxPSDArNHY3X0RteiYtc2QlYyVpIWspVkJ7IzVnTGg9ajl3P1pzLTlwKUduSz9M SGtNazJJaEAqaHgkMVZ+QAp6KFFySlUxSFVvaEAhLTM1UUs+NGMrc0ZQcFYhK3soKV9ZQC1eI2Vx NCUhd25KcWN0QChNWmUhcXdaR0hwKENLdGcKek83VncoXmwjWWNaMTdNMUBxYV5tTHB5KW5qVnw0 OG57SSFEZXlALTNfWHpAPiUheChGI2Z4aGtKJDlMNkN6c2YwCnpgQGBLZTlfK3BtVyo0RGEyaUZD IXE+b1piM3FhV2pMI1lEMFplWmZmJWpzeFpuS0sya1ckJlpoNDh0dmhad28qXgp6MntiVWg+KmhP e3ZPbFU+eSVFbz9yMykqITY2YUBhVG9HJlFaQypXa0s0PDZFUEBNMCRsS2JEamktez5HclR3Z2kK ekZ2ajZhWGtTU3I1LUJCNWVKY1p7UjslSDxGMT1vbGUhb3d6KkdzYHFlIWxrRFNMayore0t+S1Y0 U0wtVHF4QnY5CnpvfXY5UHB4eTI4QH5hbSlgcFBCRlVSWG9RO2R8WWZnZDEqd3NYMHlnaiFgJCkx LUdPUnVMTkVoeWg8aHJpI0pvWgp6VEp3dEw4YF97Pjc1R0pBcHFGM2dLUStWTHQjPmhEWGE2UV54 OGdiI1YlZ25Ob1MkRUBiTW58RlpUcEF2YC01QCoKejRMOD09Y2M1LVFYTER+fkQoJnxPKDw+bTUy cUUhJWY8T0h+R21wRjNZXkp0OXE1aCh1WisrKUsoJj1wUWBHND5wCnp7OWM+RD8tN0pPai1SXjNi SStnUSlzdlUkYmMzUHlSalAqS19oPitJRWJ6X1VjM2tqMEBHTDxubTdyd0l6fXx5Mgp6OGswPSsr OV5aSjVweGMmOHZIeTE8ajFzQGZ5KD9JWDY8UVFqbWxvQzwje3VsQXM3RlRTZ1YmVD9VcEpjN0xt NjcKek4oXldERWElVEYhK2o2VlNadU82P1NvNztVbnM1bEt+TTFiVj9MYCgrN2BSNk9TeFI4K3dH Pj5La256cnJAek48Cnp7JGBpSV58Mz1ke3A+M3xefkBSMFVzXjRFWkw8WTg5ZnFtZCUqbiR3SGEw ZnstRXAqOGE5cXM+aiRAZD5nUio3PQp6dz44Z1h1UlhBX210dUlAeGgoK08wKUpFPHohcmU9IWRf YlRDcjtGRSNkR1VmTkxRciF4aSY2b180OyslVTZ3OXkKempNYVJGPGk+LU9HJHgkX1otNDh3P3tA YEhlSmtMRkMmRWxTRTB4c28+LVlPeHg9QW0rQCpLYlpUUTNzRiF7Si0wCno0M2plcyY2Wi19MkJA MipncFFsaHlgdy1tOFB6SEA9czRoKjhSeUFrJmpZOFZ7ZWFka0NONypEbnROT3smUiFQRwp6IUQ3 MSVQJCZldV9HR1F6TzJJXytDT28lX2tVe1loP2NBIX1lQ3pnd15ERFohIXY/KmV1KFIoI0V6S3M1 aX1SRCQKejdsSHJ1Y0xKNiMzckBXcFhVPj9oe1hyMEhZaEFuenpUPzI7M15iLTNEJUU2PnNJRDI2 JHtQSEV7KDZVakt+KEE1CnpRcFp8dTsyMDJHVi1fNWtTKWpyMip4VVUwcV5reCQ/KnJyflpoSnMh WmpyaEAwaXxCcWdHKShBMEdrWUZDfGIwIQp6eTN7VFZfM1klJilVP09zdFVFVG5KRk5LJVgtcSlT N2QtUDwwWlckenRDc35xVSF+eTNhWkRKN1MyWSEqVCFyYSoKemh4JWomdGRxX0wmfj45eSNpRHJ3 dTJMRyVXVXBTTzFgJX0zVUBHWmt7KDxYM1lrP1pZKTZibyZyVGxSd2ZDMiZWCnpXKjRhMU9XfHRl Y15zI2xJZCZ1QntOamIwQTxONnt2NmA9eFdPYFNQVDN2ME1fSnRKcVVDQzQ1KXwjKVI7KU5kJAp6 PUdlQ2plel5rczQ+e0IpcHRxcl5Kb1YpKUBEbkJSYXZjXio4VX5PV1JBcHVtK1IjWjtaTUp0S2E5 bygwck5aenwKekQ3TV5PXkgxSWYkWnlvKHdQdiZZS1QzRTBJKngtPjtoNCFCQmJJQiltYD1PRFgq MClFJWlSTF9hcz5GazI0NSl4CnpVKCNPOXEqcUcwPHJ+d1FnRnxuMm5BeFQ4dyUtQjJYV3gzMjAt d0A2bkU7czlMTEFvcz9pdjxWbUl8d14rTUZ+WAp6RGEkLWUlJXVBdzxjRHBLKzdeZWFIMzNCbkxS YFJgWHImRlJYMzFDMEVSRzJXRz1KPWg5VF81KFV9ZD4meF9VPTkKemIyeUhvK0YpenhVQ1pWTntt a1lvc29UMCVGM1dBKmpPRypeeTVDeyVMOEdsUTE1ITBMeFhDJn0kMGxNY1VFe2kkCnpvbHBCcVkj K2U5RT9zMVZVUio0YV81KDkmTklCNWRFMzlxKmpHWTMwbG5LYk0zIzhHK3Z2VUJoUWBSP3FPcWAj Qgp6WnlwTzEwIUMzX2B1UnQ8YWd7MWlwSyEqK2A3KHwzWlNiR15tYlVyMl4tSkh+bk8kNEVQWWU2 dHQ/elNiJV8mND0KekQjRWQwV1NNRVVTMylPeSlMPllyUjBmYVpXPHNHMV8pPXdgZyo1S0YwbyVv eDBGangzV0YkZVFrP3c9ITZ3clE9CnpYfUJmXiRiO195UE5rfjlUQ3pxYD1IbVdBK1J2fW1PRlZk VU87UjQjS28rdXFRZjZKZjhYTTtpZ25IaXwpY2oteQp6UHFfLVctMGdBdmgyaWpSYXQwcHlwdV4y fkkhRm1vVkVSOUZDI0tlOUhGJnRMTERCfFVXIV5raXJjYTdvO0k2VlkKenJEbk9KQ0pte0RDVFR1 TzR5cFoqdD9ZKXpQNzEqQUtyOVA8MXdedXxTRklGSTxCRXJEek8/Kj1xK2J2bF5kVWgyCnpzcXtk RnRpTkQlb1MmIXRkXzs4Zm9lcTAlRV4rcFJXY2BYX2F1KChuOWoxNH5qZldnY1drblJ+UkJWRHw7 P2J2cgp6cW18WnQqUndSZjJ6PGk7TnxAQjAlNzlQN3dgeyZqeiZEeU4/M0hNVypYNV5GZmNKcGxo Q1peXnopT0ErI1QkNVQKejY+dGpVezAjZy07SEE9YWFYbn5aZURgaH5DbkhyeCRON29QQUViVEsm cSVJT1BebF5vLTBtUTZiQzYwUTFAemkqCno+XmE1M3lQO1ozZ2peZTckMmVvak5ebmhtQ1lfc3JZ fXROV0xGfXBIaTRVTkpicngyZXEzJUxRZFlTIUNkPDNOKwp6M0pkb3grKT5lUjhORX1jMF9iJVo9 dWl1eVduJFNNcnVxVyNsUzMlfFQoenEyPmJNWHYybjQ7WnNVb0pEOX1qQHYKekA1VmcmTyQmVCRk fFQjaHNubFcxekZfOHBKMyFEXjlEaVFuYGB+Iz43aUspbzJDaXFXT0lxX35uQXZ6YGVhMWpzCnpY Nn5reGdXd0JHMiF0PldwS2JHSDxgZFhSMVUqQyVDSXhCWFlaOEU+NEA/VVc/RzBsNDRnS2Z9dkZI dTxgQn5uNgp6az4pMlhRSig8VTluLWdPcDZobjklM3FxPk1fPjI1QHUxRE92XzA5c1YrajFAZExW NG0rOCpAYipmV2EwOV8qPFAKelE+YngwcktAJT4xaWw1ZCF8PEwzPT1VVW0zWldnelIwdTVLKGB5 XzJvRzBjMHleVm89Myp9Q01LOGdXfmNGcSoqCnolUzUoPl98YXR8KCo7fTw9TVFNVChSP1loRFA4 cG13fEtkaGt8fXJfWWpMNSY3eFpNSSV9KVNWaEtIMz1DNiF6bwp6O1RVamU/QnF9WUN0bEVfO1Q8 PFEpSWRKSi14Oz5+JUpMQnNkdjVvWE4pdGB3ITVeXnNSX056QVNxKHR9byVOd3cKenpyRSstanRE fkQxUHFsTlNGYUcqeDJ6am4mYFpGRTt7MTRVQnVqcFRpPCNJcElwcjMze0BHKHR0U3Y9IStSKl5g CnprdVVoYFp9XihfMmZUZmkwP3ZUX0NsZG1QO1Q8UWUxUCtlWUBEdEMyLV87cER5TFJzWS1GN2Fn WmAqdk0hTERiKAp6aldZJWlSKX1YYEMlITszaCRJMnViK1R4cHleYCklODBXeT5hVDhGcXFveDRq ckhsMEtWbykhPHAhKSFsSU54WiMKek5YTjFudXlkTjkpYm5SfGQmOUprd1I4KX4jIytxVVFqfihQ bHBxUWVCM2FnTFRYbSZ8Wk4zRHJ0aG5WS2hpMSF+Cno8Z1V+cDNGTTQ7KDEjTipzQzF1ejxUYWZR RWZ+cUltJHs7QjY0I2Y/IXtDZTk5RWxMYmdEaGFEZW0kIV40NncwOAp6em83WlUtcSgxP09uQHdD SiZKK28kXnwtaEZ7bUcyQiNoUUFDb2RralJ6dE9XSik5fEZoVXF5TSpIZVg+an1aaXYKejtgRTct U1MwZ3g3MWFzRm47JE9HK1FsSGY9ZlBMdG1LQkhKOyY4KlFhS35GNllLX2NDTk8oPjtuS05nemdX cmJ9CnomcTEkfkMyIVczQWRVeVV7REhYTUZoSUY3VWhgQUNaITx0cjJ7WipEKkdrUTtVWnp2Zj5S cl9RdjEyfkswUWYrMwp6PHM5cEZGLVM+Q0ZUN3xSS3sxJjYmMXQ/cHM4TmAqWm4+KE0rZyUjKTBr VkRmNV9fI1VlPTFfX057b2BhJUJPXisKeih1RGlvO25BOU5oTWQweWU4KkdWQHFva0o5KH1WTGxX XkFxeClDJGszYCFOMVJVRE9MMDxIQ2Q0e01oI1RSJFNNCnpfZ3ROTGt8VlN8MFk4bFprfSMwMEo8 S2EqZzVXcj9jOFBWWDV3dTdNKUpgJmhDPWheZj1eYHVydF9lcH07c2BEZwp6bk1rMTY9RXJGcFNL N3tIdHMzNVFWPnpZJGJvenpgZSk5WSkmeFdTNk1+e1g4TVhlNVpLamJuc1lpWWhZZHU2ISQKelo0 UHNiPjN8UVVQJjZqdEBMVG5JTEEjS2U8QChoQ3hGYHNFYVBtZENfP21WUyg+VDJWZD9sZSRIK3Yw ajEkO35VCnpaVGZlO09iRWdOdjlgcEBuNGJSflYqbTwtQVlGO2xVU3MqaE9MWGs1KiEqeVhTYWIk QDBtZl43Q0xsdF8lckNsQgp6PiRjfDAwcX5YYXN4Rl9gJV5iO0dVTTJLZXp4bzgrYCVhSWt4bEhy REdUaVkxJTxPaXVJOSV4OE51VipJeGMkdyMKekJpRSsjZnB7KkwjT1pmbzwtK0ZSRTJScmJUaDt2 SnoqR3g4dDEmY2I2Rll5NVBIIVhLJWBfYSp7a3grK2ZWOUIzCno3YXt+RmtGYTRvZn12USlrQ3FU SitDPWw/MG5KWn1JUTBvdysrUH0/ZU8rTFpEZm9JT2tLKXptQX5zZWVPNlp8Wgp6cGh2dF5ZS25X Xz9sTHYyLVNvcTZoMXVQWDl7Knk0dVJ6M2xPbHk0LTQhemxBe3UwZiViTVJefkJiUzFfM0hYKG8K emFSOWZWYDIpQCRTJGxZP1Z6akBjPkhwI2grUFRHXmt0R0I+NzdFJXZLej51QFdhV3V9PlNkTjBh RFhJant8ckw8CnoqKVptYEo4MDE2Q3NuPH5wXzU3dlUlMnRNR0Z+Wjlgd1cxdVA9dm5YJFAqRiRv LX1EKFckT0JoWUU1aFhvOFJMdwp6eDBuTXpOeXgtMTF5KU0hMyozNGlSQkQ1P0tMRWJtSWB+UyQj Qj5KcXJyX0pvcFJ4QnxTcyRnYzRnKHpyJll4ZzgKeng3SSVAU29YRSFQR0Q+O0l0WUAqaF5MUW5h YnE+aDJyOGYtVUxxM1JiZiQwSyt0MkZ4Vz1vY0lxYkQ4S1AwaGxkCno4JXFOPUtOV150b1dGOEte NmQ5d2Z9VHQjYzxRTyFsND03Y3Jxdk1tTGFISX42OTgmVyNWdlIxX1UlSD1TNmNfYQp6UXJGSmtS eTk5T2BJM1FPSHRQWjBsNVBfMWIlLXlXPUF5T2lKSUYtP0pMJntkVkUrPmE9bVkpTCVVcGMldVVX SXgKekQxbGd+N2hLR0MtNVIwIW4pVX1CIU5lNVljMys4N1NxOyZDUUpsWVdRUyNLY1c3YnlgTE1Z MnxRLWR9PypeRUlACnoyKTtER3QyTj1+eVkpKCh0RCpnKilvWT9QP0VILWFLa2ZLWVNzUW8pekV7 P2Q5Uz1edXoqPjdiNkBZJCQyQHR0dgp6Jj5lOUNSUklHZVRjfiVCS0U7KVJRbFNZNDZOa152YHd3 ZT1hWHI3PFAja2A5c1N5MDRJRGNiQkAkQCQoPVRBeEUKeipucFY+LUBlZlU7TDhtQkJzUTxzO3BW JXY0Y3sqS05yK2psWlYmdlZpcypXcF4zN1U2RWQoWTRjPGwmRlcoWSh0Cnp3Km9sOU5BMHV8c0Il dFZYeFgxMCZeYDc3WFYjYUE+e05PYHlvP18lVE1aIypYXyhQYHhrKWBBQ0FyfiUkRjNXawp6QCEo cj1laSRmQHs2TypJNDx4SHNhXkFqfiVVYEpaVmkwXzN3UDk2aStYby0/YD9kPGN2XzlXKWpMb207 JiMyVGcKekMkUUhoSXtQd2J0TysxX0tWVjFtMEE4KmVDfE1LVzx5USN6K1BMJDMqbmk7bVkmNUo/ NjMxflZkczlRU0ZMVWVzCnppb2pQPXA8R0Y4LXI+cHhLXlFQTCE8WGpZZiRqIWVKYDBeU2deVjIy KDRqYHR6UmJYbkJVcnR4LSskcVI/KUtkZAp6X3twezNHaX41JTZZeGQkemRNZThQcHRgIURlWFd1 VDJQPFJaMUI8I1NVJlB5byY+SS0kSFN9dlpObXNRNllQaXkKekRDS2Z1YEMkYjFHPlhvMS17YWk3 fDcmKko1a1c3eUxadmlLJCpyZmZLTTF9XjBuYyojR1JeUXdzaS15LWNmWU5+CnpsaXYmcHs5P15k cyhtU3FEaUQkNEApQHslU35ycmBDLW1+SFQycnNIKHsqQGw4b35mTj5wSTJUUzx7SWc1cFUxbwp6 bGV1ZGxiZT4+cCZnJCRiME4+VnAqVWhORVQ4QnlfM25OXypqejcmZzFHcWkmRlVVbSFKNX48UDNx VT4rTks4Tm4Kelh1dFgjdVJpeUU0JSkqYWxuQ2pFbXVYaF80cnNwSno/c3paWk94WlJxJWZOQHBs SHApVEBRTFpfcX5gWEVZTiZxCnopJUZYcmNmRjNUKmoraHE2PXs7ISRsU29NYWlRTjkhQjRKWjBq cm1Fa0Q9WShtR31JVVcpamFWMElrLWMrU0tRQQp6Umh4djkmI2B2cUQ2ZCk/LT9Rakg5fDVxX1BH Q002bCFQQ04wQmw0NyVUTjkjPWdGMVRnSj1+JFRGO2h2azcoZGIKel9USjBEJm9YPmNEZHpTJS0y SVNDeGpOX3pEOF9AWTgxfnxZTWYoRzdTWFRARjd5KmhTU1grWTc5fGt9NXsxZUJvCnpxN3pab3Jl PjtZLUdxUTF5en5QdSMzOVNUaDl2LWojUV55djVJZ015STNyZElyfmJnfEdWY0R7KmdMO1MpJUZE eAp6TGEhTnNrcSUhVGR9VmV9NmlIMSREcnlzbz0+Pjw/RD4/fUBQPE9ZJW14REVWbUN4O3UxTiY7 Z0FOM2o1YkxERE0KemU7NVFtcTVnNk9ZUXtgVyZUOUsjcFZZYTh2b0V2cGdGb2xWSU9HZ15Gd31+ JXxEQnV9eEdvR3BLfEBIQzNrQlEyCnpNc0lgai1+VyVDd1JfP2Y1WE5uU1hpYkIhMkspQXRsSXtU UThgT2xBLWomOSZtfXRUTT97YippPi1AO1VQcmw8Zwp6QFJPekN1RGVPaFUpN24mYGgtNUpPYFZL I0okVWhQJmlOaEE4fGBvQkxjcGs/QSV2WX4wR2tReXJBWWFxNXRXcm8KeiRifW5OVClkSWBLJG9K NWFvalF2dTMwdS10b2V5NDd5d0A7KkJWNX0pZUFQZmw2S25TPT1COTNVfThvV2Q0aXNICnpfKHA8 MVdweDl8Zj9CXyk5bGlSYio4MGc9P0s5TFR2O1o3YG1lblZ8I3VGbXVZPVFQQ2YpSEh+QUhYWEIt eDt4OQp6RmRaTmpONFMyVXNyJW99cVUmYVRITnZkcmNidC0wYChgRnxadnd0ajhUZUFsUjB5UG0k IVVreXlzNkgkNEdgQkUKentRODlVP0NWWUt4Um9scEh6MSRSYjtnME9FYnl6Xi1aIVVWYSF3MENW QGxoOXVZfiZjQTh+Wn45NTAmQz8rVU9BCnp0WHEqbGNzOy0kI1E/VD5DPmtBODF9YXoxKTM0TjZ4 YUJUQUtQYyZ8NUsxU2lUJkhCYmFBYEpaJFhkNVlYP35LPQp6UHQme1J4cEQ8JjdLfFg2OUtabCpZ TG1qdzdRd0dLXnwtY1hPTXttcmN+RkJ3dSZMJS14JkNyaCZqNCg7d0FOMTwKeitoM2N8dG5sUjV4 JHh7YV8lMz1MQFJiN1g1M1pOP2syMyt6Q1FoTFRsdmw2ZD9aMV9VPT47bHd6a3JTZWJsZngwCnpf YjB8X3pEanJWdSkpdCgoa016NW5CRTJSSHxQY21vcEAyMFdkcXY9S1dXNjZuMTxRaUk8QFAxI2Y2 PXU9T0Ywbwp6X2NtTU8hQjNjQFQ4SHxTcTVVflN7Z1laS0V9ZiREeXw0MDJ6ciN1TkgxSzdre1Ry YGBfS3k+UWFnbCoqU2ZKRzEKekFvaERxelVnNmhXQSlyaVclaiZQNG89ZDdCTTBtR2RDZ0MmYz9J Qy0pNFByLSFwIWVnd0MxMk9wXkd8fCtUaUZsCnp1VlQoK0drZUVxVzM4ZD5kdXQ5X15FeGJwJX1j c1Q/fC0+RTh2SkJRYyZUaV9wVldWQSVBKT5TTDt3QztmNWdqWQp6VSo7TDN7WXlwd1kkd3B4e19D PD5ZQDcpZz1NTi05Q0IyS00+RWJlZityNnt+Uy0+T345VmNCNXR5MGFHPT8jfXMKelRBSGRoMXdX dE9iekwxc08teVU7WVJ5QXltdTg5dDtIbFkrZEsyJXZUc0RoMTxFXilHTnMrYU40LX1wWHpefkxh CnpxZkFVXjs1VTwkWnctRiU9YlV9IXxLb0E9NGpAO0kwSVhUcz9fWkRIfDVnUlMkXkVlK0t9Z05R ckwpQVg4UnF4Zwp6T2U0UzRQenNUKHJaPik7dkB+NUJOKjw8dEE9SlBVc3xAX1gxVyYlT0dZVVhx MTY8SXp6dHd1YW9tNDhNe2olbHAKejg9RjVscnlhb2hyMmdIalBxT2xafEEpVmhkfHREX1UkcWlJ Y0pAIX5ibShfQTQzR35HMkx2SlA2RTkhSFRSZ3pyCnpeZ05ZKCRGMjRPdGM4PXBXQ1hWaktJNmZV MyFkS3V7UVFhPzVmM2xtQ2Aje2MyN2E/O219a3h1ZD92TD94Tzlybgp6Y21JVXZSeGZlWHFXOzl8 QUM+ZWBXQmZEY2RJPjxgej0jbi07Y2wkYlRVKC1iKTl1VlFyemtvM3JOJkJTVl5OWmoKejRMZXRf dVNiR2tQfHEmfWYxOD49dTVaNms9KitTJnlRPz0lQHojZkZlX31lYmB8VU0/P3xnLSQ9VShBaTM7 WklsCnpLUTN0ZGF6K1JOKkNHKCE3UXI5SzRyI2MhZTFaMUhEdmV3MlZ6eUd4aEQjPlhHP0kyTXJK Ujk2TyVsZkMpMj5DRwp6SmZrI3h5UENnVSs4K1NsbiZYbz9tLVFec2xXUDhxaVQ0ezJgbyFQKVZ+ IW5yaVlHXkNlcDJfKF94P0t0P0NXZW4KekZ9RVpQLVdDUEwrM05ZeVkxVEpaWTJJPVZHdiNXUVlG MVctRWA1dXwwKlFVazReMWtuPWZCPUlLa2VrVCpZVFAzCnpacEIwdl4obzhTcFVYN0EodHRRZGVD SSFLOy0mQkwhPF5QezZqYzFnQ0p+c00laDhNejJzUlQwWnlSaDtHXmpBWQp6ejZPOGByJndLSXJn OEhmT2pxbDhObWZpKih2VmoxbEghVFZoaytMRFRkUW1mSFVEfm9GU0IoNWlMSDB0dGVkQ1MKeiUh KWd5eDFaU2oyMUd2YmNtOVl8RkZ3eEdSLUNfWExjSm47WiUrZldeRGJXUWNgcWpqd3FUNDQ+OTJf YSN7Q1NHCnoxdW1Sb1clVi1FeSQ1TUVyem9YTXN+eCl1UUROcGc0PHV9b3RAfjZHNCheY1ZaYGF7 ZEh0PCN0ZjRNUzlgSTlweQp6KFVYTEZyb3pgKkJtQXFjQFk8MkBAX2YkQT9eKWVGQkcteytYSSUz fiR2UDZAJGNOYFBZWkwrUlRyQzVQMCk1b2YKejNVJW87dDU/b1puJVR8TiVxfEByNnNePSYjeEY+ NjEzRmA7dlRvYWk2fjt2WVJ7e1F6WFA+Vk5rZ2VOS2ZVbmR8CnpOIVBTPFAwcEU2Jm0/KTBJUkRD TmByck0oSVA9UHJ5a2Y9bkhyPFB5I3dXbTV1fTFZPE41dn0walNgNEY2RjhmaAp6MGBENVpGOVAw UHkoKlY0dXpMUER2ZjV4YCZyTE0hNn1lODQ8KzU3N2hONktIO294P2A5fTRBKU16bEVEcT56Tn0K enQ0JlNxJjZjK0pOb3FIIz4oPzRrcz08azs+M3JgYEllWXFPeTNiJFYocy0ydi1yayVlKns3KlN3 cT45RmR8bl9iCnpJWUlENzJtKDlkMThrS0lscUtCKWtuTDRBUFE2NFlATSM+bGkmaT41SnFMYV5m fGJFMFAmcXRzJCojPGFUPkYoUQp6bjhxPkdvdHB6YVp7dzVZVDl2eENeTDM7MyZGUEhwQ3lrZTFu PXFCVjNPeEIydG9gOHM9SXFqV21LZmFBTV9TKzMKei1rWl9ocFJxQ0dzT09HYTBXOyhVVlZvSUF7 a0UkU2ZQOUcwMjw7eWpINTI7dVBRMVh5JWN0PkxeRTlYRHNue2d0CnpzTFo9b3d0eChuaVEhfFEq SDBFV2FINjE0QnkqbVRZaVlhSHUkY2hnbjl7WH1pSjQ1fW5ATCledUd3TWY5TVIpewp6IXBhWEg8 OXlKa1NDR1RFb3dfUXlVRCsoS283UzthTENDV34tWDlwci1sZVA1YmpPbkR4V0ZHNndiO351ez00 YFcKelUqcXl5QUt7TDd7dFNDdlB0Uk8teXpFfnNrJlJycD1qTm5gSjI7P09OcE12Km5iWkUtMU1m LWhpYW4tMVMpeSViCnpfan5xb3QhbWJ7VXVsPnwmYmxjKW5NT3w2Zz1mQSs/fWN4JWFycmJHV1RQ WSNwZElWRlhwZikjXmJjOV55T2BsVQp6ZzlhQXhHUTZjKy0hY2kjO0tGIWheM3xgITFVTGxAa1om KzhvSUI4S3Z2S1RNJll3TW9Ed25BKT81Rk5uXlU3MU8KelRuJm5BeikyUVV5MCViUXVYbjhaSXRp V0l1ZCVoZldOcCU5WWtQZ3RQYCNvMWlJKG8kWiUhRkktXyZOSVJEc3V5Cno1ZEdEaygqNUNNdGFz TjViMlJWZmRNWWNIWkxqNkQrU2Q1eTJ2KUZQLT5gZ3pKT2t2bFV5VjIqSCFJXzZnQEEoMgp6cCkk RmhNfWJMVDNZWjMzeiRgRmJZcTAwPTFLaiFNX3B0QmFlV3RtQGdrVllMRXc8OVVCOERnZTVvUEIl KVNiQ2UKenM5emgwKj16SGp6MEM7ZSMhYTV0dWN3a31le3dEKk0+KDZ+YXFieDY8c1QzcGVGREdW UEp5PnE/djklNUI/fVpwCno2K0FhO2YxdiFYVmZKPmllWER+eklnPDRTOWc3KzQ5eihHY2I3ITNx UWVWelZlWDxNcmdiQEp5bX5LcTZfcU97dgp6Ym5pUlpkOzBAU09LWW1PWlFwSGdVc3p6TCFWcD5E bzdXRy1eVH5jYVcrPGZOU3Y+PSMhQz8pX2J1dkhqJXUmUUUKelBaR2NTQnZFSHxYb2pFTTFaWjtT UUlWNWt7MDMxR2dabF5DYHZgWmZldTUzX3h9QSRnZzUpIUlhYDVuYEUjKX5VCnpYVk1hZURSWj5T NzNMMXkjY2o5MGcmWGQ4a2xCZUQlODkrVUN2VkR9eDFVYnElMmZvMW9JWHFZb3N5cElsWSg1Kgp6 PUVXXiNYMmI4SVBDayEzYDVmWi12JjNQKVA7PUViazVRcXMkX2JGb0J0O0JoM3FZZGozR25PWSpz JHNpejVGYEUKejlpMlF+UGBMMGMmb3NYdWFVdSl9RDxsRmptMFp2Nlg1V28+dT5hUWtTVTdrdXQ7 VkZ6REJBNV5CSmNnQHBVKmNeCnp4cjJebUc4eG8lSDJYYyZ4bVFxVWp2YE9MZ3QmWnFwZmF9XnBx cEtAJCFDb2QwNUwpVWRYQGtycHMhaT1oSU9tVQp6c0JlWClAbEZkcy1ZKiF0QldYYnhXRENURVo4 bG8tRWJoNlAjbDUjTWY1V1h6P3pAI3t4clJIfjhKd2sobFNHblQKemhfYTI5P2Z1NlFUelU8OD1A ano5TnF3eEc5fEM8R2ZhQ1Y/RGNhUU9LV2hPZlZncn1LeUB8Xj9NeVRiT0ElNl5jCnojPzJPVXYl OHNfU3p1fnJrIUVXYndhRlJFJjFwKXRDVF52TVRoXkhkcTV1ezZzRDIwNC05VTkkUVNCQXYrNzt4 PQp6Q0ZKVHc8aT5MMFV9bSsmPVYxSW1YRXFVe3w3PVhhUkBrNk81R3VLSlhGZTYwZ2k4NmQ5VTNK PGx6ZGpYcG8rR1kKeiVAPyk7dksmKHRXZ0NMQEJYPEh6Kkk1OUhaa1dVSFgyXiomX3BQfExURUd4 UkRicj83U1pjV3hYKD9BVmIyaUQ2Cnpqak1Bd1klKlNkOC1nSDVRMiRQYWZ4VFB9cUh3Xn1eJWo3 bD80ZWBQbmBlRXcoRUw5XkU/MXRmaXJJLTJUT2c5Xwp6PFRYV1EpTiQzYVFUK3toO0c4akZrOSha WWwjV1dEdEFiNDZIfnxRKFpsYjxiYj9qT35VezR0dmgrLVVHe351QDIKekNtKDcjX2l7eXpkPk9S Slo+WiZ0cyR+WEJJZGYxWDFRZ2RMMm1XVnlqVnhHMWA7NXsyb2sjYHV0Pjs0dTxfIUVPCnoxWWxl ZVkxSTBJa2ArcVllblRaXmApZFVpdmhwVDFeQ0NlfHFwRHtrZDxXKyQxKXlsSjJET08qIzVwenli NFFSbgp6XjF1JkY4fnNyV3omS1ZZVDd6SX5iR2JrdU1tMD43M3RGbGUhdnYjUEF6eGxxVFdHJUFF Y3FpeClLNnMyUzFLfEcKemFuMzE+YT5YfkJGXlk7I3tKMDFKb0FqfWIrfXFkIXhIUlZRdyRXSWJa PmVHbjlYOHV4MExFa3ojVFo5VzdTdE13CnpTUm8hRUZ0UjlYYFFzPTZvM1RTNEpUR1QxXjM5Wl5m Y0ZeRC1hWjJLYVNKbEdBXj5jWHsyOWR0cWtNeUwhWkU0ewp6SEkle3BOZjNaaDM4cW5ON2oyZXMj ISFDVj1PX3x9YWxtaDlCZ2dIZ2Z7VFBmalZMJllGO3p4NkNULTE2c3NNfksKejZOfnxHOUtmNUlm VVZOTHZ4KVl6Zzw2NSFMQDNtbE5AQ0ctakxCUjRMPF8odUw0ZlRxcTF4O0B3eTU9NjVyRUI3Cmwk WjhCcloxKmBmJHlXZ0l7e3ZeSnN4VDg3S2VZZT0wMDJvdlBESExrVjFsVH1pQSg/aAoKbGl0ZXJh bCAwCkhjbVY/ZDAwMDAxCgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3F0L3Rlc3RzL3F3ZWJmcmFtZS90 c3RfcXdlYmZyYW1lLmNwcCBiL1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFt ZS5jcHAKaW5kZXggNzk3NDQ2Yi4uODBjOWQ3MiAxMDA2NDQKLS0tIGEvV2ViS2l0L3F0L3Rlc3Rz L3F3ZWJmcmFtZS90c3RfcXdlYmZyYW1lLmNwcAorKysgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZy YW1lL3RzdF9xd2ViZnJhbWUuY3BwCkBAIC01ODYsNiArNTg2LDcgQEAgcHJpdmF0ZSBzbG90czoK ICAgICB2b2lkIGphdmFTY3JpcHRXaW5kb3dPYmplY3RDbGVhcmVkT25FdmFsdWF0ZSgpOwogICAg IHZvaWQgc2V0SHRtbCgpOwogICAgIHZvaWQgc2V0SHRtbFdpdGhSZXNvdXJjZSgpOworICAgIHZv aWQgc2V0SHRtbFdpdGhCYXNlVVJMKCk7CiAgICAgdm9pZCBpcHY2SG9zdEVuY29kaW5nKCk7CiAg ICAgdm9pZCBtZXRhRGF0YSgpOwogICAgIHZvaWQgcG9wdXBGb2N1cygpOwpAQCAtNjk5LDYgKzcw MCw3IEBAIHZvaWQgdHN0X1FXZWJGcmFtZTo6aW5pdCgpCiAgICAgbV9wYWdlID0gbV92aWV3LT5w YWdlKCk7CiAgICAgbV9teU9iamVjdCA9IG5ldyBNeVFPYmplY3QoKTsKICAgICBtX3BhZ2UtPm1h aW5GcmFtZSgpLT5hZGRUb0phdmFTY3JpcHRXaW5kb3dPYmplY3QoIm15T2JqZWN0IiwgbV9teU9i amVjdCk7CisgICAgUURpcjo6c2V0Q3VycmVudChTUkNESVIpOwogfQogCiB2b2lkIHRzdF9RV2Vi RnJhbWU6OmNsZWFudXAoKQpAQCAtMjM3MCw2ICsyMzcyLDI4IEBAIHZvaWQgdHN0X1FXZWJGcmFt ZTo6c2V0SHRtbFdpdGhSZXNvdXJjZSgpCiAgICAgUUNPTVBBUkUocC5zdHlsZVByb3BlcnR5KCJj b2xvciIsIFFXZWJFbGVtZW50OjpDYXNjYWRlZFN0eWxlKSwgUUxhdGluMVN0cmluZygicmVkIikp OwogfQogCit2b2lkIHRzdF9RV2ViRnJhbWU6OnNldEh0bWxXaXRoQmFzZVVSTCgpCit7CisgICAg UVN0cmluZyBodG1sKCI8aHRtbD48Ym9keT48cD5oZWxsbyB3b3JsZDwvcD48aW1nIHNyYz0ncmVz b3VyY2VzL2ltYWdlMi5wbmcnLz48L2JvZHk+PC9odG1sPiIpOworCisgICAgUVdlYlBhZ2UgcGFn ZTsKKyAgICBRV2ViRnJhbWUqIGZyYW1lID0gcGFnZS5tYWluRnJhbWUoKTsKKworICAgIC8vIGlu IGZldyBzZWNvbmRzLCB0aGUgaW1hZ2Ugc2hvdWxkIGJlIGNvbXBsZXRleSBsb2FkZWQKKyAgICBR U2lnbmFsU3B5IHNweSgmcGFnZSwgU0lHTkFMKGxvYWRGaW5pc2hlZChib29sKSkpOworCisgICAg ZnJhbWUtPnNldEh0bWwoaHRtbCwgUVVybDo6ZnJvbUxvY2FsRmlsZShRRGlyOjpjdXJyZW50UGF0 aCgpKSk7CisgICAgUVRlc3Q6OnFXYWl0KDIwMCk7CisgICAgUUNPTVBBUkUoc3B5LmNvdW50KCks IDEpOworCisgICAgUUNPTVBBUkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9jdW1lbnQu aW1hZ2VzLmxlbmd0aCIpLnRvSW50KCksIDEpOworICAgIFFDT01QQVJFKGZyYW1lLT5ldmFsdWF0 ZUphdmFTY3JpcHQoImRvY3VtZW50LmltYWdlc1swXS53aWR0aCIpLnRvSW50KCksIDEyOCk7Cisg ICAgUUNPTVBBUkUoZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9jdW1lbnQuaW1hZ2VzWzBd LmhlaWdodCIpLnRvSW50KCksIDEyOCk7CisKKyAgICAvLyBubyBoaXN0b3J5IGl0ZW0gaGFzIHRv IGJlIGFkZGVkLgorICAgIFFDT01QQVJFKG1fdmlldy0+cGFnZSgpLT5oaXN0b3J5KCktPmNvdW50 KCksIDApOworfQorCiBjbGFzcyBUZXN0TmV0d29ya01hbmFnZXIgOiBwdWJsaWMgUU5ldHdvcmtB Y2Nlc3NNYW5hZ2VyCiB7CiBwdWJsaWM6Ci0tIAoxLjYuMC40Cgo= 40139 2009-09-25 13:21:35 -0700 2009-09-29 12:20:05 -0700 implemented loadAlternativeHtml + autotest 0002-2009-09-25-Antonio-Gomes-antonio.gomes-webkit.or.patch text/plain 6839 tonikitoo RnJvbSBhOTZlNmQ1NDUyNDA2ZTkyNTViNDY1NmJkOTNmOWFmMmI1YWY3MTI1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbnRvbmlvIEdvbWVzICh0b25pa2l0b28pIDxhbnRvbmlvLmdv bWVzQG9wZW5ib3NzYS5vcmc+CkRhdGU6IEZyaSwgMjUgU2VwIDIwMDkgMTU6NDg6NTAgLTA0MDAK U3ViamVjdDogW1BBVENIXSAyMDA5LTA5LTI1ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29t ZXNAd2Via2l0Lm9yZz4KCiAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgogICAg ICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJsZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRz CiAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI5MjQ4IChw YXJ0IElJKQoKICAgICAgICBQYXRjaC1ieTogQW50b25pbyBHb21lcyA8dG9uaWtpdG9vQHdlYmtp dC5vcmc+IGFuZAogICAgICAgICAgICAgICAgICBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbiAg PGtlbm5ldGhAd2Via2l0Lm9yZz4KCiAgICAgICAgQWRkZWQgbWV0aG9kIGxvYWRBbHRlcm5hdGl2 ZUh0bWwgbWV0aG9kIHRvIFFXZWJGcmFtZSwgdGFraW5nIGEgZmFsbGJhY2tVcmwKICAgICAgICAo InVybCBmb3IgaGlzdG9yeSIpIHBhcmFtZXRlciBhcyB3ZWxsIGFzICdodG1sJyAoZGF0YSBjb250 ZW50KSBhbmQgJ2Jhc2VVcmwnLgoKICAgICAgICAqIEFwaS9xd2ViZnJhbWUuY3BwOgogICAgICAg IChRV2ViRnJhbWU6OnNldEh0bWwpOgogICAgICAgIChRV2ViRnJhbWU6OmxvYWRBbHRlcm5hdGl2 ZUh0bWwpOgogICAgICAgICogQXBpL3F3ZWJmcmFtZS5oOgogICAgICAgICogdGVzdHMvcXdlYmZy YW1lL3RzdF9xd2ViZnJhbWUuY3BwOgotLS0KIFdlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNwcCAg ICAgICAgICAgICAgICAgfCAgIDM2ICsrKysrKysrKysrKysrKysrKysrKysrKystCiBXZWJLaXQv cXQvQXBpL3F3ZWJmcmFtZS5oICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJLaXQvcXQv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysrKysrKysKIFdl YktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgfCAgIDIyICsrKysrKysr KysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgNzMgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9XZWJLaXQvcXQvQXBpL3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQv QXBpL3F3ZWJmcmFtZS5jcHAKaW5kZXggM2QzMWFlOC4uZGE3MmEyNyAxMDA2NDQKLS0tIGEvV2Vi S2l0L3F0L0FwaS9xd2ViZnJhbWUuY3BwCisrKyBiL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmNw cApAQCAtNzAwLDYgKzcwMCwzOCBAQCB2b2lkIFFXZWJGcmFtZTo6bG9hZChjb25zdCBRTmV0d29y a1JlcXVlc3QgJnJlcSwKICNlbmRpZgogCiAvKiEKKyAgXHNpbmNlIDQuNgorICBMb2FkcyBhIG5l dyBwYWdlIHdpdGggdGhlIHNwZWNpZmllZCBcYSBodG1sLgorCisgIFRoaXMgbWV0aG9kIGlzIG1l YW50IGZvciBkZWFsaW5nIHdpdGggZmFpbGVkIGxvYWRzIGFuZCBzaW1pbGFyIHNpdHVhdGlvbnMs CisgIHdoZXJlIGFsdGVybmF0aXZlIFxhIGh0bWwgaXMgc2hvd24sIGJ1dCB3aGVuIHJldmlzaXRl ZCBvciByZWxvYWRlZCB0aGUKKyAgXGEgZmFsbGJhY2tVcmwgc2hvdWxkIGJlIGxvYWRlZCBpbnN0 ZWFkLgorCisgIEV4dGVybmFsIG9iamVjdHMgc3VjaCBhcyBzdHlsZXNoZWV0cyBvciBpbWFnZXMg cmVmZXJlbmNlZCBpbiB0aGUgSFRNTCBkb2N1bWVudAorICBhcmUgbG9jYXRlZCByZWxhdGl2ZSB0 byBiYXNlVXJsIHdoaWNoIGlzIG9wdGlvbmFsLgorCisgIFRoZSBcYSBodG1sIGlzIGxvYWRlZCBp bW1lZGlhdGVseTsgZXh0ZXJuYWwgb2JqZWN0cyBhcmUgbG9hZGVkIGFzeW5jaHJvbm91c2x5Lgor CisgIFdoZW4gdXNpbmcgdGhpcyBtZXRob2QsIFdlYktpdCBhc3N1bWVzIHRoYXQgZXh0ZXJuYWwg cmVzb3VyY2VzIHN1Y2ggYXMKKyAgSmF2YVNjcmlwdCBwcm9ncmFtcyBvciBzdHlsZSBzaGVldHMg YXJlIGVuY29kZWQgaW4gVVRGLTggdW5sZXNzIG90aGVyd2lzZQorICBzcGVjaWZpZWQuIEZvciBl eGFtcGxlLCB0aGUgZW5jb2Rpbmcgb2YgYW4gZXh0ZXJuYWwgc2NyaXB0IGNhbiBiZSBzcGVjaWZp ZWQKKyAgdGhyb3VnaCB0aGUgY2hhcnNldCBhdHRyaWJ1dGUgb2YgdGhlIEhUTUwgc2NyaXB0IHRh Zy4gQWx0ZXJuYXRpdmVseSwgdGhlCisgIGVuY29kaW5nIGNhbiBhbHNvIGJlIHNwZWNpZmllZCBi eSB0aGUgd2ViIHNlcnZlci4KKworICBcc2EgbG9hZCgpLCBzZXRDb250ZW50KCksIHNldEh0bWwo KSwgdG9IdG1sKCkKKyovCisKK3ZvaWQgUVdlYkZyYW1lOjpsb2FkQWx0ZXJuYXRpdmVIdG1sKGNv bnN0IFFVcmwmIGZhbGxiYWNrVXJsLCBjb25zdCBRU3RyaW5nJiBodG1sLCBjb25zdCBRVXJsJiBi YXNlVXJsKQoreworICAgIEtVUkwga3VybChiYXNlVXJsKTsKKyAgICBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QgcmVxdWVzdChrdXJsKTsKKyAgICBjb25zdCBRQnl0ZUFycmF5IHV0ZjggPSBodG1s LnRvVXRmOCgpOworICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcj4gZGF0YSA9 IFdlYkNvcmU6OlNoYXJlZEJ1ZmZlcjo6Y3JlYXRlKHV0ZjguY29uc3REYXRhKCksIHV0ZjgubGVu Z3RoKCkpOworICAgIFdlYkNvcmU6OlN1YnN0aXR1dGVEYXRhIHN1YnN0aXR1dGVEYXRhKGRhdGEs IFdlYkNvcmU6OlN0cmluZygidGV4dC9odG1sIiksIFdlYkNvcmU6OlN0cmluZygidXRmLTgiKSwg S1VSTChmYWxsYmFja1VybCkpOworICAgIGQtPmZyYW1lLT5sb2FkZXIoKS0+bG9hZChyZXF1ZXN0 LCBzdWJzdGl0dXRlRGF0YSwgZmFsc2UpOworfQorCisvKiEKICAgU2V0cyB0aGUgY29udGVudCBv ZiB0aGlzIGZyYW1lIHRvIFxhIGh0bWwuIFxhIGJhc2VVcmwgaXMgb3B0aW9uYWwgYW5kIHVzZWQg dG8gcmVzb2x2ZSByZWxhdGl2ZQogICBVUkxzIGluIHRoZSBkb2N1bWVudCwgc3VjaCBhcyByZWZl cmVuY2VkIGltYWdlcyBvciBzdHlsZXNoZWV0cy4KIApAQCAtNzEyLDcgKzc0NCw3IEBAIHZvaWQg UVdlYkZyYW1lOjpsb2FkKGNvbnN0IFFOZXR3b3JrUmVxdWVzdCAmcmVxLAogCiAgIFxub3RlIFRo aXMgbWV0aG9kIHdpbGwgbm90IGFmZmVjdCBzZXNzaW9uIG9yIGdsb2JhbCBoaXN0b3J5IGZvciB0 aGUgZnJhbWUuCiAKLSAgXHNhIHRvSHRtbCgpLCBzZXRDb250ZW50KCkKKyAgXHNhIHRvSHRtbCgp LCBzZXRDb250ZW50KCksIGxvYWRBbHRlcm5hdGl2ZUh0bWwoKQogKi8KIHZvaWQgUVdlYkZyYW1l OjpzZXRIdG1sKGNvbnN0IFFTdHJpbmcgJmh0bWwsIGNvbnN0IFFVcmwgJmJhc2VVcmwpCiB7CkBA IC03MzUsNyArNzY3LDcgQEAgdm9pZCBRV2ViRnJhbWU6OnNldEh0bWwoY29uc3QgUVN0cmluZyAm aHRtbCwgY29uc3QgUVVybCAmYmFzZVVybCkKIAogICBcbm90ZSBUaGlzIG1ldGhvZCB3aWxsIG5v dCBhZmZlY3Qgc2Vzc2lvbiBvciBnbG9iYWwgaGlzdG9yeSBmb3IgdGhlIGZyYW1lLgogCi0gIFxz YSB0b0h0bWwoKSwgc2V0SHRtbCgpCisgIFxzYSB0b0h0bWwoKSwgc2V0SHRtbCgpLCBsb2FkQWx0 ZXJuYXRpdmVIdG1sKCkKICovCiB2b2lkIFFXZWJGcmFtZTo6c2V0Q29udGVudChjb25zdCBRQnl0 ZUFycmF5ICZkYXRhLCBjb25zdCBRU3RyaW5nICZtaW1lVHlwZSwgY29uc3QgUVVybCAmYmFzZVVy bCkKIHsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9BcGkvcXdlYmZyYW1lLmggYi9XZWJLaXQvcXQv QXBpL3F3ZWJmcmFtZS5oCmluZGV4IDU1YzczYjQuLjBjOGJhZmQgMTAwNjQ0Ci0tLSBhL1dlYktp dC9xdC9BcGkvcXdlYmZyYW1lLmgKKysrIGIvV2ViS2l0L3F0L0FwaS9xd2ViZnJhbWUuaApAQCAt MTMyLDYgKzEzMiw3IEBAIHB1YmxpYzoKICNlbmRpZgogICAgIHZvaWQgc2V0SHRtbChjb25zdCBR U3RyaW5nICZodG1sLCBjb25zdCBRVXJsICZiYXNlVXJsID0gUVVybCgpKTsKICAgICB2b2lkIHNl dENvbnRlbnQoY29uc3QgUUJ5dGVBcnJheSAmZGF0YSwgY29uc3QgUVN0cmluZyAmbWltZVR5cGUg PSBRU3RyaW5nKCksIGNvbnN0IFFVcmwgJmJhc2VVcmwgPSBRVXJsKCkpOworICAgIHZvaWQgbG9h ZEFsdGVybmF0aXZlSHRtbChjb25zdCBRVXJsJiBmYWxsYmFja1VybCwgY29uc3QgUVN0cmluZyYg aHRtbCwgY29uc3QgUVVybCYgYmFzZVVybCA9IFFVcmwoKSk7CiAKICAgICB2b2lkIGFkZFRvSmF2 YVNjcmlwdFdpbmRvd09iamVjdChjb25zdCBRU3RyaW5nICZuYW1lLCBRT2JqZWN0ICpvYmplY3Qp OwogICAgIHZvaWQgYWRkVG9KYXZhU2NyaXB0V2luZG93T2JqZWN0KGNvbnN0IFFTdHJpbmcgJm5h bWUsIFFPYmplY3QgKm9iamVjdCwgUVNjcmlwdEVuZ2luZTo6VmFsdWVPd25lcnNoaXAgb3duZXJz aGlwKTsKZGlmZiAtLWdpdCBhL1dlYktpdC9xdC9DaGFuZ2VMb2cgYi9XZWJLaXQvcXQvQ2hhbmdl TG9nCmluZGV4IGRiYmE3YWQuLjUzNDAxNjYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9xdC9DaGFuZ2VM b2cKKysrIGIvV2ViS2l0L3F0L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDA5LTA5LTI1 ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29tZXNAd2Via2l0Lm9yZz4sIEtlbm5ldGggUm9o ZGUgQ2hyaXN0aWFuc2VuICA8a2VubmV0aEB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtRdF0gW0FQSV0gTWFrZSBpdCBwb3NzaWJs ZSB0byBoYXZlICdpbnZpc2libGUnIGxvYWRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yOTI0OCAocGFydCBJSSkKKworICAgICAgICBBZGRlZCBtZXRo b2QgbG9hZEFsdGVybmF0aXZlSHRtbCBtZXRob2QgdG8gUVdlYkZyYW1lLCB0YWtpbmcgYSBmYWxs YmFja1VybAorICAgICAgICAoInVybCBmb3IgaGlzdG9yeSIpIHBhcmFtZXRlciBhcyB3ZWxsIGFz ICdodG1sJyAoZGF0YSBjb250ZW50KSBhbmQgJ2Jhc2VVcmwnLgorCisgICAgICAgICogQXBpL3F3 ZWJmcmFtZS5jcHA6CisgICAgICAgIChRV2ViRnJhbWU6OnNldEh0bWwpOgorICAgICAgICAoUVdl YkZyYW1lOjpsb2FkQWx0ZXJuYXRpdmVIdG1sKToKKyAgICAgICAgKiBBcGkvcXdlYmZyYW1lLmg6 CisgICAgICAgICogdGVzdHMvcXdlYmZyYW1lL3RzdF9xd2ViZnJhbWUuY3BwOgorCiAyMDA5LTA5 LTI1ICBBbnRvbmlvIEdvbWVzICAgPGFudG9uaW8uZ29tZXNAb3BlbmJvc3NhLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL1dlYktpdC9xdC90 ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAgYi9XZWJLaXQvcXQvdGVzdHMvcXdlYmZy YW1lL3RzdF9xd2ViZnJhbWUuY3BwCmluZGV4IDgwYzlkNzIuLjU3NzcxNjkgMTAwNjQ0Ci0tLSBh L1dlYktpdC9xdC90ZXN0cy9xd2ViZnJhbWUvdHN0X3F3ZWJmcmFtZS5jcHAKKysrIGIvV2ViS2l0 L3F0L3Rlc3RzL3F3ZWJmcmFtZS90c3RfcXdlYmZyYW1lLmNwcApAQCAtNTg3LDYgKzU4Nyw3IEBA IHByaXZhdGUgc2xvdHM6CiAgICAgdm9pZCBzZXRIdG1sKCk7CiAgICAgdm9pZCBzZXRIdG1sV2l0 aFJlc291cmNlKCk7CiAgICAgdm9pZCBzZXRIdG1sV2l0aEJhc2VVUkwoKTsKKyAgICB2b2lkIGxv YWRBbHRlcm5hdGl2ZUh0bWwoKTsKICAgICB2b2lkIGlwdjZIb3N0RW5jb2RpbmcoKTsKICAgICB2 b2lkIG1ldGFEYXRhKCk7CiAgICAgdm9pZCBwb3B1cEZvY3VzKCk7CkBAIC0yMzk0LDYgKzIzOTUs MjcgQEAgdm9pZCB0c3RfUVdlYkZyYW1lOjpzZXRIdG1sV2l0aEJhc2VVUkwoKQogICAgIFFDT01Q QVJFKG1fdmlldy0+cGFnZSgpLT5oaXN0b3J5KCktPmNvdW50KCksIDApOwogfQogCit2b2lkIHRz dF9RV2ViRnJhbWU6OmxvYWRBbHRlcm5hdGl2ZUh0bWwoKQoreworICAgIFFTdHJpbmcgaHRtbCgi PGh0bWw+PGJvZHk+PHA+aGVsbG8gd29ybGQ8L3A+PGltZyBzcmM9J3Jlc291cmNlcy9pbWFnZTIu cG5nJy8+PC9ib2R5PjwvaHRtbD4iKTsKKworICAgIFFXZWJGcmFtZSogZnJhbWUgPSBtX3BhZ2Ut Pm1haW5GcmFtZSgpOworCisgICAgLy8gaW4gZmV3IHNlY29uZHMsIHRoZSBpbWFnZSBzaG91bGQg YmUgY29tcGxldGV5IGxvYWRlZAorICAgIFFTaWduYWxTcHkgc3B5KG1fcGFnZSwgU0lHTkFMKGxv YWRGaW5pc2hlZChib29sKSkpOworCisgICAgZnJhbWUtPmxvYWRBbHRlcm5hdGl2ZUh0bWwoUVVy bCgiaHR0cDovL2FueS51cmwuZ28vaGVyZSIpLCBodG1sLCBRVXJsOjpmcm9tTG9jYWxGaWxlKFFE aXI6OmN1cnJlbnRQYXRoKCkpKTsKKyAgICBRVGVzdDo6cVdhaXQoMjAwKTsKKyAgICBRQ09NUEFS RShzcHkuY291bnQoKSwgMSk7CisKKyAgICBRQ09NUEFSRShmcmFtZS0+ZXZhbHVhdGVKYXZhU2Ny aXB0KCJkb2N1bWVudC5pbWFnZXMubGVuZ3RoIikudG9JbnQoKSwgMSk7CisgICAgUUNPTVBBUkUo ZnJhbWUtPmV2YWx1YXRlSmF2YVNjcmlwdCgiZG9jdW1lbnQuaW1hZ2VzWzBdLndpZHRoIikudG9J bnQoKSwgMTI4KTsKKyAgICBRQ09NUEFSRShmcmFtZS0+ZXZhbHVhdGVKYXZhU2NyaXB0KCJkb2N1 bWVudC5pbWFnZXNbMF0uaGVpZ2h0IikudG9JbnQoKSwgMTI4KTsKKworICAgIC8vIG5vIGhpc3Rv cnkgaXRlbSBoYXMgdG8gYmUgYWRkZWQuCisgICAgUUNPTVBBUkUobV92aWV3LT5wYWdlKCktPmhp c3RvcnkoKS0+Y3VycmVudEl0ZW0oKS51cmwoKS50b1N0cmluZygpLCBRTGF0aW4xU3RyaW5nKCJo dHRwOi8vYW55LnVybC5nby9oZXJlIikpOworfQorCiBjbGFzcyBUZXN0TmV0d29ya01hbmFnZXIg OiBwdWJsaWMgUU5ldHdvcmtBY2Nlc3NNYW5hZ2VyCiB7CiBwdWJsaWM6Ci0tIAoxLjYuMC40Cgo=