40934 2010-06-21 12:09:12 -0700 Support <script defer> as specified by HTML5 2010-09-02 08:46:12 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 40968 43055 43532 43736 43875 45103 20710 43391 1 tonyg tonyg abarth commit-queue dbates eric hartman.wiki ossy peter rainhead webkit-ews webkit.review.bot oldest_to_newest 240805 0 tonyg 2010-06-21 12:09:12 -0700 Support <script defer> as specified by HTML5 240825 1 59276 tonyg 2010-06-21 12:58:49 -0700 Created attachment 59276 Patch 240829 2 tonyg 2010-06-21 13:01:19 -0700 Adam, hopefully I've addressed all your original comments from my big patch in: https://bugs.webkit.org/show_bug.cgi?id=20710 This patch only does defer so it is much more manageable. I'll mail one for async separately. 240864 3 59276 abarth 2010-06-21 13:51:58 -0700 Comment on attachment 59276 Patch Eric should review this one. 240882 4 59276 eric 2010-06-21 14:14:31 -0700 Comment on attachment 59276 Patch First of all, thank you! It's wonderful to have you working on this! This is a complicated patch. It may take me a couple passes to review it, but I'll go through it once with comments now. LayoutTests/http/tests/loading/resources/defer-script.js:1 + window.status += " defer "; I think I probably would have used some other logging mechanism. :) LayoutTests/http/tests/loading/script-defer-expected.txt:6 + main frame - didFinishLoadForFrame I'm not sure you want to have this in the loading directory, I don't think you need/want these callbacks. Maybe you do, but it makes the tests possibly more complicated than needed. LayoutTests/http/tests/loading/script-defer.html:8 + window.status += (' DCL ') function log(text) { document.getElementById("preTag").innerHTML += text + "\n"; } is the easy hack for logging. It's also just as easy to create text nodes and br nodes in a normal div, like the "console" div and log() function for script-tests do. LayoutTests/http/tests/loading/script-defer.html:17 + var results = "PASS"; You can actually use the shouldBe, log, etc. from script-tests w/o being a template-based script-test by including fast/js/js-test-pre.js. I think that's exposed in some manner to http tests, but I could be wrong. Honestly all the window.status stuff is fine. :) It was just a little strange at first to read. WebCore/html/HTML5DocumentParser.cpp:306 + m_endWasDelayed = !m_scriptRunner->executeScriptsWaitingForParsing(); This seems very strange. You mean we'd end up calling end() twice? Since we delayed the end inside end? WebCore/html/HTML5DocumentParser.cpp:306 + m_endWasDelayed = !m_scriptRunner->executeScriptsWaitingForParsing(); Maybe we should have a wrapper function for calling end instead? runAnyDeferredScriptsAndEnd() or similar? WebCore/html/HTML5ScriptRunner.cpp:233 + watchForLoad(m_parsingBlockingScript); Feels very strange to me to pull this watchForLoad call out from right next to where we make the request. Seems like it would be easy to end up watching twice or not at all. If we fail to "watch" a script, it will end up with no clients and can end up purging its data from the cache any time we hit the run-loop. WebCore/html/HTML5ScriptRunner.cpp:241 + void HTML5ScriptRunner::requestScript(PendingScript& pendingScript, Element* scriptElement) I think this is a great change. It is definitely better to pass in the m_parsingBlockingScript as a reference than to use it directly! WebCore/html/HTML5ScriptRunner.cpp:279 + m_scriptsToExecuteAfterParsing.append(pendingScript); I think the lack of watchForLoad is going to bite us here. I think instead the load function needs to know to ignore the notification. That will be slightly sad as we may have to remove more ASSERTS (which are the only thing which makes this sort of async programming possible). WebCore/html/HTML5ScriptRunner.cpp:294 + requestDeferredScript(script); This is nice and clean. :) WebCore/html/HTML5ScriptRunner.h:114 + Deque<PendingScript> m_scriptsToExecuteAfterParsing; I think this design seems totally workable. I wonder if we want the ScriptRunner to be in charge of running defer scripts, or should something else like the Document do so (since it happens after parsing is done?) How are async scripts going to wire in? Do those need to be run by the ScriptRunner or Document or something else? We may need to split the scripting logic out of Document ont something else. Maybe the ScriptRunner should be owned by the document directly and just used by the parser? Or maybe a new ScriptRunner-type-class needs to exist for the Documetns' script running needs? Those big design questions don't need to be answered by this patch, but should enter into your thinking in terms of planning async and defer. :) r- because I think this will end up with defer scripts being purged from the cache before being run (thus causing flakiness and ASSERTs in debug mode). 240954 5 tonyg 2010-06-21 16:29:34 -0700 (In reply to comment #4) > (From update of attachment 59276 [details]) > First of all, thank you! It's wonderful to have you working on this! > > This is a complicated patch. It may take me a couple passes to review it, but I'll go through it once with comments now. Thanks for the quick and detailed review. I have a few questions inline below before I update the patch. > > LayoutTests/http/tests/loading/resources/defer-script.js:1 > + window.status += " defer "; > I think I probably would have used some other logging mechanism. :) I'll switch to what you suggested below. > > LayoutTests/http/tests/loading/script-defer-expected.txt:6 > + main frame - didFinishLoadForFrame > I'm not sure you want to have this in the loading directory, I don't think you need/want these callbacks. Maybe you do, but it makes the tests possibly more complicated than needed. > Which directory should these go in? Maybe http/tests/misc/? > LayoutTests/http/tests/loading/script-defer.html:8 > + window.status += (' DCL ') > function log(text) { > document.getElementById("preTag").innerHTML += text + "\n"; > } > is the easy hack for logging. It's also just as easy to create text nodes and br nodes in a normal div, like the "console" div and log() function for script-tests do. > Good idea I'll do that. > LayoutTests/http/tests/loading/script-defer.html:17 > + var results = "PASS"; > You can actually use the shouldBe, log, etc. from script-tests w/o being a template-based script-test by including fast/js/js-test-pre.js. I think that's exposed in some manner to http tests, but I could be wrong. > > Honestly all the window.status stuff is fine. :) It was just a little strange at first to read. I like your suggestion, will switch to that instead. > > WebCore/html/HTML5DocumentParser.cpp:306 > + m_endWasDelayed = !m_scriptRunner->executeScriptsWaitingForParsing(); > This seems very strange. You mean we'd end up calling end() twice? Since we delayed the end inside end? Yes, with this approach we'd call end() twice. The root problem is that we don't have one method that implements: http://dev.w3.org/html5/spec/Overview.html#the-end It is currently spread across Document, DocumentParser, TreeBuilder, and FrameLoader. The key bit I'm trying to add is 8.2.6.3. It could either go here, in DocumentParser, or it could go in Document as I originally coded it in https://bugs.webkit.org/attachment.cgi?id=56542&action=prettypatch. > > WebCore/html/HTML5DocumentParser.cpp:306 > + m_endWasDelayed = !m_scriptRunner->executeScriptsWaitingForParsing(); > Maybe we should have a wrapper function for calling end instead? runAnyDeferredScriptsAndEnd() or similar? Yes, I can do that. Does that address your above concern about calling end() twice? > > WebCore/html/HTML5ScriptRunner.cpp:233 > + watchForLoad(m_parsingBlockingScript); > Feels very strange to me to pull this watchForLoad call out from right next to where we make the request. Seems like it would be easy to end up watching twice or not at all. If we fail to "watch" a script, it will end up with no clients and can end up purging its data from the cache any time we hit the run-loop. I believe PendingScript makes this safe. It holds a CachedResourceHandle which guarantees that it will not be purged even after it has loaded with no watcher. Also, we can't watch twice because of the ASSERT(!pendingScript.watchingForLoad()) in watchForLoad(). Let me know if you think I'm missing something. Perhaps you can suggest a test case I can add that would prove this case? > > WebCore/html/HTML5ScriptRunner.cpp:241 > + void HTML5ScriptRunner::requestScript(PendingScript& pendingScript, Element* scriptElement) > I think this is a great change. It is definitely better to pass in the m_parsingBlockingScript as a reference than to use it directly! Would it be worthwhile to break this out into a separate patch to reduce the size of this one? > > WebCore/html/HTML5ScriptRunner.cpp:279 > + m_scriptsToExecuteAfterParsing.append(pendingScript); > I think the lack of watchForLoad is going to bite us here. I think instead the load function needs to know to ignore the notification. That will be slightly sad as we may have to remove more ASSERTS (which are the only thing which makes this sort of async programming possible). Yes, I don't want to remove those ASSERTs. I believe that the PendingScript's CachedResourceHandle prevents us from having to worry about this. If I missed something, then I probably need to figure out a way to have a different host that can be notified when deferred scripts load. Perhaps a separate DeferredScriptRunnerHost. > > WebCore/html/HTML5ScriptRunner.cpp:294 > + requestDeferredScript(script); > This is nice and clean. :) > > WebCore/html/HTML5ScriptRunner.h:114 > + Deque<PendingScript> m_scriptsToExecuteAfterParsing; > I think this design seems totally workable. I wonder if we want the ScriptRunner to be in charge of running defer scripts, or should something else like the Document do so (since it happens after parsing is done?) How are async scripts going to wire in? Do those need to be run by the ScriptRunner or Document or something else? Async scripts can be run after the DocumentParser is destroyed. So I was planning to track the number of outstanding async scripts on the Document. Similar to this: https://bugs.webkit.org/attachment.cgi?id=57565&action=prettypatch I could track both deferred and async scripts on the document, but you initially didn't like the idea of having code on the document that isn't used after it is loaded. > > We may need to split the scripting logic out of Document ont something else. Maybe the ScriptRunner should be owned by the document directly and just used by the parser? Or maybe a new ScriptRunner-type-class needs to exist for the Documetns' script running needs? Letting FrameLoader or Document own an AsyncScriptRunner and DeferredScriptRunner and DocumentParser own a SyncScriptRunner would be one way to go. It is hard for me to tell if the additional classes are warranted just yet. > > Those big design questions don't need to be answered by this patch, but should enter into your thinking in terms of planning async and defer. :) > > r- because I think this will end up with defer scripts being purged from the cache before being run (thus causing flakiness and ASSERTs in debug mode). 240965 6 eric 2010-06-21 16:47:36 -0700 (In reply to comment #5) > Which directory should these go in? Maybe http/tests/misc/? If I remember correctly the "loading" directory may automatically get these callbacks turned on (which is a horrible design IMO). If you want the callbacks then sure, leave them there. Otherwise anywhere you like is fine. Maybe http/tests/local/HTMLScriptElement Since we don't actually need to load the main page off the network. I'm not sure if local/ is reserved for a special purpose or if it's just for tests which don't actually need to be sent over HTTP, just use http resources. > I believe PendingScript makes this safe. It holds a CachedResourceHandle which guarantees that it will not be purged even after it has loaded with no watcher. Also, we can't watch twice because of the ASSERT(!pendingScript.watchingForLoad()) in watchForLoad(). Let me know if you think I'm missing something. Nope! That's what I thought too. See http://trac.webkit.org/changeset/61374 for more context. CachedResource will mark itself purgeable if it has no clients. CachedResourceHandle seems to just keep the actual CachedResource alive, but that doesn't mean it will still have any data attached to it. :) > Perhaps you can suggest a test case I can add that would prove this case? Get a DEFER to finish loading, but not run yet due to the parser being blocked on something else. Load a bunch of data or somehow convince the cache to start purging stuff. Try and run the script, it will have been marked purged and thus have no data (which will do nothing in Release mode, or hit an ASSERT inside ScriptSource in debug mode.) > > WebCore/html/HTML5ScriptRunner.cpp:241 > > + void HTML5ScriptRunner::requestScript(PendingScript& pendingScript, Element* scriptElement) > > I think this is a great change. It is definitely better to pass in the m_parsingBlockingScript as a reference than to use it directly! > > Would it be worthwhile to break this out into a separate patch to reduce the size of this one? Totally up to you. I'm happy to r=me that change if you want to post it separately. This isn't a very big change, just complicated due to the end() symantecs which are delicate (and hence guarded by a zillion ASSERTS). > Yes, I don't want to remove those ASSERTs. I believe that the PendingScript's CachedResourceHandle prevents us from having to worry about this. If I missed something, then I probably need to figure out a way to have a different host that can be notified when deferred scripts load. Perhaps a separate DeferredScriptRunnerHost. Well, it would be easy to have some separate thing signed up as the client. Even something which implemented an empty notifyFinished(). > I could track both deferred and async scripts on the document, but you initially didn't like the idea of having code on the document that isn't used after it is loaded. Yup. I worry our poor Document class is a bit of a dumping ground. I still need to go back and read the spec on DEFER vs. ASYNC. 244454 7 60047 tonyg 2010-06-29 13:27:32 -0700 Created attachment 60047 Patch 244455 8 tonyg 2010-06-29 13:28:18 -0700 I believe this addresses all of your previous comments. Should be ready for another pass. 244458 9 eric 2010-06-29 13:35:10 -0700 Attachment 60047 did not build on mac: Build output: http://webkit-commit-queue.appspot.com/results/3352240 244459 10 tonyg 2010-06-29 13:37:43 -0700 So odd that VisualStudio doesn't warn/error about initialization order. I'll upload a fixed patch shortly. 244461 11 60047 eric 2010-06-29 13:46:43 -0700 Comment on attachment 60047 Patch End should be final. How are we getting past the first end check to need a second? Are you sure you need that code or does: bool shouldDelayEnd() const { return inWrite() || isWaitingForScripts() || inScriptExecution() || isScheduledForResume(); } already catch your case? 244463 12 60047 eric 2010-06-29 13:49:14 -0700 Comment on attachment 60047 Patch I'm slightly onfused why we need RefCounted PendingScript? Wouldn't the blocking script just move off the queue to become the pending blocking script when it's turn has come? 244484 13 tonyg 2010-06-29 14:18:39 -0700 (In reply to comment #12) > (From update of attachment 60047 [details]) > I'm slightly onfused why we need RefCounted PendingScript? > > Wouldn't the blocking script just move off the queue to become the pending blocking script when it's turn has come? Yes, you are right, RefPtr functionality is not needed here, it was just convenient. The problem is that PendingScript is Noncopyable so I can't just assign it. Here are some options: 1. Remove Noncopyable and implement the = operator. It seemed desirable to keep it non copyable, what do you think? 2. Make it an OwnPtr. Then I need a create() method that returns a PassOwnPtr and one that returns a PassRefPtr. Perhaps that isn't so bad? What do you recommend? 244485 14 abarth 2010-06-29 14:22:37 -0700 A class either inherits from RefCounted or it doesn't. If it does, then you can't use OwnPtr. You have to use RefPtr. If it doesn't, you can't use RefPtr and you have to use OwnPtr (or hold it directly). (There are some exceptions where folks implement the RefCounted API without inheriting from RefCounted, but this doesn't sound like one of them.) Having create methods for both RefPtr and OwnPtr doesn't make any sense. 244486 15 tonyg 2010-06-29 14:25:25 -0700 (In reply to comment #14) > A class either inherits from RefCounted or it doesn't. If it does, then you can't use OwnPtr. You have to use RefPtr. If it doesn't, you can't use RefPtr and you have to use OwnPtr (or hold it directly). (There are some exceptions where folks implement the RefCounted API without inheriting from RefCounted, but this doesn't sound like one of them.) > > Having create methods for both RefPtr and OwnPtr doesn't make any sense. I'm kind of glad the API doesn't allow that. It would have been weird. So maybe the best option is to make PendingScript copyable and not use smart ptrs at all? 244496 16 abarth 2010-06-29 14:47:00 -0700 I haven't looked at the details at all, but that could well be a good solution. 244591 17 tonyg 2010-06-29 18:39:17 -0700 (In reply to comment #11) > (From update of attachment 60047 [details]) > End should be final. How are we getting past the first end check to need a second? > > Are you sure you need that code or does: > > bool shouldDelayEnd() const { return inWrite() || isWaitingForScripts() || inScriptExecution() || isScheduledForResume(); } > > already catch your case? A deferred script needs to be run after parsing, but before DOMContentLoaded. See: http://dev.w3.org/html5/spec/Overview.html#the-end When HTMLDocumentParser::end() calls m_treeBuilder->finished(), the Document fires DOMContentLoaded. So I need to hook in before that point. However, shouldDelayEnd() doesn't handle my case because I need to wait for that to be completely finished. For example, I couldn't call executeScriptsWaitingForParsingAndEnd() if shouldDelayEnd() would return true because a synchronous script is still loading. This all feels weird at the moment because there is no single place that implements "#the-end". Those steps are mostly spread through Document and FrameLoader. An alternate approach is what I did in the original patch (way back when) which was to add a phase to Document. Adding the phase here feels cleaner to me than adding it to Document. If you have a suggestion for a third alternative, I'm happy to pursue that. It would be really nice to eventually have one method that performs "#the-end". 244593 18 60076 tonyg 2010-06-29 18:41:07 -0700 Created attachment 60076 Patch 244595 19 eric 2010-06-29 18:48:07 -0700 Attachment 60076 did not build on mac: Build output: http://webkit-commit-queue.appspot.com/results/3372026 244600 20 60078 tonyg 2010-06-29 19:02:12 -0700 Created attachment 60078 Patch 245169 21 60078 eric 2010-07-01 00:48:51 -0700 Comment on attachment 60078 Patch WebCore/html/HTMLDocumentParser.cpp:292 + if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing()) { This is kinda subtle. I might have broken the running of m_scriptRunner->executeScriptsWaitingForParsing into a separate inner if: if (m_scriptRunner) { bool continueParsing = m_scriptRunner->executeScriptsWaitingForParsing(); if (!continueParsing) { WebCore/html/HTMLScriptRunner.cpp:237 + watchForLoad(m_parsingBlockingScript); Is this always right? What about the case where parsing finshed, but a stylesheet hasn't loaded. That seems like it will end up recursing under watchForLoad() because the m_parsingBlockingScript will have already loaded but can't run because we're blocked on CSS. Or? WebCore/html/HTMLScriptRunner.cpp:245 + void HTMLScriptRunner::requestScript(PendingScript& pendingScript, Element* scriptElement) I still think this is a fantastic change to this function to make it not affect the instance, only its args. otherwise it looks fine. r- for the possible slow CSS problem. 245478 22 60271 tonyg 2010-07-01 12:26:56 -0700 Created attachment 60271 Patch 245479 23 tonyg 2010-07-01 12:29:08 -0700 (In reply to comment #21) > (From update of attachment 60078 [details]) > WebCore/html/HTMLDocumentParser.cpp:292 > + if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing()) { > This is kinda subtle. I might have broken the running of m_scriptRunner->executeScriptsWaitingForParsing into a separate inner if: > > if (m_scriptRunner) { > bool continueParsing = m_scriptRunner->executeScriptsWaitingForParsing(); > if (!continueParsing) { Good call. That is much more readable :-) > > > WebCore/html/HTMLScriptRunner.cpp:237 > + watchForLoad(m_parsingBlockingScript); > Is this always right? What about the case where parsing finshed, but a stylesheet hasn't loaded. That seems like it will end up recursing under watchForLoad() because the m_parsingBlockingScript will have already loaded but can't run because we're blocked on CSS. Or? > It should be impossible to move into #the-end 8.2.6.3 phase until after all stylesheets have loaded. I've added a new LayoutTest to verify this case. Please let me know if I'm still missing something or if that isn't what you had in mind. I'd also be interested in adding more tests if you can think of other tricky scenarios. > WebCore/html/HTMLScriptRunner.cpp:245 > + void HTMLScriptRunner::requestScript(PendingScript& pendingScript, Element* scriptElement) > I still think this is a fantastic change to this function to make it not affect the instance, only its args. > > > otherwise it looks fine. r- for the possible slow CSS problem. 245513 24 eric 2010-07-01 13:18:41 -0700 I think it's clearer if we ASSERT that stylesheets are done in end() instead of assuming. 245598 25 tonyg 2010-07-01 15:35:11 -0700 (In reply to comment #24) > I think it's clearer if we ASSERT that stylesheets are done in end() instead of assuming. You were right! There was a bug, but it was slightly different. It isn't valid to ASSERT that stylesheets are done in end(). Stylesheets don't block the end of parsing, they only block parser-inserted script execution. The suggested ASSERT would trigger for this document "<html><link rel=stylesheet href=slow.css></html>". Currently executeScriptsWaitingForParsing() calls executeParsingBlockingScripts() which calls executePendingScript() which performs an ASSERT(m_document->haveStylesheetsLoaded()). So we are guaranteed that we can never run a script (deferred or otherwise) if there is a pending stylesheet. Anyway, I added another new test that writes a slow stylesheet from the first deferred script and ensures that the second deferred happens after the stylesheet is applied. It uncovered the bug. In HTMLScriptRunner::executeScriptsWaitingForParsing(), executeParsingBlockingScripts() may return false under two conditions: 1. The script isn't loaded yet 2. A blocking stylesheet isn't loaded yet It is only valid to call watchForLoad() if it returns false for #1. So I guarded watchForLoad() with a check for #1. 245604 26 60302 tonyg 2010-07-01 15:37:44 -0700 Created attachment 60302 Patch 245616 27 60302 eric 2010-07-01 15:49:51 -0700 Comment on attachment 60302 Patch Why can't we ASSERT right here: 33 while (!m_scriptsToExecuteAfterParsing.isEmpty()) { 234 ASSERT(!haveParsingBlockingScript()); that stylesheets are done? I want to make it impossible for us to think we're running the very last script only to have us block on stylesheet loads. Or worse, have us try to run the very last script, have it block, and then call waitForLoad which imemdiately calls us back re-entrantly. 245617 28 eric 2010-07-01 15:50:37 -0700 I guess waitForLoad() asserts that the cachedScript isn't loaded... 245626 29 tonyg 2010-07-01 16:02:46 -0700 (In reply to comment #27) > (From update of attachment 60302 [details]) > Why can't we ASSERT right here: > 33 while (!m_scriptsToExecuteAfterParsing.isEmpty()) { > 234 ASSERT(!haveParsingBlockingScript()); > > that stylesheets are done? My latest test case triggers the condition where stylesheets are not done at that line (a doc.write of a stylesheet from a deferred script). In that case, the first deferred script becomes the parsing blocking script, and executeParsingBlockingScripts()'s call to isPendingScriptReady() sets us into m_hasScritpsWaitingForStylesheets state. When the stylesheet loads, the m_parsingBlockingScript executes and the remaining deferred scripts are run (if any). > > I want to make it impossible for us to think we're running the very last script only to have us block on stylesheet loads. Or worse, have us try to run the very last script, have it block, and then call waitForLoad which imemdiately calls us back re-entrantly. My new guard of !m_parsingBlockingScript.cachedScript()->isLoaded() should prevent this. Am I missing something still? 247628 30 tonyg 2010-07-07 10:21:09 -0700 (In reply to comment #29) > (In reply to comment #27) > > (From update of attachment 60302 [details] [details]) > > Why can't we ASSERT right here: > > 33 while (!m_scriptsToExecuteAfterParsing.isEmpty()) { > > 234 ASSERT(!haveParsingBlockingScript()); > > > > that stylesheets are done? > > My latest test case triggers the condition where stylesheets are not done at that line (a doc.write of a stylesheet from a deferred script). > > In that case, the first deferred script becomes the parsing blocking script, and executeParsingBlockingScripts()'s call to isPendingScriptReady() sets us into m_hasScritpsWaitingForStylesheets state. When the stylesheet loads, the m_parsingBlockingScript executes and the remaining deferred scripts are run (if any). > > > > > I want to make it impossible for us to think we're running the very last script only to have us block on stylesheet loads. Or worse, have us try to run the very last script, have it block, and then call waitForLoad which imemdiately calls us back re-entrantly. > > My new guard of !m_parsingBlockingScript.cachedScript()->isLoaded() should prevent this. Am I missing something still? I don't want to let this drop. Does that explanation convince or do you think I'm still missing a bug? 247726 31 60302 eric 2010-07-07 13:35:22 -0700 Comment on attachment 60302 Patch Totally agreed! You shouldn't let this drop. :) Nor should I have.WebCore/html/HTMLScriptRunner.cpp:281 + m_scriptsToExecuteAfterParsing.append(pendingScript); Why don't we want to check m_parsingBlockingScript.cachedScript() here? It seems strange to have the watchForLoad stuff outside of requestScript. requestScript coudl return a success bool which we could use to judge if we should waitForLoad if it's not loaded or something. requestScript could simply return a pointer to the cachedScript() too. It seems that we don't want to put the pendingScript on the "executeAfterParsing" list if it failed to be requested? Do we need to test when the before-load event fires for deferred scripts? Currently it fires synchronously as they're parsed. is that correct? This is just complicated stuff. Your job as the patch submitter is to convince me it's right. :) And my job as the reviewer is to use my (hopefully helpful) knowledge of the code to understand what could go wrong. I think this is very close, and we could probably land it as-is. But I'm curious as to your answers to the above questions first. 258049 32 63027 tonyg 2010-07-29 21:25:56 -0700 Created attachment 63027 Patch 258051 33 tonyg 2010-07-29 21:27:45 -0700 As per our offline conversation, I've added a lot of new tests. Please let me know if they happen to trigger any more ideas for tricky scenarios we could throw at it. The code change is just that bit about returning a boolean from requestScript and only adding to the queue if a request was actually made. 258054 34 63029 tonyg 2010-07-29 21:31:30 -0700 Created attachment 63029 Fix tab in ChangeLog 258143 35 63029 eric 2010-07-30 04:44:44 -0700 Comment on attachment 63029 Fix tab in ChangeLog LayoutTests/fast/dom/HTMLScriptElement/defer-double-defer-write.html:14 + onbeforeload="doubleWrite(4)" Why does this onbeforeload run at a different time than the one in the next test? This one seems to run after the 3, the next test it runs immediately? Is it racey? LayoutTests/fast/dom/HTMLScriptElement/defer-double-write.html:14 + onbeforeload="doubleWrite(3)" Here is the other onbeforeload your'e expecting to run at a different time than the other one. I'm not sure how tehse two tests are different. Oh, I see, the first one uses a "double defer". But I still wouldn't expect the onbeforeload time to change?LayoutTests/fast/dom/HTMLScriptElement/defer-inline-script.html:11 + <script defer> Excellent. This test coudl probably be simpler with just a little document.write(). :) The script-testing stuff is useful, but you don't really seem to be uing it here. :) LayoutTests/fast/dom/HTMLScriptElement/defer-onbeforeload.html:8 + Checks that deferred scripts fire onbeforeload immediately and that it is cancellable. This test seems to have conflicting expectations with teh first one... LayoutTests/fast/dom/HTMLScriptElement/defer-onbeforeload.html:10 + <script src="resources/shouldnotexecute.js" onbeforeload="return false;" defer></script> Seems you'd want to log here, no? LayoutTests/fast/dom/HTMLScriptElement/defer-script-invalid-url.html:10 + <script src="http://invalid:999999/" defer></script> Do we need/want to check timing expectations of onerror? That might be racey though. LayoutTests/fast/dom/HTMLScriptElement/resources/shouldnotexecute.js:1 + debug("should not execute"); Might put FAIL in there. LayoutTests/http/tests/misc/resources/script-debug-body-background.js:1 + debug('Body background: ' + getComputedStyle(document.body)['background-color']); This should ideally contain the expectation in it. Since you're using the full-blown js-test-pre.js harness, you could use shouldBe here or shouldBeEqualToString LayoutTests/http/tests/misc/script-defer-write-slow-stylesheet.html:18 + <script src="http://127.0.0.1:8000/misc/resources/script-write-slow-stylesheet.js" defer="defer"></script> So this is testing that writing a stylesheet from a defer script will delay DOMContentLoaded, right? WebCore/html/HTMLScriptRunner.cpp:251 + AtomicString srcValue = scriptElement->getAttribute(srcAttr); const AtomicString& srcValue should be sufficient (and prevents one uneeded ref). WebCore/html/HTMLScriptRunner.cpp:257 + pendingScript.element = scriptElement; Do we need to end up clearing this in the failure case? I guess not, since we weren't doing so before? WebCore/html/HTMLScriptRunner.cpp:276 + if (madeRequest && !m_parsingBlockingScript.cachedScript()->isLoaded()) I think I would have made the m_parsingBlockingScript.cachedScript() dependance explicit here: if (madeRequest) { ASSERT(m_parsingBlockingScript.cachedScript()); if (!m_parsingBlockingScript.cachedScript()->isLoaded()) watchForLoad(m_parsingBlockingScript); } Since requestScript can return w/o a cachedScript(), we should ASSERT that the bool and cachedScript() always agree somewhere. WebCore/html/HTMLScriptRunner.cpp:283 + bool madeRequest = requestScript(pendingScript, scriptElement); This is a success bool, it seems. I'm not sure the name "madeRequest" helps me here. My first thought was "oh, do I need to call it again?" Maybe "requestSuccessfull"? Or just throw it in the if block itself w/o a local variable would be OK too. (This is a nit, and not a big deal.) In general this looks fine. I think we could go one more round for nits. 258274 36 tonyg 2010-07-30 10:34:04 -0700 (In reply to comment #35) > (From update of attachment 63029 [details]) > LayoutTests/fast/dom/HTMLScriptElement/defer-double-defer-write.html:14 > + onbeforeload="doubleWrite(4)" > Why does this onbeforeload run at a different time than the one in the next test? This one seems to run after the 3, the next test it runs immediately? Is it racey? It isn't racey. The onbeforeload runs at the right time. Notice that it doesn't write any numbers, it only writes deferred scripts which don't write the numbers until later. I've added a write directly to the onbeforeload handler to make that clear and verify that it runs at the right time. > > LayoutTests/fast/dom/HTMLScriptElement/defer-double-write.html:14 > + onbeforeload="doubleWrite(3)" > Here is the other onbeforeload your'e expecting to run at a different time than the other one. I'm not sure how tehse two tests are different. > > Oh, I see, the first one uses a "double defer". But I still wouldn't expect the onbeforeload time to change? See above comment. Should be clear that the onbeforeload time is the same now. > LayoutTests/fast/dom/HTMLScriptElement/defer-inline-script.html:11 > + <script defer> > Excellent. This test coudl probably be simpler with just a little document.write(). :) The script-testing stuff is useful, but you don't really seem to be uing it here. :) Done. > > LayoutTests/fast/dom/HTMLScriptElement/defer-onbeforeload.html:8 > + Checks that deferred scripts fire onbeforeload immediately and that it is cancellable. > This test seems to have conflicting expectations with teh first one... See first comment. > > LayoutTests/fast/dom/HTMLScriptElement/defer-onbeforeload.html:10 > + <script src="resources/shouldnotexecute.js" onbeforeload="return false;" defer></script> > Seems you'd want to log here, no? Good idea. Done. > > LayoutTests/fast/dom/HTMLScriptElement/defer-script-invalid-url.html:10 > + <script src="http://invalid:999999/" defer></script> > Do we need/want to check timing expectations of onerror? That might be racey though. There is currently a bug about onerror not being fired for invalid URLs. I have a local patch started to fix that, but don't want to complicate these expectations for now. http://crbug.com/39423 > > LayoutTests/fast/dom/HTMLScriptElement/resources/shouldnotexecute.js:1 > + debug("should not execute"); > Might put FAIL in there. Done. > > LayoutTests/http/tests/misc/resources/script-debug-body-background.js:1 > + debug('Body background: ' + getComputedStyle(document.body)['background-color']); > This should ideally contain the expectation in it. Since you're using the full-blown js-test-pre.js harness, you could use shouldBe here or shouldBeEqualToString Done. > > LayoutTests/http/tests/misc/script-defer-write-slow-stylesheet.html:18 > + <script src="http://127.0.0.1:8000/misc/resources/script-write-slow-stylesheet.js" defer="defer"></script> > So this is testing that writing a stylesheet from a defer script will delay DOMContentLoaded, right? Yes. I've updated the description to reflect that. > > WebCore/html/HTMLScriptRunner.cpp:251 > + AtomicString srcValue = scriptElement->getAttribute(srcAttr); > const AtomicString& srcValue should be sufficient (and prevents one uneeded ref). Oops. Good catch. Fixed. > > WebCore/html/HTMLScriptRunner.cpp:257 > + pendingScript.element = scriptElement; > Do we need to end up clearing this in the failure case? I guess not, since we weren't doing so before? No, because it ASSERTs that it is clear in the first line of this method. > > WebCore/html/HTMLScriptRunner.cpp:276 > + if (madeRequest && !m_parsingBlockingScript.cachedScript()->isLoaded()) > I think I would have made the m_parsingBlockingScript.cachedScript() dependance explicit here: > > if (madeRequest) { > ASSERT(m_parsingBlockingScript.cachedScript()); > if (!m_parsingBlockingScript.cachedScript()->isLoaded()) > watchForLoad(m_parsingBlockingScript); > } > > Since requestScript can return w/o a cachedScript(), we should ASSERT that the bool and cachedScript() always agree somewhere. Good call. I did that here and in requestDeferredScript(). > > WebCore/html/HTMLScriptRunner.cpp:283 > + bool madeRequest = requestScript(pendingScript, scriptElement); > This is a success bool, it seems. > > I'm not sure the name "madeRequest" helps me here. My first thought was "oh, do I need to call it again?" > > Maybe "requestSuccessfull"? Or just throw it in the if block itself w/o a local variable would be OK too. I got rid of the variable. > > (This is a nit, and not a big deal.) > > In general this looks fine. I think we could go one more round for nits. 258277 37 63078 tonyg 2010-07-30 10:36:11 -0700 Created attachment 63078 Patch 259056 38 tonyg 2010-08-02 12:52:15 -0700 > In general this looks fine. I think we could go one more round for nits. Do you want to do one more round or should I take the previous r+? 259074 39 63078 eric 2010-08-02 13:41:59 -0700 Comment on attachment 63078 Patch LGTM! 260027 40 63078 commit-queue 2010-08-04 08:11:16 -0700 Comment on attachment 63078 Patch Rejecting patch 63078 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--exit-after-n-failures=1', '--ignore-tests', 'compositing', '--quiet']" exit_code: 1 Running build-dumprendertree Compiling Java tests make: Nothing to be done for `default'. Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Testing 20784 test cases. fast/dom/HTMLScriptElement/defer-script-invalid-url.html -> failed Exiting early after 1 failures. 6694 tests run. 132.45s total testing time 6693 test cases (99%) succeeded 1 test case (<1%) had incorrect layout Full output: http://queues.webkit.org/results/3572870 260194 41 tonyg 2010-08-04 13:39:51 -0700 Committed r64674: <http://trac.webkit.org/changeset/64674> 260199 42 tonyg 2010-08-04 13:54:17 -0700 > fast/dom/HTMLScriptElement/defer-script-invalid-url.html -> failed This test was working as intended but displaying a "blocked external resource request" message at the top. I changed http://invalid:99999 to http://localhost:99999 and landed. 260205 43 webkit.review.bot 2010-08-04 14:12:03 -0700 http://trac.webkit.org/changeset/64674 might have broken GTK Linux 64-bit Debug 260678 44 tonyg 2010-08-05 10:14:37 -0700 Rolled back due to incompatibility with HTML5 tree builder which was enabled last night. I'm going to rework this so that the insertion point is undefined when deferred scripts are run (which means no doc.write from deferred scripts). That is the behavior specced by HTML5 and it should be fine as IE's original definition of defer was basically a contract that the script won't do any doc.writes. 260968 45 tonyg 2010-08-05 17:11:21 -0700 Updating with a quick survey of document.write in deferred script behavior: IE5-IE9: Blow away document FF3.6: Blow away document Minefield: Drop document.write The HTML5 spec, says to set the insertion point to undefined before running deferred scripts, but it isn't immediately clear to me whether that means writes should blow away the doc or be dropped. I'm reading more carefully now. 262464 46 63968 tonyg 2010-08-09 20:09:23 -0700 Created attachment 63968 Work in progress 265604 47 64600 tonyg 2010-08-17 09:41:16 -0700 Created attachment 64600 Testcase This is the test case I had in mind. First close() detaches, then write() implicitly reopens the document. In the previous attempts, we bailed out of pumpTokenizer() after the first token, so I'd expect this would have resulted in a document with only "<p>" (but haven't verified). Your patch should continue the loop through all tokens and result in a document with "<p>1<p>2". This also means your comment that the parser doesn't touch webcore after detach isn't strictly true. 265606 48 tonyg 2010-08-17 09:43:05 -0700 (In reply to comment #47) > Created an attachment (id=64600) [details] > Testcase Oops, wrong tab == wrong bug :-( 272168 49 66066 tonyg 2010-08-31 10:10:47 -0700 Created attachment 66066 Patch 272257 50 66066 eric 2010-08-31 12:01:42 -0700 Comment on attachment 66066 Patch > WebCore/html/parser/HTMLDocumentParser.cpp:346 > + stop(); I'm not sure stop() is the right name here. Since it doesn't set m_parserStopped. > WebCore/html/parser/HTMLDocumentParser.h:137 > + bool m_active; // http://www.whatwg.org/specs/web-apps/current-work/#active-parser Why not just use m_parserStopped? 272348 51 tonyg 2010-08-31 14:01:02 -0700 (In reply to comment #50) > (From update of attachment 66066 [details]) > > WebCore/html/parser/HTMLDocumentParser.cpp:346 > > + stop(); > I'm not sure stop() is the right name here. Since it doesn't set m_parserStopped. Very good point. More details below, but I'm trying out prepareToEnd(). > > > WebCore/html/parser/HTMLDocumentParser.h:137 > > + bool m_active; // http://www.whatwg.org/specs/web-apps/current-work/#active-parser > Why not just use m_parserStopped? m_parserStopped is set too late -- closer to the end of 10.2.6 #the-end. When it is set, it does things like prevent further inserts/appends which isn't correct when running deferred scripts. I need something that indicates we're in the deferred scripts phase so that notifiyFinished() can direct the load and inScriptExecution() won't prevent implicit open()s. So I've changed it to m_runningDeferredScripts, please let me know what you think. 272349 52 66099 tonyg 2010-08-31 14:01:21 -0700 Created attachment 66099 Naming fixes 272360 53 eric 2010-08-31 14:13:09 -0700 OK. Seems we're building a state machine with bools. What about this: enum ParserState { InitialState, ParsingState, RunningDeferredScriptsState, StoppedState, DetachedState, }; That's an approximation, but maybe the idea is sound? 272386 54 tonyg 2010-08-31 14:41:16 -0700 (In reply to comment #53) > OK. Seems we're building a state machine with bools. > > What about this: > > enum ParserState { > InitialState, > ParsingState, > RunningDeferredScriptsState, > StoppedState, > DetachedState, > }; > > That's an approximation, but maybe the idea is sound? Yeah, that sounds very reasonable. Before I go down that path, just wanted to bounce one alternative by you. The state will need to be tracked on the Document's readyState as well. It currently has an m_bParsing attribute and a really shady implementation of readyState(). I could instead do this on Document: enum ReadyState { Loading, Interactive, Complete } Then DocumentParser could use m_document->readyState() == Interactive as RunningDeferredScriptsState and everything else would be untouched. 272396 55 eric 2010-08-31 14:49:00 -0700 I don't know what that would look like, but sounds sane. I think we eventually need a state machine in the parser too, or maybe they're the same thing. it's unclear to me. 272400 56 tonyg 2010-08-31 14:50:59 -0700 (In reply to comment #55) > I don't know what that would look like, but sounds sane. > > I think we eventually need a state machine in the parser too, or maybe they're the same thing. it's unclear to me. OK. I'll explore and see which one turns out cleaner. As another point, it would be kind of odd to have a RunningDeferredScriptsState in DocumentParser when not all subclasses would utilize that state. 272561 57 66157 tonyg 2010-08-31 18:34:58 -0700 Created attachment 66157 Use enum for parser state 272565 58 webkit-ews 2010-08-31 18:46:34 -0700 Attachment 66157 did not build on qt: Build output: http://queues.webkit.org/results/3917003 272600 59 66162 tonyg 2010-08-31 20:09:52 -0700 Created attachment 66162 Fix Qt build 272608 60 66162 abarth 2010-08-31 20:21:37 -0700 Comment on attachment 66162 Fix Qt build View in context: https://bugs.webkit.org/attachment.cgi?id=66162&action=prettypatch This looks great. A few minor comments below. The bitfield one is the main thing. > WebCore/ChangeLog:16 > +2010-08-31 Tony Gentilcore <tonyg@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Support <script defer> as specified by HTML5 > + https://bugs.webkit.org/show_bug.cgi?id=40934 > + > + Tests: fast/dom/HTMLScriptElement/defer-double-defer-write.html > + fast/dom/HTMLScriptElement/defer-double-write.html > + fast/dom/HTMLScriptElement/defer-inline-script.html > + fast/dom/HTMLScriptElement/defer-onbeforeload.html > + fast/dom/HTMLScriptElement/defer-script-invalid-url.html > + fast/dom/HTMLScriptElement/defer-write.html > + fast/dom/HTMLScriptElement/two-defer-writes.html > + http/tests/misc/script-defer-after-slow-stylesheet.html > + http/tests/misc/script-defer.html So much boilerplate in the ChangeLog but no actual text. :) > WebCore/dom/DocumentParser.h:69 > + bool isParsing() const { return m_state == ParsingState; } > + bool isActive() const { return m_state & (ParsingState | StoppingState); } > + bool isStopping() const { return m_state == StoppingState; } > + bool isDetached() const { return m_state == DetachedState; } Can you ASSERT m_document (as appropriate) in these states? > WebCore/dom/DocumentParser.h:100 > + enum ParserState { > + ParsingState = 0x1, > + StoppingState = 0x2, > + StoppedState = 0x4, > + DetachedState = 0x8 > + }; Woah. Do we really need a bit field here? It seems like an enum should be enough. 272614 61 tonyg 2010-08-31 20:54:28 -0700 > So much boilerplate in the ChangeLog but no actual text. :) Sorry, I keep losing my comments with all the iterations here. I'll add them back before landing. > Can you ASSERT m_document (as appropriate) in these states? Unfortunately that wouldn't be very clean as these are just checking the state so they may be called at any time. I'd have to do something like ASSERT(m_state == ParsingState || m_state == StoppingState || m_state == StoppedState || !m_document); Is that what you have in mind? > Woah. Do we really need a bit field here? It seems like an enum should be enough. I thought it would be more efficient, but it looks like the compiler is smart enough to optimize away the two states in isActive(). So I've removed the bitfield. Thanks for the review. Will land in the morning. 272628 62 abarth 2010-08-31 21:46:55 -0700 > > Woah. Do we really need a bit field here? It seems like an enum should be enough. > I thought it would be more efficient, but it looks like the compiler is smart enough to optimize away the two states in isActive(). So I've removed the bitfield. Thanks. 272640 63 66162 eric 2010-08-31 22:20:01 -0700 Comment on attachment 66162 Fix Qt build View in context: https://bugs.webkit.org/attachment.cgi?id=66162&action=prettypatch > WebCore/dom/Document.cpp:1827 > + if (m_frame->loader()->isLoadingMainResource() || (parser && parser->isParsing() && parser->isExecutingScript())) Why the extra check needed here? > WebCore/dom/DocumentParser.h:61 > virtual bool processingData() const { return false; } We should just remove this now since clearly it doesn't work anymore... (A matter for a separate bug.) > WebCore/dom/DocumentParser.h:67 > + bool isActive() const { return m_state & (ParsingState | StoppingState); } I would have used a < I thought you moved off of bitfields? > WebCore/dom/DocumentParser.h:100 > + }; Ah, I see, not yet moved off of a bitfield in this patch. > WebCore/dom/XMLDocumentParser.cpp:135 > + if (!isActive() || m_sawXSLTransform) !isActive() seems a strange check. why not just isStopped() and have "stopped" check m_state >= Stopped? > WebCore/html/parser/HTMLDocumentParser.cpp:163 > + if (m_scriptRunner) { > + if (!m_scriptRunner->executeScriptsWaitingForParsing()) Why not combine these into one line? !isActive() feels a little strange. Thanks again for all your work on this! 272820 64 tonyg 2010-09-01 08:47:49 -0700 > > + if (m_frame->loader()->isLoadingMainResource() || (parser && parser->isParsing() && parser->isExecutingScript())) > Why the extra check needed here? When this condition is satisfied, the method bails out early thus preventing an implicit open from a write() in a deferred script. In an earlier version of the patch, I had added the check to isExecutingScript() so that it only returns true when executing a parsing-blocking script, not a deferred script. But now that the method is accessible on parser, this seems cleaner. Let me know if you want it moved. > > virtual bool processingData() const { return false; } > We should just remove this now since clearly it doesn't work anymore... (A matter for a separate bug.) Yep, I can put together a subsequent patch. > > + bool isActive() const { return m_state & (ParsingState | StoppingState); } > I would have used a < I thought you moved off of bitfields? Done. > > + if (!isActive() || m_sawXSLTransform) > !isActive() seems a strange check. why not just isStopped() and have "stopped" check m_state >= Stopped? Good call. Done. > > + if (m_scriptRunner) { > > + if (!m_scriptRunner->executeScriptsWaitingForParsing()) > Why not combine these into one line? That was the original. You asked to break it up in Comment #21. Going back to one line now ;-) 272832 65 66219 tonyg 2010-09-01 09:11:09 -0700 Created attachment 66219 Patch for landing 272880 66 66219 commit-queue 2010-09-01 10:31:01 -0700 Comment on attachment 66219 Patch for landing Rejecting patch 66219 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--exit-after-n-failures=1', '--wait-for-httpd', '--ignore-tests', 'compositing,media', '--quiet']" exit_code: 1 Running build-dumprendertree Compiling Java tests make: Nothing to be done for `default'. Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Testing 20902 test cases. fast/dom/HTMLScriptElement/defer-inline-script.html -> failed Exiting early after 1 failures. 6743 tests run. 164.54s total testing time 6742 test cases (99%) succeeded 1 test case (<1%) had incorrect layout Full output: http://queues.webkit.org/results/3974018 273046 67 66281 tonyg 2010-09-01 15:03:40 -0700 Created attachment 66281 Patch for landing 273262 68 66281 commit-queue 2010-09-02 02:06:27 -0700 Comment on attachment 66281 Patch for landing Clearing flags on attachment: 66281 Committed r66649: <http://trac.webkit.org/changeset/66649> 273263 69 commit-queue 2010-09-02 02:06:36 -0700 All reviewed patches have been landed. Closing bug. 273303 70 webkit.review.bot 2010-09-02 03:38:45 -0700 http://trac.webkit.org/changeset/66649 might have broken Qt Linux Release 273361 71 ossy 2010-09-02 06:07:25 -0700 Reopened, because it was rolled out by http://trac.webkit.org/changeset/66660 Qt bot got the following (or similar) error for ~2000 tests: "This page contains the following errors: error on line 1 at column 2: Below is a rendering of the page up to the first error." 273403 72 tonyg 2010-09-02 08:43:31 -0700 > Qt bot got the following (or similar) error for ~2000 tests: > "This page contains the following errors: > error on line 1 at column 2: > Below is a rendering of the page up to the first error." Oops, it looks like I swapped startParsing() and stopParsing() in the XMLDocumentParserQt.cpp :-( Fixed and landing w/o the cq. I'll watch it as it lands this time. 273405 73 tonyg 2010-09-02 08:46:12 -0700 Committed r66670: <http://trac.webkit.org/changeset/66670> 59276 2010-06-21 12:58:49 -0700 2010-06-29 13:27:28 -0700 Patch bug-40934-20100621125847.patch text/plain 11649 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiMTU1ZWYyZmQ3NDJiOTlkNjQwY2U4YzU0MjU2MTBmZmM0YjE3OTZmLi5jYjE0ZWQ3 YWM2MzA3YjBlODg4NDkyMzZlZmIzNjQyNDNiMmU3NGM2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAK KzIwMTAtMDYtMjEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgTGF5b3V0VGVz dCBmb3IgPHNjcmlwdCBkZWZlcj4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAgRW5zdXJlcyB0aGF0IGRlZmVycmVkIHNjcmlw dHMgYXJlIGV4ZWN1dGVkIGJlZm9yZSBETEMgYW5kIGluIHRoZSBvcmRlcgorICAgICAgICB0aGV5 IGFyZSBpbmNsdWRlZCByZWdhcmRsZXNzIG9mIHdoZW4gdGhleSBsb2FkLgorCisgICAgICAgICog aHR0cC90ZXN0cy9sb2FkaW5nL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAg ICAgICAqIGh0dHAvdGVzdHMvbG9hZGluZy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBB ZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL2xvYWRpbmcvcmVzb3VyY2VzL3Nsb3ctZGVmZXIt c2NyaXB0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9sb2FkaW5nL3NjcmlwdC1k ZWZlci1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbG9hZGluZy9z Y3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuCisKIDIwMTAtMDYtMjEgIER1bWl0cnUgRGFuaWxpdWMg IDxkdW1pQGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkLCBmaXhpbmcgZXhwZWN0 YXRpb25zLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9sb2FkaW5nL3Jlc291 cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2xvYWRpbmcvcmVz b3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yYzg0YjQ4NzY0M2IwZjM3ODI4MGEw YjgxYTRjNmQ5OTRiNjkyOThlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9sb2FkaW5nL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMKQEAgLTAsMCArMSBAQAord2lu ZG93LnN0YXR1cyArPSAiIGRlZmVyICI7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL2xvYWRpbmcvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbG9hZGluZy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmU4ZmQwMzlhZDA5MmI1YWI2NDcxY2RmODQ5MmYyODJiYmM4MzBkY2IKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2xvYWRpbmcvcmVzb3VyY2VzL2V4dGVybmFsLXNj cmlwdC5qcwpAQCAtMCwwICsxIEBACit3aW5kb3cuc3RhdHVzICs9ICIgZXh0ZXJuYWwgIjsKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbG9hZGluZy9yZXNvdXJjZXMvc2xvdy1k ZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9sb2FkaW5nL3Jlc291cmNl cy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNWRlNjAzMDg3NGI5OTE4ZDdlMmI4 MTMyOTY0ZWI0ZjhiZTI5NGIwYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbG9hZGluZy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEs NSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2 YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJ3aW5kb3cuc3RhdHVzICs9ICcgc2xv d0RlZmVyICc7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9sb2FkaW5n L3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2xvYWRp bmcvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41MDM1OTI1ZWMwY2Y2ZjZl ZDU4YzQ5Njk1ZjIwOGYwNzkwZDc5YmVhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9sb2FkaW5nL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4 IEBACittYWluIGZyYW1lIC0gZGlkU3RhcnRQcm92aXNpb25hbExvYWRGb3JGcmFtZQ0KK21haW4g ZnJhbWUgLSBkaWRDb21taXRMb2FkRm9yRnJhbWUNCittYWluIGZyYW1lIC0gZGlkUmVjZWl2ZVRp dGxlOiA8U0NSSVBUPiBkZWZlcg0KK21haW4gZnJhbWUgLSBkaWRGaW5pc2hEb2N1bWVudExvYWRG b3JGcmFtZQ0KK21haW4gZnJhbWUgLSBkaWRIYW5kbGVPbmxvYWRFdmVudHNGb3JGcmFtZQ0KK21h aW4gZnJhbWUgLSBkaWRGaW5pc2hMb2FkRm9yRnJhbWUNCitUaGlzIHRlc3RzIGZvciBwcm9wZXIg ZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4NCitQQVNTDQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9sb2FkaW5nL3NjcmlwdC1kZWZlci5odG1sIGIv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9sb2FkaW5nL3NjcmlwdC1kZWZlci5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmY2NGEzYjllNGU1NzM4ZDdhOWE5NzJjNTBiNjEyZjUxMDg1M2ZhMDMKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL2xvYWRpbmcvc2NyaXB0LWRlZmVyLmh0bWwK QEAgLTAsMCArMSwzNyBAQAorPGh0bWw+Cis8aGVhZD4KKzx0aXRsZT4mbHQ7U0NSSVBUJmd0OyBk ZWZlcjwvdGl0bGU+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+Cit3aW5kb3cuc3Rh dHVzID0gJyc7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQi LCBmdW5jdGlvbigpIHsKKyAgd2luZG93LnN0YXR1cyArPSAoJyBEQ0wgJykKK30sIGZhbHNlKTsK KyAKK2Z1bmN0aW9uIHRlc3QoKQoreworICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworICAgIHZh ciBleHBlY3RlZCA9ICIgZXh0ZXJuYWwgIGlubGluZSAgc2xvd0RlZmVyICBkZWZlciAgRENMICI7 CisgICAgdmFyIHJlc3VsdHMgPSAiUEFTUyI7CisgICAgaWYgKHdpbmRvdy5zdGF0dXMgIT0gZXhw ZWN0ZWQpCisgICAgICAgIHJlc3VsdHMgPSAiRkFJTDogRXhwZWN0ZWQ9JyIgKyBleHBlY3RlZCAr ICInLCBBY3R1YWw9JyIgKyB3aW5kb3cuc3RhdHVzICsgIiciOworICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJIVE1MID0gcmVzdWx0czsKK30KKzwvc2NyaXB0Pgor Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL2xvYWRpbmcvcmVzb3VyY2VzL3Ns b3ctZGVmZXItc2NyaXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3Jj PSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbG9hZGluZy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0Lmpz IiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6 ODAwMC9sb2FkaW5nL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0PgorPHNj cmlwdD4KK3dpbmRvdy5zdGF0dXMgKz0gIiBpbmxpbmUgIjsKKzwvc2NyaXB0PgorCis8L2hlYWQ+ Cis8Ym9keSBvbmxvYWQ9InRlc3QoKSI+CitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9u IG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIDxhIGhyZWY9Imh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMCI+aHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNzEwPC9hPi4KKzxocj4KKzxwIGlkPSJyZXN1bHRz Ij5GQUlMOiBUZXN0IG5ldmVyIGZpbmlzaGVkLjwvcD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAt LWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYjVkYmNi MThmZWIzYjJmZDI4YzNiN2JlODUxYzIyMzMyNGQ5ZGZhYS4uMDdjNjcwOGU3OGIyZGIwNzAxMDE2 ZjlhNTQwOWU3NGYwZmNiNTFiNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxMC0wNi0yMSAgVG9ueSBHZW50 aWxjb3JlICA8dG9ueWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFN1cHBvcnQgPHNjcmlwdCBkZWZlcj4gYXMgc3BlY2lmaWVk IGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD00MDkzNAorCisgICAgICAgIFNlZTogaHR0cDovL2Rldi53My5vcmcvaHRtbDUvc3BlYy9PdmVy dmlldy5odG1sI3RoZS1lbmQKKworICAgICAgICBUZXN0OiBodHRwL3Rlc3RzL2xvYWRpbmcvc2Ny aXB0LWRlZmVyLmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTDVEb2N1bWVudFBhcnNlci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpIVE1MNURvY3VtZW50UGFyc2VyOjplbmQpOgorICAgICAgICAq IGh0bWwvSFRNTDVTY3JpcHRSdW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTDVTY3Jp cHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcpOgorICAgICAgICAoV2Vi Q29yZTo6SFRNTDVTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQpOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTDVTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTDVTY3JpcHRSdW5uZXI6OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6 CisgICAgICAgIChXZWJDb3JlOjpIVE1MNVNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KToKKyAgICAg ICAgKiBodG1sL0hUTUw1U2NyaXB0UnVubmVyLmg6CisKIDIwMTAtMDYtMjEgIEhhbnMgV2VubmJv cmcgIDxoYW5zQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBKZXJlbXkgT3Js b3cuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTDVEb2N1bWVudFBhcnNlci5jcHAgYi9X ZWJDb3JlL2h0bWwvSFRNTDVEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggODljY2Y1NzkwOTNjMTA5 OTljMDk1OTI1OTgyNDk0YTlhN2RiYmE3NS4uZTE5NjljOGQwZDk5OTYxOTdlMGQxNTM4YmE5MTUx ZGIyMjFkZjkxYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUw1RG9jdW1lbnRQYXJzZXIu Y3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MNURvY3VtZW50UGFyc2VyLmNwcApAQCAtMzAxLDgg KzMwMSwxNCBAQCB2b2lkIEhUTUw1RG9jdW1lbnRQYXJzZXI6OmVuZCgpCiAgICAgLy8gc28gRm9y Y2VTeW5jaHJvbm91cyB2cy4gQWxsb3dZaWVsZCBzaG91bGQgYmUgbWVhbmluZ2xlc3MuCiAgICAg cHVtcExleGVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsKIAotICAgIC8vIEluZm9ybXMg dGhlIHRoZSByZXN0IG9mIFdlYkNvcmUgdGhhdCBwYXJzaW5nIGlzIHJlYWxseSBmaW5pc2hlZCAo YW5kIGRlbGV0ZXMgdGhpcykuCi0gICAgbV90cmVlQ29uc3RydWN0b3ItPmZpbmlzaGVkKCk7Cisg ICAgLy8gRklYTUU6IFNldCB0aGUgY3VycmVudCBkb2N1bWVudCByZWFkaW5lc3MgdG8gImludGVy YWN0aXZlIi4KKworICAgIG1fZW5kV2FzRGVsYXllZCA9ICFtX3NjcmlwdFJ1bm5lci0+ZXhlY3V0 ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpOworICAgIG1fdHJlZUNvbnN0cnVjdG9yLT5zZXRQ YXVzZWQobV9lbmRXYXNEZWxheWVkKTsKKyAgICBpZiAoIW1fZW5kV2FzRGVsYXllZCkgeworICAg ICAgICAvLyBJbmZvcm1zIHRoZSB0aGUgcmVzdCBvZiBXZWJDb3JlIHRoYXQgcGFyc2luZyBpcyBy ZWFsbHkgZmluaXNoZWQgKGFuZCBkZWxldGVzIHRoaXMpLgorICAgICAgICBtX3RyZWVDb25zdHJ1 Y3Rvci0+ZmluaXNoZWQoKTsKKyAgICB9CiB9CiAKIHZvaWQgSFRNTDVEb2N1bWVudFBhcnNlcjo6 YXR0ZW1wdFRvRW5kKCkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MNVNjcmlwdFJ1bm5l ci5jcHAgYi9XZWJDb3JlL2h0bWwvSFRNTDVTY3JpcHRSdW5uZXIuY3BwCmluZGV4IDQwZjQ0NjU0 NDBlMGU4Njk3ZGNjNzI4MzAwNTBkMWY2NWVkODY2NjguLmRkYzVlNWI5MGJmOWMyNDE1MTg4NDgz Njk2NjdkMWZjMGExNTczNjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MNVNjcmlwdFJ1 bm5lci5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0hUTUw1U2NyaXB0UnVubmVyLmNwcApAQCAtMjI1 LDI1ICsyMjUsNDIgQEAgYm9vbCBIVE1MNVNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yU3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2Ny aXB0cygpOwogfQogCi12b2lkIEhUTUw1U2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KEVsZW1l bnQqIHNjcmlwdCkKK2Jvb2wgSFRNTDVTY3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGlu Z0ZvclBhcnNpbmcoKQogewotICAgIEFTU0VSVCghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuZWxl bWVudCk7Ci0gICAgQXRvbWljU3RyaW5nIHNyY1ZhbHVlID0gc2NyaXB0LT5nZXRBdHRyaWJ1dGUo c3JjQXR0cik7Ci0gICAgLy8gQWxsb3cgdGhlIGhvc3QgdG8gZGlzbGxvdyBzY3JpcHQgbG9hZHMg KHVzaW5nIHRoZSBYU1NBdWRpdG9yLCBldGMuKQorICAgIHdoaWxlICghbV9zY3JpcHRzVG9FeGVj dXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdCA9IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAg ICAgaWYgKCFleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpKSB7CisgICAgICAgICAgICB3 YXRjaEZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIG1fc2NyaXB0c1RvRXhlY3V0 ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCk7Cit9CisKK3ZvaWQgSFRNTDVTY3JpcHRSdW5uZXI6OnJl cXVlc3RTY3JpcHQoUGVuZGluZ1NjcmlwdCYgcGVuZGluZ1NjcmlwdCwgRWxlbWVudCogc2NyaXB0 RWxlbWVudCkKK3sKKyAgICBBU1NFUlQoIXBlbmRpbmdTY3JpcHQuZWxlbWVudCk7CisgICAgQXRv bWljU3RyaW5nIHNyY1ZhbHVlID0gc2NyaXB0RWxlbWVudC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIp OwogICAgIGlmICghbV9ob3N0LT5zaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKHNyY1Zh bHVlKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgLy8gRklYTUU6IFdlIG5lZWQgdG8gcmVzb2x2 ZSB0aGUgdXJsIHJlbGF0aXZlIHRvIHRoZSBlbGVtZW50LgotICAgIG1fcGFyc2luZ0Jsb2NraW5n U2NyaXB0LmVsZW1lbnQgPSBzY3JpcHQ7Ci0gICAgaWYgKCFzY3JpcHQtPmRpc3BhdGNoQmVmb3Jl TG9hZEV2ZW50KHNyY1ZhbHVlKSkgLy8gUGFydCBvZiBIVE1MNT8KKyAgICBwZW5kaW5nU2NyaXB0 LmVsZW1lbnQgPSBzY3JpcHRFbGVtZW50OworICAgIGlmICghc2NyaXB0RWxlbWVudC0+ZGlzcGF0 Y2hCZWZvcmVMb2FkRXZlbnQoc3JjVmFsdWUpKSAvLyBQYXJ0IG9mIEhUTUw1PwogICAgICAgICBy ZXR1cm47CiAgICAgLy8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBv ciBpbnZhbGlkIHNyY1ZhbHVlcy4KLSAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1f ZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVs ZW1lbnQoc2NyaXB0KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBDYWNoZWRTY3JpcHQqIGNhY2hl ZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVl LCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0RWxlbWVudCktPnNjcmlwdENoYXJzZXQoKSk7CiAgICAg aWYgKCFjYWNoZWRTY3JpcHQpIHsKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gRGlzcGF0 Y2ggZXJyb3IgZXZlbnQuCiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgbV9wYXJzaW5nQmxv Y2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0ID0gY2FjaGVkU2NyaXB0OworICAgIHBlbmRpbmdTY3Jp cHQuY2FjaGVkU2NyaXB0ID0gY2FjaGVkU2NyaXB0OworfQorCit2b2lkIEhUTUw1U2NyaXB0UnVu bmVyOjpyZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KEVsZW1lbnQqIHNjcmlwdEVsZW1lbnQp Cit7CisgICAgcmVxdWVzdFNjcmlwdChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCwgc2NyaXB0RWxl bWVudCk7CiAKICAgICAvLyBBbHdheXMgY2FsbCB3YXRjaEZvckxvYWQsIGV2ZW4gaWYgdGhlIHNj cmlwdCBpcyBhbHJlYWR5IGxvYWRlZC4KICAgICAvLyBDYWNoZWRSZXNvdXJjZSBtYXkgcHVyZ2Ug aXRzIGRhdGEgaWYgaXQgaGFzIG5vIGNsaWVudHMsIHdoaWNoIHdvdWxkIGNhdXNlCkBAIC0yNTUs NiArMjcyLDEzIEBAIHZvaWQgSFRNTDVTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQoRWxlbWVu dCogc2NyaXB0KQogICAgIC8vIGJlZm9yZSByZXR1cm5pbmcgY29udHJvbCB0byB0aGUgcGFyc2Vy LgogfQogCit2b2lkIEhUTUw1U2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxl bWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7 CisgICAgcmVxdWVzdFNjcmlwdChwZW5kaW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsKKyAgICBt X3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcuYXBwZW5kKHBlbmRpbmdTY3JpcHQpOworfQor CiAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCB0byBtYXRjaCB0aGUgSFRNTDUgZGVmaW5pdGlvbiBv ZiAicnVubmluZyBhIHNjcmlwdCIKIC8vIGh0dHA6Ly93d3cud2hhdHdnLm9yZy9zcGVjcy93ZWIt YXBwcy9jdXJyZW50LXdvcmsvbXVsdGlwYWdlL3NjcmlwdGluZy0xLmh0bWwjcnVubmluZy1hLXNj cmlwdAogdm9pZCBIVE1MNVNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwg aW50IHN0YXJ0aW5nTGluZU51bWJlcikKQEAgLTI2NSw4ICsyODksMTEgQEAgdm9pZCBIVE1MNVNj cmlwdFJ1bm5lcjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0aW5nTGluZU51 bWJlcikKICAgICBub3RJbXBsZW1lbnRlZCgpOyAvLyBldmVudCBmb3Igc3VwcG9ydAogCiAgICAg aWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgIC8vIEZJWE1FOiBI YW5kbGUgZGVmZXIgYW5kIGFzeW5jCi0gICAgICAgIHJlcXVlc3RTY3JpcHQoc2NyaXB0KTsKKyAg ICAgICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYworICAgICAgICBpZiAoc2NyaXB0LT5oYXNBdHRy aWJ1dGUoZGVmZXJBdHRyKSkKKyAgICAgICAgICAgIHJlcXVlc3REZWZlcnJlZFNjcmlwdChzY3Jp cHQpOworICAgICAgICBlbHNlIAorICAgICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1Nj cmlwdChzY3JpcHQpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIC8vIEZJWE1FOiBXZSBkbyBub3Qg YmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVzaGVldHMgdG8gbWF0Y2ggdGhlCiAg ICAgICAgIC8vIG9sZCBwYXJzZXIgZm9yIG5vdy4gIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NDAwNDcKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MNVNj cmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9odG1sL0hUTUw1U2NyaXB0UnVubmVyLmgKaW5kZXggMzEw OTcyMDk2ZmI2YjI4YjI4OTYxMzFlNTQ0Yzk1ZjZiN2U4NTFlZS4uMDUyYTgyYzliZGM1YjQ3OTM0 OTJjYmZkNWQyMTVjMGM4ZTZlODkyZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUw1U2Ny aXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUw1U2NyaXB0UnVubmVyLmgKQEAgLTI4 LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCiAjaW5jbHVk ZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKKyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KICNpbmNs dWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogCkBA IC01NCw2ICs1NSw3IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFzU2NyaXB0c1dhaXRpbmdGb3JT dHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNo ZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKTsK KyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKTsKIAogICAgIGJvb2wg aW5TY3JpcHRFeGVjdXRpb24oKSB7IHJldHVybiAhIW1fc2NyaXB0TmVzdGluZ0xldmVsOyB9CiAK QEAgLTkzLDcgKzk1LDkgQEAgcHJpdmF0ZToKICAgICBib29sIGV4ZWN1dGVQYXJzaW5nQmxvY2tp bmdTY3JpcHRzKCk7CiAgICAgdm9pZCBleGVjdXRlUGVuZGluZ1NjcmlwdCgpOwogCi0gICAgdm9p ZCByZXF1ZXN0U2NyaXB0KEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3RTY3JpcHQoUGVuZGlu Z1NjcmlwdCYsIEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3Jp cHQoRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQqKTsK ICAgICB2b2lkIHJ1blNjcmlwdChFbGVtZW50KiwgaW50IHN0YXJ0aW5nTGluZU51bWJlcik7CiAK ICAgICAvLyBIZWxwZXJzIGZvciBkZWFsaW5nIHdpdGggSFRNTDVTY3JpcHRSdW5uZXJIb3N0CkBA IC0xMDcsNiArMTExLDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKICAg ICBIVE1MNVNjcmlwdFJ1bm5lckhvc3QqIG1faG9zdDsKICAgICBQZW5kaW5nU2NyaXB0IG1fcGFy c2luZ0Jsb2NraW5nU2NyaXB0OworICAgIERlcXVlPFBlbmRpbmdTY3JpcHQ+IG1fc2NyaXB0c1Rv RXhlY3V0ZUFmdGVyUGFyc2luZzsKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsK IAogICAgIC8vIFdlIG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0 IGV4ZWN1dGlvbiBpZiBzY3JpcHQK 60047 2010-06-29 13:27:32 -0700 2010-06-29 18:41:03 -0700 Patch bug-40934-20100629132731.patch text/plain 16792 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA3YWQ5ZTgyMjM0NjBjZjY3MTEwZDRhODc2YjAyY2QxOTRmMTBlZTQ4Li41NTZlYzJi M2Y2ZjNlNTk3NWIxMjA5NjZlZjdlYWRkMzYxYzMwMGE5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAK KzIwMTAtMDYtMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgTGF5b3V0VGVz dCBmb3IgPHNjcmlwdCBkZWZlcj4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAgRW5zdXJlcyB0aGF0IGRlZmVycmVkIHNjcmlw dHMgYXJlIGV4ZWN1dGVkIGJlZm9yZSBET01Db250ZW50TG9hZGVkIGFuZAorICAgICAgICBpbiB0 aGUgb3JkZXIgdGhleSBhcmUgaW5jbHVkZWQgKHJlZ2FyZGxlc3Mgb2Ygd2hlbiB0aGV5IGxvYWQp LgorCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6 IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2Ny aXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct ZGVmZXItc2NyaXB0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuCisKIDIwMTAtMDYtMjkgIE1pa2hhaWwgTmFnYW5vdiAg PG1uYWdhbm92QGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIHRleHQgZXhwZWN0 YXRpb25zIHVwZGF0ZSBhZnRlciByNjIxMjEuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQx YTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCww ICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2 NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVhNDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBA IC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaQpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5hOThkM2Q1YTgxZDM3ODg3NjkyYzczOTIyYzhkM2MyOWYxYjZiZDE4Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRl ZmVyLXNjcmlwdC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJp bnQgIkNvbnRlbnQtdHlwZTogdGV4dC9qYXZhc2NyaXB0XG5cbiI7CitzbGVlcCgwLjUpOworcHJp bnQgImRlYnVnKCdzbG93RGVmZXInKTtcbiI7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFkZTgzNjJl YTJjYjRiNTllOThlMTBjMGE0ODllNjFhYWFkNjYzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDggQEAKK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Ygc2NyaXB0 cyB3aXRoIHRoZSBkZWZlciBhdHRyaWJ1dGUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwNzEwLg0KK2V4dGVybmFsDQoraW5saW5lDQorc2xvd0RlZmVyDQorZGVmZXIN CitET01Db250ZW50TG9hZGVkDQorbG9hZA0KKw0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9zY3JpcHQtZGVmZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NWNmOGIzNTA3NWZhMThiZDYyM2Jj ZDZjYWQ2YWU2N2RlNWQzYzMzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sCkBAIC0wLDAgKzEsMjQgQEAKKzwhRE9DVFlQRSBI VE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0 YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11 dGYtOCIgLz4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNv dXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVz b3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0i ZGVidWcoJ2xvYWQnKSI+CitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9m IHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIDxhIGhyZWY9Imh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMCI+aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwNzEwPC9hPi4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8 c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVy KCJET01Db250ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9h ZGVkJyk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAu MC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIiBkZWZlcj0iREVG RVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jl c291cmNlcy9kZWZlci1zY3JpcHQuanMiIGRlZmVyPSJERUZFUiI+PC9zY3JpcHQ+Cis8c2NyaXB0 IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlw dC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0PgorZGVidWcoImlubGluZSIpOworPC9zY3JpcHQ+Cis8 L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDU1OGI4ZmQ0OGJjMTlmNGZmY2EzZTkwMTQzNmYxZGMyYTE3MDkzYzgu LmE5MTVkMzhkZGY4MjgyNjA5MDNmZGRhMmRlMzI3ZGEyZmNmYTQ2NTcgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAK KzIwMTAtMDYtMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBTZWU6IGh0dHA6Ly9kZXYu dzMub3JnL2h0bWw1L3NwZWMvT3ZlcnZpZXcuaHRtbCN0aGUtZW5kCisKKyAgICAgICAgVGVzdDog aHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sCisKKyAgICAgICAgKiBodG1sL0hUTUxE b2N1bWVudFBhcnNlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6 OmF0dGVtcHRUb0VuZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OmVu ZElmRGVsYXllZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OmV4ZWN1 dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQpOgorICAgICAgICAqIGh0bWwvSFRNTERv Y3VtZW50UGFyc2VyLmg6CisgICAgICAgICogaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OkhUTUxTY3JpcHRSdW5uZXIpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6fkhUTUxTY3JpcHRSdW5uZXIpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHQpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6aGF2ZVBhcnNpbmdCbG9ja2luZ1Nj cmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2lu Z0Jsb2NraW5nU2NyaXB0cyk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpl eGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3Jp cHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcpOgorICAgICAgICAoV2Vi Q29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdCk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAgICAg ICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6Cisg ICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpydW5TY3JpcHQpOgorICAgICAgICAq IGh0bWwvSFRNTFNjcmlwdFJ1bm5lci5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1 bm5lcjo6UGVuZGluZ1NjcmlwdDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3Jp cHRSdW5uZXI6OlBlbmRpbmdTY3JpcHQ6OlBlbmRpbmdTY3JpcHQpOgorCiAyMDEwLTA2LTI5ICBC cmVudCBGdWxnaGFtICA8YmZ1bGdoYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBCdWlsZCBmaXgu IE5vdCByZXZpZXdkLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNl ci5jcHAgYi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcAppbmRleCA1ODFlNzhl Y2EwNTQ3N2Q5ZjRhYjczYmVlYmVkMmZjZTJkOGY3ZmFhLi40NzU5NzhiNjg5ODZlZWYzM2E1MjI3 MDU1MGU5MTU4MjBkODFkZjFiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50 UGFyc2VyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcApAQCAt Mjc1LDcgKzI3NSw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQoKQog ICAgICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOwogICAgICAgICByZXR1cm47CiAgICAgfQot ICAgIGVuZCgpOworICAgIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsK IH0KIAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCkBAIC0yODQsNiAr Mjg0LDE2IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQoKQogICAgICAg ICByZXR1cm47CiAKICAgICBtX2VuZFdhc0RlbGF5ZWQgPSBmYWxzZTsKKyAgICBleGVjdXRlU2Ny aXB0c1dhaXRpbmdGb3JQYXJzaW5nQW5kRW5kKCk7Cit9CisKK3ZvaWQgSFRNTERvY3VtZW50UGFy c2VyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nQW5kRW5kKCkKK3sKKyAgICBpZiAo bV9zY3JpcHRSdW5uZXIgJiYgIW1fc2NyaXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdG b3JQYXJzaW5nKCkpIHsKKyAgICAgICAgbV90cmVlQnVpbGRlci0+c2V0UGF1c2VkKHRydWUpOwor ICAgICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQog ICAgIGVuZCgpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFy c2VyLmggYi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5kZXggYjJhNjVjYTFl M2NhOWY2ODM3YTM4Mjg5YmM3MTI2NjMxZmI1ZGJmYy4uY2FlNjQ0ZWZjOWU4MGM2NmJlNTdkMGRi MmIyYmU1Zjc1NDJkNmZkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBh cnNlci5oCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTA0LDYg KzEwNCw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRv RW5kKCk7CiAgICAgdm9pZCBlbmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIGV4ZWN1dGVTY3JpcHRz V2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKICAgICB2b2lkIGVuZCgpOwogCiAgICAgYm9vbCBp c1NjaGVkdWxlZEZvclJlc3VtZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hU TUxTY3JpcHRSdW5uZXIuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmlu ZGV4IDI5NzkwYzA1NmJkOTQ1OWNhYzA3ZTM1N2M5YzgwYjRkOTA0MzRjNzYuLmJjNDg1MzdmZjA2 ZTM3ZDU3ZDIzNzVlOGQ4NTM3YzQzNmZhYTViOTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9I VE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5j cHAKQEAgLTY3LDYgKzY3LDcgQEAgSFRNTFNjcmlwdFJ1bm5lcjo6SFRNTFNjcmlwdFJ1bm5lcihE b2N1bWVudCogZG9jdW1lbnQsIEhUTUxTY3JpcHRSdW5uZXJIb3N0KiBob3MKICAgICAsIG1faG9z dChob3N0KQogICAgICwgbV9zY3JpcHROZXN0aW5nTGV2ZWwoMCkKICAgICAsIG1faGFzU2NyaXB0 c1dhaXRpbmdGb3JTdHlsZXNoZWV0cyhmYWxzZSkKKyAgICAsIG1fcGFyc2luZ0Jsb2NraW5nU2Ny aXB0KFBlbmRpbmdTY3JpcHQ6OmNyZWF0ZSgpKQogewogICAgIEFTU0VSVChtX2hvc3QpOwogfQpA QCAtNzQsOCArNzUsOCBAQCBIVE1MU2NyaXB0UnVubmVyOjpIVE1MU2NyaXB0UnVubmVyKERvY3Vt ZW50KiBkb2N1bWVudCwgSFRNTFNjcmlwdFJ1bm5lckhvc3QqIGhvcwogSFRNTFNjcmlwdFJ1bm5l cjo6fkhUTUxTY3JpcHRSdW5uZXIoKQogewogICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYmUgcGFz c2VkIGEgImRvbmUgbG9hZGluZy9wYXJzaW5nIiBjYWxsYmFjayBzb29uZXIgdGhhbiBkZXN0cnVj dGlvbj8KLSAgICBpZiAobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYg bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkpCi0gICAgICAgIHN0b3BX YXRjaGluZ0ZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAgIGlmIChtX3BhcnNp bmdCbG9ja2luZ1NjcmlwdC0+Y2FjaGVkU2NyaXB0KCkgJiYgbV9wYXJzaW5nQmxvY2tpbmdTY3Jp cHQtPndhdGNoaW5nRm9yTG9hZCgpKQorICAgICAgICBzdG9wV2F0Y2hpbmdGb3JMb2FkKCptX3Bh cnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CiAKIHN0YXRpYyBLVVJMIGRvY3VtZW50VVJMRm9yU2Ny aXB0RXhlY3V0aW9uKERvY3VtZW50KiBkb2N1bWVudCkKQEAgLTEyMywxNSArMTI0LDE1IEBAIHZv aWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHQoKQogICAgIEFTU0VSVCgh bV9zY3JpcHROZXN0aW5nTGV2ZWwpOwogICAgIEFTU0VSVChtX2RvY3VtZW50LT5oYXZlU3R5bGVz aGVldHNMb2FkZWQoKSk7CiAgICAgYm9vbCBlcnJvck9jY3VycmVkID0gZmFsc2U7Ci0gICAgQVNT RVJUKGlzUGVuZGluZ1NjcmlwdFJlYWR5KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KSk7Ci0gICAg U2NyaXB0U291cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNlRnJvbVBlbmRpbmdTY3JpcHQobV9w YXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVycm9yT2NjdXJyZWQpOworICAgIEFTU0VSVChpc1BlbmRp bmdTY3JpcHRSZWFkeSgqbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpKTsKKyAgICBTY3JpcHRTb3Vy Y2VDb2RlIHNvdXJjZUNvZGUgPSBzb3VyY2VGcm9tUGVuZGluZ1NjcmlwdCgqbV9wYXJzaW5nQmxv Y2tpbmdTY3JpcHQsIGVycm9yT2NjdXJyZWQpOwogCiAgICAgLy8gU3RvcCB3YXRjaGluZyBsb2Fk cyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0 IHJlbG9hZHMgaXRzZWxmLgotICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRT Y3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKLSAg ICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisgICAg aWYgKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LT5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC0+d2F0Y2hpbmdGb3JMb2FkKCkpCisgICAgICAgIHN0b3BXYXRjaGluZ0Zv ckxvYWQoKm1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIAogICAgIC8vIENsZWFyIHRoZSBwZW5k aW5nIHNjcmlwdCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgp Ci0gICAgUmVmUHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdC5yZWxlYXNlRWxlbWVudEFuZENsZWFyKCk7CisgICAgUmVmUHRyPEVsZW1lbnQ+IHNjcmlw dEVsZW1lbnQgPSBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC0+cmVsZWFzZUVsZW1lbnRBbmRDbGVh cigpOwogICAgIHsKICAgICAgICAgTmVzdFNjcmlwdCBuZXN0aW5nTGV2ZWwobV9zY3JpcHROZXN0 aW5nTGV2ZWwsIG1faG9zdC0+aW5wdXRTdHJlYW0oKSk7CiAgICAgICAgIGlmIChlcnJvck9jY3Vy cmVkKQpAQCAtMTk1LDE0ICsxOTYsMTQgQEAgYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRl KFBhc3NSZWZQdHI8RWxlbWVudD4gc2NyaXB0RWxlbWVudCwgaW50IHN0YXJ0TGluZSkKIAogYm9v bCBIVE1MU2NyaXB0UnVubmVyOjpoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkgY29uc3QKIHsK LSAgICByZXR1cm4gISFtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5lbGVtZW50OworICAgIHJldHVy biAhIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LT5lbGVtZW50OwogfQogCiBib29sIEhUTUxTY3Jp cHRSdW5uZXI6OmV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRzKCkKIHsKICAgICB3aGlsZSAo aGF2ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdCgpKSB7CiAgICAgICAgIC8vIFdlIG9ubHkgcmVhbGx5 IG5lZWQgdG8gY2hlY2sgb25jZS4KLSAgICAgICAgaWYgKCFpc1BlbmRpbmdTY3JpcHRSZWFkeSht X3BhcnNpbmdCbG9ja2luZ1NjcmlwdCkpCisgICAgICAgIGlmICghaXNQZW5kaW5nU2NyaXB0UmVh ZHkoKm1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KSkKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsK ICAgICAgICAgZXhlY3V0ZVBlbmRpbmdTY3JpcHQoKTsKICAgICB9CkBAIC0yMTMsOCArMjE0LDgg QEAgYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENh Y2hlZFJlc291cmNlKiBjYWNoZWRTY3JpcHQKIHsKICAgICBBU1NFUlQoIW1fc2NyaXB0TmVzdGlu Z0xldmVsKTsKICAgICBBU1NFUlQoaGF2ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdCgpKTsKLSAgICBB U1NFUlRfVU5VU0VEKGNhY2hlZFNjcmlwdCwgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVk U2NyaXB0KCkgPT0gY2FjaGVkU2NyaXB0KTsKLSAgICBBU1NFUlQobV9wYXJzaW5nQmxvY2tpbmdT Y3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVkKCkpOworICAgIEFTU0VSVF9VTlVTRUQoY2Fj aGVkU2NyaXB0LCBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC0+Y2FjaGVkU2NyaXB0KCkgPT0gY2Fj aGVkU2NyaXB0KTsKKyAgICBBU1NFUlQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQtPmNhY2hlZFNj cmlwdCgpLT5pc0xvYWRlZCgpKTsKICAgICByZXR1cm4gZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1Nj cmlwdHMoKTsKIH0KIApAQCAtMjI4LDMxICsyMjksNTYgQEAgYm9vbCBIVE1MU2NyaXB0UnVubmVy OjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpCiAgICAgcmV0dXJuIGV4ZWN1 dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRzKCk7CiB9CiAKLXZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6 cmVxdWVzdFNjcmlwdChFbGVtZW50KiBzY3JpcHQpCitib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4 ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQogewotICAgIEFTU0VSVCghbV9wYXJzaW5n QmxvY2tpbmdTY3JpcHQuZWxlbWVudCk7Ci0gICAgQXRvbWljU3RyaW5nIHNyY1ZhbHVlID0gc2Ny aXB0LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7Ci0gICAgLy8gQWxsb3cgdGhlIGhvc3QgdG8gZGlz bGxvdyBzY3JpcHQgbG9hZHMgKHVzaW5nIHRoZSBYU1NBdWRpdG9yLCBldGMuKQorICAgIHdoaWxl ICghbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBB U1NFUlQoIWhhdmVQYXJzaW5nQmxvY2tpbmdTY3JpcHQoKSk7CisgICAgICAgIG1fcGFyc2luZ0Js b2NraW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLnRha2VGaXJzdCgp LmdldCgpOworICAgICAgICBpZiAoIWV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRzKCkpIHsK KyAgICAgICAgICAgIHdhdGNoRm9yTG9hZCgqbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIG1f c2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCk7Cit9CisKK3ZvaWQgSFRNTFNj cmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0JiBwZW5kaW5nU2NyaXB0LCBF bGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVt ZW50KTsKKyAgICBBdG9taWNTdHJpbmcgc3JjVmFsdWUgPSBzY3JpcHRFbGVtZW50LT5nZXRBdHRy aWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3QtPnNob3VsZExvYWRFeHRlcm5hbFNjcmlw dEZyb21TcmMoc3JjVmFsdWUpKQogICAgICAgICByZXR1cm47CiAgICAgLy8gRklYTUU6IFdlIG5l ZWQgdG8gcmVzb2x2ZSB0aGUgdXJsIHJlbGF0aXZlIHRvIHRoZSBlbGVtZW50LgotICAgIGlmICgh c2NyaXB0LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkpCisgICAgaWYgKCFzY3Jp cHRFbGVtZW50LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkpCiAgICAgICAgIHJl dHVybjsKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5lbGVtZW50ID0gc2NyaXB0OworICAg IHBlbmRpbmdTY3JpcHQuZWxlbWVudCA9IHNjcmlwdEVsZW1lbnQ7CiAgICAgLy8gVGhpcyBzaG91 bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBvciBpbnZhbGlkIHNyY1ZhbHVlcy4KLSAg ICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5y ZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0KS0+c2NyaXB0Q2hh cnNldCgpKTsKKyAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRv Y0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0 RWxlbWVudCktPnNjcmlwdENoYXJzZXQoKSk7CiAgICAgaWYgKCFjYWNoZWRTY3JpcHQpIHsKICAg ICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gRGlzcGF0Y2ggZXJyb3IgZXZlbnQuCiAgICAgICAg IHJldHVybjsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5zZXRDYWNoZWRT Y3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5nU2NyaXB0LnNldENhY2hlZFNjcmlwdChj YWNoZWRTY3JpcHQpOworfQorCit2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5n QmxvY2tpbmdTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAgICByZXF1ZXN0U2Ny aXB0KCptX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCwgc2NyaXB0RWxlbWVudCk7CiAKICAgICAvLyBX ZSBvbmx5IGNhcmUgYWJvdXQgYSBsb2FkIGNhbGxiYWNrIGlmIGNhY2hlZFNjcmlwdCBpcyBub3Qg YWxyZWFkeQogICAgIC8vIGluIHRoZSBjYWNoZS4gIENhbGxlcnMgd2lsbCBhdHRlbXB0IHRvIHJ1 biB0aGUgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQKICAgICAvLyBpZiBwb3NzaWJsZSBiZWZvcmUg cmV0dXJuaW5nIGNvbnRyb2wgdG8gdGhlIHBhcnNlci4KLSAgICBpZiAoIW1fcGFyc2luZ0Jsb2Nr aW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKQotICAgICAgICB3YXRjaEZvckxv YWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdC0+Y2FjaGVkU2NyaXB0KCkgJiYgIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LT5jYWNoZWRT Y3JpcHQoKS0+aXNMb2FkZWQoKSkKKyAgICAgICAgd2F0Y2hGb3JMb2FkKCptX3BhcnNpbmdCbG9j a2luZ1NjcmlwdCk7Cit9CisKK3ZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVk U2NyaXB0KEVsZW1lbnQqIHNjcmlwdEVsZW1lbnQpCit7CisgICAgUmVmUHRyPFBlbmRpbmdTY3Jp cHQ+IHBlbmRpbmdTY3JpcHQgPSBQZW5kaW5nU2NyaXB0OjpjcmVhdGUoKTsKKyAgICByZXF1ZXN0 U2NyaXB0KCpwZW5kaW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsKKyAgICBtX3NjcmlwdHNUb0V4 ZWN1dGVBZnRlclBhcnNpbmcuYXBwZW5kKHBlbmRpbmdTY3JpcHQucmVsZWFzZSgpKTsKIH0KIAog Ly8gVGhpcyBtZXRob2QgaXMgbWVhbnQgdG8gbWF0Y2ggdGhlIEhUTUw1IGRlZmluaXRpb24gb2Yg InJ1bm5pbmcgYSBzY3JpcHQiCkBAIC0yNjcsOCArMjkzLDExIEBAIHZvaWQgSFRNTFNjcmlwdFJ1 bm5lcjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0aW5nTGluZU51bWJlcikK ICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gZXZlbnQgZm9yIHN1cHBvcnQKIAogICAgICAg ICBpZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoc3JjQXR0cikpIHsKLSAgICAgICAgICAgIC8vIEZJ WE1FOiBIYW5kbGUgZGVmZXIgYW5kIGFzeW5jCi0gICAgICAgICAgICByZXF1ZXN0U2NyaXB0KHNj cmlwdCk7CisgICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGFzeW5jCisgICAgICAgICAgICBp ZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoZGVmZXJBdHRyKSkKKyAgICAgICAgICAgICAgICByZXF1 ZXN0RGVmZXJyZWRTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAg ICAgICByZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KHNjcmlwdCk7CiAgICAgICAgIH0gZWxz ZSB7CiAgICAgICAgICAgICAvLyBGSVhNRTogV2UgZG8gbm90IGJsb2NrIGlubGluZSA8c2NyaXB0 PiB0YWdzIG9uIHN0eWxlc2hlZXRzIHRvIG1hdGNoIHRoZQogICAgICAgICAgICAgLy8gb2xkIHBh cnNlciBmb3Igbm93LiAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD00MDA0NwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaCBiL1dl YkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZjkzYWUxMDJiN2QyOGU3MjE1Y2U3 OThhMWRhZjdkMmY0ZTdmOTBhZC4uMWNkYjhjYjBjNDY2ZGZjZGNkNjRiNThlOTI1NTE0ZjZlYTUz ZDUwNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaAorKysgYi9X ZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5oCkBAIC0yOCw4ICsyOCwxMCBAQAogCiAjaW5j bHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhh bmRsZS5oIgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJs ZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5o PgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTUyLDYgKzU0LDcgQEAgcHVibGljOgogICAg IGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAg IGJvb2wgaGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1f aGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlw dHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKTsKKyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGlu Z0ZvclBhcnNpbmcoKTsKIAogICAgIGJvb2wgaW5TY3JpcHRFeGVjdXRpb24oKSB7IHJldHVybiAh IW1fc2NyaXB0TmVzdGluZ0xldmVsOyB9CiAKQEAgLTYzLDEyICs2NiwxMSBAQCBwcml2YXRlOgog ICAgIC8vIGxpZmV0aW1lIGluIG9yZGVyIHRvIGd1YXJhbnRlZSB0aGF0IHRoZSBkYXRhIGJ1ZmZl ciB3aWxsIG5vdCBiZSBwdXJnZWQuCiAgICAgLy8KICAgICAvLyBGSVhNRTogRmluaXNoIHR1cm5p bmcgdGhpcyBpbnRvIGEgcHJvcGVyIGNsYXNzLgotICAgIGNsYXNzIFBlbmRpbmdTY3JpcHQgOiBw dWJsaWMgQ2FjaGVkUmVzb3VyY2VDbGllbnQsIE5vbmNvcHlhYmxlIHsKKyAgICBjbGFzcyBQZW5k aW5nU2NyaXB0IDogcHVibGljIENhY2hlZFJlc291cmNlQ2xpZW50LCBwdWJsaWMgUmVmQ291bnRl ZDxQZW5kaW5nU2NyaXB0PiB7CiAgICAgcHVibGljOgotICAgICAgICBQZW5kaW5nU2NyaXB0KCkK LSAgICAgICAgICAgIDogc3RhcnRpbmdMaW5lTnVtYmVyKDApCi0gICAgICAgICAgICAsIG1fd2F0 Y2hpbmdGb3JMb2FkKGZhbHNlKQorICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxQZW5kaW5nU2Ny aXB0PiBjcmVhdGUoKQogICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3 IFBlbmRpbmdTY3JpcHQoKSk7CiAgICAgICAgIH0KIAogICAgICAgICB+UGVuZGluZ1NjcmlwdCgp OwpAQCAtOTEsNiArOTMsMTIgQEAgcHJpdmF0ZToKICAgICAgICAgLy8gbV9kb2N1bWVudC0+aGF2 ZVN0eWxlc2hlZXRzTG9hZGVkKCkgJiYgY2FjaGVkU2NyaXB0LT5pc0xvYWRlZCgpCiAKICAgICBw cml2YXRlOgorICAgICAgICBQZW5kaW5nU2NyaXB0KCkKKyAgICAgICAgICAgIDogc3RhcnRpbmdM aW5lTnVtYmVyKDApCisgICAgICAgICAgICAsIG1fd2F0Y2hpbmdGb3JMb2FkKGZhbHNlKQorICAg ICAgICB7CisgICAgICAgIH0KKwogICAgICAgICBib29sIG1fd2F0Y2hpbmdGb3JMb2FkOwogICAg ICAgICBDYWNoZWRSZXNvdXJjZUhhbmRsZTxDYWNoZWRTY3JpcHQ+IG1fY2FjaGVkU2NyaXB0Owog ICAgIH07CkBAIC0xMDEsNyArMTA5LDkgQEAgcHJpdmF0ZToKICAgICBib29sIGV4ZWN1dGVQYXJz aW5nQmxvY2tpbmdTY3JpcHRzKCk7CiAgICAgdm9pZCBleGVjdXRlUGVuZGluZ1NjcmlwdCgpOwog Ci0gICAgdm9pZCByZXF1ZXN0U2NyaXB0KEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3RTY3Jp cHQoUGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3RQYXJzaW5nQmxv Y2tpbmdTY3JpcHQoRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVzdERlZmVycmVkU2NyaXB0KEVs ZW1lbnQqKTsKICAgICB2b2lkIHJ1blNjcmlwdChFbGVtZW50KiwgaW50IHN0YXJ0aW5nTGluZU51 bWJlcik7CiAKICAgICAvLyBIZWxwZXJzIGZvciBkZWFsaW5nIHdpdGggSFRNTFNjcmlwdFJ1bm5l ckhvc3QKQEAgLTExNCw3ICsxMjQsOCBAQCBwcml2YXRlOgogCiAgICAgRG9jdW1lbnQqIG1fZG9j dW1lbnQ7CiAgICAgSFRNTFNjcmlwdFJ1bm5lckhvc3QqIG1faG9zdDsKLSAgICBQZW5kaW5nU2Ny aXB0IG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0OworICAgIFJlZlB0cjxQZW5kaW5nU2NyaXB0PiBt X3BhcnNpbmdCbG9ja2luZ1NjcmlwdDsKKyAgICBEZXF1ZTxSZWZQdHI8UGVuZGluZ1NjcmlwdD4g PiBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmc7CiAgICAgdW5zaWduZWQgbV9zY3JpcHRO ZXN0aW5nTGV2ZWw7CiAKICAgICAvLyBXZSBvbmx5IHdhbnQgc3R5bGVzaGVldCBsb2FkcyB0byB0 cmlnZ2VyIHNjcmlwdCBleGVjdXRpb24gaWYgc2NyaXB0Cg== 60076 2010-06-29 18:41:07 -0700 2010-06-29 19:02:08 -0700 Patch bug-40934-20100629184105.patch text/plain 13649 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4YjRlZjAwMTljMDgxMzBlNjdiYWU2MzY4MzhiNWRkYjEyOGU2MzU4Li4xODAyYTY3 NzkzNGJkNGVhZTk2ZjViODU2NTI0NjBhMWQ5ZTc5ZDI2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAK KzIwMTAtMDYtMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgTGF5b3V0VGVz dCBmb3IgPHNjcmlwdCBkZWZlcj4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAgRW5zdXJlcyB0aGF0IGRlZmVycmVkIHNjcmlw dHMgYXJlIGV4ZWN1dGVkIGJlZm9yZSBET01Db250ZW50TG9hZGVkIGFuZAorICAgICAgICBpbiB0 aGUgb3JkZXIgdGhleSBhcmUgaW5jbHVkZWQgKHJlZ2FyZGxlc3Mgb2Ygd2hlbiB0aGV5IGxvYWQp LgorCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6 IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2Ny aXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct ZGVmZXItc2NyaXB0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuCisKIDIwMTAtMDYtMjkgIFJvYmVydCBIb2dhbiAgPHJv YmVydEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hy aXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0 ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRl ZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0 NDUyZWJkZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1 ZygiZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4 MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBA IC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6 IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0Rl ZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0 LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hZGU4MzYyZWEyY2I0YjU5ZTk4ZTEwYzBh NDg5ZTYxYWFhZDY2M2U1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4IEBACitUaGlzIHRl c3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIg YXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4N CitleHRlcm5hbA0KK2lubGluZQ0KK3Nsb3dEZWZlcg0KK2RlZmVyDQorRE9NQ29udGVudExvYWRl ZA0KK2xvYWQNCisNCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhiMzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2Mz MwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lF VEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29u dGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5 bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgor VGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhl IGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y MDcxMDwvYT4uCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRl ZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2Up OworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVz b3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2Ny aXB0LmpzIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcu MC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0Pgor PHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUiKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBj OGFmMGZkOTE0NWY4Y2Y1NzZjMDg0ZTE1MTUwYjRmMTRkY2ZiMWQyLi4wYzdkNTlkMDFlMzViZTc0 NzAwM2UyZGM5MWVkN2JkNzgwYzMxNjdkIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA2LTI5ICBUb255 IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVj aWZpZWQgYnkgSFRNTDUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQwOTM0CisKKyAgICAgICAgU2VlOiBodHRwOi8vZGV2LnczLm9yZy9odG1sNS9zcGVj L092ZXJ2aWV3Lmh0bWwjdGhlLWVuZAorCisgICAgICAgIFRlc3Q6IGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXIuaHRtbAorCisgICAgICAgICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdG b3JQYXJzaW5nQW5kRW5kKToKKyAgICAgICAgKiBodG1sL0hUTUxEb2N1bWVudFBhcnNlci5oOgor ICAgICAgICAqIGh0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpI VE1MU2NyaXB0UnVubmVyOjpIVE1MU2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6On5IVE1MU2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxTY3JpcHRSdW5uZXI6OmhhdmVQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRl U2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRS dW5uZXI6OnJlcXVlc3RTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5l cjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KToKKyAgICAgICAgKiBodG1sL0hUTUxTY3JpcHRS dW5uZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OlBlbmRpbmdTY3Jp cHQ6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpQZW5kaW5n U2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKwogMjAxMC0wNi0yOSAgS2VubmV0aCBSdXNzZWxsICA8 a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGltaXRyaSBHbGF6a292Lgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3Jl L2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcAppbmRleCA1ODFlNzhlY2EwNTQ3N2Q5ZjRhYjcz YmVlYmVkMmZjZTJkOGY3ZmFhLi40NzU5NzhiNjg5ODZlZWYzM2E1MjI3MDU1MGU5MTU4MjBkODFk ZjFiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcAorKysg Yi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtMjc1LDcgKzI3NSw3IEBA IHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQoKQogICAgICAgICBtX2VuZFdh c0RlbGF5ZWQgPSB0cnVlOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIGVuZCgpOworICAg IGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKIH0KIAogdm9pZCBIVE1M RG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCkBAIC0yODQsNiArMjg0LDE2IEBAIHZvaWQg SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQoKQogICAgICAgICByZXR1cm47CiAKICAg ICBtX2VuZFdhc0RlbGF5ZWQgPSBmYWxzZTsKKyAgICBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQ YXJzaW5nQW5kRW5kKCk7Cit9CisKK3ZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpleGVjdXRlU2Ny aXB0c1dhaXRpbmdGb3JQYXJzaW5nQW5kRW5kKCkKK3sKKyAgICBpZiAobV9zY3JpcHRSdW5uZXIg JiYgIW1fc2NyaXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCkpIHsK KyAgICAgICAgbV90cmVlQnVpbGRlci0+c2V0UGF1c2VkKHRydWUpOworICAgICAgICBtX2VuZFdh c0RlbGF5ZWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQogICAgIGVuZCgpOwogfQog CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3Jl L2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5kZXggYjJhNjVjYTFlM2NhOWY2ODM3YTM4Mjg5 YmM3MTI2NjMxZmI1ZGJmYy4uY2FlNjQ0ZWZjOWU4MGM2NmJlNTdkMGRiMmIyYmU1Zjc1NDJkNmZk YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dl YkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTA0LDYgKzEwNCw3IEBAIHByaXZh dGU6CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRvRW5kKCk7CiAgICAgdm9p ZCBlbmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNp bmdBbmRFbmQoKTsKICAgICB2b2lkIGVuZCgpOwogCiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJl c3VtZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIu Y3BwIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmluZGV4IDI5NzkwYzA1NmJk OTQ1OWNhYzA3ZTM1N2M5YzgwYjRkOTA0MzRjNzYuLmYzYWFhODU0ZTg2ZmEzMjZkZDA4YzBlZjI0 N2I3MGU1ODhhNTExYTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVy LmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKQEAgLTIyOCwzMyAr MjI4LDU4IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9y U3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygp OwogfQogCi12b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQoRWxlbWVudCogc2Ny aXB0KQorYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJz aW5nKCkKIHsKLSAgICBBU1NFUlQoIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQpOwot ICAgIEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNjcmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIp OwotICAgIC8vIEFsbG93IHRoZSBob3N0IHRvIGRpc2xsb3cgc2NyaXB0IGxvYWRzICh1c2luZyB0 aGUgWFNTQXVkaXRvciwgZXRjLikKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVy UGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5n U2NyaXB0KCkpOworICAgICAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCA9IG1fc2NyaXB0c1Rv RXhlY3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAgICAgaWYgKCFleGVjdXRlUGFy c2luZ0Jsb2NraW5nU2NyaXB0cygpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxvYWQobV9wYXJz aW5nQmxvY2tpbmdTY3JpcHQpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9 CisgICAgfQorCisgICAgcmV0dXJuIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0Vt cHR5KCk7Cit9CisKK3ZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChQZW5kaW5n U2NyaXB0JiBwZW5kaW5nU2NyaXB0LCBFbGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIEFT U0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KTsKKyAgICBBdG9taWNTdHJpbmcgc3JjVmFsdWUg PSBzY3JpcHRFbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3Qt PnNob3VsZExvYWRFeHRlcm5hbFNjcmlwdEZyb21TcmMoc3JjVmFsdWUpKQogICAgICAgICByZXR1 cm47CiAgICAgLy8gRklYTUU6IFdlIG5lZWQgdG8gcmVzb2x2ZSB0aGUgdXJsIHJlbGF0aXZlIHRv IHRoZSBlbGVtZW50LgotICAgIGlmICghc2NyaXB0LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChz cmNWYWx1ZSkpCisgICAgaWYgKCFzY3JpcHRFbGVtZW50LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVu dChzcmNWYWx1ZSkpCiAgICAgICAgIHJldHVybjsKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5lbGVtZW50ID0gc2NyaXB0OworICAgIHBlbmRpbmdTY3JpcHQuZWxlbWVudCA9IHNjcmlwdEVs ZW1lbnQ7CiAgICAgLy8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBv ciBpbnZhbGlkIHNyY1ZhbHVlcy4KLSAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1f ZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVs ZW1lbnQoc2NyaXB0KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBDYWNoZWRTY3JpcHQqIGNhY2hl ZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVl LCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0RWxlbWVudCktPnNjcmlwdENoYXJzZXQoKSk7CiAgICAg aWYgKCFjYWNoZWRTY3JpcHQpIHsKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gRGlzcGF0 Y2ggZXJyb3IgZXZlbnQuCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC5zZXRDYWNoZWRTY3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5n U2NyaXB0LnNldENhY2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworfQorCit2b2lkIEhUTUxTY3Jp cHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxl bWVudCkKK3sKKyAgICByZXF1ZXN0U2NyaXB0KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LCBzY3Jp cHRFbGVtZW50KTsKIAogICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91dCBhIGxvYWQgY2FsbGJhY2sg aWYgY2FjaGVkU2NyaXB0IGlzIG5vdCBhbHJlYWR5CiAgICAgLy8gaW4gdGhlIGNhY2hlLiAgQ2Fs bGVycyB3aWxsIGF0dGVtcHQgdG8gcnVuIHRoZSBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdAogICAg IC8vIGlmIHBvc3NpYmxlIGJlZm9yZSByZXR1cm5pbmcgY29udHJvbCB0byB0aGUgcGFyc2VyLgot ICAgIGlmICghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVk KCkpCisgICAgaWYgKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpICYmICFt X3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkKICAgICAg ICAgd2F0Y2hGb3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1M U2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVu dCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgcmVxdWVzdFNjcmlw dChwZW5kaW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsKKyAgICBtX3NjcmlwdHNUb0V4ZWN1dGVB ZnRlclBhcnNpbmcuYXBwZW5kKHBlbmRpbmdTY3JpcHQpOworfQorCiAvLyBUaGlzIG1ldGhvZCBp cyBtZWFudCB0byBtYXRjaCB0aGUgSFRNTDUgZGVmaW5pdGlvbiBvZiAicnVubmluZyBhIHNjcmlw dCIKIC8vIGh0dHA6Ly93d3cud2hhdHdnLm9yZy9zcGVjcy93ZWItYXBwcy9jdXJyZW50LXdvcmsv bXVsdGlwYWdlL3NjcmlwdGluZy0xLmh0bWwjcnVubmluZy1hLXNjcmlwdAogdm9pZCBIVE1MU2Ny aXB0UnVubmVyOjpydW5TY3JpcHQoRWxlbWVudCogc2NyaXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVt YmVyKQpAQCAtMjY3LDggKzI5MiwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlw dChFbGVtZW50KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdElt cGxlbWVudGVkKCk7IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+ aGFzQXR0cmlidXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRl ZmVyIGFuZCBhc3luYwotICAgICAgICAgICAgcmVxdWVzdFNjcmlwdChzY3JpcHQpOworICAgICAg ICAgICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYworICAgICAgICAgICAgaWYgKHNjcmlwdC0+aGFz QXR0cmlidXRlKGRlZmVyQXR0cikpCisgICAgICAgICAgICAgICAgcmVxdWVzdERlZmVycmVkU2Ny aXB0KHNjcmlwdCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgcmVxdWVzdFBh cnNpbmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAg ICAgLy8gRklYTUU6IFdlIGRvIG5vdCBibG9jayBpbmxpbmUgPHNjcmlwdD4gdGFncyBvbiBzdHls ZXNoZWV0cyB0byBtYXRjaCB0aGUKICAgICAgICAgICAgIC8vIG9sZCBwYXJzZXIgZm9yIG5vdy4g IFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDAwNDcKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmggYi9XZWJDb3JlL2h0bWwvSFRN TFNjcmlwdFJ1bm5lci5oCmluZGV4IGY5M2FlMTAyYjdkMjhlNzIxNWNlNzk4YTFkYWY3ZDJmNGU3 ZjkwYWQuLmJkYTJmNjczNmI2NWJmZDVhNGUxMWMwYzZhZTg5NjBmYWQzYWQzOGEgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL0hU TUxTY3JpcHRSdW5uZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVz b3VyY2VDbGllbnQuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1 ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CiAKQEAgLTUyLDYgKzUzLDcgQEAgcHVibGljOgogICAgIGJvb2wg ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAgIGJvb2wg aGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2Ny aXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yU3R5bGVzaGVldHMoKTsKKyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmcoKTsKIAogICAgIGJvb2wgaW5TY3JpcHRFeGVjdXRpb24oKSB7IHJldHVybiAhIW1fc2Ny aXB0TmVzdGluZ0xldmVsOyB9CiAKQEAgLTYzLDcgKzY1LDcgQEAgcHJpdmF0ZToKICAgICAvLyBs aWZldGltZSBpbiBvcmRlciB0byBndWFyYW50ZWUgdGhhdCB0aGUgZGF0YSBidWZmZXIgd2lsbCBu b3QgYmUgcHVyZ2VkLgogICAgIC8vCiAgICAgLy8gRklYTUU6IEZpbmlzaCB0dXJuaW5nIHRoaXMg aW50byBhIHByb3BlciBjbGFzcy4KLSAgICBjbGFzcyBQZW5kaW5nU2NyaXB0IDogcHVibGljIENh Y2hlZFJlc291cmNlQ2xpZW50LCBOb25jb3B5YWJsZSB7CisgICAgY2xhc3MgUGVuZGluZ1Njcmlw dCA6IHB1YmxpYyBDYWNoZWRSZXNvdXJjZUNsaWVudCB7CiAgICAgcHVibGljOgogICAgICAgICBQ ZW5kaW5nU2NyaXB0KCkKICAgICAgICAgICAgIDogc3RhcnRpbmdMaW5lTnVtYmVyKDApCkBAIC03 MSw2ICs3MywyNyBAQCBwcml2YXRlOgogICAgICAgICB7CiAgICAgICAgIH0KIAorICAgICAgICBQ ZW5kaW5nU2NyaXB0KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICAgICAgOiBl bGVtZW50KG90aGVyLmVsZW1lbnQpCisgICAgICAgICAgICAsIHN0YXJ0aW5nTGluZU51bWJlcihv dGhlci5zdGFydGluZ0xpbmVOdW1iZXIpCisgICAgICAgICAgICAsIG1fd2F0Y2hpbmdGb3JMb2Fk KG90aGVyLm1fd2F0Y2hpbmdGb3JMb2FkKQorICAgICAgICB7CisgICAgICAgICAgICBzZXRDYWNo ZWRTY3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICB9CisKKyAgICAgICAgUGVu ZGluZ1NjcmlwdCYgb3BlcmF0b3I9KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAg ICB7CisgICAgICAgICAgICBpZiAodGhpcyA9PSAmb3RoZXIpCisgICAgICAgICAgICAgICAgcmV0 dXJuICp0aGlzOworCisgICAgICAgICAgICBlbGVtZW50ID0gb3RoZXIuZWxlbWVudDsKKyAgICAg ICAgICAgIHN0YXJ0aW5nTGluZU51bWJlciA9IG90aGVyLnN0YXJ0aW5nTGluZU51bWJlcjsKKyAg ICAgICAgICAgIG1fd2F0Y2hpbmdGb3JMb2FkID0gb3RoZXIubV93YXRjaGluZ0ZvckxvYWQ7Cisg ICAgICAgICAgICBzZXRDYWNoZWRTY3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworCisgICAg ICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgICAgIH0KKwogICAgICAgICB+UGVuZGluZ1Njcmlw dCgpOwogCiAgICAgICAgIFBhc3NSZWZQdHI8RWxlbWVudD4gcmVsZWFzZUVsZW1lbnRBbmRDbGVh cigpOwpAQCAtMTAxLDcgKzEyNCw5IEBAIHByaXZhdGU6CiAgICAgYm9vbCBleGVjdXRlUGFyc2lu Z0Jsb2NraW5nU2NyaXB0cygpOwogICAgIHZvaWQgZXhlY3V0ZVBlbmRpbmdTY3JpcHQoKTsKIAot ICAgIHZvaWQgcmVxdWVzdFNjcmlwdChFbGVtZW50Kik7CisgICAgdm9pZCByZXF1ZXN0U2NyaXB0 KFBlbmRpbmdTY3JpcHQmLCBFbGVtZW50Kik7CisgICAgdm9pZCByZXF1ZXN0UGFyc2luZ0Jsb2Nr aW5nU2NyaXB0KEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3REZWZlcnJlZFNjcmlwdChFbGVt ZW50Kik7CiAgICAgdm9pZCBydW5TY3JpcHQoRWxlbWVudCosIGludCBzdGFydGluZ0xpbmVOdW1i ZXIpOwogCiAgICAgLy8gSGVscGVycyBmb3IgZGVhbGluZyB3aXRoIEhUTUxTY3JpcHRSdW5uZXJI b3N0CkBAIC0xMTUsNiArMTQwLDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVu dDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQg bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7CisgICAgRGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3Jp cHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOwogICAgIHVuc2lnbmVkIG1fc2NyaXB0TmVzdGluZ0xl dmVsOwogCiAgICAgLy8gV2Ugb25seSB3YW50IHN0eWxlc2hlZXQgbG9hZHMgdG8gdHJpZ2dlciBz Y3JpcHQgZXhlY3V0aW9uIGlmIHNjcmlwdAo= 60078 2010-06-29 19:02:12 -0700 2010-07-01 12:26:52 -0700 Patch bug-40934-20100629190210.patch text/plain 13692 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4YjRlZjAwMTljMDgxMzBlNjdiYWU2MzY4MzhiNWRkYjEyOGU2MzU4Li4xODAyYTY3 NzkzNGJkNGVhZTk2ZjViODU2NTI0NjBhMWQ5ZTc5ZDI2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAK KzIwMTAtMDYtMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgTGF5b3V0VGVz dCBmb3IgPHNjcmlwdCBkZWZlcj4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAgRW5zdXJlcyB0aGF0IGRlZmVycmVkIHNjcmlw dHMgYXJlIGV4ZWN1dGVkIGJlZm9yZSBET01Db250ZW50TG9hZGVkIGFuZAorICAgICAgICBpbiB0 aGUgb3JkZXIgdGhleSBhcmUgaW5jbHVkZWQgKHJlZ2FyZGxlc3Mgb2Ygd2hlbiB0aGV5IGxvYWQp LgorCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6 IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2Ny aXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct ZGVmZXItc2NyaXB0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuCisKIDIwMTAtMDYtMjkgIFJvYmVydCBIb2dhbiAgPHJv YmVydEB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbm5ldGggUm9oZGUgQ2hy aXN0aWFuc2VuLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0 ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRl ZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0 NDUyZWJkZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1 ZygiZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4 MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBA IC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6 IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0Rl ZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0 LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hZGU4MzYyZWEyY2I0YjU5ZTk4ZTEwYzBh NDg5ZTYxYWFhZDY2M2U1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4IEBACitUaGlzIHRl c3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIg YXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4N CitleHRlcm5hbA0KK2lubGluZQ0KK3Nsb3dEZWZlcg0KK2RlZmVyDQorRE9NQ29udGVudExvYWRl ZA0KK2xvYWQNCisNCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhiMzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2Mz MwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lF VEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29u dGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5 bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgor VGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhl IGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y MDcxMDwvYT4uCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRl ZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2Up OworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVz b3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2Ny aXB0LmpzIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcu MC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0Pgor PHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUiKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBj OGFmMGZkOTE0NWY4Y2Y1NzZjMDg0ZTE1MTUwYjRmMTRkY2ZiMWQyLi4wYzdkNTlkMDFlMzViZTc0 NzAwM2UyZGM5MWVkN2JkNzgwYzMxNjdkIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA2LTI5ICBUb255 IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVj aWZpZWQgYnkgSFRNTDUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQwOTM0CisKKyAgICAgICAgU2VlOiBodHRwOi8vZGV2LnczLm9yZy9odG1sNS9zcGVj L092ZXJ2aWV3Lmh0bWwjdGhlLWVuZAorCisgICAgICAgIFRlc3Q6IGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXIuaHRtbAorCisgICAgICAgICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdG b3JQYXJzaW5nQW5kRW5kKToKKyAgICAgICAgKiBodG1sL0hUTUxEb2N1bWVudFBhcnNlci5oOgor ICAgICAgICAqIGh0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpI VE1MU2NyaXB0UnVubmVyOjpIVE1MU2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6On5IVE1MU2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxTY3JpcHRSdW5uZXI6OmhhdmVQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRl U2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRS dW5uZXI6OnJlcXVlc3RTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5l cjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KToKKyAgICAgICAgKiBodG1sL0hUTUxTY3JpcHRS dW5uZXIuaDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OlBlbmRpbmdTY3Jp cHQ6OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpQZW5kaW5n U2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKwogMjAxMC0wNi0yOSAgS2VubmV0aCBSdXNzZWxsICA8 a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGltaXRyaSBHbGF6a292Lgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3Jl L2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcAppbmRleCA1ODFlNzhlY2EwNTQ3N2Q5ZjRhYjcz YmVlYmVkMmZjZTJkOGY3ZmFhLi40NzU5NzhiNjg5ODZlZWYzM2E1MjI3MDU1MGU5MTU4MjBkODFk ZjFiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcAorKysg Yi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtMjc1LDcgKzI3NSw3IEBA IHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQoKQogICAgICAgICBtX2VuZFdh c0RlbGF5ZWQgPSB0cnVlOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIGVuZCgpOworICAg IGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKIH0KIAogdm9pZCBIVE1M RG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCkBAIC0yODQsNiArMjg0LDE2IEBAIHZvaWQg SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQoKQogICAgICAgICByZXR1cm47CiAKICAg ICBtX2VuZFdhc0RlbGF5ZWQgPSBmYWxzZTsKKyAgICBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQ YXJzaW5nQW5kRW5kKCk7Cit9CisKK3ZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpleGVjdXRlU2Ny aXB0c1dhaXRpbmdGb3JQYXJzaW5nQW5kRW5kKCkKK3sKKyAgICBpZiAobV9zY3JpcHRSdW5uZXIg JiYgIW1fc2NyaXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCkpIHsK KyAgICAgICAgbV90cmVlQnVpbGRlci0+c2V0UGF1c2VkKHRydWUpOworICAgICAgICBtX2VuZFdh c0RlbGF5ZWQgPSB0cnVlOworICAgICAgICByZXR1cm47CisgICAgfQogICAgIGVuZCgpOwogfQog CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3Jl L2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5kZXggYjJhNjVjYTFlM2NhOWY2ODM3YTM4Mjg5 YmM3MTI2NjMxZmI1ZGJmYy4uY2FlNjQ0ZWZjOWU4MGM2NmJlNTdkMGRiMmIyYmU1Zjc1NDJkNmZk YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dl YkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTA0LDYgKzEwNCw3IEBAIHByaXZh dGU6CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRvRW5kKCk7CiAgICAgdm9p ZCBlbmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNp bmdBbmRFbmQoKTsKICAgICB2b2lkIGVuZCgpOwogCiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJl c3VtZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIu Y3BwIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmluZGV4IDI5NzkwYzA1NmJk OTQ1OWNhYzA3ZTM1N2M5YzgwYjRkOTA0MzRjNzYuLmYzYWFhODU0ZTg2ZmEzMjZkZDA4YzBlZjI0 N2I3MGU1ODhhNTExYTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVy LmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKQEAgLTIyOCwzMyAr MjI4LDU4IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9y U3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygp OwogfQogCi12b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQoRWxlbWVudCogc2Ny aXB0KQorYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJz aW5nKCkKIHsKLSAgICBBU1NFUlQoIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQpOwot ICAgIEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNjcmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIp OwotICAgIC8vIEFsbG93IHRoZSBob3N0IHRvIGRpc2xsb3cgc2NyaXB0IGxvYWRzICh1c2luZyB0 aGUgWFNTQXVkaXRvciwgZXRjLikKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVy UGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5n U2NyaXB0KCkpOworICAgICAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCA9IG1fc2NyaXB0c1Rv RXhlY3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAgICAgaWYgKCFleGVjdXRlUGFy c2luZ0Jsb2NraW5nU2NyaXB0cygpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxvYWQobV9wYXJz aW5nQmxvY2tpbmdTY3JpcHQpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9 CisgICAgfQorCisgICAgcmV0dXJuIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0Vt cHR5KCk7Cit9CisKK3ZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChQZW5kaW5n U2NyaXB0JiBwZW5kaW5nU2NyaXB0LCBFbGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIEFT U0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KTsKKyAgICBBdG9taWNTdHJpbmcgc3JjVmFsdWUg PSBzY3JpcHRFbGVtZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3Qt PnNob3VsZExvYWRFeHRlcm5hbFNjcmlwdEZyb21TcmMoc3JjVmFsdWUpKQogICAgICAgICByZXR1 cm47CiAgICAgLy8gRklYTUU6IFdlIG5lZWQgdG8gcmVzb2x2ZSB0aGUgdXJsIHJlbGF0aXZlIHRv IHRoZSBlbGVtZW50LgotICAgIGlmICghc2NyaXB0LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChz cmNWYWx1ZSkpCisgICAgaWYgKCFzY3JpcHRFbGVtZW50LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVu dChzcmNWYWx1ZSkpCiAgICAgICAgIHJldHVybjsKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5lbGVtZW50ID0gc2NyaXB0OworICAgIHBlbmRpbmdTY3JpcHQuZWxlbWVudCA9IHNjcmlwdEVs ZW1lbnQ7CiAgICAgLy8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBv ciBpbnZhbGlkIHNyY1ZhbHVlcy4KLSAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1f ZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVs ZW1lbnQoc2NyaXB0KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBDYWNoZWRTY3JpcHQqIGNhY2hl ZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVl LCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0RWxlbWVudCktPnNjcmlwdENoYXJzZXQoKSk7CiAgICAg aWYgKCFjYWNoZWRTY3JpcHQpIHsKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gRGlzcGF0 Y2ggZXJyb3IgZXZlbnQuCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC5zZXRDYWNoZWRTY3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5n U2NyaXB0LnNldENhY2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworfQorCit2b2lkIEhUTUxTY3Jp cHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxl bWVudCkKK3sKKyAgICByZXF1ZXN0U2NyaXB0KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LCBzY3Jp cHRFbGVtZW50KTsKIAogICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91dCBhIGxvYWQgY2FsbGJhY2sg aWYgY2FjaGVkU2NyaXB0IGlzIG5vdCBhbHJlYWR5CiAgICAgLy8gaW4gdGhlIGNhY2hlLiAgQ2Fs bGVycyB3aWxsIGF0dGVtcHQgdG8gcnVuIHRoZSBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdAogICAg IC8vIGlmIHBvc3NpYmxlIGJlZm9yZSByZXR1cm5pbmcgY29udHJvbCB0byB0aGUgcGFyc2VyLgot ICAgIGlmICghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVk KCkpCisgICAgaWYgKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpICYmICFt X3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkKICAgICAg ICAgd2F0Y2hGb3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1M U2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVu dCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgcmVxdWVzdFNjcmlw dChwZW5kaW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsKKyAgICBtX3NjcmlwdHNUb0V4ZWN1dGVB ZnRlclBhcnNpbmcuYXBwZW5kKHBlbmRpbmdTY3JpcHQpOworfQorCiAvLyBUaGlzIG1ldGhvZCBp cyBtZWFudCB0byBtYXRjaCB0aGUgSFRNTDUgZGVmaW5pdGlvbiBvZiAicnVubmluZyBhIHNjcmlw dCIKIC8vIGh0dHA6Ly93d3cud2hhdHdnLm9yZy9zcGVjcy93ZWItYXBwcy9jdXJyZW50LXdvcmsv bXVsdGlwYWdlL3NjcmlwdGluZy0xLmh0bWwjcnVubmluZy1hLXNjcmlwdAogdm9pZCBIVE1MU2Ny aXB0UnVubmVyOjpydW5TY3JpcHQoRWxlbWVudCogc2NyaXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVt YmVyKQpAQCAtMjY3LDggKzI5MiwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlw dChFbGVtZW50KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdElt cGxlbWVudGVkKCk7IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+ aGFzQXR0cmlidXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRl ZmVyIGFuZCBhc3luYwotICAgICAgICAgICAgcmVxdWVzdFNjcmlwdChzY3JpcHQpOworICAgICAg ICAgICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYworICAgICAgICAgICAgaWYgKHNjcmlwdC0+aGFz QXR0cmlidXRlKGRlZmVyQXR0cikpCisgICAgICAgICAgICAgICAgcmVxdWVzdERlZmVycmVkU2Ny aXB0KHNjcmlwdCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgcmVxdWVzdFBh cnNpbmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAg ICAgLy8gRklYTUU6IFdlIGRvIG5vdCBibG9jayBpbmxpbmUgPHNjcmlwdD4gdGFncyBvbiBzdHls ZXNoZWV0cyB0byBtYXRjaCB0aGUKICAgICAgICAgICAgIC8vIG9sZCBwYXJzZXIgZm9yIG5vdy4g IFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDAwNDcKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmggYi9XZWJDb3JlL2h0bWwvSFRN TFNjcmlwdFJ1bm5lci5oCmluZGV4IGY5M2FlMTAyYjdkMjhlNzIxNWNlNzk4YTFkYWY3ZDJmNGU3 ZjkwYWQuLmJmOTRkYTIzYmExZjZjYTZiNmE2ZDgwZjQ0NGU4MDViYzQwMjM5NzQgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL0hU TUxTY3JpcHRSdW5uZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVz b3VyY2VDbGllbnQuaCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1 ZGUgPHd0Zi9EZXF1ZS5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CiAKQEAgLTUyLDYgKzUzLDcgQEAgcHVibGljOgogICAgIGJvb2wg ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAgIGJvb2wg aGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2Ny aXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yU3R5bGVzaGVldHMoKTsKKyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmcoKTsKIAogICAgIGJvb2wgaW5TY3JpcHRFeGVjdXRpb24oKSB7IHJldHVybiAhIW1fc2Ny aXB0TmVzdGluZ0xldmVsOyB9CiAKQEAgLTYzLDcgKzY1LDcgQEAgcHJpdmF0ZToKICAgICAvLyBs aWZldGltZSBpbiBvcmRlciB0byBndWFyYW50ZWUgdGhhdCB0aGUgZGF0YSBidWZmZXIgd2lsbCBu b3QgYmUgcHVyZ2VkLgogICAgIC8vCiAgICAgLy8gRklYTUU6IEZpbmlzaCB0dXJuaW5nIHRoaXMg aW50byBhIHByb3BlciBjbGFzcy4KLSAgICBjbGFzcyBQZW5kaW5nU2NyaXB0IDogcHVibGljIENh Y2hlZFJlc291cmNlQ2xpZW50LCBOb25jb3B5YWJsZSB7CisgICAgY2xhc3MgUGVuZGluZ1Njcmlw dCA6IHB1YmxpYyBDYWNoZWRSZXNvdXJjZUNsaWVudCB7CiAgICAgcHVibGljOgogICAgICAgICBQ ZW5kaW5nU2NyaXB0KCkKICAgICAgICAgICAgIDogc3RhcnRpbmdMaW5lTnVtYmVyKDApCkBAIC03 MSw2ICs3MywyOCBAQCBwcml2YXRlOgogICAgICAgICB7CiAgICAgICAgIH0KIAorICAgICAgICBQ ZW5kaW5nU2NyaXB0KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICAgICAgOiBD YWNoZWRSZXNvdXJjZUNsaWVudChvdGhlcikKKyAgICAgICAgICAgICwgZWxlbWVudChvdGhlci5l bGVtZW50KQorICAgICAgICAgICAgLCBzdGFydGluZ0xpbmVOdW1iZXIob3RoZXIuc3RhcnRpbmdM aW5lTnVtYmVyKQorICAgICAgICAgICAgLCBtX3dhdGNoaW5nRm9yTG9hZChvdGhlci5tX3dhdGNo aW5nRm9yTG9hZCkKKyAgICAgICAgeworICAgICAgICAgICAgc2V0Q2FjaGVkU2NyaXB0KG90aGVy LmNhY2hlZFNjcmlwdCgpKTsKKyAgICAgICAgfQorCisgICAgICAgIFBlbmRpbmdTY3JpcHQmIG9w ZXJhdG9yPShjb25zdCBQZW5kaW5nU2NyaXB0JiBvdGhlcikKKyAgICAgICAgeworICAgICAgICAg ICAgaWYgKHRoaXMgPT0gJm90aGVyKQorICAgICAgICAgICAgICAgIHJldHVybiAqdGhpczsKKwor ICAgICAgICAgICAgZWxlbWVudCA9IG90aGVyLmVsZW1lbnQ7CisgICAgICAgICAgICBzdGFydGlu Z0xpbmVOdW1iZXIgPSBvdGhlci5zdGFydGluZ0xpbmVOdW1iZXI7CisgICAgICAgICAgICBtX3dh dGNoaW5nRm9yTG9hZCA9IG90aGVyLm1fd2F0Y2hpbmdGb3JMb2FkOworICAgICAgICAgICAgc2V0 Q2FjaGVkU2NyaXB0KG90aGVyLmNhY2hlZFNjcmlwdCgpKTsKKworICAgICAgICAgICAgcmV0dXJu ICp0aGlzOworICAgICAgICB9CisKICAgICAgICAgflBlbmRpbmdTY3JpcHQoKTsKIAogICAgICAg ICBQYXNzUmVmUHRyPEVsZW1lbnQ+IHJlbGVhc2VFbGVtZW50QW5kQ2xlYXIoKTsKQEAgLTEwMSw3 ICsxMjUsOSBAQCBwcml2YXRlOgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1Njcmlw dHMoKTsKICAgICB2b2lkIGV4ZWN1dGVQZW5kaW5nU2NyaXB0KCk7CiAKLSAgICB2b2lkIHJlcXVl c3RTY3JpcHQoRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0 JiwgRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVt ZW50Kik7CisgICAgdm9pZCByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIHZv aWQgcnVuU2NyaXB0KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKIAogICAgIC8v IEhlbHBlcnMgZm9yIGRlYWxpbmcgd2l0aCBIVE1MU2NyaXB0UnVubmVySG9zdApAQCAtMTE1LDYg KzE0MSw3IEBAIHByaXZhdGU6CiAgICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CiAgICAgSFRNTFNj cmlwdFJ1bm5lckhvc3QqIG1faG9zdDsKICAgICBQZW5kaW5nU2NyaXB0IG1fcGFyc2luZ0Jsb2Nr aW5nU2NyaXB0OworICAgIERlcXVlPFBlbmRpbmdTY3JpcHQ+IG1fc2NyaXB0c1RvRXhlY3V0ZUFm dGVyUGFyc2luZzsKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8v IFdlIG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlv biBpZiBzY3JpcHQK 60271 2010-07-01 12:26:56 -0700 2010-07-01 15:37:40 -0700 Patch bug-40934-20100701122655.patch text/plain 16359 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxN2NkNzcwYWQ2MWNiZGU1ZDkzZWNlYzMwNWM1NDViMDg1Y2IzMzg0Li5kOWE3NmVh ZDQ1YzBiNTQwNWViZTliN2I1NzYyZDcxYTllZTZlYzBiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAK KzIwMTAtMDctMDEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBFbnN1cmVzIHRoYXQgZGVm ZXJyZWQgc2NyaXB0cyBhcmUgZXhlY3V0ZWQgYWZ0ZXIgaW5saW5lIHN0eWxlc2hlZXRzLAorICAg ICAgICBiZWZvcmUgRE9NQ29udGVudExvYWRlZCwgYW5kIGluIHRoZSBvcmRlciB0aGV5IGFyZSBp bmNsdWRlZCAocmVnYXJkbGVzcworICAgICAgICBvZiB3aGVuIHRoZXkgbG9hZCkuCisKKyAgICAg ICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qczogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanM6IEFk ZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJv ZHktYmFja2dyb3VuZC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVy LXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mv c2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci5odG1sOiBBZGRlZC4KKwogMjAxMC0wNy0wMSAgQWxleGV5IFByb3Nr dXJ5YWtvdiAgPGFwQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxl ci4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVm ZXItc2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZl ci1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUxYzQ0Mjg3YzNiNmNmNGVmZDYxMjEw OGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5h bC1zY3JpcHQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVy bmFsLXNjcmlwdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYmFkNDY1MjM0MjA1NWNlYmIxOWQxNDQ1MmViZGUx ZWE0NDc3ZWY4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNj L3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImV4dGVy bmFsIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uMWNhYWQ3ZWVlYTBjNDRkNjMyOGQxMWE1NWUxY2FkNjE4NGJjNjliYgotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVn LWJvZHktYmFja2dyb3VuZC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygnQm9keSBiYWNrZ3JvdW5k OiAnICsgZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvcidd KTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xv dy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3 MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBA QAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2YXNj cmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0 eWxlc2hlZXQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93 LXN0eWxlc2hlZXQuY2dpCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjIwZDI2N2U0MmY1NDZmOTc4MjgwZTM5YTIzM2Yz ZGVlMDQ5MWVlMzcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3Iv YmluL3BlcmwgLXcKKworcHJpbnQgIkNvbnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsKK3NsZWVw KDAuNSk7CitwcmludCAiYm9keSB7IGJhY2tncm91bmQtY29sb3I6IHJlZCB9XG4iOwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93 LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjVkOTQ0ZDZhNGZkZTE3ZjYwYzhiNDgxZDYxZDI0N2VjZTllYmU5MDYKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ct c3R5bGVzaGVldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw0IEBACitUaGlzIHRlc3RzIHRoYXQg YW4gaW5saW5lIHNsb3cgc3R5bGVzaGVldCBleGVjdXRlcyBiZWZvcmUgZGVmZXJyZWQgc2NyaXB0 cy4NCitCb2R5IGJhY2tncm91bmQ6IHJnYigyNTUsIDAsIDApDQorRE9NQ29udGVudExvYWRlZA0K Kw0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIt YWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mv c2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjczYjM4 OGY5OGUwYTI3N2IyM2Q1MDM3NzVmOGQ2ODlkNWYyZGE5NjQKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVz aGVldC5odG1sCkBAIC0wLDAgKzEsMjEgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVU Ri8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIgLz4KKzxsaW5rIHJl bD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC1zdHls ZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorVGhpcyB0ZXN0cyB0aGF0IGFuIGlubGlu ZSBzbG93IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNjcmlwdHMuCis8ZGl2 IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor ZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkg eworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+CisK KzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcyIgZGVmZXI9ImRlZmVyIj48L3NjcmlwdD4KKzxsaW5r IHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3Vy Y2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kiPgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5hZGU4MzYyZWEyY2I0YjU5ZTk4ZTEwYzBhNDg5ZTYxYWFhZDY2M2U1Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSw4IEBACitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9u IG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4NCitleHRlcm5hbA0KK2lubGluZQ0KK3Ns b3dEZWZlcg0KK2RlZmVyDQorRE9NQ29udGVudExvYWRlZA0KK2xvYWQNCisNCmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhi MzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2MzMwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0 IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRt bD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0 L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4u Ly4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+ Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgorVGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4 ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVm PSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMDwvYT4uCis8ZGl2IGlkPSJjb25z b2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZG9jdW1lbnQu YWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1 ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNy Yz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0 LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAu MC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzIiBkZWZlcj0iREVGRVIiPjwv c2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNl cy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUi KTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFu Z2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2YjM5N2Y2YzFkNGNmNmUzNDgzNWYwMmI3 ZDRiOWEwN2MwYWFlYjU0Li5lZjAyOGIxYzI3MzUwODBmYTdmMDBjMDIzYWUxYjI2NDUwZGNhYmY1 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDMwIEBACisyMDEwLTA3LTAxICBUb255IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAg ICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVjaWZpZWQgYnkgSFRNTDUKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAg U2VlOiBodHRwOi8vZGV2LnczLm9yZy9odG1sNS9zcGVjL092ZXJ2aWV3Lmh0bWwjdGhlLWVuZAor CisgICAgICAgIFRlc3RzOiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ct c3R5bGVzaGVldC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRl ZmVyLmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKToKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2lu Z0FuZEVuZCk6CisgICAgICAgICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAg KiBodG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlw dFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6 OkhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAgICAg ICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdCk6CisgICAgICAgICog aHRtbC9IVE1MU2NyaXB0UnVubmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVu bmVyOjpQZW5kaW5nU2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6OlBlbmRpbmdTY3JpcHQ6Om9wZXJhdG9yPSk6CisKIDIwMTAtMDctMDEg IEFsZXhleSBQcm9za3VyeWFrb3YgIDxhcEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGFyaW4gQWRsZXIuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFy c2VyLmNwcCBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCmluZGV4IGE1Yzlj NjY3YzA1NDZmMjFmYWIzNjY3MzIwZGVlNmNjOTEzMGVmNGUuLmRmM2ZjNDIyMzRkYjc0OWZjYzVi YTEyYThiZjRlNTY0ODRkMWMwMmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1l bnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCkBA IC0yNzUsNyArMjc1LDcgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmF0dGVtcHRUb0VuZCgp CiAgICAgICAgIG1fZW5kV2FzRGVsYXllZCA9IHRydWU7CiAgICAgICAgIHJldHVybjsKICAgICB9 Ci0gICAgZW5kKCk7CisgICAgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgp OwogfQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKQEAgLTI4NCw2 ICsyODQsMTkgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCiAgICAg ICAgIHJldHVybjsKIAogICAgIG1fZW5kV2FzRGVsYXllZCA9IGZhbHNlOworICAgIGV4ZWN1dGVT Y3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKK30KKwordm9pZCBIVE1MRG9jdW1lbnRQ YXJzZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKQoreworICAgIGlm IChtX3NjcmlwdFJ1bm5lcikgeworICAgICAgICBib29sIGNvbnRpbnVlUGFyc2luZyA9IG1fc2Ny aXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCk7CisgICAgICAgIGlm ICghY29udGludWVQYXJzaW5nKSB7CisgICAgICAgICAgICBtX3RyZWVCdWlsZGVyLT5zZXRQYXVz ZWQodHJ1ZSk7CisgICAgICAgICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOworICAgICAgICAg ICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQogICAgIGVuZCgpOwogfQogCmRpZmYgLS1naXQg YS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3JlL2h0bWwvSFRNTERv Y3VtZW50UGFyc2VyLmgKaW5kZXggYjJhNjVjYTFlM2NhOWY2ODM3YTM4Mjg5YmM3MTI2NjMxZmI1 ZGJmYy4uY2FlNjQ0ZWZjOWU4MGM2NmJlNTdkMGRiMmIyYmU1Zjc1NDJkNmZkYyAxMDA2NDQKLS0t IGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dlYkNvcmUvaHRtbC9I VE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTA0LDYgKzEwNCw3IEBAIHByaXZhdGU6CiAgICAgdm9p ZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRvRW5kKCk7CiAgICAgdm9pZCBlbmRJZkRlbGF5 ZWQoKTsKKyAgICB2b2lkIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsK ICAgICB2b2lkIGVuZCgpOwogCiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJlc3VtZSgpIGNvbnN0 OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwIGIvV2ViQ29y ZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmluZGV4IDI5NzkwYzA1NmJkOTQ1OWNhYzA3ZTM1 N2M5YzgwYjRkOTA0MzRjNzYuLmYzYWFhODU0ZTg2ZmEzMjZkZDA4YzBlZjI0N2I3MGU1ODhhNTEx YTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9X ZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKQEAgLTIyOCwzMyArMjI4LDU4IEBAIGJv b2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMo KQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwogfQogCi12b2lk IEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQoRWxlbWVudCogc2NyaXB0KQorYm9vbCBI VE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCkKIHsKLSAg ICBBU1NFUlQoIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQpOwotICAgIEF0b21pY1N0 cmluZyBzcmNWYWx1ZSA9IHNjcmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOwotICAgIC8vIEFs bG93IHRoZSBob3N0IHRvIGRpc2xsb3cgc2NyaXB0IGxvYWRzICh1c2luZyB0aGUgWFNTQXVkaXRv ciwgZXRjLikKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0Vt cHR5KCkpIHsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkpOwor ICAgICAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCA9IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVy UGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAgICAgaWYgKCFleGVjdXRlUGFyc2luZ0Jsb2NraW5n U2NyaXB0cygpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdT Y3JpcHQpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAgfQorCisg ICAgcmV0dXJuIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCk7Cit9CisK K3ZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0JiBwZW5k aW5nU2NyaXB0LCBFbGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIEFTU0VSVCghcGVuZGlu Z1NjcmlwdC5lbGVtZW50KTsKKyAgICBBdG9taWNTdHJpbmcgc3JjVmFsdWUgPSBzY3JpcHRFbGVt ZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3QtPnNob3VsZExvYWRF eHRlcm5hbFNjcmlwdEZyb21TcmMoc3JjVmFsdWUpKQogICAgICAgICByZXR1cm47CiAgICAgLy8g RklYTUU6IFdlIG5lZWQgdG8gcmVzb2x2ZSB0aGUgdXJsIHJlbGF0aXZlIHRvIHRoZSBlbGVtZW50 LgotICAgIGlmICghc2NyaXB0LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkpCisg ICAgaWYgKCFzY3JpcHRFbGVtZW50LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkp CiAgICAgICAgIHJldHVybjsKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5lbGVtZW50ID0g c2NyaXB0OworICAgIHBlbmRpbmdTY3JpcHQuZWxlbWVudCA9IHNjcmlwdEVsZW1lbnQ7CiAgICAg Ly8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBvciBpbnZhbGlkIHNy Y1ZhbHVlcy4KLSAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRv Y0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0 KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBDYWNoZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1f ZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVs ZW1lbnQoc2NyaXB0RWxlbWVudCktPnNjcmlwdENoYXJzZXQoKSk7CiAgICAgaWYgKCFjYWNoZWRT Y3JpcHQpIHsKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gRGlzcGF0Y2ggZXJyb3IgZXZl bnQuCiAgICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5zZXRDYWNoZWRTY3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5nU2NyaXB0LnNldENh Y2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworfQorCit2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJl cXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAg ICByZXF1ZXN0U2NyaXB0KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsK IAogICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91dCBhIGxvYWQgY2FsbGJhY2sgaWYgY2FjaGVkU2Ny aXB0IGlzIG5vdCBhbHJlYWR5CiAgICAgLy8gaW4gdGhlIGNhY2hlLiAgQ2FsbGVycyB3aWxsIGF0 dGVtcHQgdG8gcnVuIHRoZSBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdAogICAgIC8vIGlmIHBvc3Np YmxlIGJlZm9yZSByZXR1cm5pbmcgY29udHJvbCB0byB0aGUgcGFyc2VyLgotICAgIGlmICghbV9w YXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVkKCkpCisgICAgaWYg KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpICYmICFtX3BhcnNpbmdCbG9j a2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkKICAgICAgICAgd2F0Y2hGb3JM b2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVubmVy OjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAgICBQ ZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgcmVxdWVzdFNjcmlwdChwZW5kaW5nU2Ny aXB0LCBzY3JpcHRFbGVtZW50KTsKKyAgICBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcu YXBwZW5kKHBlbmRpbmdTY3JpcHQpOworfQorCiAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCB0byBt YXRjaCB0aGUgSFRNTDUgZGVmaW5pdGlvbiBvZiAicnVubmluZyBhIHNjcmlwdCIKIC8vIGh0dHA6 Ly93d3cud2hhdHdnLm9yZy9zcGVjcy93ZWItYXBwcy9jdXJyZW50LXdvcmsvbXVsdGlwYWdlL3Nj cmlwdGluZy0xLmh0bWwjcnVubmluZy1hLXNjcmlwdAogdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpy dW5TY3JpcHQoRWxlbWVudCogc2NyaXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKQpAQCAtMjY3 LDggKzI5MiwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBz Y3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7 IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRl KHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBhc3lu YwotICAgICAgICAgICAgcmVxdWVzdFNjcmlwdChzY3JpcHQpOworICAgICAgICAgICAgLy8gRklY TUU6IEhhbmRsZSBhc3luYworICAgICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKGRl ZmVyQXR0cikpCisgICAgICAgICAgICAgICAgcmVxdWVzdERlZmVycmVkU2NyaXB0KHNjcmlwdCk7 CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2lu Z1NjcmlwdChzY3JpcHQpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgLy8gRklYTUU6 IFdlIGRvIG5vdCBibG9jayBpbmxpbmUgPHNjcmlwdD4gdGFncyBvbiBzdHlsZXNoZWV0cyB0byBt YXRjaCB0aGUKICAgICAgICAgICAgIC8vIG9sZCBwYXJzZXIgZm9yIG5vdy4gIFNlZSBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDAwNDcKZGlmZiAtLWdpdCBhL1dlYkNv cmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmggYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5l ci5oCmluZGV4IGY5M2FlMTAyYjdkMjhlNzIxNWNlNzk4YTFkYWY3ZDJmNGU3ZjkwYWQuLmJmOTRk YTIzYmExZjZjYTZiNmE2ZDgwZjQ0NGU4MDViYzQwMjM5NzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv aHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5u ZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQu aCIKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgPHd0Zi9EZXF1 ZS5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVm UHRyLmg+CiAKQEAgLTUyLDYgKzUzLDcgQEAgcHVibGljOgogICAgIGJvb2wgZXhlY3V0ZVNjcmlw dHNXYWl0aW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAgIGJvb2wgaGFzU2NyaXB0c1dh aXRpbmdGb3JTdHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2NyaXB0c1dhaXRpbmdG b3JTdHlsZXNoZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVz aGVldHMoKTsKKyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKTsKIAog ICAgIGJvb2wgaW5TY3JpcHRFeGVjdXRpb24oKSB7IHJldHVybiAhIW1fc2NyaXB0TmVzdGluZ0xl dmVsOyB9CiAKQEAgLTYzLDcgKzY1LDcgQEAgcHJpdmF0ZToKICAgICAvLyBsaWZldGltZSBpbiBv cmRlciB0byBndWFyYW50ZWUgdGhhdCB0aGUgZGF0YSBidWZmZXIgd2lsbCBub3QgYmUgcHVyZ2Vk LgogICAgIC8vCiAgICAgLy8gRklYTUU6IEZpbmlzaCB0dXJuaW5nIHRoaXMgaW50byBhIHByb3Bl ciBjbGFzcy4KLSAgICBjbGFzcyBQZW5kaW5nU2NyaXB0IDogcHVibGljIENhY2hlZFJlc291cmNl Q2xpZW50LCBOb25jb3B5YWJsZSB7CisgICAgY2xhc3MgUGVuZGluZ1NjcmlwdCA6IHB1YmxpYyBD YWNoZWRSZXNvdXJjZUNsaWVudCB7CiAgICAgcHVibGljOgogICAgICAgICBQZW5kaW5nU2NyaXB0 KCkKICAgICAgICAgICAgIDogc3RhcnRpbmdMaW5lTnVtYmVyKDApCkBAIC03MSw2ICs3MywyOCBA QCBwcml2YXRlOgogICAgICAgICB7CiAgICAgICAgIH0KIAorICAgICAgICBQZW5kaW5nU2NyaXB0 KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICAgICAgOiBDYWNoZWRSZXNvdXJj ZUNsaWVudChvdGhlcikKKyAgICAgICAgICAgICwgZWxlbWVudChvdGhlci5lbGVtZW50KQorICAg ICAgICAgICAgLCBzdGFydGluZ0xpbmVOdW1iZXIob3RoZXIuc3RhcnRpbmdMaW5lTnVtYmVyKQor ICAgICAgICAgICAgLCBtX3dhdGNoaW5nRm9yTG9hZChvdGhlci5tX3dhdGNoaW5nRm9yTG9hZCkK KyAgICAgICAgeworICAgICAgICAgICAgc2V0Q2FjaGVkU2NyaXB0KG90aGVyLmNhY2hlZFNjcmlw dCgpKTsKKyAgICAgICAgfQorCisgICAgICAgIFBlbmRpbmdTY3JpcHQmIG9wZXJhdG9yPShjb25z dCBQZW5kaW5nU2NyaXB0JiBvdGhlcikKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKHRoaXMg PT0gJm90aGVyKQorICAgICAgICAgICAgICAgIHJldHVybiAqdGhpczsKKworICAgICAgICAgICAg ZWxlbWVudCA9IG90aGVyLmVsZW1lbnQ7CisgICAgICAgICAgICBzdGFydGluZ0xpbmVOdW1iZXIg PSBvdGhlci5zdGFydGluZ0xpbmVOdW1iZXI7CisgICAgICAgICAgICBtX3dhdGNoaW5nRm9yTG9h ZCA9IG90aGVyLm1fd2F0Y2hpbmdGb3JMb2FkOworICAgICAgICAgICAgc2V0Q2FjaGVkU2NyaXB0 KG90aGVyLmNhY2hlZFNjcmlwdCgpKTsKKworICAgICAgICAgICAgcmV0dXJuICp0aGlzOworICAg ICAgICB9CisKICAgICAgICAgflBlbmRpbmdTY3JpcHQoKTsKIAogICAgICAgICBQYXNzUmVmUHRy PEVsZW1lbnQ+IHJlbGVhc2VFbGVtZW50QW5kQ2xlYXIoKTsKQEAgLTEwMSw3ICsxMjUsOSBAQCBw cml2YXRlOgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKICAgICB2 b2lkIGV4ZWN1dGVQZW5kaW5nU2NyaXB0KCk7CiAKLSAgICB2b2lkIHJlcXVlc3RTY3JpcHQoRWxl bWVudCopOworICAgIHZvaWQgcmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0JiwgRWxlbWVudCop OworICAgIHZvaWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAg dm9pZCByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIHZvaWQgcnVuU2NyaXB0 KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKIAogICAgIC8vIEhlbHBlcnMgZm9y IGRlYWxpbmcgd2l0aCBIVE1MU2NyaXB0UnVubmVySG9zdApAQCAtMTE1LDYgKzE0MSw3IEBAIHBy aXZhdGU6CiAgICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CiAgICAgSFRNTFNjcmlwdFJ1bm5lckhv c3QqIG1faG9zdDsKICAgICBQZW5kaW5nU2NyaXB0IG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0Owor ICAgIERlcXVlPFBlbmRpbmdTY3JpcHQ+IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZzsK ICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8vIFdlIG9ubHkgd2Fu dCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlvbiBpZiBzY3JpcHQK 60302 2010-07-01 15:37:44 -0700 2010-07-29 21:25:52 -0700 Patch bug-40934-20100701153742.patch text/plain 19022 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiNzkxMjk5MmJjOThjZGNlN2NjNjUxZGVkNzlmNDgxNjQzY2ViOTViLi40OGRmMGJj M2MyZDk2YjRjYWMyOWIxZmExMmQ5NTUyODM3ZWMyNzViIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjggQEAK KzIwMTAtMDctMDEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBFbnN1cmVzIHRoYXQgZGVm ZXJyZWQgc2NyaXB0cyBhcmUgZXhlY3V0ZWQgYWZ0ZXIgaW5saW5lIHN0eWxlc2hlZXRzLAorICAg ICAgICBiZWZvcmUgRE9NQ29udGVudExvYWRlZCwgYW5kIGluIHRoZSBvcmRlciB0aGV5IGFyZSBp bmNsdWRlZCAocmVnYXJkbGVzcworICAgICAgICBvZiB3aGVuIHRoZXkgbG9hZCkuIEFsc28gZW5z dXJlcyB0aGF0IGRvY3VtZW50LndyaXRpbmcgYSBzdHlsZXNoZWV0CisgICAgICAgIGZyb20gYSBk ZWZlcnJlZCBzY3JpcHQgd29ya3MuCisKKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2RlZmVyLXNjcmlwdC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9leHRlcm5hbC1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qczogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUtc2xvdy1zdHls ZXNoZWV0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Ns b3ctZGVmZXItc2NyaXB0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1z dHlsZXNoZWV0Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItd3JpdGUtc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQuaHRt bDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3Rl ZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRt bDogQWRkZWQuCisKIDIwMTAtMDctMDEgIEtpbnVrbyBZYXN1ZGEgIDxraW51a29AY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuIFVwZGF0ZSBjaHJvbWl1bSB0ZXN0cyBleHBlY3Rh dGlvbnMgZm9yIGZsYWt5IHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFj NDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMKQEAgLTAsMCArMSBA QAorZGVidWcoImRlZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQy MDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcwpAQCAtMCww ICsxIEBACitkZWJ1ZygiZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFj a2dyb3VuZC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xY2FhZDdlZWVhMGM0NGQ2MzI4ZDExYTU1ZTFjYWQ2MTg0 YmM2OWJiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCkBAIC0wLDAgKzEgQEAKK2Rl YnVnKCdCb2R5IGJhY2tncm91bmQ6ICcgKyBnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkp WydiYWNrZ3JvdW5kLWNvbG9yJ10pOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNo ZWV0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmVkMTFlYjUyYzZlZjdmZWVmMTUxZDJkNDc5OWUzZGMyYWViMjc2 ZjMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMKQEAgLTAsMCArMSBAQAorZG9jdW1l bnQud3JpdGUoJzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cDovLzEyNy4wLjAuMTo4 MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kiPicpOwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5j Z2kgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2Ny aXB0LmNnaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5hOThkM2Q1YTgxZDM3ODg3NjkyYzczOTIyYzhkM2MyOWYxYjZi ZDE4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3Bl cmwgLXcKKworcHJpbnQgIkNvbnRlbnQtdHlwZTogdGV4dC9qYXZhc2NyaXB0XG5cbiI7CitzbGVl cCgwLjUpOworcHJpbnQgImRlYnVnKCdzbG93RGVmZXInKTtcbiI7CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uMjBkMjY3ZTQyZjU0NmY5NzgyODBlMzlhMjMzZjNkZWUwNDkxZWUzNwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xv dy1zdHlsZXNoZWV0LmNnaQpAQCAtMCwwICsxLDUgQEAKKyMhL3Vzci9iaW4vcGVybCAtdworCitw cmludCAiQ29udGVudC10eXBlOiB0ZXh0L2Nzc1xuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJi b2R5IHsgYmFja2dyb3VuZC1jb2xvcjogcmVkIH1cbiI7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVy LXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNWQ5NDRkNmE0ZmRlMTdm NjBjOGI0ODFkNjFkMjQ3ZWNlOWViZTkwNgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBz dHlsZXNoZWV0IGV4ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLg0KK0JvZHkgYmFja2dy b3VuZDogcmdiKDI1NSwgMCwgMCkNCitET01Db250ZW50TG9hZGVkDQorDQpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxl c2hlZXQuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0 ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzNiMzg4Zjk4ZTBhMjc3YjIzZDUw Mzc3NWY4ZDY4OWQ1ZjJkYTk2NAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAs MCArMSwyMSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4i PgorPGh0bWw+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVu dD0idGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBo cmVmPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+CitUaGlzIHRlc3RzIHRoYXQgYW4gaW5saW5lIHNsb3cgc3R5bGVzaGVl dCBleGVjdXRlcyBiZWZvcmUgZGVmZXJyZWQgc2NyaXB0cy4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwv ZGl2PgorCis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVu dExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01D b250ZW50TG9hZGVkJyk7Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KKworPHNjcmlwdCBzcmM9Imh0 dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNr Z3JvdW5kLmpzIiBkZWZlcj0iZGVmZXIiPjwvc2NyaXB0PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0 IiBocmVmPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNo ZWV0LmNnaSI+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFkZTgzNjJl YTJjYjRiNTllOThlMTBjMGE0ODllNjFhYWFkNjYzZTUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDggQEAKK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Ygc2NyaXB0 cyB3aXRoIHRoZSBkZWZlciBhdHRyaWJ1dGUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwNzEwLg0KK2V4dGVybmFsDQoraW5saW5lDQorc2xvd0RlZmVyDQorZGVmZXIN CitET01Db250ZW50TG9hZGVkDQorbG9hZA0KKw0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUtc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUtc2xv dy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mZGQwNjI1YjkyODg2ZjRjYTRl OTU1NTRjYWVjMzMwNGFjMWI5YjU4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsNCBAQAorVGhpcyB0ZXN0cyBhIGRlZmVycmVkIHNjcmlwdCB3aGljaCB3 cml0ZXMgYSBzbG93IHN0eWxlc2hlZXQuDQorQm9keSBiYWNrZ3JvdW5kOiByZ2IoMjU1LCAwLCAw KQ0KK0RPTUNvbnRlbnRMb2FkZWQNCisNCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi40MGU3OTg3MTM5NTY5ZDc3OTU1MzU3MDFlYTNhYjNjNTg5OTVmMjgy Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQuaHRtbApAQCAtMCwwICsxLDIxIEBACis8IURPQ1RZ UEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgor PG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJz ZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3Qt cmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0 LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK1Ro aXMgdGVzdHMgYSBkZWZlcnJlZCBzY3JpcHQgd2hpY2ggd3JpdGVzIGEgc2xvdyBzdHlsZXNoZWV0 LgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisKKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2Ny aXB0Ij4KK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5j dGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKK30sIGZhbHNlKTsKKzwvc2Ny aXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2Vz L3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMiIGRlZmVyPSJkZWZlciI+PC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Njcmlw dC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMiIGRlZmVyPSJkZWZlciI+PC9zY3JpcHQ+Cis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhiMzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2Mz MwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lF VEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29u dGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5 bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgor VGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhl IGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y MDcxMDwvYT4uCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRl ZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2Up OworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVz b3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2Ny aXB0LmpzIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcu MC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0Pgor PHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUiKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBm N2IyNzc2YzQxMjljOGI2N2UxYWY0Yjg4ZmNlNDkyZTE5MDk2ZDU0Li5kNjM3MDk3OGIzYjE3YmUz MTMxMmE0ODg3MTQ1YjUwN2M4NzkzZGNkIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEwLTA3LTAxICBUb255 IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVj aWZpZWQgYnkgSFRNTDUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQwOTM0CisKKyAgICAgICAgU2VlOiBodHRwOi8vZGV2LnczLm9yZy9odG1sNS9zcGVj L092ZXJ2aWV3Lmh0bWwjdGhlLWVuZAorCisgICAgICAgIFRlc3RzOiBodHRwL3Rlc3RzL21pc2Mv c2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAgICAgICAgICAgICBo dHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC5odG1sCisg ICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKKworICAgICAg ICAqIGh0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxE b2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1 bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVu dFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCk6CisgICAgICAg ICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBodG1sL0hUTUxTY3JpcHRS dW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNj cmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVu bmVyOjpyZXF1ZXN0U2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6 OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNj cmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdCk6CisgICAgICAgICogaHRtbC9IVE1MU2NyaXB0UnVu bmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpQZW5kaW5nU2NyaXB0 OjpQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OlBl bmRpbmdTY3JpcHQ6Om9wZXJhdG9yPSk6CisKIDIwMTAtMDctMDEgIERhcmluIEFkbGVyICA8ZGFy aW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFN0ZXZlIEZhbGtlbmJ1cmcuCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcCBiL1dlYkNvcmUv aHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCmluZGV4IGE1YzljNjY3YzA1NDZmMjFmYWIzNjY3 MzIwZGVlNmNjOTEzMGVmNGUuLmRmM2ZjNDIyMzRkYjc0OWZjYzViYTEyYThiZjRlNTY0ODRkMWMw MmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCisrKyBi L1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCkBAIC0yNzUsNyArMjc1LDcgQEAg dm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmF0dGVtcHRUb0VuZCgpCiAgICAgICAgIG1fZW5kV2Fz RGVsYXllZCA9IHRydWU7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgZW5kKCk7CisgICAg ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgpOwogfQogCiB2b2lkIEhUTUxE b2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKQEAgLTI4NCw2ICsyODQsMTkgQEAgdm9pZCBI VE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCiAgICAgICAgIHJldHVybjsKIAogICAg IG1fZW5kV2FzRGVsYXllZCA9IGZhbHNlOworICAgIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmdBbmRFbmQoKTsKK30KKwordm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmV4ZWN1dGVTY3Jp cHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKQoreworICAgIGlmIChtX3NjcmlwdFJ1bm5lcikg eworICAgICAgICBib29sIGNvbnRpbnVlUGFyc2luZyA9IG1fc2NyaXB0UnVubmVyLT5leGVjdXRl U2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCk7CisgICAgICAgIGlmICghY29udGludWVQYXJzaW5n KSB7CisgICAgICAgICAgICBtX3RyZWVCdWlsZGVyLT5zZXRQYXVzZWQodHJ1ZSk7CisgICAgICAg ICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOworICAgICAgICAgICAgcmV0dXJuOworICAgICAg ICB9CisgICAgfQogICAgIGVuZCgpOwogfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRN TERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5k ZXggYjJhNjVjYTFlM2NhOWY2ODM3YTM4Mjg5YmM3MTI2NjMxZmI1ZGJmYy4uY2FlNjQ0ZWZjOWU4 MGM2NmJlNTdkMGRiMmIyYmU1Zjc1NDJkNmZkYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hU TUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIu aApAQCAtMTA0LDYgKzEwNCw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZv aWQgYXR0ZW1wdFRvRW5kKCk7CiAgICAgdm9pZCBlbmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIGV4 ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKICAgICB2b2lkIGVuZCgpOwog CiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJlc3VtZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRS dW5uZXIuY3BwCmluZGV4IDI5NzkwYzA1NmJkOTQ1OWNhYzA3ZTM1N2M5YzgwYjRkOTA0MzRjNzYu LjQxMzRmYWNhZDkxOTBlODRjNzhkOWI4MmUyM2ZmNGJjOTE0ZjQyMTcgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNj cmlwdFJ1bm5lci5jcHAKQEAgLTIyOCwzMyArMjI4LDU5IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5l cjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVj dXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwogfQogCi12b2lkIEhUTUxTY3JpcHRSdW5uZXI6 OnJlcXVlc3RTY3JpcHQoRWxlbWVudCogc2NyaXB0KQorYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpl eGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCkKIHsKLSAgICBBU1NFUlQoIW1fcGFyc2lu Z0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQpOwotICAgIEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNj cmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOwotICAgIC8vIEFsbG93IHRoZSBob3N0IHRvIGRp c2xsb3cgc2NyaXB0IGxvYWRzICh1c2luZyB0aGUgWFNTQXVkaXRvciwgZXRjLikKKyAgICB3aGls ZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAg QVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkpOworICAgICAgICBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdCA9IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3Qo KTsKKyAgICAgICAgaWYgKCFleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpKSB7CisgICAg ICAgICAgICBpZiAobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgIW1f cGFyc2luZ0Jsb2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKQorICAgICAg ICAgICAgICAgIHdhdGNoRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gbV9zY3Jp cHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKTsKK30KKwordm9pZCBIVE1MU2NyaXB0 UnVubmVyOjpyZXF1ZXN0U2NyaXB0KFBlbmRpbmdTY3JpcHQmIHBlbmRpbmdTY3JpcHQsIEVsZW1l bnQqIHNjcmlwdEVsZW1lbnQpCit7CisgICAgQVNTRVJUKCFwZW5kaW5nU2NyaXB0LmVsZW1lbnQp OworICAgIEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNjcmlwdEVsZW1lbnQtPmdldEF0dHJpYnV0 ZShzcmNBdHRyKTsKICAgICBpZiAoIW1faG9zdC0+c2hvdWxkTG9hZEV4dGVybmFsU2NyaXB0RnJv bVNyYyhzcmNWYWx1ZSkpCiAgICAgICAgIHJldHVybjsKICAgICAvLyBGSVhNRTogV2UgbmVlZCB0 byByZXNvbHZlIHRoZSB1cmwgcmVsYXRpdmUgdG8gdGhlIGVsZW1lbnQuCi0gICAgaWYgKCFzY3Jp cHQtPmRpc3BhdGNoQmVmb3JlTG9hZEV2ZW50KHNyY1ZhbHVlKSkKKyAgICBpZiAoIXNjcmlwdEVs ZW1lbnQtPmRpc3BhdGNoQmVmb3JlTG9hZEV2ZW50KHNyY1ZhbHVlKSkKICAgICAgICAgcmV0dXJu OwotICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQgPSBzY3JpcHQ7CisgICAgcGVu ZGluZ1NjcmlwdC5lbGVtZW50ID0gc2NyaXB0RWxlbWVudDsKICAgICAvLyBUaGlzIHNob3VsZCBj b3JyZWN0bHkgcmV0dXJuIDAgZm9yIGVtcHR5IG9yIGludmFsaWQgc3JjVmFsdWVzLgotICAgIENh Y2hlZFNjcmlwdCogY2FjaGVkU2NyaXB0ID0gbV9kb2N1bWVudC0+ZG9jTG9hZGVyKCktPnJlcXVl c3RTY3JpcHQoc3JjVmFsdWUsIHRvU2NyaXB0RWxlbWVudChzY3JpcHQpLT5zY3JpcHRDaGFyc2V0 KCkpOworICAgIENhY2hlZFNjcmlwdCogY2FjaGVkU2NyaXB0ID0gbV9kb2N1bWVudC0+ZG9jTG9h ZGVyKCktPnJlcXVlc3RTY3JpcHQoc3JjVmFsdWUsIHRvU2NyaXB0RWxlbWVudChzY3JpcHRFbGVt ZW50KS0+c2NyaXB0Q2hhcnNldCgpKTsKICAgICBpZiAoIWNhY2hlZFNjcmlwdCkgewogICAgICAg ICBub3RJbXBsZW1lbnRlZCgpOyAvLyBEaXNwYXRjaCBlcnJvciBldmVudC4KICAgICAgICAgcmV0 dXJuOwogICAgIH0KIAotICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LnNldENhY2hlZFNjcmlw dChjYWNoZWRTY3JpcHQpOworICAgIHBlbmRpbmdTY3JpcHQuc2V0Q2FjaGVkU2NyaXB0KGNhY2hl ZFNjcmlwdCk7Cit9CisKK3ZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBhcnNpbmdCbG9j a2luZ1NjcmlwdChFbGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIHJlcXVlc3RTY3JpcHQo bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIHNjcmlwdEVsZW1lbnQpOwogCiAgICAgLy8gV2Ugb25s eSBjYXJlIGFib3V0IGEgbG9hZCBjYWxsYmFjayBpZiBjYWNoZWRTY3JpcHQgaXMgbm90IGFscmVh ZHkKICAgICAvLyBpbiB0aGUgY2FjaGUuICBDYWxsZXJzIHdpbGwgYXR0ZW1wdCB0byBydW4gdGhl IG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0CiAgICAgLy8gaWYgcG9zc2libGUgYmVmb3JlIHJldHVy bmluZyBjb250cm9sIHRvIHRoZSBwYXJzZXIuCi0gICAgaWYgKCFtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkKKyAgICBpZiAobV9wYXJzaW5nQmxvY2tp bmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmNhY2hl ZFNjcmlwdCgpLT5pc0xvYWRlZCgpKQogICAgICAgICB3YXRjaEZvckxvYWQobV9wYXJzaW5nQmxv Y2tpbmdTY3JpcHQpOwogfQogCit2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3REZWZlcnJl ZFNjcmlwdChFbGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIFBlbmRpbmdTY3JpcHQgcGVu ZGluZ1NjcmlwdDsKKyAgICByZXF1ZXN0U2NyaXB0KHBlbmRpbmdTY3JpcHQsIHNjcmlwdEVsZW1l bnQpOworICAgIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5hcHBlbmQocGVuZGluZ1Nj cmlwdCk7Cit9CisKIC8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IHRvIG1hdGNoIHRoZSBIVE1MNSBk ZWZpbml0aW9uIG9mICJydW5uaW5nIGEgc2NyaXB0IgogLy8gaHR0cDovL3d3dy53aGF0d2cub3Jn L3NwZWNzL3dlYi1hcHBzL2N1cnJlbnQtd29yay9tdWx0aXBhZ2Uvc2NyaXB0aW5nLTEuaHRtbCNy dW5uaW5nLWEtc2NyaXB0CiB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50 KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCkBAIC0yNjcsOCArMjkzLDExIEBAIHZv aWQgSFRNTFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0 aW5nTGluZU51bWJlcikKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gZXZlbnQgZm9yIHN1 cHBvcnQKIAogICAgICAgICBpZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoc3JjQXR0cikpIHsKLSAg ICAgICAgICAgIC8vIEZJWE1FOiBIYW5kbGUgZGVmZXIgYW5kIGFzeW5jCi0gICAgICAgICAgICBy ZXF1ZXN0U2NyaXB0KHNjcmlwdCk7CisgICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGFzeW5j CisgICAgICAgICAgICBpZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoZGVmZXJBdHRyKSkKKyAgICAg ICAgICAgICAgICByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIGVs c2UKKyAgICAgICAgICAgICAgICByZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KHNjcmlwdCk7 CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAvLyBGSVhNRTogV2UgZG8gbm90IGJsb2Nr IGlubGluZSA8c2NyaXB0PiB0YWdzIG9uIHN0eWxlc2hlZXRzIHRvIG1hdGNoIHRoZQogICAgICAg ICAgICAgLy8gb2xkIHBhcnNlciBmb3Igbm93LiAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD00MDA0NwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3Jp cHRSdW5uZXIuaCBiL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZjkzYWUx MDJiN2QyOGU3MjE1Y2U3OThhMWRhZjdkMmY0ZTdmOTBhZC4uYmY5NGRhMjNiYTFmNmNhNmI2YTZk ODBmNDQ0ZTgwNWJjNDAyMzk3NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRS dW5uZXIuaAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5oCkBAIC0yOCw2ICsy OCw3IEBACiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgogI2luY2x1ZGUgIkNh Y2hlZFJlc291cmNlSGFuZGxlLmgiCisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8 d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTIs NiArNTMsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2Fk KENhY2hlZFJlc291cmNlKik7CiAgICAgYm9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hl ZXRzKCkgY29uc3QgeyByZXR1cm4gbV9oYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9 CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJv b2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpblNjcmlw dEV4ZWN1dGlvbigpIHsgcmV0dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAtNjMs NyArNjUsNyBAQCBwcml2YXRlOgogICAgIC8vIGxpZmV0aW1lIGluIG9yZGVyIHRvIGd1YXJhbnRl ZSB0aGF0IHRoZSBkYXRhIGJ1ZmZlciB3aWxsIG5vdCBiZSBwdXJnZWQuCiAgICAgLy8KICAgICAv LyBGSVhNRTogRmluaXNoIHR1cm5pbmcgdGhpcyBpbnRvIGEgcHJvcGVyIGNsYXNzLgotICAgIGNs YXNzIFBlbmRpbmdTY3JpcHQgOiBwdWJsaWMgQ2FjaGVkUmVzb3VyY2VDbGllbnQsIE5vbmNvcHlh YmxlIHsKKyAgICBjbGFzcyBQZW5kaW5nU2NyaXB0IDogcHVibGljIENhY2hlZFJlc291cmNlQ2xp ZW50IHsKICAgICBwdWJsaWM6CiAgICAgICAgIFBlbmRpbmdTY3JpcHQoKQogICAgICAgICAgICAg OiBzdGFydGluZ0xpbmVOdW1iZXIoMCkKQEAgLTcxLDYgKzczLDI4IEBAIHByaXZhdGU6CiAgICAg ICAgIHsKICAgICAgICAgfQogCisgICAgICAgIFBlbmRpbmdTY3JpcHQoY29uc3QgUGVuZGluZ1Nj cmlwdCYgb3RoZXIpCisgICAgICAgICAgICA6IENhY2hlZFJlc291cmNlQ2xpZW50KG90aGVyKQor ICAgICAgICAgICAgLCBlbGVtZW50KG90aGVyLmVsZW1lbnQpCisgICAgICAgICAgICAsIHN0YXJ0 aW5nTGluZU51bWJlcihvdGhlci5zdGFydGluZ0xpbmVOdW1iZXIpCisgICAgICAgICAgICAsIG1f d2F0Y2hpbmdGb3JMb2FkKG90aGVyLm1fd2F0Y2hpbmdGb3JMb2FkKQorICAgICAgICB7CisgICAg ICAgICAgICBzZXRDYWNoZWRTY3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICB9 CisKKyAgICAgICAgUGVuZGluZ1NjcmlwdCYgb3BlcmF0b3I9KGNvbnN0IFBlbmRpbmdTY3JpcHQm IG90aGVyKQorICAgICAgICB7CisgICAgICAgICAgICBpZiAodGhpcyA9PSAmb3RoZXIpCisgICAg ICAgICAgICAgICAgcmV0dXJuICp0aGlzOworCisgICAgICAgICAgICBlbGVtZW50ID0gb3RoZXIu ZWxlbWVudDsKKyAgICAgICAgICAgIHN0YXJ0aW5nTGluZU51bWJlciA9IG90aGVyLnN0YXJ0aW5n TGluZU51bWJlcjsKKyAgICAgICAgICAgIG1fd2F0Y2hpbmdGb3JMb2FkID0gb3RoZXIubV93YXRj aGluZ0ZvckxvYWQ7CisgICAgICAgICAgICBzZXRDYWNoZWRTY3JpcHQob3RoZXIuY2FjaGVkU2Ny aXB0KCkpOworCisgICAgICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgICAgIH0KKwogICAgICAg ICB+UGVuZGluZ1NjcmlwdCgpOwogCiAgICAgICAgIFBhc3NSZWZQdHI8RWxlbWVudD4gcmVsZWFz ZUVsZW1lbnRBbmRDbGVhcigpOwpAQCAtMTAxLDcgKzEyNSw5IEBAIHByaXZhdGU6CiAgICAgYm9v bCBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwogICAgIHZvaWQgZXhlY3V0ZVBlbmRp bmdTY3JpcHQoKTsKIAotICAgIHZvaWQgcmVxdWVzdFNjcmlwdChFbGVtZW50Kik7CisgICAgdm9p ZCByZXF1ZXN0U2NyaXB0KFBlbmRpbmdTY3JpcHQmLCBFbGVtZW50Kik7CisgICAgdm9pZCByZXF1 ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3REZWZl cnJlZFNjcmlwdChFbGVtZW50Kik7CiAgICAgdm9pZCBydW5TY3JpcHQoRWxlbWVudCosIGludCBz dGFydGluZ0xpbmVOdW1iZXIpOwogCiAgICAgLy8gSGVscGVycyBmb3IgZGVhbGluZyB3aXRoIEhU TUxTY3JpcHRSdW5uZXJIb3N0CkBAIC0xMTUsNiArMTQxLDcgQEAgcHJpdmF0ZToKICAgICBEb2N1 bWVudCogbV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OwogICAg IFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7CisgICAgRGVxdWU8UGVuZGlu Z1NjcmlwdD4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOwogICAgIHVuc2lnbmVkIG1f c2NyaXB0TmVzdGluZ0xldmVsOwogCiAgICAgLy8gV2Ugb25seSB3YW50IHN0eWxlc2hlZXQgbG9h ZHMgdG8gdHJpZ2dlciBzY3JpcHQgZXhlY3V0aW9uIGlmIHNjcmlwdAo= 63027 2010-07-29 21:25:56 -0700 2010-07-29 21:31:26 -0700 Patch bug-40934-20100729212555.patch text/plain 28377 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA5ZTYwNTY1NWU5NDRlMzNhNTE5ZDQ3MmU2MmM0ODU2ODE1ZTEzNzE0Li42YjRhNjM4 YmRjMGJhNDBkZTg5NDM3ZGFmNzQ2NjllMjY0MzljYjUzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAK KzIwMTAtMDctMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMYXlvdXRUZXN0cyBm b3IgPHNjcmlwdCBkZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgICogZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLWRlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5IG9yZGVyaW5nIGFu ZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGRlZmVyZWQgc2NyaXB0cy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUt ZXhwZWN0ZWQudHh0OiBDb3BpZWQgZnJvbSBMYXlvdXRUZXN0cy9mYXN0L3Rva2VuaXplci93cml0 ZS1iZWZvcmUtbG9hZC1leHBlY3RlZC50eHQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5 IG9yZGVyaW5nIGFuZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGlubGlu ZSBzY3JpcHRzLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlu bGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0 IHRoZSBkZWZlciBhdHRyaWJ1dGUgaXMgaWdub3JlZCBvbiBpbmxpbmUgc2NyaXB0IGJsb2Nrcy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgb25iZWZvcmVsb2Fk IGZpcmVzIGltbWVkaWF0ZWx5IHdoZW4gYSBkZWZlcnJlZCBzY3JpcHQgaXMgZW5jb3VudGVkLiBB bHNvIHRlc3RzIHRoYXQgaXQgY2FuIGJlIGNhbmNlbGxlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgaW52YWxpZCBVUkxzIGFyZSBpZ25v cmVkIGFuZCBzdWJzZXF1ZW50IHNjcmlwdHMgYXJlIHN0aWxsIGV4ZWN1dGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpz OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMv c2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanM6IEFkZGVk LgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ct c3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVzdHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhh dmlvci4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1z bG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVz dHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhhdmlvciB3aXRoIGEgc2xvdyBzdHlsZXNoZWV0Lgor ICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuIFRlc3Rz IGJhc2ljIGZ1bmN0aW9uYWxpdHkgYW5kIG9yZGVyaW5nLgorCiAyMDEwLTA3LTI4ICBEdW1pdHJ1 IERhbmlsaXVjICA8ZHVtaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2 aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5kNzJjNDYxMGM0YmJjYTU1MTU5OWZiMTZmY2UwMjgxMzZhMTcw ZjcxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBA CisxIDIgMyA0NSA2NwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi42YzU3MjVjMjNiZjljZjg2YjQ3MGM4MzdhZWNlOGJkNWYwNTFhOTQ2Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXIt ZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorMQorPHNjcmlwdD4KK2lm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBkb3VibGVXcml0ZShudW1iZXIpCit7CisgICAgZG9j dW1lbnQud3JpdGUoIjxzY3JpcHQgc3JjPSdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53 cml0ZSgiICsgbnVtYmVyICsgIiknIGRlZmVyPjwvc2NyIiArCisgICAgICAgICAgICAgICAgICAg ImlwdD4gPHNjcmlwdCBzcmM9J2RhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCIg KyAobnVtYmVyICsgMSkgKyAiKScgZGVmZXI+PC9zY3IiICsgImlwdD4gIikKK30KKzwvc2NyaXB0 PgorMgorPHNjcmlwdAorICAgIG9uYmVmb3JlbG9hZD0iZG91YmxlV3JpdGUoNCkiCisgICAgc3Jj PSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb3VibGVXcml0ZSg2KSIKKyAgICBkZWZlcj4KKzwvc2Ny aXB0PgorMwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uYjQ0NTdhYWU2NmY2YjFlNDYxMjJkNzI0ZWExMmU5ZmFlOTU2ZDM5MgotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRv dWJsZS13cml0ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorMSAyIDMgNCA1IDYgNwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jODU4OTkzN2U2Mzg1MGVmMTM2NTli NDUwYTNlNGRiMmJmNDI1ODZkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSwx OCBAQAorMQorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBkb3VibGVXcml0 ZShudW1iZXIpCit7CisgICAgZG9jdW1lbnQud3JpdGUoIjxzY3JpcHQ+ZG9jdW1lbnQud3JpdGUo IiArIG51bWJlciArICIpPC9zY3IiICsKKyAgICAgICAgICAgICAgICAgICAiaXB0PiA8c2NyaXB0 PmRvY3VtZW50LndyaXRlKCIgKyAobnVtYmVyICsgMSkgKyAiKTwvc2NyIiArICJpcHQ+ICIpCit9 Cis8L3NjcmlwdD4KKzIKKzxzY3JpcHQKKyAgICBvbmJlZm9yZWxvYWQ9ImRvdWJsZVdyaXRlKDMp IgorICAgIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG91YmxlV3JpdGUoNikiCisgICAgZGVm ZXI+Cis8L3NjcmlwdD4KKzUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMzg2YTJkYWM5Mzc1NDE1MjA0MmM2MGE4OWJhOGZjZTFjMGVlMGQ2 MQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorQ2hl Y2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KK2lubGluZSBkZWZlcgor ZGVmZXIKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU1Y2NlMjJk OGEyYWIyMWFmOTVjYzNiOGU0YjZhZDQ5OWYwMjM4ZTQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0 bWwKQEAgLTAsMCArMSwxNSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQg SFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0i Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+ CitDaGVja3MgdGhhdCBpbmxpbmUgc2NyaXB0cyBhcmUgbm90IGRlZmVycmVkLgorPGRpdiBpZD0i Y29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBkZWZlcj48 L3NjcmlwdD4KKzxzY3JpcHQgZGVmZXI+CisgIGRlYnVnKCdpbmxpbmUgZGVmZXInKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uODUxYmYwYzkyNjgwMDRjMjcyNjljYzNmYjRlNjZkNmQ5OGU2 YWEzNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9y ZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitkZWZlcgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjZlMGYwNzliMzIxNTU4MjdiZDc2YTNiZWYyZGE0ZTM2NGM1NmRmYTkK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApAQCAtMCwwICsxLDE0IEBACis8IURPQ1RZUEUgSFRN TCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsg cmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5j c3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgZmly ZSBvbmJlZm9yZWxvYWQgaW1tZWRpYXRlbHkgYW5kIHRoYXQgaXQgaXMgY2FuY2VsbGFibGUuCis8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2hvdWxkbm90 ZXhlY3V0ZS5qcyIgb25iZWZvcmVsb2FkPSJyZXR1cm4gZmFsc2U7IiBkZWZlcj48L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZGVmZXIuanMiIG9uYmVmb3JlbG9hZD0iZGVidWcoJ29u YmVmb3JlbG9hZCBkZWZlcicpO3JldHVybiB0cnVlOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0 IHNyYz0icmVzb3VyY2VzL2V4dGVybmFsLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdvbmJlZm9y ZWxvYWQgZXh0ZXJuYWwnKTtyZXR1cm4gdHJ1ZTsiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uODMwY2M2NzMzOGRhNDlhZDgwYmVmMWM5ZjVmYWU4ZjIzM2ZlODVmOAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2Rl ZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBACitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFu ZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgYXJlIGV4ZWN1dGVkLgorZGVmZXIKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2Ny aXB0LWludmFsaWQtdXJsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jOGVlZWRlNmY2 NWJhMjUwMzhmNmQ5YzNiZGY2MTkxNjE4ZTY5ZDg0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJs Lmh0bWwKQEAgLTAsMCArMSwxMyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9E VEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJl Zj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+CitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBp Z25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgYXJlIGV4ZWN1dGVkLgorPGRp diBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNyYz0iaHR0cDovL2ludmFsaWQ6OTk5OTk5 LyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBkZWZl cj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2Rl ZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzIGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFs LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0NzdlZjgK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImV4dGVybmFsIik7 CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNv dXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNiYjZi NGRhNGQyMWM5NzhjOTlmMzg4MDEzMDVmYjYwMWFjYmNhYTQKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90 ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1Zygic2hvdWxkIG5vdCBleGVjdXRlIik7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNj cmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2Ny aXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0 Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2Ny aXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1z Y3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVhNDQ3 N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNv dXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIp OwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3Jp cHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNj L3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFj YWFkN2VlZWEwYzQ0ZDYzMjhkMTFhNTVlMWNhZDYxODRiYzY5YmIKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5 LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoJ0JvZHkgYmFja2dyb3VuZDogJyAr IGdldENvbXB1dGVkU3R5bGUoZG9jdW1lbnQuYm9keSlbJ2JhY2tncm91bmQtY29sb3InXSk7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC13 cml0ZS1zbG93LXN0eWxlc2hlZXQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWQxMWVi NTJjNmVmN2ZlZWYxNTFkMmQ0Nzk5ZTNkYzJhZWIyNzZmMwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5 bGVzaGVldC5qcwpAQCAtMCwwICsxIEBACitkb2N1bWVudC53cml0ZSgnPGxpbmsgcmVsPSJzdHls ZXNoZWV0IiBocmVmPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1z dHlsZXNoZWV0LmNnaSI+Jyk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE5OGQz ZDVhODFkMzc4ODc2OTJjNzM5MjJjOGQzYzI5ZjFiNmJkMTgKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNn aQpAQCAtMCwwICsxLDUgQEAKKyMhL3Vzci9iaW4vcGVybCAtdworCitwcmludCAiQ29udGVudC10 eXBlOiB0ZXh0L2phdmFzY3JpcHRcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiZGVidWcoJ3Ns b3dEZWZlcicpO1xuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yMGQyNjdlNDJmNTQ2 Zjk3ODI4MGUzOWEyMzNmM2RlZTA0OTFlZTM3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCkBAIC0wLDAg KzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQv Y3NzXG5cbiI7CitzbGVlcCgwLjUpOworcHJpbnQgImJvZHkgeyBiYWNrZ3JvdW5kLWNvbG9yOiBy ZWQgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVk LnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5hZjkyYmQyOGQ4N2YyOTQyMTQ0ZTdlMWM4Y2ZkYTU0MzBlYzVmMjIx Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAor VGhpcyB0ZXN0cyB0aGF0IGFuIGlubGluZSBzbG93IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3Jl IGRlZmVycmVkIHNjcmlwdHMuCitCb2R5IGJhY2tncm91bmQ6IHJnYigyNTUsIDAsIDApCitET01D b250ZW50TG9hZGVkCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjczYjM4OGY5OGUwYTI3N2IyM2Q1MDM3NzVmOGQ2ODlkNWYyZGE5NjQKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVy LXNsb3ctc3R5bGVzaGVldC5odG1sCkBAIC0wLDAgKzEsMjEgQEAKKzwhRE9DVFlQRSBIVE1MIFBV QkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRw LWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIg Lz4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMv anMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2Vz L2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorVGhpcyB0ZXN0cyB0 aGF0IGFuIGlubGluZSBzbG93IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNj cmlwdHMuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2ph dmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIs IGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOwor PC9zY3JpcHQ+CisKKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNv dXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcyIgZGVmZXI9ImRlZmVyIj48L3Nj cmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cDovLzEyNy4wLjAuMTo4MDAw L21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kiPgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5iZmNhYTZlOTI0NTQ2YmNiOTRmNDhmZTFmM2Y2MzczNGFlNTE1 MjY1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4IEBACitUaGlzIHRlc3RzIGZvciBwcm9w ZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4KK2V4dGVybmFsCitp bmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNvbnRlbnRMb2FkZWQKK2xvYWQKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93 LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjJlMGNkOTQxMmNkMTAwOWE0MTQ1MmNmZThmNjVlZDg5YWZlMTNhZjcKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ct c3R5bGVzaGVldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw0IEBACitUaGlzIHRlc3RzIGEgZGVm ZXJyZWQgc2NyaXB0IHdoaWNoIHdyaXRlcyBhIHNsb3cgc3R5bGVzaGVldC4KK0JvZHkgYmFja2dy b3VuZDogcmdiKDI1NSwgMCwgMCkKK0RPTUNvbnRlbnRMb2FkZWQKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hl ZXQuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUt c2xvdy1zdHlsZXNoZWV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDBlNzk4NzEzOTU2OWQ3Nzk1NTM1NzAx ZWEzYWIzYzU4OTk1ZjI4MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUtc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAsMCAr MSwyMSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgor PGh0bWw+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0i dGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVm PSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9o ZWFkPgorPGJvZHk+CitUaGlzIHRlc3RzIGEgZGVmZXJyZWQgc2NyaXB0IHdoaWNoIHdyaXRlcyBh IHNsb3cgc3R5bGVzaGVldC4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250 ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7Cit9 LCBmYWxzZSk7Cis8L3NjcmlwdD4KKworPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAw MC9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzIiBkZWZlcj0i ZGVmZXIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNj L3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIiBkZWZlcj0iZGVmZXIi Pjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjk1Y2Y4YjM1MDc1ZmExOGJkNjIzYmNk NmNhZDZhZTY3ZGU1ZDNjMzMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKQEAgLTAsMCArMSwyNCBAQAorPCFET0NUWVBFIEhU TUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxtZXRh IGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXV0 Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy10ZXN0LXJlc291 cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMtdGVzdC1yZXNv dXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJk ZWJ1ZygnbG9hZCcpIj4KK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Yg c2NyaXB0cyB3aXRoIHRoZSBkZWZlciBhdHRyaWJ1dGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNzEwIj5odHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA3MTA8L2E+LgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisKKzxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIo IkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2Fk ZWQnKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4w LjE6ODAwMC9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kiIGRlZmVyPSJERUZF UiI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVz b3VyY2VzL2RlZmVyLXNjcmlwdC5qcyIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQg c3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0 LmpzIj48L3NjcmlwdD4KKzxzY3JpcHQ+CitkZWJ1ZygiaW5saW5lIik7Cis8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9D aGFuZ2VMb2cKaW5kZXggNzY1NWY4YWM2MjhjYmYxZGZjNWM5MGNjZTFlYTc4MzEyMzViZTFiYS4u OTU2OGM0Mjk5YjRiNGU5MmFhNzlkODk1MDIyZTUyOWQ2MTYwMzZiNSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAor MjAxMC0wNy0yOSAgVG9ueSBHZW50aWxjb3JlICA8dG9ueWdAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN1cHBvcnQgPHNjcmlw dCBkZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgIFNlZTogaHR0cDovL2Rldi53 My5vcmcvaHRtbDUvc3BlYy9PdmVydmlldy5odG1sI3RoZS1lbmQKKworCVRlc3RzOiBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbAorICAgICAg ICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0 bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGlu ZS1zY3JpcHQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv ZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCisgICAgICAgICAgICAgICBo dHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCisg ICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5 bGVzaGVldC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKToKKyAgICAgICAgKFdlYkNv cmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0Fu ZEVuZCk6CisgICAgICAgICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAgICAgKiBo dG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1 bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KToKKyAgICAg ICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdCk6CisgICAgICAgICogaHRt bC9IVE1MU2NyaXB0UnVubmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVy OjpQZW5kaW5nU2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxT Y3JpcHRSdW5uZXI6OlBlbmRpbmdTY3JpcHQ6Om9wZXJhdG9yPSk6CisKIDIwMTAtMDctMjkgIE1h cnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJldmlld2Vk IGJ5IERpcmsgU2NodWx6ZS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQ YXJzZXIuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggNzIz ZmJlNzYyM2VjZWIzMmViYzNlYmNjNmUwMWExNmIzMTRjYzFjYS4uMWZjOTgwYzdhYzQ0ZDcwZWIx ZTAxY2Y4ODc1NDUyNDY3ZjQ5Y2ZmZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1 bWVudFBhcnNlci5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHAK QEAgLTI4MCw3ICsyODAsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5k KCkKICAgICAgICAgbV9lbmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAgICAgcmV0dXJuOwogICAg IH0KLSAgICBlbmQoKTsKKyAgICBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nQW5kRW5k KCk7CiB9CiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQoKQpAQCAtMjg5 LDYgKzI4OSwxOSBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKICAg ICAgICAgcmV0dXJuOwogCiAgICAgbV9lbmRXYXNEZWxheWVkID0gZmFsc2U7CisgICAgZXhlY3V0 ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgpOworfQorCit2b2lkIEhUTUxEb2N1bWVu dFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgpCit7CisgICAg aWYgKG1fc2NyaXB0UnVubmVyKSB7CisgICAgICAgIGJvb2wgY29udGludWVQYXJzaW5nID0gbV9z Y3JpcHRSdW5uZXItPmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKTsKKyAgICAgICAg aWYgKCFjb250aW51ZVBhcnNpbmcpIHsKKyAgICAgICAgICAgIG1fdHJlZUJ1aWxkZXItPnNldFBh dXNlZCh0cnVlKTsKKyAgICAgICAgICAgIG1fZW5kV2FzRGVsYXllZCA9IHRydWU7CisgICAgICAg ICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CiAgICAgZW5kKCk7CiB9CiAKZGlmZiAtLWdp dCBhL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaCBiL1dlYkNvcmUvaHRtbC9IVE1M RG9jdW1lbnRQYXJzZXIuaAppbmRleCBjYzQ2ZDMxM2YyNTJmMmY5YTVhM2FhYmJkMzI0ZmI3MTE3 NThkZjI5Li5kZjY0OTE1OTJmODRlOGNlZWE3ODQwMjc3OTY0NDNhYzFlMGJmNTIxIDEwMDY0NAot LS0gYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKKysrIGIvV2ViQ29yZS9odG1s L0hUTUxEb2N1bWVudFBhcnNlci5oCkBAIC0xMDUsNiArMTA1LDcgQEAgcHJpdmF0ZToKICAgICB2 b2lkIGJlZ2luKCk7CiAgICAgdm9pZCBhdHRlbXB0VG9FbmQoKTsKICAgICB2b2lkIGVuZElmRGVs YXllZCgpOworICAgIHZvaWQgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgp OwogICAgIHZvaWQgZW5kKCk7CiAKICAgICBib29sIGlzU2NoZWR1bGVkRm9yUmVzdW1lKCkgY29u c3Q7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAgYi9XZWJD b3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggZjRiNzAxMzNlMmE4ZDk3M2Y2M2E2 YjhiMjgwN2I4ZGQ5MGEzOGJjMi4uYTU5NzFmZTdjZGY3NmNkNDA1NmZlM2MyOGM3ODg0NjAzYzRk ZTQxMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCisrKyBi L1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcApAQCAtMjI4LDMzICsyMjgsNjMgQEAg Ym9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0 cygpCiAgICAgcmV0dXJuIGV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRzKCk7CiB9CiAKLXZv aWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChFbGVtZW50KiBzY3JpcHQpCitib29s IEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQogewot ICAgIEFTU0VSVCghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuZWxlbWVudCk7Ci0gICAgQXRvbWlj U3RyaW5nIHNyY1ZhbHVlID0gc2NyaXB0LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7Ci0gICAgLy8g QWxsb3cgdGhlIGhvc3QgdG8gZGlzbGxvdyBzY3JpcHQgbG9hZHMgKHVzaW5nIHRoZSBYU1NBdWRp dG9yLCBldGMuKQorICAgIHdoaWxlICghbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlz RW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIWhhdmVQYXJzaW5nQmxvY2tpbmdTY3JpcHQoKSk7 CisgICAgICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0 ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAgICBBU1NFUlQobV9wYXJzaW5nQmxvY2tpbmdT Y3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fcGFyc2luZ0Jsb2NraW5nU2Ny aXB0LmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxv YWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgICAgICB9CisgICAgICAgIGlmICghZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKSkK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICByZXR1cm4gbV9zY3JpcHRz VG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKTsKK30KKworYm9vbCBIVE1MU2NyaXB0UnVu bmVyOjpyZXF1ZXN0U2NyaXB0KFBlbmRpbmdTY3JpcHQmIHBlbmRpbmdTY3JpcHQsIEVsZW1lbnQq IHNjcmlwdEVsZW1lbnQpCit7CisgICAgQVNTRVJUKCFwZW5kaW5nU2NyaXB0LmVsZW1lbnQpOwor ICAgIEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNjcmlwdEVsZW1lbnQtPmdldEF0dHJpYnV0ZShz cmNBdHRyKTsKICAgICBpZiAoIW1faG9zdC0+c2hvdWxkTG9hZEV4dGVybmFsU2NyaXB0RnJvbVNy YyhzcmNWYWx1ZSkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAg IC8vIEZJWE1FOiBXZSBuZWVkIHRvIHJlc29sdmUgdGhlIHVybCByZWxhdGl2ZSB0byB0aGUgZWxl bWVudC4KLSAgICBpZiAoIXNjcmlwdC0+ZGlzcGF0Y2hCZWZvcmVMb2FkRXZlbnQoc3JjVmFsdWUp KQotICAgICAgICByZXR1cm47Ci0gICAgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuZWxlbWVudCA9 IHNjcmlwdDsKKyAgICBpZiAoIXNjcmlwdEVsZW1lbnQtPmRpc3BhdGNoQmVmb3JlTG9hZEV2ZW50 KHNyY1ZhbHVlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHBlbmRpbmdTY3JpcHQuZWxl bWVudCA9IHNjcmlwdEVsZW1lbnQ7CiAgICAgLy8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVy biAwIGZvciBlbXB0eSBvciBpbnZhbGlkIHNyY1ZhbHVlcy4KLSAgICBDYWNoZWRTY3JpcHQqIGNh Y2hlZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0U2NyaXB0KHNyY1Zh bHVlLCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBDYWNo ZWRTY3JpcHQqIGNhY2hlZFNjcmlwdCA9IG1fZG9jdW1lbnQtPmRvY0xvYWRlcigpLT5yZXF1ZXN0 U2NyaXB0KHNyY1ZhbHVlLCB0b1NjcmlwdEVsZW1lbnQoc2NyaXB0RWxlbWVudCktPnNjcmlwdENo YXJzZXQoKSk7CiAgICAgaWYgKCFjYWNoZWRTY3JpcHQpIHsKICAgICAgICAgbm90SW1wbGVtZW50 ZWQoKTsgLy8gRGlzcGF0Y2ggZXJyb3IgZXZlbnQuCi0gICAgICAgIHJldHVybjsKKyAgICAgICAg cmV0dXJuIGZhbHNlOwogICAgIH0KIAotICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LnNldENh Y2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworICAgIHBlbmRpbmdTY3JpcHQuc2V0Q2FjaGVkU2Ny aXB0KGNhY2hlZFNjcmlwdCk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgSFRNTFNjcmlw dFJ1bm5lcjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiBzY3JpcHRFbGVt ZW50KQoreworICAgIGJvb2wgbWFkZVJlcXVlc3QgPSByZXF1ZXN0U2NyaXB0KG1fcGFyc2luZ0Js b2NraW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KTsKIAogICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91 dCBhIGxvYWQgY2FsbGJhY2sgaWYgY2FjaGVkU2NyaXB0IGlzIG5vdCBhbHJlYWR5CiAgICAgLy8g aW4gdGhlIGNhY2hlLiAgQ2FsbGVycyB3aWxsIGF0dGVtcHQgdG8gcnVuIHRoZSBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdAogICAgIC8vIGlmIHBvc3NpYmxlIGJlZm9yZSByZXR1cm5pbmcgY29udHJv bCB0byB0aGUgcGFyc2VyLgotICAgIGlmICghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVk U2NyaXB0KCktPmlzTG9hZGVkKCkpCisgICAgaWYgKG1hZGVSZXF1ZXN0ICYmICFtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkKICAgICAgICAgd2F0Y2hG b3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVu bmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAg ICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgYm9vbCBtYWRlUmVxdWVzdCA9IHJl cXVlc3RTY3JpcHQocGVuZGluZ1NjcmlwdCwgc2NyaXB0RWxlbWVudCk7CisgICAgaWYgKG1hZGVS ZXF1ZXN0KQorICAgICAgICBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcuYXBwZW5kKHBl bmRpbmdTY3JpcHQpOworfQorCiAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCB0byBtYXRjaCB0aGUg SFRNTDUgZGVmaW5pdGlvbiBvZiAicnVubmluZyBhIHNjcmlwdCIKIC8vIGh0dHA6Ly93d3cud2hh dHdnLm9yZy9zcGVjcy93ZWItYXBwcy9jdXJyZW50LXdvcmsvbXVsdGlwYWdlL3NjcmlwdGluZy0x Lmh0bWwjcnVubmluZy1hLXNjcmlwdAogdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpydW5TY3JpcHQo RWxlbWVudCogc2NyaXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKQpAQCAtMjY3LDggKzI5Nywx MSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBzY3JpcHQsIGlu dCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIGV2ZW50 IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKHNyY0F0dHIp KSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBhc3luYwotICAgICAg ICAgICAgcmVxdWVzdFNjcmlwdChzY3JpcHQpOworICAgICAgICAgICAgLy8gRklYTUU6IEhhbmRs ZSBhc3luYworICAgICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKGRlZmVyQXR0cikp CisgICAgICAgICAgICAgICAgcmVxdWVzdERlZmVycmVkU2NyaXB0KHNjcmlwdCk7CisgICAgICAg ICAgICBlbHNlCisgICAgICAgICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChz Y3JpcHQpOwogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgLy8gRklYTUU6IFdlIGRvIG5v dCBibG9jayBpbmxpbmUgPHNjcmlwdD4gdGFncyBvbiBzdHlsZXNoZWV0cyB0byBtYXRjaCB0aGUK ICAgICAgICAgICAgIC8vIG9sZCBwYXJzZXIgZm9yIG5vdy4gIFNlZSBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDAwNDcKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9I VE1MU2NyaXB0UnVubmVyLmggYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5oCmluZGV4 IGNjNjk0NDM1MTQ0MTdiZTMzM2NmNGRhNzhjMDkyNDRjMjIzMzliZmIuLmJiYWM3Y2Y3OGFmYjhm ZmE1ZDE1MGZlZTU4ZmFkYzgxMTk0MTAxMjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1M U2NyaXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaApAQCAt MjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VDbGllbnQuaCIKICNpbmNs dWRlICJDYWNoZWRSZXNvdXJjZUhhbmRsZS5oIgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgogI2lu Y2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAK QEAgLTUyLDYgKzUzLDcgQEAgcHVibGljOgogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5n Rm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAgIGJvb2wgaGFzU2NyaXB0c1dhaXRpbmdGb3JT dHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNo ZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKTsK KyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKTsKIAogICAgIGJvb2wg aXNFeGVjdXRpbmdTY3JpcHQoKSB7IHJldHVybiAhIW1fc2NyaXB0TmVzdGluZ0xldmVsOyB9CiAK QEAgLTYzLDcgKzY1LDcgQEAgcHJpdmF0ZToKICAgICAvLyBsaWZldGltZSBpbiBvcmRlciB0byBn dWFyYW50ZWUgdGhhdCB0aGUgZGF0YSBidWZmZXIgd2lsbCBub3QgYmUgcHVyZ2VkLgogICAgIC8v CiAgICAgLy8gRklYTUU6IEZpbmlzaCB0dXJuaW5nIHRoaXMgaW50byBhIHByb3BlciBjbGFzcy4K LSAgICBjbGFzcyBQZW5kaW5nU2NyaXB0IDogcHVibGljIENhY2hlZFJlc291cmNlQ2xpZW50LCBO b25jb3B5YWJsZSB7CisgICAgY2xhc3MgUGVuZGluZ1NjcmlwdCA6IHB1YmxpYyBDYWNoZWRSZXNv dXJjZUNsaWVudCB7CiAgICAgcHVibGljOgogICAgICAgICBQZW5kaW5nU2NyaXB0KCkKICAgICAg ICAgICAgIDogc3RhcnRpbmdMaW5lTnVtYmVyKDApCkBAIC03MSw2ICs3MywyOCBAQCBwcml2YXRl OgogICAgICAgICB7CiAgICAgICAgIH0KIAorICAgICAgICBQZW5kaW5nU2NyaXB0KGNvbnN0IFBl bmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICAgICAgOiBDYWNoZWRSZXNvdXJjZUNsaWVudChv dGhlcikKKyAgICAgICAgICAgICwgZWxlbWVudChvdGhlci5lbGVtZW50KQorICAgICAgICAgICAg LCBzdGFydGluZ0xpbmVOdW1iZXIob3RoZXIuc3RhcnRpbmdMaW5lTnVtYmVyKQorICAgICAgICAg ICAgLCBtX3dhdGNoaW5nRm9yTG9hZChvdGhlci5tX3dhdGNoaW5nRm9yTG9hZCkKKyAgICAgICAg eworICAgICAgICAgICAgc2V0Q2FjaGVkU2NyaXB0KG90aGVyLmNhY2hlZFNjcmlwdCgpKTsKKyAg ICAgICAgfQorCisgICAgICAgIFBlbmRpbmdTY3JpcHQmIG9wZXJhdG9yPShjb25zdCBQZW5kaW5n U2NyaXB0JiBvdGhlcikKKyAgICAgICAgeworICAgICAgICAgICAgaWYgKHRoaXMgPT0gJm90aGVy KQorICAgICAgICAgICAgICAgIHJldHVybiAqdGhpczsKKworICAgICAgICAgICAgZWxlbWVudCA9 IG90aGVyLmVsZW1lbnQ7CisgICAgICAgICAgICBzdGFydGluZ0xpbmVOdW1iZXIgPSBvdGhlci5z dGFydGluZ0xpbmVOdW1iZXI7CisgICAgICAgICAgICBtX3dhdGNoaW5nRm9yTG9hZCA9IG90aGVy Lm1fd2F0Y2hpbmdGb3JMb2FkOworICAgICAgICAgICAgc2V0Q2FjaGVkU2NyaXB0KG90aGVyLmNh Y2hlZFNjcmlwdCgpKTsKKworICAgICAgICAgICAgcmV0dXJuICp0aGlzOworICAgICAgICB9CisK ICAgICAgICAgflBlbmRpbmdTY3JpcHQoKTsKIAogICAgICAgICBQYXNzUmVmUHRyPEVsZW1lbnQ+ IHJlbGVhc2VFbGVtZW50QW5kQ2xlYXIoKTsKQEAgLTEwMSw3ICsxMjUsOSBAQCBwcml2YXRlOgog ICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKICAgICB2b2lkIGV4ZWN1 dGVQZW5kaW5nU2NyaXB0KCk7CiAKLSAgICB2b2lkIHJlcXVlc3RTY3JpcHQoRWxlbWVudCopOwor ICAgIGJvb2wgcmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0JiwgRWxlbWVudCopOworICAgIHZv aWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAgdm9pZCByZXF1 ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIHZvaWQgcnVuU2NyaXB0KEVsZW1lbnQq LCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKIAogICAgIC8vIEhlbHBlcnMgZm9yIGRlYWxpbmcg d2l0aCBIVE1MU2NyaXB0UnVubmVySG9zdApAQCAtMTE1LDYgKzE0MSw3IEBAIHByaXZhdGU6CiAg ICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CiAgICAgSFRNTFNjcmlwdFJ1bm5lckhvc3QqIG1faG9z dDsKICAgICBQZW5kaW5nU2NyaXB0IG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0OworICAgIERlcXVl PFBlbmRpbmdTY3JpcHQ+IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZzsKICAgICB1bnNp Z25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8vIFdlIG9ubHkgd2FudCBzdHlsZXNo ZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlvbiBpZiBzY3JpcHQK 63029 2010-07-29 21:31:30 -0700 2010-07-30 10:36:06 -0700 Fix tab in ChangeLog bug-40934-20100729213129.patch text/plain 28384 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA5ZTYwNTY1NWU5NDRlMzNhNTE5ZDQ3MmU2MmM0ODU2ODE1ZTEzNzE0Li42YjRhNjM4 YmRjMGJhNDBkZTg5NDM3ZGFmNzQ2NjllMjY0MzljYjUzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAK KzIwMTAtMDctMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMYXlvdXRUZXN0cyBm b3IgPHNjcmlwdCBkZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgICogZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLWRlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5IG9yZGVyaW5nIGFu ZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGRlZmVyZWQgc2NyaXB0cy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUt ZXhwZWN0ZWQudHh0OiBDb3BpZWQgZnJvbSBMYXlvdXRUZXN0cy9mYXN0L3Rva2VuaXplci93cml0 ZS1iZWZvcmUtbG9hZC1leHBlY3RlZC50eHQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5 IG9yZGVyaW5nIGFuZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGlubGlu ZSBzY3JpcHRzLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlu bGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0 IHRoZSBkZWZlciBhdHRyaWJ1dGUgaXMgaWdub3JlZCBvbiBpbmxpbmUgc2NyaXB0IGJsb2Nrcy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgb25iZWZvcmVsb2Fk IGZpcmVzIGltbWVkaWF0ZWx5IHdoZW4gYSBkZWZlcnJlZCBzY3JpcHQgaXMgZW5jb3VudGVkLiBB bHNvIHRlc3RzIHRoYXQgaXQgY2FuIGJlIGNhbmNlbGxlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgaW52YWxpZCBVUkxzIGFyZSBpZ25v cmVkIGFuZCBzdWJzZXF1ZW50IHNjcmlwdHMgYXJlIHN0aWxsIGV4ZWN1dGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpz OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMv c2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanM6IEFkZGVk LgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ct c3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVzdHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhh dmlvci4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1z bG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVz dHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhhdmlvciB3aXRoIGEgc2xvdyBzdHlsZXNoZWV0Lgor ICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuIFRlc3Rz IGJhc2ljIGZ1bmN0aW9uYWxpdHkgYW5kIG9yZGVyaW5nLgorCiAyMDEwLTA3LTI4ICBEdW1pdHJ1 IERhbmlsaXVjICA8ZHVtaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2 aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5kNzJjNDYxMGM0YmJjYTU1MTU5OWZiMTZmY2UwMjgxMzZhMTcw ZjcxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBA CisxIDIgMyA0NSA2NwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi42YzU3MjVjMjNiZjljZjg2YjQ3MGM4MzdhZWNlOGJkNWYwNTFhOTQ2Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXIt ZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorMQorPHNjcmlwdD4KK2lm ICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBkb3VibGVXcml0ZShudW1iZXIpCit7CisgICAgZG9j dW1lbnQud3JpdGUoIjxzY3JpcHQgc3JjPSdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53 cml0ZSgiICsgbnVtYmVyICsgIiknIGRlZmVyPjwvc2NyIiArCisgICAgICAgICAgICAgICAgICAg ImlwdD4gPHNjcmlwdCBzcmM9J2RhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCIg KyAobnVtYmVyICsgMSkgKyAiKScgZGVmZXI+PC9zY3IiICsgImlwdD4gIikKK30KKzwvc2NyaXB0 PgorMgorPHNjcmlwdAorICAgIG9uYmVmb3JlbG9hZD0iZG91YmxlV3JpdGUoNCkiCisgICAgc3Jj PSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb3VibGVXcml0ZSg2KSIKKyAgICBkZWZlcj4KKzwvc2Ny aXB0PgorMwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQKbmV3IGZp bGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uYjQ0NTdhYWU2NmY2YjFlNDYxMjJkNzI0ZWExMmU5ZmFlOTU2ZDM5MgotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRv dWJsZS13cml0ZS1leHBlY3RlZC50eHQKQEAgLTAsMCArMSBAQAorMSAyIDMgNCA1IDYgNwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jODU4OTkzN2U2Mzg1MGVmMTM2NTli NDUwYTNlNGRiMmJmNDI1ODZkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSwx OCBAQAorMQorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCitmdW5jdGlvbiBkb3VibGVXcml0 ZShudW1iZXIpCit7CisgICAgZG9jdW1lbnQud3JpdGUoIjxzY3JpcHQ+ZG9jdW1lbnQud3JpdGUo IiArIG51bWJlciArICIpPC9zY3IiICsKKyAgICAgICAgICAgICAgICAgICAiaXB0PiA8c2NyaXB0 PmRvY3VtZW50LndyaXRlKCIgKyAobnVtYmVyICsgMSkgKyAiKTwvc2NyIiArICJpcHQ+ICIpCit9 Cis8L3NjcmlwdD4KKzIKKzxzY3JpcHQKKyAgICBvbmJlZm9yZWxvYWQ9ImRvdWJsZVdyaXRlKDMp IgorICAgIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG91YmxlV3JpdGUoNikiCisgICAgZGVm ZXI+Cis8L3NjcmlwdD4KKzUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMzg2YTJkYWM5Mzc1NDE1MjA0MmM2MGE4OWJhOGZjZTFjMGVlMGQ2 MQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAorQ2hl Y2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KK2lubGluZSBkZWZlcgor ZGVmZXIKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU1Y2NlMjJk OGEyYWIyMWFmOTVjYzNiOGU0YjZhZDQ5OWYwMjM4ZTQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0 bWwKQEAgLTAsMCArMSwxNSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQg SFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0i Li4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+ CitDaGVja3MgdGhhdCBpbmxpbmUgc2NyaXB0cyBhcmUgbm90IGRlZmVycmVkLgorPGRpdiBpZD0i Y29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBkZWZlcj48 L3NjcmlwdD4KKzxzY3JpcHQgZGVmZXI+CisgIGRlYnVnKCdpbmxpbmUgZGVmZXInKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uODUxYmYwYzkyNjgwMDRjMjcyNjljYzNmYjRlNjZkNmQ5OGU2 YWEzNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9y ZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitkZWZlcgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjZlMGYwNzliMzIxNTU4MjdiZDc2YTNiZWYyZGE0ZTM2NGM1NmRmYTkK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApAQCAtMCwwICsxLDE0IEBACis8IURPQ1RZUEUgSFRN TCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsg cmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5j c3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgZmly ZSBvbmJlZm9yZWxvYWQgaW1tZWRpYXRlbHkgYW5kIHRoYXQgaXQgaXMgY2FuY2VsbGFibGUuCis8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvc2hvdWxkbm90 ZXhlY3V0ZS5qcyIgb25iZWZvcmVsb2FkPSJyZXR1cm4gZmFsc2U7IiBkZWZlcj48L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZGVmZXIuanMiIG9uYmVmb3JlbG9hZD0iZGVidWcoJ29u YmVmb3JlbG9hZCBkZWZlcicpO3JldHVybiB0cnVlOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0 IHNyYz0icmVzb3VyY2VzL2V4dGVybmFsLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdvbmJlZm9y ZWxvYWQgZXh0ZXJuYWwnKTtyZXR1cm4gdHJ1ZTsiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uODMwY2M2NzMzOGRhNDlhZDgwYmVmMWM5ZjVmYWU4ZjIzM2ZlODVmOAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2Rl ZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBACitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFu ZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgYXJlIGV4ZWN1dGVkLgorZGVmZXIKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2Ny aXB0LWludmFsaWQtdXJsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jOGVlZWRlNmY2 NWJhMjUwMzhmNmQ5YzNiZGY2MTkxNjE4ZTY5ZDg0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJs Lmh0bWwKQEAgLTAsMCArMSwxMyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9E VEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJl Zj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+CitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBp Z25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgYXJlIGV4ZWN1dGVkLgorPGRp diBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNyYz0iaHR0cDovL2ludmFsaWQ6OTk5OTk5 LyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBkZWZl cj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2Rl ZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzIGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFs LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0NzdlZjgK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImV4dGVybmFsIik7 CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNv dXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjNiYjZi NGRhNGQyMWM5NzhjOTlmMzg4MDEzMDVmYjYwMWFjYmNhYTQKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90 ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1Zygic2hvdWxkIG5vdCBleGVjdXRlIik7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNj cmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2Ny aXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0 Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2Ny aXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1z Y3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVhNDQ3 N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNv dXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIp OwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3Jp cHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNj L3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjFj YWFkN2VlZWEwYzQ0ZDYzMjhkMTFhNTVlMWNhZDYxODRiYzY5YmIKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5 LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoJ0JvZHkgYmFja2dyb3VuZDogJyAr IGdldENvbXB1dGVkU3R5bGUoZG9jdW1lbnQuYm9keSlbJ2JhY2tncm91bmQtY29sb3InXSk7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC13 cml0ZS1zbG93LXN0eWxlc2hlZXQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWQxMWVi NTJjNmVmN2ZlZWYxNTFkMmQ0Nzk5ZTNkYzJhZWIyNzZmMwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5 bGVzaGVldC5qcwpAQCAtMCwwICsxIEBACitkb2N1bWVudC53cml0ZSgnPGxpbmsgcmVsPSJzdHls ZXNoZWV0IiBocmVmPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1z dHlsZXNoZWV0LmNnaSI+Jyk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE5OGQz ZDVhODFkMzc4ODc2OTJjNzM5MjJjOGQzYzI5ZjFiNmJkMTgKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNn aQpAQCAtMCwwICsxLDUgQEAKKyMhL3Vzci9iaW4vcGVybCAtdworCitwcmludCAiQ29udGVudC10 eXBlOiB0ZXh0L2phdmFzY3JpcHRcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiZGVidWcoJ3Ns b3dEZWZlcicpO1xuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yMGQyNjdlNDJmNTQ2 Zjk3ODI4MGUzOWEyMzNmM2RlZTA0OTFlZTM3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCkBAIC0wLDAg KzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQv Y3NzXG5cbiI7CitzbGVlcCgwLjUpOworcHJpbnQgImJvZHkgeyBiYWNrZ3JvdW5kLWNvbG9yOiBy ZWQgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVk LnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5hZjkyYmQyOGQ4N2YyOTQyMTQ0ZTdlMWM4Y2ZkYTU0MzBlYzVmMjIx Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBAQAor VGhpcyB0ZXN0cyB0aGF0IGFuIGlubGluZSBzbG93IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3Jl IGRlZmVycmVkIHNjcmlwdHMuCitCb2R5IGJhY2tncm91bmQ6IHJnYigyNTUsIDAsIDApCitET01D b250ZW50TG9hZGVkCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9odHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjczYjM4OGY5OGUwYTI3N2IyM2Q1MDM3NzVmOGQ2ODlkNWYyZGE5NjQKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVy LXNsb3ctc3R5bGVzaGVldC5odG1sCkBAIC0wLDAgKzEsMjEgQEAKKzwhRE9DVFlQRSBIVE1MIFBV QkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRw LWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIg Lz4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMv anMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2Vz L2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorVGhpcyB0ZXN0cyB0 aGF0IGFuIGlubGluZSBzbG93IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNj cmlwdHMuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2ph dmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIs IGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOwor PC9zY3JpcHQ+CisKKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNv dXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcyIgZGVmZXI9ImRlZmVyIj48L3Nj cmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cDovLzEyNy4wLjAuMTo4MDAw L21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kiPgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi5iZmNhYTZlOTI0NTQ2YmNiOTRmNDhmZTFmM2Y2MzczNGFlNTE1 MjY1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4IEBACitUaGlzIHRlc3RzIGZvciBwcm9w ZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMC4KK2V4dGVybmFsCitp bmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNvbnRlbnRMb2FkZWQKK2xvYWQKKwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93 LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjJlMGNkOTQxMmNkMTAwOWE0MTQ1MmNmZThmNjVlZDg5YWZlMTNhZjcKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ct c3R5bGVzaGVldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw0IEBACitUaGlzIHRlc3RzIGEgZGVm ZXJyZWQgc2NyaXB0IHdoaWNoIHdyaXRlcyBhIHNsb3cgc3R5bGVzaGVldC4KK0JvZHkgYmFja2dy b3VuZDogcmdiKDI1NSwgMCwgMCkKK0RPTUNvbnRlbnRMb2FkZWQKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hl ZXQuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUt c2xvdy1zdHlsZXNoZWV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDBlNzk4NzEzOTU2OWQ3Nzk1NTM1NzAx ZWEzYWIzYzU4OTk1ZjI4MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUtc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAsMCAr MSwyMSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgor PGh0bWw+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0i dGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVm PSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNy Yz0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9o ZWFkPgorPGJvZHk+CitUaGlzIHRlc3RzIGEgZGVmZXJyZWQgc2NyaXB0IHdoaWNoIHdyaXRlcyBh IHNsb3cgc3R5bGVzaGVldC4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250 ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7Cit9 LCBmYWxzZSk7Cis8L3NjcmlwdD4KKworPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAw MC9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzIiBkZWZlcj0i ZGVmZXIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNj L3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIiBkZWZlcj0iZGVmZXIi Pjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjk1Y2Y4YjM1MDc1ZmExOGJkNjIzYmNk NmNhZDZhZTY3ZGU1ZDNjMzMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKQEAgLTAsMCArMSwyNCBAQAorPCFET0NUWVBFIEhU TUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxtZXRh IGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXV0 Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy10ZXN0LXJlc291 cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMtdGVzdC1yZXNv dXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJk ZWJ1ZygnbG9hZCcpIj4KK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Yg c2NyaXB0cyB3aXRoIHRoZSBkZWZlciBhdHRyaWJ1dGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNzEwIj5odHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA3MTA8L2E+LgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisKKzxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIo IkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2Fk ZWQnKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4w LjE6ODAwMC9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kiIGRlZmVyPSJERUZF UiI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVz b3VyY2VzL2RlZmVyLXNjcmlwdC5qcyIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQg c3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0 LmpzIj48L3NjcmlwdD4KKzxzY3JpcHQ+CitkZWJ1ZygiaW5saW5lIik7Cis8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9D aGFuZ2VMb2cKaW5kZXggNzY1NWY4YWM2MjhjYmYxZGZjNWM5MGNjZTFlYTc4MzEyMzViZTFiYS4u YWVmOGJhZTY0NzAxZjc5MmQxZTNmMDgyYTRkNmNhNzhmODQ2OGY5YyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBAQAor MjAxMC0wNy0yOSAgVG9ueSBHZW50aWxjb3JlICA8dG9ueWdAY2hyb21pdW0ub3JnPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN1cHBvcnQgPHNjcmlw dCBkZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgIFNlZTogaHR0cDovL2Rldi53 My5vcmcvaHRtbDUvc3BlYy9PdmVydmlldy5odG1sI3RoZS1lbmQKKworICAgICAgICBUZXN0czog ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwK KyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13 cml0ZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1pbmxpbmUtc2NyaXB0Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbAorICAgICAgICAg ICAgICAgaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQu aHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1z bG93LXN0eWxlc2hlZXQuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy9taXNjL3Njcmlw dC1kZWZlci5odG1sCisKKyAgICAgICAgKiBodG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OmF0dGVtcHRUb0VuZCk6CisgICAg ICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCk6CisgICAgICAg IChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmdBbmRFbmQpOgorICAgICAgICAqIGh0bWwvSFRNTERvY3VtZW50UGFyc2VyLmg6CisgICAg ICAgICogaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxT Y3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdCk6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6 CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpydW5TY3JpcHQpOgorICAgICAg ICAqIGh0bWwvSFRNTFNjcmlwdFJ1bm5lci5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlw dFJ1bm5lcjo6UGVuZGluZ1NjcmlwdDo6UGVuZGluZ1NjcmlwdCk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MU2NyaXB0UnVubmVyOjpQZW5kaW5nU2NyaXB0OjpvcGVyYXRvcj0pOgorCiAyMDEwLTA3 LTI5ICBNYXJ0aW4gUm9iaW5zb24gIDxtcm9iaW5zb25AaWdhbGlhLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEaXJrIFNjaHVsemUuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERv Y3VtZW50UGFyc2VyLmNwcCBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCmlu ZGV4IDcyM2ZiZTc2MjNlY2ViMzJlYmMzZWJjYzZlMDFhMTZiMzE0Y2MxY2EuLjFmYzk4MGM3YWM0 NGQ3MGViMWUwMWNmODg3NTQ1MjQ2N2Y0OWNmZmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9I VE1MRG9jdW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJz ZXIuY3BwCkBAIC0yODAsNyArMjgwLDcgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmF0dGVt cHRUb0VuZCgpCiAgICAgICAgIG1fZW5kV2FzRGVsYXllZCA9IHRydWU7CiAgICAgICAgIHJldHVy bjsKICAgICB9Ci0gICAgZW5kKCk7CisgICAgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2lu Z0FuZEVuZCgpOwogfQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkK QEAgLTI4OSw2ICsyODksMTkgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXll ZCgpCiAgICAgICAgIHJldHVybjsKIAogICAgIG1fZW5kV2FzRGVsYXllZCA9IGZhbHNlOworICAg IGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKTsKK30KKwordm9pZCBIVE1M RG9jdW1lbnRQYXJzZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdBbmRFbmQoKQor eworICAgIGlmIChtX3NjcmlwdFJ1bm5lcikgeworICAgICAgICBib29sIGNvbnRpbnVlUGFyc2lu ZyA9IG1fc2NyaXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCk7Cisg ICAgICAgIGlmICghY29udGludWVQYXJzaW5nKSB7CisgICAgICAgICAgICBtX3RyZWVCdWlsZGVy LT5zZXRQYXVzZWQodHJ1ZSk7CisgICAgICAgICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOwor ICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQogICAgIGVuZCgpOwogfQogCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3JlL2h0 bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5kZXggY2M0NmQzMTNmMjUyZjJmOWE1YTNhYWJiZDMy NGZiNzExNzU4ZGYyOS4uZGY2NDkxNTkyZjg0ZThjZWVhNzg0MDI3Nzk2NDQzYWMxZTBiZjUyMSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dlYkNv cmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTA1LDYgKzEwNSw3IEBAIHByaXZhdGU6 CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRvRW5kKCk7CiAgICAgdm9pZCBl bmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmdB bmRFbmQoKTsKICAgICB2b2lkIGVuZCgpOwogCiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJlc3Vt ZSgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3Bw IGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmluZGV4IGY0YjcwMTMzZTJhOGQ5 NzNmNjNhNmI4YjI4MDdiOGRkOTBhMzhiYzIuLmE1OTcxZmU3Y2RmNzZjZDQwNTZmZTNjMjhjNzg4 NDYwM2M0ZGU0MTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNw cAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKQEAgLTIyOCwzMyArMjI4 LDYzIEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5 bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwog fQogCi12b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RTY3JpcHQoRWxlbWVudCogc2NyaXB0 KQorYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5n KCkKIHsKLSAgICBBU1NFUlQoIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQpOwotICAg IEF0b21pY1N0cmluZyBzcmNWYWx1ZSA9IHNjcmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOwot ICAgIC8vIEFsbG93IHRoZSBob3N0IHRvIGRpc2xsb3cgc2NyaXB0IGxvYWRzICh1c2luZyB0aGUg WFNTQXVkaXRvciwgZXRjLikKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFy c2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2Ny aXB0KCkpOworICAgICAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCA9IG1fc2NyaXB0c1RvRXhl Y3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAgICAgQVNTRVJUKG1fcGFyc2luZ0Js b2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpKTsKKyAgICAgICAgaWYgKCFtX3BhcnNpbmdCbG9j a2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKS0+aXNMb2FkZWQoKSkgeworICAgICAgICAgICAgd2F0 Y2hGb3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKKyAgICAgICAgICAgIHJldHVybiBm YWxzZTsKKyAgICAgICAgfQorICAgICAgICBpZiAoIWV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3Jp cHRzKCkpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgcmV0dXJuIG1f c2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCk7Cit9CisKK2Jvb2wgSFRNTFNj cmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChQZW5kaW5nU2NyaXB0JiBwZW5kaW5nU2NyaXB0LCBF bGVtZW50KiBzY3JpcHRFbGVtZW50KQoreworICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVt ZW50KTsKKyAgICBBdG9taWNTdHJpbmcgc3JjVmFsdWUgPSBzY3JpcHRFbGVtZW50LT5nZXRBdHRy aWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3QtPnNob3VsZExvYWRFeHRlcm5hbFNjcmlw dEZyb21TcmMoc3JjVmFsdWUpKQotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxz ZTsKICAgICAvLyBGSVhNRTogV2UgbmVlZCB0byByZXNvbHZlIHRoZSB1cmwgcmVsYXRpdmUgdG8g dGhlIGVsZW1lbnQuCi0gICAgaWYgKCFzY3JpcHQtPmRpc3BhdGNoQmVmb3JlTG9hZEV2ZW50KHNy Y1ZhbHVlKSkKLSAgICAgICAgcmV0dXJuOwotICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LmVs ZW1lbnQgPSBzY3JpcHQ7CisgICAgaWYgKCFzY3JpcHRFbGVtZW50LT5kaXNwYXRjaEJlZm9yZUxv YWRFdmVudChzcmNWYWx1ZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBwZW5kaW5nU2Ny aXB0LmVsZW1lbnQgPSBzY3JpcHRFbGVtZW50OwogICAgIC8vIFRoaXMgc2hvdWxkIGNvcnJlY3Rs eSByZXR1cm4gMCBmb3IgZW1wdHkgb3IgaW52YWxpZCBzcmNWYWx1ZXMuCi0gICAgQ2FjaGVkU2Ny aXB0KiBjYWNoZWRTY3JpcHQgPSBtX2RvY3VtZW50LT5kb2NMb2FkZXIoKS0+cmVxdWVzdFNjcmlw dChzcmNWYWx1ZSwgdG9TY3JpcHRFbGVtZW50KHNjcmlwdCktPnNjcmlwdENoYXJzZXQoKSk7Cisg ICAgQ2FjaGVkU2NyaXB0KiBjYWNoZWRTY3JpcHQgPSBtX2RvY3VtZW50LT5kb2NMb2FkZXIoKS0+ cmVxdWVzdFNjcmlwdChzcmNWYWx1ZSwgdG9TY3JpcHRFbGVtZW50KHNjcmlwdEVsZW1lbnQpLT5z Y3JpcHRDaGFyc2V0KCkpOwogICAgIGlmICghY2FjaGVkU2NyaXB0KSB7CiAgICAgICAgIG5vdElt cGxlbWVudGVkKCk7IC8vIERpc3BhdGNoIGVycm9yIGV2ZW50LgotICAgICAgICByZXR1cm47Cisg ICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5zZXRDYWNoZWRTY3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5nU2NyaXB0LnNldENh Y2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIEhU TUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogc2Ny aXB0RWxlbWVudCkKK3sKKyAgICBib29sIG1hZGVSZXF1ZXN0ID0gcmVxdWVzdFNjcmlwdChtX3Bh cnNpbmdCbG9ja2luZ1NjcmlwdCwgc2NyaXB0RWxlbWVudCk7CiAKICAgICAvLyBXZSBvbmx5IGNh cmUgYWJvdXQgYSBsb2FkIGNhbGxiYWNrIGlmIGNhY2hlZFNjcmlwdCBpcyBub3QgYWxyZWFkeQog ICAgIC8vIGluIHRoZSBjYWNoZS4gIENhbGxlcnMgd2lsbCBhdHRlbXB0IHRvIHJ1biB0aGUgbV9w YXJzaW5nQmxvY2tpbmdTY3JpcHQKICAgICAvLyBpZiBwb3NzaWJsZSBiZWZvcmUgcmV0dXJuaW5n IGNvbnRyb2wgdG8gdGhlIHBhcnNlci4KLSAgICBpZiAoIW1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0 LmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKQorICAgIGlmIChtYWRlUmVxdWVzdCAmJiAhbV9w YXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVkKCkpCiAgICAgICAg IHdhdGNoRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CiAKK3ZvaWQgSFRNTFNj cmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQqIHNjcmlwdEVsZW1lbnQp Cit7CisgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0OworICAgIGJvb2wgbWFkZVJlcXVl c3QgPSByZXF1ZXN0U2NyaXB0KHBlbmRpbmdTY3JpcHQsIHNjcmlwdEVsZW1lbnQpOworICAgIGlm IChtYWRlUmVxdWVzdCkKKyAgICAgICAgbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmFw cGVuZChwZW5kaW5nU2NyaXB0KTsKK30KKwogLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgdG8gbWF0 Y2ggdGhlIEhUTUw1IGRlZmluaXRpb24gb2YgInJ1bm5pbmcgYSBzY3JpcHQiCiAvLyBodHRwOi8v d3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrL211bHRpcGFnZS9zY3Jp cHRpbmctMS5odG1sI3J1bm5pbmctYS1zY3JpcHQKIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cnVu U2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0aW5nTGluZU51bWJlcikKQEAgLTI2Nyw4 ICsyOTcsMTEgQEAgdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpydW5TY3JpcHQoRWxlbWVudCogc2Ny aXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKQogICAgICAgICBub3RJbXBsZW1lbnRlZCgpOyAv LyBldmVudCBmb3Igc3VwcG9ydAogCiAgICAgICAgIGlmIChzY3JpcHQtPmhhc0F0dHJpYnV0ZShz cmNBdHRyKSkgewotICAgICAgICAgICAgLy8gRklYTUU6IEhhbmRsZSBkZWZlciBhbmQgYXN5bmMK LSAgICAgICAgICAgIHJlcXVlc3RTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIC8vIEZJWE1F OiBIYW5kbGUgYXN5bmMKKyAgICAgICAgICAgIGlmIChzY3JpcHQtPmhhc0F0dHJpYnV0ZShkZWZl ckF0dHIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3REZWZlcnJlZFNjcmlwdChzY3JpcHQpOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdT Y3JpcHQoc2NyaXB0KTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIC8vIEZJWE1FOiBX ZSBkbyBub3QgYmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVzaGVldHMgdG8gbWF0 Y2ggdGhlCiAgICAgICAgICAgICAvLyBvbGQgcGFyc2VyIGZvciBub3cuICBTZWUgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQwMDQ3CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIu aAppbmRleCBjYzY5NDQzNTE0NDE3YmUzMzNjZjRkYTc4YzA5MjQ0YzIyMzM5YmZiLi5iYmFjN2Nm NzhhZmI4ZmZhNWQxNTBmZWU1OGZhZGM4MTE5NDEwMTI2IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0 bWwvSFRNTFNjcmlwdFJ1bm5lci5oCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVy LmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50Lmgi CiAjaW5jbHVkZSAiQ2FjaGVkUmVzb3VyY2VIYW5kbGUuaCIKKyNpbmNsdWRlIDx3dGYvRGVxdWUu aD4KICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgogCkBAIC01Miw2ICs1Myw3IEBAIHB1YmxpYzoKICAgICBib29sIGV4ZWN1dGVTY3JpcHRz V2FpdGluZ0ZvckxvYWQoQ2FjaGVkUmVzb3VyY2UqKTsKICAgICBib29sIGhhc1NjcmlwdHNXYWl0 aW5nRm9yU3R5bGVzaGVldHMoKSBjb25zdCB7IHJldHVybiBtX2hhc1NjcmlwdHNXYWl0aW5nRm9y U3R5bGVzaGVldHM7IH0KICAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hl ZXRzKCk7CisgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCk7CiAKICAg ICBib29sIGlzRXhlY3V0aW5nU2NyaXB0KCkgeyByZXR1cm4gISFtX3NjcmlwdE5lc3RpbmdMZXZl bDsgfQogCkBAIC02Myw3ICs2NSw3IEBAIHByaXZhdGU6CiAgICAgLy8gbGlmZXRpbWUgaW4gb3Jk ZXIgdG8gZ3VhcmFudGVlIHRoYXQgdGhlIGRhdGEgYnVmZmVyIHdpbGwgbm90IGJlIHB1cmdlZC4K ICAgICAvLwogICAgIC8vIEZJWE1FOiBGaW5pc2ggdHVybmluZyB0aGlzIGludG8gYSBwcm9wZXIg Y2xhc3MuCi0gICAgY2xhc3MgUGVuZGluZ1NjcmlwdCA6IHB1YmxpYyBDYWNoZWRSZXNvdXJjZUNs aWVudCwgTm9uY29weWFibGUgeworICAgIGNsYXNzIFBlbmRpbmdTY3JpcHQgOiBwdWJsaWMgQ2Fj aGVkUmVzb3VyY2VDbGllbnQgewogICAgIHB1YmxpYzoKICAgICAgICAgUGVuZGluZ1NjcmlwdCgp CiAgICAgICAgICAgICA6IHN0YXJ0aW5nTGluZU51bWJlcigwKQpAQCAtNzEsNiArNzMsMjggQEAg cHJpdmF0ZToKICAgICAgICAgewogICAgICAgICB9CiAKKyAgICAgICAgUGVuZGluZ1NjcmlwdChj b25zdCBQZW5kaW5nU2NyaXB0JiBvdGhlcikKKyAgICAgICAgICAgIDogQ2FjaGVkUmVzb3VyY2VD bGllbnQob3RoZXIpCisgICAgICAgICAgICAsIGVsZW1lbnQob3RoZXIuZWxlbWVudCkKKyAgICAg ICAgICAgICwgc3RhcnRpbmdMaW5lTnVtYmVyKG90aGVyLnN0YXJ0aW5nTGluZU51bWJlcikKKyAg ICAgICAgICAgICwgbV93YXRjaGluZ0ZvckxvYWQob3RoZXIubV93YXRjaGluZ0ZvckxvYWQpCisg ICAgICAgIHsKKyAgICAgICAgICAgIHNldENhY2hlZFNjcmlwdChvdGhlci5jYWNoZWRTY3JpcHQo KSk7CisgICAgICAgIH0KKworICAgICAgICBQZW5kaW5nU2NyaXB0JiBvcGVyYXRvcj0oY29uc3Qg UGVuZGluZ1NjcmlwdCYgb3RoZXIpCisgICAgICAgIHsKKyAgICAgICAgICAgIGlmICh0aGlzID09 ICZvdGhlcikKKyAgICAgICAgICAgICAgICByZXR1cm4gKnRoaXM7CisKKyAgICAgICAgICAgIGVs ZW1lbnQgPSBvdGhlci5lbGVtZW50OworICAgICAgICAgICAgc3RhcnRpbmdMaW5lTnVtYmVyID0g b3RoZXIuc3RhcnRpbmdMaW5lTnVtYmVyOworICAgICAgICAgICAgbV93YXRjaGluZ0ZvckxvYWQg PSBvdGhlci5tX3dhdGNoaW5nRm9yTG9hZDsKKyAgICAgICAgICAgIHNldENhY2hlZFNjcmlwdChv dGhlci5jYWNoZWRTY3JpcHQoKSk7CisKKyAgICAgICAgICAgIHJldHVybiAqdGhpczsKKyAgICAg ICAgfQorCiAgICAgICAgIH5QZW5kaW5nU2NyaXB0KCk7CiAKICAgICAgICAgUGFzc1JlZlB0cjxF bGVtZW50PiByZWxlYXNlRWxlbWVudEFuZENsZWFyKCk7CkBAIC0xMDEsNyArMTI1LDkgQEAgcHJp dmF0ZToKICAgICBib29sIGV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRzKCk7CiAgICAgdm9p ZCBleGVjdXRlUGVuZGluZ1NjcmlwdCgpOwogCi0gICAgdm9pZCByZXF1ZXN0U2NyaXB0KEVsZW1l bnQqKTsKKyAgICBib29sIHJlcXVlc3RTY3JpcHQoUGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKTsK KyAgICB2b2lkIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCopOworICAgIHZv aWQgcmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQqKTsKICAgICB2b2lkIHJ1blNjcmlwdChF bGVtZW50KiwgaW50IHN0YXJ0aW5nTGluZU51bWJlcik7CiAKICAgICAvLyBIZWxwZXJzIGZvciBk ZWFsaW5nIHdpdGggSFRNTFNjcmlwdFJ1bm5lckhvc3QKQEAgLTExNSw2ICsxNDEsNyBAQCBwcml2 YXRlOgogICAgIERvY3VtZW50KiBtX2RvY3VtZW50OwogICAgIEhUTUxTY3JpcHRSdW5uZXJIb3N0 KiBtX2hvc3Q7CiAgICAgUGVuZGluZ1NjcmlwdCBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdDsKKyAg ICBEZXF1ZTxQZW5kaW5nU2NyaXB0PiBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmc7CiAg ICAgdW5zaWduZWQgbV9zY3JpcHROZXN0aW5nTGV2ZWw7CiAKICAgICAvLyBXZSBvbmx5IHdhbnQg c3R5bGVzaGVldCBsb2FkcyB0byB0cmlnZ2VyIHNjcmlwdCBleGVjdXRpb24gaWYgc2NyaXB0Cg== 63078 2010-07-30 10:36:11 -0700 2010-08-09 20:09:18 -0700 Patch bug-40934-20100730103609.patch text/plain 29036 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA5ZTYwNTY1NWU5NDRlMzNhNTE5ZDQ3MmU2MmM0ODU2ODE1ZTEzNzE0Li42YjRhNjM4 YmRjMGJhNDBkZTg5NDM3ZGFmNzQ2NjllMjY0MzljYjUzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAK KzIwMTAtMDctMjkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBMYXlvdXRUZXN0cyBm b3IgPHNjcmlwdCBkZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgICogZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLWRlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5IG9yZGVyaW5nIGFu ZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGRlZmVyZWQgc2NyaXB0cy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUt ZXhwZWN0ZWQudHh0OiBDb3BpZWQgZnJvbSBMYXlvdXRUZXN0cy9mYXN0L3Rva2VuaXplci93cml0 ZS1iZWZvcmUtbG9hZC1leHBlY3RlZC50eHQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0cyBmb3IgdHJpY2t5 IG9yZGVyaW5nIGFuZCByZWVudHJhbmN5IGJ5IGRvaW5nIGEgZG91YmxlIHdyaXRlIG9mIGlubGlu ZSBzY3JpcHRzLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlu bGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0 IHRoZSBkZWZlciBhdHRyaWJ1dGUgaXMgaWdub3JlZCBvbiBpbmxpbmUgc2NyaXB0IGJsb2Nrcy4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgb25iZWZvcmVsb2Fk IGZpcmVzIGltbWVkaWF0ZWx5IHdoZW4gYSBkZWZlcnJlZCBzY3JpcHQgaXMgZW5jb3VudGVkLiBB bHNvIHRlc3RzIHRoYXQgaXQgY2FuIGJlIGNhbmNlbGxlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgaW52YWxpZCBVUkxzIGFyZSBpZ25v cmVkIGFuZCBzdWJzZXF1ZW50IHNjcmlwdHMgYXJlIHN0aWxsIGV4ZWN1dGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpz OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMv c2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanM6IEFkZGVk LgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ct c3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVzdHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhh dmlvci4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1z bG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4gVGVz dHMgc3R5bGVzaGVldCBibG9ja2luZyBiZWhhdmlvciB3aXRoIGEgc2xvdyBzdHlsZXNoZWV0Lgor ICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbDogQWRkZWQuIFRlc3Rz IGJhc2ljIGZ1bmN0aW9uYWxpdHkgYW5kIG9yZGVyaW5nLgorCiAyMDEwLTA3LTI4ICBEdW1pdHJ1 IERhbmlsaXVjICA8ZHVtaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2 aWQgTGV2aW4uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4xNTEzYjI4MDdiNTRmNDFmNDc5MmRjNTViMWJkYTRjYzIzMDNk OTVhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBA CisxIDIgMyA0IDU2IDc4CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2Ny aXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjQwNzRlMDFjZjg3NTY2YzNjNGE4N2NkZDUzNjQ4MjFlNTk1NTE4NzcKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDE4IEBACisxCis8c2NyaXB0Pgor aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7CisKK2Z1bmN0aW9uIGRvdWJsZVdyaXRlKG51bWJlcikKK3sKKyAgICBk b2N1bWVudC53cml0ZSgiPHNjcmlwdCBzcmM9J2RhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50 LndyaXRlKCIgKyBudW1iZXIgKyAiKScgZGVmZXI+PC9zY3IiICsKKyAgICAgICAgICAgICAgICAg ICAiaXB0PiA8c2NyaXB0IHNyYz0nZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUo IiArIChudW1iZXIgKyAxKSArICIpJyBkZWZlcj48L3NjciIgKyAiaXB0PiAiKQorfQorPC9zY3Jp cHQ+CisyCis8c2NyaXB0CisgICAgb25iZWZvcmVsb2FkPSJkb2N1bWVudC53cml0ZSgzKTtkb3Vi bGVXcml0ZSg1KSIKKyAgICBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRvdWJsZVdyaXRlKDcp IgorICAgIGRlZmVyPgorPC9zY3JpcHQ+Cis0CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRl LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iNDQ1N2FhZTY2ZjZiMWU0NjEyMmQ3MjRlYTEyZTlm YWU5NTZkMzkyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBA CisxIDIgMyA0IDUgNiA3CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2Ny aXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmM4 NTg5OTM3ZTYzODUwZWYxMzY1OWI0NTBhM2U0ZGIyYmY0MjU4NmQKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3Jp dGUuaHRtbApAQCAtMCwwICsxLDE4IEBACisxCis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisK K2Z1bmN0aW9uIGRvdWJsZVdyaXRlKG51bWJlcikKK3sKKyAgICBkb2N1bWVudC53cml0ZSgiPHNj cmlwdD5kb2N1bWVudC53cml0ZSgiICsgbnVtYmVyICsgIik8L3NjciIgKworICAgICAgICAgICAg ICAgICAgICJpcHQ+IDxzY3JpcHQ+ZG9jdW1lbnQud3JpdGUoIiArIChudW1iZXIgKyAxKSArICIp PC9zY3IiICsgImlwdD4gIikKK30KKzwvc2NyaXB0PgorMgorPHNjcmlwdAorICAgIG9uYmVmb3Jl bG9hZD0iZG91YmxlV3JpdGUoMykiCisgICAgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb3Vi bGVXcml0ZSg2KSIKKyAgICBkZWZlcj4KKzwvc2NyaXB0PgorNQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1p bmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZDA0Zjk2MWEwMzcxMTdjMWVh YTY5YWM2MGViMzYzZDM3YWU3OGQxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSBAQAorMSAyCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYWEzMWFhMmMwZTE2MjcxYTlkYTVlYjYwNWZjNmIxNjA3ZmI3M2VmOQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGlu ZS1zY3JpcHQuaHRtbApAQCAtMCwwICsxLDggQEAKKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK Kzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50Lndy aXRlKCcyJykiIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBkZWZlcj4KKyAgZG9jdW1lbnQud3Jp dGUoJzEnKTsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMmViNTZjOThmOTNjYWYzNzQwZmYxMTg3NTFkMzU3MTVmMDU3N2Ri NQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5IGFu ZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZlcgor b25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9yZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitkZWZl cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1vbmJlZm9yZWxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQyMjYxNmM0YWM1YTY4 ZTU1MDU3NWEwNjBkMmY1ZDFiMzJjMTMwMjEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApAQCAt MCwwICsxLDE0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9F TiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9q cy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0NoZWNr cyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgZmlyZSBvbmJlZm9yZWxvYWQgaW1tZWRpYXRlbHkgYW5k IHRoYXQgaXQgaXMgY2FuY2VsbGFibGUuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3Jp cHQgc3JjPSJyZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyIgb25iZWZvcmVsb2FkPSJkZWJ1 ZygnY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZlcicpO3JldHVybiBmYWxzZTsiIGRlZmVyPjwv c2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIgb25iZWZvcmVsb2FkPSJk ZWJ1Zygnb25iZWZvcmVsb2FkIGRlZmVyJyk7cmV0dXJuIHRydWU7IiBkZWZlcj48L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZXh0ZXJuYWwuanMiIG9uYmVmb3JlbG9hZD0iZGVidWco J29uYmVmb3JlbG9hZCBleHRlcm5hbCcpO3JldHVybiB0cnVlOyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi44MzBjYzY3MzM4ZGE0OWFkODBiZWYxYzlmNWZhZThmMjMzZmU4 NWY4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMg QEAKK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVSTHMgYXJlIGln bm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgZXhlY3V0ZWQuCitkZWZl cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmM4 ZWVlZGU2ZjY1YmEyNTAzOGY2ZDljM2JkZjYxOTE2MThlNjlkODQKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52 YWxpZC11cmwuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0v L0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVS THMgYXJlIGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgZXhlY3V0 ZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSJodHRwOi8vaW52YWxp ZDo5OTk5OTkvIiBkZWZlcj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZGVmZXIu anMiIGRlZmVyPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2RlZmVyLmpzIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2RlZmVyLmpzCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNv dXJjZXMvZGVmZXIuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRlZmVyIik7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZXh0ZXJu YWwuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMv ZXh0ZXJuYWwuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVh NDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZXh0 ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYzBkNjk1NDAxNjJmOWFkN2NhYjFmMDIwNzZkZjgxYjE5NzE3YmQ5MAotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9z aG91bGRub3RleGVjdXRlLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJGQUlMIik7CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5q cyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0Lmpz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2Rl ZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0Lmpz IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3JpcHQu anMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVhNDQ3N2VmOAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv ZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIpOwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVi dWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZmYmU3YTFj NDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tn cm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJnZXRDb21wdXRl ZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10iLCAicmdiKDI1NSwgMCwg MCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv c2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5lZDExZWI1MmM2ZWY3ZmVlZjE1MWQyZDQ3OTllM2RjMmFlYjI3NmYzCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtd3JpdGUt c2xvdy1zdHlsZXNoZWV0LmpzCkBAIC0wLDAgKzEgQEAKK2RvY3VtZW50LndyaXRlKCc8bGluayBy ZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNl cy9zbG93LXN0eWxlc2hlZXQuY2dpIj4nKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAv dGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1z Y3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJD b250ZW50LXR5cGU6IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJk ZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjZGRj YTQwMWY4YWIzYTZhNWRmODczYTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kK QEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJpbnQgIkNvbnRlbnQtdHlw ZTogdGV4dC9jc3NcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiYm9keSB7IGJhY2tncm91bmQt Y29sb3I6ICNGRjAwMDAgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNo ZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41MjQ1NzYzZDg1MTMyMDIxNDEyMzYyMzcwZmY2 MTEyYzg2ZDQ2ZDcwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0CkBAIC0w LDAgKzEsMTAgQEAKK1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4 ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBz ZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVU RSIuCisKK1BBU1MgZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1j b2xvciddIGlzICJyZ2IoMjU1LCAwLCAwKSIKK0RPTUNvbnRlbnRMb2FkZWQKK1BBU1Mgc3VjY2Vz c2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVl dC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1z bG93LXN0eWxlc2hlZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lMDU2MTIxZDc0NThhY2E4MmE2MDVlNTVk Mzc2YmJhNmI1ZmVlOWZlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApAQCAtMCwwICsx LDMwIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8 aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0 ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9 Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KKzxkdmkgaWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxkaXYgaWQ9ImNvbnNv bGUiPjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24o J1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1dGVzIGJlZm9y ZSBkZWZlcnJlZCBzY3JpcHRzLicpOworCit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7CisKK2Rv Y3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5jdGlvbigpIHsK KyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rlc3QoKTsKK30sIGZh bHNlKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21p c2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMiIGRlZmVyPSJkZWZl ciI+PC9zY3JpcHQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4w LjE6ODAwMC9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4KKzxzY3JpcHQ+Cit2 YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0 LWRlZmVyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJmY2FhNmU5MjQ1NDZiY2I5NGY0OGZlMWYz ZjYzNzM0YWU1MTUyNjUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDggQEAKK1RoaXMgdGVz dHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Ygc2NyaXB0cyB3aXRoIHRoZSBkZWZlciBh dHRyaWJ1dGUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNzEwLgor ZXh0ZXJuYWwKK2lubGluZQorc2xvd0RlZmVyCitkZWZlcgorRE9NQ29udGVudExvYWRlZAorbG9h ZAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy LXdyaXRlLXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdyaXRlLXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZjIwNDk3ZDlmMzNhYTEzODNkOTZmMDhiYTA4M2Y0MDkxZjQ5ODJkMwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIt d3JpdGUtc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDEwIEBACitUaGlz IHRlc3RzIHRoYXQgYSBzbG93IHN0eWxlc2hlZXQgd3JpdHRlbiBieSBhIGRlZmVycmVkIHNjcmlw dCBkZWxheXMgRE9NQ29udGVudExvYWRlZC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEg c2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgor CitQQVNTIGdldENvbXB1dGVkU3R5bGUoZG9jdW1lbnQuYm9keSlbJ2JhY2tncm91bmQtY29sb3In XSBpcyAicmdiKDI1NSwgMCwgMCkiCitET01Db250ZW50TG9hZGVkCitQQVNTIHN1Y2Nlc3NmdWxs eVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci13cml0ZS1zbG93LXN0eWxlc2hlZXQuaHRt bCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItd3JpdGUtc2xvdy1z dHlsZXNoZWV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMjM4ODlkM2QwNzgwOGYxMzAzZjE5YWRiZDgwM2Zl NjQ1OWM5NjViMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9zY3JpcHQtZGVmZXItd3JpdGUtc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAsMCArMSwyOSBA QAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+ Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9o dG1sOyBjaGFyc2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8u Li9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4v Li4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgor PGJvZHk+Cis8ZGl2IGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+Cis8ZGl2IGlkPSJjb25zb2xlIj48 L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK3ZhciBqc1Rlc3RJc0FzeW5j ID0gdHJ1ZTsKKworZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBhIHNsb3cgc3R5bGVzaGVl dCB3cml0dGVuIGJ5IGEgZGVmZXJyZWQgc2NyaXB0IGRlbGF5cyBET01Db250ZW50TG9hZGVkLicp OworCitkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIiwgZnVuY3Rp b24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7CisKKyAgZmluaXNoSlNUZXN0KCk7 Cit9LCBmYWxzZSk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgw MDAvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyIgZGVmZXI9 ImRlZmVyIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlz Yy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcyIgZGVmZXI9ImRlZmVy Ij48L3NjcmlwdD4KKzxzY3JpcHQ+Cit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwv c2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhiMzUwNzVmYTE4YmQ2 MjNiY2Q2Y2FkNmFlNjdkZTVkM2MzMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0IEBACis8IURPQ1RZ UEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgor PG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJz ZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3Qt cmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0 LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keSBvbmxv YWQ9ImRlYnVnKCdsb2FkJykiPgorVGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4ZWN1dGlvbiBvcmRl ciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVmPSJodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMDwvYT4uCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4K KworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZG9jdW1lbnQuYWRkRXZlbnRMaXN0 ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1ZygnRE9NQ29udGVu dExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEy Ny4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSIgZGVmZXI9 IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlz Yy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0PgorPHNj cmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1z Y3JpcHQuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUiKTsKKzwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCA3NjU1ZjhhYzYyOGNiZjFkZmM1YzkwY2NlMWVhNzgzMTIzNWJl MWJhLi5hZWY4YmFlNjQ3MDFmNzkyZDFlM2YwODJhNGQ2Y2E3OGY4NDY4ZjljIDEwMDY0NAotLS0g YS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2 IEBACisyMDEwLTA3LTI5ICBUb255IEdlbnRpbGNvcmUgIDx0b255Z0BjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgU3VwcG9ydCA8 c2NyaXB0IGRlZmVyPiBhcyBzcGVjaWZpZWQgYnkgSFRNTDUKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQwOTM0CisKKyAgICAgICAgU2VlOiBodHRwOi8v ZGV2LnczLm9yZy9odG1sNS9zcGVjL092ZXJ2aWV3Lmh0bWwjdGhlLWVuZAorCisgICAgICAgIFRl c3RzOiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUu aHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVz aGVldC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLXdy aXRlLXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mv c2NyaXB0LWRlZmVyLmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTERvY3VtZW50UGFyc2VyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKToK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5n Rm9yUGFyc2luZ0FuZEVuZCk6CisgICAgICAgICogaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaDoK KyAgICAgICAgKiBodG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAg ICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KToKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2Ny aXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdCk6Cisg ICAgICAgICogaHRtbC9IVE1MU2NyaXB0UnVubmVyLmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpQZW5kaW5nU2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OlBlbmRpbmdTY3JpcHQ6Om9wZXJhdG9yPSk6CisKIDIw MTAtMDctMjkgIE1hcnRpbiBSb2JpbnNvbiAgPG1yb2JpbnNvbkBpZ2FsaWEuY29tPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERpcmsgU2NodWx6ZS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9I VE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5j cHAKaW5kZXggNzIzZmJlNzYyM2VjZWIzMmViYzNlYmNjNmUwMWExNmIzMTRjYzFjYS4uMWZjOTgw YzdhYzQ0ZDcwZWIxZTAxY2Y4ODc1NDUyNDY3ZjQ5Y2ZmZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9o dG1sL0hUTUxEb2N1bWVudFBhcnNlci5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxEb2N1bWVu dFBhcnNlci5jcHAKQEAgLTI4MCw3ICsyODAsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6 YXR0ZW1wdFRvRW5kKCkKICAgICAgICAgbV9lbmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAgICAg cmV0dXJuOwogICAgIH0KLSAgICBlbmQoKTsKKyAgICBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQ YXJzaW5nQW5kRW5kKCk7CiB9CiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5 ZWQoKQpAQCAtMjg5LDYgKzI4OSwxOSBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZE ZWxheWVkKCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgbV9lbmRXYXNEZWxheWVkID0gZmFsc2U7 CisgICAgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVuZCgpOworfQorCit2b2lk IEhUTUxEb2N1bWVudFBhcnNlcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZ0FuZEVu ZCgpCit7CisgICAgaWYgKG1fc2NyaXB0UnVubmVyKSB7CisgICAgICAgIGJvb2wgY29udGludWVQ YXJzaW5nID0gbV9zY3JpcHRSdW5uZXItPmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmco KTsKKyAgICAgICAgaWYgKCFjb250aW51ZVBhcnNpbmcpIHsKKyAgICAgICAgICAgIG1fdHJlZUJ1 aWxkZXItPnNldFBhdXNlZCh0cnVlKTsKKyAgICAgICAgICAgIG1fZW5kV2FzRGVsYXllZCA9IHRy dWU7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICB9CiAgICAgZW5kKCk7CiB9 CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaCBiL1dlYkNv cmUvaHRtbC9IVE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCBjYzQ2ZDMxM2YyNTJmMmY5YTVhM2Fh YmJkMzI0ZmI3MTE3NThkZjI5Li5kZjY0OTE1OTJmODRlOGNlZWE3ODQwMjc3OTY0NDNhYzFlMGJm NTIxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTERvY3VtZW50UGFyc2VyLmgKKysrIGIv V2ViQ29yZS9odG1sL0hUTUxEb2N1bWVudFBhcnNlci5oCkBAIC0xMDUsNiArMTA1LDcgQEAgcHJp dmF0ZToKICAgICB2b2lkIGJlZ2luKCk7CiAgICAgdm9pZCBhdHRlbXB0VG9FbmQoKTsKICAgICB2 b2lkIGVuZElmRGVsYXllZCgpOworICAgIHZvaWQgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFy c2luZ0FuZEVuZCgpOwogICAgIHZvaWQgZW5kKCk7CiAKICAgICBib29sIGlzU2NoZWR1bGVkRm9y UmVzdW1lKCkgY29uc3Q7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5l ci5jcHAgYi9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggZjRiNzAxMzNl MmE4ZDk3M2Y2M2E2YjhiMjgwN2I4ZGQ5MGEzOGJjMi4uMGQxODQ1ZmRmYzRjMTEyYmI1N2E0ZDZh NWNkZjQ2OTU3NmQxMmU0ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5u ZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmNwcApAQCAtMjI4LDI1 ICsyMjgsNTAgQEAgYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdG b3JTdHlsZXNoZWV0cygpCiAgICAgcmV0dXJuIGV4ZWN1dGVQYXJzaW5nQmxvY2tpbmdTY3JpcHRz KCk7CiB9CiAKLXZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChFbGVtZW50KiBz Y3JpcHQpCitib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmcoKQogewotICAgIEFTU0VSVCghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuZWxlbWVudCk7 Ci0gICAgQXRvbWljU3RyaW5nIHNyY1ZhbHVlID0gc2NyaXB0LT5nZXRBdHRyaWJ1dGUoc3JjQXR0 cik7Ci0gICAgLy8gQWxsb3cgdGhlIGhvc3QgdG8gZGlzbGxvdyBzY3JpcHQgbG9hZHMgKHVzaW5n IHRoZSBYU1NBdWRpdG9yLCBldGMuKQorICAgIHdoaWxlICghbV9zY3JpcHRzVG9FeGVjdXRlQWZ0 ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIWhhdmVQYXJzaW5nQmxvY2tp bmdTY3JpcHQoKSk7CisgICAgICAgIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0ID0gbV9zY3JpcHRz VG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAgICBBU1NFUlQobV9wYXJz aW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fcGFyc2lu Z0Jsb2NraW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgICAg ICB3YXRjaEZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOworICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOworICAgICAgICB9CisgICAgICAgIGlmICghZXhlY3V0ZVBhcnNpbmdCbG9ja2lu Z1NjcmlwdHMoKSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICByZXR1 cm4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKTsKK30KKworYm9vbCBI VE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KFBlbmRpbmdTY3JpcHQmIHBlbmRpbmdTY3Jp cHQsIEVsZW1lbnQqIHNjcmlwdEVsZW1lbnQpCit7CisgICAgQVNTRVJUKCFwZW5kaW5nU2NyaXB0 LmVsZW1lbnQpOworICAgIGNvbnN0IEF0b21pY1N0cmluZyYgc3JjVmFsdWUgPSBzY3JpcHRFbGVt ZW50LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7CiAgICAgaWYgKCFtX2hvc3QtPnNob3VsZExvYWRF eHRlcm5hbFNjcmlwdEZyb21TcmMoc3JjVmFsdWUpKQotICAgICAgICByZXR1cm47CisgICAgICAg IHJldHVybiBmYWxzZTsKICAgICAvLyBGSVhNRTogV2UgbmVlZCB0byByZXNvbHZlIHRoZSB1cmwg cmVsYXRpdmUgdG8gdGhlIGVsZW1lbnQuCi0gICAgaWYgKCFzY3JpcHQtPmRpc3BhdGNoQmVmb3Jl TG9hZEV2ZW50KHNyY1ZhbHVlKSkKLSAgICAgICAgcmV0dXJuOwotICAgIG1fcGFyc2luZ0Jsb2Nr aW5nU2NyaXB0LmVsZW1lbnQgPSBzY3JpcHQ7CisgICAgaWYgKCFzY3JpcHRFbGVtZW50LT5kaXNw YXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICBwZW5kaW5nU2NyaXB0LmVsZW1lbnQgPSBzY3JpcHRFbGVtZW50OwogICAgIC8vIFRoaXMgc2hv dWxkIGNvcnJlY3RseSByZXR1cm4gMCBmb3IgZW1wdHkgb3IgaW52YWxpZCBzcmNWYWx1ZXMuCi0g ICAgQ2FjaGVkU2NyaXB0KiBjYWNoZWRTY3JpcHQgPSBtX2RvY3VtZW50LT5kb2NMb2FkZXIoKS0+ cmVxdWVzdFNjcmlwdChzcmNWYWx1ZSwgdG9TY3JpcHRFbGVtZW50KHNjcmlwdCktPnNjcmlwdENo YXJzZXQoKSk7CisgICAgQ2FjaGVkU2NyaXB0KiBjYWNoZWRTY3JpcHQgPSBtX2RvY3VtZW50LT5k b2NMb2FkZXIoKS0+cmVxdWVzdFNjcmlwdChzcmNWYWx1ZSwgdG9TY3JpcHRFbGVtZW50KHNjcmlw dEVsZW1lbnQpLT5zY3JpcHRDaGFyc2V0KCkpOwogICAgIGlmICghY2FjaGVkU2NyaXB0KSB7CiAg ICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIERpc3BhdGNoIGVycm9yIGV2ZW50LgotICAgICAg ICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKLSAgICBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC5zZXRDYWNoZWRTY3JpcHQoY2FjaGVkU2NyaXB0KTsKKyAgICBwZW5kaW5n U2NyaXB0LnNldENhY2hlZFNjcmlwdChjYWNoZWRTY3JpcHQpOworICAgIHJldHVybiB0cnVlOwor fQorCit2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQo RWxlbWVudCogc2NyaXB0RWxlbWVudCkKK3sKKyAgICBpZiAoIXJlcXVlc3RTY3JpcHQobV9wYXJz aW5nQmxvY2tpbmdTY3JpcHQsIHNjcmlwdEVsZW1lbnQpKQorICAgICAgICByZXR1cm47CisKKyAg ICBBU1NFUlQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkpOwogCiAgICAg Ly8gV2Ugb25seSBjYXJlIGFib3V0IGEgbG9hZCBjYWxsYmFjayBpZiBjYWNoZWRTY3JpcHQgaXMg bm90IGFscmVhZHkKICAgICAvLyBpbiB0aGUgY2FjaGUuICBDYWxsZXJzIHdpbGwgYXR0ZW1wdCB0 byBydW4gdGhlIG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0CkBAIC0yNTUsNiArMjgwLDE2IEBAIHZv aWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFNjcmlwdChFbGVtZW50KiBzY3JpcHQpCiAgICAg ICAgIHdhdGNoRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CiAKK3ZvaWQgSFRN TFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQqIHNjcmlwdEVsZW1l bnQpCit7CisgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0OworICAgIGlmICghcmVxdWVz dFNjcmlwdChwZW5kaW5nU2NyaXB0LCBzY3JpcHRFbGVtZW50KSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgQVNTRVJUKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAgIG1fc2NyaXB0 c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5hcHBlbmQocGVuZGluZ1NjcmlwdCk7Cit9CisKIC8vIFRo aXMgbWV0aG9kIGlzIG1lYW50IHRvIG1hdGNoIHRoZSBIVE1MNSBkZWZpbml0aW9uIG9mICJydW5u aW5nIGEgc2NyaXB0IgogLy8gaHR0cDovL3d3dy53aGF0d2cub3JnL3NwZWNzL3dlYi1hcHBzL2N1 cnJlbnQtd29yay9tdWx0aXBhZ2Uvc2NyaXB0aW5nLTEuaHRtbCNydW5uaW5nLWEtc2NyaXB0CiB2 b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBzY3JpcHQsIGludCBzdGFy dGluZ0xpbmVOdW1iZXIpCkBAIC0yNjcsOCArMzAyLDExIEBAIHZvaWQgSFRNTFNjcmlwdFJ1bm5l cjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0aW5nTGluZU51bWJlcikKICAg ICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gZXZlbnQgZm9yIHN1cHBvcnQKIAogICAgICAgICBp ZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoc3JjQXR0cikpIHsKLSAgICAgICAgICAgIC8vIEZJWE1F OiBIYW5kbGUgZGVmZXIgYW5kIGFzeW5jCi0gICAgICAgICAgICByZXF1ZXN0U2NyaXB0KHNjcmlw dCk7CisgICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGFzeW5jCisgICAgICAgICAgICBpZiAo c2NyaXB0LT5oYXNBdHRyaWJ1dGUoZGVmZXJBdHRyKSkKKyAgICAgICAgICAgICAgICByZXF1ZXN0 RGVmZXJyZWRTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAg ICByZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KHNjcmlwdCk7CiAgICAgICAgIH0gZWxzZSB7 CiAgICAgICAgICAgICAvLyBGSVhNRTogV2UgZG8gbm90IGJsb2NrIGlubGluZSA8c2NyaXB0PiB0 YWdzIG9uIHN0eWxlc2hlZXRzIHRvIG1hdGNoIHRoZQogICAgICAgICAgICAgLy8gb2xkIHBhcnNl ciBmb3Igbm93LiAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00 MDA0NwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaCBiL1dlYkNv cmUvaHRtbC9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggY2M2OTQ0MzUxNDQxN2JlMzMzY2Y0ZGE3 OGMwOTI0NGMyMjMzOWJmYi4uYmJhYzdjZjc4YWZiOGZmYTVkMTUwZmVlNThmYWRjODExOTQxMDEy NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaAorKysgYi9XZWJD b3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5oCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpbmNsdWRl ICJDYWNoZWRSZXNvdXJjZUNsaWVudC5oIgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxl LmgiCisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+ CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTIsNiArNTMsNyBAQCBwdWJsaWM6 CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENhY2hlZFJlc291cmNlKik7 CiAgICAgYm9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCkgY29uc3QgeyByZXR1 cm4gbV9oYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9CiAgICAgYm9vbCBleGVjdXRl U2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNX YWl0aW5nRm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIHsgcmV0 dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAtNjMsNyArNjUsNyBAQCBwcml2YXRl OgogICAgIC8vIGxpZmV0aW1lIGluIG9yZGVyIHRvIGd1YXJhbnRlZSB0aGF0IHRoZSBkYXRhIGJ1 ZmZlciB3aWxsIG5vdCBiZSBwdXJnZWQuCiAgICAgLy8KICAgICAvLyBGSVhNRTogRmluaXNoIHR1 cm5pbmcgdGhpcyBpbnRvIGEgcHJvcGVyIGNsYXNzLgotICAgIGNsYXNzIFBlbmRpbmdTY3JpcHQg OiBwdWJsaWMgQ2FjaGVkUmVzb3VyY2VDbGllbnQsIE5vbmNvcHlhYmxlIHsKKyAgICBjbGFzcyBQ ZW5kaW5nU2NyaXB0IDogcHVibGljIENhY2hlZFJlc291cmNlQ2xpZW50IHsKICAgICBwdWJsaWM6 CiAgICAgICAgIFBlbmRpbmdTY3JpcHQoKQogICAgICAgICAgICAgOiBzdGFydGluZ0xpbmVOdW1i ZXIoMCkKQEAgLTcxLDYgKzczLDI4IEBAIHByaXZhdGU6CiAgICAgICAgIHsKICAgICAgICAgfQog CisgICAgICAgIFBlbmRpbmdTY3JpcHQoY29uc3QgUGVuZGluZ1NjcmlwdCYgb3RoZXIpCisgICAg ICAgICAgICA6IENhY2hlZFJlc291cmNlQ2xpZW50KG90aGVyKQorICAgICAgICAgICAgLCBlbGVt ZW50KG90aGVyLmVsZW1lbnQpCisgICAgICAgICAgICAsIHN0YXJ0aW5nTGluZU51bWJlcihvdGhl ci5zdGFydGluZ0xpbmVOdW1iZXIpCisgICAgICAgICAgICAsIG1fd2F0Y2hpbmdGb3JMb2FkKG90 aGVyLm1fd2F0Y2hpbmdGb3JMb2FkKQorICAgICAgICB7CisgICAgICAgICAgICBzZXRDYWNoZWRT Y3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICB9CisKKyAgICAgICAgUGVuZGlu Z1NjcmlwdCYgb3BlcmF0b3I9KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICB7 CisgICAgICAgICAgICBpZiAodGhpcyA9PSAmb3RoZXIpCisgICAgICAgICAgICAgICAgcmV0dXJu ICp0aGlzOworCisgICAgICAgICAgICBlbGVtZW50ID0gb3RoZXIuZWxlbWVudDsKKyAgICAgICAg ICAgIHN0YXJ0aW5nTGluZU51bWJlciA9IG90aGVyLnN0YXJ0aW5nTGluZU51bWJlcjsKKyAgICAg ICAgICAgIG1fd2F0Y2hpbmdGb3JMb2FkID0gb3RoZXIubV93YXRjaGluZ0ZvckxvYWQ7CisgICAg ICAgICAgICBzZXRDYWNoZWRTY3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworCisgICAgICAg ICAgICByZXR1cm4gKnRoaXM7CisgICAgICAgIH0KKwogICAgICAgICB+UGVuZGluZ1NjcmlwdCgp OwogCiAgICAgICAgIFBhc3NSZWZQdHI8RWxlbWVudD4gcmVsZWFzZUVsZW1lbnRBbmRDbGVhcigp OwpAQCAtMTAxLDcgKzEyNSw5IEBAIHByaXZhdGU6CiAgICAgYm9vbCBleGVjdXRlUGFyc2luZ0Js b2NraW5nU2NyaXB0cygpOwogICAgIHZvaWQgZXhlY3V0ZVBlbmRpbmdTY3JpcHQoKTsKIAotICAg IHZvaWQgcmVxdWVzdFNjcmlwdChFbGVtZW50Kik7CisgICAgYm9vbCByZXF1ZXN0U2NyaXB0KFBl bmRpbmdTY3JpcHQmLCBFbGVtZW50Kik7CisgICAgdm9pZCByZXF1ZXN0UGFyc2luZ0Jsb2NraW5n U2NyaXB0KEVsZW1lbnQqKTsKKyAgICB2b2lkIHJlcXVlc3REZWZlcnJlZFNjcmlwdChFbGVtZW50 Kik7CiAgICAgdm9pZCBydW5TY3JpcHQoRWxlbWVudCosIGludCBzdGFydGluZ0xpbmVOdW1iZXIp OwogCiAgICAgLy8gSGVscGVycyBmb3IgZGVhbGluZyB3aXRoIEhUTUxTY3JpcHRSdW5uZXJIb3N0 CkBAIC0xMTUsNiArMTQxLDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsK ICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQgbV9w YXJzaW5nQmxvY2tpbmdTY3JpcHQ7CisgICAgRGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3JpcHRz VG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOwogICAgIHVuc2lnbmVkIG1fc2NyaXB0TmVzdGluZ0xldmVs OwogCiAgICAgLy8gV2Ugb25seSB3YW50IHN0eWxlc2hlZXQgbG9hZHMgdG8gdHJpZ2dlciBzY3Jp cHQgZXhlY3V0aW9uIGlmIHNjcmlwdAo= 63968 2010-08-09 20:09:23 -0700 2010-08-17 09:42:34 -0700 Work in progress bug-40934-20100809200922.patch text/plain 62453 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkZDYzM2U2ZDAzN2M0MzJkM2Y5ZTBhYzY1MDNlOTNjYTI1YTc2MDcyLi45MTdkMGE3 NmMyYzA3MzcwMDZkZTJhMjAyZDljNGZkNGNiOTllMTE4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzMgQEAK KzIwMTAtMDgtMDkgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBXb3JrIGluIHByb2dyZXNz LiBDb250YWlucyByZWZhY3RvciBmcm9tIDQzNzM2LgorCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXIt b25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0bWw6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2Rl ZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uLzUxMzY2OTYtZXhwZWN0ZWQudHh0LgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qczog QWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9y ZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0 cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAv dGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAgICAg KiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQu anM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZl ci1zY3JpcHQuY2dpOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L3Nsb3ctc3R5bGVzaGVldC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hl ZXQuaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVm ZXIuaHRtbDogQWRkZWQuCisKIDIwMTAtMDgtMDkgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjk1YjcxN2YyMDk2YzUyNjY5 ZGYwNzQzYTE4MWMwM2M3YWU5YjNlYmIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4 dApAQCAtMCwwICsxLDQgQEAKK0NoZWNrcyB0aGF0IGlubGluZSBzY3JpcHRzIGFyZSBub3QgZGVm ZXJyZWQuCitpbmxpbmUgZGVmZXIKK2V4dGVybmFsIGRlZmVyCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1z Y3JpcHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41YWZjNzNhNWJjNmU4OGMwMDMyNjM1N2JlYmRlYTNhMThj YzdjNWMwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCkBAIC0wLDAgKzEsMTUgQEAKKzwhRE9D VFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+ Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJl LmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlw dHMgYXJlIG5vdCBkZWZlcnJlZC4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBz cmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRlYnVnKCdleHRlcm5hbCBkZWZlcicpIiBkZWZlcj48 L3NjcmlwdD4KKzxzY3JpcHQgZGVmZXI+CisgIGRlYnVnKCdpbmxpbmUgZGVmZXInKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uMmViNTZjOThmOTNjYWYzNzQwZmYxMTg3NTFkMzU3MTVmMDU3 N2RiNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw3IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZl cgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9yZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitk ZWZlcgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQyMjYxNmM0YWM1 YTY4ZTU1MDU3NWEwNjBkMmY1ZDFiMzJjMTMwMjEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApA QCAtMCwwICsxLDE0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1M Ly9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8u Li9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pz L3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0No ZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgZmlyZSBvbmJlZm9yZWxvYWQgaW1tZWRpYXRlbHkg YW5kIHRoYXQgaXQgaXMgY2FuY2VsbGFibGUuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxz Y3JpcHQgc3JjPSJyZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyIgb25iZWZvcmVsb2FkPSJk ZWJ1ZygnY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZlcicpO3JldHVybiBmYWxzZTsiIGRlZmVy Pjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIgb25iZWZvcmVsb2Fk PSJkZWJ1Zygnb25iZWZvcmVsb2FkIGRlZmVyJyk7cmV0dXJuIHRydWU7IiBkZWZlcj48L3Njcmlw dD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZXh0ZXJuYWwuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ29uYmVmb3JlbG9hZCBleHRlcm5hbCcpO3JldHVybiB0cnVlOyI+PC9zY3JpcHQ+Cis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44MzBjYzY3MzM4ZGE0OWFkODBiZWYxYzlmNWZhZThmMjMz ZmU4NWY4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dApAQCAtMCwwICsx LDMgQEAKK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVSTHMgYXJl IGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgZXhlY3V0ZWQuCitk ZWZlcgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmFhZjI2ZmRkZGYxYmQ2MGY5YTI0MTJkMzk1Njc0ODI1ODY1ZDE3NmQKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMg Ii0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHls ZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNj cmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlk IFVSTHMgYXJlIGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgZXhl Y3V0ZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSJodHRwOi8vbG9j YWxob3N0Ojk5OTk5OS8iIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9k ZWZlci5qcyIgZGVmZXI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0 ZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uN2VmMjJlOWE0MzFhZDAyNzI3MTNiNzFmZGM4Nzk0 MDE2YzhlZjEyZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNT CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci13cml0ZS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MzdiZWJkZjIwMGE2OWE5N2I3ZDkxNWY0MDU4MzJm N2E2OThhYzRkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDMgQEAKK0NoZWNrcyB0aGF0 IGEgZG9jdW1lbnQud3JpdGUoKSBpbiBhIGRlZmVycmVkIHNjcmlwdCBibG93cyBhd2F5IHRoZSBj dXJyZW50IGRvY3VtZW50LgorRkFJTAorPHNjcmlwdCBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0 LGRvY3VtZW50LndyaXRlKCdQQVNTJykiIGRlZmVyPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2RlZmVyLmpzIGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2RlZmVyLmpz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9y ZXNvdXJjZXMvZGVmZXIuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRlZmVyIik7CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZXh0 ZXJuYWwuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvZXh0ZXJuYWwuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRl MWVhNDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcwpAQCAtMCwwICsxIEBACitkZWJ1Zygi ZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uYzBkNjk1NDAxNjJmOWFkN2NhYjFmMDIwNzZkZjgxYjE5NzE3YmQ5MAotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNl cy9zaG91bGRub3RleGVjdXRlLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJGQUlMIik7CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlw dC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0 LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0 LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5hbC1zY3Jp cHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVhNDQ3N2Vm OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIpOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQt ZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZmYmU3 YTFjNDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJh Y2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJnZXRDb21w dXRlZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10iLCAicmdiKDI1NSwg MCwgMCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jl c291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4 NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAg KzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQv amF2YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7 XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9z bG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zbG93LXN0eWxlc2hlZXQuY2dpCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjZGRjYTQwMWY4YWIzYTZhNWRmODcz YTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisj IS91c3IvYmluL3BlcmwgLXcKKworcHJpbnQgIkNvbnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsK K3NsZWVwKDAuNSk7CitwcmludCAiYm9keSB7IGJhY2tncm91bmQtY29sb3I6ICNGRjAwMDAgfVxu IjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIt YWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi41MjQ1NzYzZDg1MTMyMDIxNDEyMzYyMzcwZmY2MTEyYzg2ZDQ2ZDcwCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1h ZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMg dGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1dGVzIGJlZm9yZSBkZWZl cnJlZCBzY3JpcHRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBB U1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKK1BBU1MgZ2V0Q29t cHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvciddIGlzICJyZ2IoMjU1 LCAwLCAwKSIKK0RPTUNvbnRlbnRMb2FkZWQKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRy dWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5lMDU2MTIxZDc0NThhY2E4MmE2MDVlNTVkMzc2YmJhNmI1ZmVlOWZlCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZl ci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApAQCAtMCwwICsxLDMwIEBACis8IURPQ1RZUEUg SFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1l dGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9 dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVz b3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkdmkg aWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlw dCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBh biBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRz LicpOworCit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlz dGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRl bnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rlc3QoKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0Pgor Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Njcmlw dC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMiIGRlZmVyPSJkZWZlciI+PC9zY3JpcHQ+Cis8bGlu ayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291 cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4KKzxzY3JpcHQ+Cit2YXIgc3VjY2Vzc2Z1bGx5UGFy c2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3Vy Y2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0 Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmJmY2FhNmU5MjQ1NDZiY2I5NGY0OGZlMWYzZjYzNzM0YWU1MTUyNjUKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVy LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDggQEAKK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVj dXRpb24gb3JkZXIgb2Ygc2NyaXB0cyB3aXRoIHRoZSBkZWZlciBhdHRyaWJ1dGUgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNzEwLgorZXh0ZXJuYWwKK2lubGluZQor c2xvd0RlZmVyCitkZWZlcgorRE9NQ29udGVudExvYWRlZAorbG9hZAorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVjZjhiMzUw NzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2MzMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbApAQCAtMCwwICsxLDI0IEBA Cis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4K KzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0 bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4u L2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8 Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgorVGhpcyB0ZXN0cyBmb3IgcHJvcGVyIGV4ZWN1 dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSA8YSBocmVmPSJo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMDwvYT4uCis8ZGl2IGlkPSJjb25zb2xl Ij48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZG9jdW1lbnQuYWRk RXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkgeworICBkZWJ1Zygn RE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0i aHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNn aSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4x OjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzIiBkZWZlcj0iREVGRVIiPjwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9l eHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2RlYnVnKCJpbmxpbmUiKTsK Kzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9BbmRyb2lk Lm1rIGIvV2ViQ29yZS9BbmRyb2lkLm1rCmluZGV4IDRiNTVhNDY0MjY1Yjc3MWEyYWU3ODAwNjY4 Zjc1YmRhYzAyN2YzMDIuLmNjMWQ2OGM5ZDRlN2E3ZjNiNTYwNWM5OGMzYzM1ZjNhYTNlMTJkZTIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQW5kcm9pZC5taworKysgYi9XZWJDb3JlL0FuZHJvaWQubWsK QEAgLTE3MCw2ICsxNzAsNyBAQCBMT0NBTF9TUkNfRklMRVMgOj0gJChMT0NBTF9TUkNfRklMRVMp IFwKIAlkb20vU2NyaXB0YWJsZURvY3VtZW50UGFyc2VyLmNwcCBcCiAJZG9tL1NjcmlwdEVsZW1l bnQuY3BwIFwKIAlkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHAgXAorCWRvbS9TY3JpcHRS dW5uZXIuY3BwIFwKIAlkb20vU2VsZWN0RWxlbWVudC5jcHAgXAogCWRvbS9TZWxlY3Rvck5vZGVM aXN0LmNwcCBcCiAJZG9tL1NwYWNlU3BsaXRTdHJpbmcuY3BwIFwKZGlmZiAtLWdpdCBhL1dlYkNv cmUvQ01ha2VMaXN0cy50eHQgYi9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CmluZGV4IDVhN2I5OWI0 MGQ5MGIzYzQ2MDFkNjY0ODNjNzFkZmVmN2Y4MzlkMDUuLmFlYTE0YzAzZGQxZGE3MmIxNTZhNTdi NzE0ZWMzMGE1ZmRhOTI2OTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKKysr IGIvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtODQ3LDYgKzg0Nyw3IEBAIFNFVChXZWJDb3Jl X1NPVVJDRVMKICAgICBkb20vU2NyaXB0YWJsZURvY3VtZW50UGFyc2VyLmNwcAogICAgIGRvbS9T Y3JpcHRFbGVtZW50LmNwcAogICAgIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcAorICAg IGRvbS9TY3JpcHRSdW5uZXIuY3BwCiAgICAgZG9tL1NlbGVjdEVsZW1lbnQuY3BwCiAgICAgZG9t L1NlbGVjdG9yTm9kZUxpc3QuY3BwCiAgICAgZG9tL1NwYWNlU3BsaXRTdHJpbmcuY3BwCmRpZmYg LS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDcyYWMx MmI2NTA0Y2RhZTAyNmMyODM0ZjY4NTU3M2YwM2IyMGU5NTguLmUyY2ZlNGU4ZmZmYjJiYWEzZDNi MDViNmQxZmYxOTk0ZTI1ODY4NzEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBi L1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzIgQEAKKzIwMTAtMDgtMDkgIFRvbnkgR2Vu dGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3JpcHQgZGVmZXI+IGFzIHNwZWNpZmll ZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9NDA5MzQKKworICAgICAgICBUZXN0czogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItaW5saW5lLXNjcmlwdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLmh0bWwKKyAgICAgICAg ICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKKyAgICAg ICAgICAgICAgIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNo ZWV0Lmh0bWwKKyAgICAgICAgICAgICAgIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRt bAorCisgICAgICAgICogQW5kcm9pZC5tazoKKyAgICAgICAgKiBDTWFrZUxpc3RzLnR4dDoKKyAg ICAgICAgKiBHTlVtYWtlZmlsZS5hbToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAg ICogV2ViQ29yZS5wcm86CisgICAgICAgICogV2ViQ29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2o6 CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAq IGRvbS9EZWZlcnJlZFNjcmlwdFJ1bm5lci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6 RGVmZXJyZWRTY3JpcHRSdW5uZXI6OkRlZmVycmVkU2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdl YkNvcmU6OkRlZmVycmVkU2NyaXB0UnVubmVyOjphZGRTY3JpcHQpOgorICAgICAgICAoV2ViQ29y ZTo6RGVmZXJyZWRTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdHMpOgorICAgICAgICAoV2ViQ29yZTo6 RGVmZXJyZWRTY3JpcHRSdW5uZXI6OndhdGNoRm9yTG9hZCk6CisgICAgICAgIChXZWJDb3JlOjpE ZWZlcnJlZFNjcmlwdFJ1bm5lcjo6c3RvcFdhdGNoaW5nRm9yTG9hZCk6CisgICAgICAgIChXZWJD b3JlOjpEZWZlcnJlZFNjcmlwdFJ1bm5lcjo6c2hvdWxkTG9hZEV4dGVybmFsU2NyaXB0RnJvbVNy Yyk6CisgICAgICAgIChXZWJDb3JlOjpEZWZlcnJlZFNjcmlwdFJ1bm5lcjo6bm90aWZ5RmluaXNo ZWQpOgorICAgICAgICAqIGRvbS9EZWZlcnJlZFNjcmlwdFJ1bm5lci5oOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OkRlZmVycmVkU2NyaXB0UnVubmVyOjpjcmVhdGUpOgorICAgICAgICAoV2Vi Q29yZTo6RGVmZXJyZWRTY3JpcHRSdW5uZXI6On5EZWZlcnJlZFNjcmlwdFJ1bm5lcik6CisgICAg ICAgICogZG9tL0RvY3VtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpEb2N1 bWVudCk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZmluaXNoZWRQYXJzaW5nKToKKyAg ICAgICAgKFdlYkNvcmU6OkRvY3VtZW50OjpydW5EZWZlcnJlZFNjcmlwdHMpOgorICAgICAgICAo V2ViQ29yZTo6RG9jdW1lbnQ6OmRpc3BhdGNoRE9NQ29udGVudExvYWRlZCk6CisgICAgICAgICog ZG9tL0RvY3VtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6ZGVmZXJyZWRTY3Jp cHRSdW5uZXIpOgorICAgICAgICAqIGRvbS9QZW5kaW5nU2NyaXB0Lmg6CisgICAgICAgIChXZWJD b3JlOjpQZW5kaW5nU2NyaXB0OjpQZW5kaW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OlBl bmRpbmdTY3JpcHQ6Om9wZXJhdG9yPSk6CisgICAgICAgIChXZWJDb3JlOjpQZW5kaW5nU2NyaXB0 OjpzZXRTdGFydGluZ0xpbmVOdW1iZXIpOgorICAgICAgICAqIGRvbS9TY3JpcHRSdW5uZXIuY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OmRvY3VtZW50VVJMRm9yU2NyaXB0RXhlY3V0aW9u KToKKyAgICAgICAgKFdlYkNvcmU6OmNyZWF0ZVNjcmlwdExvYWRFdmVudCk6CisgICAgICAgIChX ZWJDb3JlOjpjcmVhdGVTY3JpcHRFcnJvckV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlw dFJ1bm5lcjo6U2NyaXB0UnVubmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdFJ1bm5lcjo6 c291cmNlRnJvbVBlbmRpbmdTY3JpcHQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0UnVubmVy OjpyZXF1ZXN0U2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdFJ1bm5lcjo6ZXhlY3V0 ZVNjcmlwdEFuZERpc3BhdGNoRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0UnVubmVy OjpleGVjdXRlU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdFJ1bm5lcjo6d2F0Y2hG b3JMb2FkKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdFJ1bm5lcjo6c3RvcFdhdGNoaW5nRm9y TG9hZCk6CisgICAgICAgICogZG9tL1NjcmlwdFJ1bm5lci5oOiBBZGRlZC4KKyAgICAgICAgKFdl YkNvcmU6OlNjcmlwdFJ1bm5lcjo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdFJ1 bm5lcjo6flNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJDb3JlOjpTY3JpcHRSdW5uZXI6OmRv Y3VtZW50KToKKyAgICAgICAgKiBkb20vU2NyaXB0UnVubmVySG9zdC5oOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OlNjcmlwdFJ1bm5lckhvc3Q6On5TY3JpcHRSdW5uZXJIb3N0KToKKyAgICAg ICAgKiBodG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNj cmlwdFJ1bm5lcjo6SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2Ny aXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2Ny aXB0UnVubmVyOjpleGVjdXRlUGVuZGluZ1NjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpyZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdCk6CisgICAgICAgICogaHRtbC9IVE1M U2NyaXB0UnVubmVyLmg6CisgICAgICAgICogaHRtbC9IVE1MU2NyaXB0UnVubmVySG9zdC5oOgor CiAyMDEwLTA4LTA5ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5h bSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggZjQxYWIzYmVhZTY3MzgxMzQ5M2Y1MGQ0 Y2Q1MzE5N2U1ZTc5ZTU3MS4uZTM5MDBlZDllYWU5NjI0NTE1MTc3NTg2MjY1NDAxYTlmNTkxMzY1 NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1h a2VmaWxlLmFtCkBAIC0xMTQ0LDYgKzExNDQsOSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdl YkNvcmUvZG9tL1NjcmlwdEVsZW1lbnQuaCBcCiAJV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5jcHAgXAogCVdlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCBcCisJ V2ViQ29yZS9kb20vU2NyaXB0UnVubmVyLmNwcCBcCisJV2ViQ29yZS9kb20vU2NyaXB0UnVubmVy LmggXAorCVdlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lckhvc3QuaCBcCiAJV2ViQ29yZS9kb20vU2Vs ZWN0RWxlbWVudC5jcHAgXAogCVdlYkNvcmUvZG9tL1NlbGVjdEVsZW1lbnQuaCBcCiAJV2ViQ29y ZS9kb20vU2VsZWN0b3JOb2RlTGlzdC5jcHAgXApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkgYi9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCA3NjQ3OWUzZTVjZjhiYTgwNjAyMGY5 Y2EwYmEzMjYxYTVkMzU2Yjg2Li5mZjI5NDgxODJmMWY5NDkxZjBjMzkzMzY3ZWQwYzc2OWY2ZDNh Y2FlIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9XZWJDb3JlL1dlYkNv cmUuZ3lwaQpAQCAtMTI0Nyw2ICsxMjQ3LDkgQEAKICAgICAgICAgICAgICdkb20vU2NyaXB0RWxl bWVudC5oJywKICAgICAgICAgICAgICdkb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHAnLAog ICAgICAgICAgICAgJ2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmgnLAorICAgICAgICAgICAg J2RvbS9TY3JpcHRSdW5uZXIuY3BwJywKKyAgICAgICAgICAgICdkb20vU2NyaXB0UnVubmVyLmgn LAorICAgICAgICAgICAgJ2RvbS9TY3JpcHRSdW5uZXJIb3N0LmgnLAogICAgICAgICAgICAgJ2Rv bS9TZWxlY3RFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAnZG9tL1NlbGVjdEVsZW1lbnQuaCcs CiAgICAgICAgICAgICAnZG9tL1NlbGVjdG9yTm9kZUxpc3QuY3BwJywKZGlmZiAtLWdpdCBhL1dl YkNvcmUvV2ViQ29yZS5wcm8gYi9XZWJDb3JlL1dlYkNvcmUucHJvCmluZGV4IDUxM2RiM2JiNDkz MTFkNTAzMTBiN2IzMjE2Y2E2YWRlM2U4MDhmNzkuLjY3Yzk2ZGNlMjRlMzY2NGMyNjk3YjUyMjJj YWYwZjVlNWZkNTNiMmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvV2Vi Q29yZS9XZWJDb3JlLnBybwpAQCAtNTM5LDYgKzUzOSw3IEBAIFNPVVJDRVMgKz0gXAogICAgIGRv bS9TY3JpcHRhYmxlRG9jdW1lbnRQYXJzZXIuY3BwIFwKICAgICBkb20vU2NyaXB0RWxlbWVudC5j cHAgXAogICAgIGRvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcCBcCisgICAgZG9tL1Njcmlw dFJ1bm5lci5jcHAgXAogICAgIGRvbS9TZWxlY3RFbGVtZW50LmNwcCBcCiAgICAgZG9tL1NlbGVj dG9yTm9kZUxpc3QuY3BwIFwKICAgICBkb20vU3BhY2VTcGxpdFN0cmluZy5jcHAgXApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvaiBiL1dlYkNvcmUvV2Vi Q29yZS52Y3Byb2ovV2ViQ29yZS52Y3Byb2oKaW5kZXggYmNiOTY4OTdlYmRhYjVjMjhjNDAyYjAy MDY1YTFhYzRiMzUyZTZhOS4uMWRjYWUzYjUxYWY1ZjA3NWMzM2EwODU4Zjc4YzhlMzA5YjE4NmU3 NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnZjcHJvai9XZWJDb3JlLnZjcHJvagorKysg Yi9XZWJDb3JlL1dlYkNvcmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCkBAIC0zMzIwOSw2ICszMzIw OSwxOCBAQAogCQkJCT4NCiAJCQk8L0ZpbGU+DQogCQkJPEZpbGUNCisJCQkJUmVsYXRpdmVQYXRo PSIuLlxkb21cU2NyaXB0UnVubmVyLmNwcCINCisJCQkJPg0KKwkJCTwvRmlsZT4NCisJCQk8Rmls ZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRvbVxTY3JpcHRSdW5uZXIuaCINCisJCQkJPg0KKwkJ CTwvRmlsZT4NCisJCQk8RmlsZQ0KKwkJCQlSZWxhdGl2ZVBhdGg9Ii4uXGRvbVxTY3JpcHRSdW5u ZXJIb3N0LmgiDQorCQkJCT4NCisJCQk8L0ZpbGU+DQorCQkJPEZpbGUNCiAJCQkJUmVsYXRpdmVQ YXRoPSIuLlxkb21cU2VsZWN0RWxlbWVudC5jcHAiDQogCQkJCT4NCiAJCQk8L0ZpbGU+DQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9XZWJD b3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBiMDY5MzZkMjQ4ZGQ3 YjA0MjBmNDI3ZTNiYWI5YTEzNDMzZmRiZWEyLi5kMjc0ZjFmNzUxZDE4MmZlZWE4ZDhhNTU5NThk Zjg1MjU1NjY5OTAyIDEwMDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvagorKysgYi9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agpAQCAtMjM3MCw4ICsyMzcwLDExIEBACiAJCTg5Q0QwMjkzMTFDODVCODcwMDcwQjc5MSAvKiBK U0Jsb2JCdWlsZGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDg5Q0QwMjkxMTFDODVCODcwMDcwQjc5MSAvKiBKU0Jsb2JCdWlsZGVyLmNwcCAqLzsg fTsKIAkJODlDRDAyOTQxMUM4NUI4NzAwNzBCNzkxIC8qIEpTQmxvYkJ1aWxkZXIuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDg5Q0QwMjkyMTFDODVCODcw MDcwQjc5MSAvKiBKU0Jsb2JCdWlsZGVyLmggKi87IH07CiAJCThBMTJFMzVEMTFGQTMzMjgwMDI1 ODM2QSAvKiBEb2N1bWVudExvYWRUaW1pbmcuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDhBMTJFMzVDMTFGQTMzMjgwMDI1ODM2QSAvKiBEb2N1bWVudExv YWRUaW1pbmcuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OworCQk4QTIzMDU4NDEyMENFNkRDMDA5MDI4NEYgLyogU2NyaXB0UnVubmVySG9zdC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEEyMzA1ODMxMjBDRTZE QzAwOTAyODRGIC8qIFNjcmlwdFJ1bm5lckhvc3QuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk4QTQxM0FFMDEyMDdCQkE1MDA4MjAxNkUgLyogQXN5 bmNTY3JpcHRSdW5uZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDhBNDEzQURFMTIwN0JCQTUwMDgyMDE2RSAvKiBBc3luY1NjcmlwdFJ1bm5lci5oICov OyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCThBNDEzQUUx MTIwN0JCQTUwMDgyMDE2RSAvKiBBc3luY1NjcmlwdFJ1bm5lci5jcHAgaW4gU291cmNlcyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTQxM0FERjEyMDdCQkE1MDA4MjAxNkUg LyogQXN5bmNTY3JpcHRSdW5uZXIuY3BwICovOyB9OworCQk4QTYxNTkwRTEyMENGNDc3MDA4QTUx QjYgLyogRGVmZXJyZWRTY3JpcHRSdW5uZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDhBNjE1OTBEMTIwQ0Y0NzcwMDhBNTFCNiAvKiBEZWZlcnJlZFNj cmlwdFJ1bm5lci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CisJCThBNjE1OTEwMTIwQ0Y0OEIwMDhBNTFCNiAvKiBEZWZlcnJlZFNjcmlwdFJ1bm5lci5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTYxNTkw RjEyMENGNDhCMDA4QTUxQjYgLyogRGVmZXJyZWRTY3JpcHRSdW5uZXIuY3BwICovOyB9OwogCQk4 QTdDQzk2QjEyMDc2RDczMDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEE3Q0M5NkExMjA3NkQ3MzAwMUQ0NTg4 IC8qIFBlbmRpbmdTY3JpcHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRl LCApOyB9OyB9OwogCQk4QTdDQzk3MDEyMDc2RjhBMDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTdDQzk2 RjEyMDc2RjhBMDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5jcHAgKi87IH07CiAJCThBODFCRjg1 MTFEQ0ZEOTAwMERBMkI5OCAvKiBSZXNvdXJjZUxvYWRUaW1pbmcuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBODFCRjg0MTFEQ0ZEOTAwMERBMkI5OCAv KiBSZXNvdXJjZUxvYWRUaW1pbmcuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2 YXRlLCApOyB9OyB9OwpAQCAtMjM4Myw2ICsyMzg2LDggQEAKIAkJOEE5QTU4NzUxMUU4NEM4MTAw OEFDRkQxIC8qIEpTUGVyZm9ybWFuY2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDhBOUE1ODczMTFFODRDODEwMDhBQ0ZEMSAvKiBKU1BlcmZvcm1hbmNl LmggKi87IH07CiAJCThBOUE1ODg3MTFFODRGMzcwMDhBQ0ZEMSAvKiBKU1RpbWluZy5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTlBNTg3NjExRTg0 Qzk4MDA4QUNGRDEgLyogSlNUaW1pbmcuY3BwICovOyB9OwogCQk4QTlBNTg4ODExRTg0RjM3MDA4 QUNGRDEgLyogSlNUaW1pbmcuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDhBOUE1ODc3MTFFODRDOTgwMDhBQ0ZEMSAvKiBKU1RpbWluZy5oICovOyB9Owor CQk4QUJFNEM2MjEyMEUxNzNDMDBENkZCRDUgLyogU2NyaXB0UnVubmVyLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QUJFNEM2MTEyMEUxNzNDMDBENkZC RDUgLyogU2NyaXB0UnVubmVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKKwkJOEFCRTRDNjQxMjBFMTc1MTAwRDZGQkQ1IC8qIFNjcmlwdFJ1bm5lci5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QUJFNEM2 MzEyMEUxNzUxMDBENkZCRDUgLyogU2NyaXB0UnVubmVyLmNwcCAqLzsgfTsKIAkJOEFGNEU1NTUx MURDNUEzNjAwMEVEM0RFIC8qIE5hdmlnYXRpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEFGNEU1NTIxMURDNUEzNjAwMEVEM0RFIC8qIE5hdmln YXRpb24uY3BwICovOyB9OwogCQk4QUY0RTU1NjExREM1QTM2MDAwRUQzREUgLyogTmF2aWdhdGlv bi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEFGNEU1 NTMxMURDNUEzNjAwMEVEM0RFIC8qIE5hdmlnYXRpb24uaCAqLzsgfTsKIAkJOEFGNEU1NUIxMURD NUE2MzAwMEVEM0RFIC8qIFRpbWluZy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA4QUY0RTU1ODExREM1QTYzMDAwRUQzREUgLyogVGltaW5nLmNwcCAq LzsgfTsKQEAgLTgxODgsOCArODE5MywxMSBAQAogCQk4OUNEMDI5MTExQzg1Qjg3MDA3MEI3OTEg LyogSlNCbG9iQnVpbGRlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGgg PSBKU0Jsb2JCdWlsZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJODlDRDAy OTIxMUM4NUI4NzAwNzBCNzkxIC8qIEpTQmxvYkJ1aWxkZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuYy5oOyBwYXRoID0gSlNCbG9iQnVpbGRlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk4QTEyRTM1QzExRkEzMzI4MDAyNTgzNkEgLyogRG9jdW1lbnRMb2FkVGltaW5nLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IERvY3VtZW50TG9hZFRpbWluZy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4QTIzMDU4MzEyMENFNkRDMDA5MDI4NEYgLyogU2Ny aXB0UnVubmVySG9zdC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBTY3JpcHRS dW5uZXJIb3N0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThBNDEzQURFMTIwN0JC QTUwMDgyMDE2RSAvKiBBc3luY1NjcmlwdFJ1bm5lci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBBc3luY1NjcmlwdFJ1bm5lci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQk4QTQxM0FERjEyMDdCQkE1MDA4MjAxNkUgLyogQXN5bmNTY3JpcHRSdW5uZXIuY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQXN5bmNTY3JpcHRSdW5uZXIuY3Bw OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk4QTYxNTkwRDEyMENGNDc3MDA4QTUxQjYg LyogRGVmZXJyZWRTY3JpcHRSdW5uZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gRGVmZXJyZWRTY3JpcHRSdW5uZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ OEE2MTU5MEYxMjBDRjQ4QjAwOEE1MUI2IC8qIERlZmVycmVkU2NyaXB0UnVubmVyLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IERlZmVycmVkU2NyaXB0UnVubmVyLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEE3Q0M5NkExMjA3NkQ3MzAwMUQ0NTg4 IC8qIFBlbmRpbmdTY3JpcHQuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGVu ZGluZ1NjcmlwdC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk4QTdDQzk2RjEyMDc2 RjhBMDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBQZW5kaW5nU2NyaXB0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJOEE4MUJGODQxMURDRkQ5MDAwREEyQjk4IC8qIFJlc291cmNlTG9hZFRpbWluZy5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZXNvdXJjZUxvYWRUaW1pbmcuaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTgyMDIsNiArODIxMCw4IEBACiAJCThBOUE1ODcz MTFFODRDODEwMDhBQ0ZEMSAvKiBKU1BlcmZvcm1hbmNlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IEpTUGVyZm9ybWFuY2UuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJOEE5QTU4NzYxMUU4NEM5ODAwOEFDRkQxIC8qIEpTVGltaW5nLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTVGltaW5nLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJOEE5QTU4NzcxMUU4NEM5ODAwOEFDRkQxIC8qIEpTVGltaW5nLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTVGltaW5nLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCThBQkU0QzYxMTIwRTE3M0MwMEQ2RkJENSAvKiBTY3JpcHRSdW5uZXIuaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gU2NyaXB0UnVubmVyLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCThBQkU0QzYzMTIwRTE3NTEwMEQ2RkJENSAvKiBTY3JpcHRS dW5uZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gU2NyaXB0UnVu bmVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOEFGNEU1NTIxMURDNUEzNjAw MEVEM0RFIC8qIE5hdmlnYXRpb24uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gTmF2aWdhdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCThBRjRF NTUzMTFEQzVBMzYwMDBFRDNERSAvKiBOYXZpZ2F0aW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IE5hdmlnYXRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ OEFGNEU1NTQxMURDNUEzNjAwMEVEM0RFIC8qIE5hdmlnYXRpb24uaWRsICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4 dDsgcGF0aCA9IE5hdmlnYXRpb24uaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt MTcxNzgsNiArMTcxODgsOCBAQAogCQkJCUJDNjQ2NDFBMTFEN0Y0MTYwMDY0NTVCMCAvKiBEYXRh c2V0RE9NU3RyaW5nTWFwLmggKi8sCiAJCQkJQThDMjI4QTAxMUQ1NzIyRTAwRDVBN0QzIC8qIERl Y29kZWREYXRhRG9jdW1lbnRQYXJzZXIuY3BwICovLAogCQkJCUE4QzIyODlGMTFENTcyMkUwMEQ1 QTdEMyAvKiBEZWNvZGVkRGF0YURvY3VtZW50UGFyc2VyLmggKi8sCisJCQkJOEE2MTU5MEYxMjBD RjQ4QjAwOEE1MUI2IC8qIERlZmVycmVkU2NyaXB0UnVubmVyLmNwcCAqLywKKwkJCQk4QTYxNTkw RDEyMENGNDc3MDA4QTUxQjYgLyogRGVmZXJyZWRTY3JpcHRSdW5uZXIuaCAqLywKIAkJCQkzMUZC MUE0RjEyMEE1RDA2MDBEQzAyQTAgLyogRGV2aWNlTW90aW9uQ2xpZW50LmggKi8sCiAJCQkJMzFG QjFBNTAxMjBBNUQwNjAwREMwMkEwIC8qIERldmljZU1vdGlvbkNvbnRyb2xsZXIuY3BwICovLAog CQkJCTMxRkIxQTUxMTIwQTVEMDYwMERDMDJBMCAvKiBEZXZpY2VNb3Rpb25Db250cm9sbGVyLmgg Ki8sCkBAIC0xNzM0NCw2ICsxNzM1Niw5IEBACiAJCQkJMDhBNDg0NzYwRTUyNzJDNTAwQzNGRTc2 IC8qIFNjcmlwdEVsZW1lbnQuaCAqLywKIAkJCQlFMTFDOURBRjBFQjM2OTk1MDBFNDA5REIgLyog U2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHAgKi8sCiAJCQkJRTExQzlEOUEwRUIzNjgxMjAwRTQw OURCIC8qIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQuaCAqLywKKwkJCQk4QUJFNEM2MzEyMEUxNzUx MDBENkZCRDUgLyogU2NyaXB0UnVubmVyLmNwcCAqLywKKwkJCQk4QUJFNEM2MTEyMEUxNzNDMDBE NkZCRDUgLyogU2NyaXB0UnVubmVyLmggKi8sCisJCQkJOEEyMzA1ODMxMjBDRTZEQzAwOTAyODRG IC8qIFNjcmlwdFJ1bm5lckhvc3QuaCAqLywKIAkJCQkwODRBRUJFMjBGQjUwNUZBMDAzODQ4M0Ug LyogU2VsZWN0RWxlbWVudC5jcHAgKi8sCiAJCQkJMDg0QUVCRTMwRkI1MDVGQTAwMzg0ODNFIC8q IFNlbGVjdEVsZW1lbnQuaCAqLywKIAkJCQlCQzdGQTY4MDBEMUYxNjc5MDBEQjIyQTkgLyogU2Vs ZWN0b3JOb2RlTGlzdC5jcHAgKi8sCkBAIC0yMDEzMyw2ICsyMDE0OCw5IEBACiAJCQkJRTFCRTUx MkUwQ0Y2QzUxMjAwMkVBOTU5IC8qIFhTTFRVbmljb2RlU29ydC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJOTdERDREODcwRkRGNEQ2RTAwRUNGOUE0IC8qIFhTU0F1ZGl0b3IuaCBpbiBIZWFkZXJzICov LAogCQkJCUNFMTcyRTAxMTEzNkU4Q0UwMDYyQTUzMyAvKiBab29tTW9kZS5oIGluIEhlYWRlcnMg Ki8sCisJCQkJOEEyMzA1ODQxMjBDRTZEQzAwOTAyODRGIC8qIFNjcmlwdFJ1bm5lckhvc3QuaCBp biBIZWFkZXJzICovLAorCQkJCThBNjE1OTBFMTIwQ0Y0NzcwMDhBNTFCNiAvKiBEZWZlcnJlZFNj cmlwdFJ1bm5lci5oIGluIEhlYWRlcnMgKi8sCisJCQkJOEFCRTRDNjIxMjBFMTczQzAwRDZGQkQ1 IC8qIFNjcmlwdFJ1bm5lci5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRl cGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0yMjU1NCw2ICsyMjU3Miw4IEBA CiAJCQkJOTNGMTlCMDUwODI0NUU1OTAwMUU5QUJDIC8qIFhTTFRQcm9jZXNzb3JMaWJ4c2x0LmNw cCBpbiBTb3VyY2VzICovLAogCQkJCUUxQkU1MTJEMENGNkM1MTIwMDJFQTk1OSAvKiBYU0xUVW5p Y29kZVNvcnQuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJOTdERDREODYwRkRGNEQ2RTAwRUNGOUE0 IC8qIFhTU0F1ZGl0b3IuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOEE2MTU5MTAxMjBDRjQ4QjAw OEE1MUI2IC8qIERlZmVycmVkU2NyaXB0UnVubmVyLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCThB QkU0QzY0MTIwRTE3NTEwMEQ2RkJENSAvKiBTY3JpcHRSdW5uZXIuY3BwIGluIFNvdXJjZXMgKi8s CiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9EZWZlcnJlZFNjcmlwdFJ1bm5lci5jcHAgYi9XZWJD b3JlL2RvbS9EZWZlcnJlZFNjcmlwdFJ1bm5lci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjk0NGVhZjBlNGE1 MjRiZjU3OTRlMTgyZDVkMzNlMjA2MjAxZWVhMQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv ZG9tL0RlZmVycmVkU2NyaXB0UnVubmVyLmNwcApAQCAtMCwwICsxLDk3IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIEdvb2dsZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIkRlZmVycmVkU2NyaXB0UnVubmVyLmgiCisKKyNpbmNsdWRlICJDYWNoZWRS ZXNvdXJjZS5oIgorI2luY2x1ZGUgIkNhY2hlZFNjcmlwdC5oIgorI2luY2x1ZGUgIkVsZW1lbnQu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitEZWZlcnJlZFNjcmlwdFJ1bm5lcjo6RGVmZXJy ZWRTY3JpcHRSdW5uZXIoRG9jdW1lbnQqIGRvY3VtZW50KQorICAgIDogbV9ydW5uZXIoU2NyaXB0 UnVubmVyOjpjcmVhdGUoZG9jdW1lbnQsIHRoaXMpKQoreworfQorCisKK3ZvaWQgRGVmZXJyZWRT Y3JpcHRSdW5uZXI6OmFkZFNjcmlwdChFbGVtZW50KiBzY3JpcHRFbGVtZW50LCBjb25zdCBBdG9t aWNTdHJpbmcmIHNvdXJjZVVSTCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7 CisgICAgaWYgKCFtX3J1bm5lci0+cmVxdWVzdFNjcmlwdChwZW5kaW5nU2NyaXB0LCBzb3VyY2VV UkwsIHNjcmlwdEVsZW1lbnQpKQorICAgICAgICByZXR1cm47CisKKyAgICBBU1NFUlQocGVuZGlu Z1NjcmlwdC5jYWNoZWRTY3JpcHQoKSk7CisgICAgbV9wZW5kaW5nU2NyaXB0cy5hcHBlbmQocGVu ZGluZ1NjcmlwdCk7Cit9CisKK2Jvb2wgRGVmZXJyZWRTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdHMo KQoreworICAgIHdoaWxlICghbV9wZW5kaW5nU2NyaXB0cy5pc0VtcHR5KCkpIHsKKyAgICAgICAg QVNTRVJUKG1fcGVuZGluZ1NjcmlwdHMuZmlyc3QoKS5jYWNoZWRTY3JpcHQoKSk7CisgICAgICAg IGlmICghbV9wZW5kaW5nU2NyaXB0cy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgp KSB7CisgICAgICAgICAgICBtX3J1bm5lci0+d2F0Y2hGb3JMb2FkKG1fcGVuZGluZ1NjcmlwdHMu Zmlyc3QoKSk7CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKyAgICAgICAg UGVuZGluZ1NjcmlwdCBmaXJzdCA9IG1fcGVuZGluZ1NjcmlwdHMudGFrZUZpcnN0KCk7CisgICAg ICAgIG1fcnVubmVyLT5leGVjdXRlU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChmaXJzdCk7CisgICAg fQorICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIERlZmVycmVkU2NyaXB0UnVubmVyOjp3YXRj aEZvckxvYWQoQ2FjaGVkUmVzb3VyY2UqIGNhY2hlZFJlc291cmNlKQoreworICAgIEFTU0VSVCgh Y2FjaGVkUmVzb3VyY2UtPmlzTG9hZGVkKCkpOworICAgIC8vIGFkZENsaWVudCB3b3VsZCBjYWxs IG5vdGlmeUZpbmlzaGVkIGlmIHRoZSBsb2FkIHdlcmUgY29tcGxldGUuCisgICAgLy8gQ2FsbGVy cyBkbyBub3QgZXhwZWN0IHRvIGJlIHJlLWVudGVyZWQgZnJvbSB0aGlzIGNhbGwsIHNvIHRoZXkg c2hvdWxkCisgICAgLy8gbm90IGFuIGFscmVhZHktbG9hZGVkIENhY2hlZFJlc291cmNlLgorICAg IGNhY2hlZFJlc291cmNlLT5hZGRDbGllbnQodGhpcyk7Cit9CisKK3ZvaWQgRGVmZXJyZWRTY3Jp cHRSdW5uZXI6OnN0b3BXYXRjaGluZ0ZvckxvYWQoQ2FjaGVkUmVzb3VyY2UqIGNhY2hlZFJlc291 cmNlKQoreworICAgIGNhY2hlZFJlc291cmNlLT5yZW1vdmVDbGllbnQodGhpcyk7Cit9CisKK2Jv b2wgRGVmZXJyZWRTY3JpcHRSdW5uZXI6OnNob3VsZExvYWRFeHRlcm5hbFNjcmlwdEZyb21TcmMo Y29uc3QgQXRvbWljU3RyaW5nJikKK3sKKyAgICByZXR1cm4gdHJ1ZTsgLy8gRklYTUU6IFhTU0F1 ZGl0b3IKK30KKworLy8gRklYTUU6IFBlcmhhcHMgdGhlIERvY3VtZW50IHNob3VsZCBiZSB0aGUg Q2FjaGVkUmVzb3VyY2VDbGllbnQ/Cit2b2lkIERlZmVycmVkU2NyaXB0UnVubmVyOjpub3RpZnlG aW5pc2hlZChDYWNoZWRSZXNvdXJjZSogY2FjaGVkUmVzb3VyY2UpCit7CisgICAgQVNTRVJUKCFt X3BlbmRpbmdTY3JpcHRzLmlzRW1wdHkoKSk7CisKKyAgICBjb25zdCBQZW5kaW5nU2NyaXB0JiBm aXJzdFNjcmlwdCA9IG1fcGVuZGluZ1NjcmlwdHMuZmlyc3QoKTsKKyAgICBpZiAoIWZpcnN0U2Ny aXB0LndhdGNoaW5nRm9yTG9hZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBBU1NFUlRfVU5V U0VEKGNhY2hlZFJlc291cmNlLCBjYWNoZWRSZXNvdXJjZSA9PSBmaXJzdFNjcmlwdC5jYWNoZWRT Y3JpcHQoKSk7CisgICAgbV9ydW5uZXItPmRvY3VtZW50KCktPnJ1bkRlZmVycmVkU2NyaXB0cygp OworfQorCit9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9EZWZlcnJlZFNjcmlwdFJ1bm5lci5o IGIvV2ViQ29yZS9kb20vRGVmZXJyZWRTY3JpcHRSdW5uZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yNjQ2ODFh NzM5MzUwZTM2ZDZlNDgzZWNhY2NiYmEzYTVmMzA5MTQ0Ci0tLSAvZGV2L251bGwKKysrIGIvV2Vi Q29yZS9kb20vRGVmZXJyZWRTY3JpcHRSdW5uZXIuaApAQCAtMCwwICsxLDcwIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoK KyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdp dGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmli dXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJv ZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVu dGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0 aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFT IElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUg RElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4gCisgKi8KKworI2lmbmRlZiBEZWZlcnJl ZFNjcmlwdFJ1bm5lcl9oCisjZGVmaW5lIERlZmVycmVkU2NyaXB0UnVubmVyX2gKKworI2luY2x1 ZGUgIkNhY2hlZFJlc291cmNlQ2xpZW50LmgiCisjaW5jbHVkZSAiUGVuZGluZ1NjcmlwdC5oIgor I2luY2x1ZGUgIlNjcmlwdFJ1bm5lci5oIgorI2luY2x1ZGUgIlNjcmlwdFJ1bm5lckhvc3QuaCIK KyNpbmNsdWRlIDx3dGYvRGVxdWUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCitu YW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEF0b21pY1N0cmluZzsKK2NsYXNzIENhY2hlZFJl c291cmNlOworY2xhc3MgRG9jdW1lbnQ7CitjbGFzcyBQZW5kaW5nU2NyaXB0OworCitjbGFzcyBE ZWZlcnJlZFNjcmlwdFJ1bm5lciA6IHB1YmxpYyBTY3JpcHRSdW5uZXJIb3N0LCBwdWJsaWMgQ2Fj aGVkUmVzb3VyY2VDbGllbnQgeworcHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPERlZmVy cmVkU2NyaXB0UnVubmVyPiBjcmVhdGUoRG9jdW1lbnQqIGRvY3VtZW50KSB7IHJldHVybiBuZXcg RGVmZXJyZWRTY3JpcHRSdW5uZXIoZG9jdW1lbnQpOyB9CisgICAgdmlydHVhbCB+RGVmZXJyZWRT Y3JpcHRSdW5uZXIoKQorICAgIHsKKyAgICB9CisKKyAgICB2b2lkIGFkZFNjcmlwdChFbGVtZW50 KiBzY3JpcHRFbGVtZW50LCBjb25zdCBBdG9taWNTdHJpbmcmIHNvdXJjZVVSTCk7CisgICAgYm9v bCBydW5TY3JpcHRzKCk7CisKKyAgICAvLyBTY3JpcHRSdW5uZXJIb3N0CisgICAgdmlydHVhbCB2 b2lkIHdhdGNoRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOworICAgIHZpcnR1YWwgdm9pZCBzdG9w V2F0Y2hpbmdGb3JMb2FkKENhY2hlZFJlc291cmNlKik7CisgICAgdmlydHVhbCBib29sIHNob3Vs ZExvYWRFeHRlcm5hbFNjcmlwdEZyb21TcmMoY29uc3QgQXRvbWljU3RyaW5nJik7CisKKyAgICAv LyBDYWNoZWRSZXNvdXJjZUNsaWVudAorICAgIHZpcnR1YWwgdm9pZCBub3RpZnlGaW5pc2hlZChD YWNoZWRSZXNvdXJjZSopOworCitwcml2YXRlOgorICAgIERlZmVycmVkU2NyaXB0UnVubmVyKERv Y3VtZW50KiBkb2N1bWVudCk7CisKKyAgICBPd25QdHI8U2NyaXB0UnVubmVyPiBtX3J1bm5lcjsK KyAgICBEZXF1ZTxQZW5kaW5nU2NyaXB0PiBtX3BlbmRpbmdTY3JpcHRzOworfTsKKworfQorCisj ZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1dlYkNvcmUvZG9t L0RvY3VtZW50LmNwcAppbmRleCA4ZmEyMzQ2ODUxMDUxMzk5NmQ1ZWJhZjM2OTY5ZDAwOTExNTI4 YzI4Li5iZTNmN2EzOTAyMGFiMmVmNmMyYjVjM2Y2MjhlMWU4OTJlYTFlMjMyIDEwMDY0NAotLS0g YS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3Bw CkBAIC00Myw2ICs0Myw3IEBACiAjaW5jbHVkZSAiQ29uc29sZS5oIgogI2luY2x1ZGUgIkNvb2tp ZUphci5oIgogI2luY2x1ZGUgIkN1c3RvbUV2ZW50LmgiCisjaW5jbHVkZSAiRGVmZXJyZWRTY3Jp cHRSdW5uZXIuaCIKICNpbmNsdWRlICJET01JbXBsZW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIkRP TVdpbmRvdy5oIgogI2luY2x1ZGUgIkRldmljZU1vdGlvbkV2ZW50LmgiCkBAIC0zNzUsNiArMzc2 LDcgQEAgRG9jdW1lbnQ6OkRvY3VtZW50KEZyYW1lKiBmcmFtZSwgY29uc3QgS1VSTCYgdXJsLCBi b29sIGlzWEhUTUwsIGJvb2wgaXNIVE1MKQogICAgICwgbV9vdmVyTWluaW11bUxheW91dFRocmVz aG9sZChmYWxzZSkKICAgICAsIG1fZXh0cmFMYXlvdXREZWxheSgwKQogICAgICwgbV9hc3luY1Nj cmlwdFJ1bm5lcihBc3luY1NjcmlwdFJ1bm5lcjo6Y3JlYXRlKCkpCisgICAgLCBtX2RlZmVycmVk U2NyaXB0UnVubmVyKERlZmVycmVkU2NyaXB0UnVubmVyOjpjcmVhdGUodGhpcykpCiAgICAgLCBt X3htbFZlcnNpb24oIjEuMCIpCiAgICAgLCBtX3htbFN0YW5kYWxvbmUoZmFsc2UpCiAjaWYgRU5B QkxFKFhCTCkKQEAgLTQ0NjEsOSArNDQ2MywyNiBAQCBDb2xsZWN0aW9uQ2FjaGUqIERvY3VtZW50 OjpuYW1lQ29sbGVjdGlvbkluZm8oQ29sbGVjdGlvblR5cGUgdHlwZSwgY29uc3QgQXRvbWljUwog ICAgIHJldHVybiBpdGVyLT5zZWNvbmQ7CiB9CiAKKy8vIFRoaXMga2lja3Mgb2ZmIHRoZSBiZWdp bm5pbmcgb2YgSFRNTDUncyAiVGhlIGVuZCIKKy8vIGh0dHA6Ly9kZXYudzMub3JnL2h0bWw1L3Nw ZWMvT3ZlcnZpZXcuaHRtbCN0aGUtZW5kCiB2b2lkIERvY3VtZW50OjpmaW5pc2hlZFBhcnNpbmco KQogewogICAgIHNldFBhcnNpbmcoZmFsc2UpOworICAgIHJ1bkRlZmVycmVkU2NyaXB0cygpOwor fQorCit2b2lkIERvY3VtZW50OjpydW5EZWZlcnJlZFNjcmlwdHMoKQoreworICAgIEFTU0VSVCgh cGFyc2luZygpKTsKKyAgICBpZiAoIW1fZGVmZXJyZWRTY3JpcHRSdW5uZXItPnJ1blNjcmlwdHMo KSkKKyAgICAgICAgcmV0dXJuOworICAgIEFTU0VSVCh0aGlzKTsgLy8gRklYTUU6IFdoYXQgaXMg dGhlIGJlc3Qgd2F5IHRvIGhhbmRsZSB3aGVuIHJ1blNjcmlwdHMgY29ycmVjdGx5IGJsb3dzIGF3 YXkgdGhlIGRvY3VtZW50PworICAgIGRpc3BhdGNoRE9NQ29udGVudExvYWRlZCgpOworfQorCit2 b2lkIERvY3VtZW50OjpkaXNwYXRjaERPTUNvbnRlbnRMb2FkZWQoKQoreworICAgIEFTU0VSVCgh cGFyc2luZygpKTsKICAgICBkaXNwYXRjaEV2ZW50KEV2ZW50OjpjcmVhdGUoZXZlbnROYW1lcygp LkRPTUNvbnRlbnRMb2FkZWRFdmVudCwgdHJ1ZSwgZmFsc2UpKTsKIAogICAgIGlmIChGcmFtZSog ZiA9IGZyYW1lKCkpIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmggYi9XZWJD b3JlL2RvbS9Eb2N1bWVudC5oCmluZGV4IGQ5YmFhOTBhZGY1OGZlYTczMjYyZTQ4YzhkMDY4NTgw ZDM4MjZhZTEuLmU4MTc3NzFkOGQ1MjM1ZjUwNWRlNTZiZTA4MDA0OWE1NmE0MzhlMGIgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvZG9tL0RvY3VtZW50LmgKKysrIGIvV2ViQ29yZS9kb20vRG9jdW1lbnQu aApAQCAtNjEsNiArNjEsNyBAQCBjbGFzcyBDU1NTdHlsZVNlbGVjdG9yOwogY2xhc3MgQ1NTU3R5 bGVTaGVldDsKIGNsYXNzIENvbW1lbnQ7CiBjbGFzcyBEYXRhYmFzZTsKK2NsYXNzIERlZmVycmVk U2NyaXB0UnVubmVyOwogY2xhc3MgRE9NSW1wbGVtZW50YXRpb247CiBjbGFzcyBET01TZWxlY3Rp b247CiBjbGFzcyBET01XaW5kb3c7CkBAIC01MzcsNiArNTM4LDggQEAgcHVibGljOgogICAgIHZv aWQgd3JpdGUoY29uc3QgU3RyaW5nJiB0ZXh0LCBEb2N1bWVudCogb3duZXJEb2N1bWVudCA9IDAp OwogICAgIHZvaWQgd3JpdGVsbihjb25zdCBTdHJpbmcmIHRleHQsIERvY3VtZW50KiBvd25lckRv Y3VtZW50ID0gMCk7CiAgICAgdm9pZCBmaW5pc2hQYXJzaW5nKCk7CisgICAgdm9pZCBydW5EZWZl cnJlZFNjcmlwdHMoKTsKKyAgICB2b2lkIGRpc3BhdGNoRE9NQ29udGVudExvYWRlZCgpOwogCiAg ICAgYm9vbCB3ZWxsRm9ybWVkKCkgY29uc3QgeyByZXR1cm4gbV93ZWxsRm9ybWVkOyB9CiAKQEAg LTg0NCw2ICs4NDcsNyBAQCBwdWJsaWM6CiAgICAgaW50IGRvY0lEKCkgY29uc3QgeyByZXR1cm4g bV9kb2NJRDsgfQogICAgIAogICAgIEFzeW5jU2NyaXB0UnVubmVyKiBhc3luY1NjcmlwdFJ1bm5l cigpIHsgcmV0dXJuIG1fYXN5bmNTY3JpcHRSdW5uZXIuZ2V0KCk7IH0KKyAgICBEZWZlcnJlZFNj cmlwdFJ1bm5lciogZGVmZXJyZWRTY3JpcHRSdW5uZXIoKSB7IHJldHVybiBtX2RlZmVycmVkU2Ny aXB0UnVubmVyLmdldCgpOyB9CiAKICNpZiBFTkFCTEUoWFNMVCkKICAgICB2b2lkIGFwcGx5WFNM VHJhbnNmb3JtKFByb2Nlc3NpbmdJbnN0cnVjdGlvbiogcGkpOwpAQCAtMTE5OSw2ICsxMjAzLDcg QEAgcHJpdmF0ZToKICAgICBpbnQgbV9leHRyYUxheW91dERlbGF5OwogICAgIAogICAgIE93blB0 cjxBc3luY1NjcmlwdFJ1bm5lcj4gbV9hc3luY1NjcmlwdFJ1bm5lcjsKKyAgICBPd25QdHI8RGVm ZXJyZWRTY3JpcHRSdW5uZXI+IG1fZGVmZXJyZWRTY3JpcHRSdW5uZXI7CiAKICNpZiBFTkFCTEUo WFNMVCkKICAgICBPd25QdHI8VHJhbnNmb3JtU291cmNlPiBtX3RyYW5zZm9ybVNvdXJjZTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1BlbmRpbmdTY3JpcHQuaCBiL1dlYkNvcmUvZG9tL1BlbmRp bmdTY3JpcHQuaAppbmRleCA4MDVmN2ZmOWVjZGZhMzQ5ZDBiNzBmZTJiNGE1MmIyYWE0NTBlYTcz Li41ZjhkMGEwZjUzMDg5ZDA1MmY1MzkzYTQ4ZjZjZGZlYWJhMjVmYmVhIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2RvbS9QZW5kaW5nU2NyaXB0LmgKKysrIGIvV2ViQ29yZS9kb20vUGVuZGluZ1Njcmlw dC5oCkBAIC0yOCw3ICsyOCw2IEBACiAKICNpbmNsdWRlICJDYWNoZWRSZXNvdXJjZUNsaWVudC5o IgogI2luY2x1ZGUgIkNhY2hlZFJlc291cmNlSGFuZGxlLmgiCi0jaW5jbHVkZSA8d3RmL05vbmNv cHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtNDEsNyArNDAsNyBAQCBjbGFzcyBFbGVtZW50OwogLy8gQSBDYWNoZWRSZXNvdXJj ZUhhbmRsZSBhbG9uZSBkb2VzIG5vdCBwcmV2ZW50IHRoZSB1bmRlcmx5aW5nIENhY2hlZFJlc291 cmNlCiAvLyBmcm9tIHB1cmdpbmcgaXRzIGRhdGEgYnVmZmVyLiBUaGlzIGNsYXNzIGhvbGRzIGEg ZHVtbXkgY2xpZW50IG9wZW4gZm9yIGl0cwogLy8gbGlmZXRpbWUgaW4gb3JkZXIgdG8gZ3VhcmFu dGVlIHRoYXQgdGhlIGRhdGEgYnVmZmVyIHdpbGwgbm90IGJlIHB1cmdlZC4KLWNsYXNzIFBlbmRp bmdTY3JpcHQgOiBwdWJsaWMgTm9uY29weWFibGUsIENhY2hlZFJlc291cmNlQ2xpZW50IHsKK2Ns YXNzIFBlbmRpbmdTY3JpcHQgOiBwdWJsaWMgQ2FjaGVkUmVzb3VyY2VDbGllbnQgewogcHVibGlj OgogICAgIFBlbmRpbmdTY3JpcHQoKQogICAgICAgICA6IG1fc3RhcnRpbmdMaW5lTnVtYmVyKDAp CkBAIC00OSwxMSArNDgsMzIgQEAgcHVibGljOgogICAgIHsKICAgICB9CiAKKyAgICBQZW5kaW5n U2NyaXB0KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgICAgICA6IENhY2hlZFJlc291 cmNlQ2xpZW50KG90aGVyKQorICAgICAgICAsIG1fc3RhcnRpbmdMaW5lTnVtYmVyKG90aGVyLm1f c3RhcnRpbmdMaW5lTnVtYmVyKQorICAgICAgICAsIG1fd2F0Y2hpbmdGb3JMb2FkKG90aGVyLm1f d2F0Y2hpbmdGb3JMb2FkKQorICAgICAgICAsIG1fZWxlbWVudChvdGhlci5tX2VsZW1lbnQpCisg ICAgeworICAgICAgICBzZXRDYWNoZWRTY3JpcHQob3RoZXIuY2FjaGVkU2NyaXB0KCkpOworICAg IH0KKwogICAgIH5QZW5kaW5nU2NyaXB0KCk7CiAKLSAgICAvLyBGSVhNRTogTm8gc2V0dGVyIG1l YW5zIHRoaXMgaXMgbmV2ZXIgc2V0IHRvIGFueXRoaW5nIG90aGVyIHRoYW4gMC4KLSAgICAvLyBU aGlzIGlzIGVpdGhlciB1bm5lY2Vzc2FyeSBvciBpbmNvcnJlY3QuCisgICAgUGVuZGluZ1Njcmlw dCYgb3BlcmF0b3I9KGNvbnN0IFBlbmRpbmdTY3JpcHQmIG90aGVyKQorICAgIHsKKyAgICAgICAg aWYgKHRoaXMgPT0gJm90aGVyKQorICAgICAgICAgICAgcmV0dXJuICp0aGlzOworCisgICAgICAg IG1fc3RhcnRpbmdMaW5lTnVtYmVyID0gb3RoZXIubV9zdGFydGluZ0xpbmVOdW1iZXI7CisgICAg ICAgIG1fd2F0Y2hpbmdGb3JMb2FkID0gb3RoZXIubV93YXRjaGluZ0ZvckxvYWQ7CisgICAgICAg IG1fZWxlbWVudCA9IG90aGVyLm1fZWxlbWVudDsKKyAgICAgICAgc2V0Q2FjaGVkU2NyaXB0KG90 aGVyLmNhY2hlZFNjcmlwdCgpKTsKKworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorCiAg ICAgaW50IHN0YXJ0aW5nTGluZU51bWJlcigpIGNvbnN0IHsgcmV0dXJuIG1fc3RhcnRpbmdMaW5l TnVtYmVyOyB9CisgICAgdm9pZCBzZXRTdGFydGluZ0xpbmVOdW1iZXIoaW50IGkpIHsgbV9zdGFy dGluZ0xpbmVOdW1iZXIgPSBpOyB9CiAKICAgICBib29sIHdhdGNoaW5nRm9yTG9hZCgpIGNvbnN0 IHsgcmV0dXJuIG1fd2F0Y2hpbmdGb3JMb2FkOyB9CiAgICAgdm9pZCBzZXRXYXRjaGluZ0Zvckxv YWQoYm9vbCBiKSB7IG1fd2F0Y2hpbmdGb3JMb2FkID0gYjsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9kb20vU2NyaXB0UnVubmVyLmNwcCBiL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lci5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uM2NiYTZmYTc3NmE3MDc5MGE5ZGI2MGJkNTMzY2Y2NmUyMTUwNTU5MwotLS0gL2Rl di9udWxsCisrKyBiL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lci5jcHAKQEAgLTAsMCArMSwxMzgg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlLCBJbmMuIEFsbCBSaWdodHMgUmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAx LiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAq ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgor ICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVP UlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiU2NyaXB0UnVubmVyLmgiCisKKyNpbmNsdWRlICJD YWNoZWRTY3JpcHQuaCIKKyNpbmNsdWRlICJEb2NMb2FkZXIuaCIKKyNpbmNsdWRlICJFbGVtZW50 LmgiCisjaW5jbHVkZSAiRXZlbnQuaCIKKyNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIk5v dEltcGxlbWVudGVkLmgiCisjaW5jbHVkZSAiUGVuZGluZ1NjcmlwdC5oIgorI2luY2x1ZGUgIlNj cmlwdEVsZW1lbnQuaCIKKyNpbmNsdWRlICJTY3JpcHRSdW5uZXJIb3N0LmgiCisjaW5jbHVkZSAi U2NyaXB0U291cmNlQ29kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0YXRpYyBLVVJM IGRvY3VtZW50VVJMRm9yU2NyaXB0RXhlY3V0aW9uKERvY3VtZW50KiBkb2N1bWVudCkKK3sKKyAg ICBpZiAoIWRvY3VtZW50IHx8ICFkb2N1bWVudC0+ZnJhbWUoKSkKKyAgICAgICAgcmV0dXJuIEtV UkwoKTsKKworICAgIC8vIFVzZSB0aGUgVVJMIG9mIHRoZSBjdXJyZW50bHkgYWN0aXZlIGRvY3Vt ZW50IGZvciB0aGlzIGZyYW1lLgorICAgIHJldHVybiBkb2N1bWVudC0+ZnJhbWUoKS0+ZG9jdW1l bnQoKS0+dXJsKCk7Cit9CisKK2lubGluZSBQYXNzUmVmUHRyPEV2ZW50PiBjcmVhdGVTY3JpcHRM b2FkRXZlbnQoKQoreworICAgIHJldHVybiBFdmVudDo6Y3JlYXRlKGV2ZW50TmFtZXMoKS5sb2Fk RXZlbnQsIGZhbHNlLCBmYWxzZSk7Cit9CisKK2lubGluZSBQYXNzUmVmUHRyPEV2ZW50PiBjcmVh dGVTY3JpcHRFcnJvckV2ZW50KCkKK3sKKyAgICByZXR1cm4gRXZlbnQ6OmNyZWF0ZShldmVudE5h bWVzKCkuZXJyb3JFdmVudCwgdHJ1ZSwgZmFsc2UpOworfQorCitTY3JpcHRSdW5uZXI6OlNjcmlw dFJ1bm5lcihEb2N1bWVudCogZG9jdW1lbnQsIFNjcmlwdFJ1bm5lckhvc3QqIGhvc3QpCisgICAg OiBtX2RvY3VtZW50KGRvY3VtZW50KQorICAgICwgbV9ob3N0KGhvc3QpCit7CisgICAgQVNTRVJU KG1faG9zdCk7Cit9CisKK1NjcmlwdFNvdXJjZUNvZGUgU2NyaXB0UnVubmVyOjpzb3VyY2VGcm9t UGVuZGluZ1NjcmlwdChjb25zdCBQZW5kaW5nU2NyaXB0JiBzY3JpcHQsIGJvb2wmIGVycm9yT2Nj dXJyZWQpIGNvbnN0Cit7CisgICAgaWYgKHNjcmlwdC5jYWNoZWRTY3JpcHQoKSkgeworICAgICAg ICBlcnJvck9jY3VycmVkID0gc2NyaXB0LmNhY2hlZFNjcmlwdCgpLT5lcnJvck9jY3VycmVkKCk7 CisgICAgICAgIEFTU0VSVChzY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlzTG9hZGVkKCkpOworICAg ICAgICByZXR1cm4gU2NyaXB0U291cmNlQ29kZShzY3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAg IH0KKyAgICBlcnJvck9jY3VycmVkID0gZmFsc2U7CisgICAgcmV0dXJuIFNjcmlwdFNvdXJjZUNv ZGUoc2NyaXB0LmVsZW1lbnQoKS0+dGV4dENvbnRlbnQoKSwgZG9jdW1lbnRVUkxGb3JTY3JpcHRF eGVjdXRpb24obV9kb2N1bWVudCksIHNjcmlwdC5zdGFydGluZ0xpbmVOdW1iZXIoKSk7Cit9CisK K2Jvb2wgU2NyaXB0UnVubmVyOjpyZXF1ZXN0U2NyaXB0KFBlbmRpbmdTY3JpcHQmIHBlbmRpbmdT Y3JpcHQsIGNvbnN0IEF0b21pY1N0cmluZyYgc291cmNlVVJMLCBFbGVtZW50KiBzY3JpcHRFbGVt ZW50KSBjb25zdAoreworICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KCkpOworICAg IGlmICghbV9ob3N0LT5zaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKHNvdXJjZVVSTCkp CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAvLyBGSVhNRTogV2UgbmVlZCB0byByZXNvbHZl IHRoZSB1cmwgcmVsYXRpdmUgdG8gdGhlIGVsZW1lbnQuCisgICAgaWYgKCFzY3JpcHRFbGVtZW50 LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzb3VyY2VVUkwpKQorICAgICAgICByZXR1cm4gZmFs c2U7CisgICAgcGVuZGluZ1NjcmlwdC5hZG9wdEVsZW1lbnQoc2NyaXB0RWxlbWVudCk7CisgICAg Ly8gVGhpcyBzaG91bGQgY29ycmVjdGx5IHJldHVybiAwIGZvciBlbXB0eSBvciBpbnZhbGlkIHNv dXJjZVVSTHMuCisgICAgQ2FjaGVkU2NyaXB0KiBjYWNoZWRTY3JpcHQgPSBtX2RvY3VtZW50LT5k b2NMb2FkZXIoKS0+cmVxdWVzdFNjcmlwdChzb3VyY2VVUkwsIHRvU2NyaXB0RWxlbWVudChzY3Jp cHRFbGVtZW50KS0+c2NyaXB0Q2hhcnNldCgpKTsKKyAgICBpZiAoIWNhY2hlZFNjcmlwdCkgewor ICAgICAgICBub3RJbXBsZW1lbnRlZCgpOyAvLyBEaXNwYXRjaCBlcnJvciBldmVudC4KKyAgICAg ICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIHBlbmRpbmdTY3JpcHQuc2V0Q2FjaGVkU2Ny aXB0KGNhY2hlZFNjcmlwdCk7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgU2NyaXB0UnVu bmVyOjpleGVjdXRlU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChQZW5kaW5nU2NyaXB0JiBwZW5kaW5n U2NyaXB0KSBjb25zdAoreworICAgIGJvb2wgZXJyb3JPY2N1cnJlZCA9IGZhbHNlOworICAgIFNj cmlwdFNvdXJjZUNvZGUgc291cmNlQ29kZSA9IHNvdXJjZUZyb21QZW5kaW5nU2NyaXB0KHBlbmRp bmdTY3JpcHQsIGVycm9yT2NjdXJyZWQpOworICAgIC8vIENsZWFyIHRoZSBwZW5kaW5nIHNjcmlw dCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgpCisgICAgUmVm UHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBwZW5kaW5nU2NyaXB0LnJlbGVhc2VFbGVtZW50 QW5kQ2xlYXIoKTsKKyAgICBpZiAoZXJyb3JPY2N1cnJlZCkKKyAgICAgICAgc2NyaXB0RWxlbWVu dC0+ZGlzcGF0Y2hFdmVudChjcmVhdGVTY3JpcHRFcnJvckV2ZW50KCkpOworICAgIGVsc2Ugewor ICAgICAgICBleGVjdXRlU2NyaXB0KHNjcmlwdEVsZW1lbnQuZ2V0KCksIHNvdXJjZUNvZGUpOwor ICAgICAgICBzY3JpcHRFbGVtZW50LT5kaXNwYXRjaEV2ZW50KGNyZWF0ZVNjcmlwdExvYWRFdmVu dCgpKTsKKyAgICB9Cit9CisKK3ZvaWQgU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0KEVsZW1l bnQqIGVsZW1lbnQsIGNvbnN0IFNjcmlwdFNvdXJjZUNvZGUmIHNvdXJjZUNvZGUpIGNvbnN0Cit7 CisgICAgU2NyaXB0RWxlbWVudCogc2NyaXB0RWxlbWVudCA9IHRvU2NyaXB0RWxlbWVudChlbGVt ZW50KTsKKyAgICBBU1NFUlQoc2NyaXB0RWxlbWVudCk7CisgICAgaWYgKCFzY3JpcHRFbGVtZW50 LT5zaG91bGRFeGVjdXRlQXNKYXZhU2NyaXB0KCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAo IW1fZG9jdW1lbnQtPmZyYW1lKCkpCisgICAgICAgIHJldHVybjsKKyAgICBtX2RvY3VtZW50LT5m cmFtZSgpLT5zY3JpcHQoKS0+ZXhlY3V0ZVNjcmlwdChzb3VyY2VDb2RlKTsKK30KKwordm9pZCBT Y3JpcHRSdW5uZXI6OndhdGNoRm9yTG9hZChQZW5kaW5nU2NyaXB0JiBwZW5kaW5nU2NyaXB0KSBj b25zdAoreworICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSk7Cisg ICAgbV9ob3N0LT53YXRjaEZvckxvYWQocGVuZGluZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSk7Cisg ICAgcGVuZGluZ1NjcmlwdC5zZXRXYXRjaGluZ0ZvckxvYWQodHJ1ZSk7Cit9CisKK3ZvaWQgU2Ny aXB0UnVubmVyOjpzdG9wV2F0Y2hpbmdGb3JMb2FkKFBlbmRpbmdTY3JpcHQmIHBlbmRpbmdTY3Jp cHQpIGNvbnN0Cit7CisgICAgQVNTRVJUKHBlbmRpbmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkp OworICAgIG1faG9zdC0+c3RvcFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0LmNhY2hlZFNj cmlwdCgpKTsKKyAgICBwZW5kaW5nU2NyaXB0LnNldFdhdGNoaW5nRm9yTG9hZChmYWxzZSk7Cit9 CisKK30KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9k b20vU2NyaXB0UnVubmVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMmRlMGU1YWM1ODRmOWI4NjRhNzI2MmIxNGE4 ZDdmODkzOGIzOTY5OQotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5l ci5oCkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlLCBJ bmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQor ICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLiAKKyAqLworCisjaWZuZGVmIFNjcmlwdFJ1bm5lcl9oCisjZGVmaW5lIFNjcmlwdFJ1bm5l cl9oCisKKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093 blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEF0b21pY1N0cmluZzsKK2Ns YXNzIERvY3VtZW50OworY2xhc3MgRWxlbWVudDsKK2NsYXNzIFBlbmRpbmdTY3JpcHQ7CitjbGFz cyBTY3JpcHRSdW5uZXJIb3N0OworY2xhc3MgU2NyaXB0U291cmNlQ29kZTsKKworY2xhc3MgU2Ny aXB0UnVubmVyIDogcHVibGljIE5vbmNvcHlhYmxlIHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFz c093blB0cjxTY3JpcHRSdW5uZXI+IGNyZWF0ZShEb2N1bWVudCogZG9jdW1lbnQsIFNjcmlwdFJ1 bm5lckhvc3QqIGhvc3QpIHsgcmV0dXJuIG5ldyBTY3JpcHRSdW5uZXIoZG9jdW1lbnQsIGhvc3Qp OyB9CisgICAgdmlydHVhbCB+U2NyaXB0UnVubmVyKCkgeyB9CisKKyAgICBTY3JpcHRTb3VyY2VD b2RlIHNvdXJjZUZyb21QZW5kaW5nU2NyaXB0KGNvbnN0IFBlbmRpbmdTY3JpcHQmLCBib29sJiBl cnJvck9jY3VycmVkKSBjb25zdDsKKyAgICBib29sIHJlcXVlc3RTY3JpcHQoUGVuZGluZ1Njcmlw dCYsIGNvbnN0IEF0b21pY1N0cmluZyYgc291cmNlVVJMLCBFbGVtZW50KikgY29uc3Q7CisgICAg dm9pZCB3YXRjaEZvckxvYWQoUGVuZGluZ1NjcmlwdCYpIGNvbnN0OworICAgIHZvaWQgc3RvcFdh dGNoaW5nRm9yTG9hZChQZW5kaW5nU2NyaXB0JikgY29uc3Q7CisgICAgdm9pZCBleGVjdXRlU2Ny aXB0QW5kRGlzcGF0Y2hFdmVudChQZW5kaW5nU2NyaXB0JikgY29uc3Q7CisgICAgdm9pZCBleGVj dXRlU2NyaXB0KEVsZW1lbnQqLCBjb25zdCBTY3JpcHRTb3VyY2VDb2RlJikgY29uc3Q7CisKKyAg ICBEb2N1bWVudCogZG9jdW1lbnQoKSB7IHJldHVybiBtX2RvY3VtZW50OyB9CisKK3ByaXZhdGU6 CisgICAgU2NyaXB0UnVubmVyKERvY3VtZW50KiwgU2NyaXB0UnVubmVySG9zdCopOworCisgICAg RG9jdW1lbnQqIG1fZG9jdW1lbnQ7CisgICAgU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OworfTsK KworfQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lckhvc3Qu aCBiL1dlYkNvcmUvZG9tL1NjcmlwdFJ1bm5lckhvc3QuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iMzVjMzVhYjQ3 OTVlODEyZjczOGMzMTcyMDg0MDU5NmVjOTMxMGNiCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29y ZS9kb20vU2NyaXB0UnVubmVySG9zdC5oCkBAIC0wLDAgKzEsNDkgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBB TkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisg KiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLiAKKyAqLworCisjaWZuZGVmIFNjcmlwdFJ1bm5lckhv c3RfaAorI2RlZmluZSBTY3JpcHRSdW5uZXJIb3N0X2gKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitjbGFzcyBBdG9taWNTdHJpbmc7CitjbGFzcyBDYWNoZWRSZXNvdXJjZTsKKworY2xhc3MgU2Ny aXB0UnVubmVySG9zdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB+U2NyaXB0UnVubmVySG9zdCgp IHsgfQorCisgICAgLy8gSW1wbGVtZW50b3JzIHNob3VsZCBjYWxsIGNhY2hlZFJlc291cmNlLT5h ZGRDbGllbnQoKSBoZXJlIG9yIHNvb24gYWZ0ZXIuCisgICAgdmlydHVhbCB2b2lkIHdhdGNoRm9y TG9hZChDYWNoZWRSZXNvdXJjZSopID0gMDsKKyAgICAvLyBJbXBsZW1lbnRvcnMgbXVzdCBjYWxs IGNhY2hlZFJlc291cmNlLT5yZW1vdmVDbGllbnQoKSBpbW1lZGlhdGVseS4KKyAgICB2aXJ0dWFs IHZvaWQgc3RvcFdhdGNoaW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopID0gMDsKKworICAgIC8v IEltcGxlbWVudG9ycyBjYW4gYmxvY2sgY2VydGFpbiBzY3JpcHQgbG9hZHMgKGZvciBYU1NBdWRp dG9yLCBldGMuKQorICAgIHZpcnR1YWwgYm9vbCBzaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9t U3JjKGNvbnN0IEF0b21pY1N0cmluZyYpID0gMDsKK307CisKK30KKworI2VuZGlmCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lci5jcHAgYi9XZWJDb3JlL2h0bWwvSFRN TFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggNGE5MDU4ZmFmNDVjZDg1MjFiZDNhYTM5YWUxMGYxZDVi MGY3ZDVmZS4uMzI0MjQ0OTU0Y2Y5NWUzNzQ1MTQyYjU4NTE3ZTMyOGIwYTBkNmVjYyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRt bC9IVE1MU2NyaXB0UnVubmVyLmNwcApAQCAtMjgsMTUgKzI4LDE0IEBACiAKICNpbmNsdWRlICJB dHRyaWJ1dGUuaCIKICNpbmNsdWRlICJDYWNoZWRTY3JpcHQuaCIKLSNpbmNsdWRlICJEb2NMb2Fk ZXIuaCIKKyNpbmNsdWRlICJEZWZlcnJlZFNjcmlwdFJ1bm5lci5oIgogI2luY2x1ZGUgIkVsZW1l bnQuaCIKLSNpbmNsdWRlICJFdmVudC5oIgotI2luY2x1ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAi SFRNTFNjcmlwdFJ1bm5lckhvc3QuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRTdHJlYW0uaCIKICNp bmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRlZC5oIgogI2luY2x1 ZGUgIlNjcmlwdEVsZW1lbnQuaCIKKyNpbmNsdWRlICJTY3JpcHRSdW5uZXIuaCIKICNpbmNsdWRl ICJTY3JpcHRTb3VyY2VDb2RlLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTYzLDcgKzYy LDggQEAgcHJpdmF0ZToKIH07CiAKIEhUTUxTY3JpcHRSdW5uZXI6OkhUTUxTY3JpcHRSdW5uZXIo RG9jdW1lbnQqIGRvY3VtZW50LCBIVE1MU2NyaXB0UnVubmVySG9zdCogaG9zdCkKLSAgICA6IG1f ZG9jdW1lbnQoZG9jdW1lbnQpCisgICAgOiBtX3J1bm5lcihTY3JpcHRSdW5uZXI6OmNyZWF0ZShk b2N1bWVudCwgaG9zdCkpCisgICAgLCBtX2RvY3VtZW50KGRvY3VtZW50KQogICAgICwgbV9ob3N0 KGhvc3QpCiAgICAgLCBtX3NjcmlwdE5lc3RpbmdMZXZlbCgwKQogICAgICwgbV9oYXNTY3JpcHRz V2FpdGluZ0ZvclN0eWxlc2hlZXRzKGZhbHNlKQpAQCAtNzUsMzcgKzc1LDcgQEAgSFRNTFNjcmlw dFJ1bm5lcjo6fkhUTUxTY3JpcHRSdW5uZXIoKQogewogICAgIC8vIEZJWE1FOiBTaG91bGQgd2Ug YmUgcGFzc2VkIGEgImRvbmUgbG9hZGluZy9wYXJzaW5nIiBjYWxsYmFjayBzb29uZXIgdGhhbiBk ZXN0cnVjdGlvbj8KICAgICBpZiAobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0 KCkgJiYgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkpCi0gICAgICAg IHN0b3BXYXRjaGluZ0ZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOwotfQotCi1zdGF0 aWMgS1VSTCBkb2N1bWVudFVSTEZvclNjcmlwdEV4ZWN1dGlvbihEb2N1bWVudCogZG9jdW1lbnQp Ci17Ci0gICAgaWYgKCFkb2N1bWVudCB8fCAhZG9jdW1lbnQtPmZyYW1lKCkpCi0gICAgICAgIHJl dHVybiBLVVJMKCk7Ci0KLSAgICAvLyBVc2UgdGhlIFVSTCBvZiB0aGUgY3VycmVudGx5IGFjdGl2 ZSBkb2N1bWVudCBmb3IgdGhpcyBmcmFtZS4KLSAgICByZXR1cm4gZG9jdW1lbnQtPmZyYW1lKCkt PmRvY3VtZW50KCktPnVybCgpOwotfQotCi1pbmxpbmUgUGFzc1JlZlB0cjxFdmVudD4gY3JlYXRl U2NyaXB0TG9hZEV2ZW50KCkKLXsKLSAgICByZXR1cm4gRXZlbnQ6OmNyZWF0ZShldmVudE5hbWVz KCkubG9hZEV2ZW50LCBmYWxzZSwgZmFsc2UpOwotfQotCi1pbmxpbmUgUGFzc1JlZlB0cjxFdmVu dD4gY3JlYXRlU2NyaXB0RXJyb3JFdmVudCgpCi17Ci0gICAgcmV0dXJuIEV2ZW50OjpjcmVhdGUo ZXZlbnROYW1lcygpLmVycm9yRXZlbnQsIHRydWUsIGZhbHNlKTsKLX0KLQotU2NyaXB0U291cmNl Q29kZSBIVE1MU2NyaXB0UnVubmVyOjpzb3VyY2VGcm9tUGVuZGluZ1NjcmlwdChjb25zdCBQZW5k aW5nU2NyaXB0JiBzY3JpcHQsIGJvb2wmIGVycm9yT2NjdXJyZWQpCi17Ci0gICAgaWYgKHNjcmlw dC5jYWNoZWRTY3JpcHQoKSkgewotICAgICAgICBlcnJvck9jY3VycmVkID0gc2NyaXB0LmNhY2hl ZFNjcmlwdCgpLT5lcnJvck9jY3VycmVkKCk7Ci0gICAgICAgIEFTU0VSVChzY3JpcHQuY2FjaGVk U2NyaXB0KCktPmlzTG9hZGVkKCkpOwotICAgICAgICByZXR1cm4gU2NyaXB0U291cmNlQ29kZShz Y3JpcHQuY2FjaGVkU2NyaXB0KCkpOwotICAgIH0KLSAgICBlcnJvck9jY3VycmVkID0gZmFsc2U7 Ci0gICAgcmV0dXJuIFNjcmlwdFNvdXJjZUNvZGUoc2NyaXB0LmVsZW1lbnQoKS0+dGV4dENvbnRl bnQoKSwgZG9jdW1lbnRVUkxGb3JTY3JpcHRFeGVjdXRpb24obV9kb2N1bWVudCksIHNjcmlwdC5z dGFydGluZ0xpbmVOdW1iZXIoKSk7CisgICAgICAgIG1fcnVubmVyLT5zdG9wV2F0Y2hpbmdGb3JM b2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAogYm9vbCBIVE1MU2NyaXB0UnVubmVy Ojppc1BlbmRpbmdTY3JpcHRSZWFkeShjb25zdCBQZW5kaW5nU2NyaXB0JiBzY3JpcHQpCkBAIC0x MjIsNTggKzkyLDIyIEBAIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3Jp cHQoKQogewogICAgIEFTU0VSVCghbV9zY3JpcHROZXN0aW5nTGV2ZWwpOwogICAgIEFTU0VSVCht X2RvY3VtZW50LT5oYXZlU3R5bGVzaGVldHNMb2FkZWQoKSk7Ci0gICAgYm9vbCBlcnJvck9jY3Vy cmVkID0gZmFsc2U7CiAgICAgQVNTRVJUKGlzUGVuZGluZ1NjcmlwdFJlYWR5KG1fcGFyc2luZ0Js b2NraW5nU2NyaXB0KSk7Ci0gICAgU2NyaXB0U291cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNl RnJvbVBlbmRpbmdTY3JpcHQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVycm9yT2NjdXJyZWQp OwogCiAgICAgLy8gU3RvcCB3YXRjaGluZyBsb2FkcyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBw cmV2ZW50IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0IHJlbG9hZHMgaXRzZWxmLgogICAgIGlmICht X3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2lu Z1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKLSAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZCht X3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisgICAgICAgIG1fcnVubmVyLT5zdG9wV2F0Y2hpbmdG b3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIAotICAgIC8vIENsZWFyIHRoZSBwZW5k aW5nIHNjcmlwdCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgp Ci0gICAgUmVmUHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdC5yZWxlYXNlRWxlbWVudEFuZENsZWFyKCk7CiAgICAgewogICAgICAgICBOZXN0U2NyaXB0 IG5lc3RpbmdMZXZlbChtX3NjcmlwdE5lc3RpbmdMZXZlbCwgbV9ob3N0LT5pbnB1dFN0cmVhbSgp KTsKLSAgICAgICAgaWYgKGVycm9yT2NjdXJyZWQpCi0gICAgICAgICAgICBzY3JpcHRFbGVtZW50 LT5kaXNwYXRjaEV2ZW50KGNyZWF0ZVNjcmlwdEVycm9yRXZlbnQoKSk7Ci0gICAgICAgIGVsc2Ug ewotICAgICAgICAgICAgZXhlY3V0ZVNjcmlwdChzY3JpcHRFbGVtZW50LmdldCgpLCBzb3VyY2VD b2RlKTsKLSAgICAgICAgICAgIHNjcmlwdEVsZW1lbnQtPmRpc3BhdGNoRXZlbnQoY3JlYXRlU2Ny aXB0TG9hZEV2ZW50KCkpOwotICAgICAgICB9CisKKyAgICAgICAgQVNTRVJUKG1fZG9jdW1lbnQt PmhhdmVTdHlsZXNoZWV0c0xvYWRlZCgpKTsKKyAgICAgICAgQVNTRVJUKGlzRXhlY3V0aW5nU2Ny aXB0KCkpOworICAgICAgICBtX3J1bm5lci0+ZXhlY3V0ZVNjcmlwdEFuZERpc3BhdGNoRXZlbnQo bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOwogICAgIH0KICAgICBBU1NFUlQoIW1fc2NyaXB0TmVz dGluZ0xldmVsKTsKIH0KIAotdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0KEVs ZW1lbnQqIGVsZW1lbnQsIGNvbnN0IFNjcmlwdFNvdXJjZUNvZGUmIHNvdXJjZUNvZGUpCi17Ci0g ICAgLy8gRklYTUU6IFdlIGRvIG5vdCBibG9jayBpbmxpbmUgPHNjcmlwdD4gdGFncyBvbiBzdHls ZXNoZWV0cyBmb3Igbm93LgotICAgIC8vIFdoZW4gd2UgZG8sICB8fCAhZWxlbWVudC0+aGFzQXR0 cmlidXRlKHNyY0F0dHIpIHNob3VsZCBiZSByZW1vdmVkIGZyb20KLSAgICAvLyB0aGUgQVNTRVJU IGJlbG93LiAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00MDA0 NwotICAgIEFTU0VSVChtX2RvY3VtZW50LT5oYXZlU3R5bGVzaGVldHNMb2FkZWQoKSB8fCAhZWxl bWVudC0+aGFzQXR0cmlidXRlKHNyY0F0dHIpKTsKLSAgICBTY3JpcHRFbGVtZW50KiBzY3JpcHRF bGVtZW50ID0gdG9TY3JpcHRFbGVtZW50KGVsZW1lbnQpOwotICAgIEFTU0VSVChzY3JpcHRFbGVt ZW50KTsKLSAgICBpZiAoIXNjcmlwdEVsZW1lbnQtPnNob3VsZEV4ZWN1dGVBc0phdmFTY3JpcHQo KSkKLSAgICAgICAgcmV0dXJuOwotICAgIEFTU0VSVChpc0V4ZWN1dGluZ1NjcmlwdCgpKTsKLSAg ICBpZiAoIW1fZG9jdW1lbnQtPmZyYW1lKCkpCi0gICAgICAgIHJldHVybjsKLSAgICBtX2RvY3Vt ZW50LT5mcmFtZSgpLT5zY3JpcHQoKS0+ZXhlY3V0ZVNjcmlwdChzb3VyY2VDb2RlKTsKLX0KLQot dm9pZCBIVE1MU2NyaXB0UnVubmVyOjp3YXRjaEZvckxvYWQoUGVuZGluZ1NjcmlwdCYgcGVuZGlu Z1NjcmlwdCkKLXsKLSAgICBBU1NFUlQoIXBlbmRpbmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkp OwotICAgIG1faG9zdC0+d2F0Y2hGb3JMb2FkKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkp OwotICAgIHBlbmRpbmdTY3JpcHQuc2V0V2F0Y2hpbmdGb3JMb2FkKHRydWUpOwotfQotCi12b2lk IEhUTUxTY3JpcHRSdW5uZXI6OnN0b3BXYXRjaGluZ0ZvckxvYWQoUGVuZGluZ1NjcmlwdCYgcGVu ZGluZ1NjcmlwdCkKLXsKLSAgICBBU1NFUlQocGVuZGluZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQo KSk7Ci0gICAgbV9ob3N0LT5zdG9wV2F0Y2hpbmdGb3JMb2FkKHBlbmRpbmdTY3JpcHQuY2FjaGVk U2NyaXB0KCkpOwotICAgIHBlbmRpbmdTY3JpcHQuc2V0V2F0Y2hpbmdGb3JMb2FkKGZhbHNlKTsK LX0KLQogLy8gVGhpcyBmdW5jdGlvbiBzaG91bGQgbWF0Y2ggMTAuMi41LjExICJBbiBlbmQgdGFn IHdob3NlIHRhZyBuYW1lIGlzICdzY3JpcHQnIgogLy8gU2NyaXB0IGhhbmRsaW5nIGxpdmVzIG91 dHNpZGUgdGhlIHRyZWUgYnVpbGRlciB0byBrZWVwIHRoZSBlYWNoIGNsYXNzIHNpbXBsZS4KIGJv b2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZShQYXNzUmVmUHRyPEVsZW1lbnQ+IHNjcmlwdEVs ZW1lbnQsIGludCBzdGFydExpbmUpCkBAIC0yMjgsMzEgKzE2MiwxOCBAQCBib29sIEhUTUxTY3Jp cHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCkKICAgICByZXR1 cm4gZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKIH0KIAotdm9pZCBIVE1MU2NyaXB0 UnVubmVyOjpyZXF1ZXN0U2NyaXB0KEVsZW1lbnQqIHNjcmlwdCkKK3ZvaWQgSFRNTFNjcmlwdFJ1 bm5lcjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiBzY3JpcHRFbGVtZW50 LCBjb25zdCBBdG9taWNTdHJpbmcmIHNvdXJjZVVSTCkKIHsKLSAgICBBU1NFUlQoIW1fcGFyc2lu Z0Jsb2NraW5nU2NyaXB0LmVsZW1lbnQoKSk7Ci0gICAgQXRvbWljU3RyaW5nIHNyY1ZhbHVlID0g c2NyaXB0LT5nZXRBdHRyaWJ1dGUoc3JjQXR0cik7Ci0gICAgLy8gQWxsb3cgdGhlIGhvc3QgdG8g ZGlzbGxvdyBzY3JpcHQgbG9hZHMgKHVzaW5nIHRoZSBYU1NBdWRpdG9yLCBldGMuKQotICAgIGlm ICghbV9ob3N0LT5zaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKHNyY1ZhbHVlKSkKKyAg ICBpZiAoIW1fcnVubmVyLT5yZXF1ZXN0U2NyaXB0KG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0LCBz b3VyY2VVUkwsIHNjcmlwdEVsZW1lbnQpKQogICAgICAgICByZXR1cm47Ci0gICAgLy8gRklYTUU6 IFdlIG5lZWQgdG8gcmVzb2x2ZSB0aGUgdXJsIHJlbGF0aXZlIHRvIHRoZSBlbGVtZW50LgotICAg IGlmICghc2NyaXB0LT5kaXNwYXRjaEJlZm9yZUxvYWRFdmVudChzcmNWYWx1ZSkpCi0gICAgICAg IHJldHVybjsKLSAgICBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5hZG9wdEVsZW1lbnQoc2NyaXB0 KTsKLSAgICAvLyBUaGlzIHNob3VsZCBjb3JyZWN0bHkgcmV0dXJuIDAgZm9yIGVtcHR5IG9yIGlu dmFsaWQgc3JjVmFsdWVzLgotICAgIENhY2hlZFNjcmlwdCogY2FjaGVkU2NyaXB0ID0gbV9kb2N1 bWVudC0+ZG9jTG9hZGVyKCktPnJlcXVlc3RTY3JpcHQoc3JjVmFsdWUsIHRvU2NyaXB0RWxlbWVu dChzY3JpcHQpLT5zY3JpcHRDaGFyc2V0KCkpOwotICAgIGlmICghY2FjaGVkU2NyaXB0KSB7Ci0g ICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIERpc3BhdGNoIGVycm9yIGV2ZW50LgotICAgICAg ICByZXR1cm47Ci0gICAgfQogCi0gICAgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuc2V0Q2FjaGVk U2NyaXB0KGNhY2hlZFNjcmlwdCk7CisgICAgQVNTRVJUKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0 LmNhY2hlZFNjcmlwdCgpKTsKIAogICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91dCBhIGxvYWQgY2Fs bGJhY2sgaWYgY2FjaGVkU2NyaXB0IGlzIG5vdCBhbHJlYWR5CiAgICAgLy8gaW4gdGhlIGNhY2hl LiAgQ2FsbGVycyB3aWxsIGF0dGVtcHQgdG8gcnVuIHRoZSBtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dAogICAgIC8vIGlmIHBvc3NpYmxlIGJlZm9yZSByZXR1cm5pbmcgY29udHJvbCB0byB0aGUgcGFy c2VyLgogICAgIGlmICghbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCktPmlz TG9hZGVkKCkpCi0gICAgICAgIHdhdGNoRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7 CisgICAgICAgIG1fcnVubmVyLT53YXRjaEZvckxvYWQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQp OwogfQogCiAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCB0byBtYXRjaCB0aGUgSFRNTDUgZGVmaW5p dGlvbiBvZiAicnVubmluZyBhIHNjcmlwdCIKQEAgLTI2NywxMyArMTg4LDI1IEBAIHZvaWQgSFRN TFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KEVsZW1lbnQqIHNjcmlwdCwgaW50IHN0YXJ0aW5nTGlu ZU51bWJlcikKICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsgLy8gZXZlbnQgZm9yIHN1cHBvcnQK IAogICAgICAgICBpZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoc3JjQXR0cikpIHsKLSAgICAgICAg ICAgIC8vIEZJWE1FOiBIYW5kbGUgZGVmZXIgYW5kIGFzeW5jCi0gICAgICAgICAgICByZXF1ZXN0 U2NyaXB0KHNjcmlwdCk7CisgICAgICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIHNvdXJjZVVS TCA9IHNjcmlwdC0+Z2V0QXR0cmlidXRlKHNyY0F0dHIpOworICAgICAgICAgICAgLy8gRklYTUU6 IEhhbmRsZSBhc3luYworICAgICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKGRlZmVy QXR0cikpCisgICAgICAgICAgICAgICAgbV9kb2N1bWVudC0+ZGVmZXJyZWRTY3JpcHRSdW5uZXIo KS0+YWRkU2NyaXB0KHNjcmlwdCwgc291cmNlVVJMKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICByZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KHNjcmlwdCwgc291cmNlVVJM KTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIC8vIEZJWE1FOiBXZSBkbyBub3QgYmxv Y2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVzaGVldHMgdG8gbWF0Y2ggdGhlCi0gICAg ICAgICAgICAvLyBvbGQgcGFyc2VyIGZvciBub3cuICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTQwMDQ3Ci0gICAgICAgICAgICBTY3JpcHRTb3VyY2VDb2RlIHNv dXJjZUNvZGUoc2NyaXB0LT50ZXh0Q29udGVudCgpLCBkb2N1bWVudFVSTEZvclNjcmlwdEV4ZWN1 dGlvbihtX2RvY3VtZW50KSwgc3RhcnRpbmdMaW5lTnVtYmVyKTsKLSAgICAgICAgICAgIGV4ZWN1 dGVTY3JpcHQoc2NyaXB0LCBzb3VyY2VDb2RlKTsKKyAgICAgICAgICAgIC8vIG9sZCBwYXJzZXIg Zm9yIG5vdy4gIFdoZW4gd2UgZG8sIHRoZSBBU1NFUlQgYmVsb3cgc2hvdWxkIGJlIGFkZGVkLgor ICAgICAgICAgICAgLy8gU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD00MDA0NworICAgICAgICAgICAgLy8gQVNTRVJUKG1fZG9jdW1lbnQtPmhhdmVTdHlsZXNoZWV0 c0xvYWRlZCgpKTsKKyAgICAgICAgICAgIEFTU0VSVChpc0V4ZWN1dGluZ1NjcmlwdCgpKTsKKwor ICAgICAgICAgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0OworICAgICAgICAgICAgcGVu ZGluZ1NjcmlwdC5hZG9wdEVsZW1lbnQoc2NyaXB0KTsKKyAgICAgICAgICAgIHBlbmRpbmdTY3Jp cHQuc2V0U3RhcnRpbmdMaW5lTnVtYmVyKHN0YXJ0aW5nTGluZU51bWJlcik7CisgICAgICAgICAg ICBib29sIHVudXNlZEVycm9yT2NjdXJyZWQ7CisgICAgICAgICAgICBTY3JpcHRTb3VyY2VDb2Rl IHNvdXJjZUNvZGUgPSBtX3J1bm5lci0+c291cmNlRnJvbVBlbmRpbmdTY3JpcHQocGVuZGluZ1Nj cmlwdCwgdW51c2VkRXJyb3JPY2N1cnJlZCk7CisgICAgICAgICAgICBtX3J1bm5lci0+ZXhlY3V0 ZVNjcmlwdChzY3JpcHQsIHNvdXJjZUNvZGUpOwogICAgICAgICB9CiAgICAgfQogfQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaCBiL1dlYkNvcmUvaHRtbC9IVE1M U2NyaXB0UnVubmVyLmgKaW5kZXggODU4MDFiMjk0NDEyZDg3YTQ5MGUwNmM5ODVmZDY1ZmFiY2Mx NTUzMC4uZmUyNDE5MmUzNDg5ODVjZmQxNjJlZTg0ODdlYjgwZGZhZjk5MGQzZSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9odG1sL0hUTUxTY3JpcHRSdW5uZXIuaAorKysgYi9XZWJDb3JlL2h0bWwvSFRN TFNjcmlwdFJ1bm5lci5oCkBAIC0zMiwxMiArMzIsMTQgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCitjbGFzcyBBdG9taWNTdHJpbmc7CiBjbGFzcyBDYWNoZWRSZXNvdXJjZTsKIGNsYXNzIENh Y2hlZFNjcmlwdDsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgRWxlbWVudDsKIGNsYXNzIEZyYW1l OwogY2xhc3MgSFRNTFNjcmlwdFJ1bm5lckhvc3Q7CitjbGFzcyBTY3JpcHRSdW5uZXI7CiBjbGFz cyBTY3JpcHRTb3VyY2VDb2RlOwogCiBjbGFzcyBIVE1MU2NyaXB0UnVubmVyIDogcHVibGljIE5v bmNvcHlhYmxlIHsKQEAgLTYxLDE3ICs2MywxMiBAQCBwcml2YXRlOgogICAgIGJvb2wgZXhlY3V0 ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKICAgICB2b2lkIGV4ZWN1dGVQZW5kaW5nU2NyaXB0 KCk7CiAKLSAgICB2b2lkIHJlcXVlc3RTY3JpcHQoRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVz dFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiwgY29uc3QgQXRvbWljU3RyaW5nJiBzb3Vy Y2VVUkwpOwogICAgIHZvaWQgcnVuU2NyaXB0KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVt YmVyKTsKIAotICAgIC8vIEhlbHBlcnMgZm9yIGRlYWxpbmcgd2l0aCBIVE1MU2NyaXB0UnVubmVy SG9zdAotICAgIHZvaWQgd2F0Y2hGb3JMb2FkKFBlbmRpbmdTY3JpcHQmKTsKLSAgICB2b2lkIHN0 b3BXYXRjaGluZ0ZvckxvYWQoUGVuZGluZ1NjcmlwdCYpOwotICAgIHZvaWQgZXhlY3V0ZVNjcmlw dChFbGVtZW50KiwgY29uc3QgU2NyaXB0U291cmNlQ29kZSYpOwotCiAgICAgYm9vbCBpc1BlbmRp bmdTY3JpcHRSZWFkeShjb25zdCBQZW5kaW5nU2NyaXB0Jik7Ci0gICAgU2NyaXB0U291cmNlQ29k ZSBzb3VyY2VGcm9tUGVuZGluZ1NjcmlwdChjb25zdCBQZW5kaW5nU2NyaXB0JiwgYm9vbCYgZXJy b3JPY2N1cnJlZCk7CiAKKyAgICBPd25QdHI8U2NyaXB0UnVubmVyPiBtX3J1bm5lcjsKICAgICBE b2N1bWVudCogbV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0Owog ICAgIFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL2h0bWwvSFRNTFNjcmlwdFJ1bm5lckhvc3QuaCBiL1dlYkNvcmUvaHRtbC9IVE1MU2Ny aXB0UnVubmVySG9zdC5oCmluZGV4IGExMjk1MjA3OWY4OTQ2NzFiNDYxZTY3MTQxNjVkNzg2YWFl MjE3MTMuLjRhMTU3ZTEzMjkwMTE2NTMzYzVlZDVmODI5NGI3MjM0NWE5ZDAxZDMgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvaHRtbC9IVE1MU2NyaXB0UnVubmVySG9zdC5oCisrKyBiL1dlYkNvcmUvaHRt bC9IVE1MU2NyaXB0UnVubmVySG9zdC5oCkBAIC0yNiwyNSArMjYsMTggQEAKICNpZm5kZWYgSFRN TFNjcmlwdFJ1bm5lckhvc3RfaAogI2RlZmluZSBIVE1MU2NyaXB0UnVubmVySG9zdF9oCiAKKyNp bmNsdWRlICJTY3JpcHRSdW5uZXJIb3N0LmgiCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xh c3MgQXRvbWljU3RyaW5nOwogY2xhc3MgQ2FjaGVkUmVzb3VyY2U7Ci1jbGFzcyBFbGVtZW50Owog Y2xhc3MgSFRNTElucHV0U3RyZWFtOwotY2xhc3MgU2NyaXB0U291cmNlQ29kZTsKIAotY2xhc3Mg SFRNTFNjcmlwdFJ1bm5lckhvc3QgeworY2xhc3MgSFRNTFNjcmlwdFJ1bm5lckhvc3QgOiBwdWJs aWMgU2NyaXB0UnVubmVySG9zdCB7CiBwdWJsaWM6CiAgICAgdmlydHVhbCB+SFRNTFNjcmlwdFJ1 bm5lckhvc3QoKSB7IH0KIAotICAgIC8vIEltcGxlbWVudG9ycyBzaG91bGQgY2FsbCBjYWNoZWRS ZXNvdXJjZS0+YWRkQ2xpZW50KCkgaGVyZSBvciBzb29uIGFmdGVyLgotICAgIHZpcnR1YWwgdm9p ZCB3YXRjaEZvckxvYWQoQ2FjaGVkUmVzb3VyY2UqKSA9IDA7Ci0gICAgLy8gSW1wbGVtZW50b3Jz IG11c3QgY2FsbCBjYWNoZWRSZXNvdXJjZS0+cmVtb3ZlQ2xpZW50KCkgaW1tZWRpYXRlbHkuCi0g ICAgdmlydHVhbCB2b2lkIHN0b3BXYXRjaGluZ0ZvckxvYWQoQ2FjaGVkUmVzb3VyY2UqKSA9IDA7 Ci0KLSAgICAvLyBJbXBsZW1lbnRvcnMgY2FuIGJsb2NrIGNlcnRhaW4gc2NyaXB0IGxvYWRzIChm b3IgWFNTQXVkaXRvciwgZXRjLikKLSAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkTG9hZEV4dGVybmFs U2NyaXB0RnJvbVNyYyhjb25zdCBBdG9taWNTdHJpbmcmKSA9IDA7CiAgICAgdmlydHVhbCBIVE1M SW5wdXRTdHJlYW0mIGlucHV0U3RyZWFtKCkgPSAwOwogfTsKIAo= 64600 2010-08-17 09:41:16 -0700 2010-08-17 09:42:09 -0700 Testcase iframe-write-two-nodes-in-onload.html text/html 78 tonyg RkFJTAo8aWZyYW1lIG9ubG9hZD0iZG9jdW1lbnQuY2xvc2UoKTsgZG9jdW1lbnQud3JpdGUoJzxw PjE8cD4yJyk7Ij48L2lmcmFtZT4K 66066 2010-08-31 10:10:47 -0700 2010-08-31 14:01:16 -0700 Patch bug-40934-20100831101046.patch text/plain 30468 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkNDMxNmQwNTllMmQxMzI4ZWNjNjU0ZDZlOGZkYjFiZWNlZmNhODZhLi5lZWUyN2Zi ZTg0NmQ5ZWJhMzhlMjZkNDZjYTAyZTgxZTVmYTU3YTBkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDgtMzEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IEFkZGVk LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZl ci13cml0ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNj cmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LXdyaXRlLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90ZXhlY3V0ZS5q czogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVy LXdyaXRlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAg ICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91 bmQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAg ICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRl ZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sOiBBZGRlZC4KKwogMjAxMC0wOC0zMCAgUm9i ZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2lt b24gSGF1c21hbm4uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ZWYyMmU5YTQzMWFkMDI3MjcxM2I3MWZkYzg3OTQwMTZj OGVmMTJmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsx IEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjA0MTIwNTBiMmU0M2I2OTQ5MWI1NDM0NzM1ZjJkNmZlNTE0ZWY5OWQKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3Vi bGUtZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZh c2NyaXB0LGRvY3VtZW50LndyaXRlKCdGQUlMJyk7IGRvY3VtZW50LndyaXRlKCc8c2NyaXB0IGRl ZmVyIHNyYz1cJ2RhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCZxdW90O1BBU1Mm cXVvdDspO1wnPjwvc2NyaXB0PicpOyBkb2N1bWVudC5jbG9zZSgpOyI+PC9zY3JpcHQ+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3Vi bGUtd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1 NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZDA0Zjk2 MWEwMzcxMTdjMWVhYTY5YWM2MGViMzYzZDM3YWU3OGQxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACisxIDIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZTU1ZTFkM2RiM2Y5NjNjOGY5N2E5NzY1MmEwNGE2Y2ExZmNkYWM5MQotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2Rl ZmVyLWRvdWJsZS13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBAQAorPHNjcmlwdD4KK2lmICh3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRlZmVyIHNyYz0iZGF0YTp0ZXh0L2ph dmFzY3JpcHQsZG9jdW1lbnQud3JpdGVsbigxKTsgZG9jdW1lbnQud3JpdGUoJzxzY3JpcHQgc3Jj PVwnZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGVsbigyKVwnPjwvc2NyaXB0Picp OyI+PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0 Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjliMDJkMTYzMTc3ZjU2NWNkYjdkMGNlNTZiMzViODU0MzMyMTM5Y2QKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1pbmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK0NoZWNrcyB0 aGF0IGlubGluZSBzY3JpcHRzIGFyZSBub3QgZGVmZXJyZWQuCisxCisyCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0 Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxp bmUtc2NyaXB0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTE1YzIwMTE5YWM0ODA0NTYyMDc0NDhkZjI4NjM1 MjM4YTlmZTk1NwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbApAQCAtMCwwICsxLDE1IEBACis8 IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxo ZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0 LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGlubGluZSBz Y3JpcHRzIGFyZSBub3QgZGVmZXJyZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3Jp cHQgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkZWJ1ZygyKTsiIGRlZmVyPjwvc2NyaXB0Pgor PHNjcmlwdCBkZWZlcj4KKyAgZGVidWcoMSk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2Ny aXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJh M2UzNzFmNzAyOGZhMTM4MGUyYTM1ZjU0NTQ4MWI5NGFiMjAxMDcKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxv YWQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorQ2hlY2tzIHRoYXQgZGVmZXJyZWQgc2Ny aXB0cyBmaXJlIG9uYmVmb3JlbG9hZCBpbW1lZGlhdGVseSBhbmQgdGhhdCBpdCBpcyBjYW5jZWxs YWJsZS4KK2NhbmNlbGxlZCBvbmJlZm9yZWxvYWQgZGVmZXIKK29uYmVmb3JlbG9hZCBkZWZlcgor b25iZWZvcmVsb2FkIGV4dGVybmFsCitleHRlcm5hbAorZGVmZXIKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1s IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVs b2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYTIyYjE4NGRhNjNiYTQ3NTcxMWJlMWY3YmY1OTU5OWE1NDE2 MGUyYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCkBAIC0wLDAgKzEsMTQgQEAKKzwhRE9DVFlQ RSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8 bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0 eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpz Ij48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorQ2hlY2tzIHRoYXQgZGVmZXJyZWQgc2NyaXB0 cyBmaXJlIG9uYmVmb3JlbG9hZCBpbW1lZGlhdGVseSBhbmQgdGhhdCBpdCBpcyBjYW5jZWxsYWJs ZS4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zaG91 bGRub3RleGVjdXRlLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdjYW5jZWxsZWQgb25iZWZvcmVs b2FkIGRlZmVyJyk7IHJldHVybiBmYWxzZTsiIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9 InJlc291cmNlcy9kZWZlci5qcyIgb25iZWZvcmVsb2FkPSJkZWJ1Zygnb25iZWZvcmVsb2FkIGRl ZmVyJyk7IHJldHVybiB0cnVlOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3Vy Y2VzL2V4dGVybmFsLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdvbmJlZm9yZWxvYWQgZXh0ZXJu YWwnKTsgcmV0dXJuIHRydWU7Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1p bnZhbGlkLXVybC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjA0NWFmMWRjZDY5YWY4Njc1MjdiN2ZlZDU5ZGYxMzAzZTQ2M2M0OGMKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMyBAQAorQ2hlY2tzIHRoYXQgZGVm ZXJyZWQgc2NyaXB0cyB3aXRoIGludmFsaWQgVVJMcyBhcmUgaWdub3JlZCBhbmQgc3Vic2VxdWVu dCBkZWZlcnJlZCBzY3JpcHRzIGV4ZWN1dGVkLgorZGVmZXIKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJs Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3Jp cHQtaW52YWxpZC11cmwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kNWEzZTUxZmI5MzJjMjQ4MjcxZWI1OTg4 ZmJhMWY0MzJiODdkM2Q4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLmh0bWwKQEAgLTAsMCAr MSwxMyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgor PGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVz b3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVja3MgdGhh dCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFuZCBzdWJz ZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rp dj4KKzxzY3JpcHQgc3JjPSJodHRwOi8vaW52YWxpZDo5OTk5OTkvIiBkZWZlcj48L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZGVmZXIuanMiIGRlZmVyPjwvc2NyaXB0PgorPC9ib2R5 PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIy ZTlhNDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMGMwYmJm ZjQ1NjE3NmYxNmQ5NjYzYWEwOTlmYzM2ODE5ZTRkYjljMQotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKQEAg LTAsMCArMSw2IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwK KzxzY3JpcHQgZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgn UEFTUycpOyI+PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZGVmZXIuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZGVmZXIuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFh NmUxYzQ0Mjg3YzNiNmNmNGVmZDYxMjEwOGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcwpAQCAt MCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5mYmFkNDY1MjM0MjA1NWNlYmIxOWQxNDQ1MmViZGUxZWE0NDc3ZWY4Ci0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2Vz L2V4dGVybmFsLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIpOwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3Vs ZG5vdGV4ZWN1dGUuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9y ZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMGQ2OTU0MDE2MmY5YWQ3 Y2FiMWYwMjA3NmRmODFiMTk3MTdiZDkwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMK QEAgLTAsMCArMSBAQAorZGVidWcoIkZBSUwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9zaG91bGRub3Rl eGVjdXRlLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy1leHBl Y3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVm ZXItd3JpdGVzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ZWYyMmU5YTQzMWFkMDI3MjcxM2I3 MWZkYzg3OTQwMTZjOGVmMTJmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy1leHBlY3RlZC50eHQKQEAgLTAs MCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjRiMGQzNzg3 MzA1ZDgyNGJhODc2ZTJiNjE0ZTM2YzFjNmYwNDViN2MKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwK QEAgLTAsMCArMSw3IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZB SUwKKzxzY3JpcHQgZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0 ZSgnUEFTUycpOyI+PC9zY3JpcHQ+Cis8c2NyaXB0IGRlZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFz Y3JpcHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3Jp cHQuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRlZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0NzdlZjgKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFs LXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHkt YmFja2dyb3VuZC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2Ny aXB0LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZmJlN2ExYzQyNDhkYWMz ODI1NTM1YTc0ZGNmNTQzNGM0ZjZiOTQyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpz CkBAIC0wLDAgKzEgQEAKK3Nob3VsZEJlRXF1YWxUb1N0cmluZygiZ2V0Q29tcHV0ZWRTdHlsZShk b2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvciddIiwgInJnYigyNTUsIDAsIDApIik7CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC13 cml0ZS1zbG93LXN0eWxlc2hlZXQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWQxMWVi NTJjNmVmN2ZlZWYxNTFkMmQ0Nzk5ZTNkYzJhZWIyNzZmMwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5 bGVzaGVldC5qcwpAQCAtMCwwICsxIEBACitkb2N1bWVudC53cml0ZSgnPGxpbmsgcmVsPSJzdHls ZXNoZWV0IiBocmVmPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1z dHlsZXNoZWV0LmNnaSI+Jyk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVz dHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE5OGQz ZDVhODFkMzc4ODc2OTJjNzM5MjJjOGQzYzI5ZjFiNmJkMTgKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNn aQpAQCAtMCwwICsxLDUgQEAKKyMhL3Vzci9iaW4vcGVybCAtdworCitwcmludCAiQ29udGVudC10 eXBlOiB0ZXh0L2phdmFzY3JpcHRcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiZGVidWcoJ3Ns b3dEZWZlcicpO1xuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mY2RkY2E0MDFmOGFi M2E2YTVkZjg3M2E2NTQxYzdmNDBhYjA5ZWNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCkBAIC0wLDAg KzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQv Y3NzXG5cbiI7CitzbGVlcCgwLjUpOworcHJpbnQgImJvZHkgeyBiYWNrZ3JvdW5kLWNvbG9yOiAj RkYwMDAwIH1cbiI7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uNDkwYWYwOGQyZGY2MDBjYmJiOTJjNTFjYzgyZTQxNDQyNTY2 YzRkMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3Jp cHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDkg QEAKK1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1dGVzIGJl Zm9yZSBkZWZlcnJlZCBzY3JpcHRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJp ZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKK1BB U1MgZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvciddIGlz ICJyZ2IoMjU1LCAwLCAwKSIKK0RPTUNvbnRlbnRMb2FkZWQKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFy c2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbCBiL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNo ZWV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uMDZlYzg0OWMzODlkNDM5YmI3OTQ4MGVmYjNmMzM3N2MzNTQz YzE5OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3Jp cHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAsMCArMSwzMiBAQAorPCFE T0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVh ZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBj aGFyc2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy10 ZXN0LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMt dGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+ Cis8ZHZpIGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4K KzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUaGlzIHRlc3Rz IHRoYXQgYW4gaW5saW5lIHNsb3cgc3R5bGVzaGVldCBleGVjdXRlcyBiZWZvcmUgZGVmZXJyZWQg c2NyaXB0cy4nKTsKKwordmFyIGpzVGVzdElzQXN5bmMgPSB0cnVlOworCitkb2N1bWVudC5hZGRF dmVudExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdE T01Db250ZW50TG9hZGVkJyk7CisKKyAgZmluaXNoSlNUZXN0KCk7Cit9LCBmYWxzZSk7Cis8L3Nj cmlwdD4KKworPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNl cy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLgoranMiIGRlZmVyPSJkZWZlciI+PC9zY3Jp cHQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9t aXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlCitldC5jZ2kiPgorPHNjcmlwdD4KK3ZhciBzdWNj ZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMt dGVzdC1yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIt ZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWY0NTE4NzMzMzZiY2NlODBjMWVhODBhOWY4Y2Y3NDMx OTdhNWJiYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9z Y3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGhpcyB0ZXN0cyBmb3Ig cHJvcGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0 ZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAuCitleHRlcm5h bAoraW5saW5lCitzbG93RGVmZXIKK2RlZmVyCitET01Db250ZW50TG9hZGVkCitsb2FkCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwgYi9M YXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u OTVjZjhiMzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2MzMwotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbApAQCAtMCww ICsxLDI0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+ Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50 PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhy ZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQg c3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgorVGhpcyB0ZXN0cyBmb3IgcHJv cGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSA8 YSBocmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAiPmh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMDwvYT4uCis8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZG9j dW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkgewor ICBkZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+Cis8c2Ny aXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXIt c2NyaXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8v MTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzIiBkZWZlcj0iREVG RVIiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jl c291cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2RlYnVnKCJp bmxpbmUiKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0MTY2YTIzZmQ2YTZjNzUxZGRh MzdmOWRkZGVkNTZmZjE0ZTBiM2M0Li4zY2U3NTJlN2U2YjBlMjFlOTYzNTBkMDNhZDZhM2E4YTU2 MDQ3NWRiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDEwLTA4LTMxICBUb255IEdlbnRpbGNvcmUgIDx0b255 Z0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVjaWZpZWQgYnkgSFRNTDUKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQwOTM0CisKKyAg ICAgICAgVGVzdHM6IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZl ci13cml0ZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbAorICAgICAgICAgICAg ICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLmh0 bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRl Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3R3by1kZWZl ci13cml0ZXMuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZl ci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci5odG1sCisKKyAgICAgICAgKiBodG1sL3BhcnNlci9IVE1MRG9jdW1l bnRQYXJzZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpIVE1M RG9jdW1lbnRQYXJzZXIpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpl bmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9FbmQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpzdG9wKToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6aW5TY3JpcHRFeGVjdXRpb24pOgorICAgICAgICAo V2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZCk6CisgICAgICAgICog aHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmg6CisgICAgICAgICogaHRtbC9wYXJzZXIv SFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVy Ojp+SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVy OjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxT Y3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQ YXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3REZWZl cnJlZFNjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpydW5TY3Jp cHQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuaDoKKwogMjAxMC0w OC0zMCAgUm9iZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgU2ltb24gSGF1c21hbm4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hU TUxEb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBh cnNlci5jcHAKaW5kZXggMjA3YmQzZTYzMjAwYjQ2MTI2Y2QyODA2NGY2MmNiNjYxNDI3YmRiMi4u ZGUxMjNkZjJmZDBiMWY1N2YzMTg1M2UwMjE1MTQyZWU3NzhhNDhhOSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRt bC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtOTksNiArOTksNyBAQCBIVE1MRG9j dW1lbnRQYXJzZXI6OkhUTUxEb2N1bWVudFBhcnNlcihIVE1MRG9jdW1lbnQqIGRvY3VtZW50LCBi b29sIHJlcG9ydEVycm9ycwogICAgICwgbV9zY3JpcHRSdW5uZXIoSFRNTFNjcmlwdFJ1bm5lcjo6 Y3JlYXRlKGRvY3VtZW50LCB0aGlzKSkKICAgICAsIG1fdHJlZUJ1aWxkZXIoSFRNTFRyZWVCdWls ZGVyOjpjcmVhdGUobV90b2tlbml6ZXIuZ2V0KCksIGRvY3VtZW50LCByZXBvcnRFcnJvcnMpKQog ICAgICwgbV9wYXJzZXJTY2hlZHVsZXIoSFRNTFBhcnNlclNjaGVkdWxlcjo6Y3JlYXRlKHRoaXMp KQorICAgICwgbV9hY3RpdmUodHJ1ZSkKICAgICAsIG1fZW5kV2FzRGVsYXllZChmYWxzZSkKICAg ICAsIG1fd3JpdGVOZXN0aW5nTGV2ZWwoMCkKIHsKQEAgLTExMCw2ICsxMTEsNyBAQCBIVE1MRG9j dW1lbnRQYXJzZXI6OkhUTUxEb2N1bWVudFBhcnNlcihEb2N1bWVudEZyYWdtZW50KiBmcmFnbWVu dCwgRWxlbWVudCogY29udAogICAgIDogU2NyaXB0YWJsZURvY3VtZW50UGFyc2VyKGZyYWdtZW50 LT5kb2N1bWVudCgpKQogICAgICwgbV90b2tlbml6ZXIoSFRNTFRva2VuaXplcjo6Y3JlYXRlKCkp CiAgICAgLCBtX3RyZWVCdWlsZGVyKEhUTUxUcmVlQnVpbGRlcjo6Y3JlYXRlKG1fdG9rZW5pemVy LmdldCgpLCBmcmFnbWVudCwgY29udGV4dEVsZW1lbnQsIHNjcmlwdGluZ1Blcm1pc3Npb24pKQor ICAgICwgbV9hY3RpdmUodHJ1ZSkKICAgICAsIG1fZW5kV2FzRGVsYXllZChmYWxzZSkKICAgICAs IG1fd3JpdGVOZXN0aW5nTGV2ZWwoMCkKIHsKQEAgLTMyOCwxNCArMzMwLDYgQEAgdm9pZCBIVE1M RG9jdW1lbnRQYXJzZXI6OmVuZCgpCiAgICAgQVNTRVJUKCFpc0RldGFjaGVkKCkpOwogICAgIEFT U0VSVCghaXNTY2hlZHVsZWRGb3JSZXN1bWUoKSk7CiAKLSAgICAvLyBwdW1wVG9rZW5pemVyIGNh biBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKLSAg ICAvLyBidXQgd2UgbmVlZCB0byBlbnN1cmUgaXQgaXNuJ3QgZGVsZXRlZCB5ZXQuCi0gICAgUmVm UHRyPEhUTUxEb2N1bWVudFBhcnNlcj4gcHJvdGVjdCh0aGlzKTsKLQotICAgIC8vIE5PVEU6IFRo aXMgcHVtcCBzaG91bGQgb25seSBldmVyIGVtaXQgYnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywK LSAgICAvLyBzbyBGb3JjZVN5bmNocm9ub3VzIHZzLiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFu aW5nbGVzcy4KLSAgICBwdW1wVG9rZW5pemVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsK LQogICAgIC8vIEluZm9ybXMgdGhlIHRoZSByZXN0IG9mIFdlYkNvcmUgdGhhdCBwYXJzaW5nIGlz IHJlYWxseSBmaW5pc2hlZCAoYW5kIGRlbGV0ZXMgdGhpcykuCiAgICAgbV90cmVlQnVpbGRlci0+ ZmluaXNoZWQoKTsKIH0KQEAgLTM0OSw3ICszNDMsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNl cjo6YXR0ZW1wdFRvRW5kKCkKICAgICAgICAgbV9lbmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAg ICAgcmV0dXJuOwogICAgIH0KLSAgICBlbmQoKTsKKyAgICBzdG9wKCk7CiB9CiAKIHZvaWQgSFRN TERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQoKQpAQCAtMzYyLDYgKzM1NiwzMCBAQCB2b2lk IEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKICAgICAgICAgcmV0dXJuOwogCiAg ICAgbV9lbmRXYXNEZWxheWVkID0gZmFsc2U7CisgICAgc3RvcCgpOworfQorCisvLyBUaGlzIGtp Y2tzIG9mZiAiT25jZSB0aGUgdXNlciBhZ2VudCBzdG9wcyBwYXJzaW5nIiBhcyBkZXNjcmliZWQg Ynk6CisvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3Jr L211bHRpcGFnZS90aGUtZW5kLmh0bWwjdGhlLWVuZAordm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6 OnN0b3AoKQoreworICAgIEFTU0VSVCghaGFzSW5zZXJ0aW9uUG9pbnQoKSk7CisKKyAgICAvLyBw dW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRo ZSBEb2N1bWVudCwKKyAgICAvLyBidXQgd2UgbmVlZCB0byBlbnN1cmUgaXQgaXNuJ3QgZGVsZXRl ZCB5ZXQuCisgICAgUmVmUHRyPEhUTUxEb2N1bWVudFBhcnNlcj4gcHJvdGVjdCh0aGlzKTsKKwor ICAgIC8vIEZJWE1FOiBTZXQgdGhlIGN1cnJlbnQgZG9jdW1lbnQgcmVhZGluZXNzIHRvICJpbnRl cmFjdGl2ZSIuCisKKyAgICAvLyBOT1RFOiBUaGlzIHB1bXAgc2hvdWxkIG9ubHkgZXZlciBlbWl0 IGJ1ZmZlcmVkIGNoYXJhY3RlciB0b2tlbnMsCisgICAgLy8gc28gRm9yY2VTeW5jaHJvbm91cyB2 cy4gQWxsb3dZaWVsZCBzaG91bGQgYmUgbWVhbmluZ2xlc3MuCisgICAgcHVtcFRva2VuaXplcklm UG9zc2libGUoRm9yY2VTeW5jaHJvbm91cyk7CisKKyAgICBtX2FjdGl2ZSA9IGZhbHNlOworICAg IGlmIChtX3NjcmlwdFJ1bm5lcikgeworICAgICAgICBpZiAoIW1fc2NyaXB0UnVubmVyLT5leGVj dXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKCkpCisgICAgICAgICAgICByZXR1cm47CisgICAg fQogICAgIGVuZCgpOwogfQogCkBAIC0zOTYsNyArNDE0LDcgQEAgYm9vbCBIVE1MRG9jdW1lbnRQ YXJzZXI6OmluU2NyaXB0RXhlY3V0aW9uKCkgY29uc3QKIHsKICAgICBpZiAoIW1fc2NyaXB0UnVu bmVyKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIG1fc2NyaXB0UnVubmVyLT5p c0V4ZWN1dGluZ1NjcmlwdCgpOworICAgIHJldHVybiBtX2FjdGl2ZSAmJiBtX3NjcmlwdFJ1bm5l ci0+aXNFeGVjdXRpbmdTY3JpcHQoKTsKIH0KIAogaW50IEhUTUxEb2N1bWVudFBhcnNlcjo6bGlu ZU51bWJlcigpIGNvbnN0CkBAIC00NDcsNiArNDY1LDExIEBAIGJvb2wgSFRNTERvY3VtZW50UGFy c2VyOjpzaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKGNvbnN0IEF0b21pY1N0cmluZyYg c3JjCiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZChDYWNoZWRSZXNv dXJjZSogY2FjaGVkUmVzb3VyY2UpCiB7CisgICAgaWYgKCFtX2FjdGl2ZSkgeworICAgICAgICBz dG9wKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICAvLyBwdW1wVG9rZW5pemVyIGNh biBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKICAg ICAvLyBidXQgd2UgbmVlZCB0byBlbnN1cmUgaXQgaXNuJ3QgZGVsZXRlZCB5ZXQuCiAgICAgUmVm UHRyPEhUTUxEb2N1bWVudFBhcnNlcj4gcHJvdGVjdCh0aGlzKTsKZGlmZiAtLWdpdCBhL1dlYkNv cmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmggYi9XZWJDb3JlL2h0bWwvcGFyc2Vy L0hUTUxEb2N1bWVudFBhcnNlci5oCmluZGV4IGRhMjFhMmJhMTE0ZTIwMDJiZGUyNGZjYWYzOWVk MDlkYmI1MTlkYzEuLjIxZTBmZDdhOTA2MmNkZWNjYTVkNDg2YTk4YTJlNTY4NTJhZjE2YzUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmgKKysrIGIv V2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuaApAQCAtMTEzLDYgKzExMyw3 IEBAIHByaXZhdGU6CiAgICAgdm9pZCBiZWdpbigpOwogICAgIHZvaWQgYXR0ZW1wdFRvRW5kKCk7 CiAgICAgdm9pZCBlbmRJZkRlbGF5ZWQoKTsKKyAgICB2b2lkIHN0b3AoKTsKICAgICB2b2lkIGVu ZCgpOwogCiAgICAgYm9vbCBpc1NjaGVkdWxlZEZvclJlc3VtZSgpIGNvbnN0OwpAQCAtMTMzLDYg KzEzNCw3IEBAIHByaXZhdGU6CiAgICAgT3duUHRyPEhUTUxQcmVsb2FkU2Nhbm5lcj4gbV9wcmVs b2FkU2Nhbm5lcjsKICAgICBPd25QdHI8SFRNTFBhcnNlclNjaGVkdWxlcj4gbV9wYXJzZXJTY2hl ZHVsZXI7CiAKKyAgICBib29sIG1fYWN0aXZlOyAvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3Bl Y3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNhY3RpdmUtcGFyc2VyCiAgICAgYm9vbCBtX2VuZFdh c0RlbGF5ZWQ7CiAgICAgaW50IG1fd3JpdGVOZXN0aW5nTGV2ZWw7CiB9OwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcCBiL1dlYkNvcmUvaHRtbC9w YXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggNmQ0NzBhMGE1ZTA4YjQwZjY4YTE4MzVh ZjUxODg5MmI4Y2E1YmIxOS4uNzY0YmYwMWE4ZDcxYzcxNjdhY2ZhZTJkMjE4ZmM2MGM4ZDJmMmE3 NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcAor KysgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwCkBAIC03NSw2ICs3 NSwxMiBAQCBIVE1MU2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcigpCiAgICAgLy8gRklY TUU6IFNob3VsZCB3ZSBiZSBwYXNzZWQgYSAiZG9uZSBsb2FkaW5nL3BhcnNpbmciIGNhbGxiYWNr IHNvb25lciB0aGFuIGRlc3RydWN0aW9uPwogICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0Zvckxv YWQoKSkKICAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dCk7CisKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5 KCkpIHsKKyAgICAgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9F eGVjdXRlQWZ0ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAgICBpZiAocGVuZGluZ1Njcmlw dC5jYWNoZWRTY3JpcHQoKSAmJiBwZW5kaW5nU2NyaXB0LndhdGNoaW5nRm9yTG9hZCgpKQorICAg ICAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKyAgICB9CiB9CiAK IHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZGV0YWNoKCkKQEAgLTEyOSwxMCArMTM1LDYgQEAgdm9p ZCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkKICAgICBB U1NFUlQobV9kb2N1bWVudC0+aGF2ZVN0eWxlc2hlZXRzTG9hZGVkKCkpOwogICAgIEFTU0VSVChp c1BlbmRpbmdTY3JpcHRSZWFkeShtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCkpOwogCi0gICAgLy8g U3RvcCB3YXRjaGluZyBsb2FkcyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50IHJlY3Vy c2lvbiBpZiB0aGUgc2NyaXB0IHJlbG9hZHMgaXRzZWxmLgotICAgIGlmIChtX3BhcnNpbmdCbG9j a2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRj aGluZ0ZvckxvYWQoKSkKLSAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9j a2luZ1NjcmlwdCk7Ci0KICAgICBJbnNlcnRpb25Qb2ludFJlY29yZCBpbnNlcnRpb25Qb2ludFJl Y29yZChtX2hvc3QtPmlucHV0U3RyZWFtKCkpOwogICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5k RGlzcGF0Y2hFdmVudChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CkBAIC0xNDIsNiArMTQ0 LDEwIEBAIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHRBbmREaXNw YXRjaEV2ZW50KFBlbmRpbmdTY3JpcHQmIHBlbmRpCiAgICAgYm9vbCBlcnJvck9jY3VycmVkID0g ZmFsc2U7CiAgICAgU2NyaXB0U291cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNlRnJvbVBlbmRp bmdTY3JpcHQocGVuZGluZ1NjcmlwdCwgZXJyb3JPY2N1cnJlZCk7CiAKKyAgICAvLyBTdG9wIHdh dGNoaW5nIGxvYWRzIGJlZm9yZSBleGVjdXRlU2NyaXB0IHRvIHByZXZlbnQgcmVjdXJzaW9uIGlm IHRoZSBzY3JpcHQgcmVsb2FkcyBpdHNlbGYuCisgICAgaWYgKHBlbmRpbmdTY3JpcHQuY2FjaGVk U2NyaXB0KCkgJiYgcGVuZGluZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKKyAgICAgICAgc3Rv cFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKwogICAgIC8vIENsZWFyIHRoZSBwZW5k aW5nIHNjcmlwdCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgp CiAgICAgUmVmUHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBwZW5kaW5nU2NyaXB0LnJlbGVh c2VFbGVtZW50QW5kQ2xlYXIoKTsKICAgICB7CkBAIC0yMzgsNiArMjQ0LDI0IEBAIGJvb2wgSFRN TFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKQogICAg IHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwogfQogCitib29sIEhUTUxT Y3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQoreworICAgIHdo aWxlICghbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAg ICBBU1NFUlQoIW1fc2NyaXB0TmVzdGluZ0xldmVsKTsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFy c2luZ0Jsb2NraW5nU2NyaXB0KCkpOworICAgICAgICBBU1NFUlQobV9zY3JpcHRzVG9FeGVjdXRl QWZ0ZXJQYXJzaW5nLmZpcnN0KCkuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fc2Ny aXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRl ZCgpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxvYWQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQ YXJzaW5nLmZpcnN0KCkpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9Cisg ICAgICAgIFBlbmRpbmdTY3JpcHQgZmlyc3QgPSBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNp bmcudGFrZUZpcnN0KCk7CisgICAgICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hF dmVudChmaXJzdCk7CisgICAgICAgIGlmICghbV9kb2N1bWVudCkKKyAgICAgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHRydWU7Cit9CisKIHZvaWQgSFRNTFNjcmlwdFJ1 bm5lcjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiBlbGVtZW50KQogewog ICAgIGlmICghcmVxdWVzdFBlbmRpbmdTY3JpcHQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVs ZW1lbnQpKQpAQCAtMjUyLDYgKzI3NiwxNiBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVl c3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogZWxlbWVudCkKICAgICAgICAgd2F0Y2hG b3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVu bmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBQZW5k aW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgaWYgKCFyZXF1ZXN0UGVuZGluZ1NjcmlwdChw ZW5kaW5nU2NyaXB0LCBlbGVtZW50KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQVNTRVJUKHBl bmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAgIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVy UGFyc2luZy5hcHBlbmQocGVuZGluZ1NjcmlwdCk7Cit9CisKIGJvb2wgSFRNTFNjcmlwdFJ1bm5l cjo6cmVxdWVzdFBlbmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYgcGVuZGluZ1NjcmlwdCwgRWxl bWVudCogc2NyaXB0KSBjb25zdAogewogICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50 KCkpOwpAQCAtMjg3LDggKzMyMSwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlw dChFbGVtZW50KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdElt cGxlbWVudGVkKCk7IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+ aGFzQXR0cmlidXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRl ZmVyIGFuZCBhc3luYwotICAgICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChz Y3JpcHQpOworICAgICAgICAgICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYy4KKyAgICAgICAgICAg IGlmIChzY3JpcHQtPmhhc0F0dHJpYnV0ZShkZWZlckF0dHIpKQorICAgICAgICAgICAgICAgIHJl cXVlc3REZWZlcnJlZFNjcmlwdChzY3JpcHQpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAg ICAgICAgIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoc2NyaXB0KTsKICAgICAgICAgfSBl bHNlIHsKICAgICAgICAgICAgIC8vIEZJWE1FOiBXZSBkbyBub3QgYmxvY2sgaW5saW5lIDxzY3Jp cHQ+IHRhZ3Mgb24gc3R5bGVzaGVldHMgdG8gbWF0Y2ggdGhlCiAgICAgICAgICAgICAvLyBvbGQg cGFyc2VyIGZvciBub3cuICBXaGVuIHdlIGRvLCB0aGUgQVNTRVJUIGJlbG93IHNob3VsZCBiZSBh ZGRlZC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5o IGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZWFkOTI4OTU0 OWVjMTAyOGE2YTY5N2IyMTRjZTRlYTRjNjEwMDc5ZS4uNDdjOTZmZGJkNDE2ZDAzMWY5NWM2Yzhm NjBhOTU3ZGJiMTQzNWUzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2Ny aXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgK QEAgLTI3LDYgKzI3LDcgQEAKICNkZWZpbmUgSFRNTFNjcmlwdFJ1bm5lcl9oCiAKICNpbmNsdWRl ICJQZW5kaW5nU2NyaXB0LmgiCisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3Rm L05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTYsNiAr NTcsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENh Y2hlZFJlc291cmNlKik7CiAgICAgYm9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRz KCkgY29uc3QgeyByZXR1cm4gbV9oYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9CiAg ICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJvb2wg ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpc0V4ZWN1dGlu Z1NjcmlwdCgpIGNvbnN0IHsgcmV0dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAt NzEsNiArNzMsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1Nj cmlwdHMoKTsKIAogICAgIHZvaWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50 Kik7CisgICAgdm9pZCByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIGJvb2wg cmVxdWVzdFBlbmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKSBjb25zdDsKIAog ICAgIHZvaWQgcnVuU2NyaXB0KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKQEAg LTg0LDYgKzg3LDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKICAgICBI VE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5n QmxvY2tpbmdTY3JpcHQ7CisgICAgRGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3JpcHRzVG9FeGVj dXRlQWZ0ZXJQYXJzaW5nOyAvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMv Y3VycmVudC13b3JrLyNsaXN0LW9mLXNjcmlwdHMtdGhhdC13aWxsLWV4ZWN1dGUtd2hlbi10aGUt ZG9jdW1lbnQtaGFzLWZpbmlzaGVkLXBhcnNpbmcKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3Rp bmdMZXZlbDsKIAogICAgIC8vIFdlIG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdn ZXIgc2NyaXB0IGV4ZWN1dGlvbiBpZiBzY3JpcHQK 66099 2010-08-31 14:01:21 -0700 2010-08-31 18:34:53 -0700 Naming fixes bug-40934-20100831140120.patch text/plain 30507 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NzljMzIxYWNjZDdkNjRlMGY5ZDRhZDBiMWQ4ZGQxOWZiMmY1ODk3Li41ODlhOTU4 M2U2MTE4NDdlNjdhNTdjNDc0NTkwZDIxNzMzZWM2YjhkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDgtMzEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IEFkZGVk LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZl ci13cml0ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNj cmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LXdyaXRlLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90ZXhlY3V0ZS5q czogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVy LXdyaXRlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAg ICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91 bmQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAg ICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRl ZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sOiBBZGRlZC4KKwogMjAxMC0wOC0zMSAgVG9u eSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHVwZGF0 aW5nIGNocm9taXVtIHRlc3RfZXhwZWN0YXRpb25zLnR4dC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIyZTlhNDMx YWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1s IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRl ZmVyLXdyaXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQxMjA1MGIyZTQzYjY5NDkxYjU0MzQ3MzVmMmQ2 ZmU1MTRlZjk5ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBA QAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRl ZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsgZG9j dW1lbnQud3JpdGUoJzxzY3JpcHQgZGVmZXIgc3JjPVwnZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9j dW1lbnQud3JpdGUoJnF1b3Q7UEFTUyZxdW90Oyk7XCc+PC9zY3JpcHQ+Jyk7IGRvY3VtZW50LmNs b3NlKCk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjhkMDRmOTYxYTAzNzExN2MxZWFhNjlhYzYwZWIzNjNkMzdhZTc4ZDEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKKzEgMgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNTVlMWQzZGIzZjk2M2M4Zjk3YTk3 NjUyYTA0YTZjYTFmY2RhYzkxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSw2 IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwKKzxzY3JpcHQg ZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZWxuKDEpOyBkb2N1 bWVudC53cml0ZSgnPHNjcmlwdCBzcmM9XCdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53 cml0ZWxuKDIpXCc+PC9zY3JpcHQ+Jyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5s aW5lLXNjcmlwdC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOWIwMmQxNjMxNzdmNTY1Y2RiN2Qw Y2U1NmIzNWI4NTQzMzIxMzljZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsMyBAQAorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJl ZC4KKzEKKzIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMTVjMjAx MTlhYzQ4MDQ1NjIwNzQ0OGRmMjg2MzUyMzhhOWZlOTU3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5o dG1sCkBAIC0wLDAgKzEsMTUgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFRE IEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9 Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4v Li4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 PgorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KKzxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRlYnVn KDIpOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IGRlZmVyPgorICBkZWJ1ZygxKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYmEzZTM3MWY3MDI4ZmExMzgwZTJhMzVmNTQ1NDgxYjk0YWIy MDEwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZl cgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9yZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitk ZWZlcgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv ZGVmZXItb25iZWZvcmVsb2FkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMjJiMTg0ZGE2M2Jh NDc1NzExYmUxZjdiZjU5NTk5YTU0MTYwZTJhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKQEAg LTAsMCArMSwxNCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8v RU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4v anMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5IGFu ZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ2NhbmNlbGxlZCBvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIGZhbHNlOyIgZGVmZXI+ PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBvbmJlZm9yZWxvYWQ9 ImRlYnVnKCdvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIHRydWU7IiBkZWZlcj48L3Njcmlw dD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZXh0ZXJuYWwuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ29uYmVmb3JlbG9hZCBleHRlcm5hbCcpOyByZXR1cm4gdHJ1ZTsiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQ1YWYxZGNkNjlhZjg2NzUyN2I3ZmVkNTlkZjEzMDNl NDYzYzQ4YwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSwzIEBACitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFy ZSBpZ25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCitkZWZl cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmQ1 YTNlNTFmYjkzMmMyNDgyNzFlYjU5ODhmYmExZjQzMmI4N2QzZDgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52 YWxpZC11cmwuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0v L0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVS THMgYXJlIGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBleGVjdXRlZC4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly9pbnZhbGlkOjk5 OTk5OS8iIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIg ZGVmZXI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uN2VmMjJlOWE0MzFhZDAyNzI3MTNiNzFmZGM4Nzk0MDE2YzhlZjEy ZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4wYzBiYmZmNDU2MTc2ZjE2ZDk2NjNhYTA5OWZjMzY4MTllNGRiOWMx Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZh c2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBi L0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5q cwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv cmVzb3VyY2VzL2RlZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3Vy Y2VzL2V4dGVybmFsLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJk ZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWco ImV4dGVybmFsIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmMwZDY5NTQwMTYyZjlhZDdjYWIxZjAyMDc2ZGY4MWIxOTcxN2JkOTAKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiRkFJTCIpOwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90 ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3Vs ZG5vdGV4ZWN1dGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUxYzQ0Mjg3YzNiNmNmNGVmZDYx MjEwOGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRl ZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC90d28tZGVmZXItd3JpdGVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjdlZjIyZTlhNDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3Jp dGVzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNGIwZDM3ODczMDVkODI0YmE4NzZlMmI2MTRlMzZjMWM2ZjA0NWI3Ywot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3R3by1kZWZlci13cml0ZXMuaHRtbApAQCAtMCwwICsxLDcgQEAKKzxzY3JpcHQ+CitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9q YXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KKzxzY3JpcHQgZGVm ZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgnRkFJTCcpOyI+PC9z Y3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2RlZmVyLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv ZGVmZXItc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2 MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIi KTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0 ZXJuYWwtc2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9l eHRlcm5hbC1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJl YmRlMWVhNDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJl eHRlcm5hbCIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjZmYmU3YTFjNDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1k ZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCJnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10i LCAicmdiKDI1NSwgMCwgMCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVl dC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lZDExZWI1MmM2ZWY3ZmVlZjE1MWQyZDQ3OTllM2RjMmFlYjI3NmYz Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzCkBAIC0wLDAgKzEgQEAKK2RvY3VtZW50 LndyaXRlKCc8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAw MC9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4nKTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dp IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlw dC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQx OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJs IC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAo MC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZjZGRjYTQwMWY4YWIzYTZhNWRmODczYTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct c3R5bGVzaGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJp bnQgIkNvbnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiYm9k eSB7IGJhY2tncm91bmQtY29sb3I6ICNGRjAwMDAgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0 ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40OTBhZjA4ZDJkZjYw MGNiYmI5MmM1MWNjODJlNDE0NDI1NjZjNGQyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0cyB0aGF0IGFuIGlubGluZSBzbG93 IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNjcmlwdHMuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworUEFTUyBnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkp WydiYWNrZ3JvdW5kLWNvbG9yJ10gaXMgInJnYigyNTUsIDAsIDApIgorRE9NQ29udGVudExvYWRl ZAorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wNmVjODQ5YzM4OWQ0 MzliYjc5NDgwZWZiM2YzMzc3YzM1NDNjMTk5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRt bApAQCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBI VE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBl IiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxl c2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkdmkgaWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor ZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4 ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLicpOworCit2YXIganNUZXN0SXNBc3luYyA9 IHRydWU7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBm dW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rl c3QoKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4w LjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuCitq cyIgZGVmZXI9ImRlZmVyIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0i aHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGUKK2V0LmNn aSI+Cis8c2NyaXB0PgordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwv c2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lZjQ1MTg3MzMz NmJjY2U4MGMxZWE4MGE5ZjhjZjc0MzE5N2E1YmJjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSw3IEBACitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMg d2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMDcxMC4KK2V4dGVybmFsCitpbmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNv bnRlbnRMb2FkZWQKK2xvYWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9zY3JpcHQtZGVmZXIuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NWNmOGIzNTA3NWZhMThiZDYyM2JjZDZjYWQ2YWU2N2Rl NWQzYzMzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci5odG1sCkBAIC0wLDAgKzEsMjQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAi LS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2 PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIgLz4KKzxs aW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0iZGVidWcoJ2xvYWQn KSI+CitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0 aCB0aGUgZGVmZXIgYXR0cmlidXRlIDxhIGhyZWY9Imh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDcxMCI+aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwNzEwPC9hPi4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50 TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7Cit9LCBm YWxzZSk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlz Yy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9kZWZl ci1zY3JpcHQuanMiIGRlZmVyPSJERUZFUiI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDov LzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0PgorZGVidWcoImlubGluZSIpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0 bWw+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDNiZDQ5ZGJjZWU1YmU4NDkzZDlhODFhNDY2OTRmN2UwMzljYWYzMjcuLmU4M2Y2NmE3OTA4 MGQwOWRhOTFiYTdjMWZmZWQzNmZlZWUzMjc0ZGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzggQEAKKzIwMTAtMDgtMzEg IFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3JpcHQgZGVmZXI+IGFz IHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBUZXN0czogZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sCisgICAgICAgICAg ICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwK KyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3Jl bG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sCisgICAgICAgICAgICAgICBodHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKKworICAgICAgICAq IGh0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpI VE1MRG9jdW1lbnRQYXJzZXI6OkhUTUxEb2N1bWVudFBhcnNlcik6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1l bnRQYXJzZXI6OmF0dGVtcHRUb0VuZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQ YXJzZXI6OmVuZElmRGVsYXllZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJz ZXI6OnByZXBhcmVUb0VuZCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6 OmluU2NyaXB0RXhlY3V0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNl cjo6bm90aWZ5RmluaXNoZWQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBh cnNlci5oOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6fkhUTUxTY3JpcHRSdW5uZXIpOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1Nj cmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGVuZGlu Z1NjcmlwdEFuZERpc3BhdGNoRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1 bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQpOgorICAgICAgICAoV2Vi Q29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KToKKyAgICAgICAgKiBodG1sL3BhcnNl ci9IVE1MU2NyaXB0UnVubmVyLmg6CisKIDIwMTAtMDgtMzAgIElseWEgVGlraG9ub3Zza3kgIDxs b2lzbG9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEpvc2VwaCBQZWNvcmFy by4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNw cCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcAppbmRleCAyMDdi ZDNlNjMyMDBiNDYxMjZjZDI4MDY0ZjYyY2I2NjE0MjdiZGIyLi41MzQ4NWNmZDA2NTMzYWI3YTM0 YzZkMDRjNDliZDg3NGZkMTA0MzQ1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hU TUxEb2N1bWVudFBhcnNlci5jcHAKKysrIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1l bnRQYXJzZXIuY3BwCkBAIC0xMDAsNiArMTAwLDcgQEAgSFRNTERvY3VtZW50UGFyc2VyOjpIVE1M RG9jdW1lbnRQYXJzZXIoSFRNTERvY3VtZW50KiBkb2N1bWVudCwgYm9vbCByZXBvcnRFcnJvcnMK ICAgICAsIG1fdHJlZUJ1aWxkZXIoSFRNTFRyZWVCdWlsZGVyOjpjcmVhdGUobV90b2tlbml6ZXIu Z2V0KCksIGRvY3VtZW50LCByZXBvcnRFcnJvcnMpKQogICAgICwgbV9wYXJzZXJTY2hlZHVsZXIo SFRNTFBhcnNlclNjaGVkdWxlcjo6Y3JlYXRlKHRoaXMpKQogICAgICwgbV9lbmRXYXNEZWxheWVk KGZhbHNlKQorICAgICwgbV9ydW5uaW5nRGVmZXJyZWRTY3JpcHRzKGZhbHNlKQogICAgICwgbV93 cml0ZU5lc3RpbmdMZXZlbCgwKQogewogfQpAQCAtMTExLDYgKzExMiw3IEBAIEhUTUxEb2N1bWVu dFBhcnNlcjo6SFRNTERvY3VtZW50UGFyc2VyKERvY3VtZW50RnJhZ21lbnQqIGZyYWdtZW50LCBF bGVtZW50KiBjb250CiAgICAgLCBtX3Rva2VuaXplcihIVE1MVG9rZW5pemVyOjpjcmVhdGUoKSkK ICAgICAsIG1fdHJlZUJ1aWxkZXIoSFRNTFRyZWVCdWlsZGVyOjpjcmVhdGUobV90b2tlbml6ZXIu Z2V0KCksIGZyYWdtZW50LCBjb250ZXh0RWxlbWVudCwgc2NyaXB0aW5nUGVybWlzc2lvbikpCiAg ICAgLCBtX2VuZFdhc0RlbGF5ZWQoZmFsc2UpCisgICAgLCBtX3J1bm5pbmdEZWZlcnJlZFNjcmlw dHMoZmFsc2UpCiAgICAgLCBtX3dyaXRlTmVzdGluZ0xldmVsKDApCiB7CiAgICAgYm9vbCByZXBv cnRFcnJvcnMgPSBmYWxzZTsgLy8gRm9yIG5vdyBkb2N1bWVudCBmcmFnbWVudCBwYXJzaW5nIG5l dmVyIHJlcG9ydHMgZXJyb3JzLgpAQCAtMzI4LDE0ICszMzAsNiBAQCB2b2lkIEhUTUxEb2N1bWVu dFBhcnNlcjo6ZW5kKCkKICAgICBBU1NFUlQoIWlzRGV0YWNoZWQoKSk7CiAgICAgQVNTRVJUKCFp c1NjaGVkdWxlZEZvclJlc3VtZSgpKTsKIAotICAgIC8vIHB1bXBUb2tlbml6ZXIgY2FuIGNhdXNl IHRoaXMgcGFyc2VyIHRvIGJlIGRldGFjaGVkIGZyb20gdGhlIERvY3VtZW50LAotICAgIC8vIGJ1 dCB3ZSBuZWVkIHRvIGVuc3VyZSBpdCBpc24ndCBkZWxldGVkIHlldC4KLSAgICBSZWZQdHI8SFRN TERvY3VtZW50UGFyc2VyPiBwcm90ZWN0KHRoaXMpOwotCi0gICAgLy8gTk9URTogVGhpcyBwdW1w IHNob3VsZCBvbmx5IGV2ZXIgZW1pdCBidWZmZXJlZCBjaGFyYWN0ZXIgdG9rZW5zLAotICAgIC8v IHNvIEZvcmNlU3luY2hyb25vdXMgdnMuIEFsbG93WWllbGQgc2hvdWxkIGJlIG1lYW5pbmdsZXNz LgotICAgIHB1bXBUb2tlbml6ZXJJZlBvc3NpYmxlKEZvcmNlU3luY2hyb25vdXMpOwotCiAgICAg Ly8gSW5mb3JtcyB0aGUgdGhlIHJlc3Qgb2YgV2ViQ29yZSB0aGF0IHBhcnNpbmcgaXMgcmVhbGx5 IGZpbmlzaGVkIChhbmQgZGVsZXRlcyB0aGlzKS4KICAgICBtX3RyZWVCdWlsZGVyLT5maW5pc2hl ZCgpOwogfQpAQCAtMzQ5LDcgKzM0Myw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjphdHRl bXB0VG9FbmQoKQogICAgICAgICBtX2VuZFdhc0RlbGF5ZWQgPSB0cnVlOwogICAgICAgICByZXR1 cm47CiAgICAgfQotICAgIGVuZCgpOworICAgIHByZXBhcmVUb0VuZCgpOwogfQogCiB2b2lkIEhU TUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKQEAgLTM2Miw2ICszNTYsMzEgQEAgdm9p ZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZElmRGVsYXllZCgpCiAgICAgICAgIHJldHVybjsKIAog ICAgIG1fZW5kV2FzRGVsYXllZCA9IGZhbHNlOworICAgIHByZXBhcmVUb0VuZCgpOworfQorCisv LyBUaGlzIGtpY2tzIG9mZiAiT25jZSB0aGUgdXNlciBhZ2VudCBzdG9wcyBwYXJzaW5nIiBhcyBk ZXNjcmliZWQgYnk6CisvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3Vy cmVudC13b3JrL211bHRpcGFnZS90aGUtZW5kLmh0bWwjdGhlLWVuZAordm9pZCBIVE1MRG9jdW1l bnRQYXJzZXI6OnByZXBhcmVUb0VuZCgpCit7CisgICAgQVNTRVJUKCFoYXNJbnNlcnRpb25Qb2lu dCgpKTsKKworICAgIC8vIHB1bXBUb2tlbml6ZXIgY2FuIGNhdXNlIHRoaXMgcGFyc2VyIHRvIGJl IGRldGFjaGVkIGZyb20gdGhlIERvY3VtZW50LAorICAgIC8vIGJ1dCB3ZSBuZWVkIHRvIGVuc3Vy ZSBpdCBpc24ndCBkZWxldGVkIHlldC4KKyAgICBSZWZQdHI8SFRNTERvY3VtZW50UGFyc2VyPiBw cm90ZWN0KHRoaXMpOworCisgICAgLy8gRklYTUU6IFNldCB0aGUgY3VycmVudCBkb2N1bWVudCBy ZWFkaW5lc3MgdG8gImludGVyYWN0aXZlIi4KKworICAgIC8vIE5PVEU6IFRoaXMgcHVtcCBzaG91 bGQgb25seSBldmVyIGVtaXQgYnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywKKyAgICAvLyBzbyBG b3JjZVN5bmNocm9ub3VzIHZzLiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFuaW5nbGVzcy4KKyAg ICBwdW1wVG9rZW5pemVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsKKworICAgIG1fcnVu bmluZ0RlZmVycmVkU2NyaXB0cyA9IHRydWU7CisgICAgaWYgKG1fc2NyaXB0UnVubmVyKSB7Cisg ICAgICAgIGlmICghbV9zY3JpcHRSdW5uZXItPmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNp bmcoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBlbmQoKTsKIH0KIApAQCAt Mzk2LDcgKzQxNSw3IEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjppblNjcmlwdEV4ZWN1dGlv bigpIGNvbnN0CiB7CiAgICAgaWYgKCFtX3NjcmlwdFJ1bm5lcikKICAgICAgICAgcmV0dXJuIGZh bHNlOwotICAgIHJldHVybiBtX3NjcmlwdFJ1bm5lci0+aXNFeGVjdXRpbmdTY3JpcHQoKTsKKyAg ICByZXR1cm4gIW1fcnVubmluZ0RlZmVycmVkU2NyaXB0cyAmJiBtX3NjcmlwdFJ1bm5lci0+aXNF eGVjdXRpbmdTY3JpcHQoKTsKIH0KIAogaW50IEhUTUxEb2N1bWVudFBhcnNlcjo6bGluZU51bWJl cigpIGNvbnN0CkBAIC00NDcsNiArNDY2LDExIEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpz aG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKGNvbnN0IEF0b21pY1N0cmluZyYgc3JjCiAK IHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZChDYWNoZWRSZXNvdXJjZSog Y2FjaGVkUmVzb3VyY2UpCiB7CisgICAgaWYgKG1fcnVubmluZ0RlZmVycmVkU2NyaXB0cykgewor ICAgICAgICBwcmVwYXJlVG9FbmQoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAgIC8v IHB1bXBUb2tlbml6ZXIgY2FuIGNhdXNlIHRoaXMgcGFyc2VyIHRvIGJlIGRldGFjaGVkIGZyb20g dGhlIERvY3VtZW50LAogICAgIC8vIGJ1dCB3ZSBuZWVkIHRvIGVuc3VyZSBpdCBpc24ndCBkZWxl dGVkIHlldC4KICAgICBSZWZQdHI8SFRNTERvY3VtZW50UGFyc2VyPiBwcm90ZWN0KHRoaXMpOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuaCBiL1dl YkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmgKaW5kZXggZGEyMWEyYmExMTRl MjAwMmJkZTI0ZmNhZjM5ZWQwOWRiYjUxOWRjMS4uZGVlMmI5NDRkMDIwNjEwYjQ5MzUyNmY0ZWNk ZGJlN2U4YzFhYzc0MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1l bnRQYXJzZXIuaAorKysgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5o CkBAIC0xMTMsNiArMTEzLDcgQEAgcHJpdmF0ZToKICAgICB2b2lkIGJlZ2luKCk7CiAgICAgdm9p ZCBhdHRlbXB0VG9FbmQoKTsKICAgICB2b2lkIGVuZElmRGVsYXllZCgpOworICAgIHZvaWQgcHJl cGFyZVRvRW5kKCk7CiAgICAgdm9pZCBlbmQoKTsKIAogICAgIGJvb2wgaXNTY2hlZHVsZWRGb3JS ZXN1bWUoKSBjb25zdDsKQEAgLTEzNCw2ICsxMzUsNyBAQCBwcml2YXRlOgogICAgIE93blB0cjxI VE1MUGFyc2VyU2NoZWR1bGVyPiBtX3BhcnNlclNjaGVkdWxlcjsKIAogICAgIGJvb2wgbV9lbmRX YXNEZWxheWVkOworICAgIGJvb2wgbV9ydW5uaW5nRGVmZXJyZWRTY3JpcHRzOwogICAgIGludCBt X3dyaXRlTmVzdGluZ0xldmVsOwogfTsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNl ci9IVE1MU2NyaXB0UnVubmVyLmNwcCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1 bm5lci5jcHAKaW5kZXggNmQ0NzBhMGE1ZTA4YjQwZjY4YTE4MzVhZjUxODg5MmI4Y2E1YmIxOS4u NzY0YmYwMWE4ZDcxYzcxNjdhY2ZhZTJkMjE4ZmM2MGM4ZDJmMmE3NyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwv cGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwCkBAIC03NSw2ICs3NSwxMiBAQCBIVE1MU2NyaXB0 UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcigpCiAgICAgLy8gRklYTUU6IFNob3VsZCB3ZSBiZSBw YXNzZWQgYSAiZG9uZSBsb2FkaW5nL3BhcnNpbmciIGNhbGxiYWNrIHNvb25lciB0aGFuIGRlc3Ry dWN0aW9uPwogICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAm JiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKICAgICAgICAgc3Rv cFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisKKyAgICB3aGlsZSAo IW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgUGVu ZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5n LnRha2VGaXJzdCgpOworICAgICAgICBpZiAocGVuZGluZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAm JiBwZW5kaW5nU2NyaXB0LndhdGNoaW5nRm9yTG9hZCgpKQorICAgICAgICAgICAgc3RvcFdhdGNo aW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKyAgICB9CiB9CiAKIHZvaWQgSFRNTFNjcmlwdFJ1 bm5lcjo6ZGV0YWNoKCkKQEAgLTEyOSwxMCArMTM1LDYgQEAgdm9pZCBIVE1MU2NyaXB0UnVubmVy OjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkKICAgICBBU1NFUlQobV9kb2N1bWVudC0+ aGF2ZVN0eWxlc2hlZXRzTG9hZGVkKCkpOwogICAgIEFTU0VSVChpc1BlbmRpbmdTY3JpcHRSZWFk eShtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCkpOwogCi0gICAgLy8gU3RvcCB3YXRjaGluZyBsb2Fk cyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0 IHJlbG9hZHMgaXRzZWxmLgotICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRT Y3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKLSAg ICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7Ci0KICAg ICBJbnNlcnRpb25Qb2ludFJlY29yZCBpbnNlcnRpb25Qb2ludFJlY29yZChtX2hvc3QtPmlucHV0 U3RyZWFtKCkpOwogICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChtX3Bh cnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CkBAIC0xNDIsNiArMTQ0LDEwIEBAIHZvaWQgSFRNTFNj cmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHRBbmREaXNwYXRjaEV2ZW50KFBlbmRpbmdT Y3JpcHQmIHBlbmRpCiAgICAgYm9vbCBlcnJvck9jY3VycmVkID0gZmFsc2U7CiAgICAgU2NyaXB0 U291cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNlRnJvbVBlbmRpbmdTY3JpcHQocGVuZGluZ1Nj cmlwdCwgZXJyb3JPY2N1cnJlZCk7CiAKKyAgICAvLyBTdG9wIHdhdGNoaW5nIGxvYWRzIGJlZm9y ZSBleGVjdXRlU2NyaXB0IHRvIHByZXZlbnQgcmVjdXJzaW9uIGlmIHRoZSBzY3JpcHQgcmVsb2Fk cyBpdHNlbGYuCisgICAgaWYgKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgcGVuZGlu Z1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKKyAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChw ZW5kaW5nU2NyaXB0KTsKKwogICAgIC8vIENsZWFyIHRoZSBwZW5kaW5nIHNjcmlwdCBiZWZvcmUg cG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgpCiAgICAgUmVmUHRyPEVsZW1l bnQ+IHNjcmlwdEVsZW1lbnQgPSBwZW5kaW5nU2NyaXB0LnJlbGVhc2VFbGVtZW50QW5kQ2xlYXIo KTsKICAgICB7CkBAIC0yMzgsNiArMjQ0LDI0IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhl Y3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFy c2luZ0Jsb2NraW5nU2NyaXB0cygpOwogfQogCitib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1 dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQoreworICAgIHdoaWxlICghbV9zY3JpcHRzVG9F eGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIW1fc2NyaXB0 TmVzdGluZ0xldmVsKTsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0 KCkpOworICAgICAgICBBU1NFUlQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0 KCkuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVy UGFyc2luZy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgICAg ICB3YXRjaEZvckxvYWQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0KCkpOwor ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAgICAgIFBlbmRpbmdTY3Jp cHQgZmlyc3QgPSBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcudGFrZUZpcnN0KCk7Cisg ICAgICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChmaXJzdCk7CisgICAg ICAgIGlmICghbV9kb2N1bWVudCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9Cisg ICAgcmV0dXJuIHRydWU7Cit9CisKIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBhcnNp bmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiBlbGVtZW50KQogewogICAgIGlmICghcmVxdWVzdFBl bmRpbmdTY3JpcHQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVsZW1lbnQpKQpAQCAtMjUyLDYg KzI3NiwxNiBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdT Y3JpcHQoRWxlbWVudCogZWxlbWVudCkKICAgICAgICAgd2F0Y2hGb3JMb2FkKG1fcGFyc2luZ0Js b2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJy ZWRTY3JpcHQoRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdT Y3JpcHQ7CisgICAgaWYgKCFyZXF1ZXN0UGVuZGluZ1NjcmlwdChwZW5kaW5nU2NyaXB0LCBlbGVt ZW50KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQVNTRVJUKHBlbmRpbmdTY3JpcHQuY2FjaGVk U2NyaXB0KCkpOworICAgIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5hcHBlbmQocGVu ZGluZ1NjcmlwdCk7Cit9CisKIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBlbmRpbmdT Y3JpcHQoUGVuZGluZ1NjcmlwdCYgcGVuZGluZ1NjcmlwdCwgRWxlbWVudCogc2NyaXB0KSBjb25z dAogewogICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KCkpOwpAQCAtMjg3LDggKzMy MSwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBzY3JpcHQs IGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIGV2 ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKHNyY0F0 dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBhc3luYwotICAg ICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOworICAgICAgICAg ICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYy4KKyAgICAgICAgICAgIGlmIChzY3JpcHQtPmhhc0F0 dHJpYnV0ZShkZWZlckF0dHIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3REZWZlcnJlZFNjcmlw dChzY3JpcHQpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJlcXVlc3RQYXJz aW5nQmxvY2tpbmdTY3JpcHQoc2NyaXB0KTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAg IC8vIEZJWE1FOiBXZSBkbyBub3QgYmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVz aGVldHMgdG8gbWF0Y2ggdGhlCiAgICAgICAgICAgICAvLyBvbGQgcGFyc2VyIGZvciBub3cuICBX aGVuIHdlIGRvLCB0aGUgQVNTRVJUIGJlbG93IHNob3VsZCBiZSBhZGRlZC4KZGlmZiAtLWdpdCBh L1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9odG1sL3Bh cnNlci9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZWFkOTI4OTU0OWVjMTAyOGE2YTY5N2IyMTRj ZTRlYTRjNjEwMDc5ZS4uNDdjOTZmZGJkNDE2ZDAzMWY5NWM2YzhmNjBhOTU3ZGJiMTQzNWUzMCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIv V2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKQEAgLTI3LDYgKzI3LDcgQEAK ICNkZWZpbmUgSFRNTFNjcmlwdFJ1bm5lcl9oCiAKICNpbmNsdWRlICJQZW5kaW5nU2NyaXB0Lmgi CisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAj aW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTYsNiArNTcsNyBAQCBwdWJsaWM6CiAg ICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENhY2hlZFJlc291cmNlKik7CiAg ICAgYm9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCkgY29uc3QgeyByZXR1cm4g bV9oYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9CiAgICAgYm9vbCBleGVjdXRlU2Ny aXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNvbnN0IHsg cmV0dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAtNzEsNiArNzMsNyBAQCBwcml2 YXRlOgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKIAogICAgIHZv aWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAgdm9pZCByZXF1 ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIGJvb2wgcmVxdWVzdFBlbmRpbmdTY3Jp cHQoUGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKSBjb25zdDsKIAogICAgIHZvaWQgcnVuU2NyaXB0 KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKQEAgLTg0LDYgKzg3LDcgQEAgcHJp dmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9z dCogbV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7Cisg ICAgRGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOyAv LyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNsaXN0 LW9mLXNjcmlwdHMtdGhhdC13aWxsLWV4ZWN1dGUtd2hlbi10aGUtZG9jdW1lbnQtaGFzLWZpbmlz aGVkLXBhcnNpbmcKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8v IFdlIG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlv biBpZiBzY3JpcHQK 66157 2010-08-31 18:34:58 -0700 2010-08-31 20:09:47 -0700 Use enum for parser state bug-40934-20100831183456.patch text/plain 43642 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NzljMzIxYWNjZDdkNjRlMGY5ZDRhZDBiMWQ4ZGQxOWZiMmY1ODk3Li42NTkzZDVm ZTM5Njc4MmU4OWM2ODM4NGIxNTUyZTU0Mzc1ZmE5MjRmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDgtMzEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IENvcGll ZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uLzUxMzY2OTYtZXhwZWN0ZWQudHh0 LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZl ci13cml0ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNj cmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uLzUxMzY2OTYt ZXhwZWN0ZWQudHh0LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LXdyaXRlLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90ZXhlY3V0ZS5q czogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVy LXdyaXRlcy1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uLzUxMzY2OTYtZXhwZWN0ZWQudHh0LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAg ICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91 bmQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAg ICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRl ZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sOiBBZGRlZC4KKwogMjAxMC0wOC0zMSAgVG9u eSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHVwZGF0 aW5nIGNocm9taXVtIHRlc3RfZXhwZWN0YXRpb25zLnR4dC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIyZTlhNDMx YWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1s IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRl ZmVyLXdyaXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQxMjA1MGIyZTQzYjY5NDkxYjU0MzQ3MzVmMmQ2 ZmU1MTRlZjk5ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBA QAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRl ZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsgZG9j dW1lbnQud3JpdGUoJzxzY3JpcHQgZGVmZXIgc3JjPVwnZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9j dW1lbnQud3JpdGUoJnF1b3Q7UEFTUyZxdW90Oyk7XCc+PC9zY3JpcHQ+Jyk7IGRvY3VtZW50LmNs b3NlKCk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjhkMDRmOTYxYTAzNzExN2MxZWFhNjlhYzYwZWIzNjNkMzdhZTc4ZDEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKKzEgMgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNTVlMWQzZGIzZjk2M2M4Zjk3YTk3 NjUyYTA0YTZjYTFmY2RhYzkxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSw2 IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwKKzxzY3JpcHQg ZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZWxuKDEpOyBkb2N1 bWVudC53cml0ZSgnPHNjcmlwdCBzcmM9XCdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53 cml0ZWxuKDIpXCc+PC9zY3JpcHQ+Jyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5s aW5lLXNjcmlwdC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOWIwMmQxNjMxNzdmNTY1Y2RiN2Qw Y2U1NmIzNWI4NTQzMzIxMzljZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsMyBAQAorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJl ZC4KKzEKKzIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMTVjMjAx MTlhYzQ4MDQ1NjIwNzQ0OGRmMjg2MzUyMzhhOWZlOTU3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5o dG1sCkBAIC0wLDAgKzEsMTUgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFRE IEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9 Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4v Li4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 PgorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KKzxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRlYnVn KDIpOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IGRlZmVyPgorICBkZWJ1ZygxKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYmEzZTM3MWY3MDI4ZmExMzgwZTJhMzVmNTQ1NDgxYjk0YWIy MDEwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZl cgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9yZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitk ZWZlcgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv ZGVmZXItb25iZWZvcmVsb2FkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMjJiMTg0ZGE2M2Jh NDc1NzExYmUxZjdiZjU5NTk5YTU0MTYwZTJhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKQEAg LTAsMCArMSwxNCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8v RU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4v anMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5IGFu ZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ2NhbmNlbGxlZCBvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIGZhbHNlOyIgZGVmZXI+ PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBvbmJlZm9yZWxvYWQ9 ImRlYnVnKCdvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIHRydWU7IiBkZWZlcj48L3Njcmlw dD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZXh0ZXJuYWwuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ29uYmVmb3JlbG9hZCBleHRlcm5hbCcpOyByZXR1cm4gdHJ1ZTsiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQ1YWYxZGNkNjlhZjg2NzUyN2I3ZmVkNTlkZjEzMDNl NDYzYzQ4YwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSwzIEBACitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFy ZSBpZ25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCitkZWZl cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmQ1 YTNlNTFmYjkzMmMyNDgyNzFlYjU5ODhmYmExZjQzMmI4N2QzZDgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52 YWxpZC11cmwuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0v L0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVS THMgYXJlIGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBleGVjdXRlZC4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly9pbnZhbGlkOjk5 OTk5OS8iIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIg ZGVmZXI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uN2VmMjJlOWE0MzFhZDAyNzI3MTNiNzFmZGM4Nzk0MDE2YzhlZjEy ZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4wYzBiYmZmNDU2MTc2ZjE2ZDk2NjNhYTA5OWZjMzY4MTllNGRiOWMx Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZh c2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBi L0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5q cwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv cmVzb3VyY2VzL2RlZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3Vy Y2VzL2V4dGVybmFsLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJk ZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWco ImV4dGVybmFsIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmMwZDY5NTQwMTYyZjlhZDdjYWIxZjAyMDc2ZGY4MWIxOTcxN2JkOTAKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiRkFJTCIpOwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90 ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3Vs ZG5vdGV4ZWN1dGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUxYzQ0Mjg3YzNiNmNmNGVmZDYx MjEwOGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRl ZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC90d28tZGVmZXItd3JpdGVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjdlZjIyZTlhNDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3Jp dGVzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNGIwZDM3ODczMDVkODI0YmE4NzZlMmI2MTRlMzZjMWM2ZjA0NWI3Ywot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3R3by1kZWZlci13cml0ZXMuaHRtbApAQCAtMCwwICsxLDcgQEAKKzxzY3JpcHQ+CitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9q YXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KKzxzY3JpcHQgZGVm ZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgnRkFJTCcpOyI+PC9z Y3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2RlZmVyLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv ZGVmZXItc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2 MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIi KTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0 ZXJuYWwtc2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9l eHRlcm5hbC1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJl YmRlMWVhNDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJl eHRlcm5hbCIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjZmYmU3YTFjNDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1k ZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCJnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10i LCAicmdiKDI1NSwgMCwgMCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVl dC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lZDExZWI1MmM2ZWY3ZmVlZjE1MWQyZDQ3OTllM2RjMmFlYjI3NmYz Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzCkBAIC0wLDAgKzEgQEAKK2RvY3VtZW50 LndyaXRlKCc8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAw MC9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4nKTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dp IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlw dC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQx OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJs IC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAo MC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZjZGRjYTQwMWY4YWIzYTZhNWRmODczYTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct c3R5bGVzaGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJp bnQgIkNvbnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiYm9k eSB7IGJhY2tncm91bmQtY29sb3I6ICNGRjAwMDAgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0 ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40OTBhZjA4ZDJkZjYw MGNiYmI5MmM1MWNjODJlNDE0NDI1NjZjNGQyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0cyB0aGF0IGFuIGlubGluZSBzbG93 IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNjcmlwdHMuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworUEFTUyBnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkp WydiYWNrZ3JvdW5kLWNvbG9yJ10gaXMgInJnYigyNTUsIDAsIDApIgorRE9NQ29udGVudExvYWRl ZAorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wNmVjODQ5YzM4OWQ0 MzliYjc5NDgwZWZiM2YzMzc3YzM1NDNjMTk5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRt bApAQCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBI VE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBl IiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxl c2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkdmkgaWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor ZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4 ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLicpOworCit2YXIganNUZXN0SXNBc3luYyA9 IHRydWU7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBm dW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rl c3QoKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4w LjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuCitq cyIgZGVmZXI9ImRlZmVyIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0i aHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGUKK2V0LmNn aSI+Cis8c2NyaXB0PgordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwv c2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lZjQ1MTg3MzMz NmJjY2U4MGMxZWE4MGE5ZjhjZjc0MzE5N2E1YmJjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSw3IEBACitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMg d2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMDcxMC4KK2V4dGVybmFsCitpbmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNv bnRlbnRMb2FkZWQKK2xvYWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9zY3JpcHQtZGVmZXIuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NWNmOGIzNTA3NWZhMThiZDYyM2JjZDZjYWQ2YWU2N2Rl NWQzYzMzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci5odG1sCkBAIC0wLDAgKzEsMjQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAi LS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2 PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIgLz4KKzxs aW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0iZGVidWcoJ2xvYWQn KSI+CitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0 aCB0aGUgZGVmZXIgYXR0cmlidXRlIDxhIGhyZWY9Imh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDcxMCI+aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwNzEwPC9hPi4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50 TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7Cit9LCBm YWxzZSk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlz Yy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9kZWZl ci1zY3JpcHQuanMiIGRlZmVyPSJERUZFUiI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDov LzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0PgorZGVidWcoImlubGluZSIpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0 bWw+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDNiZDQ5ZGJjZWU1YmU4NDkzZDlhODFhNDY2OTRmN2UwMzljYWYzMjcuLmM0ZGRmNWZmOWQ3 Mjc4MmQzMjM3NmE0ZmQ5MmNhNmM2MjI4MzM1NGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzIgQEAKKzIwMTAtMDgtMzEg IFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3JpcHQgZGVmZXI+IGFz IHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBUZXN0czogZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sCisgICAgICAgICAg ICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwK KyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3Jl bG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sCisgICAgICAgICAgICAgICBodHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKKworICAgICAgICAq IGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6b3Blbik6Cisg ICAgICAgICogZG9tL0RvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3Vt ZW50UGFyc2VyOjpEb2N1bWVudFBhcnNlcik6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBh cnNlcjo6c3RhcnRQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50UGFyc2VyOjpw cmVwYXJlVG9TdG9wUGFyc2luZyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6 c3RvcFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6OmRldGFjaCk6 CisgICAgICAgICogZG9tL0RvY3VtZW50UGFyc2VyLmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudFBhcnNlcjo6aXNQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50UGFyc2Vy Ojppc0FjdGl2ZSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNTdG9wcGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNEZXRhY2hlZCk6CisgICAg ICAgICogZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oOgorICAgICAgICAoV2ViQ29yZTo6UmF3 RGF0YURvY3VtZW50UGFyc2VyOjpmaW5pc2gpOgorICAgICAgICAqIGRvbS9YTUxEb2N1bWVudFBh cnNlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKToK KyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpleGl0VGV4dCk6CisgICAgICAg ICogZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpY TUxEb2N1bWVudFBhcnNlcjo6ZG9Xcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVu dFBhcnNlcjo6c3RhcnRFbGVtZW50TnMpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQ YXJzZXI6OmVuZEVsZW1lbnROcyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNl cjo6Y2hhcmFjdGVycyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6ZXJy b3IpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJbnN0 cnVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y2RhdGFCbG9j ayk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y29tbWVudCk6CisgICAg ICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW50ZXJuYWxTdWJzZXQpOgorICAgICAg ICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KToK KyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpkb0VuZCk6CisgICAgICAgICog aHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxEb2N1bWVudFBhcnNlcjo6cHJlcGFyZVRvU3RvcFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVySWZQb3NzaWJsZSk6CisgICAgICAg IChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXIpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjppbnNlcnQpOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTERvY3VtZW50UGFyc2VyOjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3Vt ZW50UGFyc2VyOjplbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjph dHRlbXB0VG9FbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJ ZkRlbGF5ZWQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlG aW5pc2hlZCk6CisgICAgICAgICogaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmg6Cisg ICAgICAgICogaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5k RGlzcGF0Y2hFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVj dXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3Jp cHRSdW5uZXI6OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpydW5TY3JpcHQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3Jp cHRSdW5uZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpJbWFnZURvY3VtZW50UGFyc2VyOjpmaW5pc2gpOgorCiAyMDEwLTA4LTMwICBJ bHlhIFRpa2hvbm92c2t5ICA8bG9pc2xvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBKb3NlcGggUGVjb3Jhcm8uCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggOGEzNWFiY2ZkMjNlYjkxOTU3NTNj OWZmYmExZWZjZjIxNDYwOTkxMC4uNTc4M2I4ZDI5NWYyMDJjZGQyOTM4M2Y2YTJhZDI3MzkwOGIz NWUwMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNvcmUv ZG9tL0RvY3VtZW50LmNwcApAQCAtMTgyNCw3ICsxODI0LDcgQEAgdm9pZCBEb2N1bWVudDo6b3Bl bihEb2N1bWVudCogb3duZXJEb2N1bWVudCkKIAogICAgIGlmIChtX2ZyYW1lKSB7CiAgICAgICAg IFNjcmlwdGFibGVEb2N1bWVudFBhcnNlciogcGFyc2VyID0gc2NyaXB0YWJsZURvY3VtZW50UGFy c2VyKCk7Ci0gICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIoKS0+aXNMb2FkaW5nTWFpblJlc291 cmNlKCkgfHwgKHBhcnNlciAmJiBwYXJzZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkpKQorICAgICAg ICBpZiAobV9mcmFtZS0+bG9hZGVyKCktPmlzTG9hZGluZ01haW5SZXNvdXJjZSgpIHx8IChwYXJz ZXIgJiYgcGFyc2VyLT5pc1BhcnNpbmcoKSAmJiBwYXJzZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkp KQogICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIoKS0+ c3RhdGUoKSA9PSBGcmFtZVN0YXRlUHJvdmlzaW9uYWwpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Rv bS9Eb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5jcHAKaW5k ZXggY2M0YzYxYjAzNDk2NWJmMWNmMDEzY2Q2NDA5OTIxOWQxYjExMmVmMS4uNjM5ODYwYTJjYWU0 YTk5YTQzY2EwOWQ2NTRlYjY0NmY5ZWU0NzAwYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9j dW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmNwcApAQCAt MzEsNyArMzEsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBEb2N1bWVudFBhcnNlcjo6RG9j dW1lbnRQYXJzZXIoRG9jdW1lbnQqIGRvY3VtZW50KQotICAgIDogbV9wYXJzZXJTdG9wcGVkKGZh bHNlKQorICAgIDogbV9zdGF0ZShQYXJzaW5nU3RhdGUpCiAgICAgLCBtX2RvY3VtZW50KGRvY3Vt ZW50KQogewogICAgIEFTU0VSVChkb2N1bWVudCk7CkBAIC00NSw4ICs0NSwyNSBAQCBEb2N1bWVu dFBhcnNlcjo6fkRvY3VtZW50UGFyc2VyKCkKICAgICBBU1NFUlQoIW1fZG9jdW1lbnQpOwogfQog Cit2b2lkIERvY3VtZW50UGFyc2VyOjpzdGFydFBhcnNpbmcoKQoreworICAgIG1fc3RhdGUgPSBQ YXJzaW5nU3RhdGU7Cit9CisKK3ZvaWQgRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJz aW5nKCkKK3sKKyAgICBpZiAobV9zdGF0ZSA9PSBQYXJzaW5nU3RhdGUpCisgICAgICAgIG1fc3Rh dGUgPSBTdG9wcGluZ1N0YXRlOworfQorCit2b2lkIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2lu ZygpCit7CisgICAgbV9zdGF0ZSA9IFN0b3BwZWRTdGF0ZTsKK30KKwogdm9pZCBEb2N1bWVudFBh cnNlcjo6ZGV0YWNoKCkKIHsKKyAgICBtX3N0YXRlID0gRGV0YWNoZWRTdGF0ZTsKICAgICBtX2Rv Y3VtZW50ID0gMDsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIu aCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmgKaW5kZXggM2MyODg1NjI1ZWUxMzEwNDBj MWY3Yzk5OWRiZTUzMjc5MDZlMmRhYy4uZjQyMWYwYmY4ODEzOWYwZGNlMWQ4NDI2NGVkZGY2Yjk4 ODNjMDg0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIuaAorKysgYi9X ZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5oCkBAIC01NywxMiArNTcsMjkgQEAgcHVibGljOgog CiAgICAgLy8gRklYTUU6IHByb2Nlc3NpbmdEYXRhKCkgaXMgb25seSB1c2VkIGJ5IERvY3VtZW50 TG9hZGVyOjppc0xvYWRpbmdJbkFQSVNlbnNlCiAgICAgLy8gYW5kIGlzIHZlcnkgdW5jbGVhciBh cyB0byB3aGF0IGl0IGFjdHVhbGx5IG1lYW5zLiAgVGhlIExlZ2FjeUhUTUxEb2N1bWVudFBhcnNl cgotICAgIC8vIHVzZWQgdG8gaW1wbGVtZW50cyBpdC4KKyAgICAvLyB1c2VkIHRvIGltcGxlbWVu dCBpdC4KICAgICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0RhdGEoKSBjb25zdCB7IHJldHVybiBm YWxzZTsgfQogCiAgICAgLy8gZG9jdW1lbnQoKSB3aWxsIHJldHVybiAwIGFmdGVyIGRldGFjaCgp IGlzIGNhbGxlZC4KICAgICBEb2N1bWVudCogZG9jdW1lbnQoKSBjb25zdCB7IEFTU0VSVChtX2Rv Y3VtZW50KTsgcmV0dXJuIG1fZG9jdW1lbnQ7IH0KLSAgICBib29sIGlzRGV0YWNoZWQoKSBjb25z dCB7IHJldHVybiAhbV9kb2N1bWVudDsgfQorCisgICAgYm9vbCBpc1BhcnNpbmcoKSBjb25zdCB7 IHJldHVybiBtX3N0YXRlID09IFBhcnNpbmdTdGF0ZTsgfQorICAgIGJvb2wgaXNBY3RpdmUoKSBj b25zdCB7IHJldHVybiBtX3N0YXRlICYgKFBhcnNpbmdTdGF0ZSB8IFN0b3BwaW5nU3RhdGUpOyB9 CisgICAgYm9vbCBpc1N0b3BwaW5nKCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZSA9PSBTdG9wcGlu Z1N0YXRlOyB9CisgICAgYm9vbCBpc0RldGFjaGVkKCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZSA9 PSBEZXRhY2hlZFN0YXRlOyB9CisKKyAgICAvLyBGSVhNRTogSXMgdGhpcyBuZWNlc3Nhcnk/IERv ZXMgWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyIHJlYWxseSBuZWVkIHRvIHNldCB0aGlzPworICAg IHZpcnR1YWwgdm9pZCBzdGFydFBhcnNpbmcoKTsKKworICAgIC8vIHByZXBhcmVUb1N0b3AoKSBp cyB1c2VkIHdoZW4gdGhlIEVPRiB0b2tlbiBpcyBlbmNvdW50ZXJlZCBhbmQgcGFyc2luZyBpcyB0 byBiZQorICAgIC8vIHN0b3BwZWQgbm9ybWFsbHkuCisgICAgdmlydHVhbCB2b2lkIHByZXBhcmVU b1N0b3BQYXJzaW5nKCk7CisKKyAgICAvLyBzdG9wUGFyc2luZygpIGlzIHVzZWQgd2hlbiBhIGxv YWQgaXMgY2FuY2VsZWQvc3RvcHBlZC4KKyAgICAvLyBzdG9wUGFyc2luZygpIGlzIGN1cnJlbnRs eSBkaWZmZXJlbnQgZnJvbSBkZXRhY2goKSwgYnV0IHNob3VsZG4ndCBiZS4KKyAgICAvLyBJdCBz aG91bGQgTk9UIGJlIG9rIHRvIGNhbGwgYW55IG1ldGhvZHMgb24gRG9jdW1lbnRQYXJzZXIgYWZ0 ZXIgZWl0aGVyCisgICAgLy8gZGV0YWNoKCkgb3Igc3RvcFBhcnNpbmcoKSBidXQgcmlnaHQgbm93 IG9ubHkgZGV0YWNoKCkgd2lsbCBBU1NFUlQuCisgICAgdmlydHVhbCB2b2lkIHN0b3BQYXJzaW5n KCk7CiAKICAgICAvLyBEb2N1bWVudCBpcyBleHBlY3RlZCB0byBkZXRhY2ggdGhlIHBhcnNlciBi ZWZvcmUgcmVsZWFzaW5nIGl0cyByZWYuCiAgICAgLy8gQWZ0ZXIgZGV0YWNoLCBtX2RvY3VtZW50 IGlzIGNsZWFyZWQuICBUaGUgcGFyc2VyIHdpbGwgdW53aW5kIGl0cwpAQCAtNzEsMjIgKzg4LDE4 IEBAIHB1YmxpYzoKICAgICAvLyBkZXRhY2ggaXMgY2FsbGVkLgogICAgIHZpcnR1YWwgdm9pZCBk ZXRhY2goKTsKIAotICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgdXNlZCB3aGVuIGEgbG9hZCBpcyBj YW5jZWxlZC9zdG9wcGVkLgotICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgY3VycmVudGx5IGRpZmZl cmVudCBmcm9tIGRldGFjaCgpLCBidXQgc2hvdWxkbid0IGJlLgotICAgIC8vIEl0IHNob3VsZCBO T1QgYmUgb2sgdG8gY2FsbCBhbnkgbWV0aG9kcyBvbiBEb2N1bWVudFBhcnNlciBhZnRlciBlaXRo ZXIKLSAgICAvLyBkZXRhY2goKSBvciBzdG9wUGFyc2luZygpIGJ1dCByaWdodCBub3cgb25seSBk ZXRhY2goKSB3aWxsIEFTU0VSVC4KLSAgICB2aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKSB7IG1f cGFyc2VyU3RvcHBlZCA9IHRydWU7IH0KLQogcHJvdGVjdGVkOgogICAgIERvY3VtZW50UGFyc2Vy KERvY3VtZW50Kik7CiAKLSAgICAvLyBUaGUgcGFyc2VyIGhhcyBidWZmZXJzLCBzbyBwYXJzaW5n IG1heSBjb250aW51ZSBldmVuIGFmdGVyCi0gICAgLy8gaXQgc3RvcHMgcmVjZWl2aW5nIGRhdGEu IFdlIHVzZSBtX3BhcnNlclN0b3BwZWQgdG8gc3RvcCB0aGUgcGFyc2VyCi0gICAgLy8gZXZlbiB3 aGVuIGl0IGhhcyBidWZmZXJlZCBkYXRhLgotICAgIC8vIEZJWE1FOiBtX2RvY3VtZW50ID0gMCBj b3VsZCBiZSBjaGFuZ2VkIHRvIG1lYW4gInBhcnNlciBzdG9wcGVkIi4KLSAgICBib29sIG1fcGFy c2VyU3RvcHBlZDsKLQogcHJpdmF0ZToKKyAgICBlbnVtIFBhcnNlclN0YXRlIHsKKyAgICAgICAg UGFyc2luZ1N0YXRlID0gMHgxLAorICAgICAgICBTdG9wcGluZ1N0YXRlID0gMHgyLAorICAgICAg ICBTdG9wcGVkU3RhdGUgPSAweDQsCisgICAgICAgIERldGFjaGVkU3RhdGUgPSAweDgKKyAgICB9 OworICAgIFBhcnNlclN0YXRlIG1fc3RhdGU7CisKICAgICAvLyBFdmVyeSBEb2N1bWVudFBhcnNl ciBuZWVkcyBhIHBvaW50ZXIgYmFjayB0byB0aGUgZG9jdW1lbnQuCiAgICAgLy8gbV9kb2N1bWVu dCB3aWxsIGJlIDAgYWZ0ZXIgdGhlIHBhcnNlciBpcyBzdG9wcGVkLgogICAgIERvY3VtZW50KiBt X2RvY3VtZW50OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUmF3RGF0YURvY3VtZW50UGFyc2Vy LmggYi9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaAppbmRleCAwOTNkZGFmNjdk MTgwYzRkYTBhYzcxNjZjZTRmYWFmZDVjMTgxMWMxLi45NzZlYzQwNTdmNDM0ZmViNjE5NGFiMGU1 OThkNGI1MzdmY2E1ZDk0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQ YXJzZXIuaAorKysgYi9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaApAQCAtMzks NyArMzksNyBAQCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgZmluaXNoKCkKICAgICB7 Ci0gICAgICAgIGlmICghbV9wYXJzZXJTdG9wcGVkICYmICFpc0RldGFjaGVkKCkpCisgICAgICAg IGlmIChpc0FjdGl2ZSgpKQogICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZmluaXNoZWRQYXJzaW5n KCk7CiAgICAgfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5j cHAgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggNGI3NjQ3MjJhZWVm MzZlMjZhNTE1YTEzZTZjMzcyM2MwNmFjZjhkNy4uMWM3NTgyOGQ5OTUwMWJhOTUwMzAwYzU1ZTk4 YThhYjdiYmNkNTQwZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIu Y3BwCisrKyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtMTMyLDcgKzEz Miw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZChjb25zdCBTZWdtZW50ZWRTdHJp bmcmIHMpCiAgICAgaWYgKG1fc2F3WFNMVHJhbnNmb3JtIHx8ICFtX3Nhd0ZpcnN0RWxlbWVudCkK ICAgICAgICAgbV9vcmlnaW5hbFNvdXJjZUZvclRyYW5zZm9ybSArPSBwYXJzZVN0cmluZzsKIAot ICAgIGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkIHx8IG1fc2F3WFNMVHJhbnNm b3JtKQorICAgIGlmICghaXNBY3RpdmUoKSB8fCBtX3Nhd1hTTFRyYW5zZm9ybSkKICAgICAgICAg cmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC0xOTAsNyArMTkwLDcgQEAg c3RhdGljIGlubGluZSBTdHJpbmcgdG9TdHJpbmcoY29uc3QgeG1sQ2hhciogc3RyLCB1bnNpZ25l ZCBsZW4pCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmV4aXRUZXh0KCkKIHsKLSAgICBpZiAo bV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwog CiAgICAgaWYgKCFtX2N1cnJlbnROb2RlIHx8ICFtX2N1cnJlbnROb2RlLT5pc1RleHROb2RlKCkp CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwIGIv V2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAppbmRleCBkYjk0YzUwYjQ0 NzcxZmQ1MWVhNDNmODQxNmM4NGFlZDI3MTVlZTlmLi43ZWZkNmYyZDYwNWYyYTRiMDU0NWI5YTQ0 NDVkY2Y3ZWRhYzJiOGE0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNl ckxpYnhtbDIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHAKQEAgLTY2MCw3ICs2NjAsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpkb1dyaXRlKGNv bnN0IFN0cmluZyYgcGFyc2VTdHJpbmcpCiAKICAgICAgICAgLy8gSmF2YVNjcmlwdCAod2hpY2gg bWF5IGJlIHJ1biB1bmRlciB0aGUgeG1sUGFyc2VDaHVuayBjYWxsc3RhY2spIG1heQogICAgICAg ICAvLyBjYXVzZSB0aGUgcGFyc2VyIHRvIGJlIHN0b3BwZWQgb3IgZGV0YWNoZWQuCi0gICAgICAg IGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkKQorICAgICAgICBpZiAoIWlzQWN0 aXZlKCkpCiAgICAgICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC03MzMsNyArNzMzLDcgQEAg c3RhdGljIGlubGluZSB2b2lkIGhhbmRsZUVsZW1lbnRBdHRyaWJ1dGVzKEVsZW1lbnQqIG5ld0Vs ZW1lbnQsIGNvbnN0IHhtbENoYXIqKgogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6c3RhcnRFbGVt ZW50TnMoY29uc3QgeG1sQ2hhciogeG1sTG9jYWxOYW1lLCBjb25zdCB4bWxDaGFyKiB4bWxQcmVm aXgsIGNvbnN0IHhtbENoYXIqIHhtbFVSSSwgaW50IG5iX25hbWVzcGFjZXMsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhcioqIGxpYnhtbE5hbWVzcGFjZXMs IGludCBuYl9hdHRyaWJ1dGVzLCBpbnQgbmJfZGVmYXVsdGVkLCBjb25zdCB4bWxDaGFyKiogbGli eG1sQXR0cmlidXRlcykKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNB Y3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBA IC04MjIsNyArODIyLDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6c3RhcnRFbGVtZW50TnMo Y29uc3QgeG1sQ2hhciogeG1sTG9jYWxOYW1lLCBjb25zdCB4bWxDaGEKIAogdm9pZCBYTUxEb2N1 bWVudFBhcnNlcjo6ZW5kRWxlbWVudE5zKCkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQor ICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2Vy UGF1c2VkKSB7CkBAIC05MDYsNyArOTA2LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZW5k RWxlbWVudE5zKCkKIAogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6Y2hhcmFjdGVycyhjb25zdCB4 bWxDaGFyKiBzLCBpbnQgbGVuKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYg KCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1cm47CiAKICAgICBpZiAobV9wYXJzZXJQYXVzZWQp IHsKQEAgLTkyMSw3ICs5MjEsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpjaGFyYWN0ZXJz KGNvbnN0IHhtbENoYXIqIHMsIGludCBsZW4pCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVy cm9yKEVycm9yVHlwZSB0eXBlLCBjb25zdCBjaGFyKiBtZXNzYWdlLCB2YV9saXN0IGFyZ3MpCiB7 Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoIWlzQWN0aXZlKCkpCiAgICAgICAg IHJldHVybjsKIAogI2lmIENPTVBJTEVSKE1TVkMpIHx8IENPTVBJTEVSKFJWQ1QpCkBAIC05NDUs NyArOTQ1LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZXJyb3IoRXJyb3JUeXBlIHR5cGUs IGNvbnN0IGNoYXIqIG1lc3NhZ2UsIHZhX2xpc3QgYXJncykKIAogdm9pZCBYTUxEb2N1bWVudFBh cnNlcjo6cHJvY2Vzc2luZ0luc3RydWN0aW9uKGNvbnN0IHhtbENoYXIqIHRhcmdldCwgY29uc3Qg eG1sQ2hhciogZGF0YSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNB Y3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBA IC05NzksNyArOTc5LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc2luZ0luc3Ry dWN0aW9uKGNvbnN0IHhtbENoYXIqIHRhcmdldCwgY29uc3QgeG1sQ2gKIAogdm9pZCBYTUxEb2N1 bWVudFBhcnNlcjo6Y2RhdGFCbG9jayhjb25zdCB4bWxDaGFyKiBzLCBpbnQgbGVuKQogewotICAg IGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYgKCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1 cm47CiAKICAgICBpZiAobV9wYXJzZXJQYXVzZWQpIHsKQEAgLTk5Nyw3ICs5OTcsNyBAQCB2b2lk IFhNTERvY3VtZW50UGFyc2VyOjpjZGF0YUJsb2NrKGNvbnN0IHhtbENoYXIqIHMsIGludCBsZW4p CiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmNvbW1lbnQoY29uc3QgeG1sQ2hhciogcykKIHsK LSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAg cmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC0xMDM0LDcgKzEwMzQsNyBA QCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjplbmREb2N1bWVudCgpCiAKIHZvaWQgWE1MRG9jdW1l bnRQYXJzZXI6OmludGVybmFsU3Vic2V0KGNvbnN0IHhtbENoYXIqIG5hbWUsIGNvbnN0IHhtbENo YXIqIGV4dGVybmFsSUQsIGNvbnN0IHhtbENoYXIqIHN5c3RlbUlEKQogewotICAgIGlmIChtX3Bh cnNlclN0b3BwZWQpCisgICAgaWYgKCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1cm47CiAKICAg ICBpZiAobV9wYXJzZXJQYXVzZWQpIHsKQEAgLTEyOTQsNyArMTI5NCw3IEBAIHZvaWQgWE1MRG9j dW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNodW5rKQog ICAgIHNheC5pZ25vcmFibGVXaGl0ZXNwYWNlID0gaWdub3JhYmxlV2hpdGVzcGFjZUhhbmRsZXI7 CiAgICAgc2F4LmVudGl0eURlY2wgPSB4bWxTQVgyRW50aXR5RGVjbDsKICAgICBzYXguaW5pdGlh bGl6ZWQgPSBYTUxfU0FYMl9NQUdJQzsKLSAgICBtX3BhcnNlclN0b3BwZWQgPSBmYWxzZTsKKyAg ICBEb2N1bWVudFBhcnNlcjo6c3RhcnRQYXJzaW5nKCk7CiAgICAgbV9zYXdFcnJvciA9IGZhbHNl OwogICAgIG1fc2F3WFNMVHJhbnNmb3JtID0gZmFsc2U7CiAgICAgbV9zYXdGaXJzdEVsZW1lbnQg PSBmYWxzZTsKQEAgLTEzMTgsMTEgKzEzMTgsMTEgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6 ZG9FbmQoKQogICAgICAgICBkb2N1bWVudCgpLT5zZXRQYXJzaW5nKGZhbHNlKTsgLy8gTWFrZSB0 aGUgZG9jIHRoaW5rIGl0J3MgZG9uZSwgc28gaXQgd2lsbCBhcHBseSB4c2wgc2hlZXRzLgogICAg ICAgICBkb2N1bWVudCgpLT5zdHlsZVNlbGVjdG9yQ2hhbmdlZChSZWNhbGNTdHlsZUltbWVkaWF0 ZWx5KTsKICAgICAgICAgZG9jdW1lbnQoKS0+c2V0UGFyc2luZyh0cnVlKTsKLSAgICAgICAgbV9w YXJzZXJTdG9wcGVkID0gdHJ1ZTsKKyAgICAgICAgRG9jdW1lbnRQYXJzZXI6OnN0b3BQYXJzaW5n KCk7CiAgICAgfQogI2VuZGlmCiAKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICgh aXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fY29udGV4dCkgewpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIvV2Vi Q29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuY3BwCmluZGV4IDIwN2JkM2U2MzIw MGI0NjEyNmNkMjgwNjRmNjJjYjY2MTQyN2JkYjIuLjM3NDIwMTU2MmY4ZGMwYzIzYTk5MTNiZWE3 YjQ2MTdhMTFkODlhMTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3Vt ZW50UGFyc2VyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNl ci5jcHAKQEAgLTE0Miw2ICsxNDIsMzEgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnN0b3BQ YXJzaW5nKCkKICAgICBtX3BhcnNlclNjaGVkdWxlci5jbGVhcigpOyAvLyBEZWxldGluZyB0aGUg c2NoZWR1bGVyIHdpbGwgY2xlYXIgYW55IHRpbWVycy4KIH0KIAorLy8gVGhpcyBraWNrcyBvZmYg Ik9uY2UgdGhlIHVzZXIgYWdlbnQgc3RvcHMgcGFyc2luZyIgYXMgZGVzY3JpYmVkIGJ5OgorLy8g aHR0cDovL3d3dy53aGF0d2cub3JnL3NwZWNzL3dlYi1hcHBzL2N1cnJlbnQtd29yay9tdWx0aXBh Z2UvdGhlLWVuZC5odG1sI3RoZS1lbmQKK3ZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwcmVwYXJl VG9TdG9wUGFyc2luZygpCit7CisgICAgQVNTRVJUKCFoYXNJbnNlcnRpb25Qb2ludCgpKTsKKwor ICAgIC8vIHB1bXBUb2tlbml6ZXIgY2FuIGNhdXNlIHRoaXMgcGFyc2VyIHRvIGJlIGRldGFjaGVk IGZyb20gdGhlIERvY3VtZW50LAorICAgIC8vIGJ1dCB3ZSBuZWVkIHRvIGVuc3VyZSBpdCBpc24n dCBkZWxldGVkIHlldC4KKyAgICBSZWZQdHI8SFRNTERvY3VtZW50UGFyc2VyPiBwcm90ZWN0KHRo aXMpOworCisgICAgLy8gRklYTUU6IFNldCB0aGUgY3VycmVudCBkb2N1bWVudCByZWFkaW5lc3Mg dG8gImludGVyYWN0aXZlIi4KKworICAgIC8vIE5PVEU6IFRoaXMgcHVtcCBzaG91bGQgb25seSBl dmVyIGVtaXQgYnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywKKyAgICAvLyBzbyBGb3JjZVN5bmNo cm9ub3VzIHZzLiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFuaW5nbGVzcy4KKyAgICBwdW1wVG9r ZW5pemVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsKKworICAgIERvY3VtZW50UGFyc2Vy OjpwcmVwYXJlVG9TdG9wUGFyc2luZygpOworICAgIGlmIChtX3NjcmlwdFJ1bm5lcikgeworICAg ICAgICBpZiAoIW1fc2NyaXB0UnVubmVyLT5leGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5n KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZW5kKCk7Cit9CisKIGJvb2wg SFRNTERvY3VtZW50UGFyc2VyOjpwcm9jZXNzaW5nRGF0YSgpIGNvbnN0CiB7CiAgICAgcmV0dXJu IGlzU2NoZWR1bGVkRm9yUmVzdW1lKCkgfHwgaW5Xcml0ZSgpOwpAQCAtMTQ5LDcgKzE3NCw3IEBA IGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpwcm9jZXNzaW5nRGF0YSgpIGNvbnN0CiAKIHZvaWQg SFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVySWZQb3NzaWJsZShTeW5jaHJvbm91c01v ZGUgbW9kZSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkIHx8IG1fdHJlZUJ1aWxkZXItPmlz UGF1c2VkKCkpCisgICAgaWYgKCFpc0FjdGl2ZSgpIHx8IG1fdHJlZUJ1aWxkZXItPmlzUGF1c2Vk KCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIC8vIE9uY2UgYSByZXN1bWUgaXMgc2NoZWR1bGVk LCBIVE1MUGFyc2VyU2NoZWR1bGVyIGNvbnRyb2xzIHdoZW4gd2UgbmV4dCBwdW1wLgpAQCAtMTkz LDggKzIxOCw3IEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpydW5TY3JpcHRzRm9yUGF1c2Vk VHJlZUJ1aWxkZXIoKQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6cHVtcFRva2VuaXplcihT eW5jaHJvbm91c01vZGUgbW9kZSkKIHsKLSAgICBBU1NFUlQoIWlzRGV0YWNoZWQoKSk7Ci0gICAg QVNTRVJUKCFtX3BhcnNlclN0b3BwZWQpOworICAgIEFTU0VSVChpc0FjdGl2ZSgpKTsKICAgICBB U1NFUlQoIW1fdHJlZUJ1aWxkZXItPmlzUGF1c2VkKCkpOwogICAgIEFTU0VSVCghaXNTY2hlZHVs ZWRGb3JSZXN1bWUoKSk7CiAgICAgLy8gQVNTRVJUIHRoYXQgdGhpcyBvYmplY3QgaXMgYm90aCBh dHRhY2hlZCB0byB0aGUgRG9jdW1lbnQgYW5kIHByb3RlY3RlZC4KQEAgLTIxNCw3ICsyMzgsNyBA QCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6cHVtcFRva2VuaXplcihTeW5jaHJvbm91c01vZGUg bW9kZSkKICAgICAgICAgbV90b2tlbi5jbGVhcigpOwogCiAgICAgICAgIC8vIEphdmFTY3JpcHQg bWF5IGhhdmUgc3RvcHBlZCBvciBkZXRhY2hlZCB0aGUgcGFyc2VyLgotICAgICAgICBpZiAoaXNE ZXRhY2hlZCgpIHx8IG1fcGFyc2VyU3RvcHBlZCkKKyAgICAgICAgaWYgKCFpc0FjdGl2ZSgpKQog ICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIC8vIFRoZSBwYXJzZXIgd2lsbCBwYXVzZSBp dHNlbGYgd2hlbiB3YWl0aW5nIG9uIGEgc2NyaXB0IHRvIGxvYWQgb3IgcnVuLgpAQCAtMjI2LDcg KzI1MCw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVyKFN5bmNocm9u b3VzTW9kZSBtb2RlKQogICAgICAgICBtX3RyZWVCdWlsZGVyLT5zZXRQYXVzZWQoIXNob3VsZENv bnRpbnVlUGFyc2luZyk7CiAKICAgICAgICAgLy8gSmF2YVNjcmlwdCBtYXkgaGF2ZSBzdG9wcGVk IG9yIGRldGFjaGVkIHRoZSBwYXJzZXIuCi0gICAgICAgIGlmIChpc0RldGFjaGVkKCkgfHwgbV9w YXJzZXJTdG9wcGVkKQorICAgICAgICBpZiAoIWlzQWN0aXZlKCkpCiAgICAgICAgICAgICByZXR1 cm47CiAKICAgICAgICAgaWYgKCFzaG91bGRDb250aW51ZVBhcnNpbmcpCkBAIC0yNzUsNyArMjk5 LDcgQEAgYm9vbCBIVE1MRG9jdW1lbnRQYXJzZXI6Omhhc0luc2VydGlvblBvaW50KCkKIAogdm9p ZCBIVE1MRG9jdW1lbnRQYXJzZXI6Omluc2VydChjb25zdCBTZWdtZW50ZWRTdHJpbmcmIHNvdXJj ZSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNBY3RpdmUoKSkKICAg ICAgICAgcmV0dXJuOwogCiAgICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJz ZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUgRG9jdW1lbnQsCkBAIC0yOTYsNyArMzIwLDcgQEAg dm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6Omluc2VydChjb25zdCBTZWdtZW50ZWRTdHJpbmcmIHNv dXJjZSkKIAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZChjb25zdCBTZWdtZW50ZWRT dHJpbmcmIHNvdXJjZSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNB Y3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1 c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUgRG9jdW1lbnQsCkBAIC0zMjgs MTQgKzM1Miw2IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjplbmQoKQogICAgIEFTU0VSVCgh aXNEZXRhY2hlZCgpKTsKICAgICBBU1NFUlQoIWlzU2NoZWR1bGVkRm9yUmVzdW1lKCkpOwogCi0g ICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNoZWQg ZnJvbSB0aGUgRG9jdW1lbnQsCi0gICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0IGlzbid0 IGRlbGV0ZWQgeWV0LgotICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3RlY3QodGhp cyk7Ci0KLSAgICAvLyBOT1RFOiBUaGlzIHB1bXAgc2hvdWxkIG9ubHkgZXZlciBlbWl0IGJ1ZmZl cmVkIGNoYXJhY3RlciB0b2tlbnMsCi0gICAgLy8gc28gRm9yY2VTeW5jaHJvbm91cyB2cy4gQWxs b3dZaWVsZCBzaG91bGQgYmUgbWVhbmluZ2xlc3MuCi0gICAgcHVtcFRva2VuaXplcklmUG9zc2li bGUoRm9yY2VTeW5jaHJvbm91cyk7Ci0KICAgICAvLyBJbmZvcm1zIHRoZSB0aGUgcmVzdCBvZiBX ZWJDb3JlIHRoYXQgcGFyc2luZyBpcyByZWFsbHkgZmluaXNoZWQgKGFuZCBkZWxldGVzIHRoaXMp LgogICAgIG1fdHJlZUJ1aWxkZXItPmZpbmlzaGVkKCk7CiB9CkBAIC0zNDksNyArMzY1LDcgQEAg dm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmF0dGVtcHRUb0VuZCgpCiAgICAgICAgIG1fZW5kV2Fz RGVsYXllZCA9IHRydWU7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgZW5kKCk7CisgICAg cHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKIH0KIAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVu ZElmRGVsYXllZCgpCkBAIC0zNjIsNyArMzc4LDcgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6 OmVuZElmRGVsYXllZCgpCiAgICAgICAgIHJldHVybjsKIAogICAgIG1fZW5kV2FzRGVsYXllZCA9 IGZhbHNlOwotICAgIGVuZCgpOworICAgIHByZXBhcmVUb1N0b3BQYXJzaW5nKCk7CiB9CiAKIHZv aWQgSFRNTERvY3VtZW50UGFyc2VyOjpmaW5pc2goKQpAQCAtNDQ3LDYgKzQ2MywxMSBAQCBib29s IEhUTUxEb2N1bWVudFBhcnNlcjo6c2hvdWxkTG9hZEV4dGVybmFsU2NyaXB0RnJvbVNyYyhjb25z dCBBdG9taWNTdHJpbmcmIHNyYwogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6bm90aWZ5Rmlu aXNoZWQoQ2FjaGVkUmVzb3VyY2UqIGNhY2hlZFJlc291cmNlKQogeworICAgIGlmIChpc1N0b3Bw aW5nKCkpIHsKKyAgICAgICAgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKKyAgICAgICAgcmV0dXJu OworICAgIH0KKwogICAgIC8vIHB1bXBUb2tlbml6ZXIgY2FuIGNhdXNlIHRoaXMgcGFyc2VyIHRv IGJlIGRldGFjaGVkIGZyb20gdGhlIERvY3VtZW50LAogICAgIC8vIGJ1dCB3ZSBuZWVkIHRvIGVu c3VyZSBpdCBpc24ndCBkZWxldGVkIHlldC4KICAgICBSZWZQdHI8SFRNTERvY3VtZW50UGFyc2Vy PiBwcm90ZWN0KHRoaXMpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9j dW1lbnRQYXJzZXIuaCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmgK aW5kZXggZGEyMWEyYmExMTRlMjAwMmJkZTI0ZmNhZjM5ZWQwOWRiYjUxOWRjMS4uYTMyYjQzOTZk MzljZDAwNjViYWZkNjQyZWQ2MjU0MmQ4MGVmZTliYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1s L3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuaAorKysgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hU TUxEb2N1bWVudFBhcnNlci5oCkBAIC04MSw2ICs4MSw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVh bCB2b2lkIGFwcGVuZChjb25zdCBTZWdtZW50ZWRTdHJpbmcmKTsKICAgICB2aXJ0dWFsIGJvb2wg ZmluaXNoV2FzQ2FsbGVkKCk7CiAgICAgdmlydHVhbCBib29sIHByb2Nlc3NpbmdEYXRhKCkgY29u c3Q7CisgICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1N0b3BQYXJzaW5nKCk7CiAgICAgdmlydHVh bCB2b2lkIHN0b3BQYXJzaW5nKCk7CiAgICAgdmlydHVhbCBib29sIGlzV2FpdGluZ0ZvclNjcmlw dHMoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNFeGVjdXRpbmdTY3JpcHQoKSBjb25zdDsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHAgYi9X ZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwCmluZGV4IDZkNDcwYTBhNWUw OGI0MGY2OGExODM1YWY1MTg4OTJiOGNhNWJiMTkuLjc2NGJmMDFhOGQ3MWM3MTY3YWNmYWUyZDIx OGZjNjBjOGQyZjJhNzcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlw dFJ1bm5lci5jcHAKKysrIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNw cApAQCAtNzUsNiArNzUsMTIgQEAgSFRNTFNjcmlwdFJ1bm5lcjo6fkhUTUxTY3JpcHRSdW5uZXIo KQogICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYmUgcGFzc2VkIGEgImRvbmUgbG9hZGluZy9wYXJz aW5nIiBjYWxsYmFjayBzb29uZXIgdGhhbiBkZXN0cnVjdGlvbj8KICAgICBpZiAobV9wYXJzaW5n QmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQu d2F0Y2hpbmdGb3JMb2FkKCkpCiAgICAgICAgIHN0b3BXYXRjaGluZ0ZvckxvYWQobV9wYXJzaW5n QmxvY2tpbmdTY3JpcHQpOworCisgICAgd2hpbGUgKCFtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBh cnNpbmcuaXNFbXB0eSgpKSB7CisgICAgICAgIFBlbmRpbmdTY3JpcHQgcGVuZGluZ1NjcmlwdCA9 IG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy50YWtlRmlyc3QoKTsKKyAgICAgICAgaWYg KHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgcGVuZGluZ1NjcmlwdC53YXRjaGluZ0Zv ckxvYWQoKSkKKyAgICAgICAgICAgIHN0b3BXYXRjaGluZ0ZvckxvYWQocGVuZGluZ1NjcmlwdCk7 CisgICAgfQogfQogCiB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OmRldGFjaCgpCkBAIC0xMjksMTAg KzEzNSw2IEBAIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1Nj cmlwdCgpCiAgICAgQVNTRVJUKG1fZG9jdW1lbnQtPmhhdmVTdHlsZXNoZWV0c0xvYWRlZCgpKTsK ICAgICBBU1NFUlQoaXNQZW5kaW5nU2NyaXB0UmVhZHkobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQp KTsKIAotICAgIC8vIFN0b3Agd2F0Y2hpbmcgbG9hZHMgYmVmb3JlIGV4ZWN1dGVTY3JpcHQgdG8g cHJldmVudCByZWN1cnNpb24gaWYgdGhlIHNjcmlwdCByZWxvYWRzIGl0c2VsZi4KLSAgICBpZiAo bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgbV9wYXJzaW5nQmxvY2tp bmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkpCi0gICAgICAgIHN0b3BXYXRjaGluZ0ZvckxvYWQo bV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOwotCiAgICAgSW5zZXJ0aW9uUG9pbnRSZWNvcmQgaW5z ZXJ0aW9uUG9pbnRSZWNvcmQobV9ob3N0LT5pbnB1dFN0cmVhbSgpKTsKICAgICBleGVjdXRlUGVu ZGluZ1NjcmlwdEFuZERpc3BhdGNoRXZlbnQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQpOwogfQpA QCAtMTQyLDYgKzE0NCwxMCBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5n U2NyaXB0QW5kRGlzcGF0Y2hFdmVudChQZW5kaW5nU2NyaXB0JiBwZW5kaQogICAgIGJvb2wgZXJy b3JPY2N1cnJlZCA9IGZhbHNlOwogICAgIFNjcmlwdFNvdXJjZUNvZGUgc291cmNlQ29kZSA9IHNv dXJjZUZyb21QZW5kaW5nU2NyaXB0KHBlbmRpbmdTY3JpcHQsIGVycm9yT2NjdXJyZWQpOwogCisg ICAgLy8gU3RvcCB3YXRjaGluZyBsb2FkcyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50 IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0IHJlbG9hZHMgaXRzZWxmLgorICAgIGlmIChwZW5kaW5n U2NyaXB0LmNhY2hlZFNjcmlwdCgpICYmIHBlbmRpbmdTY3JpcHQud2F0Y2hpbmdGb3JMb2FkKCkp CisgICAgICAgIHN0b3BXYXRjaGluZ0ZvckxvYWQocGVuZGluZ1NjcmlwdCk7CisKICAgICAvLyBD bGVhciB0aGUgcGVuZGluZyBzY3JpcHQgYmVmb3JlIHBvc3NpYmxlIHJlbnRyYW5jeSBmcm9tIGV4 ZWN1dGVTY3JpcHQoKQogICAgIFJlZlB0cjxFbGVtZW50PiBzY3JpcHRFbGVtZW50ID0gcGVuZGlu Z1NjcmlwdC5yZWxlYXNlRWxlbWVudEFuZENsZWFyKCk7CiAgICAgewpAQCAtMjM4LDYgKzI0NCwy NCBAQCBib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclN0eWxl c2hlZXRzKCkKICAgICByZXR1cm4gZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKIH0K IAorYm9vbCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5n KCkKK3sKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5 KCkpIHsKKyAgICAgICAgQVNTRVJUKCFtX3NjcmlwdE5lc3RpbmdMZXZlbCk7CisgICAgICAgIEFT U0VSVCghaGF2ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdCgpKTsKKyAgICAgICAgQVNTRVJUKG1fc2Ny aXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpKTsKKyAgICAg ICAgaWYgKCFtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcuZmlyc3QoKS5jYWNoZWRTY3Jp cHQoKS0+aXNMb2FkZWQoKSkgeworICAgICAgICAgICAgd2F0Y2hGb3JMb2FkKG1fc2NyaXB0c1Rv RXhlY3V0ZUFmdGVyUGFyc2luZy5maXJzdCgpKTsKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICAgICAgfQorICAgICAgICBQZW5kaW5nU2NyaXB0IGZpcnN0ID0gbV9zY3JpcHRzVG9FeGVj dXRlQWZ0ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAgICBleGVjdXRlUGVuZGluZ1Njcmlw dEFuZERpc3BhdGNoRXZlbnQoZmlyc3QpOworICAgICAgICBpZiAoIW1fZG9jdW1lbnQpCisgICAg ICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorICAgIHJldHVybiB0cnVlOworfQorCiB2b2lk IEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCog ZWxlbWVudCkKIHsKICAgICBpZiAoIXJlcXVlc3RQZW5kaW5nU2NyaXB0KG1fcGFyc2luZ0Jsb2Nr aW5nU2NyaXB0LCBlbGVtZW50KSkKQEAgLTI1Miw2ICsyNzYsMTYgQEAgdm9pZCBIVE1MU2NyaXB0 UnVubmVyOjpyZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KEVsZW1lbnQqIGVsZW1lbnQpCiAg ICAgICAgIHdhdGNoRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CiAKK3ZvaWQg SFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQqIGVsZW1lbnQp Cit7CisgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0OworICAgIGlmICghcmVxdWVzdFBl bmRpbmdTY3JpcHQocGVuZGluZ1NjcmlwdCwgZWxlbWVudCkpCisgICAgICAgIHJldHVybjsKKwor ICAgIEFTU0VSVChwZW5kaW5nU2NyaXB0LmNhY2hlZFNjcmlwdCgpKTsKKyAgICBtX3NjcmlwdHNU b0V4ZWN1dGVBZnRlclBhcnNpbmcuYXBwZW5kKHBlbmRpbmdTY3JpcHQpOworfQorCiBib29sIEhU TUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQZW5kaW5nU2NyaXB0KFBlbmRpbmdTY3JpcHQmIHBlbmRp bmdTY3JpcHQsIEVsZW1lbnQqIHNjcmlwdCkgY29uc3QKIHsKICAgICBBU1NFUlQoIXBlbmRpbmdT Y3JpcHQuZWxlbWVudCgpKTsKQEAgLTI4Nyw4ICszMjEsMTEgQEAgdm9pZCBIVE1MU2NyaXB0UnVu bmVyOjpydW5TY3JpcHQoRWxlbWVudCogc2NyaXB0LCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKQog ICAgICAgICBub3RJbXBsZW1lbnRlZCgpOyAvLyBldmVudCBmb3Igc3VwcG9ydAogCiAgICAgICAg IGlmIChzY3JpcHQtPmhhc0F0dHJpYnV0ZShzcmNBdHRyKSkgewotICAgICAgICAgICAgLy8gRklY TUU6IEhhbmRsZSBkZWZlciBhbmQgYXN5bmMKLSAgICAgICAgICAgIHJlcXVlc3RQYXJzaW5nQmxv Y2tpbmdTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIC8vIEZJWE1FOiBIYW5kbGUgYXN5bmMu CisgICAgICAgICAgICBpZiAoc2NyaXB0LT5oYXNBdHRyaWJ1dGUoZGVmZXJBdHRyKSkKKyAgICAg ICAgICAgICAgICByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoc2NyaXB0KTsKKyAgICAgICAgICAgIGVs c2UKKyAgICAgICAgICAgICAgICByZXF1ZXN0UGFyc2luZ0Jsb2NraW5nU2NyaXB0KHNjcmlwdCk7 CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAvLyBGSVhNRTogV2UgZG8gbm90IGJsb2Nr IGlubGluZSA8c2NyaXB0PiB0YWdzIG9uIHN0eWxlc2hlZXRzIHRvIG1hdGNoIHRoZQogICAgICAg ICAgICAgLy8gb2xkIHBhcnNlciBmb3Igbm93LiAgV2hlbiB3ZSBkbywgdGhlIEFTU0VSVCBiZWxv dyBzaG91bGQgYmUgYWRkZWQuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxT Y3JpcHRSdW5uZXIuaCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5oCmlu ZGV4IGVhZDkyODk1NDllYzEwMjhhNmE2OTdiMjE0Y2U0ZWE0YzYxMDA3OWUuLjQ3Yzk2ZmRiZDQx NmQwMzFmOTVjNmM4ZjYwYTk1N2RiYjE0MzVlMzAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9w YXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5oCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNj cmlwdFJ1bm5lci5oCkBAIC0yNyw2ICsyNyw3IEBACiAjZGVmaW5lIEhUTUxTY3JpcHRSdW5uZXJf aAogCiAjaW5jbHVkZSAiUGVuZGluZ1NjcmlwdC5oIgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgog I2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+ CiAKQEAgLTU2LDYgKzU3LDcgQEAgcHVibGljOgogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0 aW5nRm9yTG9hZChDYWNoZWRSZXNvdXJjZSopOwogICAgIGJvb2wgaGFzU2NyaXB0c1dhaXRpbmdG b3JTdHlsZXNoZWV0cygpIGNvbnN0IHsgcmV0dXJuIG1faGFzU2NyaXB0c1dhaXRpbmdGb3JTdHls ZXNoZWV0czsgfQogICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMo KTsKKyAgICBib29sIGV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKTsKIAogICAgIGJv b2wgaXNFeGVjdXRpbmdTY3JpcHQoKSBjb25zdCB7IHJldHVybiAhIW1fc2NyaXB0TmVzdGluZ0xl dmVsOyB9CiAKQEAgLTcxLDYgKzczLDcgQEAgcHJpdmF0ZToKICAgICBib29sIGV4ZWN1dGVQYXJz aW5nQmxvY2tpbmdTY3JpcHRzKCk7CiAKICAgICB2b2lkIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdT Y3JpcHQoRWxlbWVudCopOworICAgIHZvaWQgcmVxdWVzdERlZmVycmVkU2NyaXB0KEVsZW1lbnQq KTsKICAgICBib29sIHJlcXVlc3RQZW5kaW5nU2NyaXB0KFBlbmRpbmdTY3JpcHQmLCBFbGVtZW50 KikgY29uc3Q7CiAKICAgICB2b2lkIHJ1blNjcmlwdChFbGVtZW50KiwgaW50IHN0YXJ0aW5nTGlu ZU51bWJlcik7CkBAIC04NCw2ICs4Nyw3IEBAIHByaXZhdGU6CiAgICAgRG9jdW1lbnQqIG1fZG9j dW1lbnQ7CiAgICAgSFRNTFNjcmlwdFJ1bm5lckhvc3QqIG1faG9zdDsKICAgICBQZW5kaW5nU2Ny aXB0IG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0OworICAgIERlcXVlPFBlbmRpbmdTY3JpcHQ+IG1f c2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZzsgLy8gaHR0cDovL3d3dy53aGF0d2cub3JnL3Nw ZWNzL3dlYi1hcHBzL2N1cnJlbnQtd29yay8jbGlzdC1vZi1zY3JpcHRzLXRoYXQtd2lsbC1leGVj dXRlLXdoZW4tdGhlLWRvY3VtZW50LWhhcy1maW5pc2hlZC1wYXJzaW5nCiAgICAgdW5zaWduZWQg bV9zY3JpcHROZXN0aW5nTGV2ZWw7CiAKICAgICAvLyBXZSBvbmx5IHdhbnQgc3R5bGVzaGVldCBs b2FkcyB0byB0cmlnZ2VyIHNjcmlwdCBleGVjdXRpb24gaWYgc2NyaXB0CmRpZmYgLS1naXQgYS9X ZWJDb3JlL2xvYWRlci9JbWFnZURvY3VtZW50LmNwcCBiL1dlYkNvcmUvbG9hZGVyL0ltYWdlRG9j dW1lbnQuY3BwCmluZGV4IDcwMmVkOWQ3MGQ2NWVlYjM1ZjFhYTFlYjI0ODYyMzEyNTM2NmY3NmEu LmViYzk5ODk4MDQxMmZiYzRhYWNhOTM2NTQ5ZGM1MzY5MTk3OTVmODUgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvbG9hZGVyL0ltYWdlRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvbG9hZGVyL0ltYWdl RG9jdW1lbnQuY3BwCkBAIC0xMzgsNyArMTM4LDcgQEAgdm9pZCBJbWFnZURvY3VtZW50UGFyc2Vy OjphcHBlbmRCeXRlcyhEb2N1bWVudFdyaXRlciosIGNvbnN0IGNoYXIqLCBpbnQsIGJvb2wpCiAK IHZvaWQgSW1hZ2VEb2N1bWVudFBhcnNlcjo6ZmluaXNoKCkKIHsKLSAgICBpZiAoIW1fcGFyc2Vy U3RvcHBlZCAmJiBkb2N1bWVudCgpLT5pbWFnZUVsZW1lbnQoKSkgeworICAgIGlmIChpc0FjdGl2 ZSgpICYmIGRvY3VtZW50KCktPmltYWdlRWxlbWVudCgpKSB7CiAgICAgICAgIENhY2hlZEltYWdl KiBjYWNoZWRJbWFnZSA9IGRvY3VtZW50KCktPmNhY2hlZEltYWdlKCk7CiAgICAgICAgIFJlZlB0 cjxTaGFyZWRCdWZmZXI+IGRhdGEgPSBkb2N1bWVudCgpLT5mcmFtZSgpLT5sb2FkZXIoKS0+ZG9j dW1lbnRMb2FkZXIoKS0+bWFpblJlc291cmNlRGF0YSgpOwogCg== 66162 2010-08-31 20:09:52 -0700 2010-09-01 09:10:43 -0700 Fix Qt build bug-40934-20100831200951.patch text/plain 44958 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0NzljMzIxYWNjZDdkNjRlMGY5ZDRhZDBiMWQ4ZGQxOWZiMmY1ODk3Li42NTkzZDVm ZTM5Njc4MmU4OWM2ODM4NGIxNTUyZTU0Mzc1ZmE5MjRmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDgtMzEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3Jp cHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IENvcGll ZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uLzUxMzY2OTYtZXhwZWN0ZWQudHh0 LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZl ci13cml0ZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNj cmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uLzUxMzY2OTYt ZXhwZWN0ZWQudHh0LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LXdyaXRlLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9kZWZlci5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFsLmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qczogQWRkZWQu CisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90ZXhlY3V0ZS5q czogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVy LXdyaXRlcy1leHBlY3RlZC50eHQ6IENvcGllZCBmcm9tIExheW91dFRlc3RzL2VkaXRpbmcvc2Vs ZWN0aW9uLzUxMzY2OTYtZXhwZWN0ZWQudHh0LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMuaHRtbDogQWRkZWQuCisgICAgICAgICogaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanM6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzOiBBZGRlZC4KKyAgICAg ICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91 bmQuanM6IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qczogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2k6IEFkZGVkLgorICAgICAgICAqIGh0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaTogQWRkZWQuCisgICAg ICAgICogaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRl ZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sOiBBZGRlZC4KKwogMjAxMC0wOC0zMSAgVG9u eSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHVwZGF0 aW5nIGNocm9taXVtIHRlc3RfZXhwZWN0YXRpb25zLnR4dC4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIyZTlhNDMx YWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1s IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRl ZmVyLXdyaXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQxMjA1MGIyZTQzYjY5NDkxYjU0MzQ3MzVmMmQ2 ZmU1MTRlZjk5ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBA QAorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRl ZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsgZG9j dW1lbnQud3JpdGUoJzxzY3JpcHQgZGVmZXIgc3JjPVwnZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9j dW1lbnQud3JpdGUoJnF1b3Q7UEFTUyZxdW90Oyk7XCc+PC9zY3JpcHQ+Jyk7IGRvY3VtZW50LmNs b3NlKCk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjhkMDRmOTYxYTAzNzExN2MxZWFhNjlhYzYwZWIzNjNkMzdhZTc4ZDEK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKKzEgMgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91 YmxlLXdyaXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1kb3VibGUtd3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNTVlMWQzZGIzZjk2M2M4Zjk3YTk3 NjUyYTA0YTZjYTFmY2RhYzkxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9k b20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSw2 IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwKKzxzY3JpcHQg ZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZWxuKDEpOyBkb2N1 bWVudC53cml0ZSgnPHNjcmlwdCBzcmM9XCdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53 cml0ZWxuKDIpXCc+PC9zY3JpcHQ+Jyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5s aW5lLXNjcmlwdC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOWIwMmQxNjMxNzdmNTY1Y2RiN2Qw Y2U1NmIzNWI4NTQzMzIxMzljZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsMyBAQAorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJl ZC4KKzEKKzIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMTVjMjAx MTlhYzQ4MDQ1NjIwNzQ0OGRmMjg2MzUyMzhhOWZlOTU3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5o dG1sCkBAIC0wLDAgKzEsMTUgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFRE IEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9 Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4v Li4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 PgorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KKzxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0LGRlYnVn KDIpOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IGRlZmVyPgorICBkZWJ1ZygxKTsKKzwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYmEzZTM3MWY3MDI4ZmExMzgwZTJhMzVmNTQ1NDgxYjk0YWIy MDEwNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitD aGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5 IGFuZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorY2FuY2VsbGVkIG9uYmVmb3JlbG9hZCBkZWZl cgorb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9yZWxvYWQgZXh0ZXJuYWwKK2V4dGVybmFsCitk ZWZlcgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv ZGVmZXItb25iZWZvcmVsb2FkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hMjJiMTg0ZGE2M2Jh NDc1NzExYmUxZjdiZjU5NTk5YTU0MTYwZTJhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKQEAg LTAsMCArMSwxNCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8v RU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4v anMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVj a3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIGZpcmUgb25iZWZvcmVsb2FkIGltbWVkaWF0ZWx5IGFu ZCB0aGF0IGl0IGlzIGNhbmNlbGxhYmxlLgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ2NhbmNlbGxlZCBvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIGZhbHNlOyIgZGVmZXI+ PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2VzL2RlZmVyLmpzIiBvbmJlZm9yZWxvYWQ9 ImRlYnVnKCdvbmJlZm9yZWxvYWQgZGVmZXInKTsgcmV0dXJuIHRydWU7IiBkZWZlcj48L3Njcmlw dD4KKzxzY3JpcHQgc3JjPSJyZXNvdXJjZXMvZXh0ZXJuYWwuanMiIG9uYmVmb3JlbG9hZD0iZGVi dWcoJ29uYmVmb3JlbG9hZCBleHRlcm5hbCcpOyByZXR1cm4gdHJ1ZTsiPjwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDQ1YWYxZGNkNjlhZjg2NzUyN2I3ZmVkNTlkZjEzMDNl NDYzYzQ4YwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSwzIEBACitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFy ZSBpZ25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCitkZWZl cgorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9k ZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmQ1 YTNlNTFmYjkzMmMyNDgyNzFlYjU5ODhmYmExZjQzMmI4N2QzZDgKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52 YWxpZC11cmwuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0v L0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1zdHlsZS5jc3MiPgorPHNjcmlw dCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGRlZmVycmVkIHNjcmlwdHMgd2l0aCBpbnZhbGlkIFVS THMgYXJlIGlnbm9yZWQgYW5kIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBleGVjdXRlZC4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly9pbnZhbGlkOjk5 OTk5OS8iIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIg ZGVmZXI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uN2VmMjJlOWE0MzFhZDAyNzI3MTNiNzFmZGM4Nzk0MDE2YzhlZjEy ZgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS5o dG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4wYzBiYmZmNDU2MTc2ZjE2ZDk2NjNhYTA5OWZjMzY4MTllNGRiOWMx Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1Rl eHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZh c2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBi L0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5q cwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv cmVzb3VyY2VzL2RlZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3Vy Y2VzL2V4dGVybmFsLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJk ZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWco ImV4dGVybmFsIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmMwZDY5NTQwMTYyZjlhZDdjYWIxZjAyMDc2ZGY4MWIxOTcxN2JkOTAKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiRkFJTCIpOwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90 ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3Vs ZG5vdGV4ZWN1dGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUxYzQ0Mjg3YzNiNmNmNGVmZDYx MjEwOGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRl ZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC90d28tZGVmZXItd3JpdGVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjdlZjIyZTlhNDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3Jp dGVzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uNGIwZDM3ODczMDVkODI0YmE4NzZlMmI2MTRlMzZjMWM2ZjA0NWI3Ywot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3R3by1kZWZlci13cml0ZXMuaHRtbApAQCAtMCwwICsxLDcgQEAKKzxzY3JpcHQ+CitpZiAod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9q YXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KKzxzY3JpcHQgZGVm ZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgnRkFJTCcpOyI+PC9z Y3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2Vz L2RlZmVyLXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMv ZGVmZXItc2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2 MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21p c2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIi KTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0 ZXJuYWwtc2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9l eHRlcm5hbC1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJl YmRlMWVhNDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJl eHRlcm5hbCIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291 cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjZmYmU3YTFjNDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1k ZWJ1Zy1ib2R5LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCJnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10i LCAicmdiKDI1NSwgMCwgMCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVl dC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lZDExZWI1MmM2ZWY3ZmVlZjE1MWQyZDQ3OTllM2RjMmFlYjI3NmYz Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNl cy9zY3JpcHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzCkBAIC0wLDAgKzEgQEAKK2RvY3VtZW50 LndyaXRlKCc8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAw MC9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4nKTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dp IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlw dC5jZ2kKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQx OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJj ZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJs IC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAo MC41KTsKK3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLmZjZGRjYTQwMWY4YWIzYTZhNWRmODczYTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ct c3R5bGVzaGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJp bnQgIkNvbnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiYm9k eSB7IGJhY2tncm91bmQtY29sb3I6ICNGRjAwMDAgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0 ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40OTBhZjA4ZDJkZjYw MGNiYmI5MmM1MWNjODJlNDE0NDI1NjZjNGQyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0cyB0aGF0IGFuIGlubGluZSBzbG93 IHN0eWxlc2hlZXQgZXhlY3V0ZXMgYmVmb3JlIGRlZmVycmVkIHNjcmlwdHMuCisKK09uIHN1Y2Nl c3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5 ICJURVNUIENPTVBMRVRFIi4KKworUEFTUyBnZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkp WydiYWNrZ3JvdW5kLWNvbG9yJ10gaXMgInJnYigyNTUsIDAsIDApIgorRE9NQ29udGVudExvYWRl ZAorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNs b3ctc3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wNmVjODQ5YzM4OWQ0 MzliYjc5NDgwZWZiM2YzMzc3YzM1NDNjMTk5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRt bApAQCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBI VE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBl IiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxl c2hlZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkdmkgaWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxk aXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgor ZGVzY3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4 ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLicpOworCit2YXIganNUZXN0SXNBc3luYyA9 IHRydWU7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBm dW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rl c3QoKTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4w LjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuCitq cyIgZGVmZXI9ImRlZmVyIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0i aHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGUKK2V0LmNn aSI+Cis8c2NyaXB0PgordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwv c2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rl c3RzL21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lZjQ1MTg3MzMz NmJjY2U4MGMxZWE4MGE5ZjhjZjc0MzE5N2E1YmJjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSw3IEBACitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMg d2l0aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMDcxMC4KK2V4dGVybmFsCitpbmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNv bnRlbnRMb2FkZWQKK2xvYWQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlz Yy9zY3JpcHQtZGVmZXIuaHRtbCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NWNmOGIzNTA3NWZhMThiZDYyM2JjZDZjYWQ2YWU2N2Rl NWQzYzMzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Nj cmlwdC1kZWZlci5odG1sCkBAIC0wLDAgKzEsMjQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAi LS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2 PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD11dGYtOCIgLz4KKzxs aW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRl c3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0iZGVidWcoJ2xvYWQn KSI+CitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0 aCB0aGUgZGVmZXIgYXR0cmlidXRlIDxhIGhyZWY9Imh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDcxMCI+aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwNzEwPC9hPi4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorCis8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+Citkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50 TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01Db250ZW50TG9hZGVkJyk7Cit9LCBm YWxzZSk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlz Yy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIiBkZWZlcj0iREVGRVIiPjwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9kZWZl ci1zY3JpcHQuanMiIGRlZmVyPSJERUZFUiI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iaHR0cDov LzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0PgorZGVidWcoImlubGluZSIpOworPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0 bWw+CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmlu ZGV4IDNiZDQ5ZGJjZWU1YmU4NDkzZDlhODFhNDY2OTRmN2UwMzljYWYzMjcuLmM0ZGRmNWZmOWQ3 Mjc4MmQzMjM3NmE0ZmQ5MmNhNmM2MjI4MzM1NGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzIgQEAKKzIwMTAtMDgtMzEg IFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTdXBwb3J0IDxzY3JpcHQgZGVmZXI+IGFz IHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBUZXN0czogZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sCisgICAgICAgICAg ICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwK KyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3Jl bG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sCisgICAgICAgICAgICAgICBodHRw L3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAg ICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKKworICAgICAgICAq IGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6b3Blbik6Cisg ICAgICAgICogZG9tL0RvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRvY3Vt ZW50UGFyc2VyOjpEb2N1bWVudFBhcnNlcik6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBh cnNlcjo6c3RhcnRQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50UGFyc2VyOjpw cmVwYXJlVG9TdG9wUGFyc2luZyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6 c3RvcFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6OmRldGFjaCk6 CisgICAgICAgICogZG9tL0RvY3VtZW50UGFyc2VyLmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1 bWVudFBhcnNlcjo6aXNQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50UGFyc2Vy Ojppc0FjdGl2ZSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNTdG9wcGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNEZXRhY2hlZCk6CisgICAg ICAgICogZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oOgorICAgICAgICAoV2ViQ29yZTo6UmF3 RGF0YURvY3VtZW50UGFyc2VyOjpmaW5pc2gpOgorICAgICAgICAqIGRvbS9YTUxEb2N1bWVudFBh cnNlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKToK KyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpleGl0VGV4dCk6CisgICAgICAg ICogZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpY TUxEb2N1bWVudFBhcnNlcjo6ZG9Xcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVu dFBhcnNlcjo6c3RhcnRFbGVtZW50TnMpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQ YXJzZXI6OmVuZEVsZW1lbnROcyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNl cjo6Y2hhcmFjdGVycyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6ZXJy b3IpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJbnN0 cnVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y2RhdGFCbG9j ayk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y29tbWVudCk6CisgICAg ICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW50ZXJuYWxTdWJzZXQpOgorICAgICAg ICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KToK KyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpkb0VuZCk6CisgICAgICAgICog aHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhU TUxEb2N1bWVudFBhcnNlcjo6cHJlcGFyZVRvU3RvcFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29y ZTo6SFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVySWZQb3NzaWJsZSk6CisgICAgICAg IChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXIpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjppbnNlcnQpOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTERvY3VtZW50UGFyc2VyOjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3Vt ZW50UGFyc2VyOjplbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjph dHRlbXB0VG9FbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJ ZkRlbGF5ZWQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlG aW5pc2hlZCk6CisgICAgICAgICogaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmg6Cisg ICAgICAgICogaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJD b3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5k RGlzcGF0Y2hFdmVudCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVj dXRlU2NyaXB0c1dhaXRpbmdGb3JQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3Jp cHRSdW5uZXI6OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpydW5TY3JpcHQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3Jp cHRSdW5uZXIuaDoKKyAgICAgICAgKiBsb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpJbWFnZURvY3VtZW50UGFyc2VyOjpmaW5pc2gpOgorCiAyMDEwLTA4LTMwICBJ bHlhIFRpa2hvbm92c2t5ICA8bG9pc2xvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdl ZCBieSBKb3NlcGggUGVjb3Jhcm8uCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXggOGEzNWFiY2ZkMjNlYjkxOTU3NTNj OWZmYmExZWZjZjIxNDYwOTkxMC4uNTc4M2I4ZDI5NWYyMDJjZGQyOTM4M2Y2YTJhZDI3MzkwOGIz NWUwMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNvcmUv ZG9tL0RvY3VtZW50LmNwcApAQCAtMTgyNCw3ICsxODI0LDcgQEAgdm9pZCBEb2N1bWVudDo6b3Bl bihEb2N1bWVudCogb3duZXJEb2N1bWVudCkKIAogICAgIGlmIChtX2ZyYW1lKSB7CiAgICAgICAg IFNjcmlwdGFibGVEb2N1bWVudFBhcnNlciogcGFyc2VyID0gc2NyaXB0YWJsZURvY3VtZW50UGFy c2VyKCk7Ci0gICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIoKS0+aXNMb2FkaW5nTWFpblJlc291 cmNlKCkgfHwgKHBhcnNlciAmJiBwYXJzZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkpKQorICAgICAg ICBpZiAobV9mcmFtZS0+bG9hZGVyKCktPmlzTG9hZGluZ01haW5SZXNvdXJjZSgpIHx8IChwYXJz ZXIgJiYgcGFyc2VyLT5pc1BhcnNpbmcoKSAmJiBwYXJzZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkp KQogICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIoKS0+ c3RhdGUoKSA9PSBGcmFtZVN0YXRlUHJvdmlzaW9uYWwpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Rv bS9Eb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5jcHAKaW5k ZXggY2M0YzYxYjAzNDk2NWJmMWNmMDEzY2Q2NDA5OTIxOWQxYjExMmVmMS4uNjM5ODYwYTJjYWU0 YTk5YTQzY2EwOWQ2NTRlYjY0NmY5ZWU0NzAwYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9j dW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmNwcApAQCAt MzEsNyArMzEsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBEb2N1bWVudFBhcnNlcjo6RG9j dW1lbnRQYXJzZXIoRG9jdW1lbnQqIGRvY3VtZW50KQotICAgIDogbV9wYXJzZXJTdG9wcGVkKGZh bHNlKQorICAgIDogbV9zdGF0ZShQYXJzaW5nU3RhdGUpCiAgICAgLCBtX2RvY3VtZW50KGRvY3Vt ZW50KQogewogICAgIEFTU0VSVChkb2N1bWVudCk7CkBAIC00NSw4ICs0NSwyNSBAQCBEb2N1bWVu dFBhcnNlcjo6fkRvY3VtZW50UGFyc2VyKCkKICAgICBBU1NFUlQoIW1fZG9jdW1lbnQpOwogfQog Cit2b2lkIERvY3VtZW50UGFyc2VyOjpzdGFydFBhcnNpbmcoKQoreworICAgIG1fc3RhdGUgPSBQ YXJzaW5nU3RhdGU7Cit9CisKK3ZvaWQgRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJz aW5nKCkKK3sKKyAgICBpZiAobV9zdGF0ZSA9PSBQYXJzaW5nU3RhdGUpCisgICAgICAgIG1fc3Rh dGUgPSBTdG9wcGluZ1N0YXRlOworfQorCit2b2lkIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2lu ZygpCit7CisgICAgbV9zdGF0ZSA9IFN0b3BwZWRTdGF0ZTsKK30KKwogdm9pZCBEb2N1bWVudFBh cnNlcjo6ZGV0YWNoKCkKIHsKKyAgICBtX3N0YXRlID0gRGV0YWNoZWRTdGF0ZTsKICAgICBtX2Rv Y3VtZW50ID0gMDsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIu aCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmgKaW5kZXggM2MyODg1NjI1ZWUxMzEwNDBj MWY3Yzk5OWRiZTUzMjc5MDZlMmRhYy4uZjQyMWYwYmY4ODEzOWYwZGNlMWQ4NDI2NGVkZGY2Yjk4 ODNjMDg0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIuaAorKysgYi9X ZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5oCkBAIC01NywxMiArNTcsMjkgQEAgcHVibGljOgog CiAgICAgLy8gRklYTUU6IHByb2Nlc3NpbmdEYXRhKCkgaXMgb25seSB1c2VkIGJ5IERvY3VtZW50 TG9hZGVyOjppc0xvYWRpbmdJbkFQSVNlbnNlCiAgICAgLy8gYW5kIGlzIHZlcnkgdW5jbGVhciBh cyB0byB3aGF0IGl0IGFjdHVhbGx5IG1lYW5zLiAgVGhlIExlZ2FjeUhUTUxEb2N1bWVudFBhcnNl cgotICAgIC8vIHVzZWQgdG8gaW1wbGVtZW50cyBpdC4KKyAgICAvLyB1c2VkIHRvIGltcGxlbWVu dCBpdC4KICAgICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0RhdGEoKSBjb25zdCB7IHJldHVybiBm YWxzZTsgfQogCiAgICAgLy8gZG9jdW1lbnQoKSB3aWxsIHJldHVybiAwIGFmdGVyIGRldGFjaCgp IGlzIGNhbGxlZC4KICAgICBEb2N1bWVudCogZG9jdW1lbnQoKSBjb25zdCB7IEFTU0VSVChtX2Rv Y3VtZW50KTsgcmV0dXJuIG1fZG9jdW1lbnQ7IH0KLSAgICBib29sIGlzRGV0YWNoZWQoKSBjb25z dCB7IHJldHVybiAhbV9kb2N1bWVudDsgfQorCisgICAgYm9vbCBpc1BhcnNpbmcoKSBjb25zdCB7 IHJldHVybiBtX3N0YXRlID09IFBhcnNpbmdTdGF0ZTsgfQorICAgIGJvb2wgaXNBY3RpdmUoKSBj b25zdCB7IHJldHVybiBtX3N0YXRlICYgKFBhcnNpbmdTdGF0ZSB8IFN0b3BwaW5nU3RhdGUpOyB9 CisgICAgYm9vbCBpc1N0b3BwaW5nKCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZSA9PSBTdG9wcGlu Z1N0YXRlOyB9CisgICAgYm9vbCBpc0RldGFjaGVkKCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZSA9 PSBEZXRhY2hlZFN0YXRlOyB9CisKKyAgICAvLyBGSVhNRTogSXMgdGhpcyBuZWNlc3Nhcnk/IERv ZXMgWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyIHJlYWxseSBuZWVkIHRvIHNldCB0aGlzPworICAg IHZpcnR1YWwgdm9pZCBzdGFydFBhcnNpbmcoKTsKKworICAgIC8vIHByZXBhcmVUb1N0b3AoKSBp cyB1c2VkIHdoZW4gdGhlIEVPRiB0b2tlbiBpcyBlbmNvdW50ZXJlZCBhbmQgcGFyc2luZyBpcyB0 byBiZQorICAgIC8vIHN0b3BwZWQgbm9ybWFsbHkuCisgICAgdmlydHVhbCB2b2lkIHByZXBhcmVU b1N0b3BQYXJzaW5nKCk7CisKKyAgICAvLyBzdG9wUGFyc2luZygpIGlzIHVzZWQgd2hlbiBhIGxv YWQgaXMgY2FuY2VsZWQvc3RvcHBlZC4KKyAgICAvLyBzdG9wUGFyc2luZygpIGlzIGN1cnJlbnRs eSBkaWZmZXJlbnQgZnJvbSBkZXRhY2goKSwgYnV0IHNob3VsZG4ndCBiZS4KKyAgICAvLyBJdCBz aG91bGQgTk9UIGJlIG9rIHRvIGNhbGwgYW55IG1ldGhvZHMgb24gRG9jdW1lbnRQYXJzZXIgYWZ0 ZXIgZWl0aGVyCisgICAgLy8gZGV0YWNoKCkgb3Igc3RvcFBhcnNpbmcoKSBidXQgcmlnaHQgbm93 IG9ubHkgZGV0YWNoKCkgd2lsbCBBU1NFUlQuCisgICAgdmlydHVhbCB2b2lkIHN0b3BQYXJzaW5n KCk7CiAKICAgICAvLyBEb2N1bWVudCBpcyBleHBlY3RlZCB0byBkZXRhY2ggdGhlIHBhcnNlciBi ZWZvcmUgcmVsZWFzaW5nIGl0cyByZWYuCiAgICAgLy8gQWZ0ZXIgZGV0YWNoLCBtX2RvY3VtZW50 IGlzIGNsZWFyZWQuICBUaGUgcGFyc2VyIHdpbGwgdW53aW5kIGl0cwpAQCAtNzEsMjIgKzg4LDE4 IEBAIHB1YmxpYzoKICAgICAvLyBkZXRhY2ggaXMgY2FsbGVkLgogICAgIHZpcnR1YWwgdm9pZCBk ZXRhY2goKTsKIAotICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgdXNlZCB3aGVuIGEgbG9hZCBpcyBj YW5jZWxlZC9zdG9wcGVkLgotICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgY3VycmVudGx5IGRpZmZl cmVudCBmcm9tIGRldGFjaCgpLCBidXQgc2hvdWxkbid0IGJlLgotICAgIC8vIEl0IHNob3VsZCBO T1QgYmUgb2sgdG8gY2FsbCBhbnkgbWV0aG9kcyBvbiBEb2N1bWVudFBhcnNlciBhZnRlciBlaXRo ZXIKLSAgICAvLyBkZXRhY2goKSBvciBzdG9wUGFyc2luZygpIGJ1dCByaWdodCBub3cgb25seSBk ZXRhY2goKSB3aWxsIEFTU0VSVC4KLSAgICB2aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKSB7IG1f cGFyc2VyU3RvcHBlZCA9IHRydWU7IH0KLQogcHJvdGVjdGVkOgogICAgIERvY3VtZW50UGFyc2Vy KERvY3VtZW50Kik7CiAKLSAgICAvLyBUaGUgcGFyc2VyIGhhcyBidWZmZXJzLCBzbyBwYXJzaW5n IG1heSBjb250aW51ZSBldmVuIGFmdGVyCi0gICAgLy8gaXQgc3RvcHMgcmVjZWl2aW5nIGRhdGEu IFdlIHVzZSBtX3BhcnNlclN0b3BwZWQgdG8gc3RvcCB0aGUgcGFyc2VyCi0gICAgLy8gZXZlbiB3 aGVuIGl0IGhhcyBidWZmZXJlZCBkYXRhLgotICAgIC8vIEZJWE1FOiBtX2RvY3VtZW50ID0gMCBj b3VsZCBiZSBjaGFuZ2VkIHRvIG1lYW4gInBhcnNlciBzdG9wcGVkIi4KLSAgICBib29sIG1fcGFy c2VyU3RvcHBlZDsKLQogcHJpdmF0ZToKKyAgICBlbnVtIFBhcnNlclN0YXRlIHsKKyAgICAgICAg UGFyc2luZ1N0YXRlID0gMHgxLAorICAgICAgICBTdG9wcGluZ1N0YXRlID0gMHgyLAorICAgICAg ICBTdG9wcGVkU3RhdGUgPSAweDQsCisgICAgICAgIERldGFjaGVkU3RhdGUgPSAweDgKKyAgICB9 OworICAgIFBhcnNlclN0YXRlIG1fc3RhdGU7CisKICAgICAvLyBFdmVyeSBEb2N1bWVudFBhcnNl ciBuZWVkcyBhIHBvaW50ZXIgYmFjayB0byB0aGUgZG9jdW1lbnQuCiAgICAgLy8gbV9kb2N1bWVu dCB3aWxsIGJlIDAgYWZ0ZXIgdGhlIHBhcnNlciBpcyBzdG9wcGVkLgogICAgIERvY3VtZW50KiBt X2RvY3VtZW50OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUmF3RGF0YURvY3VtZW50UGFyc2Vy LmggYi9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaAppbmRleCAwOTNkZGFmNjdk MTgwYzRkYTBhYzcxNjZjZTRmYWFmZDVjMTgxMWMxLi45NzZlYzQwNTdmNDM0ZmViNjE5NGFiMGU1 OThkNGI1MzdmY2E1ZDk0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQ YXJzZXIuaAorKysgYi9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaApAQCAtMzks NyArMzksNyBAQCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgZmluaXNoKCkKICAgICB7 Ci0gICAgICAgIGlmICghbV9wYXJzZXJTdG9wcGVkICYmICFpc0RldGFjaGVkKCkpCisgICAgICAg IGlmIChpc0FjdGl2ZSgpKQogICAgICAgICAgICAgZG9jdW1lbnQoKS0+ZmluaXNoZWRQYXJzaW5n KCk7CiAgICAgfQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5j cHAgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggNGI3NjQ3MjJhZWVm MzZlMjZhNTE1YTEzZTZjMzcyM2MwNmFjZjhkNy4uMWM3NTgyOGQ5OTUwMWJhOTUwMzAwYzU1ZTk4 YThhYjdiYmNkNTQwZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIu Y3BwCisrKyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyLmNwcApAQCAtMTMyLDcgKzEz Miw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmFwcGVuZChjb25zdCBTZWdtZW50ZWRTdHJp bmcmIHMpCiAgICAgaWYgKG1fc2F3WFNMVHJhbnNmb3JtIHx8ICFtX3Nhd0ZpcnN0RWxlbWVudCkK ICAgICAgICAgbV9vcmlnaW5hbFNvdXJjZUZvclRyYW5zZm9ybSArPSBwYXJzZVN0cmluZzsKIAot ICAgIGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkIHx8IG1fc2F3WFNMVHJhbnNm b3JtKQorICAgIGlmICghaXNBY3RpdmUoKSB8fCBtX3Nhd1hTTFRyYW5zZm9ybSkKICAgICAgICAg cmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC0xOTAsNyArMTkwLDcgQEAg c3RhdGljIGlubGluZSBTdHJpbmcgdG9TdHJpbmcoY29uc3QgeG1sQ2hhciogc3RyLCB1bnNpZ25l ZCBsZW4pCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmV4aXRUZXh0KCkKIHsKLSAgICBpZiAo bV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwog CiAgICAgaWYgKCFtX2N1cnJlbnROb2RlIHx8ICFtX2N1cnJlbnROb2RlLT5pc1RleHROb2RlKCkp CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwIGIv V2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAppbmRleCBkYjk0YzUwYjQ0 NzcxZmQ1MWVhNDNmODQxNmM4NGFlZDI3MTVlZTlmLi43ZWZkNmYyZDYwNWYyYTRiMDU0NWI5YTQ0 NDVkY2Y3ZWRhYzJiOGE0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNl ckxpYnhtbDIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5j cHAKQEAgLTY2MCw3ICs2NjAsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpkb1dyaXRlKGNv bnN0IFN0cmluZyYgcGFyc2VTdHJpbmcpCiAKICAgICAgICAgLy8gSmF2YVNjcmlwdCAod2hpY2gg bWF5IGJlIHJ1biB1bmRlciB0aGUgeG1sUGFyc2VDaHVuayBjYWxsc3RhY2spIG1heQogICAgICAg ICAvLyBjYXVzZSB0aGUgcGFyc2VyIHRvIGJlIHN0b3BwZWQgb3IgZGV0YWNoZWQuCi0gICAgICAg IGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkKQorICAgICAgICBpZiAoIWlzQWN0 aXZlKCkpCiAgICAgICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC03MzMsNyArNzMzLDcgQEAg c3RhdGljIGlubGluZSB2b2lkIGhhbmRsZUVsZW1lbnRBdHRyaWJ1dGVzKEVsZW1lbnQqIG5ld0Vs ZW1lbnQsIGNvbnN0IHhtbENoYXIqKgogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6c3RhcnRFbGVt ZW50TnMoY29uc3QgeG1sQ2hhciogeG1sTG9jYWxOYW1lLCBjb25zdCB4bWxDaGFyKiB4bWxQcmVm aXgsIGNvbnN0IHhtbENoYXIqIHhtbFVSSSwgaW50IG5iX25hbWVzcGFjZXMsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgeG1sQ2hhcioqIGxpYnhtbE5hbWVzcGFjZXMs IGludCBuYl9hdHRyaWJ1dGVzLCBpbnQgbmJfZGVmYXVsdGVkLCBjb25zdCB4bWxDaGFyKiogbGli eG1sQXR0cmlidXRlcykKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNB Y3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBA IC04MjIsNyArODIyLDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6c3RhcnRFbGVtZW50TnMo Y29uc3QgeG1sQ2hhciogeG1sTG9jYWxOYW1lLCBjb25zdCB4bWxDaGEKIAogdm9pZCBYTUxEb2N1 bWVudFBhcnNlcjo6ZW5kRWxlbWVudE5zKCkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQor ICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2Vy UGF1c2VkKSB7CkBAIC05MDYsNyArOTA2LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZW5k RWxlbWVudE5zKCkKIAogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6Y2hhcmFjdGVycyhjb25zdCB4 bWxDaGFyKiBzLCBpbnQgbGVuKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYg KCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1cm47CiAKICAgICBpZiAobV9wYXJzZXJQYXVzZWQp IHsKQEAgLTkyMSw3ICs5MjEsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpjaGFyYWN0ZXJz KGNvbnN0IHhtbENoYXIqIHMsIGludCBsZW4pCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVy cm9yKEVycm9yVHlwZSB0eXBlLCBjb25zdCBjaGFyKiBtZXNzYWdlLCB2YV9saXN0IGFyZ3MpCiB7 Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoIWlzQWN0aXZlKCkpCiAgICAgICAg IHJldHVybjsKIAogI2lmIENPTVBJTEVSKE1TVkMpIHx8IENPTVBJTEVSKFJWQ1QpCkBAIC05NDUs NyArOTQ1LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZXJyb3IoRXJyb3JUeXBlIHR5cGUs IGNvbnN0IGNoYXIqIG1lc3NhZ2UsIHZhX2xpc3QgYXJncykKIAogdm9pZCBYTUxEb2N1bWVudFBh cnNlcjo6cHJvY2Vzc2luZ0luc3RydWN0aW9uKGNvbnN0IHhtbENoYXIqIHRhcmdldCwgY29uc3Qg eG1sQ2hhciogZGF0YSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNB Y3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBA IC05NzksNyArOTc5LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6cHJvY2Vzc2luZ0luc3Ry dWN0aW9uKGNvbnN0IHhtbENoYXIqIHRhcmdldCwgY29uc3QgeG1sQ2gKIAogdm9pZCBYTUxEb2N1 bWVudFBhcnNlcjo6Y2RhdGFCbG9jayhjb25zdCB4bWxDaGFyKiBzLCBpbnQgbGVuKQogewotICAg IGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYgKCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1 cm47CiAKICAgICBpZiAobV9wYXJzZXJQYXVzZWQpIHsKQEAgLTk5Nyw3ICs5OTcsNyBAQCB2b2lk IFhNTERvY3VtZW50UGFyc2VyOjpjZGF0YUJsb2NrKGNvbnN0IHhtbENoYXIqIHMsIGludCBsZW4p CiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmNvbW1lbnQoY29uc3QgeG1sQ2hhciogcykKIHsK LSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAg cmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC0xMDM0LDcgKzEwMzQsNyBA QCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjplbmREb2N1bWVudCgpCiAKIHZvaWQgWE1MRG9jdW1l bnRQYXJzZXI6OmludGVybmFsU3Vic2V0KGNvbnN0IHhtbENoYXIqIG5hbWUsIGNvbnN0IHhtbENo YXIqIGV4dGVybmFsSUQsIGNvbnN0IHhtbENoYXIqIHN5c3RlbUlEKQogewotICAgIGlmIChtX3Bh cnNlclN0b3BwZWQpCisgICAgaWYgKCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1cm47CiAKICAg ICBpZiAobV9wYXJzZXJQYXVzZWQpIHsKQEAgLTEyOTQsNyArMTI5NCw3IEBAIHZvaWQgWE1MRG9j dW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqIGNodW5rKQog ICAgIHNheC5pZ25vcmFibGVXaGl0ZXNwYWNlID0gaWdub3JhYmxlV2hpdGVzcGFjZUhhbmRsZXI7 CiAgICAgc2F4LmVudGl0eURlY2wgPSB4bWxTQVgyRW50aXR5RGVjbDsKICAgICBzYXguaW5pdGlh bGl6ZWQgPSBYTUxfU0FYMl9NQUdJQzsKLSAgICBtX3BhcnNlclN0b3BwZWQgPSBmYWxzZTsKKyAg ICBEb2N1bWVudFBhcnNlcjo6c3RhcnRQYXJzaW5nKCk7CiAgICAgbV9zYXdFcnJvciA9IGZhbHNl OwogICAgIG1fc2F3WFNMVHJhbnNmb3JtID0gZmFsc2U7CiAgICAgbV9zYXdGaXJzdEVsZW1lbnQg PSBmYWxzZTsKQEAgLTEzMTgsMTEgKzEzMTgsMTEgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6 ZG9FbmQoKQogICAgICAgICBkb2N1bWVudCgpLT5zZXRQYXJzaW5nKGZhbHNlKTsgLy8gTWFrZSB0 aGUgZG9jIHRoaW5rIGl0J3MgZG9uZSwgc28gaXQgd2lsbCBhcHBseSB4c2wgc2hlZXRzLgogICAg ICAgICBkb2N1bWVudCgpLT5zdHlsZVNlbGVjdG9yQ2hhbmdlZChSZWNhbGNTdHlsZUltbWVkaWF0 ZWx5KTsKICAgICAgICAgZG9jdW1lbnQoKS0+c2V0UGFyc2luZyh0cnVlKTsKLSAgICAgICAgbV9w YXJzZXJTdG9wcGVkID0gdHJ1ZTsKKyAgICAgICAgRG9jdW1lbnRQYXJzZXI6OnN0b3BQYXJzaW5n KCk7CiAgICAgfQogI2VuZGlmCiAKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmICgh aXNBY3RpdmUoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fY29udGV4dCkgewpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJRdC5jcHAgYi9XZWJDb3JlL2Rv bS9YTUxEb2N1bWVudFBhcnNlclF0LmNwcAppbmRleCBkZmQ2ZmIxOTJiOGRjYjViZjcwMjhkNGU3 ZDY2MmU3OGZjZTM3NGJiLi40MWZjMzU2NzYxNmZmNTAwOTU3ODE2YThiMmY2ZTQxYzJkODI0NTU2 IDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlclF0LmNwcAorKysgYi9X ZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlclF0LmNwcApAQCAtMTk5LDcgKzE5OSw3IEBAIHZv aWQgWE1MRG9jdW1lbnRQYXJzZXI6OmRvV3JpdGUoY29uc3QgU3RyaW5nJiBwYXJzZVN0cmluZykK IAogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6aW5pdGlhbGl6ZVBhcnNlckNvbnRleHQoY29uc3Qg Y2hhciopCiB7Ci0gICAgbV9wYXJzZXJTdG9wcGVkID0gZmFsc2U7CisgICAgRG9jdW1lbnRQYXJz ZXI6OnN0b3BQYXJzaW5nKCk7CiAgICAgbV9zYXdFcnJvciA9IGZhbHNlOwogICAgIG1fc2F3WFNM VHJhbnNmb3JtID0gZmFsc2U7CiAgICAgbV9zYXdGaXJzdEVsZW1lbnQgPSBmYWxzZTsKQEAgLTIx Myw3ICsyMTMsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpkb0VuZCgpCiAgICAgICAgIGRv Y3VtZW50KCktPnNldFBhcnNpbmcoZmFsc2UpOyAvLyBNYWtlIHRoZSBkb2MgdGhpbmsgaXQncyBk b25lLCBzbyBpdCB3aWxsIGFwcGx5IHhzbCBzaGVldHMuCiAgICAgICAgIGRvY3VtZW50KCktPnN0 eWxlU2VsZWN0b3JDaGFuZ2VkKFJlY2FsY1N0eWxlSW1tZWRpYXRlbHkpOwogICAgICAgICBkb2N1 bWVudCgpLT5zZXRQYXJzaW5nKHRydWUpOwotICAgICAgICBtX3BhcnNlclN0b3BwZWQgPSB0cnVl OworICAgICAgICBEb2N1bWVudFBhcnNlcjo6c3RhcnRQYXJzaW5nKCk7CiAgICAgfQogI2VuZGlm CiAKQEAgLTM1MCw3ICszNTAsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgaGFuZGxlRWxlbWVudEF0 dHJpYnV0ZXMoRWxlbWVudCogbmV3RWxlbWVudCwgY29uc3QgUVhtbFN0cmVhbQogCiB2b2lkIFhN TERvY3VtZW50UGFyc2VyOjpwYXJzZSgpCiB7Ci0gICAgd2hpbGUgKCFtX3BhcnNlclN0b3BwZWQg JiYgIW1fcGFyc2VyUGF1c2VkICYmICFtX3N0cmVhbS5hdEVuZCgpKSB7CisgICAgd2hpbGUgKGlz QWN0aXZlKCkgJiYgIW1fcGFyc2VyUGF1c2VkICYmICFtX3N0cmVhbS5hdEVuZCgpKSB7CiAgICAg ICAgIG1fc3RyZWFtLnJlYWROZXh0KCk7CiAgICAgICAgIHN3aXRjaCAobV9zdHJlYW0udG9rZW5U eXBlKCkpIHsKICAgICAgICAgY2FzZSBRWG1sU3RyZWFtUmVhZGVyOjpTdGFydERvY3VtZW50OiB7 CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAg Yi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggMjA3YmQz ZTYzMjAwYjQ2MTI2Y2QyODA2NGY2MmNiNjYxNDI3YmRiMi4uMzc0MjAxNTYyZjhkYzBjMjNhOTkx M2JlYTdiNDYxN2ExMWQ4OWExNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1M RG9jdW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50 UGFyc2VyLmNwcApAQCAtMTQyLDYgKzE0MiwzMSBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6 c3RvcFBhcnNpbmcoKQogICAgIG1fcGFyc2VyU2NoZWR1bGVyLmNsZWFyKCk7IC8vIERlbGV0aW5n IHRoZSBzY2hlZHVsZXIgd2lsbCBjbGVhciBhbnkgdGltZXJzLgogfQogCisvLyBUaGlzIGtpY2tz IG9mZiAiT25jZSB0aGUgdXNlciBhZ2VudCBzdG9wcyBwYXJzaW5nIiBhcyBkZXNjcmliZWQgYnk6 CisvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrL211 bHRpcGFnZS90aGUtZW5kLmh0bWwjdGhlLWVuZAordm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnBy ZXBhcmVUb1N0b3BQYXJzaW5nKCkKK3sKKyAgICBBU1NFUlQoIWhhc0luc2VydGlvblBvaW50KCkp OworCisgICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0 YWNoZWQgZnJvbSB0aGUgRG9jdW1lbnQsCisgICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0 IGlzbid0IGRlbGV0ZWQgeWV0LgorICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3Rl Y3QodGhpcyk7CisKKyAgICAvLyBGSVhNRTogU2V0IHRoZSBjdXJyZW50IGRvY3VtZW50IHJlYWRp bmVzcyB0byAiaW50ZXJhY3RpdmUiLgorCisgICAgLy8gTk9URTogVGhpcyBwdW1wIHNob3VsZCBv bmx5IGV2ZXIgZW1pdCBidWZmZXJlZCBjaGFyYWN0ZXIgdG9rZW5zLAorICAgIC8vIHNvIEZvcmNl U3luY2hyb25vdXMgdnMuIEFsbG93WWllbGQgc2hvdWxkIGJlIG1lYW5pbmdsZXNzLgorICAgIHB1 bXBUb2tlbml6ZXJJZlBvc3NpYmxlKEZvcmNlU3luY2hyb25vdXMpOworCisgICAgRG9jdW1lbnRQ YXJzZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCk7CisgICAgaWYgKG1fc2NyaXB0UnVubmVyKSB7 CisgICAgICAgIGlmICghbV9zY3JpcHRSdW5uZXItPmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmcoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBlbmQoKTsKK30KKwog Ym9vbCBIVE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdEYXRhKCkgY29uc3QKIHsKICAgICBy ZXR1cm4gaXNTY2hlZHVsZWRGb3JSZXN1bWUoKSB8fCBpbldyaXRlKCk7CkBAIC0xNDksNyArMTc0 LDcgQEAgYm9vbCBIVE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdEYXRhKCkgY29uc3QKIAog dm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXJJZlBvc3NpYmxlKFN5bmNocm9u b3VzTW9kZSBtb2RlKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQgfHwgbV90cmVlQnVpbGRl ci0+aXNQYXVzZWQoKSkKKyAgICBpZiAoIWlzQWN0aXZlKCkgfHwgbV90cmVlQnVpbGRlci0+aXNQ YXVzZWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgLy8gT25jZSBhIHJlc3VtZSBpcyBzY2hl ZHVsZWQsIEhUTUxQYXJzZXJTY2hlZHVsZXIgY29udHJvbHMgd2hlbiB3ZSBuZXh0IHB1bXAuCkBA IC0xOTMsOCArMjE4LDcgQEAgYm9vbCBIVE1MRG9jdW1lbnRQYXJzZXI6OnJ1blNjcmlwdHNGb3JQ YXVzZWRUcmVlQnVpbGRlcigpCiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5p emVyKFN5bmNocm9ub3VzTW9kZSBtb2RlKQogewotICAgIEFTU0VSVCghaXNEZXRhY2hlZCgpKTsK LSAgICBBU1NFUlQoIW1fcGFyc2VyU3RvcHBlZCk7CisgICAgQVNTRVJUKGlzQWN0aXZlKCkpOwog ICAgIEFTU0VSVCghbV90cmVlQnVpbGRlci0+aXNQYXVzZWQoKSk7CiAgICAgQVNTRVJUKCFpc1Nj aGVkdWxlZEZvclJlc3VtZSgpKTsKICAgICAvLyBBU1NFUlQgdGhhdCB0aGlzIG9iamVjdCBpcyBi b3RoIGF0dGFjaGVkIHRvIHRoZSBEb2N1bWVudCBhbmQgcHJvdGVjdGVkLgpAQCAtMjE0LDcgKzIz OCw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVyKFN5bmNocm9ub3Vz TW9kZSBtb2RlKQogICAgICAgICBtX3Rva2VuLmNsZWFyKCk7CiAKICAgICAgICAgLy8gSmF2YVNj cmlwdCBtYXkgaGF2ZSBzdG9wcGVkIG9yIGRldGFjaGVkIHRoZSBwYXJzZXIuCi0gICAgICAgIGlm IChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkKQorICAgICAgICBpZiAoIWlzQWN0aXZl KCkpCiAgICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAgLy8gVGhlIHBhcnNlciB3aWxsIHBh dXNlIGl0c2VsZiB3aGVuIHdhaXRpbmcgb24gYSBzY3JpcHQgdG8gbG9hZCBvciBydW4uCkBAIC0y MjYsNyArMjUwLDcgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXIoU3lu Y2hyb25vdXNNb2RlIG1vZGUpCiAgICAgICAgIG1fdHJlZUJ1aWxkZXItPnNldFBhdXNlZCghc2hv dWxkQ29udGludWVQYXJzaW5nKTsKIAogICAgICAgICAvLyBKYXZhU2NyaXB0IG1heSBoYXZlIHN0 b3BwZWQgb3IgZGV0YWNoZWQgdGhlIHBhcnNlci4KLSAgICAgICAgaWYgKGlzRGV0YWNoZWQoKSB8 fCBtX3BhcnNlclN0b3BwZWQpCisgICAgICAgIGlmICghaXNBY3RpdmUoKSkKICAgICAgICAgICAg IHJldHVybjsKIAogICAgICAgICBpZiAoIXNob3VsZENvbnRpbnVlUGFyc2luZykKQEAgLTI3NSw3 ICsyOTksNyBAQCBib29sIEhUTUxEb2N1bWVudFBhcnNlcjo6aGFzSW5zZXJ0aW9uUG9pbnQoKQog CiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6aW5zZXJ0KGNvbnN0IFNlZ21lbnRlZFN0cmluZyYg c291cmNlKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYgKCFpc0FjdGl2ZSgp KQogICAgICAgICByZXR1cm47CiAKICAgICAvLyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlz IHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKQEAgLTI5Niw3ICszMjAs NyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6aW5zZXJ0KGNvbnN0IFNlZ21lbnRlZFN0cmlu ZyYgc291cmNlKQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKGNvbnN0IFNlZ21l bnRlZFN0cmluZyYgc291cmNlKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYg KCFpc0FjdGl2ZSgpKQogICAgICAgICByZXR1cm47CiAKICAgICAvLyBwdW1wVG9rZW5pemVyIGNh biBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKQEAg LTMyOCwxNCArMzUyLDYgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmVuZCgpCiAgICAgQVNT RVJUKCFpc0RldGFjaGVkKCkpOwogICAgIEFTU0VSVCghaXNTY2hlZHVsZWRGb3JSZXN1bWUoKSk7 CiAKLSAgICAvLyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRh Y2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKLSAgICAvLyBidXQgd2UgbmVlZCB0byBlbnN1cmUgaXQg aXNuJ3QgZGVsZXRlZCB5ZXQuCi0gICAgUmVmUHRyPEhUTUxEb2N1bWVudFBhcnNlcj4gcHJvdGVj dCh0aGlzKTsKLQotICAgIC8vIE5PVEU6IFRoaXMgcHVtcCBzaG91bGQgb25seSBldmVyIGVtaXQg YnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywKLSAgICAvLyBzbyBGb3JjZVN5bmNocm9ub3VzIHZz LiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFuaW5nbGVzcy4KLSAgICBwdW1wVG9rZW5pemVySWZQ b3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsKLQogICAgIC8vIEluZm9ybXMgdGhlIHRoZSByZXN0 IG9mIFdlYkNvcmUgdGhhdCBwYXJzaW5nIGlzIHJlYWxseSBmaW5pc2hlZCAoYW5kIGRlbGV0ZXMg dGhpcykuCiAgICAgbV90cmVlQnVpbGRlci0+ZmluaXNoZWQoKTsKIH0KQEAgLTM0OSw3ICszNjUs NyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKCkKICAgICAgICAgbV9l bmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICBlbmQoKTsK KyAgICBwcmVwYXJlVG9TdG9wUGFyc2luZygpOwogfQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNl cjo6ZW5kSWZEZWxheWVkKCkKQEAgLTM2Miw3ICszNzgsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBh cnNlcjo6ZW5kSWZEZWxheWVkKCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgbV9lbmRXYXNEZWxh eWVkID0gZmFsc2U7Ci0gICAgZW5kKCk7CisgICAgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKIH0K IAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCgpCkBAIC00NDcsNiArNDYzLDExIEBA IGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpzaG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3Jj KGNvbnN0IEF0b21pY1N0cmluZyYgc3JjCiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpub3Rp ZnlGaW5pc2hlZChDYWNoZWRSZXNvdXJjZSogY2FjaGVkUmVzb3VyY2UpCiB7CisgICAgaWYgKGlz U3RvcHBpbmcoKSkgeworICAgICAgICBwcmVwYXJlVG9TdG9wUGFyc2luZygpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCiAgICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJz ZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUgRG9jdW1lbnQsCiAgICAgLy8gYnV0IHdlIG5lZWQg dG8gZW5zdXJlIGl0IGlzbid0IGRlbGV0ZWQgeWV0LgogICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQ YXJzZXI+IHByb3RlY3QodGhpcyk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hU TUxEb2N1bWVudFBhcnNlci5oIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJz ZXIuaAppbmRleCBkYTIxYTJiYTExNGUyMDAyYmRlMjRmY2FmMzllZDA5ZGJiNTE5ZGMxLi5hMzJi NDM5NmQzOWNkMDA2NWJhZmQ2NDJlZDYyNTQyZDgwZWZlOWJjIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJz ZXIvSFRNTERvY3VtZW50UGFyc2VyLmgKQEAgLTgxLDYgKzgxLDcgQEAgcHJpdmF0ZToKICAgICB2 aXJ0dWFsIHZvaWQgYXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYpOwogICAgIHZpcnR1YWwg Ym9vbCBmaW5pc2hXYXNDYWxsZWQoKTsKICAgICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0RhdGEo KSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKICAgICB2 aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKTsKICAgICB2aXJ0dWFsIGJvb2wgaXNXYWl0aW5nRm9y U2NyaXB0cygpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNv bnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNw cCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggNmQ0NzBh MGE1ZTA4YjQwZjY4YTE4MzVhZjUxODg5MmI4Y2E1YmIxOS4uNzY0YmYwMWE4ZDcxYzcxNjdhY2Zh ZTJkMjE4ZmM2MGM4ZDJmMmE3NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1M U2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5u ZXIuY3BwCkBAIC03NSw2ICs3NSwxMiBAQCBIVE1MU2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1 bm5lcigpCiAgICAgLy8gRklYTUU6IFNob3VsZCB3ZSBiZSBwYXNzZWQgYSAiZG9uZSBsb2FkaW5n L3BhcnNpbmciIGNhbGxiYWNrIHNvb25lciB0aGFuIGRlc3RydWN0aW9uPwogICAgIGlmIChtX3Bh cnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKICAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3Bh cnNpbmdCbG9ja2luZ1NjcmlwdCk7CisKKyAgICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFm dGVyUGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2Ny aXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAg ICBpZiAocGVuZGluZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBwZW5kaW5nU2NyaXB0LndhdGNo aW5nRm9yTG9hZCgpKQorICAgICAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2Ny aXB0KTsKKyAgICB9CiB9CiAKIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZGV0YWNoKCkKQEAgLTEy OSwxMCArMTM1LDYgQEAgdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2Nr aW5nU2NyaXB0KCkKICAgICBBU1NFUlQobV9kb2N1bWVudC0+aGF2ZVN0eWxlc2hlZXRzTG9hZGVk KCkpOwogICAgIEFTU0VSVChpc1BlbmRpbmdTY3JpcHRSZWFkeShtX3BhcnNpbmdCbG9ja2luZ1Nj cmlwdCkpOwogCi0gICAgLy8gU3RvcCB3YXRjaGluZyBsb2FkcyBiZWZvcmUgZXhlY3V0ZVNjcmlw dCB0byBwcmV2ZW50IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0IHJlbG9hZHMgaXRzZWxmLgotICAg IGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdC bG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKLSAgICAgICAgc3RvcFdhdGNoaW5nRm9y TG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7Ci0KICAgICBJbnNlcnRpb25Qb2ludFJlY29y ZCBpbnNlcnRpb25Qb2ludFJlY29yZChtX2hvc3QtPmlucHV0U3RyZWFtKCkpOwogICAgIGV4ZWN1 dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7 CiB9CkBAIC0xNDIsNiArMTQ0LDEwIEBAIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBl bmRpbmdTY3JpcHRBbmREaXNwYXRjaEV2ZW50KFBlbmRpbmdTY3JpcHQmIHBlbmRpCiAgICAgYm9v bCBlcnJvck9jY3VycmVkID0gZmFsc2U7CiAgICAgU2NyaXB0U291cmNlQ29kZSBzb3VyY2VDb2Rl ID0gc291cmNlRnJvbVBlbmRpbmdTY3JpcHQocGVuZGluZ1NjcmlwdCwgZXJyb3JPY2N1cnJlZCk7 CiAKKyAgICAvLyBTdG9wIHdhdGNoaW5nIGxvYWRzIGJlZm9yZSBleGVjdXRlU2NyaXB0IHRvIHBy ZXZlbnQgcmVjdXJzaW9uIGlmIHRoZSBzY3JpcHQgcmVsb2FkcyBpdHNlbGYuCisgICAgaWYgKHBl bmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgcGVuZGluZ1NjcmlwdC53YXRjaGluZ0Zvckxv YWQoKSkKKyAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKwogICAg IC8vIENsZWFyIHRoZSBwZW5kaW5nIHNjcmlwdCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZy b20gZXhlY3V0ZVNjcmlwdCgpCiAgICAgUmVmUHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBw ZW5kaW5nU2NyaXB0LnJlbGVhc2VFbGVtZW50QW5kQ2xlYXIoKTsKICAgICB7CkBAIC0yMzgsNiAr MjQ0LDI0IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9y U3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygp OwogfQogCitib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBh cnNpbmcoKQoreworICAgIHdoaWxlICghbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlz RW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIW1fc2NyaXB0TmVzdGluZ0xldmVsKTsKKyAgICAg ICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkpOworICAgICAgICBBU1NFUlQo bV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0KCkuY2FjaGVkU2NyaXB0KCkpOwor ICAgICAgICBpZiAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5maXJzdCgpLmNhY2hl ZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgICAgICB3YXRjaEZvckxvYWQobV9zY3Jp cHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0KCkpOworICAgICAgICAgICAgcmV0dXJuIGZh bHNlOworICAgICAgICB9CisgICAgICAgIFBlbmRpbmdTY3JpcHQgZmlyc3QgPSBtX3NjcmlwdHNU b0V4ZWN1dGVBZnRlclBhcnNpbmcudGFrZUZpcnN0KCk7CisgICAgICAgIGV4ZWN1dGVQZW5kaW5n U2NyaXB0QW5kRGlzcGF0Y2hFdmVudChmaXJzdCk7CisgICAgICAgIGlmICghbV9kb2N1bWVudCkK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHRydWU7Cit9CisK IHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVt ZW50KiBlbGVtZW50KQogewogICAgIGlmICghcmVxdWVzdFBlbmRpbmdTY3JpcHQobV9wYXJzaW5n QmxvY2tpbmdTY3JpcHQsIGVsZW1lbnQpKQpAQCAtMjUyLDYgKzI3NiwxNiBAQCB2b2lkIEhUTUxT Y3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoRWxlbWVudCogZWxlbWVu dCkKICAgICAgICAgd2F0Y2hGb3JMb2FkKG1fcGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAor dm9pZCBIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogZWxl bWVudCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3JpcHQ7CisgICAgaWYgKCFyZXF1 ZXN0UGVuZGluZ1NjcmlwdChwZW5kaW5nU2NyaXB0LCBlbGVtZW50KSkKKyAgICAgICAgcmV0dXJu OworCisgICAgQVNTRVJUKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkpOworICAgIG1fc2Ny aXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5hcHBlbmQocGVuZGluZ1NjcmlwdCk7Cit9CisKIGJv b2wgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBlbmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYg cGVuZGluZ1NjcmlwdCwgRWxlbWVudCogc2NyaXB0KSBjb25zdAogewogICAgIEFTU0VSVCghcGVu ZGluZ1NjcmlwdC5lbGVtZW50KCkpOwpAQCAtMjg3LDggKzMyMSwxMSBAQCB2b2lkIEhUTUxTY3Jp cHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1i ZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAg ICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAv LyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBhc3luYwotICAgICAgICAgICAgcmVxdWVzdFBhcnNp bmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOworICAgICAgICAgICAgLy8gRklYTUU6IEhhbmRsZSBh c3luYy4KKyAgICAgICAgICAgIGlmIChzY3JpcHQtPmhhc0F0dHJpYnV0ZShkZWZlckF0dHIpKQor ICAgICAgICAgICAgICAgIHJlcXVlc3REZWZlcnJlZFNjcmlwdChzY3JpcHQpOworICAgICAgICAg ICAgZWxzZQorICAgICAgICAgICAgICAgIHJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoc2Ny aXB0KTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIC8vIEZJWE1FOiBXZSBkbyBub3Qg YmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVzaGVldHMgdG8gbWF0Y2ggdGhlCiAg ICAgICAgICAgICAvLyBvbGQgcGFyc2VyIGZvciBub3cuICBXaGVuIHdlIGRvLCB0aGUgQVNTRVJU IGJlbG93IHNob3VsZCBiZSBhZGRlZC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9wYXJzZXIv SFRNTFNjcmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVy LmgKaW5kZXggZWFkOTI4OTU0OWVjMTAyOGE2YTY5N2IyMTRjZTRlYTRjNjEwMDc5ZS4uNDdjOTZm ZGJkNDE2ZDAzMWY5NWM2YzhmNjBhOTU3ZGJiMTQzNWUzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9o dG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIvV2ViQ29yZS9odG1sL3BhcnNlci9I VE1MU2NyaXB0UnVubmVyLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNkZWZpbmUgSFRNTFNjcmlwdFJ1 bm5lcl9oCiAKICNpbmNsdWRlICJQZW5kaW5nU2NyaXB0LmgiCisjaW5jbHVkZSA8d3RmL0RlcXVl Lmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQ dHIuaD4KIApAQCAtNTYsNiArNTcsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0 c1dhaXRpbmdGb3JMb2FkKENhY2hlZFJlc291cmNlKik7CiAgICAgYm9vbCBoYXNTY3JpcHRzV2Fp dGluZ0ZvclN0eWxlc2hlZXRzKCkgY29uc3QgeyByZXR1cm4gbV9oYXNTY3JpcHRzV2FpdGluZ0Zv clN0eWxlc2hlZXRzOyB9CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNo ZWV0cygpOworICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpOwogCiAg ICAgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNvbnN0IHsgcmV0dXJuICEhbV9zY3JpcHROZXN0 aW5nTGV2ZWw7IH0KIApAQCAtNzEsNiArNzMsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgZXhlY3V0 ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKIAogICAgIHZvaWQgcmVxdWVzdFBhcnNpbmdCbG9j a2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAgdm9pZCByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxl bWVudCopOwogICAgIGJvb2wgcmVxdWVzdFBlbmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYsIEVs ZW1lbnQqKSBjb25zdDsKIAogICAgIHZvaWQgcnVuU2NyaXB0KEVsZW1lbnQqLCBpbnQgc3RhcnRp bmdMaW5lTnVtYmVyKTsKQEAgLTg0LDYgKzg3LDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCog bV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCogbV9ob3N0OwogICAgIFBlbmRp bmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7CisgICAgRGVxdWU8UGVuZGluZ1Njcmlw dD4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOyAvLyBodHRwOi8vd3d3LndoYXR3Zy5v cmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNsaXN0LW9mLXNjcmlwdHMtdGhhdC13aWxs LWV4ZWN1dGUtd2hlbi10aGUtZG9jdW1lbnQtaGFzLWZpbmlzaGVkLXBhcnNpbmcKICAgICB1bnNp Z25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8vIFdlIG9ubHkgd2FudCBzdHlsZXNo ZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlvbiBpZiBzY3JpcHQKZGlmZiAtLWdp dCBhL1dlYkNvcmUvbG9hZGVyL0ltYWdlRG9jdW1lbnQuY3BwIGIvV2ViQ29yZS9sb2FkZXIvSW1h Z2VEb2N1bWVudC5jcHAKaW5kZXggNzAyZWQ5ZDcwZDY1ZWViMzVmMWFhMWViMjQ4NjIzMTI1MzY2 Zjc2YS4uZWJjOTk4OTgwNDEyZmJjNGFhY2E5MzY1NDlkYzUzNjkxOTc5NWY4NSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKKysrIGIvV2ViQ29yZS9sb2FkZXIv SW1hZ2VEb2N1bWVudC5jcHAKQEAgLTEzOCw3ICsxMzgsNyBAQCB2b2lkIEltYWdlRG9jdW1lbnRQ YXJzZXI6OmFwcGVuZEJ5dGVzKERvY3VtZW50V3JpdGVyKiwgY29uc3QgY2hhciosIGludCwgYm9v bCkKIAogdm9pZCBJbWFnZURvY3VtZW50UGFyc2VyOjpmaW5pc2goKQogewotICAgIGlmICghbV9w YXJzZXJTdG9wcGVkICYmIGRvY3VtZW50KCktPmltYWdlRWxlbWVudCgpKSB7CisgICAgaWYgKGlz QWN0aXZlKCkgJiYgZG9jdW1lbnQoKS0+aW1hZ2VFbGVtZW50KCkpIHsKICAgICAgICAgQ2FjaGVk SW1hZ2UqIGNhY2hlZEltYWdlID0gZG9jdW1lbnQoKS0+Y2FjaGVkSW1hZ2UoKTsKICAgICAgICAg UmVmUHRyPFNoYXJlZEJ1ZmZlcj4gZGF0YSA9IGRvY3VtZW50KCktPmZyYW1lKCktPmxvYWRlcigp LT5kb2N1bWVudExvYWRlcigpLT5tYWluUmVzb3VyY2VEYXRhKCk7CiAK 66219 2010-09-01 09:11:09 -0700 2010-09-01 15:03:24 -0700 Patch for landing bug-40934-20100901091107.patch text/plain 45674 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA4YTdmYTAzNTA4ZGJlMTlkOWNkZmJlZWU5ZTcwYzQ3ZjE4MWJiNWFjLi5lYzkxYmFi YWI5NWNiYjZiYTUyMGFmNDZlNDA3OGJhYzk5NjczZWJhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDgtMzEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgIFN1cHBvcnQgPHNjcmlwdCBk ZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdy aXRlLmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IGEgd3JpdGUgb2YgYSBkZWZlcnJlZCBzY3JpcHQg ZnJvbSBhIGRlZmVycmVkIHNjcmlwdCB3aWxsIGV4ZWN1dGUgd2hlbiB0aGUgZG9jdW1lbnQgaXMg Y2xvc2VkLiBUaGUgZXhwbGljaXQgY2xvc2UgaXMgbmVjZXNzYXJ5IGJlY2F1c2UgdGhpcyBpcyBh IHNjcmlwdCBjcmVhdGVkIHBhcnNlci4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQu IFRlc3RzIHRoYXQgYSBzY3JpcHQgYmxvY2sgd3JpdHRlbiBmcm9tIGEgZGVmZXJyZWQgc2NyaXB0 IHdpbGwgd3JpdGUgaW50byB0aGUgbmV3IGRvY3VtZW50LgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0 Lmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IGlubGluZSBzY3JpcHRzIGFyZSBub3QgZGVmZXJyZWQu IFRoaXMgaXMgY29uc2lzdGVudCB3aXRoIEhUTUw1IGFuZCBpbmNvbnNpc3RlbnQgd2l0aCBJRS4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgdGhlIGJlZm9yZWxv YWQgZXZlbnQgaXMgZmlyZWQgaW1tZWRpYXRlbHkgYW5kIGlzIGNhbmNlbGxhYmxlLgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4gVGVzdHMgdGhhdCBkZWZlcnJl ZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFuZCB0aGF0IHN1YnNlcXVl bnQgZGVmZXJyZWQgc2NyaXB0cyB3aWxsIGJlIHJ1bi4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0 cyB0aGF0IGEgYmFzaWMgd3JpdGUgZnJvbSBhIGRlZmVycmVkIHNjcmlwdCBibG93cyBhd2F5IHRo ZSBkb2N1bWVudC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvZGVmZXIuanM6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9leHRlcm5hbC5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanM6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanM6IEFkZGVk LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC90d28tZGVmZXItd3JpdGVzLmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IHdoZW4gYSBkb2N1bWVu dC53cml0ZSBmcm9tIHRoZSBmaXJzdCBkZWZlcnJlZCBzY3JpcHQgYmxvd3MgYXdheSB0aGUgZG9j dW1lbnQsIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgbm90IGV4ZWN1dGVkLgorICAg ICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qczog QWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWct Ym9keS1iYWNrZ3JvdW5kLmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanM6IEFkZGVkLgorICAgICAgICAq IGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2k6 IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xv dy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbDogQWRkZWQuIFRlc3Rz IHRoYXQgZGVmZXJyZWQgc2NyaXB0cyByZXNwZWN0IGJsb2NraW5nIHN0eWxlc2hlZXRzLgorICAg ICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWw6IEFkZGVkLiBUZXN0 cyBiYXNpYyBvcmRlcmluZyBvZiBkZWZlcnJlZCBzY3JpcHRzLgorCiAyMDEwLTA4LTMxICBBbGV4 ZXkgUHJvc2t1cnlha292ICA8YXBAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFk YW0gQmFydGguCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVj dGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi43ZWYyMmU5YTQzMWFkMDI3MjcxM2I3MWZkYzg3OTQwMTZjOGVm MTJmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBA CitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjA0MTIwNTBiMmU0M2I2OTQ5MWI1NDM0NzM1ZjJkNmZlNTE0ZWY5OWQKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUt ZGVmZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZhc2Ny aXB0LGRvY3VtZW50LndyaXRlKCdGQUlMJyk7IGRvY3VtZW50LndyaXRlKCc8c2NyaXB0IGRlZmVy IHNyYz1cJ2RhdGE6dGV4dC9qYXZhc2NyaXB0LGRvY3VtZW50LndyaXRlKCZxdW90O1BBU1MmcXVv dDspO1wnPjwvc2NyaXB0PicpOyBkb2N1bWVudC5jbG9zZSgpOyI+PC9zY3JpcHQ+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUt d3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDc1NQpp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZDA0Zjk2MWEw MzcxMTdjMWVhYTY5YWM2MGViMzYzZDM3YWU3OGQxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxIEBACisxIDIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS13cml0ZS5odG1sIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZTU1ZTFkM2RiM2Y5NjNjOGY5N2E5NzY1MmEwNGE2Y2ExZmNkYWM5MQotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVy LWRvdWJsZS13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBAQAorPHNjcmlwdD4KK2lmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRlZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFz Y3JpcHQsZG9jdW1lbnQud3JpdGVsbigxKTsgZG9jdW1lbnQud3JpdGUoJzxzY3JpcHQgc3JjPVwn ZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGVsbigyKVwnPjwvc2NyaXB0PicpOyI+ PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1pbmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjliMDJkMTYzMTc3ZjU2NWNkYjdkMGNlNTZiMzViODU0MzMyMTM5Y2QKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZl ci1pbmxpbmUtc2NyaXB0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK0NoZWNrcyB0aGF0 IGlubGluZSBzY3JpcHRzIGFyZSBub3QgZGVmZXJyZWQuCisxCisyCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUt c2NyaXB0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTE1YzIwMTE5YWM0ODA0NTYyMDc0NDhkZjI4NjM1MjM4 YTlmZTk1NwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQuaHRtbApAQCAtMCwwICsxLDE1IEBACis8IURP Q1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFk PgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVz dC1zdHlsZS5jc3MiPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KK0NoZWNrcyB0aGF0IGlubGluZSBzY3Jp cHRzIGFyZSBub3QgZGVmZXJyZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQg c3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkZWJ1ZygyKTsiIGRlZmVyPjwvc2NyaXB0PgorPHNj cmlwdCBkZWZlcj4KKyAgZGVidWcoMSk7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9u YmVmb3JlbG9hZC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmJhM2Uz NzFmNzAyOGZhMTM4MGUyYTM1ZjU0NTQ4MWI5NGFiMjAxMDcKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorQ2hlY2tzIHRoYXQgZGVmZXJyZWQgc2NyaXB0 cyBmaXJlIG9uYmVmb3JlbG9hZCBpbW1lZGlhdGVseSBhbmQgdGhhdCBpdCBpcyBjYW5jZWxsYWJs ZS4KK2NhbmNlbGxlZCBvbmJlZm9yZWxvYWQgZGVmZXIKK29uYmVmb3JlbG9hZCBkZWZlcgorb25i ZWZvcmVsb2FkIGV4dGVybmFsCitleHRlcm5hbAorZGVmZXIKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2Fk Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYTIyYjE4NGRhNjNiYTQ3NTcxMWJlMWY3YmY1OTU5OWE1NDE2MGUy YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVt ZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCkBAIC0wLDAgKzEsMTQgQEAKKzwhRE9DVFlQRSBI VE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGlu ayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxl LmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorQ2hlY2tzIHRoYXQgZGVmZXJyZWQgc2NyaXB0cyBm aXJlIG9uYmVmb3JlbG9hZCBpbW1lZGlhdGVseSBhbmQgdGhhdCBpdCBpcyBjYW5jZWxsYWJsZS4K KzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9zaG91bGRu b3RleGVjdXRlLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdjYW5jZWxsZWQgb25iZWZvcmVsb2Fk IGRlZmVyJyk7IHJldHVybiBmYWxzZTsiIGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJl c291cmNlcy9kZWZlci5qcyIgb25iZWZvcmVsb2FkPSJkZWJ1Zygnb25iZWZvcmVsb2FkIGRlZmVy Jyk7IHJldHVybiB0cnVlOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0icmVzb3VyY2Vz L2V4dGVybmFsLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdvbmJlZm9yZWxvYWQgZXh0ZXJuYWwn KTsgcmV0dXJuIHRydWU7Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZh bGlkLXVybC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA0 NWFmMWRjZDY5YWY4Njc1MjdiN2ZlZDU5ZGYxMzAzZTQ2M2M0OGMKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52 YWxpZC11cmwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMyBAQAorQ2hlY2tzIHRoYXQgZGVmZXJy ZWQgc2NyaXB0cyB3aXRoIGludmFsaWQgVVJMcyBhcmUgaWdub3JlZCBhbmQgc3Vic2VxdWVudCBk ZWZlcnJlZCBzY3JpcHRzIGV4ZWN1dGVkLgorZGVmZXIKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQt aW52YWxpZC11cmwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kNWEzZTUxZmI5MzJjMjQ4MjcxZWI1OTg4ZmJh MWY0MzJiODdkM2Q4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRN TFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJsLmh0bWwKQEAgLTAsMCArMSwx MyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0 bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMvcmVzb3Vy Y2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMv anMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVja3MgdGhhdCBk ZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFuZCBzdWJzZXF1 ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4K KzxzY3JpcHQgc3JjPSJodHRwOi8vaW52YWxpZDo5OTk5OTkvIiBkZWZlcj48L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSJyZXNvdXJjZXMvZGVmZXIuanMiIGRlZmVyPjwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIyZTlh NDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMGMwYmJmZjQ1 NjE3NmYxNmQ5NjYzYWEwOTlmYzM2ODE5ZTRkYjljMQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKQEAgLTAs MCArMSw2IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAg ICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwKKzxz Y3JpcHQgZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgnUEFT UycpOyI+PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2Ny aXB0RWxlbWVudC9yZXNvdXJjZXMvZGVmZXIuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvZGVmZXIuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUx YzQ0Mjg3YzNiNmNmNGVmZDYxMjEwOGEzZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcwpAQCAtMCww ICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcyBiL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9leHRlcm5hbC5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5mYmFkNDY1MjM0MjA1NWNlYmIxOWQxNDQ1MmViZGUxZWE0NDc3ZWY4Ci0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5hbCIpOwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5v dGV4ZWN1dGUuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNv dXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5jMGQ2OTU0MDE2MmY5YWQ3Y2Fi MWYwMjA3NmRmODFiMTk3MTdiZDkwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanMKQEAg LTAsMCArMSBAQAorZGVidWcoIkZBSUwiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhhM2Q0Y2IKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9zaG91bGRub3RleGVj dXRlLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXIt d3JpdGVzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ZWYyMmU5YTQzMWFkMDI3MjcxM2I3MWZk Yzg3OTQwMTZjOGVmMTJmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy1leHBlY3RlZC50eHQKQEAgLTAsMCAr MSBAQAorUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVs ZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRlcy5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjRiMGQzNzg3MzA1 ZDgyNGJhODc2ZTJiNjE0ZTM2YzFjNmYwNDViN2MKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwKQEAg LTAsMCArMSw3IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwK KzxzY3JpcHQgZGVmZXIgc3JjPSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgn UEFTUycpOyI+PC9zY3JpcHQ+Cis8c2NyaXB0IGRlZmVyIHNyYz0iZGF0YTp0ZXh0L2phdmFzY3Jp cHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsiPjwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQuanMgYi9MYXlvdXRU ZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9kZWZlci1zY3JpcHQu anMKQEAgLTAsMCArMSBAQAorZGVidWcoImRlZmVyIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qcyBiL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0NzdlZjgKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNj cmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZXh0ZXJuYWwiKTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LWRlYnVnLWJvZHktYmFj a2dyb3VuZC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0 LWRlYnVnLWJvZHktYmFja2dyb3VuZC5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZmJlN2ExYzQyNDhkYWMzODI1 NTM1YTc0ZGNmNTQzNGM0ZjZiOTQyCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCkBA IC0wLDAgKzEgQEAKK3Nob3VsZEJlRXF1YWxUb1N0cmluZygiZ2V0Q29tcHV0ZWRTdHlsZShkb2N1 bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvciddIiwgInJnYigyNTUsIDAsIDApIik7CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC13cml0 ZS1zbG93LXN0eWxlc2hlZXQuanMgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3Vy Y2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZWQxMWViNTJj NmVmN2ZlZWYxNTFkMmQ0Nzk5ZTNkYzJhZWIyNzZmMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVz aGVldC5qcwpAQCAtMCwwICsxIEBACitkb2N1bWVudC53cml0ZSgnPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSJodHRwOi8vMTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvc2xvdy1zdHls ZXNoZWV0LmNnaSI+Jyk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mv cmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMv bWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE5OGQzZDVh ODFkMzc4ODc2OTJjNzM5MjJjOGQzYzI5ZjFiNmJkMTgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2NyaXB0LmNnaQpA QCAtMCwwICsxLDUgQEAKKyMhL3Vzci9iaW4vcGVybCAtdworCitwcmludCAiQ29udGVudC10eXBl OiB0ZXh0L2phdmFzY3JpcHRcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiZGVidWcoJ3Nsb3dE ZWZlcicpO1xuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNv dXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaSBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2xvdy1zdHlsZXNoZWV0LmNnaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mY2RkY2E0MDFmOGFiM2E2 YTVkZjg3M2E2NTQxYzdmNDBhYjA5ZWNlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCkBAIC0wLDAgKzEs NSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisKK3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvY3Nz XG5cbiI7CitzbGVlcCgwLjUpOworcHJpbnQgImJvZHkgeyBiYWNrZ3JvdW5kLWNvbG9yOiAjRkYw MDAwIH1cbiI7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0 LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9o dHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ctc3R5bGVzaGVldC1leHBlY3Rl ZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNDkwYWYwOGQyZGY2MDBjYmJiOTJjNTFjYzgyZTQxNDQyNTY2YzRk MgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDkgQEAK K1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1dGVzIGJlZm9y ZSBkZWZlcnJlZCBzY3JpcHRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKK1BBU1Mg Z2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFja2dyb3VuZC1jb2xvciddIGlzICJy Z2IoMjU1LCAwLCAwKSIKK0RPTUNvbnRlbnRMb2FkZWQKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2Vk IGlzIHRydWUKKworVEVTVCBDT01QTEVURQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90 ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbCBiL0xheW91 dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0 Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMDZlYzg0OWMzODlkNDM5YmI3OTQ4MGVmYjNmMzM3N2MzNTQzYzE5 OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQt ZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0Lmh0bWwKQEAgLTAsMCArMSwzMiBAQAorPCFET0NU WVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4K KzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFy c2V0PXV0Zi04IiAvPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy10ZXN0 LXJlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMtdGVz dC1yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8 ZHZpIGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUaGlzIHRlc3RzIHRo YXQgYW4gaW5saW5lIHNsb3cgc3R5bGVzaGVldCBleGVjdXRlcyBiZWZvcmUgZGVmZXJyZWQgc2Ny aXB0cy4nKTsKKwordmFyIGpzVGVzdElzQXN5bmMgPSB0cnVlOworCitkb2N1bWVudC5hZGRFdmVu dExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIiwgZnVuY3Rpb24oKSB7CisgIGRlYnVnKCdET01D b250ZW50TG9hZGVkJyk7CisKKyAgZmluaXNoSlNUZXN0KCk7Cit9LCBmYWxzZSk7Cis8L3Njcmlw dD4KKworPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291cmNlcy9z Y3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLgoranMiIGRlZmVyPSJkZWZlciI+PC9zY3JpcHQ+ Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNj L3Jlc291cmNlcy9zbG93LXN0eWxlc2hlCitldC5jZ2kiPgorPHNjcmlwdD4KK3ZhciBzdWNjZXNz ZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMtdGVz dC1yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBl Y3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZWY0NTE4NzMzMzZiY2NlODBjMWVhODBhOWY4Y2Y3NDMxOTdh NWJiYwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3Jp cHQtZGVmZXItZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAorVGhpcyB0ZXN0cyBmb3IgcHJv cGVyIGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAuCitleHRlcm5hbAor aW5saW5lCitzbG93RGVmZXIKK2RlZmVyCitET01Db250ZW50TG9hZGVkCitsb2FkCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwgYi9MYXlv dXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVj ZjhiMzUwNzVmYTE4YmQ2MjNiY2Q2Y2FkNmFlNjdkZTVkM2MzMwotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXIuaHRtbApAQCAtMCwwICsx LDI0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8 aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0 ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9 Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3Jj PSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hl YWQ+Cis8Ym9keSBvbmxvYWQ9ImRlYnVnKCdsb2FkJykiPgorVGhpcyB0ZXN0cyBmb3IgcHJvcGVy IGV4ZWN1dGlvbiBvcmRlciBvZiBzY3JpcHRzIHdpdGggdGhlIGRlZmVyIGF0dHJpYnV0ZSA8YSBo cmVmPSJodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA3MTAiPmh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDcxMDwvYT4uCis8ZGl2IGlkPSJj b25zb2xlIj48L2Rpdj4KKworPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZG9jdW1l bnQuYWRkRXZlbnRMaXN0ZW5lcigiRE9NQ29udGVudExvYWRlZCIsIGZ1bmN0aW9uKCkgeworICBk ZWJ1ZygnRE9NQ29udGVudExvYWRlZCcpOworfSwgZmFsc2UpOworPC9zY3JpcHQ+Cis8c2NyaXB0 IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctZGVmZXItc2Ny aXB0LmNnaSIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8vMTI3 LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzIiBkZWZlcj0iREVGRVIi Pjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNjL3Jlc291 cmNlcy9leHRlcm5hbC1zY3JpcHQuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2RlYnVnKCJpbmxp bmUiKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9D aGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhMmUyYWMwY2JmM2Y3ZDBiODA1NjZm MzQ0MjJiNzFjZWIxZjYwNmJlLi42ZjdhNTI1YzlkMTcyZTUzMWZjZmI2NGFmMzFlODk0N2U1ODcy ZjQ1IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDcyIEBACisyMDEwLTA4LTMxICBUb255IEdlbnRpbGNvcmUgIDx0b255Z0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAg ICBTdXBwb3J0IDxzY3JpcHQgZGVmZXI+IGFzIHNwZWNpZmllZCBieSBIVE1MNQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDA5MzQKKworICAgICAgICBU ZXN0czogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRl Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRv dWJsZS13cml0ZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxT Y3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCisgICAgICAgICAgICAgICBmYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbAorICAg ICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbAor ICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvdHdvLWRlZmVyLXdyaXRl cy5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVy LXNsb3ctc3R5bGVzaGVldC5odG1sCisgICAgICAgICAgICAgICBodHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLmh0bWwKKworICAgICAgICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpEb2N1bWVudDo6b3Blbik6IEFsbG93IGltcGxpY2l0IG9wZW4gZm9yIHdyaXRlcygp IHdoaWxlIGV4ZWN1dGluZyBkZWZlcnJlZCBzY3JpcHRzLgorICAgICAgICAqIGRvbS9Eb2N1bWVu dFBhcnNlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6RG9jdW1lbnRQ YXJzZXIpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6OnN0YXJ0UGFyc2luZyk6 CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6cHJlcGFyZVRvU3RvcFBhcnNpbmcp OiBJZiBjYWxsZWQgd2hlbiBzdG9wcGVkIG9yIGRldGFjaGVkLCBpdCBzaG91bGRuJ3QgcmVzZXQg dG8gc3RvcHBpbmcuCisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6c3RvcFBhcnNp bmcpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6OmRldGFjaCk6CisgICAgICAg ICogZG9tL0RvY3VtZW50UGFyc2VyLmg6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNl cjo6aXNQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50UGFyc2VyOjppc0FjdGl2 ZSk6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNTdG9wcGluZyk6CisgICAg ICAgIChXZWJDb3JlOjpEb2N1bWVudFBhcnNlcjo6aXNEZXRhY2hlZCk6CisgICAgICAgICogZG9t L1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oOgorICAgICAgICAoV2ViQ29yZTo6UmF3RGF0YURvY3Vt ZW50UGFyc2VyOjpmaW5pc2gpOgorICAgICAgICAqIGRvbS9YTUxEb2N1bWVudFBhcnNlci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKToKKyAgICAgICAg KFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpleGl0VGV4dCk6CisgICAgICAgICogZG9tL1hN TERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVu dFBhcnNlcjo6ZG9Xcml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6 c3RhcnRFbGVtZW50TnMpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmVu ZEVsZW1lbnROcyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y2hhcmFj dGVycyk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6ZXJyb3IpOgorICAg ICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJbnN0cnVjdGlvbik6 CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y2RhdGFCbG9jayk6CisgICAg ICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6Y29tbWVudCk6CisgICAgICAgIChXZWJD b3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6aW50ZXJuYWxTdWJzZXQpOgorICAgICAgICAoV2ViQ29y ZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KToKKyAgICAgICAg KFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjpkb0VuZCk6CisgICAgICAgICogaHRtbC9wYXJz ZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVu dFBhcnNlcjo6cHJlcGFyZVRvU3RvcFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERv Y3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVySWZQb3NzaWJsZSk6CisgICAgICAgIChXZWJDb3Jl OjpIVE1MRG9jdW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXIpOgorICAgICAgICAoV2ViQ29yZTo6 SFRNTERvY3VtZW50UGFyc2VyOjppbnNlcnQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3Vt ZW50UGFyc2VyOjphcHBlbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2Vy OjplbmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjphdHRlbXB0VG9F bmQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjplbmRJZkRlbGF5ZWQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZCk6 CisgICAgICAgICogaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmg6CisgICAgICAgICog aHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcik6CisgICAgICAgIChXZWJDb3JlOjpIVE1M U2NyaXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hF dmVudCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRlU2NyaXB0 c1dhaXRpbmdGb3JQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxTY3JpcHRSdW5uZXI6 OnJlcXVlc3REZWZlcnJlZFNjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVu bmVyOjpydW5TY3JpcHQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIu aDoKKyAgICAgICAgKiBsb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpJbWFnZURvY3VtZW50UGFyc2VyOjpmaW5pc2gpOgorCiAyMDEwLTA4LTMxICBEYXZlIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAKaW5kZXggOGEzNWFiY2ZkMjNlYjkxOTU3NTNjOWZmYmExZWZjZjIxNDYwOTkxMC4uNTc4 M2I4ZDI5NWYyMDJjZGQyOTM4M2Y2YTJhZDI3MzkwOGIzNWUwMyAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCisrKyBiL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMTgy NCw3ICsxODI0LDcgQEAgdm9pZCBEb2N1bWVudDo6b3BlbihEb2N1bWVudCogb3duZXJEb2N1bWVu dCkKIAogICAgIGlmIChtX2ZyYW1lKSB7CiAgICAgICAgIFNjcmlwdGFibGVEb2N1bWVudFBhcnNl ciogcGFyc2VyID0gc2NyaXB0YWJsZURvY3VtZW50UGFyc2VyKCk7Ci0gICAgICAgIGlmIChtX2Zy YW1lLT5sb2FkZXIoKS0+aXNMb2FkaW5nTWFpblJlc291cmNlKCkgfHwgKHBhcnNlciAmJiBwYXJz ZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkpKQorICAgICAgICBpZiAobV9mcmFtZS0+bG9hZGVyKCkt PmlzTG9hZGluZ01haW5SZXNvdXJjZSgpIHx8IChwYXJzZXIgJiYgcGFyc2VyLT5pc1BhcnNpbmco KSAmJiBwYXJzZXItPmlzRXhlY3V0aW5nU2NyaXB0KCkpKQogICAgICAgICAgICAgcmV0dXJuOwog CiAgICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIoKS0+c3RhdGUoKSA9PSBGcmFtZVN0YXRlUHJv dmlzaW9uYWwpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5jcHAgYi9X ZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5jcHAKaW5kZXggY2M0YzYxYjAzNDk2NWJmMWNmMDEz Y2Q2NDA5OTIxOWQxYjExMmVmMS4uNjM5ODYwYTJjYWU0YTk5YTQzY2EwOWQ2NTRlYjY0NmY5ZWU0 NzAwYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIuY3BwCisrKyBiL1dl YkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmNwcApAQCAtMzEsNyArMzEsNyBAQAogbmFtZXNwYWNl IFdlYkNvcmUgewogCiBEb2N1bWVudFBhcnNlcjo6RG9jdW1lbnRQYXJzZXIoRG9jdW1lbnQqIGRv Y3VtZW50KQotICAgIDogbV9wYXJzZXJTdG9wcGVkKGZhbHNlKQorICAgIDogbV9zdGF0ZShQYXJz aW5nU3RhdGUpCiAgICAgLCBtX2RvY3VtZW50KGRvY3VtZW50KQogewogICAgIEFTU0VSVChkb2N1 bWVudCk7CkBAIC00NSw4ICs0NSwyNSBAQCBEb2N1bWVudFBhcnNlcjo6fkRvY3VtZW50UGFyc2Vy KCkKICAgICBBU1NFUlQoIW1fZG9jdW1lbnQpOwogfQogCit2b2lkIERvY3VtZW50UGFyc2VyOjpz dGFydFBhcnNpbmcoKQoreworICAgIG1fc3RhdGUgPSBQYXJzaW5nU3RhdGU7Cit9CisKK3ZvaWQg RG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCkKK3sKKyAgICBpZiAobV9zdGF0 ZSA9PSBQYXJzaW5nU3RhdGUpCisgICAgICAgIG1fc3RhdGUgPSBTdG9wcGluZ1N0YXRlOworfQor Cit2b2lkIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2luZygpCit7CisgICAgbV9zdGF0ZSA9IFN0 b3BwZWRTdGF0ZTsKK30KKwogdm9pZCBEb2N1bWVudFBhcnNlcjo6ZGV0YWNoKCkKIHsKKyAgICBt X3N0YXRlID0gRGV0YWNoZWRTdGF0ZTsKICAgICBtX2RvY3VtZW50ID0gMDsKIH0KIApkaWZmIC0t Z2l0IGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIuaCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50 UGFyc2VyLmgKaW5kZXggM2MyODg1NjI1ZWUxMzEwNDBjMWY3Yzk5OWRiZTUzMjc5MDZlMmRhYy4u N2NjOWU3Yjk2MDViNTI2MjY1YTkyNWUzZWZhOTA4YTg5ZWNiY2EzZCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9kb20vRG9jdW1lbnRQYXJzZXIuaAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNl ci5oCkBAIC01NywxMiArNTcsMjkgQEAgcHVibGljOgogCiAgICAgLy8gRklYTUU6IHByb2Nlc3Np bmdEYXRhKCkgaXMgb25seSB1c2VkIGJ5IERvY3VtZW50TG9hZGVyOjppc0xvYWRpbmdJbkFQSVNl bnNlCiAgICAgLy8gYW5kIGlzIHZlcnkgdW5jbGVhciBhcyB0byB3aGF0IGl0IGFjdHVhbGx5IG1l YW5zLiAgVGhlIExlZ2FjeUhUTUxEb2N1bWVudFBhcnNlcgotICAgIC8vIHVzZWQgdG8gaW1wbGVt ZW50cyBpdC4KKyAgICAvLyB1c2VkIHRvIGltcGxlbWVudCBpdC4KICAgICB2aXJ0dWFsIGJvb2wg cHJvY2Vzc2luZ0RhdGEoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCiAgICAgLy8gZG9jdW1l bnQoKSB3aWxsIHJldHVybiAwIGFmdGVyIGRldGFjaCgpIGlzIGNhbGxlZC4KICAgICBEb2N1bWVu dCogZG9jdW1lbnQoKSBjb25zdCB7IEFTU0VSVChtX2RvY3VtZW50KTsgcmV0dXJuIG1fZG9jdW1l bnQ7IH0KLSAgICBib29sIGlzRGV0YWNoZWQoKSBjb25zdCB7IHJldHVybiAhbV9kb2N1bWVudDsg fQorCisgICAgYm9vbCBpc1BhcnNpbmcoKSBjb25zdCB7IHJldHVybiBtX3N0YXRlID09IFBhcnNp bmdTdGF0ZTsgfQorICAgIGJvb2wgaXNTdG9wcGluZygpIGNvbnN0IHsgcmV0dXJuIG1fc3RhdGUg PT0gU3RvcHBpbmdTdGF0ZTsgfQorICAgIGJvb2wgaXNTdG9wcGVkKCkgY29uc3QgeyByZXR1cm4g bV9zdGF0ZSA+PSBTdG9wcGVkU3RhdGU7IH0KKyAgICBib29sIGlzRGV0YWNoZWQoKSBjb25zdCB7 IHJldHVybiBtX3N0YXRlID09IERldGFjaGVkU3RhdGU7IH0KKworICAgIC8vIEZJWE1FOiBJcyB0 aGlzIG5lY2Vzc2FyeT8gRG9lcyBYTUxEb2N1bWVudFBhcnNlckxpYnhtbDIgcmVhbGx5IG5lZWQg dG8gc2V0IHRoaXM/CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0UGFyc2luZygpOworCisgICAgLy8g cHJlcGFyZVRvU3RvcCgpIGlzIHVzZWQgd2hlbiB0aGUgRU9GIHRva2VuIGlzIGVuY291bnRlcmVk IGFuZCBwYXJzaW5nIGlzIHRvIGJlCisgICAgLy8gc3RvcHBlZCBub3JtYWxseS4KKyAgICB2aXJ0 dWFsIHZvaWQgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKKworICAgIC8vIHN0b3BQYXJzaW5nKCkg aXMgdXNlZCB3aGVuIGEgbG9hZCBpcyBjYW5jZWxlZC9zdG9wcGVkLgorICAgIC8vIHN0b3BQYXJz aW5nKCkgaXMgY3VycmVudGx5IGRpZmZlcmVudCBmcm9tIGRldGFjaCgpLCBidXQgc2hvdWxkbid0 IGJlLgorICAgIC8vIEl0IHNob3VsZCBOT1QgYmUgb2sgdG8gY2FsbCBhbnkgbWV0aG9kcyBvbiBE b2N1bWVudFBhcnNlciBhZnRlciBlaXRoZXIKKyAgICAvLyBkZXRhY2goKSBvciBzdG9wUGFyc2lu ZygpIGJ1dCByaWdodCBub3cgb25seSBkZXRhY2goKSB3aWxsIEFTU0VSVC4KKyAgICB2aXJ0dWFs IHZvaWQgc3RvcFBhcnNpbmcoKTsKIAogICAgIC8vIERvY3VtZW50IGlzIGV4cGVjdGVkIHRvIGRl dGFjaCB0aGUgcGFyc2VyIGJlZm9yZSByZWxlYXNpbmcgaXRzIHJlZi4KICAgICAvLyBBZnRlciBk ZXRhY2gsIG1fZG9jdW1lbnQgaXMgY2xlYXJlZC4gIFRoZSBwYXJzZXIgd2lsbCB1bndpbmQgaXRz CkBAIC03MSwyMiArODgsMTggQEAgcHVibGljOgogICAgIC8vIGRldGFjaCBpcyBjYWxsZWQuCiAg ICAgdmlydHVhbCB2b2lkIGRldGFjaCgpOwogCi0gICAgLy8gc3RvcFBhcnNpbmcoKSBpcyB1c2Vk IHdoZW4gYSBsb2FkIGlzIGNhbmNlbGVkL3N0b3BwZWQuCi0gICAgLy8gc3RvcFBhcnNpbmcoKSBp cyBjdXJyZW50bHkgZGlmZmVyZW50IGZyb20gZGV0YWNoKCksIGJ1dCBzaG91bGRuJ3QgYmUuCi0g ICAgLy8gSXQgc2hvdWxkIE5PVCBiZSBvayB0byBjYWxsIGFueSBtZXRob2RzIG9uIERvY3VtZW50 UGFyc2VyIGFmdGVyIGVpdGhlcgotICAgIC8vIGRldGFjaCgpIG9yIHN0b3BQYXJzaW5nKCkgYnV0 IHJpZ2h0IG5vdyBvbmx5IGRldGFjaCgpIHdpbGwgQVNTRVJULgotICAgIHZpcnR1YWwgdm9pZCBz dG9wUGFyc2luZygpIHsgbV9wYXJzZXJTdG9wcGVkID0gdHJ1ZTsgfQotCiBwcm90ZWN0ZWQ6CiAg ICAgRG9jdW1lbnRQYXJzZXIoRG9jdW1lbnQqKTsKIAotICAgIC8vIFRoZSBwYXJzZXIgaGFzIGJ1 ZmZlcnMsIHNvIHBhcnNpbmcgbWF5IGNvbnRpbnVlIGV2ZW4gYWZ0ZXIKLSAgICAvLyBpdCBzdG9w cyByZWNlaXZpbmcgZGF0YS4gV2UgdXNlIG1fcGFyc2VyU3RvcHBlZCB0byBzdG9wIHRoZSBwYXJz ZXIKLSAgICAvLyBldmVuIHdoZW4gaXQgaGFzIGJ1ZmZlcmVkIGRhdGEuCi0gICAgLy8gRklYTUU6 IG1fZG9jdW1lbnQgPSAwIGNvdWxkIGJlIGNoYW5nZWQgdG8gbWVhbiAicGFyc2VyIHN0b3BwZWQi LgotICAgIGJvb2wgbV9wYXJzZXJTdG9wcGVkOwotCiBwcml2YXRlOgorICAgIGVudW0gUGFyc2Vy U3RhdGUgeworICAgICAgICBQYXJzaW5nU3RhdGUsCisgICAgICAgIFN0b3BwaW5nU3RhdGUsCisg ICAgICAgIFN0b3BwZWRTdGF0ZSwKKyAgICAgICAgRGV0YWNoZWRTdGF0ZQorICAgIH07CisgICAg UGFyc2VyU3RhdGUgbV9zdGF0ZTsKKwogICAgIC8vIEV2ZXJ5IERvY3VtZW50UGFyc2VyIG5lZWRz IGEgcG9pbnRlciBiYWNrIHRvIHRoZSBkb2N1bWVudC4KICAgICAvLyBtX2RvY3VtZW50IHdpbGwg YmUgMCBhZnRlciB0aGUgcGFyc2VyIGlzIHN0b3BwZWQuCiAgICAgRG9jdW1lbnQqIG1fZG9jdW1l bnQ7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaCBiL1dl YkNvcmUvZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oCmluZGV4IDA5M2RkYWY2N2QxODBjNGRh MGFjNzE2NmNlNGZhYWZkNWMxODExYzEuLjljYTM2ZjRkYzc2Y2Q1MjNlMTJkZGFiNTc4ZDVkZTE3 OGMxNzM4OTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5o CisrKyBiL1dlYkNvcmUvZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oCkBAIC0zOSw3ICszOSw3 IEBAIHByb3RlY3RlZDoKIAogICAgIHZpcnR1YWwgdm9pZCBmaW5pc2goKQogICAgIHsKLSAgICAg ICAgaWYgKCFtX3BhcnNlclN0b3BwZWQgJiYgIWlzRGV0YWNoZWQoKSkKKyAgICAgICAgaWYgKCFp c1N0b3BwZWQoKSkKICAgICAgICAgICAgIGRvY3VtZW50KCktPmZpbmlzaGVkUGFyc2luZygpOwog ICAgIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIv V2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuY3BwCmluZGV4IDRiNzY0NzIyYWVlZjM2ZTI2 YTUxNWExM2U2YzM3MjNjMDZhY2Y4ZDcuLjVmYjhiNTQ0ODA0OTg4NzRiMzFkNGQ5OTdlYjlkM2Zh NWEyNDkzZmQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyLmNwcAor KysgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlci5jcHAKQEAgLTEzMiw3ICsxMzIsNyBA QCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjphcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBz KQogICAgIGlmIChtX3Nhd1hTTFRyYW5zZm9ybSB8fCAhbV9zYXdGaXJzdEVsZW1lbnQpCiAgICAg ICAgIG1fb3JpZ2luYWxTb3VyY2VGb3JUcmFuc2Zvcm0gKz0gcGFyc2VTdHJpbmc7CiAKLSAgICBp ZiAoaXNEZXRhY2hlZCgpIHx8IG1fcGFyc2VyU3RvcHBlZCB8fCBtX3Nhd1hTTFRyYW5zZm9ybSkK KyAgICBpZiAoaXNTdG9wcGVkKCkgfHwgbV9zYXdYU0xUcmFuc2Zvcm0pCiAgICAgICAgIHJldHVy bjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtMTkwLDcgKzE5MCw3IEBAIHN0YXRp YyBpbmxpbmUgU3RyaW5nIHRvU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0ciwgdW5zaWduZWQgbGVu KQogCiB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjpleGl0VGV4dCgpCiB7Ci0gICAgaWYgKG1fcGFy c2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAg IGlmICghbV9jdXJyZW50Tm9kZSB8fCAhbV9jdXJyZW50Tm9kZS0+aXNUZXh0Tm9kZSgpKQpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCBiL1dlYkNv cmUvZG9tL1hNTERvY3VtZW50UGFyc2VyTGlieG1sMi5jcHAKaW5kZXggZGI5NGM1MGI0NDc3MWZk NTFlYTQzZjg0MTZjODRhZWQyNzE1ZWU5Zi4uZDk5YWI0YjlhZWEzNWU0Y2EzYjc0ZTljMGY4YjYx NTI1NDk4NzRjNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4 bWwyLmNwcAorKysgYi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCkBA IC02NjAsNyArNjYwLDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZG9Xcml0ZShjb25zdCBT dHJpbmcmIHBhcnNlU3RyaW5nKQogCiAgICAgICAgIC8vIEphdmFTY3JpcHQgKHdoaWNoIG1heSBi ZSBydW4gdW5kZXIgdGhlIHhtbFBhcnNlQ2h1bmsgY2FsbHN0YWNrKSBtYXkKICAgICAgICAgLy8g Y2F1c2UgdGhlIHBhcnNlciB0byBiZSBzdG9wcGVkIG9yIGRldGFjaGVkLgotICAgICAgICBpZiAo aXNEZXRhY2hlZCgpIHx8IG1fcGFyc2VyU3RvcHBlZCkKKyAgICAgICAgaWYgKGlzU3RvcHBlZCgp KQogICAgICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtNzMzLDcgKzczMyw3IEBAIHN0YXRp YyBpbmxpbmUgdm9pZCBoYW5kbGVFbGVtZW50QXR0cmlidXRlcyhFbGVtZW50KiBuZXdFbGVtZW50 LCBjb25zdCB4bWxDaGFyKioKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnN0YXJ0RWxlbWVudE5z KGNvbnN0IHhtbENoYXIqIHhtbExvY2FsTmFtZSwgY29uc3QgeG1sQ2hhciogeG1sUHJlZml4LCBj b25zdCB4bWxDaGFyKiB4bWxVUkksIGludCBuYl9uYW1lc3BhY2VzLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IHhtbENoYXIqKiBsaWJ4bWxOYW1lc3BhY2VzLCBpbnQg bmJfYXR0cmlidXRlcywgaW50IG5iX2RlZmF1bHRlZCwgY29uc3QgeG1sQ2hhcioqIGxpYnhtbEF0 dHJpYnV0ZXMpCiB7Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVk KCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtODIy LDcgKzgyMiw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnN0YXJ0RWxlbWVudE5zKGNvbnN0 IHhtbENoYXIqIHhtbExvY2FsTmFtZSwgY29uc3QgeG1sQ2hhCiAKIHZvaWQgWE1MRG9jdW1lbnRQ YXJzZXI6OmVuZEVsZW1lbnROcygpCiB7Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBp ZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNl ZCkgewpAQCAtOTA2LDcgKzkwNiw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVuZEVsZW1l bnROcygpCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmNoYXJhY3RlcnMoY29uc3QgeG1sQ2hh ciogcywgaW50IGxlbikKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmIChpc1N0 b3BwZWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBA IC05MjEsNyArOTIxLDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6Y2hhcmFjdGVycyhjb25z dCB4bWxDaGFyKiBzLCBpbnQgbGVuKQogCiB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjplcnJvcihF cnJvclR5cGUgdHlwZSwgY29uc3QgY2hhciogbWVzc2FnZSwgdmFfbGlzdCBhcmdzKQogewotICAg IGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1 cm47CiAKICNpZiBDT01QSUxFUihNU1ZDKSB8fCBDT01QSUxFUihSVkNUKQpAQCAtOTQ1LDcgKzk0 NSw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVycm9yKEVycm9yVHlwZSB0eXBlLCBjb25z dCBjaGFyKiBtZXNzYWdlLCB2YV9saXN0IGFyZ3MpCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6 OnByb2Nlc3NpbmdJbnN0cnVjdGlvbihjb25zdCB4bWxDaGFyKiB0YXJnZXQsIGNvbnN0IHhtbENo YXIqIGRhdGEpCiB7Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVk KCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtOTc5 LDcgKzk3OSw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJbnN0cnVjdGlv bihjb25zdCB4bWxDaGFyKiB0YXJnZXQsIGNvbnN0IHhtbENoCiAKIHZvaWQgWE1MRG9jdW1lbnRQ YXJzZXI6OmNkYXRhQmxvY2soY29uc3QgeG1sQ2hhciogcywgaW50IGxlbikKIHsKLSAgICBpZiAo bV9wYXJzZXJTdG9wcGVkKQorICAgIGlmIChpc1N0b3BwZWQoKSkKICAgICAgICAgcmV0dXJuOwog CiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC05OTcsNyArOTk3LDcgQEAgdm9pZCBYTUxE b2N1bWVudFBhcnNlcjo6Y2RhdGFCbG9jayhjb25zdCB4bWxDaGFyKiBzLCBpbnQgbGVuKQogCiB2 b2lkIFhNTERvY3VtZW50UGFyc2VyOjpjb21tZW50KGNvbnN0IHhtbENoYXIqIHMpCiB7Ci0gICAg aWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgIHJldHVy bjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtMTAzNCw3ICsxMDM0LDcgQEAgdm9p ZCBYTUxEb2N1bWVudFBhcnNlcjo6ZW5kRG9jdW1lbnQoKQogCiB2b2lkIFhNTERvY3VtZW50UGFy c2VyOjppbnRlcm5hbFN1YnNldChjb25zdCB4bWxDaGFyKiBuYW1lLCBjb25zdCB4bWxDaGFyKiBl eHRlcm5hbElELCBjb25zdCB4bWxDaGFyKiBzeXN0ZW1JRCkKIHsKLSAgICBpZiAobV9wYXJzZXJT dG9wcGVkKQorICAgIGlmIChpc1N0b3BwZWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYg KG1fcGFyc2VyUGF1c2VkKSB7CkBAIC0xMjk0LDcgKzEyOTQsNyBAQCB2b2lkIFhNTERvY3VtZW50 UGFyc2VyOjppbml0aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBjaGFyKiBjaHVuaykKICAgICBz YXguaWdub3JhYmxlV2hpdGVzcGFjZSA9IGlnbm9yYWJsZVdoaXRlc3BhY2VIYW5kbGVyOwogICAg IHNheC5lbnRpdHlEZWNsID0geG1sU0FYMkVudGl0eURlY2w7CiAgICAgc2F4LmluaXRpYWxpemVk ID0gWE1MX1NBWDJfTUFHSUM7Ci0gICAgbV9wYXJzZXJTdG9wcGVkID0gZmFsc2U7CisgICAgRG9j dW1lbnRQYXJzZXI6OnN0YXJ0UGFyc2luZygpOwogICAgIG1fc2F3RXJyb3IgPSBmYWxzZTsKICAg ICBtX3Nhd1hTTFRyYW5zZm9ybSA9IGZhbHNlOwogICAgIG1fc2F3Rmlyc3RFbGVtZW50ID0gZmFs c2U7CkBAIC0xMzE4LDExICsxMzE4LDExIEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmRvRW5k KCkKICAgICAgICAgZG9jdW1lbnQoKS0+c2V0UGFyc2luZyhmYWxzZSk7IC8vIE1ha2UgdGhlIGRv YyB0aGluayBpdCdzIGRvbmUsIHNvIGl0IHdpbGwgYXBwbHkgeHNsIHNoZWV0cy4KICAgICAgICAg ZG9jdW1lbnQoKS0+c3R5bGVTZWxlY3RvckNoYW5nZWQoUmVjYWxjU3R5bGVJbW1lZGlhdGVseSk7 CiAgICAgICAgIGRvY3VtZW50KCktPnNldFBhcnNpbmcodHJ1ZSk7Ci0gICAgICAgIG1fcGFyc2Vy U3RvcHBlZCA9IHRydWU7CisgICAgICAgIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2luZygpOwog ICAgIH0KICNlbmRpZgogCi0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9w cGVkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChtX2NvbnRleHQpIHsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyUXQuY3BwIGIvV2ViQ29yZS9kb20vWE1M RG9jdW1lbnRQYXJzZXJRdC5jcHAKaW5kZXggZGZkNmZiMTkyYjhkY2I1YmY3MDI4ZDRlN2Q2NjJl NzhmY2UzNzRiYi4uNTliYjk0YzU5MjYwYmI0MDQxMWZiODUwOGY1YzM4OTNjYWRiYTBjMCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJRdC5jcHAKKysrIGIvV2ViQ29y ZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJRdC5jcHAKQEAgLTE5OSw3ICsxOTksNyBAQCB2b2lkIFhN TERvY3VtZW50UGFyc2VyOjpkb1dyaXRlKGNvbnN0IFN0cmluZyYgcGFyc2VTdHJpbmcpCiAKIHZv aWQgWE1MRG9jdW1lbnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIq KQogewotICAgIG1fcGFyc2VyU3RvcHBlZCA9IGZhbHNlOworICAgIERvY3VtZW50UGFyc2VyOjpz dG9wUGFyc2luZygpOwogICAgIG1fc2F3RXJyb3IgPSBmYWxzZTsKICAgICBtX3Nhd1hTTFRyYW5z Zm9ybSA9IGZhbHNlOwogICAgIG1fc2F3Rmlyc3RFbGVtZW50ID0gZmFsc2U7CkBAIC0yMTMsNyAr MjEzLDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZG9FbmQoKQogICAgICAgICBkb2N1bWVu dCgpLT5zZXRQYXJzaW5nKGZhbHNlKTsgLy8gTWFrZSB0aGUgZG9jIHRoaW5rIGl0J3MgZG9uZSwg c28gaXQgd2lsbCBhcHBseSB4c2wgc2hlZXRzLgogICAgICAgICBkb2N1bWVudCgpLT5zdHlsZVNl bGVjdG9yQ2hhbmdlZChSZWNhbGNTdHlsZUltbWVkaWF0ZWx5KTsKICAgICAgICAgZG9jdW1lbnQo KS0+c2V0UGFyc2luZyh0cnVlKTsKLSAgICAgICAgbV9wYXJzZXJTdG9wcGVkID0gdHJ1ZTsKKyAg ICAgICAgRG9jdW1lbnRQYXJzZXI6OnN0YXJ0UGFyc2luZygpOwogICAgIH0KICNlbmRpZgogCkBA IC0zNTAsNyArMzUwLDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGhhbmRsZUVsZW1lbnRBdHRyaWJ1 dGVzKEVsZW1lbnQqIG5ld0VsZW1lbnQsIGNvbnN0IFFYbWxTdHJlYW0KIAogdm9pZCBYTUxEb2N1 bWVudFBhcnNlcjo6cGFyc2UoKQogewotICAgIHdoaWxlICghbV9wYXJzZXJTdG9wcGVkICYmICFt X3BhcnNlclBhdXNlZCAmJiAhbV9zdHJlYW0uYXRFbmQoKSkgeworICAgIHdoaWxlICghaXNTdG9w cGVkKCkgJiYgIW1fcGFyc2VyUGF1c2VkICYmICFtX3N0cmVhbS5hdEVuZCgpKSB7CiAgICAgICAg IG1fc3RyZWFtLnJlYWROZXh0KCk7CiAgICAgICAgIHN3aXRjaCAobV9zdHJlYW0udG9rZW5UeXBl KCkpIHsKICAgICAgICAgY2FzZSBRWG1sU3RyZWFtUmVhZGVyOjpTdGFydERvY3VtZW50OiB7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAgYi9X ZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggMjA3YmQzZTYz MjAwYjQ2MTI2Y2QyODA2NGY2MmNiNjYxNDI3YmRiMi4uOTc1ZmNiODdhZDBhMTYyZTIwNTc5YzZh ZWZlMDNjNmFkYmI5YTk1MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9j dW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFy c2VyLmNwcApAQCAtMTQyLDYgKzE0MiwyOCBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6c3Rv cFBhcnNpbmcoKQogICAgIG1fcGFyc2VyU2NoZWR1bGVyLmNsZWFyKCk7IC8vIERlbGV0aW5nIHRo ZSBzY2hlZHVsZXIgd2lsbCBjbGVhciBhbnkgdGltZXJzLgogfQogCisvLyBUaGlzIGtpY2tzIG9m ZiAiT25jZSB0aGUgdXNlciBhZ2VudCBzdG9wcyBwYXJzaW5nIiBhcyBkZXNjcmliZWQgYnk6Cisv LyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrL211bHRp cGFnZS90aGUtZW5kLmh0bWwjdGhlLWVuZAordm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnByZXBh cmVUb1N0b3BQYXJzaW5nKCkKK3sKKyAgICBBU1NFUlQoIWhhc0luc2VydGlvblBvaW50KCkpOwor CisgICAgLy8gcHVtcFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNo ZWQgZnJvbSB0aGUgRG9jdW1lbnQsCisgICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0IGlz bid0IGRlbGV0ZWQgeWV0LgorICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3RlY3Qo dGhpcyk7CisKKyAgICAvLyBGSVhNRTogU2V0IHRoZSBjdXJyZW50IGRvY3VtZW50IHJlYWRpbmVz cyB0byAiaW50ZXJhY3RpdmUiLgorCisgICAgLy8gTk9URTogVGhpcyBwdW1wIHNob3VsZCBvbmx5 IGV2ZXIgZW1pdCBidWZmZXJlZCBjaGFyYWN0ZXIgdG9rZW5zLAorICAgIC8vIHNvIEZvcmNlU3lu Y2hyb25vdXMgdnMuIEFsbG93WWllbGQgc2hvdWxkIGJlIG1lYW5pbmdsZXNzLgorICAgIHB1bXBU b2tlbml6ZXJJZlBvc3NpYmxlKEZvcmNlU3luY2hyb25vdXMpOworCisgICAgRG9jdW1lbnRQYXJz ZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCk7CisgICAgaWYgKG1fc2NyaXB0UnVubmVyICYmICFt X3NjcmlwdFJ1bm5lci0+ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpKQorICAgICAg ICByZXR1cm47CisgICAgZW5kKCk7Cit9CisKIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpwcm9j ZXNzaW5nRGF0YSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGlzU2NoZWR1bGVkRm9yUmVzdW1lKCkg fHwgaW5Xcml0ZSgpOwpAQCAtMTQ5LDcgKzE3MSw3IEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2Vy Ojpwcm9jZXNzaW5nRGF0YSgpIGNvbnN0CiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1w VG9rZW5pemVySWZQb3NzaWJsZShTeW5jaHJvbm91c01vZGUgbW9kZSkKIHsKLSAgICBpZiAobV9w YXJzZXJTdG9wcGVkIHx8IG1fdHJlZUJ1aWxkZXItPmlzUGF1c2VkKCkpCisgICAgaWYgKGlzU3Rv cHBlZCgpIHx8IG1fdHJlZUJ1aWxkZXItPmlzUGF1c2VkKCkpCiAgICAgICAgIHJldHVybjsKIAog ICAgIC8vIE9uY2UgYSByZXN1bWUgaXMgc2NoZWR1bGVkLCBIVE1MUGFyc2VyU2NoZWR1bGVyIGNv bnRyb2xzIHdoZW4gd2UgbmV4dCBwdW1wLgpAQCAtMTkzLDggKzIxNSw3IEBAIGJvb2wgSFRNTERv Y3VtZW50UGFyc2VyOjpydW5TY3JpcHRzRm9yUGF1c2VkVHJlZUJ1aWxkZXIoKQogCiB2b2lkIEhU TUxEb2N1bWVudFBhcnNlcjo6cHVtcFRva2VuaXplcihTeW5jaHJvbm91c01vZGUgbW9kZSkKIHsK LSAgICBBU1NFUlQoIWlzRGV0YWNoZWQoKSk7Ci0gICAgQVNTRVJUKCFtX3BhcnNlclN0b3BwZWQp OworICAgIEFTU0VSVCghaXNTdG9wcGVkKCkpOwogICAgIEFTU0VSVCghbV90cmVlQnVpbGRlci0+ aXNQYXVzZWQoKSk7CiAgICAgQVNTRVJUKCFpc1NjaGVkdWxlZEZvclJlc3VtZSgpKTsKICAgICAv LyBBU1NFUlQgdGhhdCB0aGlzIG9iamVjdCBpcyBib3RoIGF0dGFjaGVkIHRvIHRoZSBEb2N1bWVu dCBhbmQgcHJvdGVjdGVkLgpAQCAtMjE0LDcgKzIzNSw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFy c2VyOjpwdW1wVG9rZW5pemVyKFN5bmNocm9ub3VzTW9kZSBtb2RlKQogICAgICAgICBtX3Rva2Vu LmNsZWFyKCk7CiAKICAgICAgICAgLy8gSmF2YVNjcmlwdCBtYXkgaGF2ZSBzdG9wcGVkIG9yIGRl dGFjaGVkIHRoZSBwYXJzZXIuCi0gICAgICAgIGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJT dG9wcGVkKQorICAgICAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgICAgICByZXR1cm47CiAK ICAgICAgICAgLy8gVGhlIHBhcnNlciB3aWxsIHBhdXNlIGl0c2VsZiB3aGVuIHdhaXRpbmcgb24g YSBzY3JpcHQgdG8gbG9hZCBvciBydW4uCkBAIC0yMjYsNyArMjQ3LDcgQEAgdm9pZCBIVE1MRG9j dW1lbnRQYXJzZXI6OnB1bXBUb2tlbml6ZXIoU3luY2hyb25vdXNNb2RlIG1vZGUpCiAgICAgICAg IG1fdHJlZUJ1aWxkZXItPnNldFBhdXNlZCghc2hvdWxkQ29udGludWVQYXJzaW5nKTsKIAogICAg ICAgICAvLyBKYXZhU2NyaXB0IG1heSBoYXZlIHN0b3BwZWQgb3IgZGV0YWNoZWQgdGhlIHBhcnNl ci4KLSAgICAgICAgaWYgKGlzRGV0YWNoZWQoKSB8fCBtX3BhcnNlclN0b3BwZWQpCisgICAgICAg IGlmIChpc1N0b3BwZWQoKSkKICAgICAgICAgICAgIHJldHVybjsKIAogICAgICAgICBpZiAoIXNo b3VsZENvbnRpbnVlUGFyc2luZykKQEAgLTI3NSw3ICsyOTYsNyBAQCBib29sIEhUTUxEb2N1bWVu dFBhcnNlcjo6aGFzSW5zZXJ0aW9uUG9pbnQoKQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6 aW5zZXJ0KGNvbnN0IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogewotICAgIGlmIChtX3BhcnNl clN0b3BwZWQpCisgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICAv LyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9t IHRoZSBEb2N1bWVudCwKQEAgLTI5Niw3ICszMTcsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNl cjo6aW5zZXJ0KGNvbnN0IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogCiB2b2lkIEhUTUxEb2N1 bWVudFBhcnNlcjo6YXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogewotICAg IGlmIChtX3BhcnNlclN0b3BwZWQpCisgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1 cm47CiAKICAgICAvLyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBk ZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKQEAgLTMyOCwxNCArMzQ5LDYgQEAgdm9pZCBIVE1M RG9jdW1lbnRQYXJzZXI6OmVuZCgpCiAgICAgQVNTRVJUKCFpc0RldGFjaGVkKCkpOwogICAgIEFT U0VSVCghaXNTY2hlZHVsZWRGb3JSZXN1bWUoKSk7CiAKLSAgICAvLyBwdW1wVG9rZW5pemVyIGNh biBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKLSAg ICAvLyBidXQgd2UgbmVlZCB0byBlbnN1cmUgaXQgaXNuJ3QgZGVsZXRlZCB5ZXQuCi0gICAgUmVm UHRyPEhUTUxEb2N1bWVudFBhcnNlcj4gcHJvdGVjdCh0aGlzKTsKLQotICAgIC8vIE5PVEU6IFRo aXMgcHVtcCBzaG91bGQgb25seSBldmVyIGVtaXQgYnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywK LSAgICAvLyBzbyBGb3JjZVN5bmNocm9ub3VzIHZzLiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFu aW5nbGVzcy4KLSAgICBwdW1wVG9rZW5pemVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsK LQogICAgIC8vIEluZm9ybXMgdGhlIHRoZSByZXN0IG9mIFdlYkNvcmUgdGhhdCBwYXJzaW5nIGlz IHJlYWxseSBmaW5pc2hlZCAoYW5kIGRlbGV0ZXMgdGhpcykuCiAgICAgbV90cmVlQnVpbGRlci0+ ZmluaXNoZWQoKTsKIH0KQEAgLTM0OSw3ICszNjIsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNl cjo6YXR0ZW1wdFRvRW5kKCkKICAgICAgICAgbV9lbmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAg ICAgcmV0dXJuOwogICAgIH0KLSAgICBlbmQoKTsKKyAgICBwcmVwYXJlVG9TdG9wUGFyc2luZygp OwogfQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKQEAgLTM2Miw3 ICszNzUsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKICAgICAg ICAgcmV0dXJuOwogCiAgICAgbV9lbmRXYXNEZWxheWVkID0gZmFsc2U7Ci0gICAgZW5kKCk7Cisg ICAgcHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKIH0KIAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6 OmZpbmlzaCgpCkBAIC00NDcsNiArNDYwLDExIEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpz aG91bGRMb2FkRXh0ZXJuYWxTY3JpcHRGcm9tU3JjKGNvbnN0IEF0b21pY1N0cmluZyYgc3JjCiAK IHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZChDYWNoZWRSZXNvdXJjZSog Y2FjaGVkUmVzb3VyY2UpCiB7CisgICAgaWYgKGlzU3RvcHBpbmcoKSkgeworICAgICAgICBwcmVw YXJlVG9TdG9wUGFyc2luZygpOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgLy8gcHVt cFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUg RG9jdW1lbnQsCiAgICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0IGlzbid0IGRlbGV0ZWQg eWV0LgogICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3RlY3QodGhpcyk7CmRpZmYg LS1naXQgYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5oIGIvV2ViQ29y ZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCBkYTIxYTJiYTExNGUyMDAy YmRlMjRmY2FmMzllZDA5ZGJiNTE5ZGMxLi5hMzJiNDM5NmQzOWNkMDA2NWJhZmQ2NDJlZDYyNTQy ZDgwZWZlOWJjIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBh cnNlci5oCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmgKQEAg LTgxLDYgKzgxLDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgYXBwZW5kKGNvbnN0IFNl Z21lbnRlZFN0cmluZyYpOwogICAgIHZpcnR1YWwgYm9vbCBmaW5pc2hXYXNDYWxsZWQoKTsKICAg ICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0RhdGEoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQg cHJlcGFyZVRvU3RvcFBhcnNpbmcoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKTsK ICAgICB2aXJ0dWFsIGJvb2wgaXNXYWl0aW5nRm9yU2NyaXB0cygpIGNvbnN0OwogICAgIHZpcnR1 YWwgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9o dG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRN TFNjcmlwdFJ1bm5lci5jcHAKaW5kZXggNmQ0NzBhMGE1ZTA4YjQwZjY4YTE4MzVhZjUxODg5MmI4 Y2E1YmIxOS4uNzY0YmYwMWE4ZDcxYzcxNjdhY2ZhZTJkMjE4ZmM2MGM4ZDJmMmE3NyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJD b3JlL2h0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwCkBAIC03NSw2ICs3NSwxMiBAQCBI VE1MU2NyaXB0UnVubmVyOjp+SFRNTFNjcmlwdFJ1bm5lcigpCiAgICAgLy8gRklYTUU6IFNob3Vs ZCB3ZSBiZSBwYXNzZWQgYSAiZG9uZSBsb2FkaW5nL3BhcnNpbmciIGNhbGxiYWNrIHNvb25lciB0 aGFuIGRlc3RydWN0aW9uPwogICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRT Y3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKICAg ICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisKKyAg ICB3aGlsZSAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCkpIHsKKyAg ICAgICAgUGVuZGluZ1NjcmlwdCBwZW5kaW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0 ZXJQYXJzaW5nLnRha2VGaXJzdCgpOworICAgICAgICBpZiAocGVuZGluZ1NjcmlwdC5jYWNoZWRT Y3JpcHQoKSAmJiBwZW5kaW5nU2NyaXB0LndhdGNoaW5nRm9yTG9hZCgpKQorICAgICAgICAgICAg c3RvcFdhdGNoaW5nRm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKyAgICB9CiB9CiAKIHZvaWQgSFRN TFNjcmlwdFJ1bm5lcjo6ZGV0YWNoKCkKQEAgLTEyOSwxMCArMTM1LDYgQEAgdm9pZCBIVE1MU2Ny aXB0UnVubmVyOjpleGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkKICAgICBBU1NFUlQobV9k b2N1bWVudC0+aGF2ZVN0eWxlc2hlZXRzTG9hZGVkKCkpOwogICAgIEFTU0VSVChpc1BlbmRpbmdT Y3JpcHRSZWFkeShtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCkpOwogCi0gICAgLy8gU3RvcCB3YXRj aGluZyBsb2FkcyBiZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50IHJlY3Vyc2lvbiBpZiB0 aGUgc2NyaXB0IHJlbG9hZHMgaXRzZWxmLgotICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dC5jYWNoZWRTY3JpcHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0Zvckxv YWQoKSkKLSAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1Njcmlw dCk7Ci0KICAgICBJbnNlcnRpb25Qb2ludFJlY29yZCBpbnNlcnRpb25Qb2ludFJlY29yZChtX2hv c3QtPmlucHV0U3RyZWFtKCkpOwogICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hF dmVudChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CiB9CkBAIC0xNDIsNiArMTQ0LDEwIEBAIHZv aWQgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHRBbmREaXNwYXRjaEV2ZW50 KFBlbmRpbmdTY3JpcHQmIHBlbmRpCiAgICAgYm9vbCBlcnJvck9jY3VycmVkID0gZmFsc2U7CiAg ICAgU2NyaXB0U291cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNlRnJvbVBlbmRpbmdTY3JpcHQo cGVuZGluZ1NjcmlwdCwgZXJyb3JPY2N1cnJlZCk7CiAKKyAgICAvLyBTdG9wIHdhdGNoaW5nIGxv YWRzIGJlZm9yZSBleGVjdXRlU2NyaXB0IHRvIHByZXZlbnQgcmVjdXJzaW9uIGlmIHRoZSBzY3Jp cHQgcmVsb2FkcyBpdHNlbGYuCisgICAgaWYgKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkg JiYgcGVuZGluZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKKyAgICAgICAgc3RvcFdhdGNoaW5n Rm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKwogICAgIC8vIENsZWFyIHRoZSBwZW5kaW5nIHNjcmlw dCBiZWZvcmUgcG9zc2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgpCiAgICAgUmVm UHRyPEVsZW1lbnQ+IHNjcmlwdEVsZW1lbnQgPSBwZW5kaW5nU2NyaXB0LnJlbGVhc2VFbGVtZW50 QW5kQ2xlYXIoKTsKICAgICB7CkBAIC0yMzgsNiArMjQ0LDI0IEBAIGJvb2wgSFRNTFNjcmlwdFJ1 bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKQogICAgIHJldHVybiBl eGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0cygpOwogfQogCitib29sIEhUTUxTY3JpcHRSdW5u ZXI6OmV4ZWN1dGVTY3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQoreworICAgIHdoaWxlICghbV9z Y3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBBU1NFUlQo IW1fc2NyaXB0TmVzdGluZ0xldmVsKTsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2Nr aW5nU2NyaXB0KCkpOworICAgICAgICBBU1NFUlQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJz aW5nLmZpcnN0KCkuY2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fc2NyaXB0c1RvRXhl Y3V0ZUFmdGVyUGFyc2luZy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7Cisg ICAgICAgICAgICB3YXRjaEZvckxvYWQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZp cnN0KCkpOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAgICAgIFBl bmRpbmdTY3JpcHQgZmlyc3QgPSBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcudGFrZUZp cnN0KCk7CisgICAgICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChmaXJz dCk7CisgICAgICAgIGlmICghbV9kb2N1bWVudCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICB9CisgICAgcmV0dXJuIHRydWU7Cit9CisKIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVx dWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50KiBlbGVtZW50KQogewogICAgIGlmICgh cmVxdWVzdFBlbmRpbmdTY3JpcHQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVsZW1lbnQpKQpA QCAtMjUyLDYgKzI3NiwxNiBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5n QmxvY2tpbmdTY3JpcHQoRWxlbWVudCogZWxlbWVudCkKICAgICAgICAgd2F0Y2hGb3JMb2FkKG1f cGFyc2luZ0Jsb2NraW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVubmVyOjpyZXF1 ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0 IHBlbmRpbmdTY3JpcHQ7CisgICAgaWYgKCFyZXF1ZXN0UGVuZGluZ1NjcmlwdChwZW5kaW5nU2Ny aXB0LCBlbGVtZW50KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQVNTRVJUKHBlbmRpbmdTY3Jp cHQuY2FjaGVkU2NyaXB0KCkpOworICAgIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5h cHBlbmQocGVuZGluZ1NjcmlwdCk7Cit9CisKIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVz dFBlbmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYgcGVuZGluZ1NjcmlwdCwgRWxlbWVudCogc2Ny aXB0KSBjb25zdAogewogICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KCkpOwpAQCAt Mjg3LDggKzMyMSwxMSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50 KiBzY3JpcHQsIGludCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVk KCk7IC8vIGV2ZW50IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmli dXRlKHNyY0F0dHIpKSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBh c3luYwotICAgICAgICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOwor ICAgICAgICAgICAgLy8gRklYTUU6IEhhbmRsZSBhc3luYy4KKyAgICAgICAgICAgIGlmIChzY3Jp cHQtPmhhc0F0dHJpYnV0ZShkZWZlckF0dHIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3REZWZl cnJlZFNjcmlwdChzY3JpcHQpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJl cXVlc3RQYXJzaW5nQmxvY2tpbmdTY3JpcHQoc2NyaXB0KTsKICAgICAgICAgfSBlbHNlIHsKICAg ICAgICAgICAgIC8vIEZJWE1FOiBXZSBkbyBub3QgYmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mg b24gc3R5bGVzaGVldHMgdG8gbWF0Y2ggdGhlCiAgICAgICAgICAgICAvLyBvbGQgcGFyc2VyIGZv ciBub3cuICBXaGVuIHdlIGRvLCB0aGUgQVNTRVJUIGJlbG93IHNob3VsZCBiZSBhZGRlZC4KZGlm ZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5oIGIvV2ViQ29y ZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZWFkOTI4OTU0OWVjMTAyOGE2 YTY5N2IyMTRjZTRlYTRjNjEwMDc5ZS4uNDdjOTZmZGJkNDE2ZDAzMWY5NWM2YzhmNjBhOTU3ZGJi MTQzNWUzMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVy LmgKKysrIGIvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKQEAgLTI3LDYg KzI3LDcgQEAKICNkZWZpbmUgSFRNTFNjcmlwdFJ1bm5lcl9oCiAKICNpbmNsdWRlICJQZW5kaW5n U2NyaXB0LmgiCisjaW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlh YmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTYsNiArNTcsNyBAQCBw dWJsaWM6CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENhY2hlZFJlc291 cmNlKik7CiAgICAgYm9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCkgY29uc3Qg eyByZXR1cm4gbV9oYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9CiAgICAgYm9vbCBl eGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJvb2wgZXhlY3V0ZVNj cmlwdHNXYWl0aW5nRm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgp IGNvbnN0IHsgcmV0dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAtNzEsNiArNzMs NyBAQCBwcml2YXRlOgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsK IAogICAgIHZvaWQgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAg dm9pZCByZXF1ZXN0RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIGJvb2wgcmVxdWVzdFBl bmRpbmdTY3JpcHQoUGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKSBjb25zdDsKIAogICAgIHZvaWQg cnVuU2NyaXB0KEVsZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKQEAgLTg0LDYgKzg3 LDcgQEAgcHJpdmF0ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0 UnVubmVySG9zdCogbV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdT Y3JpcHQ7CisgICAgRGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQ YXJzaW5nOyAvLyBodHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13 b3JrLyNsaXN0LW9mLXNjcmlwdHMtdGhhdC13aWxsLWV4ZWN1dGUtd2hlbi10aGUtZG9jdW1lbnQt aGFzLWZpbmlzaGVkLXBhcnNpbmcKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsK IAogICAgIC8vIFdlIG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0 IGV4ZWN1dGlvbiBpZiBzY3JpcHQKZGlmZiAtLWdpdCBhL1dlYkNvcmUvbG9hZGVyL0ltYWdlRG9j dW1lbnQuY3BwIGIvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKaW5kZXggNzAyZWQ5 ZDcwZDY1ZWViMzVmMWFhMWViMjQ4NjIzMTI1MzY2Zjc2YS4uY2MzYzg1Y2IxN2QxNDMyODViODQz ZDExNzQ1YWJlZjAxNjA4YjIxOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1 bWVudC5jcHAKKysrIGIvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKQEAgLTEzOCw3 ICsxMzgsNyBAQCB2b2lkIEltYWdlRG9jdW1lbnRQYXJzZXI6OmFwcGVuZEJ5dGVzKERvY3VtZW50 V3JpdGVyKiwgY29uc3QgY2hhciosIGludCwgYm9vbCkKIAogdm9pZCBJbWFnZURvY3VtZW50UGFy c2VyOjpmaW5pc2goKQogewotICAgIGlmICghbV9wYXJzZXJTdG9wcGVkICYmIGRvY3VtZW50KCkt PmltYWdlRWxlbWVudCgpKSB7CisgICAgaWYgKCFpc1N0b3BwZWQoKSAmJiBkb2N1bWVudCgpLT5p bWFnZUVsZW1lbnQoKSkgewogICAgICAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UgPSBkb2N1 bWVudCgpLT5jYWNoZWRJbWFnZSgpOwogICAgICAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBkYXRh ID0gZG9jdW1lbnQoKS0+ZnJhbWUoKS0+bG9hZGVyKCktPmRvY3VtZW50TG9hZGVyKCktPm1haW5S ZXNvdXJjZURhdGEoKTsKIAo= 66281 2010-09-01 15:03:40 -0700 2010-09-02 02:06:27 -0700 Patch for landing bug-40934-20100901150339.patch text/plain 45719 tonyg ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBhZDdlMmEwMjM3ODQ4MDg1YmEwN2ZjYTI3ZjQxMzJmMzA0YWY3NzYwLi44MmEyYTFm YWI1MTU5ZGM4ZTZmMDA5MDkwMjVlNjQ3MGIxMWJjMWE2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzkgQEAK KzIwMTAtMDktMDEgIFRvbnkgR2VudGlsY29yZSAgPHRvbnlnQGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgorCisgICAgICAgIFN1cHBvcnQgPHNjcmlwdCBk ZWZlcj4gYXMgc3BlY2lmaWVkIGJ5IEhUTUw1CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD00MDkzNAorCisgICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdy aXRlLmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IGEgd3JpdGUgb2YgYSBkZWZlcnJlZCBzY3JpcHQg ZnJvbSBhIGRlZmVycmVkIHNjcmlwdCB3aWxsIGV4ZWN1dGUgd2hlbiB0aGUgZG9jdW1lbnQgaXMg Y2xvc2VkLiBUaGUgZXhwbGljaXQgY2xvc2UgaXMgbmVjZXNzYXJ5IGJlY2F1c2UgdGhpcyBpcyBh IHNjcmlwdCBjcmVhdGVkIHBhcnNlci4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbDogQWRkZWQu IFRlc3RzIHRoYXQgYSBzY3JpcHQgYmxvY2sgd3JpdHRlbiBmcm9tIGEgZGVmZXJyZWQgc2NyaXB0 IHdpbGwgd3JpdGUgaW50byB0aGUgbmV3IGRvY3VtZW50LgorICAgICAgICAqIGZhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0 Lmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IGlubGluZSBzY3JpcHRzIGFyZSBub3QgZGVmZXJyZWQu IFRoaXMgaXMgY29uc2lzdGVudCB3aXRoIEhUTUw1IGFuZCBpbmNvbnNpc3RlbnQgd2l0aCBJRS4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1vbmJlZm9yZWxvYWQuaHRtbDogQWRkZWQuIFRlc3RzIHRoYXQgdGhlIGJlZm9yZWxv YWQgZXZlbnQgaXMgZmlyZWQgaW1tZWRpYXRlbHkgYW5kIGlzIGNhbmNlbGxhYmxlLgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC5odG1sOiBBZGRlZC4gVGVzdHMgdGhhdCBkZWZlcnJl ZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBpZ25vcmVkIGFuZCB0aGF0IHN1YnNlcXVl bnQgZGVmZXJyZWQgc2NyaXB0cyB3aWxsIGJlIHJ1bi4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1M U2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLXdyaXRlLmh0bWw6IEFkZGVkLiBUZXN0 cyB0aGF0IGEgYmFzaWMgd3JpdGUgZnJvbSBhIGRlZmVycmVkIHNjcmlwdCBibG93cyBhd2F5IHRo ZSBkb2N1bWVudC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJj ZXMvZGVmZXIuanM6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L3Jlc291cmNlcy9leHRlcm5hbC5qczogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTFNj cmlwdEVsZW1lbnQvcmVzb3VyY2VzL3Nob3VsZG5vdGV4ZWN1dGUuanM6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanM6IEFkZGVk LgorICAgICAgICAqIGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC90d28tZGVmZXItd3JpdGVzLmh0bWw6IEFkZGVkLiBUZXN0cyB0aGF0IHdoZW4gYSBkb2N1bWVu dC53cml0ZSBmcm9tIHRoZSBmaXJzdCBkZWZlcnJlZCBzY3JpcHQgYmxvd3MgYXdheSB0aGUgZG9j dW1lbnQsIHN1YnNlcXVlbnQgZGVmZXJyZWQgc2NyaXB0cyBhcmUgbm90IGV4ZWN1dGVkLgorICAg ICAgICAqIGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXItc2NyaXB0LmpzOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2V4dGVybmFsLXNjcmlwdC5qczog QWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWct Ym9keS1iYWNrZ3JvdW5kLmpzOiBBZGRlZC4KKyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL3NjcmlwdC13cml0ZS1zbG93LXN0eWxlc2hlZXQuanM6IEFkZGVkLgorICAgICAgICAq IGh0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpOiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGVldC5jZ2k6 IEFkZGVkLgorICAgICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xv dy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogaHR0cC90ZXN0cy9t aXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbDogQWRkZWQuIFRlc3Rz IHRoYXQgZGVmZXJyZWQgc2NyaXB0cyByZXNwZWN0IGJsb2NraW5nIHN0eWxlc2hlZXRzLgorICAg ICAgICAqIGh0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBodHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLmh0bWw6IEFkZGVkLiBUZXN0 cyBiYXNpYyBvcmRlcmluZyBvZiBkZWZlcnJlZCBzY3JpcHRzLgorCiAyMDEwLTA5LTAxICBEYXZl IEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJu c3RlaW4gYW5kIFNpbW9uIEZyYXNlci4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS1leHBlY3RlZC50eHQg Yi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVm ZXItd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIyZTlhNDMxYWQwMjcyNzEzYjcx ZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtZGVmZXItd3JpdGUtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEgQEAKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sIGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLWRlZmVyLXdyaXRlLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMDQxMjA1MGIyZTQzYjY5NDkxYjU0MzQ3MzVmMmQ2ZmU1MTRlZjk5ZAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCkBAIC0wLDAgKzEsNiBAQAorPHNjcmlwdD4K K2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+CitGQUlMCis8c2NyaXB0IGRlZmVyIHNyYz0iZGF0 YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUoJ0ZBSUwnKTsgZG9jdW1lbnQud3JpdGUo JzxzY3JpcHQgZGVmZXIgc3JjPVwnZGF0YTp0ZXh0L2phdmFzY3JpcHQsZG9jdW1lbnQud3JpdGUo JnF1b3Q7UEFTUyZxdW90Oyk7XCc+PC9zY3JpcHQ+Jyk7IGRvY3VtZW50LmNsb3NlKCk7Ij48L3Nj cmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWRvdWJsZS13cml0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxl IG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjhkMDRmOTYxYTAzNzExN2MxZWFhNjlhYzYwZWIzNjNkMzdhZTc4ZDEKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3Vi bGUtd3JpdGUtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKKzEgMgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUt d3JpdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lNTVlMWQzZGIzZjk2M2M4Zjk3YTk3NjUyYTA0YTZjYTFm Y2RhYzkxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlw dEVsZW1lbnQvZGVmZXItZG91YmxlLXdyaXRlLmh0bWwKQEAgLTAsMCArMSw2IEBACis8c2NyaXB0 PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4KK0ZBSUwKKzxzY3JpcHQgZGVmZXIgc3JjPSJk YXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZWxuKDEpOyBkb2N1bWVudC53cml0ZSgn PHNjcmlwdCBzcmM9XCdkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZWxuKDIpXCc+ PC9zY3JpcHQ+Jyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9t L0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC1l eHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmVhYWFkODk3YWZiYzU2ZGYwMGM4ZjhjOTE2YTg1Yzkz ZTg1OTc2OAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L2RlZmVyLWlubGluZS1zY3JpcHQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNCBA QAorQ2hlY2tzIHRoYXQgaW5saW5lIHNjcmlwdHMgYXJlIG5vdCBkZWZlcnJlZC4KKzEKKzIKKwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXIt aW5saW5lLXNjcmlwdC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1l bnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmExNWMyMDExOWFjNDgwNDU2 MjA3NDQ4ZGYyODYzNTIzOGE5ZmU5NTcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1pbmxpbmUtc2NyaXB0Lmh0bWwKQEAgLTAs MCArMSwxNSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9EVEQgSFRNTC8vRU4i PgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iLi4vLi4vanMv cmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNv dXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CitDaGVja3Mg dGhhdCBpbmxpbmUgc2NyaXB0cyBhcmUgbm90IGRlZmVycmVkLgorPGRpdiBpZD0iY29uc29sZSI+ PC9kaXY+Cis8c2NyaXB0IHNyYz0iZGF0YTp0ZXh0L2phdmFzY3JpcHQsZGVidWcoMik7IiBkZWZl cj48L3NjcmlwdD4KKzxzY3JpcHQgZGVmZXI+CisgIGRlYnVnKDEpOworPC9zY3JpcHQ+Cis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFz dC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4yZWI1NmM5OGY5M2NhZjM3NDBmZjExODc1MWQzNTcxNWYwNTc3ZGI1Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItb25iZWZvcmVsb2FkLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK0NoZWNrcyB0aGF0 IGRlZmVycmVkIHNjcmlwdHMgZmlyZSBvbmJlZm9yZWxvYWQgaW1tZWRpYXRlbHkgYW5kIHRoYXQg aXQgaXMgY2FuY2VsbGFibGUuCitjYW5jZWxsZWQgb25iZWZvcmVsb2FkIGRlZmVyCitvbmJlZm9y ZWxvYWQgZGVmZXIKK29uYmVmb3JlbG9hZCBleHRlcm5hbAorZXh0ZXJuYWwKK2RlZmVyCisKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9u YmVmb3JlbG9hZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQv ZGVmZXItb25iZWZvcmVsb2FkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTIyYjE4NGRhNjNiYTQ3NTcxMWJl MWY3YmY1OTU5OWE1NDE2MGUyYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv ZG9tL0hUTUxTY3JpcHRFbGVtZW50L2RlZmVyLW9uYmVmb3JlbG9hZC5odG1sCkBAIC0wLDAgKzEs MTQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxo dG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2pzL3Jlc291 cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2Vz L2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorQ2hlY2tzIHRoYXQg ZGVmZXJyZWQgc2NyaXB0cyBmaXJlIG9uYmVmb3JlbG9hZCBpbW1lZGlhdGVseSBhbmQgdGhhdCBp dCBpcyBjYW5jZWxsYWJsZS4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9 InJlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdjYW5j ZWxsZWQgb25iZWZvcmVsb2FkIGRlZmVyJyk7IHJldHVybiBmYWxzZTsiIGRlZmVyPjwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIgb25iZWZvcmVsb2FkPSJkZWJ1Zygn b25iZWZvcmVsb2FkIGRlZmVyJyk7IHJldHVybiB0cnVlOyIgZGVmZXI+PC9zY3JpcHQ+Cis8c2Ny aXB0IHNyYz0icmVzb3VyY2VzL2V4dGVybmFsLmpzIiBvbmJlZm9yZWxvYWQ9ImRlYnVnKCdvbmJl Zm9yZWxvYWQgZXh0ZXJuYWwnKTsgcmV0dXJuIHRydWU7Ij48L3NjcmlwdD4KKzwvYm9keT4KKzwv aHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLXNjcmlwdC1pbnZhbGlkLXVybC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQu dHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjA0NWFmMWRjZDY5YWY4Njc1MjdiN2ZlZDU5ZGYxMzAzZTQ2M2M0OGMK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMyBAQAor Q2hlY2tzIHRoYXQgZGVmZXJyZWQgc2NyaXB0cyB3aXRoIGludmFsaWQgVVJMcyBhcmUgaWdub3Jl ZCBhbmQgc3Vic2VxdWVudCBkZWZlcnJlZCBzY3JpcHRzIGV4ZWN1dGVkLgorZGVmZXIKKwpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2Ny aXB0LWludmFsaWQtdXJsLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxl bWVudC9kZWZlci1zY3JpcHQtaW52YWxpZC11cmwuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iZjZjZWU0ZjM2 NWI1MzZmYzhlMmI4MmY3MTlkZDk4ZTA5NGQyZWU2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2NyaXB0LWludmFsaWQtdXJs Lmh0bWwKQEAgLTAsMCArMSwxMyBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9JRVRGLy9E VEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJl Zj0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIu Li8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+CitDaGVja3MgdGhhdCBkZWZlcnJlZCBzY3JpcHRzIHdpdGggaW52YWxpZCBVUkxzIGFyZSBp Z25vcmVkIGFuZCBzdWJzZXF1ZW50IGRlZmVycmVkIHNjcmlwdHMgZXhlY3V0ZWQuCis8ZGl2IGlk PSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSJodHRwOi8vbG9jYWxob3N0Ojk5OTk5OS8i IGRlZmVyPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9kZWZlci5qcyIgZGVmZXI+ PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS1leHBlY3RlZC50eHQK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uN2VmMjJlOWE0MzFhZDAyNzI3MTNiNzFmZGM4Nzk0MDE2YzhlZjEyZgotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L2Rl ZmVyLXdyaXRlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci13cml0ZS5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItd3JpdGUuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4wYzBiYmZmNDU2MTc2ZjE2ZDk2NjNhYTA5OWZjMzY4MTllNGRiOWMxCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVm ZXItd3JpdGUuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91 dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsK Kzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZhc2NyaXB0 LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcyBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9kZWZlci5qcwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5mYzY3ZGI0MWE2ZTFjNDQyODdjM2I2Y2Y0ZWZkNjEyMTA4YTNkNGNiCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3Vy Y2VzL2RlZmVyLmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJkZWZlciIpOwpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4dGVybmFs LmpzIGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvcmVzb3VyY2VzL2V4 dGVybmFsLmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiYWQ0NjUyMzQyMDU1Y2ViYjE5ZDE0NDUyZWJkZTFlYTQ0 NzdlZjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0 RWxlbWVudC9yZXNvdXJjZXMvZXh0ZXJuYWwuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImV4dGVy bmFsIik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVu dC9yZXNvdXJjZXMvc2hvdWxkbm90ZXhlY3V0ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxTY3JpcHRFbGVtZW50L3Jlc291cmNlcy9zaG91bGRub3RleGVjdXRlLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmMwZDY5NTQwMTYyZjlhZDdjYWIxZjAyMDc2ZGY4MWIxOTcxN2JkOTAKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9yZXNvdXJjZXMvc2hv dWxkbm90ZXhlY3V0ZS5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiRkFJTCIpOwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvc2hvdWxkbm90ZXhlY3V0 ZS5qcyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3Nob3VsZG5vdGV4 ZWN1dGUuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uZmM2N2RiNDFhNmUxYzQ0Mjg3YzNiNmNmNGVmZDYxMjEwOGEz ZDRjYgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L3Nob3VsZG5vdGV4ZWN1dGUuanMKQEAgLTAsMCArMSBAQAorZGVidWcoImRlZmVyIik7 CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28t ZGVmZXItd3JpdGVzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdlZjIy ZTlhNDMxYWQwMjcyNzEzYjcxZmRjODc5NDAxNmM4ZWYxMmYKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxIEBACitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC90d28tZGVmZXItd3JpdGVzLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uNGIwZDM3ODczMDVkODI0YmE4NzZlMmI2MTRlMzZjMWM2ZjA0NWI3YwotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50L3R3by1k ZWZlci13cml0ZXMuaHRtbApAQCAtMCwwICsxLDcgQEAKKzxzY3JpcHQ+CitpZiAod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KTsKKzwvc2NyaXB0PgorRkFJTAorPHNjcmlwdCBkZWZlciBzcmM9ImRhdGE6dGV4dC9qYXZhc2Ny aXB0LGRvY3VtZW50LndyaXRlKCdQQVNTJyk7Ij48L3NjcmlwdD4KKzxzY3JpcHQgZGVmZXIgc3Jj PSJkYXRhOnRleHQvamF2YXNjcmlwdCxkb2N1bWVudC53cml0ZSgnRkFJTCcpOyI+PC9zY3JpcHQ+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL2RlZmVy LXNjcmlwdC5qcyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZGVmZXIt c2NyaXB0LmpzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZjNjdkYjQxYTZlMWM0NDI4N2MzYjZjZjRlZmQ2MTIxMDhh M2Q0Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVz b3VyY2VzL2RlZmVyLXNjcmlwdC5qcwpAQCAtMCwwICsxIEBACitkZWJ1ZygiZGVmZXIiKTsKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwt c2NyaXB0LmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9leHRlcm5h bC1zY3JpcHQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmJhZDQ2NTIzNDIwNTVjZWJiMTlkMTQ0NTJlYmRlMWVh NDQ3N2VmOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzCkBAIC0wLDAgKzEgQEAKK2RlYnVnKCJleHRlcm5h bCIpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9z Y3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9t aXNjL3Jlc291cmNlcy9zY3JpcHQtZGVidWctYm9keS1iYWNrZ3JvdW5kLmpzCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjZmYmU3YTFjNDI0OGRhYzM4MjU1MzVhNzRkY2Y1NDM0YzRmNmI5NDIKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1i b2R5LWJhY2tncm91bmQuanMKQEAgLTAsMCArMSBAQAorc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJn ZXRDb21wdXRlZFN0eWxlKGRvY3VtZW50LmJvZHkpWydiYWNrZ3JvdW5kLWNvbG9yJ10iLCAicmdi KDI1NSwgMCwgMCkiKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9y ZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcyBiL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2NyaXB0LXdyaXRlLXNsb3ctc3R5bGVzaGVldC5qcwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi5lZDExZWI1MmM2ZWY3ZmVlZjE1MWQyZDQ3OTllM2RjMmFlYjI3NmYzCi0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zY3Jp cHQtd3JpdGUtc2xvdy1zdHlsZXNoZWV0LmpzCkBAIC0wLDAgKzEgQEAKK2RvY3VtZW50LndyaXRl KCc8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNj L3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIj4nKTsKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xvdy1kZWZlci1zY3JpcHQuY2dpIGIvTGF5 b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kK bmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uYTk4ZDNkNWE4MWQzNzg4NzY5MmM3MzkyMmM4ZDNjMjlmMWI2YmQxOAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9yZXNvdXJjZXMvc2xv dy1kZWZlci1zY3JpcHQuY2dpCkBAIC0wLDAgKzEsNSBAQAorIyEvdXNyL2Jpbi9wZXJsIC13CisK K3ByaW50ICJDb250ZW50LXR5cGU6IHRleHQvamF2YXNjcmlwdFxuXG4iOworc2xlZXAoMC41KTsK K3ByaW50ICJkZWJ1Zygnc2xvd0RlZmVyJyk7XG4iOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3Jlc291cmNlcy9zbG93LXN0eWxlc2hlZXQuY2dpCm5ldyBmaWxl IG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLmZjZGRjYTQwMWY4YWIzYTZhNWRmODczYTY1NDFjN2Y0MGFiMDllY2UKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVz aGVldC5jZ2kKQEAgLTAsMCArMSw1IEBACisjIS91c3IvYmluL3BlcmwgLXcKKworcHJpbnQgIkNv bnRlbnQtdHlwZTogdGV4dC9jc3NcblxuIjsKK3NsZWVwKDAuNSk7CitwcmludCAiYm9keSB7IGJh Y2tncm91bmQtY29sb3I6ICNGRjAwMDAgfVxuIjsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2h0 dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xvdy1zdHlsZXNoZWV0LWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2h0dHAvdGVzdHMvbWlzYy9zY3JpcHQtZGVmZXItYWZ0ZXItc2xv dy1zdHlsZXNoZWV0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi41MjQ1NzYzZDg1MTMyMDIxNDEy MzYyMzcwZmY2MTEyYzg2ZDQ2ZDcwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvaHR0 cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTAgQEAKK1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHls ZXNoZWV0IGV4ZWN1dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLgorCitPbiBzdWNjZXNzLCB5 b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVT VCBDT01QTEVURSIuCisKK1BBU1MgZ2V0Q29tcHV0ZWRTdHlsZShkb2N1bWVudC5ib2R5KVsnYmFj a2dyb3VuZC1jb2xvciddIGlzICJyZ2IoMjU1LCAwLCAwKSIKK0RPTUNvbnRlbnRMb2FkZWQKK1BB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2NyaXB0LWRlZmVyLWFmdGVyLXNsb3ct c3R5bGVzaGVldC5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZl ci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wNmVjODQ5YzM4OWQ0Mzli Yjc5NDgwZWZiM2YzMzc3YzM1NDNjMTk5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv aHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbApA QCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1M Ly9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBj b250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9dXRmLTgiIC8+Cis8bGluayByZWw9InN0eWxlc2hl ZXQiIGhyZWY9Ii4uLy4uL2pzLXRlc3QtcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxz Y3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3Jp cHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkdmkgaWQ9ImRlc2NyaXB0aW9uIj48L2Rpdj4KKzxkaXYg aWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVz Y3JpcHRpb24oJ1RoaXMgdGVzdHMgdGhhdCBhbiBpbmxpbmUgc2xvdyBzdHlsZXNoZWV0IGV4ZWN1 dGVzIGJlZm9yZSBkZWZlcnJlZCBzY3JpcHRzLicpOworCit2YXIganNUZXN0SXNBc3luYyA9IHRy dWU7CisKK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRMb2FkZWQiLCBmdW5j dGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKKworICBmaW5pc2hKU1Rlc3Qo KTsKK30sIGZhbHNlKTsKKzwvc2NyaXB0PgorCis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAu MTo4MDAwL21pc2MvcmVzb3VyY2VzL3NjcmlwdC1kZWJ1Zy1ib2R5LWJhY2tncm91bmQuCitqcyIg ZGVmZXI9ImRlZmVyIj48L3NjcmlwdD4KKzxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0 cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL3Nsb3ctc3R5bGVzaGUKK2V0LmNnaSI+ Cis8c2NyaXB0PgordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxz Y3JpcHQgc3JjPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0 cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3Rz L21pc2Mvc2NyaXB0LWRlZmVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iZmNhYTZlOTI0NTQ2 YmNiOTRmNDhmZTFmM2Y2MzczNGFlNTE1MjY1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw4 IEBACitUaGlzIHRlc3RzIGZvciBwcm9wZXIgZXhlY3V0aW9uIG9yZGVyIG9mIHNjcmlwdHMgd2l0 aCB0aGUgZGVmZXIgYXR0cmlidXRlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMDcxMC4KK2V4dGVybmFsCitpbmxpbmUKK3Nsb3dEZWZlcgorZGVmZXIKK0RPTUNvbnRl bnRMb2FkZWQKK2xvYWQKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNj L3NjcmlwdC1kZWZlci5odG1sIGIvTGF5b3V0VGVzdHMvaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1k ZWZlci5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjk1Y2Y4YjM1MDc1ZmExOGJkNjIzYmNkNmNhZDZhZTY3ZGU1 ZDNjMzMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9odHRwL3Rlc3RzL21pc2Mvc2Ny aXB0LWRlZmVyLmh0bWwKQEAgLTAsMCArMSwyNCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICIt Ly9JRVRGLy9EVEQgSFRNTC8vRU4iPgorPGh0bWw+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9 IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXV0Zi04IiAvPgorPGxp bmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9qcy10ZXN0LXJlc291cmNlcy9qcy10ZXN0 LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMtdGVzdC1yZXNvdXJjZXMvanMtdGVz dC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHkgb25sb2FkPSJkZWJ1ZygnbG9hZCcp Ij4KK1RoaXMgdGVzdHMgZm9yIHByb3BlciBleGVjdXRpb24gb3JkZXIgb2Ygc2NyaXB0cyB3aXRo IHRoZSBkZWZlciBhdHRyaWJ1dGUgPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwNzEwIj5odHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjA3MTA8L2E+LgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+CisKKzxzY3JpcHQgdHlwZT0i dGV4dC9qYXZhc2NyaXB0Ij4KK2RvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoIkRPTUNvbnRlbnRM b2FkZWQiLCBmdW5jdGlvbigpIHsKKyAgZGVidWcoJ0RPTUNvbnRlbnRMb2FkZWQnKTsKK30sIGZh bHNlKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Imh0dHA6Ly8xMjcuMC4wLjE6ODAwMC9taXNj L3Jlc291cmNlcy9zbG93LWRlZmVyLXNjcmlwdC5jZ2kiIGRlZmVyPSJERUZFUiI+PC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0iaHR0cDovLzEyNy4wLjAuMTo4MDAwL21pc2MvcmVzb3VyY2VzL2RlZmVy LXNjcmlwdC5qcyIgZGVmZXI9IkRFRkVSIj48L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSJodHRwOi8v MTI3LjAuMC4xOjgwMDAvbWlzYy9yZXNvdXJjZXMvZXh0ZXJuYWwtc2NyaXB0LmpzIj48L3Njcmlw dD4KKzxzY3JpcHQ+CitkZWJ1ZygiaW5saW5lIik7Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5k ZXggNWQ2ZTg4ZjI1NjFiNDlkOTQ1MWIzNzdmOTAxZTU5OWQ3MWNhNTJiMC4uNzIzNjA2MmJhNDZh ZDAzY2YyN2ZiYzFmYjFjNmM4MWU2NGQ5Y2ZlMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw3MiBAQAorMjAxMC0wOS0wMSAg VG9ueSBHZW50aWxjb3JlICA8dG9ueWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2Vk IGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgU3VwcG9ydCA8c2NyaXB0IGRlZmVyPiBhcyBzcGVj aWZpZWQgYnkgSFRNTDUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTQwOTM0CisKKyAgICAgICAgVGVzdHM6IGZhc3QvZG9tL0hUTUxTY3JpcHRFbGVtZW50 L2RlZmVyLWRvdWJsZS1kZWZlci13cml0ZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2RvbS9I VE1MU2NyaXB0RWxlbWVudC9kZWZlci1kb3VibGUtd3JpdGUuaHRtbAorICAgICAgICAgICAgICAg ZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItaW5saW5lLXNjcmlwdC5odG1sCisgICAg ICAgICAgICAgICBmYXN0L2RvbS9IVE1MU2NyaXB0RWxlbWVudC9kZWZlci1vbmJlZm9yZWxvYWQu aHRtbAorICAgICAgICAgICAgICAgZmFzdC9kb20vSFRNTFNjcmlwdEVsZW1lbnQvZGVmZXItc2Ny aXB0LWludmFsaWQtdXJsLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3JpcHRF bGVtZW50L2RlZmVyLXdyaXRlLmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvZG9tL0hUTUxTY3Jp cHRFbGVtZW50L3R3by1kZWZlci13cml0ZXMuaHRtbAorICAgICAgICAgICAgICAgaHR0cC90ZXN0 cy9taXNjL3NjcmlwdC1kZWZlci1hZnRlci1zbG93LXN0eWxlc2hlZXQuaHRtbAorICAgICAgICAg ICAgICAgaHR0cC90ZXN0cy9taXNjL3NjcmlwdC1kZWZlci5odG1sCisKKyAgICAgICAgKiBkb20v RG9jdW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnQ6Om9wZW4pOiBBbGxvdyBp bXBsaWNpdCBvcGVuIGZvciB3cml0ZXMoKSB3aGlsZSBleGVjdXRpbmcgZGVmZXJyZWQgc2NyaXB0 cy4KKyAgICAgICAgKiBkb20vRG9jdW1lbnRQYXJzZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnRQYXJzZXI6OkRvY3VtZW50UGFyc2VyKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3Vt ZW50UGFyc2VyOjpzdGFydFBhcnNpbmcpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJz ZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKTogSWYgY2FsbGVkIHdoZW4gc3RvcHBlZCBvciBkZXRh Y2hlZCwgaXQgc2hvdWxkbid0IHJlc2V0IHRvIHN0b3BwaW5nLgorICAgICAgICAoV2ViQ29yZTo6 RG9jdW1lbnRQYXJzZXI6OnN0b3BQYXJzaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkRvY3VtZW50 UGFyc2VyOjpkZXRhY2gpOgorICAgICAgICAqIGRvbS9Eb2N1bWVudFBhcnNlci5oOgorICAgICAg ICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6OmlzUGFyc2luZyk6CisgICAgICAgIChXZWJDb3Jl OjpEb2N1bWVudFBhcnNlcjo6aXNBY3RpdmUpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQ YXJzZXI6OmlzU3RvcHBpbmcpOgorICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRQYXJzZXI6Omlz RGV0YWNoZWQpOgorICAgICAgICAqIGRvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaDoKKyAgICAg ICAgKFdlYkNvcmU6OlJhd0RhdGFEb2N1bWVudFBhcnNlcjo6ZmluaXNoKToKKyAgICAgICAgKiBk b20vWE1MRG9jdW1lbnRQYXJzZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQ YXJzZXI6OmFwcGVuZCk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6ZXhp dFRleHQpOgorICAgICAgICAqIGRvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmRvV3JpdGUpOgorICAgICAgICAoV2Vi Q29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OnN0YXJ0RWxlbWVudE5zKToKKyAgICAgICAgKFdlYkNv cmU6OlhNTERvY3VtZW50UGFyc2VyOjplbmRFbGVtZW50TnMpOgorICAgICAgICAoV2ViQ29yZTo6 WE1MRG9jdW1lbnRQYXJzZXI6OmNoYXJhY3RlcnMpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9j dW1lbnRQYXJzZXI6OmVycm9yKToKKyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2Vy Ojpwcm9jZXNzaW5nSW5zdHJ1Y3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQ YXJzZXI6OmNkYXRhQmxvY2spOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6 OmNvbW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6WE1MRG9jdW1lbnRQYXJzZXI6OmludGVybmFs U3Vic2V0KToKKyAgICAgICAgKFdlYkNvcmU6OlhNTERvY3VtZW50UGFyc2VyOjppbml0aWFsaXpl UGFyc2VyQ29udGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpYTUxEb2N1bWVudFBhcnNlcjo6ZG9F bmQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHA6CisgICAg ICAgIChXZWJDb3JlOjpIVE1MRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKToK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6cHVtcFRva2VuaXplcklmUG9z c2libGUpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5p emVyKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6aW5zZXJ0KToKKyAg ICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6YXBwZW5kKToKKyAgICAgICAgKFdl YkNvcmU6OkhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxE b2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRvRW5kKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1 bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxEb2N1bWVu dFBhcnNlcjo6bm90aWZ5RmluaXNoZWQpOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxEb2N1 bWVudFBhcnNlci5oOgorICAgICAgICAqIGh0bWwvcGFyc2VyL0hUTUxTY3JpcHRSdW5uZXIuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6fkhUTUxTY3JpcHRSdW5uZXIp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0ZVBhcnNpbmdCbG9j a2luZ1NjcmlwdCk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpleGVjdXRl UGVuZGluZ1NjcmlwdEFuZERpc3BhdGNoRXZlbnQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFNj cmlwdFJ1bm5lcjo6ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZyk6CisgICAgICAgIChX ZWJDb3JlOjpIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRTY3JpcHQpOgorICAgICAg ICAoV2ViQ29yZTo6SFRNTFNjcmlwdFJ1bm5lcjo6cnVuU2NyaXB0KToKKyAgICAgICAgKiBodG1s L3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmg6CisgICAgICAgICogbG9hZGVyL0ltYWdlRG9jdW1l bnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW1hZ2VEb2N1bWVudFBhcnNlcjo6ZmluaXNoKToK KwogMjAxMC0wOS0wMSAgRGF2ZSBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBEYW4gQmVybnN0ZWluIGFuZCBTaW1vbiBGcmFzZXIuCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAKaW5kZXgg OGEzNWFiY2ZkMjNlYjkxOTU3NTNjOWZmYmExZWZjZjIxNDYwOTkxMC4uNTc4M2I4ZDI5NWYyMDJj ZGQyOTM4M2Y2YTJhZDI3MzkwOGIzNWUwMyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9jdW1l bnQuY3BwCisrKyBiL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMTgyNCw3ICsxODI0LDcg QEAgdm9pZCBEb2N1bWVudDo6b3BlbihEb2N1bWVudCogb3duZXJEb2N1bWVudCkKIAogICAgIGlm IChtX2ZyYW1lKSB7CiAgICAgICAgIFNjcmlwdGFibGVEb2N1bWVudFBhcnNlciogcGFyc2VyID0g c2NyaXB0YWJsZURvY3VtZW50UGFyc2VyKCk7Ci0gICAgICAgIGlmIChtX2ZyYW1lLT5sb2FkZXIo KS0+aXNMb2FkaW5nTWFpblJlc291cmNlKCkgfHwgKHBhcnNlciAmJiBwYXJzZXItPmlzRXhlY3V0 aW5nU2NyaXB0KCkpKQorICAgICAgICBpZiAobV9mcmFtZS0+bG9hZGVyKCktPmlzTG9hZGluZ01h aW5SZXNvdXJjZSgpIHx8IChwYXJzZXIgJiYgcGFyc2VyLT5pc1BhcnNpbmcoKSAmJiBwYXJzZXIt PmlzRXhlY3V0aW5nU2NyaXB0KCkpKQogICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIGlm IChtX2ZyYW1lLT5sb2FkZXIoKS0+c3RhdGUoKSA9PSBGcmFtZVN0YXRlUHJvdmlzaW9uYWwpCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3JlL2RvbS9E b2N1bWVudFBhcnNlci5jcHAKaW5kZXggY2M0YzYxYjAzNDk2NWJmMWNmMDEzY2Q2NDA5OTIxOWQx YjExMmVmMS4uNjM5ODYwYTJjYWU0YTk5YTQzY2EwOWQ2NTRlYjY0NmY5ZWU0NzAwYyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9kb20vRG9jdW1lbnRQYXJzZXIuY3BwCisrKyBiL1dlYkNvcmUvZG9tL0Rv Y3VtZW50UGFyc2VyLmNwcApAQCAtMzEsNyArMzEsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewog CiBEb2N1bWVudFBhcnNlcjo6RG9jdW1lbnRQYXJzZXIoRG9jdW1lbnQqIGRvY3VtZW50KQotICAg IDogbV9wYXJzZXJTdG9wcGVkKGZhbHNlKQorICAgIDogbV9zdGF0ZShQYXJzaW5nU3RhdGUpCiAg ICAgLCBtX2RvY3VtZW50KGRvY3VtZW50KQogewogICAgIEFTU0VSVChkb2N1bWVudCk7CkBAIC00 NSw4ICs0NSwyNSBAQCBEb2N1bWVudFBhcnNlcjo6fkRvY3VtZW50UGFyc2VyKCkKICAgICBBU1NF UlQoIW1fZG9jdW1lbnQpOwogfQogCit2b2lkIERvY3VtZW50UGFyc2VyOjpzdGFydFBhcnNpbmco KQoreworICAgIG1fc3RhdGUgPSBQYXJzaW5nU3RhdGU7Cit9CisKK3ZvaWQgRG9jdW1lbnRQYXJz ZXI6OnByZXBhcmVUb1N0b3BQYXJzaW5nKCkKK3sKKyAgICBpZiAobV9zdGF0ZSA9PSBQYXJzaW5n U3RhdGUpCisgICAgICAgIG1fc3RhdGUgPSBTdG9wcGluZ1N0YXRlOworfQorCit2b2lkIERvY3Vt ZW50UGFyc2VyOjpzdG9wUGFyc2luZygpCit7CisgICAgbV9zdGF0ZSA9IFN0b3BwZWRTdGF0ZTsK K30KKwogdm9pZCBEb2N1bWVudFBhcnNlcjo6ZGV0YWNoKCkKIHsKKyAgICBtX3N0YXRlID0gRGV0 YWNoZWRTdGF0ZTsKICAgICBtX2RvY3VtZW50ID0gMDsKIH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9kb20vRG9jdW1lbnRQYXJzZXIuaCBiL1dlYkNvcmUvZG9tL0RvY3VtZW50UGFyc2VyLmgKaW5k ZXggM2MyODg1NjI1ZWUxMzEwNDBjMWY3Yzk5OWRiZTUzMjc5MDZlMmRhYy4uN2NjOWU3Yjk2MDVi NTI2MjY1YTkyNWUzZWZhOTA4YTg5ZWNiY2EzZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vRG9j dW1lbnRQYXJzZXIuaAorKysgYi9XZWJDb3JlL2RvbS9Eb2N1bWVudFBhcnNlci5oCkBAIC01Nywx MiArNTcsMjkgQEAgcHVibGljOgogCiAgICAgLy8gRklYTUU6IHByb2Nlc3NpbmdEYXRhKCkgaXMg b25seSB1c2VkIGJ5IERvY3VtZW50TG9hZGVyOjppc0xvYWRpbmdJbkFQSVNlbnNlCiAgICAgLy8g YW5kIGlzIHZlcnkgdW5jbGVhciBhcyB0byB3aGF0IGl0IGFjdHVhbGx5IG1lYW5zLiAgVGhlIExl Z2FjeUhUTUxEb2N1bWVudFBhcnNlcgotICAgIC8vIHVzZWQgdG8gaW1wbGVtZW50cyBpdC4KKyAg ICAvLyB1c2VkIHRvIGltcGxlbWVudCBpdC4KICAgICB2aXJ0dWFsIGJvb2wgcHJvY2Vzc2luZ0Rh dGEoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCiAgICAgLy8gZG9jdW1lbnQoKSB3aWxsIHJl dHVybiAwIGFmdGVyIGRldGFjaCgpIGlzIGNhbGxlZC4KICAgICBEb2N1bWVudCogZG9jdW1lbnQo KSBjb25zdCB7IEFTU0VSVChtX2RvY3VtZW50KTsgcmV0dXJuIG1fZG9jdW1lbnQ7IH0KLSAgICBi b29sIGlzRGV0YWNoZWQoKSBjb25zdCB7IHJldHVybiAhbV9kb2N1bWVudDsgfQorCisgICAgYm9v bCBpc1BhcnNpbmcoKSBjb25zdCB7IHJldHVybiBtX3N0YXRlID09IFBhcnNpbmdTdGF0ZTsgfQor ICAgIGJvb2wgaXNTdG9wcGluZygpIGNvbnN0IHsgcmV0dXJuIG1fc3RhdGUgPT0gU3RvcHBpbmdT dGF0ZTsgfQorICAgIGJvb2wgaXNTdG9wcGVkKCkgY29uc3QgeyByZXR1cm4gbV9zdGF0ZSA+PSBT dG9wcGVkU3RhdGU7IH0KKyAgICBib29sIGlzRGV0YWNoZWQoKSBjb25zdCB7IHJldHVybiBtX3N0 YXRlID09IERldGFjaGVkU3RhdGU7IH0KKworICAgIC8vIEZJWE1FOiBJcyB0aGlzIG5lY2Vzc2Fy eT8gRG9lcyBYTUxEb2N1bWVudFBhcnNlckxpYnhtbDIgcmVhbGx5IG5lZWQgdG8gc2V0IHRoaXM/ CisgICAgdmlydHVhbCB2b2lkIHN0YXJ0UGFyc2luZygpOworCisgICAgLy8gcHJlcGFyZVRvU3Rv cCgpIGlzIHVzZWQgd2hlbiB0aGUgRU9GIHRva2VuIGlzIGVuY291bnRlcmVkIGFuZCBwYXJzaW5n IGlzIHRvIGJlCisgICAgLy8gc3RvcHBlZCBub3JtYWxseS4KKyAgICB2aXJ0dWFsIHZvaWQgcHJl cGFyZVRvU3RvcFBhcnNpbmcoKTsKKworICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgdXNlZCB3aGVu IGEgbG9hZCBpcyBjYW5jZWxlZC9zdG9wcGVkLgorICAgIC8vIHN0b3BQYXJzaW5nKCkgaXMgY3Vy cmVudGx5IGRpZmZlcmVudCBmcm9tIGRldGFjaCgpLCBidXQgc2hvdWxkbid0IGJlLgorICAgIC8v IEl0IHNob3VsZCBOT1QgYmUgb2sgdG8gY2FsbCBhbnkgbWV0aG9kcyBvbiBEb2N1bWVudFBhcnNl ciBhZnRlciBlaXRoZXIKKyAgICAvLyBkZXRhY2goKSBvciBzdG9wUGFyc2luZygpIGJ1dCByaWdo dCBub3cgb25seSBkZXRhY2goKSB3aWxsIEFTU0VSVC4KKyAgICB2aXJ0dWFsIHZvaWQgc3RvcFBh cnNpbmcoKTsKIAogICAgIC8vIERvY3VtZW50IGlzIGV4cGVjdGVkIHRvIGRldGFjaCB0aGUgcGFy c2VyIGJlZm9yZSByZWxlYXNpbmcgaXRzIHJlZi4KICAgICAvLyBBZnRlciBkZXRhY2gsIG1fZG9j dW1lbnQgaXMgY2xlYXJlZC4gIFRoZSBwYXJzZXIgd2lsbCB1bndpbmQgaXRzCkBAIC03MSwyMiAr ODgsMTggQEAgcHVibGljOgogICAgIC8vIGRldGFjaCBpcyBjYWxsZWQuCiAgICAgdmlydHVhbCB2 b2lkIGRldGFjaCgpOwogCi0gICAgLy8gc3RvcFBhcnNpbmcoKSBpcyB1c2VkIHdoZW4gYSBsb2Fk IGlzIGNhbmNlbGVkL3N0b3BwZWQuCi0gICAgLy8gc3RvcFBhcnNpbmcoKSBpcyBjdXJyZW50bHkg ZGlmZmVyZW50IGZyb20gZGV0YWNoKCksIGJ1dCBzaG91bGRuJ3QgYmUuCi0gICAgLy8gSXQgc2hv dWxkIE5PVCBiZSBvayB0byBjYWxsIGFueSBtZXRob2RzIG9uIERvY3VtZW50UGFyc2VyIGFmdGVy IGVpdGhlcgotICAgIC8vIGRldGFjaCgpIG9yIHN0b3BQYXJzaW5nKCkgYnV0IHJpZ2h0IG5vdyBv bmx5IGRldGFjaCgpIHdpbGwgQVNTRVJULgotICAgIHZpcnR1YWwgdm9pZCBzdG9wUGFyc2luZygp IHsgbV9wYXJzZXJTdG9wcGVkID0gdHJ1ZTsgfQotCiBwcm90ZWN0ZWQ6CiAgICAgRG9jdW1lbnRQ YXJzZXIoRG9jdW1lbnQqKTsKIAotICAgIC8vIFRoZSBwYXJzZXIgaGFzIGJ1ZmZlcnMsIHNvIHBh cnNpbmcgbWF5IGNvbnRpbnVlIGV2ZW4gYWZ0ZXIKLSAgICAvLyBpdCBzdG9wcyByZWNlaXZpbmcg ZGF0YS4gV2UgdXNlIG1fcGFyc2VyU3RvcHBlZCB0byBzdG9wIHRoZSBwYXJzZXIKLSAgICAvLyBl dmVuIHdoZW4gaXQgaGFzIGJ1ZmZlcmVkIGRhdGEuCi0gICAgLy8gRklYTUU6IG1fZG9jdW1lbnQg PSAwIGNvdWxkIGJlIGNoYW5nZWQgdG8gbWVhbiAicGFyc2VyIHN0b3BwZWQiLgotICAgIGJvb2wg bV9wYXJzZXJTdG9wcGVkOwotCiBwcml2YXRlOgorICAgIGVudW0gUGFyc2VyU3RhdGUgeworICAg ICAgICBQYXJzaW5nU3RhdGUsCisgICAgICAgIFN0b3BwaW5nU3RhdGUsCisgICAgICAgIFN0b3Bw ZWRTdGF0ZSwKKyAgICAgICAgRGV0YWNoZWRTdGF0ZQorICAgIH07CisgICAgUGFyc2VyU3RhdGUg bV9zdGF0ZTsKKwogICAgIC8vIEV2ZXJ5IERvY3VtZW50UGFyc2VyIG5lZWRzIGEgcG9pbnRlciBi YWNrIHRvIHRoZSBkb2N1bWVudC4KICAgICAvLyBtX2RvY3VtZW50IHdpbGwgYmUgMCBhZnRlciB0 aGUgcGFyc2VyIGlzIHN0b3BwZWQuCiAgICAgRG9jdW1lbnQqIG1fZG9jdW1lbnQ7CmRpZmYgLS1n aXQgYS9XZWJDb3JlL2RvbS9SYXdEYXRhRG9jdW1lbnRQYXJzZXIuaCBiL1dlYkNvcmUvZG9tL1Jh d0RhdGFEb2N1bWVudFBhcnNlci5oCmluZGV4IDA5M2RkYWY2N2QxODBjNGRhMGFjNzE2NmNlNGZh YWZkNWMxODExYzEuLjljYTM2ZjRkYzc2Y2Q1MjNlMTJkZGFiNTc4ZDVkZTE3OGMxNzM4OTUgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oCisrKyBiL1dlYkNv cmUvZG9tL1Jhd0RhdGFEb2N1bWVudFBhcnNlci5oCkBAIC0zOSw3ICszOSw3IEBAIHByb3RlY3Rl ZDoKIAogICAgIHZpcnR1YWwgdm9pZCBmaW5pc2goKQogICAgIHsKLSAgICAgICAgaWYgKCFtX3Bh cnNlclN0b3BwZWQgJiYgIWlzRGV0YWNoZWQoKSkKKyAgICAgICAgaWYgKCFpc1N0b3BwZWQoKSkK ICAgICAgICAgICAgIGRvY3VtZW50KCktPmZpbmlzaGVkUGFyc2luZygpOwogICAgIH0KIApkaWZm IC0tZ2l0IGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXIuY3BwIGIvV2ViQ29yZS9kb20v WE1MRG9jdW1lbnRQYXJzZXIuY3BwCmluZGV4IDRiNzY0NzIyYWVlZjM2ZTI2YTUxNWExM2U2YzM3 MjNjMDZhY2Y4ZDcuLjVmYjhiNTQ0ODA0OTg4NzRiMzFkNGQ5OTdlYjlkM2ZhNWEyNDkzZmQgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1hNTERvY3VtZW50UGFyc2VyLmNwcAorKysgYi9XZWJDb3Jl L2RvbS9YTUxEb2N1bWVudFBhcnNlci5jcHAKQEAgLTEzMiw3ICsxMzIsNyBAQCB2b2lkIFhNTERv Y3VtZW50UGFyc2VyOjphcHBlbmQoY29uc3QgU2VnbWVudGVkU3RyaW5nJiBzKQogICAgIGlmICht X3Nhd1hTTFRyYW5zZm9ybSB8fCAhbV9zYXdGaXJzdEVsZW1lbnQpCiAgICAgICAgIG1fb3JpZ2lu YWxTb3VyY2VGb3JUcmFuc2Zvcm0gKz0gcGFyc2VTdHJpbmc7CiAKLSAgICBpZiAoaXNEZXRhY2hl ZCgpIHx8IG1fcGFyc2VyU3RvcHBlZCB8fCBtX3Nhd1hTTFRyYW5zZm9ybSkKKyAgICBpZiAoaXNT dG9wcGVkKCkgfHwgbV9zYXdYU0xUcmFuc2Zvcm0pCiAgICAgICAgIHJldHVybjsKIAogICAgIGlm IChtX3BhcnNlclBhdXNlZCkgewpAQCAtMTkwLDcgKzE5MCw3IEBAIHN0YXRpYyBpbmxpbmUgU3Ry aW5nIHRvU3RyaW5nKGNvbnN0IHhtbENoYXIqIHN0ciwgdW5zaWduZWQgbGVuKQogCiB2b2lkIFhN TERvY3VtZW50UGFyc2VyOjpleGl0VGV4dCgpCiB7Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkK KyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmICghbV9jdXJy ZW50Tm9kZSB8fCAhbV9jdXJyZW50Tm9kZS0+aXNUZXh0Tm9kZSgpKQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcCBiL1dlYkNvcmUvZG9tL1hNTERv Y3VtZW50UGFyc2VyTGlieG1sMi5jcHAKaW5kZXggZGI5NGM1MGI0NDc3MWZkNTFlYTQzZjg0MTZj ODRhZWQyNzE1ZWU5Zi4uZDk5YWI0YjlhZWEzNWU0Y2EzYjc0ZTljMGY4YjYxNTI1NDk4NzRjNiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJMaWJ4bWwyLmNwcAorKysg Yi9XZWJDb3JlL2RvbS9YTUxEb2N1bWVudFBhcnNlckxpYnhtbDIuY3BwCkBAIC02NjAsNyArNjYw LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6ZG9Xcml0ZShjb25zdCBTdHJpbmcmIHBhcnNl U3RyaW5nKQogCiAgICAgICAgIC8vIEphdmFTY3JpcHQgKHdoaWNoIG1heSBiZSBydW4gdW5kZXIg dGhlIHhtbFBhcnNlQ2h1bmsgY2FsbHN0YWNrKSBtYXkKICAgICAgICAgLy8gY2F1c2UgdGhlIHBh cnNlciB0byBiZSBzdG9wcGVkIG9yIGRldGFjaGVkLgotICAgICAgICBpZiAoaXNEZXRhY2hlZCgp IHx8IG1fcGFyc2VyU3RvcHBlZCkKKyAgICAgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICAg ICAgcmV0dXJuOwogICAgIH0KIApAQCAtNzMzLDcgKzczMyw3IEBAIHN0YXRpYyBpbmxpbmUgdm9p ZCBoYW5kbGVFbGVtZW50QXR0cmlidXRlcyhFbGVtZW50KiBuZXdFbGVtZW50LCBjb25zdCB4bWxD aGFyKioKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnN0YXJ0RWxlbWVudE5zKGNvbnN0IHhtbENo YXIqIHhtbExvY2FsTmFtZSwgY29uc3QgeG1sQ2hhciogeG1sUHJlZml4LCBjb25zdCB4bWxDaGFy KiB4bWxVUkksIGludCBuYl9uYW1lc3BhY2VzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGNvbnN0IHhtbENoYXIqKiBsaWJ4bWxOYW1lc3BhY2VzLCBpbnQgbmJfYXR0cmlidXRl cywgaW50IG5iX2RlZmF1bHRlZCwgY29uc3QgeG1sQ2hhcioqIGxpYnhtbEF0dHJpYnV0ZXMpCiB7 Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAg IHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtODIyLDcgKzgyMiw3IEBA IHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnN0YXJ0RWxlbWVudE5zKGNvbnN0IHhtbENoYXIqIHht bExvY2FsTmFtZSwgY29uc3QgeG1sQ2hhCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVuZEVs ZW1lbnROcygpCiB7Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVk KCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtOTA2 LDcgKzkwNiw3IEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmVuZEVsZW1lbnROcygpCiAKIHZv aWQgWE1MRG9jdW1lbnRQYXJzZXI6OmNoYXJhY3RlcnMoY29uc3QgeG1sQ2hhciogcywgaW50IGxl bikKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAgIGlmIChpc1N0b3BwZWQoKSkKICAg ICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1c2VkKSB7CkBAIC05MjEsNyArOTIx LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6Y2hhcmFjdGVycyhjb25zdCB4bWxDaGFyKiBz LCBpbnQgbGVuKQogCiB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjplcnJvcihFcnJvclR5cGUgdHlw ZSwgY29uc3QgY2hhciogbWVzc2FnZSwgdmFfbGlzdCBhcmdzKQogewotICAgIGlmIChtX3BhcnNl clN0b3BwZWQpCisgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1cm47CiAKICNpZiBD T01QSUxFUihNU1ZDKSB8fCBDT01QSUxFUihSVkNUKQpAQCAtOTQ1LDcgKzk0NSw3IEBAIHZvaWQg WE1MRG9jdW1lbnRQYXJzZXI6OmVycm9yKEVycm9yVHlwZSB0eXBlLCBjb25zdCBjaGFyKiBtZXNz YWdlLCB2YV9saXN0IGFyZ3MpCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJ bnN0cnVjdGlvbihjb25zdCB4bWxDaGFyKiB0YXJnZXQsIGNvbnN0IHhtbENoYXIqIGRhdGEpCiB7 Ci0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAg IHJldHVybjsKIAogICAgIGlmIChtX3BhcnNlclBhdXNlZCkgewpAQCAtOTc5LDcgKzk3OSw3IEBA IHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OnByb2Nlc3NpbmdJbnN0cnVjdGlvbihjb25zdCB4bWxD aGFyKiB0YXJnZXQsIGNvbnN0IHhtbENoCiAKIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmNkYXRh QmxvY2soY29uc3QgeG1sQ2hhciogcywgaW50IGxlbikKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9w cGVkKQorICAgIGlmIChpc1N0b3BwZWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1f cGFyc2VyUGF1c2VkKSB7CkBAIC05OTcsNyArOTk3LDcgQEAgdm9pZCBYTUxEb2N1bWVudFBhcnNl cjo6Y2RhdGFCbG9jayhjb25zdCB4bWxDaGFyKiBzLCBpbnQgbGVuKQogCiB2b2lkIFhNTERvY3Vt ZW50UGFyc2VyOjpjb21tZW50KGNvbnN0IHhtbENoYXIqIHMpCiB7Ci0gICAgaWYgKG1fcGFyc2Vy U3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlm IChtX3BhcnNlclBhdXNlZCkgewpAQCAtMTAzNCw3ICsxMDM0LDcgQEAgdm9pZCBYTUxEb2N1bWVu dFBhcnNlcjo6ZW5kRG9jdW1lbnQoKQogCiB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjppbnRlcm5h bFN1YnNldChjb25zdCB4bWxDaGFyKiBuYW1lLCBjb25zdCB4bWxDaGFyKiBleHRlcm5hbElELCBj b25zdCB4bWxDaGFyKiBzeXN0ZW1JRCkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVkKQorICAg IGlmIChpc1N0b3BwZWQoKSkKICAgICAgICAgcmV0dXJuOwogCiAgICAgaWYgKG1fcGFyc2VyUGF1 c2VkKSB7CkBAIC0xMjk0LDcgKzEyOTQsNyBAQCB2b2lkIFhNTERvY3VtZW50UGFyc2VyOjppbml0 aWFsaXplUGFyc2VyQ29udGV4dChjb25zdCBjaGFyKiBjaHVuaykKICAgICBzYXguaWdub3JhYmxl V2hpdGVzcGFjZSA9IGlnbm9yYWJsZVdoaXRlc3BhY2VIYW5kbGVyOwogICAgIHNheC5lbnRpdHlE ZWNsID0geG1sU0FYMkVudGl0eURlY2w7CiAgICAgc2F4LmluaXRpYWxpemVkID0gWE1MX1NBWDJf TUFHSUM7Ci0gICAgbV9wYXJzZXJTdG9wcGVkID0gZmFsc2U7CisgICAgRG9jdW1lbnRQYXJzZXI6 OnN0YXJ0UGFyc2luZygpOwogICAgIG1fc2F3RXJyb3IgPSBmYWxzZTsKICAgICBtX3Nhd1hTTFRy YW5zZm9ybSA9IGZhbHNlOwogICAgIG1fc2F3Rmlyc3RFbGVtZW50ID0gZmFsc2U7CkBAIC0xMzE4 LDExICsxMzE4LDExIEBAIHZvaWQgWE1MRG9jdW1lbnRQYXJzZXI6OmRvRW5kKCkKICAgICAgICAg ZG9jdW1lbnQoKS0+c2V0UGFyc2luZyhmYWxzZSk7IC8vIE1ha2UgdGhlIGRvYyB0aGluayBpdCdz IGRvbmUsIHNvIGl0IHdpbGwgYXBwbHkgeHNsIHNoZWV0cy4KICAgICAgICAgZG9jdW1lbnQoKS0+ c3R5bGVTZWxlY3RvckNoYW5nZWQoUmVjYWxjU3R5bGVJbW1lZGlhdGVseSk7CiAgICAgICAgIGRv Y3VtZW50KCktPnNldFBhcnNpbmcodHJ1ZSk7Ci0gICAgICAgIG1fcGFyc2VyU3RvcHBlZCA9IHRy dWU7CisgICAgICAgIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2luZygpOwogICAgIH0KICNlbmRp ZgogCi0gICAgaWYgKG1fcGFyc2VyU3RvcHBlZCkKKyAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAg ICAgIHJldHVybjsKIAogICAgIGlmIChtX2NvbnRleHQpIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZG9tL1hNTERvY3VtZW50UGFyc2VyUXQuY3BwIGIvV2ViQ29yZS9kb20vWE1MRG9jdW1lbnRQYXJz ZXJRdC5jcHAKaW5kZXggZGZkNmZiMTkyYjhkY2I1YmY3MDI4ZDRlN2Q2NjJlNzhmY2UzNzRiYi4u NTliYjk0YzU5MjYwYmI0MDQxMWZiODUwOGY1YzM4OTNjYWRiYTBjMCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9kb20vWE1MRG9jdW1lbnRQYXJzZXJRdC5jcHAKKysrIGIvV2ViQ29yZS9kb20vWE1MRG9j dW1lbnRQYXJzZXJRdC5jcHAKQEAgLTE5OSw3ICsxOTksNyBAQCB2b2lkIFhNTERvY3VtZW50UGFy c2VyOjpkb1dyaXRlKGNvbnN0IFN0cmluZyYgcGFyc2VTdHJpbmcpCiAKIHZvaWQgWE1MRG9jdW1l bnRQYXJzZXI6OmluaXRpYWxpemVQYXJzZXJDb250ZXh0KGNvbnN0IGNoYXIqKQogewotICAgIG1f cGFyc2VyU3RvcHBlZCA9IGZhbHNlOworICAgIERvY3VtZW50UGFyc2VyOjpzdG9wUGFyc2luZygp OwogICAgIG1fc2F3RXJyb3IgPSBmYWxzZTsKICAgICBtX3Nhd1hTTFRyYW5zZm9ybSA9IGZhbHNl OwogICAgIG1fc2F3Rmlyc3RFbGVtZW50ID0gZmFsc2U7CkBAIC0yMTMsNyArMjEzLDcgQEAgdm9p ZCBYTUxEb2N1bWVudFBhcnNlcjo6ZG9FbmQoKQogICAgICAgICBkb2N1bWVudCgpLT5zZXRQYXJz aW5nKGZhbHNlKTsgLy8gTWFrZSB0aGUgZG9jIHRoaW5rIGl0J3MgZG9uZSwgc28gaXQgd2lsbCBh cHBseSB4c2wgc2hlZXRzLgogICAgICAgICBkb2N1bWVudCgpLT5zdHlsZVNlbGVjdG9yQ2hhbmdl ZChSZWNhbGNTdHlsZUltbWVkaWF0ZWx5KTsKICAgICAgICAgZG9jdW1lbnQoKS0+c2V0UGFyc2lu Zyh0cnVlKTsKLSAgICAgICAgbV9wYXJzZXJTdG9wcGVkID0gdHJ1ZTsKKyAgICAgICAgRG9jdW1l bnRQYXJzZXI6OnN0YXJ0UGFyc2luZygpOwogICAgIH0KICNlbmRpZgogCkBAIC0zNTAsNyArMzUw LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGhhbmRsZUVsZW1lbnRBdHRyaWJ1dGVzKEVsZW1lbnQq IG5ld0VsZW1lbnQsIGNvbnN0IFFYbWxTdHJlYW0KIAogdm9pZCBYTUxEb2N1bWVudFBhcnNlcjo6 cGFyc2UoKQogewotICAgIHdoaWxlICghbV9wYXJzZXJTdG9wcGVkICYmICFtX3BhcnNlclBhdXNl ZCAmJiAhbV9zdHJlYW0uYXRFbmQoKSkgeworICAgIHdoaWxlICghaXNTdG9wcGVkKCkgJiYgIW1f cGFyc2VyUGF1c2VkICYmICFtX3N0cmVhbS5hdEVuZCgpKSB7CiAgICAgICAgIG1fc3RyZWFtLnJl YWROZXh0KCk7CiAgICAgICAgIHN3aXRjaCAobV9zdHJlYW0udG9rZW5UeXBlKCkpIHsKICAgICAg ICAgY2FzZSBRWG1sU3RyZWFtUmVhZGVyOjpTdGFydERvY3VtZW50OiB7CmRpZmYgLS1naXQgYS9X ZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAgYi9XZWJDb3JlL2h0bWwv cGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5jcHAKaW5kZXggMjA3YmQzZTYzMjAwYjQ2MTI2Y2Qy ODA2NGY2MmNiNjYxNDI3YmRiMi4uOTc1ZmNiODdhZDBhMTYyZTIwNTc5YzZhZWZlMDNjNmFkYmI5 YTk1MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MRG9jdW1lbnRQYXJzZXIu Y3BwCisrKyBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmNwcApAQCAt MTQyLDYgKzE0MiwyOCBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6c3RvcFBhcnNpbmcoKQog ICAgIG1fcGFyc2VyU2NoZWR1bGVyLmNsZWFyKCk7IC8vIERlbGV0aW5nIHRoZSBzY2hlZHVsZXIg d2lsbCBjbGVhciBhbnkgdGltZXJzLgogfQogCisvLyBUaGlzIGtpY2tzIG9mZiAiT25jZSB0aGUg dXNlciBhZ2VudCBzdG9wcyBwYXJzaW5nIiBhcyBkZXNjcmliZWQgYnk6CisvLyBodHRwOi8vd3d3 LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrL211bHRpcGFnZS90aGUtZW5k Lmh0bWwjdGhlLWVuZAordm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVUb1N0b3BQYXJz aW5nKCkKK3sKKyAgICBBU1NFUlQoIWhhc0luc2VydGlvblBvaW50KCkpOworCisgICAgLy8gcHVt cFRva2VuaXplciBjYW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUg RG9jdW1lbnQsCisgICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0IGlzbid0IGRlbGV0ZWQg eWV0LgorICAgIFJlZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3RlY3QodGhpcyk7CisKKyAg ICAvLyBGSVhNRTogU2V0IHRoZSBjdXJyZW50IGRvY3VtZW50IHJlYWRpbmVzcyB0byAiaW50ZXJh Y3RpdmUiLgorCisgICAgLy8gTk9URTogVGhpcyBwdW1wIHNob3VsZCBvbmx5IGV2ZXIgZW1pdCBi dWZmZXJlZCBjaGFyYWN0ZXIgdG9rZW5zLAorICAgIC8vIHNvIEZvcmNlU3luY2hyb25vdXMgdnMu IEFsbG93WWllbGQgc2hvdWxkIGJlIG1lYW5pbmdsZXNzLgorICAgIHB1bXBUb2tlbml6ZXJJZlBv c3NpYmxlKEZvcmNlU3luY2hyb25vdXMpOworCisgICAgRG9jdW1lbnRQYXJzZXI6OnByZXBhcmVU b1N0b3BQYXJzaW5nKCk7CisgICAgaWYgKG1fc2NyaXB0UnVubmVyICYmICFtX3NjcmlwdFJ1bm5l ci0+ZXhlY3V0ZVNjcmlwdHNXYWl0aW5nRm9yUGFyc2luZygpKQorICAgICAgICByZXR1cm47Cisg ICAgZW5kKCk7Cit9CisKIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpwcm9jZXNzaW5nRGF0YSgp IGNvbnN0CiB7CiAgICAgcmV0dXJuIGlzU2NoZWR1bGVkRm9yUmVzdW1lKCkgfHwgaW5Xcml0ZSgp OwpAQCAtMTQ5LDcgKzE3MSw3IEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpwcm9jZXNzaW5n RGF0YSgpIGNvbnN0CiAKIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9rZW5pemVySWZQ b3NzaWJsZShTeW5jaHJvbm91c01vZGUgbW9kZSkKIHsKLSAgICBpZiAobV9wYXJzZXJTdG9wcGVk IHx8IG1fdHJlZUJ1aWxkZXItPmlzUGF1c2VkKCkpCisgICAgaWYgKGlzU3RvcHBlZCgpIHx8IG1f dHJlZUJ1aWxkZXItPmlzUGF1c2VkKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIC8vIE9uY2Ug YSByZXN1bWUgaXMgc2NoZWR1bGVkLCBIVE1MUGFyc2VyU2NoZWR1bGVyIGNvbnRyb2xzIHdoZW4g d2UgbmV4dCBwdW1wLgpAQCAtMTkzLDggKzIxNSw3IEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2Vy OjpydW5TY3JpcHRzRm9yUGF1c2VkVHJlZUJ1aWxkZXIoKQogCiB2b2lkIEhUTUxEb2N1bWVudFBh cnNlcjo6cHVtcFRva2VuaXplcihTeW5jaHJvbm91c01vZGUgbW9kZSkKIHsKLSAgICBBU1NFUlQo IWlzRGV0YWNoZWQoKSk7Ci0gICAgQVNTRVJUKCFtX3BhcnNlclN0b3BwZWQpOworICAgIEFTU0VS VCghaXNTdG9wcGVkKCkpOwogICAgIEFTU0VSVCghbV90cmVlQnVpbGRlci0+aXNQYXVzZWQoKSk7 CiAgICAgQVNTRVJUKCFpc1NjaGVkdWxlZEZvclJlc3VtZSgpKTsKICAgICAvLyBBU1NFUlQgdGhh dCB0aGlzIG9iamVjdCBpcyBib3RoIGF0dGFjaGVkIHRvIHRoZSBEb2N1bWVudCBhbmQgcHJvdGVj dGVkLgpAQCAtMjE0LDcgKzIzNSw3IEBAIHZvaWQgSFRNTERvY3VtZW50UGFyc2VyOjpwdW1wVG9r ZW5pemVyKFN5bmNocm9ub3VzTW9kZSBtb2RlKQogICAgICAgICBtX3Rva2VuLmNsZWFyKCk7CiAK ICAgICAgICAgLy8gSmF2YVNjcmlwdCBtYXkgaGF2ZSBzdG9wcGVkIG9yIGRldGFjaGVkIHRoZSBw YXJzZXIuCi0gICAgICAgIGlmIChpc0RldGFjaGVkKCkgfHwgbV9wYXJzZXJTdG9wcGVkKQorICAg ICAgICBpZiAoaXNTdG9wcGVkKCkpCiAgICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAgLy8g VGhlIHBhcnNlciB3aWxsIHBhdXNlIGl0c2VsZiB3aGVuIHdhaXRpbmcgb24gYSBzY3JpcHQgdG8g bG9hZCBvciBydW4uCkBAIC0yMjYsNyArMjQ3LDcgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6 OnB1bXBUb2tlbml6ZXIoU3luY2hyb25vdXNNb2RlIG1vZGUpCiAgICAgICAgIG1fdHJlZUJ1aWxk ZXItPnNldFBhdXNlZCghc2hvdWxkQ29udGludWVQYXJzaW5nKTsKIAogICAgICAgICAvLyBKYXZh U2NyaXB0IG1heSBoYXZlIHN0b3BwZWQgb3IgZGV0YWNoZWQgdGhlIHBhcnNlci4KLSAgICAgICAg aWYgKGlzRGV0YWNoZWQoKSB8fCBtX3BhcnNlclN0b3BwZWQpCisgICAgICAgIGlmIChpc1N0b3Bw ZWQoKSkKICAgICAgICAgICAgIHJldHVybjsKIAogICAgICAgICBpZiAoIXNob3VsZENvbnRpbnVl UGFyc2luZykKQEAgLTI3NSw3ICsyOTYsNyBAQCBib29sIEhUTUxEb2N1bWVudFBhcnNlcjo6aGFz SW5zZXJ0aW9uUG9pbnQoKQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6aW5zZXJ0KGNvbnN0 IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogewotICAgIGlmIChtX3BhcnNlclN0b3BwZWQpCisg ICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICAvLyBwdW1wVG9rZW5p emVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVu dCwKQEAgLTI5Niw3ICszMTcsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6aW5zZXJ0KGNv bnN0IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogCiB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6 YXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmluZyYgc291cmNlKQogewotICAgIGlmIChtX3BhcnNl clN0b3BwZWQpCisgICAgaWYgKGlzU3RvcHBlZCgpKQogICAgICAgICByZXR1cm47CiAKICAgICAv LyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlzIHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9t IHRoZSBEb2N1bWVudCwKQEAgLTMyOCwxNCArMzQ5LDYgQEAgdm9pZCBIVE1MRG9jdW1lbnRQYXJz ZXI6OmVuZCgpCiAgICAgQVNTRVJUKCFpc0RldGFjaGVkKCkpOwogICAgIEFTU0VSVCghaXNTY2hl ZHVsZWRGb3JSZXN1bWUoKSk7CiAKLSAgICAvLyBwdW1wVG9rZW5pemVyIGNhbiBjYXVzZSB0aGlz IHBhcnNlciB0byBiZSBkZXRhY2hlZCBmcm9tIHRoZSBEb2N1bWVudCwKLSAgICAvLyBidXQgd2Ug bmVlZCB0byBlbnN1cmUgaXQgaXNuJ3QgZGVsZXRlZCB5ZXQuCi0gICAgUmVmUHRyPEhUTUxEb2N1 bWVudFBhcnNlcj4gcHJvdGVjdCh0aGlzKTsKLQotICAgIC8vIE5PVEU6IFRoaXMgcHVtcCBzaG91 bGQgb25seSBldmVyIGVtaXQgYnVmZmVyZWQgY2hhcmFjdGVyIHRva2VucywKLSAgICAvLyBzbyBG b3JjZVN5bmNocm9ub3VzIHZzLiBBbGxvd1lpZWxkIHNob3VsZCBiZSBtZWFuaW5nbGVzcy4KLSAg ICBwdW1wVG9rZW5pemVySWZQb3NzaWJsZShGb3JjZVN5bmNocm9ub3VzKTsKLQogICAgIC8vIElu Zm9ybXMgdGhlIHRoZSByZXN0IG9mIFdlYkNvcmUgdGhhdCBwYXJzaW5nIGlzIHJlYWxseSBmaW5p c2hlZCAoYW5kIGRlbGV0ZXMgdGhpcykuCiAgICAgbV90cmVlQnVpbGRlci0+ZmluaXNoZWQoKTsK IH0KQEAgLTM0OSw3ICszNjIsNyBAQCB2b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6YXR0ZW1wdFRv RW5kKCkKICAgICAgICAgbV9lbmRXYXNEZWxheWVkID0gdHJ1ZTsKICAgICAgICAgcmV0dXJuOwog ICAgIH0KLSAgICBlbmQoKTsKKyAgICBwcmVwYXJlVG9TdG9wUGFyc2luZygpOwogfQogCiB2b2lk IEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKQEAgLTM2Miw3ICszNzUsNyBAQCB2 b2lkIEhUTUxEb2N1bWVudFBhcnNlcjo6ZW5kSWZEZWxheWVkKCkKICAgICAgICAgcmV0dXJuOwog CiAgICAgbV9lbmRXYXNEZWxheWVkID0gZmFsc2U7Ci0gICAgZW5kKCk7CisgICAgcHJlcGFyZVRv U3RvcFBhcnNpbmcoKTsKIH0KIAogdm9pZCBIVE1MRG9jdW1lbnRQYXJzZXI6OmZpbmlzaCgpCkBA IC00NDcsNiArNDYwLDExIEBAIGJvb2wgSFRNTERvY3VtZW50UGFyc2VyOjpzaG91bGRMb2FkRXh0 ZXJuYWxTY3JpcHRGcm9tU3JjKGNvbnN0IEF0b21pY1N0cmluZyYgc3JjCiAKIHZvaWQgSFRNTERv Y3VtZW50UGFyc2VyOjpub3RpZnlGaW5pc2hlZChDYWNoZWRSZXNvdXJjZSogY2FjaGVkUmVzb3Vy Y2UpCiB7CisgICAgaWYgKGlzU3RvcHBpbmcoKSkgeworICAgICAgICBwcmVwYXJlVG9TdG9wUGFy c2luZygpOworICAgICAgICByZXR1cm47CisgICAgfQorCiAgICAgLy8gcHVtcFRva2VuaXplciBj YW4gY2F1c2UgdGhpcyBwYXJzZXIgdG8gYmUgZGV0YWNoZWQgZnJvbSB0aGUgRG9jdW1lbnQsCiAg ICAgLy8gYnV0IHdlIG5lZWQgdG8gZW5zdXJlIGl0IGlzbid0IGRlbGV0ZWQgeWV0LgogICAgIFJl ZlB0cjxIVE1MRG9jdW1lbnRQYXJzZXI+IHByb3RlY3QodGhpcyk7CmRpZmYgLS1naXQgYS9XZWJD b3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5oIGIvV2ViQ29yZS9odG1sL3BhcnNl ci9IVE1MRG9jdW1lbnRQYXJzZXIuaAppbmRleCBkYTIxYTJiYTExNGUyMDAyYmRlMjRmY2FmMzll ZDA5ZGJiNTE5ZGMxLi5hMzJiNDM5NmQzOWNkMDA2NWJhZmQ2NDJlZDYyNTQyZDgwZWZlOWJjIDEw MDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvcGFyc2VyL0hUTUxEb2N1bWVudFBhcnNlci5oCisrKyBi L1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTERvY3VtZW50UGFyc2VyLmgKQEAgLTgxLDYgKzgxLDcg QEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgYXBwZW5kKGNvbnN0IFNlZ21lbnRlZFN0cmlu ZyYpOwogICAgIHZpcnR1YWwgYm9vbCBmaW5pc2hXYXNDYWxsZWQoKTsKICAgICB2aXJ0dWFsIGJv b2wgcHJvY2Vzc2luZ0RhdGEoKSBjb25zdDsKKyAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVRvU3Rv cFBhcnNpbmcoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RvcFBhcnNpbmcoKTsKICAgICB2aXJ0dWFs IGJvb2wgaXNXYWl0aW5nRm9yU2NyaXB0cygpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0V4 ZWN1dGluZ1NjcmlwdCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL3BhcnNlci9I VE1MU2NyaXB0UnVubmVyLmNwcCBiL1dlYkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5l ci5jcHAKaW5kZXggNmQ0NzBhMGE1ZTA4YjQwZjY4YTE4MzVhZjUxODg5MmI4Y2E1YmIxOS4uNzY0 YmYwMWE4ZDcxYzcxNjdhY2ZhZTJkMjE4ZmM2MGM4ZDJmMmE3NyAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmNwcAorKysgYi9XZWJDb3JlL2h0bWwvcGFy c2VyL0hUTUxTY3JpcHRSdW5uZXIuY3BwCkBAIC03NSw2ICs3NSwxMiBAQCBIVE1MU2NyaXB0UnVu bmVyOjp+SFRNTFNjcmlwdFJ1bm5lcigpCiAgICAgLy8gRklYTUU6IFNob3VsZCB3ZSBiZSBwYXNz ZWQgYSAiZG9uZSBsb2FkaW5nL3BhcnNpbmciIGNhbGxiYWNrIHNvb25lciB0aGFuIGRlc3RydWN0 aW9uPwogICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBt X3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKICAgICAgICAgc3RvcFdh dGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7CisKKyAgICB3aGlsZSAoIW1f c2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5pc0VtcHR5KCkpIHsKKyAgICAgICAgUGVuZGlu Z1NjcmlwdCBwZW5kaW5nU2NyaXB0ID0gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLnRh a2VGaXJzdCgpOworICAgICAgICBpZiAocGVuZGluZ1NjcmlwdC5jYWNoZWRTY3JpcHQoKSAmJiBw ZW5kaW5nU2NyaXB0LndhdGNoaW5nRm9yTG9hZCgpKQorICAgICAgICAgICAgc3RvcFdhdGNoaW5n Rm9yTG9hZChwZW5kaW5nU2NyaXB0KTsKKyAgICB9CiB9CiAKIHZvaWQgSFRNTFNjcmlwdFJ1bm5l cjo6ZGV0YWNoKCkKQEAgLTEyOSwxMCArMTM1LDYgQEAgdm9pZCBIVE1MU2NyaXB0UnVubmVyOjpl eGVjdXRlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkKICAgICBBU1NFUlQobV9kb2N1bWVudC0+aGF2 ZVN0eWxlc2hlZXRzTG9hZGVkKCkpOwogICAgIEFTU0VSVChpc1BlbmRpbmdTY3JpcHRSZWFkeSht X3BhcnNpbmdCbG9ja2luZ1NjcmlwdCkpOwogCi0gICAgLy8gU3RvcCB3YXRjaGluZyBsb2FkcyBi ZWZvcmUgZXhlY3V0ZVNjcmlwdCB0byBwcmV2ZW50IHJlY3Vyc2lvbiBpZiB0aGUgc2NyaXB0IHJl bG9hZHMgaXRzZWxmLgotICAgIGlmIChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC5jYWNoZWRTY3Jp cHQoKSAmJiBtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKLSAgICAg ICAgc3RvcFdhdGNoaW5nRm9yTG9hZChtX3BhcnNpbmdCbG9ja2luZ1NjcmlwdCk7Ci0KICAgICBJ bnNlcnRpb25Qb2ludFJlY29yZCBpbnNlcnRpb25Qb2ludFJlY29yZChtX2hvc3QtPmlucHV0U3Ry ZWFtKCkpOwogICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChtX3BhcnNp bmdCbG9ja2luZ1NjcmlwdCk7CiB9CkBAIC0xNDIsNiArMTQ0LDEwIEBAIHZvaWQgSFRNTFNjcmlw dFJ1bm5lcjo6ZXhlY3V0ZVBlbmRpbmdTY3JpcHRBbmREaXNwYXRjaEV2ZW50KFBlbmRpbmdTY3Jp cHQmIHBlbmRpCiAgICAgYm9vbCBlcnJvck9jY3VycmVkID0gZmFsc2U7CiAgICAgU2NyaXB0U291 cmNlQ29kZSBzb3VyY2VDb2RlID0gc291cmNlRnJvbVBlbmRpbmdTY3JpcHQocGVuZGluZ1Njcmlw dCwgZXJyb3JPY2N1cnJlZCk7CiAKKyAgICAvLyBTdG9wIHdhdGNoaW5nIGxvYWRzIGJlZm9yZSBl eGVjdXRlU2NyaXB0IHRvIHByZXZlbnQgcmVjdXJzaW9uIGlmIHRoZSBzY3JpcHQgcmVsb2FkcyBp dHNlbGYuCisgICAgaWYgKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2NyaXB0KCkgJiYgcGVuZGluZ1Nj cmlwdC53YXRjaGluZ0ZvckxvYWQoKSkKKyAgICAgICAgc3RvcFdhdGNoaW5nRm9yTG9hZChwZW5k aW5nU2NyaXB0KTsKKwogICAgIC8vIENsZWFyIHRoZSBwZW5kaW5nIHNjcmlwdCBiZWZvcmUgcG9z c2libGUgcmVudHJhbmN5IGZyb20gZXhlY3V0ZVNjcmlwdCgpCiAgICAgUmVmUHRyPEVsZW1lbnQ+ IHNjcmlwdEVsZW1lbnQgPSBwZW5kaW5nU2NyaXB0LnJlbGVhc2VFbGVtZW50QW5kQ2xlYXIoKTsK ICAgICB7CkBAIC0yMzgsNiArMjQ0LDI0IEBAIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6ZXhlY3V0 ZVNjcmlwdHNXYWl0aW5nRm9yU3R5bGVzaGVldHMoKQogICAgIHJldHVybiBleGVjdXRlUGFyc2lu Z0Jsb2NraW5nU2NyaXB0cygpOwogfQogCitib29sIEhUTUxTY3JpcHRSdW5uZXI6OmV4ZWN1dGVT Y3JpcHRzV2FpdGluZ0ZvclBhcnNpbmcoKQoreworICAgIHdoaWxlICghbV9zY3JpcHRzVG9FeGVj dXRlQWZ0ZXJQYXJzaW5nLmlzRW1wdHkoKSkgeworICAgICAgICBBU1NFUlQoIW1fc2NyaXB0TmVz dGluZ0xldmVsKTsKKyAgICAgICAgQVNTRVJUKCFoYXZlUGFyc2luZ0Jsb2NraW5nU2NyaXB0KCkp OworICAgICAgICBBU1NFUlQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0KCku Y2FjaGVkU2NyaXB0KCkpOworICAgICAgICBpZiAoIW1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFy c2luZy5maXJzdCgpLmNhY2hlZFNjcmlwdCgpLT5pc0xvYWRlZCgpKSB7CisgICAgICAgICAgICB3 YXRjaEZvckxvYWQobV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nLmZpcnN0KCkpOworICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisgICAgICAgIFBlbmRpbmdTY3JpcHQg Zmlyc3QgPSBtX3NjcmlwdHNUb0V4ZWN1dGVBZnRlclBhcnNpbmcudGFrZUZpcnN0KCk7CisgICAg ICAgIGV4ZWN1dGVQZW5kaW5nU2NyaXB0QW5kRGlzcGF0Y2hFdmVudChmaXJzdCk7CisgICAgICAg IGlmICghbV9kb2N1bWVudCkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAg cmV0dXJuIHRydWU7Cit9CisKIHZvaWQgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBhcnNpbmdC bG9ja2luZ1NjcmlwdChFbGVtZW50KiBlbGVtZW50KQogewogICAgIGlmICghcmVxdWVzdFBlbmRp bmdTY3JpcHQobV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQsIGVsZW1lbnQpKQpAQCAtMjUyLDYgKzI3 NiwxNiBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJlcXVlc3RQYXJzaW5nQmxvY2tpbmdTY3Jp cHQoRWxlbWVudCogZWxlbWVudCkKICAgICAgICAgd2F0Y2hGb3JMb2FkKG1fcGFyc2luZ0Jsb2Nr aW5nU2NyaXB0KTsKIH0KIAordm9pZCBIVE1MU2NyaXB0UnVubmVyOjpyZXF1ZXN0RGVmZXJyZWRT Y3JpcHQoRWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBQZW5kaW5nU2NyaXB0IHBlbmRpbmdTY3Jp cHQ7CisgICAgaWYgKCFyZXF1ZXN0UGVuZGluZ1NjcmlwdChwZW5kaW5nU2NyaXB0LCBlbGVtZW50 KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQVNTRVJUKHBlbmRpbmdTY3JpcHQuY2FjaGVkU2Ny aXB0KCkpOworICAgIG1fc2NyaXB0c1RvRXhlY3V0ZUFmdGVyUGFyc2luZy5hcHBlbmQocGVuZGlu Z1NjcmlwdCk7Cit9CisKIGJvb2wgSFRNTFNjcmlwdFJ1bm5lcjo6cmVxdWVzdFBlbmRpbmdTY3Jp cHQoUGVuZGluZ1NjcmlwdCYgcGVuZGluZ1NjcmlwdCwgRWxlbWVudCogc2NyaXB0KSBjb25zdAog ewogICAgIEFTU0VSVCghcGVuZGluZ1NjcmlwdC5lbGVtZW50KCkpOwpAQCAtMjg3LDggKzMyMSwx MSBAQCB2b2lkIEhUTUxTY3JpcHRSdW5uZXI6OnJ1blNjcmlwdChFbGVtZW50KiBzY3JpcHQsIGlu dCBzdGFydGluZ0xpbmVOdW1iZXIpCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7IC8vIGV2ZW50 IGZvciBzdXBwb3J0CiAKICAgICAgICAgaWYgKHNjcmlwdC0+aGFzQXR0cmlidXRlKHNyY0F0dHIp KSB7Ci0gICAgICAgICAgICAvLyBGSVhNRTogSGFuZGxlIGRlZmVyIGFuZCBhc3luYwotICAgICAg ICAgICAgcmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChzY3JpcHQpOworICAgICAgICAgICAg Ly8gRklYTUU6IEhhbmRsZSBhc3luYy4KKyAgICAgICAgICAgIGlmIChzY3JpcHQtPmhhc0F0dHJp YnV0ZShkZWZlckF0dHIpKQorICAgICAgICAgICAgICAgIHJlcXVlc3REZWZlcnJlZFNjcmlwdChz Y3JpcHQpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHJlcXVlc3RQYXJzaW5n QmxvY2tpbmdTY3JpcHQoc2NyaXB0KTsKICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgIC8v IEZJWE1FOiBXZSBkbyBub3QgYmxvY2sgaW5saW5lIDxzY3JpcHQ+IHRhZ3Mgb24gc3R5bGVzaGVl dHMgdG8gbWF0Y2ggdGhlCiAgICAgICAgICAgICAvLyBvbGQgcGFyc2VyIGZvciBub3cuICBXaGVu IHdlIGRvLCB0aGUgQVNTRVJUIGJlbG93IHNob3VsZCBiZSBhZGRlZC4KZGlmZiAtLWdpdCBhL1dl YkNvcmUvaHRtbC9wYXJzZXIvSFRNTFNjcmlwdFJ1bm5lci5oIGIvV2ViQ29yZS9odG1sL3BhcnNl ci9IVE1MU2NyaXB0UnVubmVyLmgKaW5kZXggZWFkOTI4OTU0OWVjMTAyOGE2YTY5N2IyMTRjZTRl YTRjNjEwMDc5ZS4uNDdjOTZmZGJkNDE2ZDAzMWY5NWM2YzhmNjBhOTU3ZGJiMTQzNWUzMCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKKysrIGIvV2Vi Q29yZS9odG1sL3BhcnNlci9IVE1MU2NyaXB0UnVubmVyLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNk ZWZpbmUgSFRNTFNjcmlwdFJ1bm5lcl9oCiAKICNpbmNsdWRlICJQZW5kaW5nU2NyaXB0LmgiCisj aW5jbHVkZSA8d3RmL0RlcXVlLmg+CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5j bHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtNTYsNiArNTcsNyBAQCBwdWJsaWM6CiAgICAg Ym9vbCBleGVjdXRlU2NyaXB0c1dhaXRpbmdGb3JMb2FkKENhY2hlZFJlc291cmNlKik7CiAgICAg Ym9vbCBoYXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzKCkgY29uc3QgeyByZXR1cm4gbV9o YXNTY3JpcHRzV2FpdGluZ0ZvclN0eWxlc2hlZXRzOyB9CiAgICAgYm9vbCBleGVjdXRlU2NyaXB0 c1dhaXRpbmdGb3JTdHlsZXNoZWV0cygpOworICAgIGJvb2wgZXhlY3V0ZVNjcmlwdHNXYWl0aW5n Rm9yUGFyc2luZygpOwogCiAgICAgYm9vbCBpc0V4ZWN1dGluZ1NjcmlwdCgpIGNvbnN0IHsgcmV0 dXJuICEhbV9zY3JpcHROZXN0aW5nTGV2ZWw7IH0KIApAQCAtNzEsNiArNzMsNyBAQCBwcml2YXRl OgogICAgIGJvb2wgZXhlY3V0ZVBhcnNpbmdCbG9ja2luZ1NjcmlwdHMoKTsKIAogICAgIHZvaWQg cmVxdWVzdFBhcnNpbmdCbG9ja2luZ1NjcmlwdChFbGVtZW50Kik7CisgICAgdm9pZCByZXF1ZXN0 RGVmZXJyZWRTY3JpcHQoRWxlbWVudCopOwogICAgIGJvb2wgcmVxdWVzdFBlbmRpbmdTY3JpcHQo UGVuZGluZ1NjcmlwdCYsIEVsZW1lbnQqKSBjb25zdDsKIAogICAgIHZvaWQgcnVuU2NyaXB0KEVs ZW1lbnQqLCBpbnQgc3RhcnRpbmdMaW5lTnVtYmVyKTsKQEAgLTg0LDYgKzg3LDcgQEAgcHJpdmF0 ZToKICAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKICAgICBIVE1MU2NyaXB0UnVubmVySG9zdCog bV9ob3N0OwogICAgIFBlbmRpbmdTY3JpcHQgbV9wYXJzaW5nQmxvY2tpbmdTY3JpcHQ7CisgICAg RGVxdWU8UGVuZGluZ1NjcmlwdD4gbV9zY3JpcHRzVG9FeGVjdXRlQWZ0ZXJQYXJzaW5nOyAvLyBo dHRwOi8vd3d3LndoYXR3Zy5vcmcvc3BlY3Mvd2ViLWFwcHMvY3VycmVudC13b3JrLyNsaXN0LW9m LXNjcmlwdHMtdGhhdC13aWxsLWV4ZWN1dGUtd2hlbi10aGUtZG9jdW1lbnQtaGFzLWZpbmlzaGVk LXBhcnNpbmcKICAgICB1bnNpZ25lZCBtX3NjcmlwdE5lc3RpbmdMZXZlbDsKIAogICAgIC8vIFdl IG9ubHkgd2FudCBzdHlsZXNoZWV0IGxvYWRzIHRvIHRyaWdnZXIgc2NyaXB0IGV4ZWN1dGlvbiBp ZiBzY3JpcHQKZGlmZiAtLWdpdCBhL1dlYkNvcmUvbG9hZGVyL0ltYWdlRG9jdW1lbnQuY3BwIGIv V2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKaW5kZXggNzAyZWQ5ZDcwZDY1ZWViMzVm MWFhMWViMjQ4NjIzMTI1MzY2Zjc2YS4uY2MzYzg1Y2IxN2QxNDMyODViODQzZDExNzQ1YWJlZjAx NjA4YjIxOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKKysr IGIvV2ViQ29yZS9sb2FkZXIvSW1hZ2VEb2N1bWVudC5jcHAKQEAgLTEzOCw3ICsxMzgsNyBAQCB2 b2lkIEltYWdlRG9jdW1lbnRQYXJzZXI6OmFwcGVuZEJ5dGVzKERvY3VtZW50V3JpdGVyKiwgY29u c3QgY2hhciosIGludCwgYm9vbCkKIAogdm9pZCBJbWFnZURvY3VtZW50UGFyc2VyOjpmaW5pc2go KQogewotICAgIGlmICghbV9wYXJzZXJTdG9wcGVkICYmIGRvY3VtZW50KCktPmltYWdlRWxlbWVu dCgpKSB7CisgICAgaWYgKCFpc1N0b3BwZWQoKSAmJiBkb2N1bWVudCgpLT5pbWFnZUVsZW1lbnQo KSkgewogICAgICAgICBDYWNoZWRJbWFnZSogY2FjaGVkSW1hZ2UgPSBkb2N1bWVudCgpLT5jYWNo ZWRJbWFnZSgpOwogICAgICAgICBSZWZQdHI8U2hhcmVkQnVmZmVyPiBkYXRhID0gZG9jdW1lbnQo KS0+ZnJhbWUoKS0+bG9hZGVyKCktPmRvY3VtZW50TG9hZGVyKCktPm1haW5SZXNvdXJjZURhdGEo KTsKIAo=