20534 2008-08-26 17:45:58 -0700 DumpRenderTree needs a way to override settings on a per-test basis 2009-08-11 13:26:36 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 16482 20249 22806 1 eric dimich ap aroben dimich emacemac7 gwilson jshin mrowe sam zwarich oldest_to_newest 89435 0 eric 2008-08-26 17:45:58 -0700 DumpRenderTree needs a way to override settings on a per-test basis Something like this: if (window.layoutTestController) layoutTestController.overrideSetting("WhateverYourSettingName", "YES"); or this: if (window.settingsController) settingsController.overrideSetting("WhateverYourSettingName", "YES"); This would allow us to test all sorts of things that we can't today (maybe even disabling javascript!?). 89646 1 23056 gwilson 2008-08-28 09:26:29 -0700 Created attachment 23056 Possible patch to issue 20534 Here is a possible patch to this issue. There are some questions that still remain, however. This patch allows a layout test to override a default WebPreference value at test time. For instance: layoutTestController.overridePreference("WebKitJavaScriptEnabled", false); will turn javascript off for the rest of the test. Several decisions/observations I made: 1. To keep things simple, I only developed this patch to set or unset boolean flags. It would be possible to add other methods that set string or integer values, but it would either require IWebPreferences.idl to handle classes it probably shouldn't (CFPropertyListRef), or multiple methods in LayoutTestController to accept multiple input data types. Both of those options seemed less than appealing to me, but I'm hoping for feedback about what to do there. 2. Overriding the flag seems to only work once per layout test -- that is, you cannot disable javascript, try to do some javascript work, then re-enable javascript. I'm thinking that this is an effect of layoutTestController, and not the new overridePreference method. 3. The key values used in the call (i.e. "WebKitJavaScriptEnabled") are drawn directly from WebPreferences. So if there is a key in the dictionary with a boolean value set for it, then it can be set. I added multiple erroneous calls in the layout test to illustrate that passing bad input to overridePreference would not crash the test. What else should be done here? 89667 2 23056 eric 2008-08-28 12:53:29 -0700 Comment on attachment 23056 Possible patch to issue 20534 It would need to reset preferences after every test in order to be useful. Otherwise you run any test after this one, and they'll all fail. :) 89674 3 gwilson 2008-08-28 13:35:30 -0700 Aha, I see. I thought that the LayoutTestController reset the preferences automagically, but I was wrong. I'll upload another patch that does reset them after each test. 89718 4 23056 eric 2008-08-28 21:58:32 -0700 Comment on attachment 23056 Possible patch to issue 20534 r- due to corrupting other tests. Also, I'm not sure disabling JS is the best test. But I'm not sure I have a better suggestion atm. 89875 5 23105 gwilson 2008-09-01 15:34:23 -0700 Created attachment 23105 Possible patch to issue 20534 Ok, here's the patch with additional support for resetting default values after each test. Changes from earlier patch: 1. DumpRenderTree now calls a method on IWebPreferences called "resetToDefaults". 2. Added "resetToDefaults" method to WebPreferences. "resetToDefaults" will go through all of the preferences set in its internal dictionary and replace them with the default values, but _ONLY_ if some value was overridden. If no value was overridden, this method simply returns. 3. Changed overridePreference to take a string value instead of just boolean. Although starting simple with just boolean support seemed right initially, I didn't take into account that any positive string value (such as "true", "yes", "lfaijweofij") would be interpreted as true. Any empty value (such as false, 0, maybe ""?) would be interpreted as false. So this way, the method can now support overriding both boolean values and string values in the preferences. 4. More layout tests were added. One was added to test the overriding of string values. Another was added specifically to test that preferences were being reset after every value. But wait, there's more! WebPreferences resets after every test by default. But now you can also specifically override a flag to tell WebPreferences NOT to reset. That is: layoutTestController.overridePreference("WebKitDefaultPreferencesOverridden", false); will make WebPreferences think that it hasn't been overriden, and so it won't reset until you call: layoutTestController.overridePreference("WebKitDefaultPreferencesOverridden", true); This means that you can specifically override a preference in the first test of a long series of tests, tell the preferences not to reset after that test, then tell the preferences to reset after the last test needing the overrides. So you don't need to override the same preference over and over in a long line of tests. ....Whether this is useful or not is up for debate :) Thanks to Eric for his feedback on this! 90764 6 23105 gwilson 2008-09-10 08:53:05 -0700 Comment on attachment 23105 Possible patch to issue 20534 This patch is windows only... an improved patch is in the works... 90797 7 23328 gwilson 2008-09-10 14:17:04 -0700 Created attachment 23328 Improved possible patch to issue 20534 Here is a version of the patch that also provides Mac support. 91036 8 timothy 2008-09-13 06:53:20 -0700 (In reply to comment #5) > But wait, there's more! WebPreferences resets after every test by default. > But now you can also specifically override a flag to tell WebPreferences NOT to > reset. That is: > layoutTestController.overridePreference("WebKitDefaultPreferencesOverridden", > false); > will make WebPreferences think that it hasn't been overriden, and so it won't > reset until you call: > layoutTestController.overridePreference("WebKitDefaultPreferencesOverridden", > true); > > This means that you can specifically override a preference in the first test of > a long series of tests, tell the preferences not to reset after that test, then > tell the preferences to reset after the last test needing the overrides. So > you don't need to override the same preference over and over in a long line of > tests. ....Whether this is useful or not is up for debate :) I don't think we want this. I can lead to bad tests that can't be run individually. It is true that we run the tests mostly in order, but each test should also be able to run individually. Also if a new unsuspecting test is added in the future and ends up sorting in the middle of a group that has settings disabled, that would be a pain! 91037 9 timothy 2008-09-13 06:55:15 -0700 (In reply to comment #1) > This patch allows a layout test to override a default WebPreference value at > test time. For instance: > > layoutTestController.overridePreference("WebKitJavaScriptEnabled", false); > > will turn javascript off for the rest of the test. Are you sure this fully works? In general I think the pages needs to be reloaded to disable JavaScript (at least fully). 91038 10 23328 timothy 2008-09-13 06:59:31 -0700 Comment on attachment 23328 Improved possible patch to issue 20534 You can't change WebPreferences.h (Mac) since that is a public framework header. Any changes to those public headers need formal API review first. The correct change is to put things in WebPreferencesPrivate.h, until they can someday be made public. r- because of this. I didn't review the rest. 91423 11 23484 gwilson 2008-09-16 13:14:32 -0700 Created attachment 23484 Improved possible fix to bug 20534 I've modified this patch to have overridePreference and resetToDefaults in WebPreferencesPrivate instead of WebPreferences. re: testing...I thought it was a neat quirk of the patch, but now I can see that using it would probably be unwise, since all tests should be able to be run independently. Thanks for the review & the feedback! 92176 12 23484 eric 2008-09-22 13:24:32 -0700 Comment on attachment 23484 Improved possible fix to bug 20534 Looks fine. Glenn and I talked about possibly having DumpRenderTree maintain the state of whether the preferences were "overridden" instead of extending the preferences object to know this. DRT doesn't currently have a clean way for layout test controller to record this information, and there is some (small) possibility that some other client of preferences might want to be able to check if any preferences have been changed from the defaults or to reset to the defaults in an efficient way, so he's left that added functionality in the patch. There were a couple c-style casts which could have been static_cast, but not enough to justify another round of patch. 92227 13 23484 aroben 2008-09-22 15:50:53 -0700 Comment on attachment 23484 Improved possible fix to bug 20534 I think the new functions added to WebPreferences should have some explicit comments near their declarations stating more precisely what their purpose is (i.e., these are for DRT only). + CFStringRef keyref = CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(key), (CFIndex)_tcslen(key), kCFAllocatorMalloc); This string is being leaked. Passing in kCFAllocatorMalloc here is wrong. This will cause CF to call free(key) when keyref is finalized. + setStringValue(keyref, value); Indentation here looks funny. + BSTR val = stringValueForKey(static_cast<CFStringRef>(keys[i])); val is being leaked here. It also isn't used at all. + wstring wKey = jsStringRefToWString(key); + wstring wFlag = jsStringRefToWString(flag); + + BSTR keyBSTR = SysAllocStringLen((OLECHAR*)wKey.c_str(), wKey.length()); + BSTR flagBSTR = SysAllocStringLen((OLECHAR*)wFlag.c_str(), wFlag.length()); You can use JSStringCopyBSTR here (from JSStringRefBSTR.h) instead. r- so that the leaks and free() problem above can be fixed. 92228 14 23484 aroben 2008-09-22 15:52:36 -0700 Comment on attachment 23484 Improved possible fix to bug 20534 + CFStringRef keyref = CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(key), (CFIndex)_tcslen(key), kCFAllocatorMalloc); Also, that should be wcslen, not _tcslen. 92231 15 eric 2008-09-22 15:59:00 -0700 T(In reply to comment #14) > (From update of attachment 23484 [edit]) > + CFStringRef keyref = CFStringCreateWithCharactersNoCopy(0, > (UniChar*)_wcsdup(key), (CFIndex)_tcslen(key), kCFAllocatorMalloc); > > Also, that should be wcslen, not _tcslen. Thank you Adam for the review. 94605 16 24198 gwilson 2008-10-08 13:58:02 -0700 Created attachment 24198 Improved possible patch to issue 20534 Ok, the latest patch should clean up these issues. >I think the new functions added to WebPreferences should have some explicit >comments near their declarations stating more precisely what their purpose is >(i.e., these are for DRT only). Done, added comments to WebPreferences.h describing that these functions are used in DumpRenderTree testing only. >+ CFStringRef keyref = CFStringCreateWithCharactersNoCopy(0, >(UniChar*)_wcsdup(key), (CFIndex)_tcslen(key), kCFAllocatorMalloc); > >This string is being leaked. >Passing in kCFAllocatorMalloc here is wrong. This will cause CF to call >free(key) when keyref is finalized. Oops. I'll admit my ignorance about kCFAllocatorMalloc here. I've changed this to kCFAllocatorNull, since the caller should take care of the cleanup. I debated using kCFAllocatorDefault, but I didn't want WebPreferences to get overzealous in cleaning up memory it didn't allocate. I also changed one of the c-style casts to a static_cast. I tried changing both, by my compiler didn't know of a good cast between a wide character and an unsigned short. So I left this as a c-style cast for now (it is done this way elsewhere in WebPreferences). >+ setStringValue(keyref, value); > >Indentation here looks funny. Fixed this. >+ BSTR val = stringValueForKey(static_cast<CFStringRef>(keys[i])); > >val is being leaked here. It also isn't used at all. Yep, removed this. A remnant of another way I was looping through values here. >+ wstring wKey = jsStringRefToWString(key); >+ wstring wFlag = jsStringRefToWString(flag); >+ >+ BSTR keyBSTR = SysAllocStringLen((OLECHAR*)wKey.c_str(), wKey.length()); >+ BSTR flagBSTR = SysAllocStringLen((OLECHAR*)wFlag.c_str(), >wFlag.length()); > >You can use JSStringCopyBSTR here (from JSStringRefBSTR.h) instead. Aha -- that made this much easier than allocating more memory. I had to add an include for JSStringRefBSTR. Thanks for the review! 94607 17 24198 aroben 2008-10-08 14:10:30 -0700 Comment on attachment 24198 Improved possible patch to issue 20534 1190 CFStringRef keyref = CFStringCreateWithCharactersNoCopy(0, (UniChar*)_wcsdup(key), static_cast<CFIndex>(wcslen(key)), kCFAllocatorNull); You're leaking keyref. I also see now that you were using _wcsdup, so in fact kCFAllocatorMalloc was correct (sorry for misleading you!). But I think we should just let CF handle the memory allocation, like this: RetainPtr<CFStringRef> keyRef(AdoptCF, CFStringCreateWithCharacters(0, key, wcslen(key))); (This will also fix the leak of keyRef by putting RetainPtr in charge of releasing it). 1209 for (int i = 0; i < count; ++i) { 1210 setValueForKey(static_cast<CFStringRef>(keys[i]), values[i]); 1211 } The curly braces here should be removed. 323 // This method is meant for overriding preferences for tests run 324 // with DumpRenderTree only. 325 virtual HRESULT STDMETHODCALLTYPE overridePreference( 326 /* [in] */ BSTR key, 327 /* [in] */ BSTR value); 328 329 // This method is meant for resetting overridden preferences for tests run 330 // with DumpRenderTree only. 331 virtual HRESULT STDMETHODCALLTYPE resetToDefaults(); Thanks for adding these comments. You should also put them in IWebPreferencesPrivate.idl and WebPreferencesPrivate.h. 645 prefsPrivate->setAuthorAndUserStylesEnabled(TRUE); 646 prefsPrivate->resetToDefaults(); What is the effect of the call to resetToDefaults on setAuthorAndUserStylesEnabled? I think this is quite close! r- so that we can fix the remaining memory issues. Thanks for working on this! 94610 18 aroben 2008-10-08 14:12:02 -0700 (In reply to comment #16) > I also changed one of the c-style casts to a static_cast. I tried changing > both, by my compiler didn't know of a good cast between a wide character and an > unsigned short. I think reinterpret_cast is what you want for this. 94637 19 24204 gwilson 2008-10-08 16:16:20 -0700 Created attachment 24204 Improved possible patch to issue 20534 >You're leaking keyref. I also see now that you were using _wcsdup, so in fact >kCFAllocatorMalloc was correct (sorry for misleading you!). But I think we >should just let CF handle the memory allocation, like this: > >RetainPtr<CFStringRef> keyRef(AdoptCF, CFStringCreateWithCharacters(0, key, >wcslen(key))); > >(This will also fix the leak of keyRef by putting RetainPtr in charge of >releasing it). Ah, much easier this way :) I added the line you suggested with one change: a reinterpret_cast was necessary to cast the BSTR to UniChar*, so thanks for that tip! >The curly braces here should be removed. Removed. >Thanks for adding these comments. You should also put them in >IWebPreferencesPrivate.idl and WebPreferencesPrivate.h. Added the same comments to both places. I changed the previous style of comment that I used in WebPreferencesPrivate to the style the rest of the file used (just "//"s). The only other place I can see comments being useful is in all the LayoutTestController files, but I decided against it since the LayoutTestController is only for running tests anyway (...or is it?) >What is the effect of the call to resetToDefaults on >setAuthorAndUserStylesEnabled? Since the default is the same as what is being set on this line, the net effect is zero. *But* since the default for this setting could change in the future, I've flipped these lines so the reset call won't clobber this setting. The modified Mac version of DumpRenderTree works this way, so it makes sense for consistency. Thanks for your help!! 94737 20 24204 aroben 2008-10-09 06:57:51 -0700 Comment on attachment 24204 Improved possible patch to issue 20534 1060 [self _postPreferencesChangesNotification]; 1061 [self _setBoolValue:false forKey:WebKitDefaultPreferencesOverridden]; On Windows you perform these operations in the opposite order. Which one is better? 1190 RetainPtr<CFStringRef> keyRef(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast<UniChar*>(key), wcslen(key))); I just remembered that 0 is a valid BSTR. What should be our behavior when 0 is passed in? Currently I believe we will crash. Using SysStringLen instead of wcslen would help, but I don't think we should be passing 0 for the characters pointer to CFStringCreateWithCharacters. Probably we should just bail out with E_FAIL in this case. 335 controller->overridePreference(key.get(), JSValueToStringCopy(context, arguments[1], exception)); It looks like you're leaking the second parameter to overridePreference here. Sorry for not catching these on the last go-round. But once these are fixed we should be able to land this! 94751 21 24232 gwilson 2008-10-09 12:27:40 -0700 Created attachment 24232 Improved possible patch to issue 20534 >On Windows you perform these operations in the opposite order. Which one is >better? The way I was doing this on Windows is probably better, because it avoids a race condition. The changes notification should happen after the flag gets reset, so that any listeners who care about the flag being reset will see the correct state. So, I flipped these lines on the Mac implementation of this. > 1190 RetainPtr<CFStringRef> keyRef(AdoptCF, >CFStringCreateWithCharacters(0, reinterpret_cast<UniChar*>(key), wcslen(key))); > >I just remembered that 0 is a valid BSTR. What should be our behavior when 0 is >passed in? Currently I believe we will crash. Using SysStringLen instead of >wcslen would help, but I don't think we should be passing 0 for the characters >pointer to CFStringCreateWithCharacters. Probably we should just bail out with >E_FAIL in this case. So I'm not totally sure this is the right way to do this, but I added this check: if (!key || SysStringLen(key) == 0) return E_FAIL; I figured that the BSTR could be either 0 (like you said), or an empty string (the case in which it is non-zero but empty). So I added a bailout on either one, since we probably don't want empty string key. It doesn't seem to have this type of problem on the Mac version, since it just passes the pointer through...no allocation of memory needed. > 335 controller->overridePreference(key.get(), JSValueToStringCopy(context, >arguments[1], exception)); > >It looks like you're leaking the second parameter to overridePreference here. > Ah, yes...good catch. I got the key RetainPtr right, but not the value. This has been changed so both are made into RetainPtrs before being passed in. Please let me know if you find anything else that should be fixed! Thanks for all of your feedback. 94753 22 aroben 2008-10-09 12:43:20 -0700 (In reply to comment #21) > So I'm not totally sure this is the right way to do this, but I added this > check: > > if (!key || SysStringLen(key) == 0) > return E_FAIL; > > I figured that the BSTR could be either 0 (like you said), or an empty string > (the case in which it is non-zero but empty). So I added a bailout on either > one, since we probably don't want empty string key. Agreed, we should treat empty the same as null. Passing null to SysStringLen should work just fine, so the first half of your || isn't needed, but it's not terrible to thave it there, either. > It doesn't seem to have > this type of problem on the Mac version, since it just passes the pointer > through...no allocation of memory needed. Mac and Windows are doing the same thing here: DRT allocates the string, then passes a pointer to the string in to WebKit. So maybe Mac needs a similar check, or maybe not, depending on how the code handles null/empty strings. 94754 23 24232 aroben 2008-10-09 12:44:44 -0700 Comment on attachment 24232 Improved possible patch to issue 20534 1190 if (!key || SysStringLen(key) == 0) 1191 return E_FAIL; We prefer to use ! instead of ==0. We also need the same check for value. And as mentioned above, the null-check isn't necessary. 331 JSRetainPtr<JSStringRef> key(Adopt, JSValueToStringCopy(context, arguments[0], exception)); 332 ASSERT(!*exception); 333 JSRetainPtr<JSStringRef> value(Adopt, JSValueToStringCopy(context, arguments[1], exception)); If you're going to assert about one you should assert about both. So close! 94778 24 24237 gwilson 2008-10-09 14:44:50 -0700 Created attachment 24237 Improved possible patch to issue 20534 > 1190 if (!key || SysStringLen(key) == 0) > 1191 return E_FAIL; > >We prefer to use ! instead of ==0. We also need the same check for value. And >as mentioned above, the null-check isn't necessary. Changed. I added value to the check and used ! instead: if (!SysStringLen(key) || !SysStringLen(value)) return E_FAIL; > 331 JSRetainPtr<JSStringRef> key(Adopt, JSValueToStringCopy(context, >arguments[0], exception)); > 332 ASSERT(!*exception); > 333 JSRetainPtr<JSStringRef> value(Adopt, JSValueToStringCopy(context, >arguments[1], exception)); > >If you're going to assert about one you should assert about both. I wasn't sure whether it was better to try to assert twice (after trying to create each one), or just once after they're both attempted. I went with the former, since it is probably better not to try to create the JSStringRef to value if the creation of the JSStringRef to key failed. Other functions in this class use multiple asserts as well, so this should be consistent. Thanks! We're almost there, I think. 97605 25 jshin 2008-11-04 12:21:20 -0800 Adam, can you take a look at Glenn's latest patch? Thank you :-) 97609 26 24237 aroben 2008-11-04 12:55:02 -0800 Comment on attachment 24237 Improved possible patch to issue 20534 > +HRESULT STDMETHODCALLTYPE WebPreferences::overridePreference(BSTR key, BSTR value) > +{ > + if (!SysStringLen(key) || !SysStringLen(value)) > + return E_FAIL; > + RetainPtr<CFStringRef> keyRef(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast<UniChar*>(key), wcslen(key))); We should use SysStringLen instead of wcslen when dealing with BSTRs, since it is O(1) as opposed to O(n). r=me even if we keep using wcslen. If you upload a new version that uses SysStringLen I'll r+ that, too. Thanks for all the revisions! 97719 27 24915 gwilson 2008-11-05 11:41:56 -0800 Created attachment 24915 Possible fix for issue 20534 Here's a version with SysStringLen instead of wcslen. Thanks for going through all the revisions with me! 97723 28 24915 aroben 2008-11-05 12:32:26 -0800 Comment on attachment 24915 Possible fix for issue 20534 r=me 100041 29 fishd 2008-11-24 13:31:08 -0800 Glenn, please post an updated patch. This one no longer applies cleanly. 100233 30 25486 gwilson 2008-11-25 10:38:39 -0800 Created attachment 25486 An updated patch for 20534 Here is a revived version of this patch that should apply cleanly. It looks like the conflicts came from several new methods were added to IWebPreferencesPrivate, and the references to WebPreferencesPrivate in DumpRenderTree having been moved. Fortunately, this reduces the number of lines changed by this patch :) 100266 31 25486 aroben 2008-11-25 13:08:32 -0800 Comment on attachment 25486 An updated patch for 20534 > Index: WebKit/mac/ChangeLog > =================================================================== > --- WebKit/mac/ChangeLog (revision 37402) > +++ WebKit/mac/ChangeLog (working copy) > @@ -1,3 +1,16 @@ > +2008-10-08 Glenn Wilson <gwilson@google.com> > + > + Added new methods for overriding default WebPreference values > + and for resetting preferences to their defaults. (bug 20534) It would be nice to add the URL of the bug in here (and the other ChangeLogs), too. > + [preferences setEditableLinkBehavior:WebKitEditableLinkOnlyLiveWithShiftKey]; Why was this line added? I don't know why I didn't question it before! 100277 32 25496 gwilson 2008-11-25 13:54:22 -0800 Created attachment 25496 Improved possible patch for issue 20534 >> Why was this line added? I don't know why I didn't question it before! Strange. This line may have been part of the resetWebViewTo... method in the past, and was removed in a revision since the initial version of the patch. Or maybe a copy & paste error. Anyways, it shouldn't be in there, so I removed it. Good catch! Also, rather than just referring to the issue numbers in the ChangeLogs, I replaced them with links directly to the issues. Thanks for the review! 100294 33 25496 aroben 2008-11-25 14:21:56 -0800 Comment on attachment 25496 Improved possible patch for issue 20534 r=me 102252 34 eric 2008-12-11 11:12:46 -0800 Committing to http://svn.webkit.org/repository/webkit/trunk ... A LayoutTests/security/override-preferences-2-expected.txt A LayoutTests/security/override-preferences-2.html A LayoutTests/security/override-preferences-expected.txt A LayoutTests/security/override-preferences.html A LayoutTests/security/override-zzz-reset-expected.txt A LayoutTests/security/override-zzz-reset.html M WebKit/mac/ChangeLog M WebKit/mac/WebView/WebPreferenceKeysPrivate.h M WebKit/mac/WebView/WebPreferences.mm M WebKit/mac/WebView/WebPreferencesPrivate.h M WebKit/win/ChangeLog M WebKit/win/Interfaces/IWebPreferencesPrivate.idl M WebKit/win/WebPreferenceKeysPrivate.h M WebKit/win/WebPreferences.cpp M WebKit/win/WebPreferences.h M WebKitTools/ChangeLog M WebKitTools/DumpRenderTree/LayoutTestController.cpp M WebKitTools/DumpRenderTree/LayoutTestController.h M WebKitTools/DumpRenderTree/mac/DumpRenderTree.mm M WebKitTools/DumpRenderTree/mac/LayoutTestControllerMac.mm M WebKitTools/DumpRenderTree/win/DumpRenderTree.cpp M WebKitTools/DumpRenderTree/win/LayoutTestControllerWin.cpp Committed r39212 A couple issues in the commit. one of the changelogs was missing a bug url, added. Another one had the review not as the top-most line, fixed. 2 files had tabs in them (which causes the commit to fail), removed I saw some leaks reported when I ran the layout tests. I assumed those were not related to this patch, and landed anyway. If I'm wrong, I've got a roll-out ahead of me. :) Thanks for the patch! 102330 35 zwarich 2008-12-11 23:39:10 -0800 This patch was rolled out in r39277 because it caused many test failures and assertion failures. Also, calling init again from resetToDefaults is a pretty bad idea. 102602 36 25496 eric 2008-12-15 14:14:42 -0800 Comment on attachment 25496 Improved possible patch for issue 20534 r- this rolled out patch. 103850 37 26328 gwilson 2008-12-30 17:01:45 -0800 Created attachment 26328 Revised patch to issue 20534 Here is a revised patch that may address this issue. resetToDefaults in WebPreferences.mm was calling init, which is definitely bad. I didn't know what other interactions init would have, so hopefully I know better now. I modified resetToDefaults to work much like the Win version of WebPreferences...it gets a dictionary of all the default values, loops through each entry, and resets each key/value pair to the default. To do this, I had to break out the default dictionary into its own method that just returns the dict, and have "initialize" call this method. This seemed acceptable, since this is not an instance method, no interface changes were necessary. I didn't want to break it out, but using NSUserDefaults::standardUserDefaults as the default preference value 'repository' didn't seem to work. (Possibly because WebPreferences::initialize is never called when running layout tests?) Eric, I also tried to incorporate some of the cleanup you did elsewhere -- removing all the tabs I could find, including reviewer lines in ChangeLogs, etc. Let me know what others I missed so I can clean them up for later iterations. Thanks for the feedback, and let me know what else should be improved here. 104882 38 26524 gwilson 2009-01-08 09:12:08 -0800 Created attachment 26524 Improved patch to issue 20534 Here is an improved version of the previous patch. This version does not use Objective-C 2.0 behavior (specifically, for(in) loops) in WebPreferences. Eric and I were talking last night on IRC about a different approach to this patch -- specifically keeping all overridden values in a separate dictionary, so there is no risk of any overridden values being saved to disk. I'm hoping to experiment with this in another patch. 106399 39 26874 gwilson 2009-01-20 15:23:23 -0800 Created attachment 26874 Alternate patch to issue 20534 Here is an alternate patch to this that implements the ideas that Eric and I discussed a few weeks back. This patch adds a new dictionary to WebPreferencesPrivate that holds overridden values. When valueForKey looks to access a value, it first checks the overrides to see if there is an overridden value for this particular key. If so, it uses that key, if not, it goes about its normal business. overridePreference sets a value in this new dictionary, and resetToDefaults merely empties this new dictionary of all values. This version of the patch has several advantages over previous versions: - all overridden values are kept separate from default values. If there's ever a crash, these won't be saved anywhere - resetToDefaults and overridePreference are significantly simpler - it requires no flag-setting to indicate an overridden value Please take a look and let me know what can be improved! 108199 40 27296 gwilson 2009-02-03 15:57:28 -0800 Created attachment 27296 Alternate patch to issue 20534 Here's a modified version of the override preference patch that does not have any resetToDefault method in WebPreferences. Instead, this relies on DumpRenderTree to reset preferences properly between tests. DumpRenderTree.mm was setting preference values in two places -- setDefaultsToConsistentValueForTesting and also resetWebViewToConsistentState. setDefaults was being called once when DRT starts, and resetWebView between every test. Since each layout test assumes that its preferences should be set to their default 'testing' values when it is run, I consolidated all of the web preference resetting to setDefaults and changed resetWebView to call setDefaults. This patch assumes that if a preference is meant to have a default 'testing' value, it will always be reset in DumpRenderTree. Thus, if a preference is added in the future that will need to be reset between tests, setDefaults should be modified to reset the value of the preference. I originally wanted to destroy and re-create the instance of WebPreference between tests. This is equivalent to resetting the values to their 'testing state' and getting the rest of the preferences reset as a side effect. However, the preference values that should be used for testing can often be different than the default values in WebPreferences. Moreover, if a preference must have a default testing state, it should be clearly stated as such in DumpRenderTree::setDefaultsToConsistentValueForTesting. In short, I felt that just re-instantiating WebPreferences "hides" the desired 'testing state' of these preferences. What do you think? What can I improve? 108355 41 24237 eric 2009-02-04 15:47:30 -0800 Comment on attachment 24237 Improved possible patch to issue 20534 Silly bugzilla, clearing r+ to remove it from the commit queue. 108356 42 24915 eric 2009-02-04 15:47:40 -0800 Comment on attachment 24915 Possible fix for issue 20534 Silly bugzilla, clearing r+ to remove it from the commit queue. 114064 43 dimich 2009-03-17 11:00:32 -0700 *** Bug 22816 has been marked as a duplicate of this bug. *** 122557 44 27296 mjs 2009-05-21 23:16:30 -0700 Comment on attachment 27296 Alternate patch to issue 20534 One minor comment: +- (void)setPreference:(NSString *)key stringValue:(NSString *)value Private ObjC methods on API classes should start with an underscore. Otherwise looks good, assuming it doesn't break the tests now. Please resubmit with that minor change. 130921 45 32572 dimich 2009-07-10 12:44:41 -0700 Created attachment 32572 Fixed and cleaned patch. I'd like to help move it forward. I've merged the patch and changed the method naming per Maciej's suggestion. It runs all the tests fine (on Mac). 134333 46 dimich 2009-07-23 17:56:08 -0700 Glen and I talked and I'll take this to complete. I have a couple of tests I want to write which need a back-forward page cache enabled :-) This will allow to override preferences for a single test while not affecting thousands of others. I built it on Windows and found at least one issue. Removing r? for now, will prepare updated patch. 134758 47 33495 dimich 2009-07-25 13:34:08 -0700 Created attachment 33495 Hopefully the final cut. I think this can be the final version. I've fixed windows DRT to not break the tests following the one with changed preferences. Now both mac and windows versions of DRT have 'resetDefaultsToConsistentValues()' functin which is called before each test and initializes preferences to the regular DRT 'defaults'. I also moved all the initialization of such 'defaults' into this single function. Run tests on both mac and windows. On windows (Vista) not all tests pass for me even before this patch but at least the set of failed tests is the same before and after. 135954 48 33495 aroben 2009-07-30 13:01:27 -0700 Comment on attachment 33495 Hopefully the final cut. > + * security/override-preferences-2-expected.txt: > + * security/override-preferences-2.html: Verifies overridePreverence("WebKitDefaultFontSize", "24") > + * security/override-preferences-expected.txt: > + * security/override-preferences.html: Verifies overridePreference("WebKitJavaScriptEnabled", false). > + * security/override-zzz-reset-expected.txt: > + * security/override-zzz-reset.html: Because of 'zzz' this test will run after the tests above and > + verify that override of preferences does not 'spill' to the subsequent tests in a batch. The added tests are missing from this patch. security/ seems like a strange place to put them. Maybe we need a new directory for tests of the test harness? > +- (void)_setPreference:(NSString *)key stringValue:(NSString *)value > +{ > + NSString *_key = KEY(key); > + [self _setStringValue:value forKey:_key]; > +} This is wrong. _setStringValue:forKey: also passes the key through KEY(), so you'll end up with the preferences identifier prepended twice. _setPreference:stringValue: is not a very Cocoa-y name. The obvious name would be _setStringValue:forKey:. Maybe we should just expose that method through WebPreferencesPrivate.h? Or maybe we can come up with a name that indicates this is for testing purposes only. I don't think it's super-important to have similar names on Mac and Windows for this. > @@ -70,6 +70,10 @@ interface IWebPreferencesPrivate : IUnknown > HRESULT setFontSmoothingContrast([in] float contrast); > HRESULT fontSmoothingContrast([out, retval] float* contrast); > > + // This method is meant for overriding preferences for tests run > + // with DumpRenderTree only. > + HRESULT setPreference([in] BSTR key, [in] BSTR value); > + > HRESULT isWebSecurityEnabled([out, retval] BOOL* enabled); > HRESULT setWebSecurityEnabled([in] BOOL enabled); Please add the new function at the end of the interface, to avoid the risk of breaking nightly builds. > +HRESULT STDMETHODCALLTYPE WebPreferences::setPreference(BSTR key, BSTR value) > +{ There's no need to have STDMETHODCALLTYPE on the implementation. It's only needed on the declaration. > + LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject)); static_cast is preferable here. > +void LayoutTestController::overridePreference(JSStringRef key, JSStringRef flag) > +{ > + RetainPtr<CFStringRef> keyCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, key)); > + NSString *keyNS = (NSString *)keyCF.get(); > + > + RetainPtr<CFStringRef> flagCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, flag)); > + NSString *flagNS = (NSString *)flagCF.get(); I think we tend to use 0 instead of kCFAllocatorDefault, though either is fine. > +static void resetDefaultsToConsistentValues(IWebPreferences* preferences) > +{ > +#ifdef USE_MAC_FONTS > + BSTR standardFamily = SysAllocString(TEXT("Times")); > + BSTR fixedFamily = SysAllocString(TEXT("Courier")); > + BSTR sansSerifFamily = SysAllocString(TEXT("Helvetica")); > + BSTR cursiveFamily = SysAllocString(TEXT("Apple Chancery")); > + BSTR fantasyFamily = SysAllocString(TEXT("Papyrus")); > +#else > + BSTR standardFamily = SysAllocString(TEXT("Times New Roman")); > + BSTR fixedFamily = SysAllocString(TEXT("Courier New")); > + BSTR sansSerifFamily = SysAllocString(TEXT("Arial")); > + BSTR cursiveFamily = SysAllocString(TEXT("Comic Sans MS")); // Not actually cursive, but it's what IE and Firefox use. > + BSTR fantasyFamily = SysAllocString(TEXT("Times New Roman")); > +#endif > + > + preferences->setStandardFontFamily(standardFamily); > + preferences->setFixedFontFamily(fixedFamily); > + preferences->setSerifFontFamily(standardFamily); > + preferences->setSansSerifFontFamily(sansSerifFamily); > + preferences->setCursiveFontFamily(cursiveFamily); > + preferences->setFantasyFontFamily(fantasyFamily); > + > + SysFreeString(standardFamily); > + SysFreeString(fixedFamily); > + SysFreeString(sansSerifFamily); > + SysFreeString(cursiveFamily); > + SysFreeString(fantasyFamily); You could make the font names be leaked static BSTRs. > + preferences->resetDefaultsToConsistentValues(); This won't compile. resetDefaultsToConsistentValues() isn't a member of IWebPreferences. 136111 49 33859 dimich 2009-07-30 23:27:12 -0700 Created attachment 33859 Patch with changes after review Updated per aroben's coments. Thanks for review! (In reply to comment #48) > The added tests are missing from this patch. > > security/ seems like a strange place to put them. Maybe we need a new directory > for tests of the test harness? Moved to LayoutTests/fast/harness. Indeed a new place is better. > > +- (void)_setPreference:(NSString *)key stringValue:(NSString *)value > > +{ > > + NSString *_key = KEY(key); > > + [self _setStringValue:value forKey:_key]; > > +} > > This is wrong. _setStringValue:forKey: also passes the key through KEY(), so > you'll end up with the preferences identifier prepended twice. Done. > _setPreference:stringValue: is not a very Cocoa-y name. The obvious name would > be _setStringValue:forKey:. Maybe we should just expose that method through > WebPreferencesPrivate.h? Or maybe we can come up with a name that indicates > this is for testing purposes only. I don't think it's super-important to have > similar names on Mac and Windows for this. Changed name to - (void)_setPreferenceForTestWithValue:(NSString *)value forKey:(NSString *)key; Hope it's a better name. Exposing setStringValue feels strange because it is part of a bunch of similar functions. > > + HRESULT setPreference([in] BSTR key, [in] BSTR value); > > + > > HRESULT isWebSecurityEnabled([out, retval] BOOL* enabled); > > HRESULT setWebSecurityEnabled([in] BOOL enabled); > > Please add the new function at the end of the interface, to avoid the risk of > breaking nightly builds. Fixed. Also renamed it to setPreferenceForTest to match closer the Mac version. > > +HRESULT STDMETHODCALLTYPE WebPreferences::setPreference(BSTR key, BSTR value) > > There's no need to have STDMETHODCALLTYPE on the implementation. It's only > needed on the declaration. Fixed. > > + LayoutTestController* controller = reinterpret_cast<LayoutTestController*>(JSObjectGetPrivate(thisObject)); > > static_cast is preferable here. Done. > > > +void LayoutTestController::overridePreference(JSStringRef key, JSStringRef flag) > > +{ > > + RetainPtr<CFStringRef> keyCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, key)); > > + NSString *keyNS = (NSString *)keyCF.get(); > > + > > + RetainPtr<CFStringRef> flagCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, flag)); > > + NSString *flagNS = (NSString *)flagCF.get(); > > I think we tend to use 0 instead of kCFAllocatorDefault, though either is fine. In the same file (LayoutTestControllerMac.mm) both are used but 0 once and kCFAllocatorDefault multiple times so decided to leave kCFAllocatorDefault. I can replace all with 0... > > + SysFreeString(standardFamily); > > + SysFreeString(fixedFamily); > > + SysFreeString(sansSerifFamily); > > + SysFreeString(cursiveFamily); > > + SysFreeString(fantasyFamily); > > You could make the font names be leaked static BSTRs. Done. > > + preferences->resetDefaultsToConsistentValues(); > > This won't compile. resetDefaultsToConsistentValues() isn't a member of > IWebPreferences. Oops. Fixed. 136733 50 33995 dimich 2009-08-03 12:04:43 -0700 Created attachment 33995 Same patch with ChangeLog files updated and GTK and Wx changes. Same patch with ChangeLog files updated and GTK and Wx changes to prevent build break. Also, added new tests to Skipped list on GTK until GTK DRT implements preference override. 137916 51 33995 eric 2009-08-07 09:07:22 -0700 Comment on attachment 33995 Same patch with ChangeLog files updated and GTK and Wx changes. it seems aroben has the most context here. You should try and track him down over irc and ask him to take another quick look at this. 138030 52 dimich 2009-08-07 12:05:10 -0700 (In reply to comment #51) > it seems aroben has the most context here. You should try and track him down > over irc and ask him to take another quick look at this. Thanks! I'm trying to do just that. I didn't see him on IRC for a while, perhaps on vacation or something... Will keep looking :-) 138035 53 eric 2009-08-07 12:21:47 -0700 (In reply to comment #52) > (In reply to comment #51) > > it seems aroben has the most context here. You should try and track him down > > over irc and ask him to take another quick look at this. > > Thanks! I'm trying to do just that. I didn't see him on IRC for a while, > perhaps on vacation or something... Will keep looking :-) Email works well. 138641 54 aroben 2009-08-10 07:31:56 -0700 (In reply to comment #49) > (In reply to comment #48) > > > +void LayoutTestController::overridePreference(JSStringRef key, JSStringRef flag) > > > +{ > > > + RetainPtr<CFStringRef> keyCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, key)); > > > + NSString *keyNS = (NSString *)keyCF.get(); > > > + > > > + RetainPtr<CFStringRef> flagCF(AdoptCF, JSStringCopyCFString(kCFAllocatorDefault, flag)); > > > + NSString *flagNS = (NSString *)flagCF.get(); > > > > I think we tend to use 0 instead of kCFAllocatorDefault, though either is fine. > > In the same file (LayoutTestControllerMac.mm) both are used but 0 once and > kCFAllocatorDefault multiple times so decided to leave kCFAllocatorDefault. I > can replace all with 0... Matching the existing style (even if the existing style is muddled) seems good. 138644 55 33995 aroben 2009-08-10 07:38:32 -0700 Comment on attachment 33995 Same patch with ChangeLog files updated and GTK and Wx changes. Sorry for the long delay in reviewing this -- I was away on vacation. The new tests are missing spaces between "if" and "(", and around "=", in a few places. > +++ b/WebKitTools/DumpRenderTree/LayoutTestController.h > @@ -52,6 +52,7 @@ public: > bool isCommandEnabled(JSStringRef name); > void keepWebHistory(); > void notifyDone(); > + void overridePreference(JSStringRef key, JSStringRef flag); I think "value" would be a clearer name for the second parameter. r=me 138882 56 dimich 2009-08-10 19:24:25 -0700 Fixed style in tests as suggested, renamed 'flag' to 'value' and also added new tests to Qt Skipped list. Landed: http://trac.webkit.org/changeset/47015 138886 57 dimich 2009-08-10 19:58:52 -0700 Reverted in http://trac.webkit.org/changeset/47017 Caused many Windows Layout tests to fail. 139079 58 dimich 2009-08-11 13:26:36 -0700 The failed layout tests were due to incorrect merge... re-landed in http://trac.webkit.org/changeset/47039, and fixed the issue with ShouldPaintNativeControls setting on Windows inhttp://trac.webkit.org/changeset/47043 23056 2008-08-28 09:26:29 -0700 2008-09-01 15:34:23 -0700 Possible patch to issue 20534 patch20534.txt text/plain 9237 gwilson SW5kZXg6IFdlYktpdC93aW4vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vQ2hh bmdlTG9nCShyZXZpc2lvbiAzNTk3MCkKKysrIFdlYktpdC93aW4vQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTMgQEAKKzIwMDgtMDgtMjggIEdsZW5uIFdpbHNvbiAgPHdpbHNv bmdAZ21haWwuY29tPgorCisgICAgICAgIENoYW5nZWQgV2ViUHJlZmVyZW5jZXMgdG8gaGF2ZSBh IGdlbmVyYWwgbWV0aG9kIGZvciBvdmVycmlkaW5nIGRlZmF1bHQKKyAgICAgICAgY29uZmlndXJh dGlvbiB2YWx1ZXMgKGxpa2UgaGF2aW5nIEphdmFTY3JpcHQgZW5hYmxlZCkgYXQgdGVzdCB0aW1l LgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsOgorICAgICAgICAq IFdlYlByZWZlcmVuY2VzLmNwcDoKKyAgICAgICAgKFdlYlByZWZlcmVuY2VzOjpvdmVycmlkZVBy ZWZlcmVuY2UpOgorICAgICAgICAqIFdlYlByZWZlcmVuY2VzLmg6CisKIDIwMDgtMDgtMjggIEhv bGdlciBIYW5zIFBldGVyIEZyZXl0aGVyICA8emVja2VAc2VsZmlzaC5vcmc+CiAKICAgICAgICAg UnViYmVyLXN0YW1wZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAko cmV2aXNpb24gMzU5MTcpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMjM5LDYgKzIzOSw3IEBAIHZvaWQgV2ViUHJlZmVyZW5jZXM6OmluaXRpYWxp emVEZWZhdWx0U2UKICAgICBkZWZhdWx0U2V0dGluZ3MgPSBkZWZhdWx0czsKIH0KIAorCiBSZXRh aW5QdHI8Q0ZQcm9wZXJ0eUxpc3RSZWY+IFdlYlByZWZlcmVuY2VzOjp2YWx1ZUZvcktleShDRlN0 cmluZ1JlZiBrZXkpCiB7CiAgICAgUmV0YWluUHRyPENGUHJvcGVydHlMaXN0UmVmPiB2YWx1ZSA9 IENGRGljdGlvbmFyeUdldFZhbHVlKG1fcHJpdmF0ZVByZWZzLmdldCgpLCBrZXkpOwpAQCAtMTE3 MSw2ICsxMTcyLDEzIEBAIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMK ICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVm ZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCT09MIHZhbHVlKQoreworICAg IENGU3RyaW5nUmVmIGtleXJlZiA9IENGU3RyaW5nQ3JlYXRlV2l0aENoYXJhY3RlcnNOb0NvcHko MCwgKFVuaUNoYXIqKV93Y3NkdXAoa2V5KSwgKENGSW5kZXgpX3Rjc2xlbihrZXkpLCBrQ0ZBbGxv Y2F0b3JNYWxsb2MpOworICAgIHRoaXMtPnNldEJvb2xWYWx1ZShrZXlyZWYsIHZhbHVlKTsKKyAg ICByZXR1cm4gU19PSzsKK30KKwogdm9pZCBXZWJQcmVmZXJlbmNlczo6d2lsbEFkZFRvV2ViVmll dygpCiB7CiAgICAgKyttX251bVdlYlZpZXdzOwpJbmRleDogV2ViS2l0L3dpbi9XZWJQcmVmZXJl bmNlcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAkocmV2aXNp b24gMzU5MTcpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgJKHdvcmtpbmcgY29weSkK QEAgLTMxNCw2ICszMTQsMTAgQEAgcHVibGljOgogICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRI T0RDQUxMVFlQRSBzZXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgoCiAgICAgICAgIC8qIFtpbl0g Ki8gQlNUUiBsb2NhdGlvbik7CiAKKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZ UEUgb3ZlcnJpZGVQcmVmZXJlbmNlKAorICAgICAgICAvKiBbaW5dICovIEJTVFIga2V5LAorICAg ICAgICAvKiBbaW5dICovIEJPT0wgdmFsdWUpOworCiAgICAgLy8gV2ViUHJlZmVyZW5jZXMKIAog ICAgIC8vIFRoaXMgbWV0aG9kIGFjY2Vzc2VzIGEgZGlmZmVyZW50IHByZWZlcmVuY2Uga2V5IHRo YW4gZGV2ZWxvcGVyRXh0cmFzRW5hYmxlZC4KSW5kZXg6IFdlYktpdC93aW4vSW50ZXJmYWNlcy9J V2ViUHJlZmVyZW5jZXMuaWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vSW50ZXJmYWNlcy9J V2ViUHJlZmVyZW5jZXMuaWRsCShyZXZpc2lvbiAzNTkxNykKKysrIFdlYktpdC93aW4vSW50ZXJm YWNlcy9JV2ViUHJlZmVyZW5jZXMuaWRsCSh3b3JraW5nIGNvcHkpCkBAIC0xODMsNCArMTgzLDYg QEAgaW50ZXJmYWNlIElXZWJQcmVmZXJlbmNlcyA6IElVbmtub3duCiAKICAgICBIUkVTVUxUIHNl dFNob3VsZFBhaW50Q3VzdG9tU2Nyb2xsYmFycyhCT09MIHNob3VsZFBhaW50KTsKICAgICBIUkVT VUxUIHNob3VsZFBhaW50Q3VzdG9tU2Nyb2xsYmFycyhCT09MICpzaG91bGRQYWludCk7CisKKyAg ICBIUkVTVUxUIG92ZXJyaWRlUHJlZmVyZW5jZShbaW5dIEJTVFIga2V5LCBbaW5dIEJPT0wgdmFs dWUpOwogfQpJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzU5NzApCisrKyBXZWJLaXRUb29scy9DaGFuZ2VM b2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAwOC0wOC0yOCAgR2xlbm4gV2ls c29uICA8d2lsc29uZ0BnbWFpbC5jb20+CisKKyAgICAgICAgQWRkZWQgSmF2YVNjcmlwdCBtZXRo b2QgYW5kIGNhbGxiYWNrcyB0byBhbGxvdyBsYXlvdXQgdGVzdHMgCisgICAgICAgIHRvIG92ZXJy aWRlIGRlZmF1bHQgY29uZmlndXJhdGlvbiB2YWx1ZXMgaW4gV2ViUHJlZmVyZW5jZXMgYXQgdGVz dCB0aW1lLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAob3Zl cnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2spOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnN0YXRpY0Z1bmN0aW9ucyk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaDoKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRy b2xsZXJXaW4uY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJl ZmVyZW5jZSk6CisKIDIwMDgtMDgtMjUgIFN0ZXZlIEZhbGtlbmJ1cmcgIDxzZmFsa2VuQGFwcGxl LmNvbT4KIAogICAgICAgICBCdWlsZCBmaXguIENvcHkgY29ycmVjdCB2ZXJzaW9uIG9mIElDVS4K SW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5jcHAJKHJldmlzaW9uIDM1OTE3KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMjMsNiArMzIz LDIwIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIGV4ZWNDb21tYW5kQ2FsbGJhY2soSlMKICAgICByZXR1 cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVm IG92ZXJyaWRlUHJlZmVyZW5jZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVj dFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291 bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikK K3sKKyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFr ZVVuZGVmaW5lZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXko QWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRp b24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xs ZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4o SlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlk ZVByZWZlcmVuY2Uoa2V5LmdldCgpLCBKU1ZhbHVlVG9Cb29sZWFuKGNvbnRleHQsIGFyZ3VtZW50 c1sxXSkpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQor CiBzdGF0aWMgSlNWYWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29udGV4dFJlZiBj b250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC03MDQs NiArNzE4LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OgogICAg ICAgICB7ICJleGVjQ29tbWFuZCIsIGV4ZWNDb21tYW5kQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgIm5vdGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAg ICAgeyAib3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKICAgICAgICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3Vy Y2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0 cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVl dWVCYWNrTmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2Fy ZE5hdmlnYXRpb24iLCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5k ZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuaAkocmV2aXNpb24gMzU5MTcpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC02Nyw2ICs2Nyw4IEBAIHB1Ymxp YzoKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7 CiAgICAgdm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBwYXRoKTsKICAgICB2b2lkIGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAg dm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBib29sIGZsYWcpOworCiAg ICAgaW50IHdpbmRvd0NvdW50KCk7CiAgICAgCiAgICAgYm9vbCBlbGVtZW50RG9lc0F1dG9Db21w bGV0ZUZvckVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgaWQpOwpJbmRleDogV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCShyZXZpc2lvbiAzNTkxNykKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTU2OSwzICs1 NjksMjAgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0YWJhc2VRdQogeyAgICAK ICAgICBwcmludGYoIkVSUk9SOiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0YWJhc2VRdW90 YSgpIG5vdCBpbXBsZW1lbnRlZFxuIik7CiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIGJvb2wgZmxhZykKK3sKKyAgICBD T01QdHI8SVdlYlZpZXc+IHdlYlZpZXc7CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygm d2ViVmlldykpKQorICAgICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2Vz PiBwcmVmZXJlbmNlczsKKyAgICBpZiAoRkFJTEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVm ZXJlbmNlcykpKQorICAgICAgICByZXR1cm47CisKKyAgICB3c3RyaW5nIHdLZXkgPSBqc1N0cmlu Z1JlZlRvV1N0cmluZyhrZXkpOworCisgICAgQlNUUiBrZXlCU1RSID0gU3lzQWxsb2NTdHJpbmdM ZW4oKE9MRUNIQVIqKXdLZXkuY19zdHIoKSwgd0tleS5sZW5ndGgoKSk7CisgICAgcHJlZmVyZW5j ZXMtPm92ZXJyaWRlUHJlZmVyZW5jZShrZXlCU1RSLCBmbGFnKTsKKyAgICBTeXNGcmVlU3RyaW5n KGtleUJTVFIpOworfQpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gMzU5NzApCisrKyBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNSBAQAorMjAwOC0wOC0yOCAgR2xl bm4gV2lsc29uICA8d2lsc29uZ0BnbWFpbC5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgbmV3IGxheW91dCB0ZXN0cyB0byB2ZXJpZnkg dGhhdCBwcmVmZXJlbmNlcyBpbiB0aGUgbGF5b3V0VGVzdENvbnRyb2xsZXIKKyAgICAgICAgY2Fu IGJlIG1hbnVhbGx5IG92ZXJyaWRkZW4gYXQgdGVzdCB0aW1lLgorCQorICAgICAgICAqIENoYW5n ZUxvZzoKKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50 eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWw6 IEFkZGVkLgorCisKIDIwMDgtMDgtMjcgIFJvYmVydCBLcm9lZ2VyICA8cmprcm9lZ2VAbGlxdWku b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVyaWMgU2VpZGVsLgpJbmRleDogTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVu Y2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSBAQAorUEFTUwpJbmRleDog TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRt bAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxOSBAQAorPGh0bWw+IA0KKzxib2R5PiANCis8c2Ny aXB0PiANCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7DQorICAgICAgICBs YXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCkNCisgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJsZWQiLCBmYWxz ZSk7DQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoImFq d29laWZqb2F3aWVqZm9haXdoZWdzIiwgdHJ1ZSk7DQorICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdERpc3BsYXlJbWFnZXNLZXkiLCAib2F3aWVq Zm9hd2llamZvaWF3aiIpOw0KKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQ cmVmZXJlbmNlKHRydWUsIG51bGwpOw0KKyAgICB9DQorICAgIA0KKyAgICBmdW5jdGlvbiBsb2Fk c3RhdHVzKCkgew0KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlu bmVySFRNTD0iRkFJTCI7DQorICAgIH0NCis8L3NjcmlwdD4gDQorPGJvZHkgb25sb2FkPSJsb2Fk c3RhdHVzKCkiPg0KKzxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+DQorPC9ib2R5Pg0KKzwv aHRtbD4NCgpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy5odG1sCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjpleGVjdXRhYmxlCiAgICsg KgoK 23105 2008-09-01 15:34:23 -0700 2008-09-10 14:17:04 -0700 Possible patch to issue 20534 patch20534-2.txt text/plain 15595 gwilson SW5kZXg6IFdlYktpdC93aW4vQ2hhbmdlTG9nDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L3dpbi9D aGFuZ2VMb2cJKHJldmlzaW9uIDM2MDE2KQ0KKysrIFdlYktpdC93aW4vQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpDQpAQCAtMSwzICsxLDE4IEBADQorMjAwOC0wOS0wMSAgR2xlbm4gV2lsc29uICA8 d2lsc29uZ0BnbWFpbC5jb20+DQorDQorICAgICAgICBDaGFuZ2VkIFdlYlByZWZlcmVuY2VzIHRv IGhhdmUgYSBnZW5lcmFsIG1ldGhvZCBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0DQorICAgICAgICBj b25maWd1cmF0aW9uIHZhbHVlcyAobGlrZSBoYXZpbmcgSmF2YVNjcmlwdCBlbmFibGVkKSBhdCB0 ZXN0IHRpbWUuDQorICAgICAgICBBbHNvIGFkZGVkIG1ldGhvZHMgZm9yIHJlc2V0dGluZyBXZWJQ cmVmZXJlbmNlcyB0byBpdHMgZGVmYXVsdCB2YWx1ZXMgaWYNCisgICAgICAgIGFueSBwcmVmZXJl bmNlIGhhcyBiZWVuIG92ZXJyaWRkZW4uDQorDQorDQorICAgICAgICAqIEludGVyZmFjZXMvSVdl YlByZWZlcmVuY2VzLmlkbDogQWRkZWQgc2lnbmF0dXJlcyBmb3IgdGhlIHR3byBuZXcgbWV0aG9k cw0KKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDogIEFkZGVkIG5ldyBrZXkg Zm9yIGZsYWdnaW5nIHdoZW4gb3ZlcnJpZGVzIGhhcHBlbg0KKyAgICAgICAgKiBXZWJQcmVmZXJl bmNlcy5jcHA6DQorICAgICAgICAoV2ViUHJlZmVyZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6 IG5ldyBtZXRob2QgdG8gb3ZlcnJpZGUgcHJlZmVyZW5jZXMgbWFudWFsbHkNCisgICAgICAgIChX ZWJQcmVmZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKTogbmV3IG1ldGhvZCB0byByZXNldCBwcmVm ZXJlbmNlcyBhZnRlciBvdmVycmlkZQ0KKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5oOiBBZGRl ZCBzaWduYXR1cmVzIGZvciBuZXcgbWV0aG9kcw0KKw0KIDIwMDgtMDgtMzAgIFNhbSBXZWluaWcg IDxzYW1Ad2Via2l0Lm9yZz4NCiANCiAgICAgICAgIFJldmlld2VkIGJ5IERhbiBCZXJuc3RlaW4u DQpJbmRleDogV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaA0KPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQ0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHJldmlzaW9uIDM1 OTE3KQ0KKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcg Y29weSkNCkBAIC0xMTMsMyArMTEzLDUgQEANCiAjZGVmaW5lIFdlYktpdEF1dGhvckFuZFVzZXJT dHlsZXNFbmFibGVkUHJlZmVyZW5jZUtleSAiV2ViS2l0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJs ZWQiDQogDQogI2RlZmluZSBXZWJLaXRQYWludEN1c3RvbVNjcm9sbGJhcnNQcmVmZXJlbmNlS2V5 ICJXZWJLaXRQYWludEN1c3RvbVNjcm9sbGJhcnMiDQorDQorI2RlZmluZSBXZWJLaXREZWZhdWx0 UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVu Ig0KSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwDQo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0g V2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAJKHJldmlzaW9uIDM1OTE3KQ0KKysrIFdlYktp dC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwCSh3b3JraW5nIGNvcHkpDQpAQCAtMjM5LDYgKzIzOSw3 IEBAIHZvaWQgV2ViUHJlZmVyZW5jZXM6OmluaXRpYWxpemVEZWZhdWx0U2UNCiAgICAgZGVmYXVs dFNldHRpbmdzID0gZGVmYXVsdHM7DQogfQ0KIA0KKw0KIFJldGFpblB0cjxDRlByb3BlcnR5TGlz dFJlZj4gV2ViUHJlZmVyZW5jZXM6OnZhbHVlRm9yS2V5KENGU3RyaW5nUmVmIGtleSkNCiB7DQog ICAgIFJldGFpblB0cjxDRlByb3BlcnR5TGlzdFJlZj4gdmFsdWUgPSBDRkRpY3Rpb25hcnlHZXRW YWx1ZShtX3ByaXZhdGVQcmVmcy5nZXQoKSwga2V5KTsNCkBAIC0xMTcxLDYgKzExNzIsMzkgQEAg SFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlcw0KICAgICByZXR1cm4gU19P SzsNCiB9DQogDQorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3Zl cnJpZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCU1RSIHZhbHVlKQ0KK3sNCisgICAgQ0ZTdHJpbmdS ZWYga2V5cmVmID0gQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVyc05vQ29weSgwLCAoVW5pQ2hh ciopX3djc2R1cChrZXkpLCAoQ0ZJbmRleClfdGNzbGVuKGtleSksIGtDRkFsbG9jYXRvck1hbGxv Yyk7DQorICAgIHNldFN0cmluZ1ZhbHVlKGtleXJlZiwgdmFsdWUpOw0KKyAgICBzZXRCb29sVmFs dWUoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiksIHRydWUpOw0KKyAg ICByZXR1cm4gU19PSzsNCit9DQorDQorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVm ZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKCkNCit7DQorICAgIGlmICghYm9vbFZhbHVlRm9yS2V5 KENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4pKSkNCisgICAgICAgIHJl dHVybiBTX09LOw0KKw0KKyAgICBpbnQgY291bnQgPSBDRkRpY3Rpb25hcnlHZXRDb3VudChkZWZh dWx0U2V0dGluZ3MpOw0KKyAgICBpZiAoY291bnQgPD0gMCkNCisgICAgICAgIHJldHVybiBTX09L Ow0KKyAgICANCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZb Y291bnRdKTsNCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiB2YWx1ZXMobmV3IENGVHlwZVJl Zltjb3VudF0pOw0KKyAgICBDRkRpY3Rpb25hcnlHZXRLZXlzQW5kVmFsdWVzKGRlZmF1bHRTZXR0 aW5ncywga2V5cy5nZXQoKSwgdmFsdWVzLmdldCgpKTsNCisNCisgICAgZm9yIChpbnQgaSA9IDA7 IGkgPCBjb3VudDsgKytpKSB7DQorICAgICAgICBCU1RSIHZhbCA9IHN0cmluZ1ZhbHVlRm9yS2V5 KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSk7DQorICAgICAgICBzZXRWYWx1ZUZv cktleShzdGF0aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSksIHZhbHVlc1tpXSk7DQorICAg IH0NCisNCisgICAgc2V0Qm9vbFZhbHVlKENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJlbmNlc092 ZXJyaWRkZW4pLCBmYWxzZSk7DQorDQorICAgIHBvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmlj YXRpb24oKTsNCisNCisgICAgcmV0dXJuIFNfT0s7DQorfQ0KKw0KIHZvaWQgV2ViUHJlZmVyZW5j ZXM6OndpbGxBZGRUb1dlYlZpZXcoKQ0KIHsNCiAgICAgKyttX251bVdlYlZpZXdzOw0KSW5kZXg6 IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC93aW4v V2ViUHJlZmVyZW5jZXMuaAkocmV2aXNpb24gMzU5MTcpDQorKysgV2ViS2l0L3dpbi9XZWJQcmVm ZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpDQpAQCAtMzE0LDYgKzMxNCwxMiBAQCBwdWJsaWM6DQog ICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzZXRMb2NhbFN0b3JhZ2VEYXRh YmFzZVBhdGgoDQogICAgICAgICAvKiBbaW5dICovIEJTVFIgbG9jYXRpb24pOw0KIA0KKyAgICB2 aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgb3ZlcnJpZGVQcmVmZXJlbmNlKA0KKyAg ICAgICAgLyogW2luXSAqLyBCU1RSIGtleSwNCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1 ZSk7DQorDQorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSByZXNldFRvRGVm YXVsdHMoKTsNCisNCiAgICAgLy8gV2ViUHJlZmVyZW5jZXMNCiANCiAgICAgLy8gVGhpcyBtZXRo b2QgYWNjZXNzZXMgYSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRy YXNFbmFibGVkLg0KSW5kZXg6IFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXMu aWRsDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNl cy5pZGwJKHJldmlzaW9uIDM1OTE3KQ0KKysrIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJl ZmVyZW5jZXMuaWRsCSh3b3JraW5nIGNvcHkpDQpAQCAtMTgzLDQgKzE4Myw3IEBAIGludGVyZmFj ZSBJV2ViUHJlZmVyZW5jZXMgOiBJVW5rbm93bg0KIA0KICAgICBIUkVTVUxUIHNldFNob3VsZFBh aW50Q3VzdG9tU2Nyb2xsYmFycyhCT09MIHNob3VsZFBhaW50KTsNCiAgICAgSFJFU1VMVCBzaG91 bGRQYWludEN1c3RvbVNjcm9sbGJhcnMoQk9PTCAqc2hvdWxkUGFpbnQpOw0KKw0KKyAgICBIUkVT VUxUIG92ZXJyaWRlUHJlZmVyZW5jZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOw0K KyAgICBIUkVTVUxUIHJlc2V0VG9EZWZhdWx0cygpOw0KIH0NCkluZGV4OiBXZWJLaXRUb29scy9D aGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9u IDM2MDE2KQ0KKysrIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQ0KQEAgLTEs MyArMSwxNCBAQA0KKzIwMDgtMDktMDEgIEdsZW5uIFdpbHNvbiAgPHdpbHNvbmdAZ21haWwuY29t Pg0KKw0KKyAgICAgICAgQ2hhbmdlZCBMYXlvdXRUZXN0Q29udHJvbGxlciBhbmQgRHVtcFJlbmRl clRyZWUgdG8gYWxsb3cgZm9yIG1hbnVhbA0KKyAgICAgICAgb3ZlcnJpZGluZyBvZiBkZWZhdWx0 IHByZWZlcmVuY2VzIGF0IHRlc3QgdGltZS4gIEFsc28gYWRkZWQgc3VwcG9ydCBmb3INCisgICAg ICAgIHJlc2V0dGluZyB0aGUgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0LiAgICAgICAgDQor DQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcDogQWRk ZWQgY2FsbGJhY2sgbWV0aG9kIGZvciBvdmVycmlkaW5nIHByZWZlcmVuY2VzDQorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6IEFkZGVkIHNpZ25hdHVyZSBm b3IgY2FsbGJhY2sNCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVl LmNwcDogQWRkZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMgaWYgbmVjZXNzYXJ5DQorICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6IEFk ZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uDQorDQogMjAwOC0wOC0yNSAgU3RldmUgRmFsa2VuYnVy ZyAgPHNmYWxrZW5AYXBwbGUuY29tPg0KIA0KICAgICAgICAgQnVpbGQgZml4LiBDb3B5IGNvcnJl Y3QgdmVyc2lvbiBvZiBJQ1UuDQpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuY3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCShyZXZpc2lvbiAzNTkxNykNCisrKyBX ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHdvcmtp bmcgY29weSkNCkBAIC0zMjMsNiArMzIzLDIwIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIGV4ZWNDb21t YW5kQ2FsbGJhY2soSlMNCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQp Ow0KIH0NCiANCitzdGF0aWMgSlNWYWx1ZVJlZiBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjayhK U0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRo aXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50 c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pDQorew0KKyAgICBpZiAoYXJndW1lbnRDb3VudCA8 IDIpDQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7DQorDQor ICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0Nv cHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsNCisgICAgQVNTRVJUKCEqZXhj ZXB0aW9uKTsNCisNCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSByZWlu dGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRo aXNPYmplY3QpKTsNCisgICAgY29udHJvbGxlci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleS5nZXQo KSwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikp Ow0KKw0KKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7DQorfQ0KKw0K IHN0YXRpYyBKU1ZhbHVlUmVmIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNv bnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXpl X3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJl ZiogZXhjZXB0aW9uKQ0KIHsNCiAgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbg0KQEAgLTcw NCw2ICs3MTgsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6DQog ICAgICAgICB7ICJleGVjQ29tbWFuZCIsIGV4ZWNDb21tYW5kQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwNCiAg ICAgICAgIHsgImtlZXBXZWJIaXN0b3J5Iiwga2VlcFdlYkhpc3RvcnlDYWxsYmFjaywga0pTUHJv cGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9 LA0KICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LA0K KyAgICAgICAgeyAib3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJh Y2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURv bnREZWxldGUgfSwNCiAgICAgICAgIHsgInBhdGhUb0xvY2FsUmVzb3VyY2UiLCBwYXRoVG9Mb2Nh bFJlc291cmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwNCiAgICAgICAgIHsgInF1ZXVlQmFja05hdmlnYXRp b24iLCBxdWV1ZUJhY2tOYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwNCiAgICAgICAgIHsgInF1 ZXVlRm9yd2FyZE5hdmlnYXRpb24iLCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwNCkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuaAkocmV2aXNpb24gMzU5MTcpDQorKysgV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAkod29ya2luZyBjb3B5KQ0KQEAgLTY3LDYg KzY3LDggQEAgcHVibGljOg0KICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNT dHJpbmdSZWYgcGF0aCk7DQogICAgIHZvaWQgc2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9j YXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7DQogICAgIHZvaWQgY2xlYXJQZXJzaXN0ZW50VXNlclN0 eWxlU2hlZXQoKTsNCisgICAgdm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5 LCBKU1N0cmluZ1JlZiBmbGFnKTsNCisNCiAgICAgaW50IHdpbmRvd0NvdW50KCk7DQogICAgIA0K ICAgICBib29sIGVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChKU1N0cmlu Z1JlZiBpZCk7DQpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5k ZXJUcmVlLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9EdW1wUmVuZGVyVHJlZS5jcHAJKHJldmlzaW9uIDM1OTgzKQ0KKysrIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJKHdvcmtpbmcgY29weSkNCkBAIC02 NDAsNiArNjQwLDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdA0K IA0KICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsNCiAgICAgaWYgKFNV Q0NFRURFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkgew0KKyAgICAgICAg cHJlZmVyZW5jZXMtPnJlc2V0VG9EZWZhdWx0cygpOwkJDQogICAgICAgICBwcmVmZXJlbmNlcy0+ c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZChGQUxTRSk7DQogICAgICAgICBwcmVmZXJlbmNlcy0+ c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShUUlVFKTsNCiANCkluZGV4 OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4u Y3BwDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91 dFRlc3RDb250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzU5ODMpDQorKysgV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkod29ya2luZyBj b3B5KQ0KQEAgLTU2OSwzICs1NjksMjMgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 RGF0YWJhc2VRdQ0KIHsgICAgDQogICAgIHByaW50ZigiRVJST1I6IExheW91dFRlc3RDb250cm9s bGVyOjpzZXREYXRhYmFzZVF1b3RhKCkgbm90IGltcGxlbWVudGVkXG4iKTsNCiB9DQorDQordm9p ZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtl eSwgSlNTdHJpbmdSZWYgZmxhZykNCit7DQorICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsN CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQ0KKyAgICAgICAgcmV0 dXJuOw0KKw0KKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsNCisgICAg aWYgKEZBSUxFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkNCisgICAgICAg IHJldHVybjsNCisNCisgICAgd3N0cmluZyB3S2V5ID0ganNTdHJpbmdSZWZUb1dTdHJpbmcoa2V5 KTsNCisgICAgd3N0cmluZyB3RmxhZyA9IGpzU3RyaW5nUmVmVG9XU3RyaW5nKGZsYWcpOw0KKw0K KyAgICBCU1RSIGtleUJTVFIgPSBTeXNBbGxvY1N0cmluZ0xlbigoT0xFQ0hBUiopd0tleS5jX3N0 cigpLCB3S2V5Lmxlbmd0aCgpKTsNCisgICAgQlNUUiBmbGFnQlNUUiA9IFN5c0FsbG9jU3RyaW5n TGVuKChPTEVDSEFSKil3RmxhZy5jX3N0cigpLCB3RmxhZy5sZW5ndGgoKSk7DQorICAgIHByZWZl cmVuY2VzLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5QlNUUiwgZmxhZ0JTVFIpOw0KKyAgICBTeXNG cmVlU3RyaW5nKGtleUJTVFIpOw0KKyAgICBTeXNGcmVlU3RyaW5nKGZsYWdCU1RSKTsNCit9DQpJ bmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCShyZXZpc2lvbiAzNjAxNikNCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdv cmtpbmcgY29weSkNCkBAIC0xLDMgKzEsMTcgQEANCisyMDA4LTA5LTAxICBHbGVubiBXaWxzb24g IDx3aWxzb25nQGdtYWlsLmNvbT4NCisNCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLg0KKyAgICAgICAgQWRkZWQgbmV3IHRlc3RzIGZvciB2ZXJpZnlpbmcgdGhhdCB0aGUgbGF5 b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUNCisgICAgICAgIGl0cyBwcmVmZXJlbmNlcyBvdmVy cmlkZGVuIG1hbnVhbGx5LCBhbmQgdGhhdCB0aG9zZSBwcmVmZXJlbmNlcyBhcmUNCisgICAgICAg IHJlc2V0IGFmdGVyIGV2ZXJ5IHRlc3QsIGlmIG5lY2Vzc2FyeS4NCisNCisgICAgICAgICogc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQ6IEFkZGVkLg0KKyAgICAg ICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWw6IEFkZGVkLg0KKyAgICAg ICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQ6IEFkZGVkLg0K KyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sOiBBZGRlZC4NCisg ICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dDogQWRkZWQu DQorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sOiBBZGRlZC4NCisN CiAyMDA4LTA5LTAxICBHZW9mZnJleSBHYXJlbiAgPGdnYXJlbkBhcHBsZS5jb20+DQogDQogICAg ICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4NCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0 eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dA0KPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIExh eW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0CShy ZXZpc2lvbiAwKQ0KKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2Vz LTItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQ0KQEAgLTAsMCArMSwzIEBADQorVGhpcyB0ZXN0 IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQg cHJlZmVyZW5jZXMgb3ZlcnJpZGVuLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdp bGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9u dCBzaXplLiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuDQorDQorUEFTUw0KSW5kZXg6IExh eW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbA0KPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQ0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAko cmV2aXNpb24gMCkNCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNl cy0yLmh0bWwJKHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDE4IEBADQorPGh0bWw+DQorPHNjcmlw dD4NCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7DQorICAgICAgICBsYXlv dXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7DQorICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdERlZmF1bHRGb250U2l6ZSIsICIyNCIpOw0K KyAgICB9DQorPC9zY3JpcHQ+DQorPGJvZHk+DQorICAgIDxwPlRoaXMgdGVzdCB2ZXJpZmllcyB0 aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2Vz IG92ZXJyaWRlbi4gIA0KKyAgICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwg YWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBz aXplLiAgDQorICAgIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+DQorICAgIDxzY3Jp cHQ+DQorICAgICAgICB2YXIgcCA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilb MF07DQorICAgICAgICBpZighd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyIHx8IHdpbmRvdy5n ZXRDb21wdXRlZFN0eWxlKHApLmZvbnRTaXplID09ICIyNHB4IikNCisgICAgICAgICAgICBkb2N1 bWVudC53cml0ZSgiUEFTUyIpOw0KKyAgICA8L3NjcmlwdD4NCis8L2JvZHk+DQorPC9odG1sPg0K DQpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy0yLmh0bWwNCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18NCkFkZGVkOiBzdm46ZXhlY3V0YWJsZQ0KICAgKyAq DQoNCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBl Y3RlZC50eHQNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0NCi0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1w cmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApDQorKysgTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQ0KQEAg LTAsMCArMSwzIEBADQorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRl c3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4u IFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlz YWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEg YnJvd3Nlci4NCisNCitQQVNTDQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt cHJlZmVyZW5jZXMuaHRtbA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292 ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwJKHJldmlzaW9uIDApDQorKysgTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkNCkBAIC0wLDAgKzEs MTggQEANCis8aHRtbD4gDQorPGJvZHk+IA0KKzxzY3JpcHQ+IA0KKyAgICBpZih3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpIHsNCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKQ0KKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNl KCJXZWJLaXRKYXZhU2NyaXB0RW5hYmxlZCIsIGZhbHNlKTsNCisgICAgfQ0KKyAgICANCisgICAg ZnVuY3Rpb24gbG9hZHN0YXR1cygpIHsNCisgICAgICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikNCisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIiku aW5uZXJIVE1MPSJGQUlMIjsNCisgICAgfQ0KKzwvc2NyaXB0PiANCis8Ym9keSBvbmxvYWQ9Imxv YWRzdGF0dXMoKSI+DQorICAgIDxwPlRoaXMgaXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMgdGhhdCBs YXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVy cmlkZGVuLiAgVGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNh biBiZSBkaXNhYmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5n IHdpdGggYSBicm93c2VyLjwvcD4NCisgICAgPHNwYW4gaWQ9InN0YXR1cyI+UEFTUzwvc3Bhbj4N Cis8L2JvZHk+DQorPC9odG1sPg0KDQpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBMYXlvdXRUZXN0cy9z ZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sDQpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fDQpBZGRlZDogc3Zu OmV4ZWN1dGFibGUNCiAgICsgKg0KDQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApDQorKysg TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkNCkBAIC0wLDAgKzEsMyBAQA0KK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBs YXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFm dGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuDQorDQor UEFTUw0KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1s DQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09DQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0 Lmh0bWwJKHJldmlzaW9uIDApDQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6 LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDE0IEBADQorPGh0bWw+IA0KKzxi b2R5PiANCis8c2NyaXB0PiANCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQ0K KyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOw0KKzwvc2NyaXB0PiAN Cis8Ym9keT4NCisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxheW91dFRlc3RD b250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkg bGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuPC9wPg0KKyAgICA8c3Bh biBpZD0ic3RhdHVzIj5GQUlMPC9zcGFuPg0KKyAgICA8c2NyaXB0Pg0KKyAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iUEFTUyI7ICAgICAgICANCisg ICAgPC9zY3JpcHQ+DQorPC9ib2R5Pg0KKzwvaHRtbD4NCg== 23328 2008-09-10 14:17:04 -0700 2008-09-16 13:14:32 -0700 Improved possible patch to issue 20534 patch20534-3.txt text/plain 19919 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNjMyMykKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMDktMTAgIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZh dGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLmg6CisgICAgICAgICogV2Vi Vmlldy9XZWJQcmVmZXJlbmNlcy5tbToKKyAgICAgICAgKC1bV2ViUHJlZmVyZW5jZXMgcmVzZXRU b0RlZmF1bHRzXSk6IG5ldyBtZXRob2QKKyAgICAgICAgKC1bV2ViUHJlZmVyZW5jZXMgb3ZlcnJp ZGVQcmVmZXJlbmNlOmZsYWc6XSk6IG5ldyBtZXRob2QKKwogMjAwOC0wOS0wOSAgRGFuIEJlcm5z dGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIC0gVGlnZXIgYnVpbGQgZml4CkluZGV4 OiBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCShyZXZp c2lvbiAzNjI5OSkKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZh dGUuaAkod29ya2luZyBjb3B5KQpAQCAtNzAsNiArNzAsNyBAQAogI2RlZmluZSBXZWJLaXRFbmFi bGVGdWxsRG9jdW1lbnRUZWFyZG93blByZWZlcmVuY2VLZXkgQCJXZWJLaXRFbmFibGVGdWxsRG9j dW1lbnRUZWFyZG93biIKICNkZWZpbmUgV2ViS2l0T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVF bmFibGVkUHJlZmVyZW5jZUtleSBAIldlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5h YmxlZCIKICNkZWZpbmUgV2ViS2l0Wm9vbXNUZXh0T25seVByZWZlcmVuY2VLZXkgQCJXZWJLaXRa b29tc1RleHRPbmx5IgorI2RlZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVu IEAiV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiIKIAogLy8gVGhlc2UgYXJlIHBy aXZhdGUgYm90aCBiZWNhdXNlIGNhbGxlcnMgc2hvdWxkIGJlIHVzaW5nIHRoZSBjb3ZlciBtZXRo b2RzIGFuZCBiZWNhdXNlIHRoZQogLy8gY292ZXIgbWV0aG9kcyB0aGVtc2VsdmVzIGFyZSBwcml2 YXRlLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM2Mjk5 KQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLmgJKHdvcmtpbmcgY29weSkK QEAgLTQzNyw2ICs0MzcsMjIgQEAgY2FjaGluZyBiZWhhdmlvci4KICovCiAtIChXZWJDYWNoZU1v ZGVsKWNhY2hlTW9kZWw7CiAKKworLyohCisgQG1ldGhvZCBvdmVycmlkZVByZWZlcmVuY2U6Cisg QHBhcmFtIGtleSBUaGUga2V5IG9mIHRoZSBwcmVmZXJlbmNlIHRvIGJlIG92ZXJyaWRkZW4KKyBA cGFyYW0gZmxhZyBUaGUgZGVzaXJlZCB2YWx1ZSBvZiB0aGUgcHJlZmVyZW5jZQorIEBhYnN0cmFj dCBTZXRzIHRoZSBnaXZlbiB2YWx1ZSBvZiBhIGdpdmVuIHByZWZlcmVuY2UKKyAqLworLSh2b2lk KW92ZXJyaWRlUHJlZmVyZW5jZTooTlNTdHJpbmcgKilrZXkgZmxhZzooTlNTdHJpbmcgKilmbGFn OworCisvKiEKKyBAbWV0aG9kIHJlc2V0VG9EZWZhdWx0czoKKyBAYWJzdHJhY3QgcmVzZXRzIHRo ZSBwcmVmZXJlbmNlcyB0byB0aGVpciBkZWZhdWx0IHZhbHVlcworICovCistKHZvaWQpcmVzZXRU b0RlZmF1bHRzOworCisKIEBlbmQKIAogI3VuZGVmIFdlYk5TVUludGVnZXIKSW5kZXg6IFdlYktp dC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFj L1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM2Mjk5KQorKysgV2ViS2l0L21h Yy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC03MzIsNiArNzMy LDIzIEBAIHN0YXRpYyBXZWJDYWNoZU1vZGVsIGNhY2hlTW9kZWxGb3JNYWluQnUKICAgICByZXR1 cm4gW3NlbGYgX2ludGVnZXJWYWx1ZUZvcktleTpXZWJLaXRDYWNoZU1vZGVsUHJlZmVyZW5jZUtl eV07CiB9CiAKKy0gKHZvaWQpcmVzZXRUb0RlZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9v bFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAg ICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07CisJCisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNl c0NoYW5nZXNOb3RpZmljYXRpb25dOwkKKyAgICBbc2VsZiBfc2V0Qm9vbFZhbHVlOmZhbHNlIGZv cktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsKK30KKworLSAodm9pZClv dmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5nICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVy ZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9y S2V5OmtleV07CisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZh dWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsKK30KKworCiBAZW5kCiAKIEBpbXBsZW1lbnRhdGlv biBXZWJQcmVmZXJlbmNlcyAoV2ViUHJpdmF0ZSkKQEAgLTEwNTUsNiArMTA3Miw4IEBAIHN0YXRp YyBOU1N0cmluZyAqY2xhc3NJQkNyZWF0b3JJRCA9IG5pbDsKIHsKICAgICByZXR1cm4gW3NlbGYg X2Jvb2xWYWx1ZUZvcktleTpXZWJLaXRFbmFibGVGdWxsRG9jdW1lbnRUZWFyZG93blByZWZlcmVu Y2VLZXldOwogfQorCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChX ZWJJbnRlcm5hbCkKSW5kZXg6IFdlYktpdC93aW4vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdC93aW4vQ2hhbmdlTG9nCShyZXZpc2lvbiAzNjMyMykKKysrIFdlYktpdC93aW4vQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTUgQEAKKzIwMDgtMDktMTAgIEdsZW5uIFdp bHNvbiAgPHdpbHNvbmdAZ21haWwuY29tPgorCisgICAgICAgIENoYW5nZWQgV2ViUHJlZmVyZW5j ZXMgdG8gaGF2ZSBhIGdlbmVyYWwgbWV0aG9kIGZvciBvdmVycmlkaW5nIGRlZmF1bHQKKyAgICAg ICAgY29uZmlndXJhdGlvbiB2YWx1ZXMgKGxpa2UgaGF2aW5nIEphdmFTY3JpcHQgZW5hYmxlZCkg YXQgdGVzdCB0aW1lLgorICAgICAgICBBbHNvIGFkZGVkIG1ldGhvZHMgZm9yIHJlc2V0dGluZyBX ZWJQcmVmZXJlbmNlcyB0byBpdHMgZGVmYXVsdCB2YWx1ZXMgaWYKKyAgICAgICAgYW55IHByZWZl cmVuY2UgaGFzIGJlZW4gb3ZlcnJpZGRlbi4KKworCisgICAgICAgICogSW50ZXJmYWNlcy9JV2Vi UHJlZmVyZW5jZXMuaWRsOiBBZGRlZCBzaWduYXR1cmVzIGZvciB0aGUgdHdvIG5ldyBtZXRob2Rz CisgICAgICAgICogV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmg6ICBBZGRlZCBuZXcga2V5IGZv ciBmbGFnZ2luZyB3aGVuIG92ZXJyaWRlcyBoYXBwZW4KKyAgICAgICAgKiBXZWJQcmVmZXJlbmNl cy5jcHA6CisgICAgICAgIChXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKTogbmV3 IG1ldGhvZCB0byBvdmVycmlkZSBwcmVmZXJlbmNlcyBtYW51YWxseQorICAgICAgICAoV2ViUHJl ZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cyk6IG5ldyBtZXRob2QgdG8gcmVzZXQgcHJlZmVyZW5j ZXMgYWZ0ZXIgb3ZlcnJpZGUKKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5oOiBBZGRlZCBzaWdu YXR1cmVzIGZvciBuZXcgbWV0aG9kcworCiAyMDA4LTA5LTA4ICBBZGFtIFJvYmVuICA8YXJvYmVu QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXNwZWN0IHRoZSBmb250IHNtb290aGluZyBwcmVmZXJl bmNlIHdoZW4gZHJhd2luZyB2aWEgV2ViS2l0R3JhcGhpY3MKSW5kZXg6IFdlYktpdC93aW4vV2Vi UHJlZmVyZW5jZXMuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMu Y3BwCShyZXZpc2lvbiAzNjI5OSkKKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0xMTg1LDYgKzExODYsMzkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxM VFlQRSBXZWJQcmVmZXJlbmNlcwogICAgIHJldHVybiBTX09LOwogfQogCitIUkVTVUxUIFNURE1F VEhPRENBTExUWVBFIFdlYlByZWZlcmVuY2VzOjpvdmVycmlkZVByZWZlcmVuY2UoQlNUUiBrZXks IEJTVFIgdmFsdWUpCit7CisgICAgQ0ZTdHJpbmdSZWYga2V5cmVmID0gQ0ZTdHJpbmdDcmVhdGVX aXRoQ2hhcmFjdGVyc05vQ29weSgwLCAoVW5pQ2hhciopX3djc2R1cChrZXkpLCAoQ0ZJbmRleClf dGNzbGVuKGtleSksIGtDRkFsbG9jYXRvck1hbGxvYyk7CisgICAgc2V0U3RyaW5nVmFsdWUoa2V5 cmVmLCB2YWx1ZSk7CisgICAgc2V0Qm9vbFZhbHVlKENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJl bmNlc092ZXJyaWRkZW4pLCB0cnVlKTsKKyAgICByZXR1cm4gU19PSzsKK30KKworSFJFU1VMVCBT VERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKCkKK3sKKyAg ICBpZiAoIWJvb2xWYWx1ZUZvcktleShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVy cmlkZGVuKSkpCisgICAgICAgIHJldHVybiBTX09LOworCisgICAgaW50IGNvdW50ID0gQ0ZEaWN0 aW9uYXJ5R2V0Q291bnQoZGVmYXVsdFNldHRpbmdzKTsKKyAgICBpZiAoY291bnQgPD0gMCkKKyAg ICAgICAgcmV0dXJuIFNfT0s7CisgICAgCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlz KG5ldyBDRlR5cGVSZWZbY291bnRdKTsKKyAgICBPd25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVl cyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAgQ0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVl cyhkZWZhdWx0U2V0dGluZ3MsIGtleXMuZ2V0KCksIHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3Ig KGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpIHsKKyAgICAgICAgQlNUUiB2YWwgPSBzdHJpbmdW YWx1ZUZvcktleShzdGF0aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSkpOworICAgICAgICBz ZXRWYWx1ZUZvcktleShzdGF0aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSksIHZhbHVlc1tp XSk7CisgICAgfQorCisgICAgc2V0Qm9vbFZhbHVlKENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJl bmNlc092ZXJyaWRkZW4pLCBmYWxzZSk7CisKKyAgICBwb3N0UHJlZmVyZW5jZXNDaGFuZ2VzTm90 aWZpY2F0aW9uKCk7CisKKyAgICByZXR1cm4gU19PSzsKK30KKwogdm9pZCBXZWJQcmVmZXJlbmNl czo6d2lsbEFkZFRvV2ViVmlldygpCiB7CiAgICAgKyttX251bVdlYlZpZXdzOwpJbmRleDogV2Vi S2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJl ZmVyZW5jZXMuaAkocmV2aXNpb24gMzYyOTkpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmgJKHdvcmtpbmcgY29weSkKQEAgLTMyMCw2ICszMjAsMTIgQEAgcHVibGljOgogICAgIHZpcnR1 YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKCAK ICAgICAvKiBbcmV0dmFsXVtvdXRdICovIEJPT0wgKnNob3VsZFBhaW50KTsKIAorICAgIHZpcnR1 YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBvdmVycmlkZVByZWZlcmVuY2UoCisgICAgICAg IC8qIFtpbl0gKi8gQlNUUiBrZXksCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisK KyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7 CisKICAgICAvLyBXZWJQcmVmZXJlbmNlcwogCiAgICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMg YSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJ bmRleDogV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlcy5pZGwKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlcy5pZGwJKHJldmlzaW9u IDM2Mjk5KQorKysgV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlcy5pZGwJKHdv cmtpbmcgY29weSkKQEAgLTE4Myw0ICsxODMsNyBAQCBpbnRlcmZhY2UgSVdlYlByZWZlcmVuY2Vz IDogSVVua25vd24KIAogICAgIEhSRVNVTFQgc2V0U2hvdWxkUGFpbnRDdXN0b21TY3JvbGxiYXJz KEJPT0wgc2hvdWxkUGFpbnQpOwogICAgIEhSRVNVTFQgc2hvdWxkUGFpbnRDdXN0b21TY3JvbGxi YXJzKEJPT0wgKnNob3VsZFBhaW50KTsKKworICAgIEhSRVNVTFQgb3ZlcnJpZGVQcmVmZXJlbmNl KFtpbl0gQlNUUiBrZXksIFtpbl0gQlNUUiB2YWx1ZSk7CisgICAgSFJFU1VMVCByZXNldFRvRGVm YXVsdHMoKTsKIH0KSW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJLaXRUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDM2MzIzKQorKysgV2ViS2l0VG9vbHMvQ2hh bmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDgtMDktMTAgIEdsZW5u IFdpbHNvbiAgPGd3aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBDaGFuZ2VkIExheW91dFRl c3RDb250cm9sbGVyIGFuZCBEdW1wUmVuZGVyVHJlZSB0byBhbGxvdyBmb3IgbWFudWFsCisgICAg ICAgIG92ZXJyaWRpbmcgb2YgZGVmYXVsdCBwcmVmZXJlbmNlcyBhdCB0ZXN0IHRpbWUuICBBbHNv IGFkZGVkIHN1cHBvcnQgZm9yCisgICAgICAgIHJlc2V0dGluZyB0aGUgcHJlZmVyZW5jZXMgYWZ0 ZXIgZWFjaCB0ZXN0LiAgICAgICAgCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5jcHA6IEFkZGVkIGNhbGxiYWNrIG1ldGhvZCBmb3Igb3ZlcnJpZGluZyBw cmVmZXJlbmNlcworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVy Lmg6IEFkZGVkIHNpZ25hdHVyZSBmb3IgY2FsbGJhY2sKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVmZXJlbmNl cyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5CisgICAgICAgICogRHVtcFJlbmRlclRyZWUv d2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDogQWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rp b24KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW06IEFkZGVk IGNhbGxzIHRvIHJlc2V0IHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkK KyAgICAgICAgKHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZyk6Cisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOiBB ZGRlZCBKUyBvdmVycmlkZSBmdW5jdGlvbgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6 Om92ZXJyaWRlUHJlZmVyZW5jZSk6CisKKwogMjAwOC0wOS0wOCAgRGFuIEJlcm5zdGVpbiAgPG1p dHpAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE1hcmsgUm93ZS4KSW5kZXg6IFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5j cHAJKHJldmlzaW9uIDM2Mjk5KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMjMsNiArMzIzLDIwIEBAIHN0 YXRpYyBKU1ZhbHVlUmVmIGV4ZWNDb21tYW5kQ2FsbGJhY2soSlMKICAgICByZXR1cm4gSlNWYWx1 ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG92ZXJyaWRl UHJlZmVyZW5jZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5j dGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0 IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBp ZiAoYXJndW1lbnRDb3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5l ZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRvcHQsIEpT VmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAg ICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRy b2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RH ZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlkZVByZWZlcmVu Y2Uoa2V5LmdldCgpLCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwg ZXhjZXB0aW9uKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7 Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0 UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0 LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNW YWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRpb24KQEAg LTcwNCw2ICs3MjgsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 CiAgICAgICAgIHsgImV4ZWNDb21tYW5kIiwgZXhlY0NvbW1hbmRDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1By b3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUg fSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAor ICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJwYXRoVG9Mb2NhbFJlc291cmNlIiwgcGF0aFRvTG9jYWxS ZXNvdXJjZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVy dHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlQmFja05hdmlnYXRpb24i LCBxdWV1ZUJhY2tOYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicXVldWVG b3J3YXJkTmF2aWdhdGlvbiIsIHF1ZXVlRm9yd2FyZE5hdmlnYXRpb25DYWxsYmFjaywga0pTUHJv cGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9 LApJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29u dHJvbGxlci5oCShyZXZpc2lvbiAzNjI5OSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTYyLDExICs2MiwxMyBA QCBwdWJsaWM6CiAgICAgdm9pZCBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkKGJvb2wgZmxhZyk7 CiAgICAgdm9pZCBzZXRQb3B1cEJsb2NraW5nRW5hYmxlZChib29sIGZsYWcpOwogICAgIHZvaWQg c2V0VGFiS2V5Q3ljbGVzVGhyb3VnaEVsZW1lbnRzKGJvb2wgY3ljbGVzKTsKICAgICB2b2lkIHNl dFVzZURhc2hib2FyZENvbXBhdGliaWxpdHlNb2RlKGJvb2wgZmxhZyk7CiAgICAgdm9pZCBzZXRV c2VyU3R5bGVTaGVldEVuYWJsZWQoYm9vbCBmbGFnKTsKICAgICB2b2lkIHNldFVzZXJTdHlsZVNo ZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CiAgICAgdm9pZCBzZXRQZXJzaXN0ZW50VXNl clN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2b2lkIGNsZWFyUGVy c2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAgdm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNT dHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKTsKKwogICAgIGludCB3aW5kb3dDb3VudCgp OwogICAgIAogICAgIGJvb2wgZWxlbWVudERvZXNBdXRvQ29tcGxldGVGb3JFbGVtZW50V2l0aElk KEpTU3RyaW5nUmVmIGlkKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9E dW1wUmVuZGVyVHJlZS5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0JKHJldmlzaW9uIDM2Mjk5KQorKysgV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3b3JraW5nIGNvcHkpCkBAIC05 NDcsNyArOTQ3LDggQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdAog ICAgIFt3ZWJWaWV3IF9zZXREYXNoYm9hcmRCZWhhdmlvcjpXZWJEYXNoYm9hcmRCZWhhdmlvclVz ZUJhY2t3YXJkQ29tcGF0aWJpbGl0eU1vZGUgdG86Tk9dOwogCiAgICAgV2ViUHJlZmVyZW5jZXMg KnByZWZlcmVuY2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOwotICAgIFtwcmVmZXJlbmNlcyBz ZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKKyAgICBbcHJlZmVyZW5jZXMgcmVzZXRUb0Rl ZmF1bHRzXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZDpOT107 CiAgICAgW3ByZWZlcmVuY2VzIHNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkOllFU107CiAg ICAgW3ByZWZlcmVuY2VzIHNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHk6 WUVTXTsKICAgICBbcHJlZmVyZW5jZXMgc2V0T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFi bGVkOllFU107CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVz dENvbnRyb2xsZXJNYWMubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCShyZXZpc2lvbiAzNjI5OSkKKysrIFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQko d29ya2luZyBjb3B5KQpAQCAtMjMwLDYgKzIzMCwxNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjpzZXRVc2VyU3R5bGVTCiAgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVu Y2VzXSBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uOnVybF07CiB9CiAKK3ZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5n UmVmIGZsYWcpCit7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBrZXlDRihBZG9wdENGLCBK U1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBrZXkpKTsKKyAgICBOU1N0 cmluZyAqa2V5TlMgPSAoTlNTdHJpbmcgKilrZXlDRi5nZXQoKTsKKwkKKyAgICBSZXRhaW5QdHI8 Q0ZTdHJpbmdSZWY+IGZsYWdDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxv Y2F0b3JEZWZhdWx0LCBmbGFnKSk7CisgICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAq KWZsYWdDRi5nZXQoKTsKKwkKKyAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5j ZXNdIG92ZXJyaWRlUHJlZmVyZW5jZTprZXlOUyBmbGFnOmZsYWdOU107CQorfQorCiB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihK U1N0cmluZ1JlZiBqc1VSTCkKIHsKICAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHVybFN0cmlu ZyhBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZygwLCBqc1VSTCkpOwpJbmRleDogV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCShyZXZp c2lvbiAzNjI5OSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVy VHJlZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY0MCw2ICs2NDAsNyBAQCBzdGF0aWMgdm9pZCBy ZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAKICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2Vz PiBwcmVmZXJlbmNlczsKICAgICBpZiAoU1VDQ0VFREVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZw cmVmZXJlbmNlcykpKSB7CisgICAgICAgIHByZWZlcmVuY2VzLT5yZXNldFRvRGVmYXVsdHMoKTsJ CQogICAgICAgICBwcmVmZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZChGQUxTRSk7 CiAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0 aWNhbGx5KFRSVUUpOwogCkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5 b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHJldmlzaW9uIDM2Mjk5 KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVy V2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTY5LDMgKzU4MiwyMyBAQCB2b2lkIExheW91dFRl c3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1CiB7ICAgIAogICAgIHByaW50ZigiRVJST1I6IExh eW91dFRlc3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1b3RhKCkgbm90IGltcGxlbWVudGVkXG4i KTsKIH0KKwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpT U3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+ IHdlYlZpZXc7CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAg ICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsK KyAgICBpZiAoRkFJTEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAg ICAgICByZXR1cm47CisKKyAgICB3c3RyaW5nIHdLZXkgPSBqc1N0cmluZ1JlZlRvV1N0cmluZyhr ZXkpOworICAgIHdzdHJpbmcgd0ZsYWcgPSBqc1N0cmluZ1JlZlRvV1N0cmluZyhmbGFnKTsKKwor ICAgIEJTVFIga2V5QlNUUiA9IFN5c0FsbG9jU3RyaW5nTGVuKChPTEVDSEFSKil3S2V5LmNfc3Ry KCksIHdLZXkubGVuZ3RoKCkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBTeXNBbGxvY1N0cmluZ0xl bigoT0xFQ0hBUiopd0ZsYWcuY19zdHIoKSwgd0ZsYWcubGVuZ3RoKCkpOworICAgIHByZWZlcmVu Y2VzLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5QlNUUiwgZmxhZ0JTVFIpOworICAgIFN5c0ZyZWVT dHJpbmcoa2V5QlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhmbGFnQlNUUik7Cit9CkluZGV4OiBM YXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CShyZXZpc2lvbiAzNjMyMykKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDE3IEBACisyMDA4LTA5LTEwICBHbGVubiBXaWxzb24gIDx3aWxzb25nQGdt YWlsLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAgICAg QWRkZWQgbmV3IHRlc3RzIGZvciB2ZXJpZnlpbmcgdGhhdCB0aGUgbGF5b3V0VGVzdENvbnRyb2xs ZXIgY2FuIGhhdmUKKyAgICAgICAgaXRzIHByZWZlcmVuY2VzIG92ZXJyaWRkZW4gbWFudWFsbHks IGFuZCB0aGF0IHRob3NlIHByZWZlcmVuY2VzIGFyZQorICAgICAgICByZXNldCBhZnRlciBldmVy eSB0ZXN0LCBpZiBuZWNlc3NhcnkuCisKKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy0yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJp ZGUtcHJlZmVyZW5jZXMtMi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292 ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJy aWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292 ZXJyaWRlLXp6ei1yZXNldC5odG1sOiBBZGRlZC4KKwogMjAwOC0wOS0xMCAgQWxleGV5IFByb3Nr dXJ5YWtvdiAgPGFwQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRs ZXIuCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4 cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1w cmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9s bGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRlbi4gVGhpcyB0ZXN0 IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFjY2VwdCBzdHJpbmcgdmFsdWVzIGFuZCBhbHNv IG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6ZS4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJl bG93LgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJl bmNlcy0yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt cHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBA Cis8aHRtbD4KKzxzY3JpcHQ+CisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7 CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKCJXZWJLaXREZWZhdWx0Rm9udFNp emUiLCAiMjQiKTsKKyAgICB9Cis8L3NjcmlwdD4KKzxib2R5PgorICAgIDxwPlRoaXMgdGVzdCB2 ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHBy ZWZlcmVuY2VzIG92ZXJyaWRlbi4gIAorICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBB UEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVs dCBmb250IHNpemUuICAKKyAgICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuPC9wPgorICAg IDxzY3JpcHQ+CisgICAgICAgIHZhciBwID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUo InAiKVswXTsKKyAgICAgICAgaWYoIXdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlciB8fCB3aW5k b3cuZ2V0Q29tcHV0ZWRTdHlsZShwKS5mb250U2l6ZSA9PSAiMjRweCIpCisgICAgICAgICAgICBk b2N1bWVudC53cml0ZSgiUEFTUyIpOworICAgIDwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJ bmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVu Y2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292 ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwz IEBACitUaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xs ZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gVGhpcyB0ZXN0 IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5k IHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5nIHdpdGggYSBicm93c2VyLgor CitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5o dG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVu Y2VzLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1w cmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBACis8aHRtbD4gCis8 Ym9keT4gCis8c2NyaXB0PiAKKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsK KyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpCisgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJs ZWQiLCBmYWxzZSk7CisgICAgfQorICAgIAorICAgIGZ1bmN0aW9uIGxvYWRzdGF0dXMoKSB7Cisg ICAgICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMiKS5pbm5lckhUTUw9IkZBSUwiOworICAgIH0KKzwv c2NyaXB0PiAKKzxib2R5IG9ubG9hZD0ibG9hZHN0YXR1cygpIj4KKyAgICA8cD5UaGlzIGlzIGEg dGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRz IGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkg Y2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNl ZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci48L3A+CisgICAgPHNwYW4g aWQ9InN0YXR1cyI+UEFTUzwvc3Bhbj4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1l eHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlm aWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQg cHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuIFlvdSBzaG91bGQgc2VlICJQQVNT IiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6 LXJlc2V0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt enp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVy cmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNCBAQAorPGh0bWw+ IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4g Cis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5b3V0VGVzdENv bnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRlciBldmVyeSBs YXlvdXQgdGVzdC4gIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNwYW4g aWQ9InN0YXR1cyI+RkFJTDwvc3Bhbj4KKyAgICA8c2NyaXB0PgorICAgICAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJQQVNTIjsgICAgICAgIAorICAgIDwv c2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 23484 2008-09-16 13:14:32 -0700 2008-10-08 13:58:02 -0700 Improved possible fix to bug 20534 patch20534-2.txt text/plain 21501 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L21hYy9D aGFuZ2VMb2cJKHJldmlzaW9uIDM2NDQ3KQ0KKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpDQpAQCAtMSwzICsxLDE2IEBADQorMjAwOC0wOS0xNSAgR2xlbm4gV2lsc29uICA8 Z3dpbHNvbkBnb29nbGUuY29tPg0KKw0KKyAgICAgICAgQWRkZWQgbmV3IG1ldGhvZHMgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBXZWJQcmVmZXJlbmNlIHZhbHVlcw0KKyAgICAgICAgYW5kIGZvciBy ZXNldHRpbmcgcHJlZmVyZW5jZXMgdG8gdGhlaXIgZGVmYXVsdHMuIChidWcgMjA1MzQpDQorDQor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4NCisNCisgICAgICAgICogV2ViVmll dy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDoNCisgICAgICAgICogV2ViVmlldy9XZWJQcmVm ZXJlbmNlcy5tbToNCisgICAgICAgICgtW1dlYlByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0c10p OiBuZXcgbWV0aG9kDQorICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVu Y2U6ZmxhZzpdKTogbmV3IG1ldGhvZA0KKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2Vz UHJpdmF0ZS5oOiBuZXcgbWV0aG9kIHNpZ25hdHVyZXMNCisNCiAyMDA4LTA5LTEyICBKb2huIFN1 bGxpdmFuICA8c3VsbGl2YW5AYXBwbGUuY29tPg0KIA0KICAgICAgICAgRml4ZWQgPHJkYXI6Ly9w cm9ibGVtLzYxMTA5NDE+IENsaWNraW5nIHRoZSBwcmludCBidXR0b24gaW4gUERGIGNvbnRlbnQg ZG9lcyBub3RoaW5nDQpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlz UHJpdmF0ZS5oDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCShyZXZpc2lvbiAzNjMyMykNCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcv V2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkNCkBAIC03MCw2ICs3MCw3 IEBADQogI2RlZmluZSBXZWJLaXRFbmFibGVGdWxsRG9jdW1lbnRUZWFyZG93blByZWZlcmVuY2VL ZXkgQCJXZWJLaXRFbmFibGVGdWxsRG9jdW1lbnRUZWFyZG93biINCiAjZGVmaW5lIFdlYktpdE9m ZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZs aW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQiDQogI2RlZmluZSBXZWJLaXRab29tc1RleHRP bmx5UHJlZmVyZW5jZUtleSBAIldlYktpdFpvb21zVGV4dE9ubHkiDQorI2RlZmluZSBXZWJLaXRE ZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuIEAiV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3Zl cnJpZGRlbiINCiANCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2UgY2FsbGVycyBz aG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhlDQogLy8gY292 ZXIgbWV0aG9kcyB0aGVtc2VsdmVzIGFyZSBwcml2YXRlLg0KSW5kZXg6IFdlYktpdC9tYWMvV2Vi Vmlldy9XZWJQcmVmZXJlbmNlcy5tbQ0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9tYWMvV2ViVmll dy9XZWJQcmVmZXJlbmNlcy5tbQkocmV2aXNpb24gMzYzMjMpDQorKysgV2ViS2l0L21hYy9XZWJW aWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpDQpAQCAtMTA1NSw2ICsxMDU1LDI1 IEBAIHN0YXRpYyBOU1N0cmluZyAqY2xhc3NJQkNyZWF0b3JJRCA9IG5pbDsNCiB7DQogICAgIHJl dHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1bGxEb2N1bWVudFRlYXJk b3duUHJlZmVyZW5jZUtleV07DQogfQ0KKw0KKy0gKHZvaWQpcmVzZXRUb0RlZmF1bHRzDQorew0K KyAgICBpZiAoIVtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2Vz T3ZlcnJpZGRlbl0pDQorICAgICAgICByZXR1cm47DQorICAgIFtzZWxmIGluaXRdOw0KKwkNCisg ICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb25dOwkNCisgICAgW3Nl bGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3Zl cnJpZGRlbl07DQorfQ0KKw0KKy0gKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKXByZWZlcmVuY2VGbGFnDQorew0KKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07DQorICAgIFtzZWxmIF9zZXRC b29sVmFsdWU6dHJ1ZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbl07 DQorfQ0KKw0KKw0KKw0KIEBlbmQNCiANCiBAaW1wbGVtZW50YXRpb24gV2ViUHJlZmVyZW5jZXMg KFdlYkludGVybmFsKQ0KSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1By aXZhdGUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNl c1ByaXZhdGUuaAkocmV2aXNpb24gMzYzMjMpDQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlBy ZWZlcmVuY2VzUHJpdmF0ZS5oCSh3b3JraW5nIGNvcHkpDQpAQCAtODcsNiArODcsMjEgQEAgZXh0 ZXJuIE5TU3RyaW5nICpXZWJQcmVmZXJlbmNlc1JlbW92ZWRObw0KIC0gKFdlYktpdEVkaXRhYmxl TGlua0JlaGF2aW9yKWVkaXRhYmxlTGlua0JlaGF2aW9yOw0KIC0gKHZvaWQpc2V0RWRpdGFibGVM aW5rQmVoYXZpb3I6KFdlYktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOw0KIA0KKy8q IQ0KKyBAbWV0aG9kIG92ZXJyaWRlUHJlZmVyZW5jZToNCisgQHBhcmFtIGtleSBUaGUga2V5IG9m IHRoZSBwcmVmZXJlbmNlIHRvIGJlIG92ZXJyaWRkZW4NCisgQHBhcmFtIGZsYWcgVGhlIGRlc2ly ZWQgdmFsdWUgb2YgdGhlIHByZWZlcmVuY2UNCisgQGFic3RyYWN0IFNldHMgdGhlIGdpdmVuIHZh bHVlIG9mIGEgZ2l2ZW4gcHJlZmVyZW5jZQ0KKyAqLw0KKy0odm9pZClvdmVycmlkZVByZWZlcmVu Y2U6KE5TU3RyaW5nICopa2V5IGZsYWc6KE5TU3RyaW5nICopZmxhZzsNCisNCisvKiENCisgQG1l dGhvZCByZXNldFRvRGVmYXVsdHM6DQorIEBhYnN0cmFjdCByZXNldHMgdGhlIHByZWZlcmVuY2Vz IHRvIHRoZWlyIGRlZmF1bHQgdmFsdWVzDQorICovDQorLSh2b2lkKXJlc2V0VG9EZWZhdWx0czsN CisNCisNCiAvLyBJZiBzaXRlLXNwZWNpZmljIHNwb29maW5nIGlzIGVuYWJsZWQsIHNvbWUgcGFn ZXMgdGhhdCBkbyBpbmFwcHJvcHJpYXRlIHVzZXItYWdlbnQgc3RyaW5nIGNoZWNrcyB3aWxsIGJl DQogLy8gcGFzc2VkIGEgbm9uc3RhbmRhcmQgdXNlci1hZ2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0g dG8gd29yayBjb3JyZWN0bHkuIFRoaXMgbWV0aG9kIG1pZ2h0IGJlIHJlbW92ZWQgaW4NCiAvLyB0 aGUgZnV0dXJlIHdoZW4gdGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0Lg0KSW5kZXg6IFdlYktp dC93aW4vQ2hhbmdlTG9nDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJl dmlzaW9uIDM2NDQ3KQ0KKysrIFdlYktpdC93aW4vQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpDQpA QCAtMSwzICsxLDE3IEBADQorMjAwOC0wOS0xNSAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29n bGUuY29tPg0KKw0KKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuDQorDQorICAg ICAgICBBZGRlZCBzdXBwb3J0IGZvciBvdmVycmlkaW5nIGRlZmF1bHQgcHJlZmVyZW5jZXMgcGVy LXRlc3QuIChidWcgMjA1MzQpDQorICAgICAgICBUd28gbmV3IG1ldGhvZHMgd2VyZSBhZGRlZDog cmVzZXRUb0RlZmF1bHRzIGFuZCBvdmVycmlkZVByZWZlcmVuY2UuDQorDQorICAgICAgICAqIElu dGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGw6IG5ldyBtZXRob2Qgc2lnbmF0dXJl cw0KKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDogYWRkZWQgbmV3IGtleSBm b3IgaW50ZXJuYWwgc3RhdGUNCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBu ZXcgbWV0aG9kcw0KKyAgICAgICAgKFdlYlByZWZlcmVuY2VzOjpvdmVycmlkZVByZWZlcmVuY2Up OiBuZXcgbWV0aG9kDQorICAgICAgICAoV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cyk6 IG5ldyBtZXRob2QNCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuaDogbmV3IG1ldGhvZCBzaWdu YXR1cmVzDQorDQogMjAwOC0wOS0xMyAgRGF2ZSBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4NCiAN CiAgICAgICAgIEFkZCBTY3JvbGxiYXJUaGVtZSB0byB0aGUgYnVpbGQuDQpJbmRleDogV2ViS2l0 L3dpbi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaA0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdC93 aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHJldmlzaW9uIDM2MzIzKQ0KKysrIFdlYktp dC93aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkNCkBAIC02MCw2 ICs2MCw3IEBADQogI2RlZmluZSBXZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2Vi S2l0VXNlc1BhZ2VDYWNoZVByZWZlcmVuY2VLZXkiDQogI2RlZmluZSBXZWJLaXRDYWNoZU1vZGVs UHJlZmVyZW5jZUtleSAiV2ViS2l0Q2FjaGVNb2RlbFByZWZlcmVuY2VLZXkiDQogI2RlZmluZSBX ZWJLaXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGhQcmVmZXJlbmNlS2V5ICJXZWJLaXRMb2NhbFN0 b3JhZ2VEYXRhYmFzZVBhdGgiDQorI2RlZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVy cmlkZGVuICJXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuIg0KIA0KIC8vIFRoZXNl IGFyZSBwcml2YXRlIGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292 ZXIgbWV0aG9kcyBhbmQgYmVjYXVzZSB0aGUNCiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMg YXJlIHByaXZhdGUuDQpJbmRleDogV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHANCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0NCi0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAkocmV2aXNpb24gMzYzMjMp DQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAJKHdvcmtpbmcgY29weSkNCkBAIC0x MTg1LDYgKzExODUsMzkgQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNl cw0KICAgICByZXR1cm4gU19PSzsNCiB9DQogDQorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBX ZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCU1RSIHZhbHVlKQ0K K3sNCisgICAgQ0ZTdHJpbmdSZWYga2V5cmVmID0gQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVy c05vQ29weSgwLCAoVW5pQ2hhciopX3djc2R1cChrZXkpLCAoQ0ZJbmRleClfdGNzbGVuKGtleSks IGtDRkFsbG9jYXRvck1hbGxvYyk7DQorCXNldFN0cmluZ1ZhbHVlKGtleXJlZiwgdmFsdWUpOw0K KyAgICBzZXRCb29sVmFsdWUoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRl biksIHRydWUpOw0KKyAgICByZXR1cm4gU19PSzsNCit9DQorDQorSFJFU1VMVCBTVERNRVRIT0RD QUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKCkNCit7DQorICAgIGlmICgh Ym9vbFZhbHVlRm9yS2V5KENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4p KSkNCisgICAgICAgIHJldHVybiBTX09LOw0KKw0KKyAgICBpbnQgY291bnQgPSBDRkRpY3Rpb25h cnlHZXRDb3VudChkZWZhdWx0U2V0dGluZ3MpOw0KKyAgICBpZiAoY291bnQgPD0gMCkNCisgICAg ICAgIHJldHVybiBTX09LOw0KKyAgICANCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlz KG5ldyBDRlR5cGVSZWZbY291bnRdKTsNCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiB2YWx1 ZXMobmV3IENGVHlwZVJlZltjb3VudF0pOw0KKyAgICBDRkRpY3Rpb25hcnlHZXRLZXlzQW5kVmFs dWVzKGRlZmF1bHRTZXR0aW5ncywga2V5cy5nZXQoKSwgdmFsdWVzLmdldCgpKTsNCisNCisgICAg Zm9yIChpbnQgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7DQorICAgICAgICBCU1RSIHZhbCA9IHN0 cmluZ1ZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSk7DQorICAg ICAgICBzZXRWYWx1ZUZvcktleShzdGF0aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSksIHZh bHVlc1tpXSk7DQorICAgIH0NCisNCisgICAgc2V0Qm9vbFZhbHVlKENGU1RSKFdlYktpdERlZmF1 bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4pLCBmYWxzZSk7DQorDQorICAgIHBvc3RQcmVmZXJlbmNl c0NoYW5nZXNOb3RpZmljYXRpb24oKTsNCisNCisgICAgcmV0dXJuIFNfT0s7DQorfQ0KKw0KIHZv aWQgV2ViUHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZpZXcoKQ0KIHsNCiAgICAgKyttX251bVdl YlZpZXdzOw0KSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaA0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0K LS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAkocmV2aXNpb24gMzYzMjMpDQorKysgV2Vi S2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpDQpAQCAtMzIwLDYgKzMyMCwx MiBAQCBwdWJsaWM6DQogICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzaG91 bGRQYWludE5hdGl2ZUNvbnRyb2xzKCANCiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBCT09MICpz aG91bGRQYWludCk7DQogDQorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBv dmVycmlkZVByZWZlcmVuY2UoDQorICAgICAgICAvKiBbaW5dICovIEJTVFIga2V5LA0KKyAgICAg ICAgLyogW2luXSAqLyBCU1RSIHZhbHVlKTsNCisNCisgICAgdmlydHVhbCBIUkVTVUxUIFNURE1F VEhPRENBTExUWVBFIHJlc2V0VG9EZWZhdWx0cygpOw0KKw0KICAgICAvLyBXZWJQcmVmZXJlbmNl cw0KIA0KICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3NlcyBhIGRpZmZlcmVudCBwcmVmZXJlbmNl IGtleSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQuDQpJbmRleDogV2ViS2l0L3dpbi9JbnRl cmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsDQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0 L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCShyZXZpc2lvbiAzNjMy MykNCisrKyBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJ KHdvcmtpbmcgY29weSkNCkBAIC02MCw0ICs2MCw3IEBAIGludGVyZmFjZSBJV2ViUHJlZmVyZW5j ZXNQcml2YXRlIDogSVVua24NCiANCiAgICAgSFJFU1VMVCBzZXRTaG91bGRQYWludE5hdGl2ZUNv bnRyb2xzKFtpbl0gQk9PTCBzaG91bGRQYWludCk7DQogICAgIEhSRVNVTFQgc2hvdWxkUGFpbnRO YXRpdmVDb250cm9scyhbb3V0LCByZXR2YWxdIEJPT0wqIGVuYWJsZWQpOw0KKw0KKyAgICBIUkVT VUxUIG92ZXJyaWRlUHJlZmVyZW5jZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOw0K KyAgICBIUkVTVUxUIHJlc2V0VG9EZWZhdWx0cygpOw0KIH0NCkluZGV4OiBXZWJLaXRUb29scy9D aGFuZ2VMb2cNCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0NCi0tLSBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9u IDM2NDQ3KQ0KKysrIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQ0KQEAgLTEs MyArMSwxNiBAQA0KKzIwMDgtMDktMTUgIEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AZ29vZ2xlLmNv bT4NCisNCisgICAgICAgIENoYW5nZWQgTGF5b3V0VGVzdENvbnRyb2xsZXIgYW5kIER1bXBSZW5k ZXJUcmVlIHRvIGFsbG93IGZvciBtYW51YWwNCisgICAgICAgIG92ZXJyaWRpbmcgb2YgZGVmYXVs dCBwcmVmZXJlbmNlcyBhdCB0ZXN0IHRpbWUuICBBbHNvIGFkZGVkIHN1cHBvcnQgZm9yDQorICAg ICAgICByZXNldHRpbmcgdGhlIHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdC4gKGJ1ZyAyMDUz NCkNCisNCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw OiBBZGRlZCBjYWxsYmFjayBtZXRob2QgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMNCisgICAg ICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaDogQWRkZWQgc2lnbmF0 dXJlIGZvciBjYWxsYmFjaw0KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRl clRyZWUuY3BwOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRl c3QgaWYgbmVjZXNzYXJ5DQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0 Q29udHJvbGxlcldpbi5jcHA6IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uDQorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbTogQWRkZWQgY2FsbHMgdG8gcmVz ZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlmIG5lY2Vzc2FyeQ0KKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06IEFkZGVkIEpTIG92 ZXJyaWRlIGZ1bmN0aW9uDQorDQogMjAwOC0wOS0xNCAgTWFyayBSb3dlICA8bXJvd2VAYXBwbGUu Y29tPg0KIA0KICAgICAgICAgQnVpbGQgZml4Lg0KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcA0KPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAkocmV2aXNpb24gMzYz MjMpDQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwCSh3b3JraW5nIGNvcHkpDQpAQCAtMzIzLDYgKzMyMywyMCBAQCBzdGF0aWMgSlNWYWx1ZVJl ZiBleGVjQ29tbWFuZENhbGxiYWNrKEpTDQogICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5l ZChjb250ZXh0KTsNCiB9DQogDQorc3RhdGljIEpTVmFsdWVSZWYgb3ZlcnJpZGVQcmVmZXJlbmNl Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09i amVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJl ZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQ0KK3sNCisgICAgaWYgKGFyZ3Vt ZW50Q291bnQgPCAyKQ0KKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRl eHQpOw0KKw0KKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5KEFkb3B0LCBKU1ZhbHVl VG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7DQorICAgIEFT U0VSVCghKmV4Y2VwdGlvbik7DQorDQorICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9s bGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0 UHJpdmF0ZSh0aGlzT2JqZWN0KSk7DQorICAgIGNvbnRyb2xsZXItPm92ZXJyaWRlUHJlZmVyZW5j ZShrZXkuZ2V0KCksIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzFdLCBl eGNlcHRpb24pKTsNCisNCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQp Ow0KK30NCisNCiBzdGF0aWMgSlNWYWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09i amVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10s IEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikNCiB7DQogICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRp b24NCkBAIC03MDQsNiArNzI4LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRy b2xsZXI6Og0KICAgICAgICAgeyAiZXhlY0NvbW1hbmQiLCBleGVjQ29tbWFuZENhbGxiYWNrLCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVs ZXRlIH0sDQogICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0b3J5Q2FsbGJh Y2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURv bnREZWxldGUgfSwNCiAgICAgICAgIHsgIm5vdGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ss IGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnRE ZWxldGUgfSwNCisgICAgICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJyaWRlUHJlZmVy ZW5jZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlB dHRyaWJ1dGVEb250RGVsZXRlIH0sDQogICAgICAgICB7ICJwYXRoVG9Mb2NhbFJlc291cmNlIiwg cGF0aFRvTG9jYWxSZXNvdXJjZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5 IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sDQogICAgICAgICB7ICJxdWV1ZUJh Y2tOYXZpZ2F0aW9uIiwgcXVldWVCYWNrTmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sDQogICAg ICAgICB7ICJxdWV1ZUZvcndhcmROYXZpZ2F0aW9uIiwgcXVldWVGb3J3YXJkTmF2aWdhdGlvbkNh bGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1 dGVEb250RGVsZXRlIH0sDQpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuaA0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgJKHJldmlzaW9uIDM2MzIzKQ0KKysrIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkN CkBAIC02Nyw2ICs2Nyw3IEBAIHB1YmxpYzoNCiAgICAgdm9pZCBzZXRVc2VyU3R5bGVTaGVldExv Y2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOw0KICAgICB2b2lkIHNldFBlcnNpc3RlbnRVc2VyU3R5 bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOw0KICAgICB2b2lkIGNsZWFyUGVyc2lz dGVudFVzZXJTdHlsZVNoZWV0KCk7DQorICAgIHZvaWQgb3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3Ry aW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZyk7DQogICAgIGludCB3aW5kb3dDb3VudCgpOw0K ICAgICANCiAgICAgYm9vbCBlbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVsZW1lbnRXaXRoSWQo SlNTdHJpbmdSZWYgaWQpOw0KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9E dW1wUmVuZGVyVHJlZS5tbQ0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQkocmV2aXNpb24gMzYzMjMpDQorKysgV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3b3JraW5nIGNvcHkpDQpA QCAtOTQ3LDYgKzk0Nyw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0 YXQNCiAgICAgW3dlYlZpZXcgX3NldERhc2hib2FyZEJlaGF2aW9yOldlYkRhc2hib2FyZEJlaGF2 aW9yVXNlQmFja3dhcmRDb21wYXRpYmlsaXR5TW9kZSB0bzpOT107DQogDQogICAgIFdlYlByZWZl cmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVuY2VzXTsNCisgICAgW3ByZWZl cmVuY2VzIHJlc2V0VG9EZWZhdWx0c107DQorICAgIFtwcmVmZXJlbmNlcyBzZXRFZGl0YWJsZUxp bmtCZWhhdmlvcjpXZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleV07DQogICAg IFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsNCiAgICAgW3ByZWZl cmVuY2VzIHNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkOllFU107DQogICAgIFtwcmVmZXJl bmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107DQpJbmRl eDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFj Lm1tDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09DQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91 dFRlc3RDb250cm9sbGVyTWFjLm1tCShyZXZpc2lvbiAzNjMyMykNCisrKyBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtpbmcgY29w eSkNCkBAIC0yMzAsNiArMjMwLDE3IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFVz ZXJTdHlsZVMNCiAgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBzZXRV c2VyU3R5bGVTaGVldExvY2F0aW9uOnVybF07DQogfQ0KIA0KK3ZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZs YWcpDQorew0KKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleUNGKEFkb3B0Q0YsIEpTU3Ry aW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGtleSkpOw0KKyAgICBOU1N0cmlu ZyAqa2V5TlMgPSAoTlNTdHJpbmcgKilrZXlDRi5nZXQoKTsNCisJDQorICAgIFJldGFpblB0cjxD RlN0cmluZ1JlZj4gZmxhZ0NGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9j YXRvckRlZmF1bHQsIGZsYWcpKTsNCisgICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAq KWZsYWdDRi5nZXQoKTsNCisJDQorICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJl bmNlc10gb3ZlcnJpZGVQcmVmZXJlbmNlOmtleU5TIGZsYWc6ZmxhZ05TXTsJDQorfQ0KKw0KIHZv aWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0 aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQ0KIHsNCiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1 cmxTdHJpbmcoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsNCkluZGV4 OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwDQo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09DQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVl LmNwcAkocmV2aXNpb24gMzYzMjMpDQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0R1bXBSZW5kZXJUcmVlLmNwcAkod29ya2luZyBjb3B5KQ0KQEAgLTY0MCw2ICs2NDAsMTEgQEAg c3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdA0KIA0KICAgICBDT01QdHI8 SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsNCiAgICAgaWYgKFNVQ0NFRURFRCh3ZWJWaWV3 LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkgew0KKyAgICAgICAgQ09NUHRyPElXZWJQcmVm ZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOw0KKyAgICAg ICAgaWYgKHByZWZzUHJpdmF0ZSkgew0KKyAgICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0QXV0 aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQoVFJVRSk7DQorICAgICAgICAgICAgcHJlZnNQcml2YXRl LT5yZXNldFRvRGVmYXVsdHMoKTsNCisgICAgICAgIH0gICAgICAgIAkJDQogICAgICAgICBwcmVm ZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZChGQUxTRSk7DQogICAgICAgICBwcmVm ZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShUUlVFKTsN CiANCkBAIC02NTMsMTEgKzY1OCw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lz dGVudFN0YXQNCiAgICAgICAgIH0gZWxzZQ0KICAgICAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRV c2VyU3R5bGVTaGVldEVuYWJsZWQoRkFMU0UpOw0KIA0KLSAgICAgICAgQ09NUHRyPElXZWJQcmVm ZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOw0KLSAgICAg ICAgaWYgKHByZWZzUHJpdmF0ZSkNCi0gICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldEF1dGhv ckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOw0KICAgICB9DQogDQogICAgIENPTVB0cjxJV2Vi Vmlld1ByaXZhdGU+IHdlYlZpZXdQcml2YXRlKFF1ZXJ5LCB3ZWJWaWV3KTsNCiAgICAgaWYgKCF3 ZWJWaWV3UHJpdmF0ZSkNCiAgICAgICAgIHJldHVybjsNCkluZGV4OiBXZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwDQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQot LS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2lu LmNwcAkocmV2aXNpb24gMzYzMjMpDQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkod29ya2luZyBjb3B5KQ0KQEAgLTU2OSwzICs1 ODIsMjcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0YWJhc2VRdQ0KIHsgICAg DQogICAgIHByaW50ZigiRVJST1I6IExheW91dFRlc3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1 b3RhKCkgbm90IGltcGxlbWVudGVkXG4iKTsNCiB9DQorDQordm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxh ZykNCit7DQorICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsNCisgICAgaWYgKEZBSUxFRChm cmFtZS0+d2ViVmlldygmd2ViVmlldykpKQ0KKyAgICAgICAgcmV0dXJuOw0KKw0KKyAgICBDT01Q dHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsNCisgICAgaWYgKEZBSUxFRCh3ZWJWaWV3 LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkNCisgICAgICAgIHJldHVybjsNCisNCisgICAg Q09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVy ZW5jZXMpOw0KKyAgICBpZiAoIXByZWZzUHJpdmF0ZSkNCisgICAgICAgIHJldHVybjsNCisNCisg ICAgd3N0cmluZyB3S2V5ID0ganNTdHJpbmdSZWZUb1dTdHJpbmcoa2V5KTsNCisgICAgd3N0cmlu ZyB3RmxhZyA9IGpzU3RyaW5nUmVmVG9XU3RyaW5nKGZsYWcpOw0KKw0KKyAgICBCU1RSIGtleUJT VFIgPSBTeXNBbGxvY1N0cmluZ0xlbigoT0xFQ0hBUiopd0tleS5jX3N0cigpLCB3S2V5Lmxlbmd0 aCgpKTsNCisgICAgQlNUUiBmbGFnQlNUUiA9IFN5c0FsbG9jU3RyaW5nTGVuKChPTEVDSEFSKil3 RmxhZy5jX3N0cigpLCB3RmxhZy5sZW5ndGgoKSk7DQorICAgIHByZWZzUHJpdmF0ZS0+b3ZlcnJp ZGVQcmVmZXJlbmNlKGtleUJTVFIsIGZsYWdCU1RSKTsNCisgICAgU3lzRnJlZVN0cmluZyhrZXlC U1RSKTsNCisgICAgU3lzRnJlZVN0cmluZyhmbGFnQlNUUik7DQorfQ0KSW5kZXg6IExheW91dFRl c3RzL0NoYW5nZUxvZw0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQ0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2 aXNpb24gMzY0NDcpDQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpDQpA QCAtMSwzICsxLDE3IEBADQorMjAwOC0wOS0xNSAgR2xlbm4gV2lsc29uICA8d2lsc29uZ0BnbWFp bC5jb20+DQorDQorICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4NCisgICAgICAg IEFkZGVkIG5ldyB0ZXN0cyBmb3IgdmVyaWZ5aW5nIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9s bGVyIGNhbiBoYXZlDQorICAgICAgICBpdHMgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbiBtYW51YWxs eSwgYW5kIHRoYXQgdGhvc2UgcHJlZmVyZW5jZXMgYXJlDQorICAgICAgICByZXNldCBhZnRlciBl dmVyeSB0ZXN0LCBpZiBuZWNlc3NhcnkuDQorDQorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRl LXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0OiBBZGRlZC4NCisgICAgICAgICogc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sOiBBZGRlZC4NCisgICAgICAgICogc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4NCisgICAgICAgICogc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbDogQWRkZWQuDQorICAgICAgICAqIHNlY3Vy aXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQ6IEFkZGVkLg0KKyAgICAgICAgKiBz ZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbDogQWRkZWQuDQorDQogMjAwOC0wOS0xNSAg QW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPg0KIA0KICAgICAgICAgUmV2aWV3 ZWQgYnkgTWFjaWVqLg0KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZl cmVuY2VzLTItZXhwZWN0ZWQudHh0DQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gTGF5b3V0VGVzdHMvc2VjdXJp dHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApDQorKysg TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDMgQEANCitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBs YXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVy cmlkZW4uIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5n IHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlvdSBzaG91 bGQgc2VlICJQQVNTIiBiZWxvdy4NCisNCitQQVNTDQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJp dHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sDQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09DQotLS0gTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQ0KKysr IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNp b24gMCkNCkBAIC0wLDAgKzEsMTggQEANCis8aHRtbD4NCis8c2NyaXB0Pg0KKyAgICBpZih3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsNCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsNCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJl ZmVyZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7DQorICAgIH0NCis8L3Njcmlw dD4NCis8Ym9keT4NCisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENv bnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVuLiAgDQor ICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZh bHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuICANCisgICAgWW91 IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4NCisgICAgPHNjcmlwdD4NCisgICAgICAgIHZh ciBwID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInAiKVswXTsNCisgICAgICAgIGlm KCF3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUo cCkuZm9udFNpemUgPT0gIjI0cHgiKQ0KKyAgICAgICAgICAgIGRvY3VtZW50LndyaXRlKCJQQVNT Iik7DQorICAgIDwvc2NyaXB0Pg0KKzwvYm9keT4NCis8L2h0bWw+DQpJbmRleDogTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0DQo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 DQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQu dHh0CShyZXZpc2lvbiAwKQ0KKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZl cmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkNCkBAIC0wLDAgKzEsMyBAQA0KK1RoaXMg aXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2 ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZGVuLiBUaGlzIHRlc3Qgc3BlY2lmaWNh bGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3Vs ZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuDQorDQorUEFTUw0K SW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwNCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0NCi0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5o dG1sCShyZXZpc2lvbiAwKQ0KKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZl cmVuY2VzLmh0bWwJKHJldmlzaW9uIDApDQpAQCAtMCwwICsxLDE4IEBADQorPGh0bWw+IA0KKzxi b2R5PiANCis8c2NyaXB0PiANCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7 DQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCkNCisgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVu YWJsZWQiLCBmYWxzZSk7DQorICAgIH0NCisgICAgDQorICAgIGZ1bmN0aW9uIGxvYWRzdGF0dXMo KSB7DQorICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQorICAgICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iRkFJTCI7DQor ICAgIH0NCis8L3NjcmlwdD4gDQorPGJvZHkgb25sb2FkPSJsb2Fkc3RhdHVzKCkiPg0KKyAgICA8 cD5UaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIg Y2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gIFRoaXMgdGVzdCBz cGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5 b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci48L3A+ DQorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+DQorPC9ib2R5Pg0KKzwvaHRtbD4N CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQu dHh0DQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09DQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJl c2V0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkNCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQ0KQEAgLTAsMCArMSwz IEBADQorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdp bGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3Qu IFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4NCisNCitQQVNTDQpJbmRleDogTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwNCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NCi0tLSBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24gMCkNCisr KyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24g MCkNCkBAIC0wLDAgKzEsMTQgQEANCis8aHRtbD4gDQorPGJvZHk+IA0KKzxzY3JpcHQ+IA0KKyAg ICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpDQorICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7DQorPC9zY3JpcHQ+IA0KKzxib2R5Pg0KKyAgICA8cD5UaGlz IHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5b3V0VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBp dHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRlciBldmVyeSBsYXlvdXQgdGVzdC4gIFlvdSBzaG91 bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+DQorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3Nw YW4+DQorICAgIDxzY3JpcHQ+DQorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3Rh dHVzIikuaW5uZXJIVE1MPSJQQVNTIjsgICAgICAgIA0KKyAgICA8L3NjcmlwdD4NCis8L2JvZHk+ DQorPC9odG1sPg0K 24198 2008-10-08 13:58:02 -0700 2008-10-08 16:16:20 -0700 Improved possible patch to issue 20534 patch20534-5.txt text/plain 20352 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb25dOwkKKyAg ICBbc2VsZiBfc2V0Qm9vbFZhbHVlOmZhbHNlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5j ZXNPdmVycmlkZGVuXTsKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywyMSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvKiEKKyBAbWV0aG9kIG92ZXJy aWRlUHJlZmVyZW5jZToKKyBAcGFyYW0ga2V5IFRoZSBrZXkgb2YgdGhlIHByZWZlcmVuY2UgdG8g YmUgb3ZlcnJpZGRlbgorIEBwYXJhbSBmbGFnIFRoZSBkZXNpcmVkIHZhbHVlIG9mIHRoZSBwcmVm ZXJlbmNlCisgQGFic3RyYWN0IFNldHMgdGhlIGdpdmVuIHZhbHVlIG9mIGEgZ2l2ZW4gcHJlZmVy ZW5jZQorICovCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAqKWtleSBmbGFn OihOU1N0cmluZyAqKWZsYWc7CisKKy8qIQorIEBtZXRob2QgcmVzZXRUb0RlZmF1bHRzOgorIEBh YnN0cmFjdCByZXNldHMgdGhlIHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHQgdmFsdWVzCisg Ki8KKy0odm9pZClyZXNldFRvRGVmYXVsdHM7CisKKwogLy8gSWYgc2l0ZS1zcGVjaWZpYyBzcG9v ZmluZyBpcyBlbmFibGVkLCBzb21lIHBhZ2VzIHRoYXQgZG8gaW5hcHByb3ByaWF0ZSB1c2VyLWFn ZW50IHN0cmluZyBjaGVja3Mgd2lsbCBiZQogLy8gcGFzc2VkIGEgbm9uc3RhbmRhcmQgdXNlci1h Z2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0gdG8gd29yayBjb3JyZWN0bHkuIFRoaXMgbWV0aG9kIG1p Z2h0IGJlIHJlbW92ZWQgaW4KIC8vIHRoZSBmdXR1cmUgd2hlbiB0aGVyZSdzIG5vIG1vcmUgbmVl ZCBmb3IgaXQuCkluZGV4OiBXZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDA4LTEwLTA4ICBHbGVubiBXaWxz b24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0IHBy ZWZlcmVuY2VzIHBlci10ZXN0LiAoYnVnIDIwNTM0KQorICAgICAgICBUd28gbmV3IG1ldGhvZHMg d2VyZSBhZGRlZDogcmVzZXRUb0RlZmF1bHRzIGFuZCBvdmVycmlkZVByZWZlcmVuY2UuCisKKyAg ICAgICAgKiBJbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsOiBuZXcgbWV0aG9k IHNpZ25hdHVyZXMKKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDogYWRkZWQg bmV3IGtleSBmb3IgaW50ZXJuYWwgc3RhdGUKKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5jcHA6 IGFkZGVkIG5ldyBtZXRob2RzCisgICAgICAgIChXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVm ZXJlbmNlKTogbmV3IG1ldGhvZAorICAgICAgICAoV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZh dWx0cyk6IG5ldyBtZXRob2QKKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5oOiBuZXcgbWV0aG9k IHNpZ25hdHVyZXMKKwogMjAwOC0xMC0wNiAgRGF2aWQgSHlhdHQgIDxoeWF0dEBhcHBsZS5jb20+ CiAKICAgICAgICAgRW5hYmxlIHZpZXdsZXNzIE1hYyBXZWJLaXQgdG8gcGFpbnQgc29tZSBiYXNp YyBwYWdlcy4KSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNp b24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCSh3b3Jr aW5nIGNvcHkpCkBAIC02MCw2ICs2MCw3IEBACiAjZGVmaW5lIFdlYktpdFVzZXNQYWdlQ2FjaGVQ cmVmZXJlbmNlS2V5ICJXZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSIKICNkZWZpbmUg V2ViS2l0Q2FjaGVNb2RlbFByZWZlcmVuY2VLZXkgIldlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNl S2V5IgogI2RlZmluZSBXZWJLaXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGhQcmVmZXJlbmNlS2V5 ICJXZWJLaXRMb2NhbFN0b3JhZ2VEYXRhYmFzZVBhdGgiCisjZGVmaW5lIFdlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW4gIldlYktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4i CiAKIC8vIFRoZXNlIGFyZSBwcml2YXRlIGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1 c2luZyB0aGUgY292ZXIgbWV0aG9kcyBhbmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMg dGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4KSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwCShyZXZpc2lv biAzNzQwMikKKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0xMTg1LDYgKzExODUsMzggQEAgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVm ZXJlbmNlcwogICAgIHJldHVybiBTX09LOwogfQogCitIUkVTVUxUIFNURE1FVEhPRENBTExUWVBF IFdlYlByZWZlcmVuY2VzOjpvdmVycmlkZVByZWZlcmVuY2UoQlNUUiBrZXksIEJTVFIgdmFsdWUp Cit7CisgICAgQ0ZTdHJpbmdSZWYga2V5cmVmID0gQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVy c05vQ29weSgwLCAoVW5pQ2hhciopX3djc2R1cChrZXkpLCBzdGF0aWNfY2FzdDxDRkluZGV4Pih3 Y3NsZW4oa2V5KSksIGtDRkFsbG9jYXRvck51bGwpOworICAgIHNldFN0cmluZ1ZhbHVlKGtleXJl ZiwgdmFsdWUpOworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5j ZXNPdmVycmlkZGVuKSwgdHJ1ZSk7CisgICAgcmV0dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RE TUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAg aWYgKCFib29sVmFsdWVGb3JLZXkoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJp ZGRlbikpKQorICAgICAgICByZXR1cm4gU19PSzsKKworICAgIGludCBjb3VudCA9IENGRGljdGlv bmFyeUdldENvdW50KGRlZmF1bHRTZXR0aW5ncyk7CisgICAgaWYgKGNvdW50IDw9IDApCisgICAg ICAgIHJldHVybiBTX09LOworCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBD RlR5cGVSZWZbY291bnRdKTsKKyAgICBPd25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcg Q0ZUeXBlUmVmW2NvdW50XSk7CisgICAgQ0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZh dWx0U2V0dGluZ3MsIGtleXMuZ2V0KCksIHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBp ID0gMDsgaSA8IGNvdW50OyArK2kpIHsKKyAgICAgICAgc2V0VmFsdWVGb3JLZXkoc3RhdGljX2Nh c3Q8Q0ZTdHJpbmdSZWY+KGtleXNbaV0pLCB2YWx1ZXNbaV0pOworICAgIH0KKworICAgIHNldEJv b2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgZmFsc2Up OworCisgICAgcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05vdGlmaWNhdGlvbigpOworCisgICAgcmV0 dXJuIFNfT0s7Cit9CisKIHZvaWQgV2ViUHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZpZXcoKQog ewogICAgICsrbV9udW1XZWJWaWV3czsKSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM3 NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0z MjAsNiArMzIwLDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FM TFRZUEUgc2hvdWxkUGFpbnROYXRpdmVDb250cm9scyggCiAgICAgLyogW3JldHZhbF1bb3V0XSAq LyBCT09MICpzaG91bGRQYWludCk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Ig b3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVu ZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBvdmVy cmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiBrZXksCisgICAgICAgIC8q IFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Ig cmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdp dGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FM TFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAvLyBXZWJQcmVmZXJlbmNlcwogCiAgICAg Ly8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBk ZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQ cmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vSW50ZXJmYWNl cy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQv d2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJKHdvcmtpbmcgY29weSkK QEAgLTYwLDQgKzYwLDcgQEAgaW50ZXJmYWNlIElXZWJQcmVmZXJlbmNlc1ByaXZhdGUgOiBJVW5r bgogCiAgICAgSFJFU1VMVCBzZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKFtpbl0gQk9PTCBz aG91bGRQYWludCk7CiAgICAgSFJFU1VMVCBzaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKFtvdXQs IHJldHZhbF0gQk9PTCogZW5hYmxlZCk7CisKKyAgICBIUkVTVUxUIG92ZXJyaWRlUHJlZmVyZW5j ZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOworICAgIEhSRVNVTFQgcmVzZXRUb0Rl ZmF1bHRzKCk7CiB9CkluZGV4OiBXZWJLaXRUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0No YW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBACisyMDA4LTEwLTA4ICBHbGVu biBXaWxzb24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAgICAgQ2hhbmdlZCBMYXlvdXRU ZXN0Q29udHJvbGxlciBhbmQgRHVtcFJlbmRlclRyZWUgdG8gYWxsb3cgZm9yIG1hbnVhbAorICAg ICAgICBvdmVycmlkaW5nIG9mIGRlZmF1bHQgcHJlZmVyZW5jZXMgYXQgdGVzdCB0aW1lLiAgQWxz byBhZGRlZCBzdXBwb3J0IGZvcgorICAgICAgICByZXNldHRpbmcgdGhlIHByZWZlcmVuY2VzIGFm dGVyIGVhY2ggdGVzdC4gKGJ1ZyAyMDUzNCkKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmNwcDogQWRkZWQgY2FsbGJhY2sgbWV0aG9kIGZvciBvdmVycmlk aW5nIHByZWZlcmVuY2VzCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuaDogQWRkZWQgc2lnbmF0dXJlIGZvciBjYWxsYmFjaworICAgICAgICAqIER1bXBSZW5k ZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHA6IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHByZWZl cmVuY2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBEdW1wUmVuZGVy VHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwOiBBZGRlZCBKUyBvdmVycmlkZSBm dW5jdGlvbgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbTog QWRkZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlmIG5lY2Vz c2FyeQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1h Yy5tbTogQWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rpb24KKwogMjAwOC0xMC0wNyAgQWRhbSBSb2Jl biAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBzdXJlIHNob3J0IGZ1bmN0aW9u cyBnZXQgaW5jbHVkZWQgaW4gQ2hhbmdlTG9nIG91dHB1dCBmb3IgZ2l0CkluZGV4OiBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCShy ZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzIzLDYgKzMyMywyMCBAQCBzdGF0aWMg SlNWYWx1ZVJlZiBleGVjQ29tbWFuZENhbGxiYWNrKEpTCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtl VW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiBvdmVycmlkZVByZWZl cmVuY2VDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24s IEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1Zh bHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFy Z3VtZW50Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29u dGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5KEFkb3B0LCBKU1ZhbHVl VG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNT RVJUKCEqZXhjZXB0aW9uKTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVy ID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJp dmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxlci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtl eS5nZXQoKSwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2Vw dGlvbikpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQor CiBzdGF0aWMgSlNWYWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29udGV4dFJlZiBj b250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6 ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVS ZWYqIGV4Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC03MTAs NiArNzI0LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OgogICAg ICAgICB7ICJleGVjQ29tbWFuZCIsIGV4ZWNDb21tYW5kQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgIm5vdGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAg ICAgeyAib3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKICAgICAgICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3Vy Y2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0 cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVl dWVCYWNrTmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2Fy ZE5hdmlnYXRpb24iLCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5k ZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuaAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC02OCw2ICs2OCw3IEBAIHB1Ymxp YzoKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7 CiAgICAgdm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBwYXRoKTsKICAgICB2b2lkIGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAg dm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFn KTsKICAgICBpbnQgd2luZG93Q291bnQoKTsKICAgICAKICAgICBib29sIGVsZW1lbnREb2VzQXV0 b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBpZCk7CkluZGV4OiBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lv biAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZS5tbQkod29ya2luZyBjb3B5KQpAQCAtOTUxLDYgKzk1MSw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0 V2ViVmlld1RvQ29uc2lzdGVudFN0YXQKICAgICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1l XTsKIAogICAgIFdlYlByZWZlcmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVu Y2VzXTsKKyAgICBbcHJlZmVyZW5jZXMgcmVzZXRUb0RlZmF1bHRzXTsKKyAgICBbcHJlZmVyZW5j ZXMgc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6V2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRo U2hpZnRLZXldOwogICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5P XTsKICAgICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsK ICAgICBbcHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxs eTpZRVNdOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RD b250cm9sbGVyTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdv cmtpbmcgY29weSkKQEAgLTIzMCw2ICsyMzAsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6c2V0VXNlclN0eWxlUwogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNl c10gc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1Jl ZiBmbGFnKQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNT dHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJp bmcgKmtleU5TID0gKE5TU3RyaW5nICopa2V5Q0YuZ2V0KCk7CisJCisgICAgUmV0YWluUHRyPENG U3RyaW5nUmVmPiBmbGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2Nh dG9yRGVmYXVsdCwgZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNTdHJpbmcgKilm bGFnQ0YuZ2V0KCk7CisJCisgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2Vz XSBvdmVycmlkZVByZWZlcmVuY2U6a2V5TlMgZmxhZzpmbGFnTlNdOwkKK30KKwogdm9pZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNT dHJpbmdSZWYganNVUkwpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmco QWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsKSW5kZXg6IFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAkocmV2aXNp b24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRy ZWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02NDAsNiArNjQwLDExIEBAIHN0YXRpYyB2b2lkIHJl c2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXQKIAogICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+ IHByZWZlcmVuY2VzOwogICAgIGlmIChTVUNDRUVERUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnBy ZWZlcmVuY2VzKSkpIHsKKyAgICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHBy ZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOworICAgICAgICBpZiAocHJlZnNQcml2YXRl KSB7CisgICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFi bGVkKFRSVUUpOworICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5yZXNldFRvRGVmYXVsdHMoKTsK KyAgICAgICAgfSAgICAgICAgCQkKICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFByaXZhdGVCcm93 c2luZ0VuYWJsZWQoRkFMU0UpOwogICAgICAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENh bk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShUUlVFKTsKIApAQCAtNjUzLDkgKzY1OCw2IEBAIHN0 YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXQKICAgICAgICAgfSBlbHNlCiAg ICAgICAgICAgICBwcmVmZXJlbmNlcy0+c2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKEZBTFNFKTsK IAotICAgICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1 ZXJ5LCBwcmVmZXJlbmNlcyk7Ci0gICAgICAgIGlmIChwcmVmc1ByaXZhdGUpCi0gICAgICAgICAg ICBwcmVmc1ByaXZhdGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOwogICAg IH0KIAogICAgIENPTVB0cjxJV2ViVmlld1ByaXZhdGU+IHdlYlZpZXdQcml2YXRlKFF1ZXJ5LCB3 ZWJWaWV3KTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0 Q29udHJvbGxlcldpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBX ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8SmF2YVNjcmlwdENv cmUvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3Jl Lmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDxK YXZhU2NyaXB0Q29yZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0 Lmg+CiAjaW5jbHVkZSA8c3RyaW5nPgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3Vu ZGF0aW9uLmg+CkBAIC01NjksMyArNTcwLDI0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 OnNldERhdGFiYXNlUXUKIHsgICAgCiAgICAgcHJpbnRmKCJFUlJPUjogTGF5b3V0VGVzdENvbnRy b2xsZXI6OnNldERhdGFiYXNlUXVvdGEoKSBub3QgaW1wbGVtZW50ZWRcbiIpOwogfQorCit2b2lk IExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5 LCBKU1N0cmluZ1JlZiBmbGFnKQoreworICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKKyAg ICBpZiAoRkFJTEVEKGZyYW1lLT53ZWJWaWV3KCZ3ZWJWaWV3KSkpCisgICAgICAgIHJldHVybjsK KworICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOworICAgIGlmIChGQUlM RUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpCisgICAgICAgIHJldHVybjsK KworICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnks IHByZWZlcmVuY2VzKTsKKyAgICBpZiAoIXByZWZzUHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgQlNUUiBrZXlCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihrZXkpOworICAgIEJTVFIgZmxh Z0JTVFIgPSBKU1N0cmluZ0NvcHlCU1RSKGZsYWcpOworICAgIHByZWZzUHJpdmF0ZS0+b3ZlcnJp ZGVQcmVmZXJlbmNlKGtleUJTVFIsIGZsYWdCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGtleUJT VFIpOworICAgIFN5c0ZyZWVTdHJpbmcoZmxhZ0JTVFIpOworfQpJbmRleDogTGF5b3V0VGVzdHMv c2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJl bmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRl c3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVs dCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkg d2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBm b250IHNpemUuIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5 b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIu aHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAg IGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJy aWRlUHJlZmVyZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9z Y3JpcHQ+Cis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0 Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAK KyAgICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2 YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91 IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIg cCA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCku Zm9udFNpemUgPT0gIjI0cHgiKQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsK KyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3Vy aXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhh dCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0 IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRo YXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIg YmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci4KKworUEFTUwpJbmRleDogTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQor KysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAg aWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLmR1bXBBc1RleHQoKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlk ZVByZWZlcmVuY2UoIldlYktpdEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAg ICAKKyAgICBmdW5jdGlvbiBsb2Fkc3RhdHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3Rh dHVzIikuaW5uZXJIVE1MPSJGQUlMIjsKKyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9 ImxvYWRzdGF0dXMoKSI+CisgICAgPHA+VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0 IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92 ZXJyaWRkZW4uICBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQg Y2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdp bmcgd2l0aCBhIGJyb3dzZXIuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+ Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16 enotcmVzZXQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5 L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0 Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5 IGxheW91dCB0ZXN0LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6 IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lv biAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAor ICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIuZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0 ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRz IGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxk IHNlZSAiUEFTUyIgYmVsb3cuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+ CisgICAgPHNjcmlwdD4KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIp LmlubmVySFRNTD0iUEFTUyI7ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4K 24204 2008-10-08 16:16:20 -0700 2008-10-09 12:27:40 -0700 Improved possible patch to issue 20534 patch20534-6.txt text/plain 20459 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb25dOwkKKyAg ICBbc2VsZiBfc2V0Qm9vbFZhbHVlOmZhbHNlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5j ZXNPdmVycmlkZGVuXTsKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBt ZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1 bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElm IHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGlu YXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBh IG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVj dGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4g dGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4gKGJ1ZyAyMDUzNCkKKyAgICAg ICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZhdWx0cyBhbmQgb3ZlcnJp ZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0YXRlCisgICAgICAgICog V2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVy ZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVy ZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAtMDYgIERhdmlkIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3bGVzcyBNYWMgV2ViS2l0 IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl S2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAsNyBAQAogI2RlZmluZSBX ZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZl cmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNlS2V5ICJXZWJLaXRD YWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoIgorI2Rl ZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJl ZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2Ug Y2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhl CiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM3IEBAIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJT VFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5UmVm KEFkb3B0Q0YsIENGU3RyaW5nQ3JlYXRlV2l0aENoYXJhY3RlcnMoMCwgcmVpbnRlcnByZXRfY2Fz dDxVbmlDaGFyKj4oa2V5KSwgd2NzbGVuKGtleSkpKTsKKyAgICBzZXRTdHJpbmdWYWx1ZShrZXlS ZWYuZ2V0KCksIHZhbHVlKTsKKyAgICBzZXRCb29sVmFsdWUoQ0ZTVFIoV2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbiksIHRydWUpOworICAgIHJldHVybiBTX09LOworfQorCitIUkVT VUxUIFNURE1FVEhPRENBTExUWVBFIFdlYlByZWZlcmVuY2VzOjpyZXNldFRvRGVmYXVsdHMoKQor eworICAgIGlmICghYm9vbFZhbHVlRm9yS2V5KENGU1RSKFdlYktpdERlZmF1bHRQcmVmZXJlbmNl c092ZXJyaWRkZW4pKSkKKyAgICAgICAgcmV0dXJuIFNfT0s7CisKKyAgICBpbnQgY291bnQgPSBD RkRpY3Rpb25hcnlHZXRDb3VudChkZWZhdWx0U2V0dGluZ3MpOworICAgIGlmIChjb3VudCA8PSAw KQorICAgICAgICByZXR1cm4gU19PSzsKKworICAgIE93bkFycmF5UHRyPENGVHlwZVJlZj4ga2V5 cyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiB2YWx1 ZXMobmV3IENGVHlwZVJlZltjb3VudF0pOworICAgIENGRGljdGlvbmFyeUdldEtleXNBbmRWYWx1 ZXMoZGVmYXVsdFNldHRpbmdzLCBrZXlzLmdldCgpLCB2YWx1ZXMuZ2V0KCkpOworCisgICAgZm9y IChpbnQgaSA9IDA7IGkgPCBjb3VudDsgKytpKQorICAgICAgICBzZXRWYWx1ZUZvcktleShzdGF0 aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSksIHZhbHVlc1tpXSk7CisKKyAgICBzZXRCb29s VmFsdWUoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiksIGZhbHNlKTsK KworICAgIHBvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb24oKTsKKworICAgIHJldHVy biBTX09LOworfQorCiB2b2lkIFdlYlByZWZlcmVuY2VzOjp3aWxsQWRkVG9XZWJWaWV3KCkKIHsK ICAgICArK21fbnVtV2ViVmlld3M7CkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCShyZXZpc2lvbiAzNzQw MikKKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAkod29ya2luZyBjb3B5KQpAQCAtMzIw LDYgKzMyMCwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExU WVBFIHNob3VsZFBhaW50TmF0aXZlQ29udHJvbHMoIAogICAgIC8qIFtyZXR2YWxdW291dF0gKi8g Qk9PTCAqc2hvdWxkUGFpbnQpOwogCisgICAgLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIG92 ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRl clRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgb3ZlcnJp ZGVQcmVmZXJlbmNlKAorICAgICAgICAvKiBbaW5dICovIEJTVFIga2V5LAorICAgICAgICAvKiBb aW5dICovIEJTVFIgdmFsdWUpOworCisgICAgLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIHJl c2V0dGluZyBvdmVycmlkZGVuIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKyAgICAvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgdmlydHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExU WVBFIHJlc2V0VG9EZWZhdWx0cygpOworCiAgICAgLy8gV2ViUHJlZmVyZW5jZXMKIAogICAgIC8v IFRoaXMgbWV0aG9kIGFjY2Vzc2VzIGEgZGlmZmVyZW50IHByZWZlcmVuY2Uga2V5IHRoYW4gZGV2 ZWxvcGVyRXh0cmFzRW5hYmxlZC4KSW5kZXg6IFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJl ZmVyZW5jZXNQcml2YXRlLmlkbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0ludGVyZmFjZXMv SVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dp bi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCSh3b3JraW5nIGNvcHkpCkBA IC02MCw0ICs2MCwxMyBAQCBpbnRlcmZhY2UgSVdlYlByZWZlcmVuY2VzUHJpdmF0ZSA6IElVbmtu CiAKICAgICBIUkVTVUxUIHNldFNob3VsZFBhaW50TmF0aXZlQ29udHJvbHMoW2luXSBCT09MIHNo b3VsZFBhaW50KTsKICAgICBIUkVTVUxUIHNob3VsZFBhaW50TmF0aXZlQ29udHJvbHMoW291dCwg cmV0dmFsXSBCT09MKiBlbmFibGVkKTsKKworICAgIC8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciBvdmVycmlkaW5nIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKyAgICAvLyB3aXRoIER1bXBS ZW5kZXJUcmVlIG9ubHkuCisgICAgSFJFU1VMVCBvdmVycmlkZVByZWZlcmVuY2UoW2luXSBCU1RS IGtleSwgW2luXSBCU1RSIHZhbHVlKTsKKworICAgIC8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8g d2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQgcmVzZXRUb0RlZmF1bHRzKCk7 CisKIH0KSW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRU b29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0VG9vbHMvQ2hhbmdlTG9n CSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNv biAgPGd3aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBDaGFuZ2VkIExheW91dFRlc3RDb250 cm9sbGVyIGFuZCBEdW1wUmVuZGVyVHJlZSB0byBhbGxvdyBmb3IgbWFudWFsCisgICAgICAgIG92 ZXJyaWRpbmcgb2YgZGVmYXVsdCBwcmVmZXJlbmNlcyBhdCB0ZXN0IHRpbWUuICBBbHNvIGFkZGVk IHN1cHBvcnQgZm9yCisgICAgICAgIHJlc2V0dGluZyB0aGUgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFj aCB0ZXN0LiAoYnVnIDIwNTM0KQorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuY3BwOiBBZGRlZCBjYWxsYmFjayBtZXRob2QgZm9yIG92ZXJyaWRpbmcgcHJl ZmVyZW5jZXMKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o OiBBZGRlZCBzaWduYXR1cmUgZm9yIGNhbGxiYWNrCisgICAgICAgICogRHVtcFJlbmRlclRyZWUv d2luL0R1bXBSZW5kZXJUcmVlLmNwcDogQWRkZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMg YWZ0ZXIgZWFjaCB0ZXN0IGlmIG5lY2Vzc2FyeQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dp bi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9u CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOiBBZGRlZCBj YWxscyB0byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5Cisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOiBB ZGRlZCBKUyBvdmVycmlkZSBmdW5jdGlvbgorCiAyMDA4LTEwLTA3ICBBZGFtIFJvYmVuICA8YXJv YmVuQGFwcGxlLmNvbT4KIAogICAgICAgICBNYWtlIHN1cmUgc2hvcnQgZnVuY3Rpb25zIGdldCBp bmNsdWRlZCBpbiBDaGFuZ2VMb2cgb3V0cHV0IGZvciBnaXQKSW5kZXg6IFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHJldmlzaW9u IDM3NDI1KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zMjMsNiArMzIzLDIwIEBAIHN0YXRpYyBKU1ZhbHVl UmVmIGV4ZWNDb21tYW5kQ2FsbGJhY2soSlMKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmlu ZWQoY29udGV4dCk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG92ZXJyaWRlUHJlZmVyZW5jZUNh bGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmpl Y3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYg YXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRD b3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsK KworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRvcHQsIEpTVmFsdWVUb1N0cmlu Z0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpl eGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSByZWlu dGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRo aXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5LmdldCgp LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwgZXhjZXB0aW9uKSk7 CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRp YyBKU1ZhbHVlUmVmIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQs IEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJn dW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhj ZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRpb24KQEAgLTcxMCw2ICs3MjQs NyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6CiAgICAgICAgIHsg ImV4ZWNDb21tYW5kIiwgZXhlY0NvbW1hbmRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVS ZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJr ZWVwV2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmli dXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAg eyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVS ZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJv dmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJwYXRoVG9Mb2NhbFJlc291cmNlIiwgcGF0aFRvTG9jYWxSZXNvdXJjZUNhbGxi YWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVE b250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlQmFja05hdmlnYXRpb24iLCBxdWV1ZUJhY2tO YXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicXVldWVGb3J3YXJkTmF2aWdh dGlvbiIsIHF1ZXVlRm9yd2FyZE5hdmlnYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1 dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApJbmRleDogV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCShy ZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTY4LDYgKzY4LDcgQEAgcHVibGljOgogICAg IHZvaWQgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2 b2lkIHNldFBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgp OwogICAgIHZvaWQgY2xlYXJQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXQoKTsKKyAgICB2b2lkIG92 ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpOwogICAg IGludCB3aW5kb3dDb3VudCgpOwogICAgIAogICAgIGJvb2wgZWxlbWVudERvZXNBdXRvQ29tcGxl dGVGb3JFbGVtZW50V2l0aElkKEpTU3RyaW5nUmVmIGlkKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0JKHJldmlzaW9uIDM3NDI1 KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3 b3JraW5nIGNvcHkpCkBAIC05NTEsNiArOTUxLDggQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3 VG9Db25zaXN0ZW50U3RhdAogICAgIFt3ZWJWaWV3IF9jbGVhck1haW5GcmFtZU5hbWVdOwogCiAg ICAgV2ViUHJlZmVyZW5jZXMgKnByZWZlcmVuY2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOwor ICAgIFtwcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdOworICAgIFtwcmVmZXJlbmNlcyBzZXRF ZGl0YWJsZUxpbmtCZWhhdmlvcjpXZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtl eV07CiAgICAgW3ByZWZlcmVuY2VzIHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOwogICAg IFtwcmVmZXJlbmNlcyBzZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOwogICAgIFtw cmVmZXJlbmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107 CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xs ZXJNYWMubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xh eW91dFRlc3RDb250cm9sbGVyTWFjLm1tCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkod29ya2luZyBj b3B5KQpAQCAtMjMwLDYgKzIzMCwxNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRV c2VyU3R5bGVTCiAgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBzZXRV c2VyU3R5bGVTaGVldExvY2F0aW9uOnVybF07CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xs ZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcp Cit7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBrZXlDRihBZG9wdENGLCBKU1N0cmluZ0Nv cHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBrZXkpKTsKKyAgICBOU1N0cmluZyAqa2V5 TlMgPSAoTlNTdHJpbmcgKilrZXlDRi5nZXQoKTsKKwkKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdS ZWY+IGZsYWdDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBmbGFnKSk7CisgICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAqKWZsYWdDRi5n ZXQoKTsKKwkKKyAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5jZXNdIG92ZXJy aWRlUHJlZmVyZW5jZTprZXlOUyBmbGFnOmZsYWdOU107CQorfQorCiB2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBqc1VSTCkKIHsKICAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHVybFN0cmluZyhBZG9wdENG LCBKU1N0cmluZ0NvcHlDRlN0cmluZygwLCBqc1VSTCkpOwpJbmRleDogV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCShyZXZpc2lvbiAzNzQy NSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTY0MCw2ICs2NDAsMTEgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJW aWV3VG9Db25zaXN0ZW50U3RhdAogCiAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gcHJlZmVy ZW5jZXM7CiAgICAgaWYgKFNVQ0NFRURFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5j ZXMpKSkgeworICAgICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2 YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7CisgICAgICAgIGlmIChwcmVmc1ByaXZhdGUpIHsKKyAg ICAgICAgICAgIHByZWZzUHJpdmF0ZS0+cmVzZXRUb0RlZmF1bHRzKCk7CisgICAgICAgICAgICBw cmVmc1ByaXZhdGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOworICAgICAg ICB9ICAgICAgICAJCQogICAgICAgICBwcmVmZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5h YmxlZChGQUxTRSk7CiAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRKYXZhU2NyaXB0Q2FuT3Blbldp bmRvd3NBdXRvbWF0aWNhbGx5KFRSVUUpOwogCkBAIC02NTMsOSArNjU4LDYgQEAgc3RhdGljIHZv aWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdAogICAgICAgICB9IGVsc2UKICAgICAgICAg ICAgIHByZWZlcmVuY2VzLT5zZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQoRkFMU0UpOwogCi0gICAg ICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHBy ZWZlcmVuY2VzKTsKLSAgICAgICAgaWYgKHByZWZzUHJpdmF0ZSkKLSAgICAgICAgICAgIHByZWZz UHJpdmF0ZS0+c2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQoVFJVRSk7CiAgICAgfQogCiAg ICAgQ09NUHRyPElXZWJWaWV3UHJpdmF0ZT4gd2ViVmlld1ByaXZhdGUoUXVlcnksIHdlYlZpZXcp OwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9s bGVyV2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTQwLDYgKzQwLDcgQEAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9Bc3Nl cnRpb25zLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuaD4KICNp bmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU1JldGFpblB0ci5oPgorI2luY2x1ZGUgPEphdmFTY3Jp cHRDb3JlL0pTU3RyaW5nUmVmQlNUUi5oPgogI2luY2x1ZGUgPFdlYktpdC9XZWJLaXQuaD4KICNp bmNsdWRlIDxzdHJpbmc+CiAjaW5jbHVkZSA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24u aD4KQEAgLTU2OSwzICs1NzAsMjQgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0 YWJhc2VRdQogeyAgICAKICAgICBwcmludGYoIkVSUk9SOiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c2V0RGF0YWJhc2VRdW90YSgpIG5vdCBpbXBsZW1lbnRlZFxuIik7CiB9CisKK3ZvaWQgTGF5b3V0 VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3Ry aW5nUmVmIGZsYWcpCit7CisgICAgQ09NUHRyPElXZWJWaWV3PiB3ZWJWaWV3OworICAgIGlmIChG QUlMRUQoZnJhbWUtPndlYlZpZXcoJndlYlZpZXcpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAg Q09NUHRyPElXZWJQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXM7CisgICAgaWYgKEZBSUxFRCh3ZWJW aWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAg Q09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVy ZW5jZXMpOworICAgIGlmICghcHJlZnNQcml2YXRlKQorICAgICAgICByZXR1cm47CisKKyAgICBC U1RSIGtleUJTVFIgPSBKU1N0cmluZ0NvcHlCU1RSKGtleSk7CisgICAgQlNUUiBmbGFnQlNUUiA9 IEpTU3RyaW5nQ29weUJTVFIoZmxhZyk7CisgICAgcHJlZnNQcml2YXRlLT5vdmVycmlkZVByZWZl cmVuY2Uoa2V5QlNUUiwgZmxhZ0JTVFIpOworICAgIFN5c0ZyZWVTdHJpbmcoa2V5QlNUUik7Cisg ICAgU3lzRnJlZVN0cmluZyhmbGFnQlNUUik7Cit9CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0 eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIt ZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZl cmVuY2VzIG92ZXJyaWRlbi4gVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFj Y2VwdCBzdHJpbmcgdmFsdWVzIGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6 ZS4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0 cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBACis8aHRtbD4KKzxzY3JpcHQ+CisgICAgaWYod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVm ZXJlbmNlKCJXZWJLaXREZWZhdWx0Rm9udFNpemUiLCAiMjQiKTsKKyAgICB9Cis8L3NjcmlwdD4K Kzxib2R5PgorICAgIDxwPlRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9s bGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRlbi4gIAorICAgIFRo aXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBh bmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuICAKKyAgICBZb3Ugc2hvdWxk IHNlZSAiUEFTUyIgYmVsb3cuPC9wPgorICAgIDxzY3JpcHQ+CisgICAgICAgIHZhciBwID0gZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInAiKVswXTsKKyAgICAgICAgaWYoIXdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlciB8fCB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwKS5mb250U2l6 ZSA9PSAiMjRweCIpCisgICAgICAgICAgICBkb2N1bWVudC53cml0ZSgiUEFTUyIpOworICAgIDwv c2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3Zl cnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlm aWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVy ZW5jZXMgb3ZlcnJpZGRlbi4gVGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZh c2NyaXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBp ZiB2aWV3aW5nIHdpdGggYSBicm93c2VyLgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDE4IEBACis8aHRtbD4gCis8Ym9keT4gCis8c2NyaXB0PiAKKyAgICBpZih3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVy ZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJsZWQiLCBmYWxzZSk7CisgICAgfQorICAgIAorICAg IGZ1bmN0aW9uIGxvYWRzdGF0dXMoKSB7CisgICAgICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMiKS5p bm5lckhUTUw9IkZBSUwiOworICAgIH0KKzwvc2NyaXB0PiAKKzxib2R5IG9ubG9hZD0ibG9hZHN0 YXR1cygpIj4KKyAgICA8cD5UaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0 VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRl bi4gIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUg ZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRo IGEgYnJvd3Nlci48L3A+CisgICAgPHNwYW4gaWQ9InN0YXR1cyI+UEFTUzwvc3Bhbj4KKzwvYm9k eT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNl dC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9s bGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0 IHRlc3QuIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0 VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSwxNCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4gCis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVy aWZpZXMgdGhhdCB0aGUgbGF5b3V0VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVs dCBwcmVmZXJlbmNlcyBhZnRlciBldmVyeSBsYXlvdXQgdGVzdC4gIFlvdSBzaG91bGQgc2VlICJQ QVNTIiBiZWxvdy48L3A+CisgICAgPHNwYW4gaWQ9InN0YXR1cyI+RkFJTDwvc3Bhbj4KKyAgICA8 c2NyaXB0PgorICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJI VE1MPSJQQVNTIjsgICAgICAgIAorICAgIDwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 24232 2008-10-09 12:27:40 -0700 2008-10-09 14:44:50 -0700 Improved possible patch to issue 20534 patch20534-7.txt text/plain 20575 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbl07CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNO b3RpZmljYXRpb25dOwkKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBt ZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1 bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElm IHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGlu YXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBh IG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVj dGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4g dGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4gKGJ1ZyAyMDUzNCkKKyAgICAg ICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZhdWx0cyBhbmQgb3ZlcnJp ZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0YXRlCisgICAgICAgICog V2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVy ZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVy ZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAtMDYgIERhdmlkIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3bGVzcyBNYWMgV2ViS2l0 IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl S2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAsNyBAQAogI2RlZmluZSBX ZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZl cmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNlS2V5ICJXZWJLaXRD YWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoIgorI2Rl ZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJl ZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2Ug Y2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhl CiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM5IEBAIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJT VFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICgha2V5IHx8IFN5c1N0cmluZ0xlbihrZXkp ID09IDApCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVm PiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVycygwLCByZWludGVy cHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCB3Y3NsZW4oa2V5KSkpOworICAgIHNldFN0cmluZ1Zh bHVlKGtleVJlZi5nZXQoKSwgdmFsdWUpOworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXRE ZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgdHJ1ZSk7CisgICAgcmV0dXJuIFNfT0s7Cit9 CisKK0hSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZh dWx0cygpCit7CisgICAgaWYgKCFib29sVmFsdWVGb3JLZXkoQ0ZTVFIoV2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbikpKQorICAgICAgICByZXR1cm4gU19PSzsKKworICAgIGludCBj b3VudCA9IENGRGljdGlvbmFyeUdldENvdW50KGRlZmF1bHRTZXR0aW5ncyk7CisgICAgaWYgKGNv dW50IDw9IDApCisgICAgICAgIHJldHVybiBTX09LOworCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBl UmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZbY291bnRdKTsKKyAgICBPd25BcnJheVB0cjxDRlR5cGVS ZWY+IHZhbHVlcyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAgQ0ZEaWN0aW9uYXJ5R2V0S2V5 c0FuZFZhbHVlcyhkZWZhdWx0U2V0dGluZ3MsIGtleXMuZ2V0KCksIHZhbHVlcy5nZXQoKSk7CisK KyAgICBmb3IgKGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpCisgICAgICAgIHNldFZhbHVlRm9y S2V5KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSwgdmFsdWVzW2ldKTsKKworICAg IHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwg ZmFsc2UpOworCisgICAgcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05vdGlmaWNhdGlvbigpOworCisg ICAgcmV0dXJuIFNfT0s7Cit9CisKIHZvaWQgV2ViUHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZp ZXcoKQogewogICAgICsrbV9udW1XZWJWaWV3czsKSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVy ZW5jZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgJKHJldmlz aW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkp CkBAIC0zMjAsNiArMzIwLDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgc2hvdWxkUGFpbnROYXRpdmVDb250cm9scyggCiAgICAgLyogW3JldHZhbF1b b3V0XSAqLyBCT09MICpzaG91bGRQYWludCk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFu dCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBE dW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQ RSBvdmVycmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiBrZXksCisgICAg ICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFu dCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAg IC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAvLyBXZWJQcmVmZXJlbmNlcwog CiAgICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkg dGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2ViS2l0L3dpbi9JbnRlcmZhY2Vz L0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vSW50 ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2aXNpb24gMzc0MDIpCisrKyBX ZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJKHdvcmtpbmcg Y29weSkKQEAgLTYwLDQgKzYwLDEzIEBAIGludGVyZmFjZSBJV2ViUHJlZmVyZW5jZXNQcml2YXRl IDogSVVua24KIAogICAgIEhSRVNVTFQgc2V0U2hvdWxkUGFpbnROYXRpdmVDb250cm9scyhbaW5d IEJPT0wgc2hvdWxkUGFpbnQpOwogICAgIEhSRVNVTFQgc2hvdWxkUGFpbnROYXRpdmVDb250cm9s cyhbb3V0LCByZXR2YWxdIEJPT0wqIGVuYWJsZWQpOworCisgICAgLy8gVGhpcyBtZXRob2QgaXMg bWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdp dGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIG92ZXJyaWRlUHJlZmVyZW5jZShb aW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOworCisgICAgLy8gVGhpcyBtZXRob2QgaXMg bWVhbnQgZm9yIHJlc2V0dGluZyBvdmVycmlkZGVuIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4K KyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgSFJFU1VMVCByZXNldFRvRGVm YXVsdHMoKTsKKwogfQpJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9D aGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAwOC0xMC0wOCAgR2xl bm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIENoYW5nZWQgTGF5b3V0 VGVzdENvbnRyb2xsZXIgYW5kIER1bXBSZW5kZXJUcmVlIHRvIGFsbG93IGZvciBtYW51YWwKKyAg ICAgICAgb3ZlcnJpZGluZyBvZiBkZWZhdWx0IHByZWZlcmVuY2VzIGF0IHRlc3QgdGltZS4gIEFs c28gYWRkZWQgc3VwcG9ydCBmb3IKKyAgICAgICAgcmVzZXR0aW5nIHRoZSBwcmVmZXJlbmNlcyBh ZnRlciBlYWNoIHRlc3QuIChidWcgMjA1MzQpCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5jcHA6IEFkZGVkIGNhbGxiYWNrIG1ldGhvZCBmb3Igb3ZlcnJp ZGluZyBwcmVmZXJlbmNlcworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmg6IEFkZGVkIHNpZ25hdHVyZSBmb3IgY2FsbGJhY2sKKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVm ZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDogQWRkZWQgSlMgb3ZlcnJpZGUg ZnVuY3Rpb24KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW06 IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNl c3NhcnkKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJN YWMubW06IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uCisKIDIwMDgtMTAtMDcgIEFkYW0gUm9i ZW4gIDxhcm9iZW5AYXBwbGUuY29tPgogCiAgICAgICAgIE1ha2Ugc3VyZSBzaG9ydCBmdW5jdGlv bnMgZ2V0IGluY2x1ZGVkIGluIENoYW5nZUxvZyBvdXRwdXQgZm9yIGdpdApJbmRleDogV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAko cmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMyMyw2ICszMjMsMjEgQEAgc3RhdGlj IEpTVmFsdWVSZWYgZXhlY0NvbW1hbmRDYWxsYmFjayhKUwogICAgIHJldHVybiBKU1ZhbHVlTWFr ZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgb3ZlcnJpZGVQcmVm ZXJlbmNlQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9u LCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNW YWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIGlmIChh cmd1bWVudENvdW50IDwgMikKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNv bnRleHQpOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGtleShBZG9wdCwgSlNWYWx1 ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlvbikpOworICAgIEFT U0VSVCghKmV4Y2VwdGlvbik7CisJSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IHZhbHVlKEFkb3B0 LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwgZXhjZXB0aW9uKSk7 CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJvbGxlciA9IHJlaW50ZXJwcmV0X2Nh c3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVjdCkp OworCWNvbnRyb2xsZXItPm92ZXJyaWRlUHJlZmVyZW5jZShrZXkuZ2V0KCksIHZhbHVlLmdldCgp KTsKKworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKK30KKwogc3Rh dGljIEpTVmFsdWVSZWYga2VlcFdlYkhpc3RvcnlDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4 dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBh cmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBl eGNlcHRpb24pCiB7CiAgICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgpAQCAtNzEwLDYgKzcy NSw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRlc3RDb250cm9sbGVyOjoKICAgICAgICAg eyAiZXhlY0NvbW1hbmQiLCBleGVjQ29tbWFuZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsg ImtlZXBXZWJIaXN0b3J5Iiwga2VlcFdlYkhpc3RvcnlDYWxsYmFjaywga0pTUHJvcGVydHlBdHRy aWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAg ICB7ICJub3RpZnlEb25lIiwgbm90aWZ5RG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAgIHsg Im92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJyaWRlUHJlZmVyZW5jZUNhbGxiYWNrLCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0s CiAgICAgICAgIHsgInBhdGhUb0xvY2FsUmVzb3VyY2UiLCBwYXRoVG9Mb2NhbFJlc291cmNlQ2Fs bGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0 ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicXVldWVCYWNrTmF2aWdhdGlvbiIsIHF1ZXVlQmFj a05hdmlnYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUZvcndhcmROYXZp Z2F0aW9uIiwgcXVldWVGb3J3YXJkTmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCkluZGV4OiBX ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgJ KHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuaAkod29ya2luZyBjb3B5KQpAQCAtNjgsNiArNjgsNyBAQCBwdWJsaWM6CiAg ICAgdm9pZCBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOwogICAg IHZvaWQgc2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0 aCk7CiAgICAgdm9pZCBjbGVhclBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldCgpOworICAgIHZvaWQg b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZyk7CiAg ICAgaW50IHdpbmRvd0NvdW50KCk7CiAgICAgCiAgICAgYm9vbCBlbGVtZW50RG9lc0F1dG9Db21w bGV0ZUZvckVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYgaWQpOwpJbmRleDogV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQkocmV2aXNpb24gMzc0 MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0J KHdvcmtpbmcgY29weSkKQEAgLTk1MSw2ICs5NTEsOCBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZp ZXdUb0NvbnNpc3RlbnRTdGF0CiAgICAgW3dlYlZpZXcgX2NsZWFyTWFpbkZyYW1lTmFtZV07CiAK ICAgICBXZWJQcmVmZXJlbmNlcyAqcHJlZmVyZW5jZXMgPSBbd2ViVmlldyBwcmVmZXJlbmNlc107 CisgICAgW3ByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0c107CisgICAgW3ByZWZlcmVuY2VzIHNl dEVkaXRhYmxlTGlua0JlaGF2aW9yOldlYktpdEVkaXRhYmxlTGlua09ubHlMaXZlV2l0aFNoaWZ0 S2V5XTsKICAgICBbcHJlZmVyZW5jZXMgc2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZDpOT107CiAg ICAgW3ByZWZlcmVuY2VzIHNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkOllFU107CiAgICAg W3ByZWZlcmVuY2VzIHNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHk6WUVT XTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv TGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCSh3b3JraW5n IGNvcHkpCkBAIC0yMzAsNiArMjMwLDE3IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNl dFVzZXJTdHlsZVMKICAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5jZXNdIHNl dFVzZXJTdHlsZVNoZWV0TG9jYXRpb246dXJsXTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxh ZykKK3sKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleUNGKEFkb3B0Q0YsIEpTU3RyaW5n Q29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGtleSkpOworICAgIE5TU3RyaW5nICpr ZXlOUyA9IChOU1N0cmluZyAqKWtleUNGLmdldCgpOworCQorICAgIFJldGFpblB0cjxDRlN0cmlu Z1JlZj4gZmxhZ0NGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRl ZmF1bHQsIGZsYWcpKTsKKyAgICBOU1N0cmluZyAqZmxhZ05TID0gKE5TU3RyaW5nICopZmxhZ0NG LmdldCgpOworCQorICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gb3Zl cnJpZGVQcmVmZXJlbmNlOmtleU5TIGZsYWc6ZmxhZ05TXTsJCit9CisKIHZvaWQgTGF5b3V0VGVz dENvbnRyb2xsZXI6OnNldFBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5n UmVmIGpzVVJMKQogewogICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gdXJsU3RyaW5nKEFkb3B0 Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKDAsIGpzVVJMKSk7CkluZGV4OiBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJKHJldmlzaW9uIDM3 NDI1KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNw cAkod29ya2luZyBjb3B5KQpAQCAtNjQwLDYgKzY0MCwxMSBAQCBzdGF0aWMgdm9pZCByZXNldFdl YlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAKICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVm ZXJlbmNlczsKICAgICBpZiAoU1VDQ0VFREVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJl bmNlcykpKSB7CisgICAgICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1By aXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKKyAgICAgICAgaWYgKHByZWZzUHJpdmF0ZSkgewor ICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5yZXNldFRvRGVmYXVsdHMoKTsKKyAgICAgICAgICAg IHByZWZzUHJpdmF0ZS0+c2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQoVFJVRSk7CisgICAg ICAgIH0gICAgICAgIAkJCiAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRQcml2YXRlQnJvd3NpbmdF bmFibGVkKEZBTFNFKTsKICAgICAgICAgcHJlZmVyZW5jZXMtPnNldEphdmFTY3JpcHRDYW5PcGVu V2luZG93c0F1dG9tYXRpY2FsbHkoVFJVRSk7CiAKQEAgLTY1Myw5ICs2NTgsNiBAQCBzdGF0aWMg dm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAgICAgICAgIH0gZWxzZQogICAgICAg ICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZChGQUxTRSk7CiAKLSAg ICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwg cHJlZmVyZW5jZXMpOwotICAgICAgICBpZiAocHJlZnNQcml2YXRlKQotICAgICAgICAgICAgcHJl ZnNQcml2YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsKICAgICB9CiAK ICAgICBDT01QdHI8SVdlYlZpZXdQcml2YXRlPiB3ZWJWaWV3UHJpdmF0ZShRdWVyeSwgd2ViVmll dyk7CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRy b2xsZXJXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dp bi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkod29y a2luZyBjb3B5KQpAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0Fz c2VydGlvbnMuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS5oPgog I2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTUmV0YWluUHRyLmg+CisjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvSlNTdHJpbmdSZWZCU1RSLmg+CiAjaW5jbHVkZSA8V2ViS2l0L1dlYktpdC5oPgog I2luY2x1ZGUgPHN0cmluZz4KICNpbmNsdWRlIDxDb3JlRm91bmRhdGlvbi9Db3JlRm91bmRhdGlv bi5oPgpAQCAtNTY5LDMgKzU3MCwyNCBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRE YXRhYmFzZVF1CiB7ICAgIAogICAgIHByaW50ZigiRVJST1I6IExheW91dFRlc3RDb250cm9sbGVy OjpzZXREYXRhYmFzZVF1b3RhKCkgbm90IGltcGxlbWVudGVkXG4iKTsKIH0KKwordm9pZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNT dHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+IHdlYlZpZXc7CisgICAgaWYg KEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAgICAgICByZXR1cm47CisKKyAg ICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKKyAgICBpZiAoRkFJTEVEKHdl YlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAgICAgICByZXR1cm47CisKKyAg ICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVm ZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisgICAgICAgIHJldHVybjsKKworICAg IEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5KTsKKyAgICBCU1RSIGZsYWdCU1RS ID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVmc1ByaXZhdGUtPm92ZXJyaWRlUHJl ZmVyZW5jZShrZXlCU1RSLCBmbGFnQlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhrZXlCU1RSKTsK KyAgICBTeXNGcmVlU3RyaW5nKGZsYWdCU1RSKTsKK30KSW5kZXg6IExheW91dFRlc3RzL3NlY3Vy aXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0CShy ZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMt Mi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZl cmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJl ZmVyZW5jZXMgb3ZlcnJpZGVuLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwg YWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBz aXplLiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6IExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWwJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWwJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPgorPHNjcmlwdD4KKyAgICBpZih3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVBy ZWZlcmVuY2UoIldlYktpdERlZmF1bHRGb250U2l6ZSIsICIyNCIpOworICAgIH0KKzwvc2NyaXB0 PgorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRy b2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVuLiAgCisgICAg VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFjY2VwdCBzdHJpbmcgdmFsdWVz IGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6ZS4gIAorICAgIFlvdSBzaG91 bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNjcmlwdD4KKyAgICAgICAgdmFyIHAgPSBk b2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicCIpWzBdOworICAgICAgICBpZighd2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyIHx8IHdpbmRvdy5nZXRDb21wdXRlZFN0eWxlKHApLmZvbnRT aXplID09ICIyNHB4IikKKyAgICAgICAgICAgIGRvY3VtZW50LndyaXRlKCJQQVNTIik7CisgICAg PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQu dHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1RoaXMgaXMgYSB0ZXN0IHRoYXQgdmVy aWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVm ZXJlbmNlcyBvdmVycmlkZGVuLiBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEph dmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93 IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuCisKK1BBU1MKSW5kZXg6IExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkKKysrIExh eW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxl ci5kdW1wQXNUZXh0KCkKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVm ZXJlbmNlKCJXZWJLaXRKYXZhU2NyaXB0RW5hYmxlZCIsIGZhbHNlKTsKKyAgICB9CisgICAgCisg ICAgZnVuY3Rpb24gbG9hZHN0YXR1cygpIHsKKyAgICAgICAgaWYod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIp LmlubmVySFRNTD0iRkFJTCI7CisgICAgfQorPC9zY3JpcHQ+IAorPGJvZHkgb25sb2FkPSJsb2Fk c3RhdHVzKCkiPgorICAgIDxwPlRoaXMgaXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMgdGhhdCBsYXlv dXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlk ZGVuLiAgVGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNhbiBi ZSBkaXNhYmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5nIHdp dGggYSBicm93c2VyLjwvcD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5QQVNTPC9zcGFuPgorPC9i b2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJl c2V0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVy cmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMv c2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5b3V0VGVzdENvbnRy b2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRlciBldmVyeSBsYXlv dXQgdGVzdC4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LgorCitQQVNTCkluZGV4OiBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDE0IEBACis8aHRtbD4gCis8Ym9keT4gCis8c2NyaXB0PiAKKyAgICBp Zih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9s bGVyLmR1bXBBc1RleHQoKTsKKzwvc2NyaXB0PiAKKzxib2R5PgorICAgIDxwPlRoaXMgdGVzdCB2 ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0cyBkZWZh dWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiAgWW91IHNob3VsZCBzZWUg IlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5GQUlMPC9zcGFuPgorICAg IDxzY3JpcHQ+CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMiKS5pbm5l ckhUTUw9IlBBU1MiOyAgICAgICAgCisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 24237 2008-10-09 14:44:50 -0700 2009-02-04 15:47:30 -0800 Improved possible patch to issue 20534 patch20534-8.txt text/plain 20619 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbl07CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNO b3RpZmljYXRpb25dOwkKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBt ZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1 bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElm IHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGlu YXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBh IG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVj dGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4g dGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4gKGJ1ZyAyMDUzNCkKKyAgICAg ICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZhdWx0cyBhbmQgb3ZlcnJp ZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0YXRlCisgICAgICAgICog V2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVy ZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVy ZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAtMDYgIERhdmlkIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3bGVzcyBNYWMgV2ViS2l0 IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl S2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAsNyBAQAogI2RlZmluZSBX ZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZl cmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNlS2V5ICJXZWJLaXRD YWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoIgorI2Rl ZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJl ZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2Ug Y2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhl CiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM5IEBAIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJT VFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5nTGVuKGtleSkgfHwgIVN5 c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVy cygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCB3Y3NsZW4oa2V5KSkpOworICAg IHNldFN0cmluZ1ZhbHVlKGtleVJlZi5nZXQoKSwgdmFsdWUpOworICAgIHNldEJvb2xWYWx1ZShD RlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgdHJ1ZSk7CisgICAgcmV0 dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6 OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAgaWYgKCFib29sVmFsdWVGb3JLZXkoQ0ZTVFIoV2Vi S2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbikpKQorICAgICAgICByZXR1cm4gU19PSzsK KworICAgIGludCBjb3VudCA9IENGRGljdGlvbmFyeUdldENvdW50KGRlZmF1bHRTZXR0aW5ncyk7 CisgICAgaWYgKGNvdW50IDw9IDApCisgICAgICAgIHJldHVybiBTX09LOworCisgICAgT3duQXJy YXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZbY291bnRdKTsKKyAgICBPd25BcnJh eVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAgQ0ZEaWN0 aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZhdWx0U2V0dGluZ3MsIGtleXMuZ2V0KCksIHZhbHVl cy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpCisgICAgICAg IHNldFZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSwgdmFsdWVz W2ldKTsKKworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNP dmVycmlkZGVuKSwgZmFsc2UpOworCisgICAgcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05vdGlmaWNh dGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisKIHZvaWQgV2ViUHJlZmVyZW5jZXM6Ondp bGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1XZWJWaWV3czsKSW5kZXg6IFdlYktpdC93 aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VzLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCSh3 b3JraW5nIGNvcHkpCkBAIC0zMjAsNiArMzIwLDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIEhS RVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2hvdWxkUGFpbnROYXRpdmVDb250cm9scyggCiAgICAg LyogW3JldHZhbF1bb3V0XSAqLyBCT09MICpzaG91bGRQYWludCk7CiAKKyAgICAvLyBUaGlzIG1l dGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisg ICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERN RVRIT0RDQUxMVFlQRSBvdmVycmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0gKi8gQlNU UiBrZXksCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1l dGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRl c3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhS RVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAvLyBXZWJQ cmVmZXJlbmNlcwogCiAgICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJlbnQgcHJl ZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2ViS2l0L3dp bi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5p ZGwJKHdvcmtpbmcgY29weSkKQEAgLTYwLDQgKzYwLDEzIEBAIGludGVyZmFjZSBJV2ViUHJlZmVy ZW5jZXNQcml2YXRlIDogSVVua24KIAogICAgIEhSRVNVTFQgc2V0U2hvdWxkUGFpbnROYXRpdmVD b250cm9scyhbaW5dIEJPT0wgc2hvdWxkUGFpbnQpOwogICAgIEhSRVNVTFQgc2hvdWxkUGFpbnRO YXRpdmVDb250cm9scyhbb3V0LCByZXR2YWxdIEJPT0wqIGVuYWJsZWQpOworCisgICAgLy8gVGhp cyBtZXRob2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1 bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIG92ZXJyaWRl UHJlZmVyZW5jZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOworCisgICAgLy8gVGhp cyBtZXRob2QgaXMgbWVhbnQgZm9yIHJlc2V0dGluZyBvdmVycmlkZGVuIHByZWZlcmVuY2VzIGZv ciB0ZXN0cyBydW4KKyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgSFJFU1VM VCByZXNldFRvRGVmYXVsdHMoKTsKKwogfQpJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzc0MjUpCisrKyBX ZWJLaXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIENo YW5nZWQgTGF5b3V0VGVzdENvbnRyb2xsZXIgYW5kIER1bXBSZW5kZXJUcmVlIHRvIGFsbG93IGZv ciBtYW51YWwKKyAgICAgICAgb3ZlcnJpZGluZyBvZiBkZWZhdWx0IHByZWZlcmVuY2VzIGF0IHRl c3QgdGltZS4gIEFsc28gYWRkZWQgc3VwcG9ydCBmb3IKKyAgICAgICAgcmVzZXR0aW5nIHRoZSBw cmVmZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QuIChidWcgMjA1MzQpCisKKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6IEFkZGVkIGNhbGxiYWNrIG1ldGhv ZCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xh eW91dFRlc3RDb250cm9sbGVyLmg6IEFkZGVkIHNpZ25hdHVyZSBmb3IgY2FsbGJhY2sKKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOiBBZGRlZCBjYWxscyB0 byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5CisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDogQWRkZWQg SlMgb3ZlcnJpZGUgZnVuY3Rpb24KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJl bmRlclRyZWUubW06IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHByZWZlcmVuY2VzIGFmdGVyIGVhY2gg dGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVz dENvbnRyb2xsZXJNYWMubW06IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uCisKIDIwMDgtMTAt MDcgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgogCiAgICAgICAgIE1ha2Ugc3VyZSBz aG9ydCBmdW5jdGlvbnMgZ2V0IGluY2x1ZGVkIGluIENoYW5nZUxvZyBvdXRwdXQgZm9yIGdpdApJ bmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMyMyw2ICszMjMs MjIgQEAgc3RhdGljIEpTVmFsdWVSZWYgZXhlY0NvbW1hbmRDYWxsYmFjayhKUwogICAgIHJldHVy biBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYg b3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0 UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3Vu dCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQor eworICAgIGlmIChhcmd1bWVudENvdW50IDwgMikKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtl VW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGtleShB ZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlv bikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdS ZWY+IHZhbHVlKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sx XSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKworICAgIExheW91dFRl c3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29u dHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxl ci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleS5nZXQoKSwgdmFsdWUuZ2V0KCkpOworCisgICAgcmV0 dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJl ZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJl ZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQs IGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsK ICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC03MTAsNiArNzI2LDcgQEAgSlNTdGF0 aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OgogICAgICAgICB7ICJleGVjQ29tbWFu ZCIsIGV4ZWNDb21tYW5kQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAia2VlcFdlYkhpc3Rv cnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5 IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm5vdGlmeURv bmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAib3ZlcnJpZGVQcmVm ZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi cGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3VyY2VDYWxsYmFjaywga0pTUHJv cGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9 LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVldWVCYWNrTmF2aWdhdGlvbkNh bGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1 dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2FyZE5hdmlnYXRpb24iLCBxdWV1 ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5kZXg6IFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAkocmV2aXNpb24gMzc0 MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CSh3b3JraW5nIGNvcHkpCkBAIC02OCw2ICs2OCw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHNldFVz ZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CiAgICAgdm9pZCBzZXRQZXJz aXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2b2lk IGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAgdm9pZCBvdmVycmlkZVByZWZl cmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKTsKICAgICBpbnQgd2luZG93 Q291bnQoKTsKICAgICAKICAgICBib29sIGVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9yRWxlbWVu dFdpdGhJZChKU1N0cmluZ1JlZiBpZCk7CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQkod29ya2luZyBjb3B5 KQpAQCAtOTUxLDYgKzk1MSw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVu dFN0YXQKICAgICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1lXTsKIAogICAgIFdlYlByZWZl cmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVuY2VzXTsKKyAgICBbcHJlZmVy ZW5jZXMgcmVzZXRUb0RlZmF1bHRzXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0RWRpdGFibGVMaW5r QmVoYXZpb3I6V2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRLZXldOwogICAgIFtw cmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKICAgICBbcHJlZmVyZW5j ZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsKICAgICBbcHJlZmVyZW5jZXMg c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseTpZRVNdOwpJbmRleDogV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29u dHJvbGxlck1hYy5tbQkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtpbmcgY29weSkKQEAgLTIz MCw2ICsyMzAsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlUwog ICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxlU2hl ZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlk ZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKQoreworICAgIFJl dGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmco a0NGQWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcgKmtleU5TID0gKE5TU3Ry aW5nICopa2V5Q0YuZ2V0KCk7CisJCisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBmbGFnQ0Yo QWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgZmxhZykp OworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNTdHJpbmcgKilmbGFnQ0YuZ2V0KCk7CisJCisg ICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBvdmVycmlkZVByZWZlcmVu Y2U6a2V5TlMgZmxhZzpmbGFnTlNdOwkKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYganNVUkwpCiB7 CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwgSlNTdHJpbmdD b3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC02NDAsNiArNjQwLDExIEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lz dGVudFN0YXQKIAogICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOwogICAg IGlmIChTVUNDRUVERUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpIHsKKyAg ICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwg cHJlZmVyZW5jZXMpOworICAgICAgICBpZiAocHJlZnNQcml2YXRlKSB7CisgICAgICAgICAgICBw cmVmc1ByaXZhdGUtPnJlc2V0VG9EZWZhdWx0cygpOworICAgICAgICAgICAgcHJlZnNQcml2YXRl LT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsKKyAgICAgICAgfSAgICAgICAg CQkKICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQoRkFMU0Up OwogICAgICAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21h dGljYWxseShUUlVFKTsKIApAQCAtNjUzLDkgKzY1OCw2IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2Vi Vmlld1RvQ29uc2lzdGVudFN0YXQKICAgICAgICAgfSBlbHNlCiAgICAgICAgICAgICBwcmVmZXJl bmNlcy0+c2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKEZBTFNFKTsKIAotICAgICAgICBDT01QdHI8 SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7 Ci0gICAgICAgIGlmIChwcmVmc1ByaXZhdGUpCi0gICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNl dEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOwogICAgIH0KIAogICAgIENPTVB0cjxJ V2ViVmlld1ByaXZhdGU+IHdlYlZpZXdQcml2YXRlKFF1ZXJ5LCB3ZWJWaWV3KTsKSW5kZXg6IFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RD b250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQXNzZXJ0aW9ucy5oPgog I2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+CiAjaW5jbHVkZSA8SmF2 YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU1N0 cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0Lmg+CiAjaW5jbHVkZSA8c3Ry aW5nPgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CkBAIC01Njks MyArNTcwLDI0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERhdGFiYXNlUXUKIHsg ICAgCiAgICAgcHJpbnRmKCJFUlJPUjogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERhdGFiYXNl UXVvdGEoKSBub3QgaW1wbGVtZW50ZWRcbiIpOwogfQorCit2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFn KQoreworICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKKyAgICBpZiAoRkFJTEVEKGZyYW1l LT53ZWJWaWV3KCZ3ZWJWaWV3KSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2Vi UHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOworICAgIGlmIChGQUlMRUQod2ViVmlldy0+cHJlZmVy ZW5jZXMoJnByZWZlcmVuY2VzKSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2Vi UHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKKyAg ICBpZiAoIXByZWZzUHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQlNUUiBrZXlCU1RS ID0gSlNTdHJpbmdDb3B5QlNUUihrZXkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBKU1N0cmluZ0Nv cHlCU1RSKGZsYWcpOworICAgIHByZWZzUHJpdmF0ZS0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleUJT VFIsIGZsYWdCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGtleUJTVFIpOworICAgIFN5c0ZyZWVT dHJpbmcoZmxhZ0JTVFIpOworfQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt cHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4 dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBs YXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVy cmlkZW4uIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5n IHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlvdSBzaG91 bGQgc2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2Vi S2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9zY3JpcHQ+Cis8Ym9keT4KKyAg ICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2 ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAKKyAgICBUaGlzIHRlc3QgdmVy aWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3Zl cnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91IHNob3VsZCBzZWUgIlBBU1Mi IGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgcCA9IGRvY3VtZW50LmdldEVs ZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCkuZm9udFNpemUgPT0gIjI0cHgi KQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsKKyAgICA8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZl cmVuY2VzLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRU ZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxh eW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJy aWRkZW4uIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4g YmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3 aXRoIGEgYnJvd3Nlci4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtcHJlZmVyZW5jZXMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwx OCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRl c3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQo KQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktp dEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAgICBmdW5jdGlvbiBs b2Fkc3RhdHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisg ICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJG QUlMIjsKKyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRzdGF0dXMoKSI+Cisg ICAgPHA+VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9s bGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uICBUaGlzIHRl c3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBh bmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIu PC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2JvZHk+Cis8L2h0bWw+ CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNl dC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVy cmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAK K1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJl c2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiBZb3Ug c2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6IExheW91dFRlc3RzL3NlY3Vy aXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4 dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQg dGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVyZW5j ZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cu PC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNjcmlwdD4KKyAg ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iUEFTUyI7 ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 24915 2008-11-05 11:41:56 -0800 2009-02-04 15:47:40 -0800 Possible fix for issue 20534 patch20534-download2.txt text/plain 20625 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbl07CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNO b3RpZmljYXRpb25dOwkKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBt ZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1 bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElm IHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGlu YXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBh IG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVj dGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4g dGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4gKGJ1ZyAyMDUzNCkKKyAgICAg ICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZhdWx0cyBhbmQgb3ZlcnJp ZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0YXRlCisgICAgICAgICog V2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVy ZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVy ZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAtMDYgIERhdmlkIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3bGVzcyBNYWMgV2ViS2l0 IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl S2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAsNyBAQAogI2RlZmluZSBX ZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZl cmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNlS2V5ICJXZWJLaXRD YWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoIgorI2Rl ZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJl ZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2Ug Y2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhl CiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM5IEBAIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJT VFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5nTGVuKGtleSkgfHwgIVN5 c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVy cygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBTeXNTdHJpbmdMZW4oa2V5KSkp OworICAgIHNldFN0cmluZ1ZhbHVlKGtleVJlZi5nZXQoKSwgdmFsdWUpOworICAgIHNldEJvb2xW YWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgdHJ1ZSk7Cisg ICAgcmV0dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVy ZW5jZXM6OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAgaWYgKCFib29sVmFsdWVGb3JLZXkoQ0ZT VFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbikpKQorICAgICAgICByZXR1cm4g U19PSzsKKworICAgIGludCBjb3VudCA9IENGRGljdGlvbmFyeUdldENvdW50KGRlZmF1bHRTZXR0 aW5ncyk7CisgICAgaWYgKGNvdW50IDw9IDApCisgICAgICAgIHJldHVybiBTX09LOworCisgICAg T3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZbY291bnRdKTsKKyAgICBP d25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAg Q0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZhdWx0U2V0dGluZ3MsIGtleXMuZ2V0KCks IHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpCisg ICAgICAgIHNldFZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSwg dmFsdWVzW2ldKTsKKworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVy ZW5jZXNPdmVycmlkZGVuKSwgZmFsc2UpOworCisgICAgcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05v dGlmaWNhdGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisKIHZvaWQgV2ViUHJlZmVyZW5j ZXM6OndpbGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1XZWJWaWV3czsKSW5kZXg6IFdl YktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlBy ZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl cy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMjAsNiArMzIwLDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0 dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2hvdWxkUGFpbnROYXRpdmVDb250cm9scygg CiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBCT09MICpzaG91bGRQYWludCk7CiAKKyAgICAvLyBU aGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMg cnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBvdmVycmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0g Ki8gQlNUUiBrZXksCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBU aGlzIG1ldGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMg Zm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0 dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAv LyBXZWJQcmVmZXJlbmNlcwogCiAgICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJl bnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2Vi S2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2 aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJp dmF0ZS5pZGwJKHdvcmtpbmcgY29weSkKQEAgLTYwLDQgKzYwLDEzIEBAIGludGVyZmFjZSBJV2Vi UHJlZmVyZW5jZXNQcml2YXRlIDogSVVua24KIAogICAgIEhSRVNVTFQgc2V0U2hvdWxkUGFpbnRO YXRpdmVDb250cm9scyhbaW5dIEJPT0wgc2hvdWxkUGFpbnQpOwogICAgIEhSRVNVTFQgc2hvdWxk UGFpbnROYXRpdmVDb250cm9scyhbb3V0LCByZXR2YWxdIEJPT0wqIGVuYWJsZWQpOworCisgICAg Ly8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRl c3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIG92 ZXJyaWRlUHJlZmVyZW5jZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOworCisgICAg Ly8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIHJlc2V0dGluZyBvdmVycmlkZGVuIHByZWZlcmVu Y2VzIGZvciB0ZXN0cyBydW4KKyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAg SFJFU1VMVCByZXNldFRvRGVmYXVsdHMoKTsKKwogfQpJbmRleDogV2ViS2l0VG9vbHMvQ2hhbmdl TG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkocmV2aXNpb24gMzc0MjUp CisrKyBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBA QAorMjAwOC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAg ICAgIENoYW5nZWQgTGF5b3V0VGVzdENvbnRyb2xsZXIgYW5kIER1bXBSZW5kZXJUcmVlIHRvIGFs bG93IGZvciBtYW51YWwKKyAgICAgICAgb3ZlcnJpZGluZyBvZiBkZWZhdWx0IHByZWZlcmVuY2Vz IGF0IHRlc3QgdGltZS4gIEFsc28gYWRkZWQgc3VwcG9ydCBmb3IKKyAgICAgICAgcmVzZXR0aW5n IHRoZSBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QuIChidWcgMjA1MzQpCisKKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6IEFkZGVkIGNhbGxiYWNr IG1ldGhvZCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6IEFkZGVkIHNpZ25hdHVyZSBmb3IgY2FsbGJhY2sK KyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwOiBBZGRlZCBj YWxscyB0byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5Cisg ICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDog QWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rpb24KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMv RHVtcFJlbmRlclRyZWUubW06IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHByZWZlcmVuY2VzIGFmdGVy IGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW06IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uCisKIDIw MDgtMTAtMDcgIEFkYW0gUm9iZW4gIDxhcm9iZW5AYXBwbGUuY29tPgogCiAgICAgICAgIE1ha2Ug c3VyZSBzaG9ydCBmdW5jdGlvbnMgZ2V0IGluY2x1ZGVkIGluIENoYW5nZUxvZyBvdXRwdXQgZm9y IGdpdApJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTMyMyw2 ICszMjMsMjIgQEAgc3RhdGljIEpTVmFsdWVSZWYgZXhlY0NvbW1hbmRDYWxsYmFjayhKUwogICAg IHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKIH0KIAorc3RhdGljIEpTVmFs dWVSZWYgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpT T2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1l bnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0 aW9uKQoreworICAgIGlmIChhcmd1bWVudENvdW50IDwgMikKKyAgICAgICAgcmV0dXJuIEpTVmFs dWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+ IGtleShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4 Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgSlNSZXRhaW5QdHI8SlNT dHJpbmdSZWY+IHZhbHVlKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3Vt ZW50c1sxXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKworICAgIExh eW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRU ZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29u dHJvbGxlci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleS5nZXQoKSwgdmFsdWUuZ2V0KCkpOworCisg ICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNW YWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09i amVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50 Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlv bikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC03MTAsNiArNzI2LDcgQEAg SlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OgogICAgICAgICB7ICJleGVj Q29tbWFuZCIsIGV4ZWNDb21tYW5kQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAia2VlcFdl Ykhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJl YWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm5v dGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAib3ZlcnJp ZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3VyY2VDYWxsYmFjaywg a0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERl bGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVldWVCYWNrTmF2aWdh dGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlB dHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2FyZE5hdmlnYXRpb24i LCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVh ZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5kZXg6IFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAkocmV2aXNp b24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC02OCw2ICs2OCw3IEBAIHB1YmxpYzoKICAgICB2b2lk IHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CiAgICAgdm9pZCBz ZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAg ICB2b2lkIGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAgdm9pZCBvdmVycmlk ZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKTsKICAgICBpbnQg d2luZG93Q291bnQoKTsKICAgICAKICAgICBib29sIGVsZW1lbnREb2VzQXV0b0NvbXBsZXRlRm9y RWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBpZCk7CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lvbiAzNzQyNSkKKysr IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQkod29ya2lu ZyBjb3B5KQpAQCAtOTUxLDYgKzk1MSw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29u c2lzdGVudFN0YXQKICAgICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1lXTsKIAogICAgIFdl YlByZWZlcmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVuY2VzXTsKKyAgICBb cHJlZmVyZW5jZXMgcmVzZXRUb0RlZmF1bHRzXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0RWRpdGFi bGVMaW5rQmVoYXZpb3I6V2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRLZXldOwog ICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKICAgICBbcHJl ZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsKICAgICBbcHJlZmVy ZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseTpZRVNdOwpJbmRl eDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFj Lm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRU ZXN0Q29udHJvbGxlck1hYy5tbQkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtpbmcgY29weSkK QEAgLTIzMCw2ICsyMzAsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0 eWxlUwogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0 eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpv dmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKQorewor ICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZT dHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcgKmtleU5TID0g KE5TU3RyaW5nICopa2V5Q0YuZ2V0KCk7CisJCisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBm bGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwg ZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNTdHJpbmcgKilmbGFnQ0YuZ2V0KCk7 CisJCisgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBvdmVycmlkZVBy ZWZlcmVuY2U6a2V5TlMgZmxhZzpmbGFnTlNdOwkKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYganNV UkwpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwgSlNT dHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAkocmV2aXNpb24gMzc0MjUpCisr KyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC02NDAsNiArNjQwLDExIEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1Rv Q29uc2lzdGVudFN0YXQKIAogICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2Vz OwogICAgIGlmIChTVUNDRUVERUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkp IHsKKyAgICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShR dWVyeSwgcHJlZmVyZW5jZXMpOworICAgICAgICBpZiAocHJlZnNQcml2YXRlKSB7CisgICAgICAg ICAgICBwcmVmc1ByaXZhdGUtPnJlc2V0VG9EZWZhdWx0cygpOworICAgICAgICAgICAgcHJlZnNQ cml2YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsKKyAgICAgICAgfSAg ICAgICAgCQkKICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQo RkFMU0UpOwogICAgICAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dz QXV0b21hdGljYWxseShUUlVFKTsKIApAQCAtNjUzLDkgKzY1OCw2IEBAIHN0YXRpYyB2b2lkIHJl c2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXQKICAgICAgICAgfSBlbHNlCiAgICAgICAgICAgICBw cmVmZXJlbmNlcy0+c2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKEZBTFNFKTsKIAotICAgICAgICBD T01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJl bmNlcyk7Ci0gICAgICAgIGlmIChwcmVmc1ByaXZhdGUpCi0gICAgICAgICAgICBwcmVmc1ByaXZh dGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOwogICAgIH0KIAogICAgIENP TVB0cjxJV2ViVmlld1ByaXZhdGU+IHdlYlZpZXdQcml2YXRlKFF1ZXJ5LCB3ZWJWaWV3KTsKSW5k ZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldp bi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91 dFRlc3RDb250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCSh3b3JraW5nIGNv cHkpCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQXNzZXJ0aW9u cy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+CiAjaW5jbHVk ZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0Lmg+CiAjaW5jbHVk ZSA8c3RyaW5nPgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CkBA IC01NjksMyArNTcwLDI0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERhdGFiYXNl UXUKIHsgICAgCiAgICAgcHJpbnRmKCJFUlJPUjogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERh dGFiYXNlUXVvdGEoKSBub3QgaW1wbGVtZW50ZWRcbiIpOwogfQorCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1Jl ZiBmbGFnKQoreworICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKKyAgICBpZiAoRkFJTEVE KGZyYW1lLT53ZWJWaWV3KCZ3ZWJWaWV3KSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0 cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOworICAgIGlmIChGQUlMRUQod2ViVmlldy0+ cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0 cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2Vz KTsKKyAgICBpZiAoIXByZWZzUHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQlNUUiBr ZXlCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihrZXkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBKU1N0 cmluZ0NvcHlCU1RSKGZsYWcpOworICAgIHByZWZzUHJpdmF0ZS0+b3ZlcnJpZGVQcmVmZXJlbmNl KGtleUJTVFIsIGZsYWdCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGtleUJTVFIpOworICAgIFN5 c0ZyZWVTdHJpbmcoZmxhZ0JTVFIpOworfQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3Zl cnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMg dGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNl cyBvdmVycmlkZW4uIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQg c3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlv dSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkKKysr IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1w QXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5j ZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9zY3JpcHQ+Cis8Ym9k eT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBj YW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAKKyAgICBUaGlzIHRl c3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFs c28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91IHNob3VsZCBzZWUg IlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgcCA9IGRvY3VtZW50 LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3aW5kb3cubGF5b3V0 VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCkuZm9udFNpemUgPT0g IjI0cHgiKQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsKKyAgICA8L3Njcmlw dD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRl LXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBM YXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0 aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2Vz IG92ZXJyaWRkZW4uIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlw dCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmll d2luZyB3aXRoIGEgYnJvd3Nlci4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAs MCArMSwxOCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBB c1RleHQoKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2Uo IldlYktpdEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAgICBmdW5j dGlvbiBsb2Fkc3RhdHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJI VE1MPSJGQUlMIjsKKyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRzdGF0dXMo KSI+CisgICAgPHA+VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RD b250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uICBU aGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2Fi bGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJy b3dzZXIuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2JvZHk+Cis8 L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6 ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0 eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3 aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0 LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6IExheW91dFRlc3Rz L3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVt cEFzVGV4dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVz IHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJl ZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIg YmVsb3cuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNjcmlw dD4KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0i UEFTUyI7ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 25486 2008-11-25 10:38:39 -0800 2008-11-25 13:54:22 -0800 An updated patch for 20534 patch20534-final.txt text/plain 20058 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoYnVnIDIwNTM0KQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJl bmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAor ICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3 IG1ldGhvZAorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBt ZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxl LmNvbT4KIAogICAgICAgICBNb3ZlIHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJp IG5lZWRzIGZyb20gV2ViVmlld0ludGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24g Mzc0MDIpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJ KHdvcmtpbmcgY29weSkKQEAgLTcwLDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVs bERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50 VGVhcmRvd24iCiAjZGVmaW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxl ZFByZWZlcmVuY2VLZXkgQCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQi CiAjZGVmaW5lIFdlYktpdFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNU ZXh0T25seSIKKyNkZWZpbmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldl YktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRl IGJvdGggYmVjYXVzZSBjYWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBh bmQgYmVjYXVzZSB0aGUKIC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4K SW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQor KysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBA IC0xMDUwLDYgKzEwNTAsMjUgQEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0g bmlsOwogewogICAgIHJldHVybiBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1 bGxEb2N1bWVudFRlYXJkb3duUHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzCit7CisgICAgaWYgKCFbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQ cmVmZXJlbmNlc092ZXJyaWRkZW5dKQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07 CisJCisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFBy ZWZlcmVuY2VzT3ZlcnJpZGRlbl07CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNO b3RpZmljYXRpb25dOwkKK30KKworLSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5n ICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0 U3RyaW5nVmFsdWU6cHJlZmVyZW5jZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTp0cnVlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsK K30KKworCisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRl cm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJ KHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJp dmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcg KldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcill ZGl0YWJsZUxpbmtCZWhhdmlvcjsKIC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdl YktpdEVkaXRhYmxlTGlua0JlaGF2aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBt ZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1 bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAq KWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRo IER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElm IHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGlu YXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBh IG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVj dGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4g dGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAw OC0xMC0wOCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92 ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4gKGJ1ZyAyMDUzNCkKKyAgICAg ICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZhdWx0cyBhbmQgb3ZlcnJp ZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0YXRlCisgICAgICAgICog V2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVy ZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVy ZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAtMDYgIERhdmlkIEh5YXR0 ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3bGVzcyBNYWMgV2ViS2l0 IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVu Y2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtl eXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl S2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAsNyBAQAogI2RlZmluZSBX ZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNlc1BhZ2VDYWNoZVByZWZl cmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJlbmNlS2V5ICJXZWJLaXRD YWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJh c2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoIgorI2Rl ZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJXZWJLaXREZWZhdWx0UHJl ZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0ZSBib3RoIGJlY2F1c2Ug Y2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMgYW5kIGJlY2F1c2UgdGhl CiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM5IEBAIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJT VFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5nTGVuKGtleSkgfHwgIVN5 c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVy cygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBTeXNTdHJpbmdMZW4oa2V5KSkp OworICAgIHNldFN0cmluZ1ZhbHVlKGtleVJlZi5nZXQoKSwgdmFsdWUpOworICAgIHNldEJvb2xW YWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgdHJ1ZSk7Cisg ICAgcmV0dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVy ZW5jZXM6OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAgaWYgKCFib29sVmFsdWVGb3JLZXkoQ0ZT VFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbikpKQorICAgICAgICByZXR1cm4g U19PSzsKKworICAgIGludCBjb3VudCA9IENGRGljdGlvbmFyeUdldENvdW50KGRlZmF1bHRTZXR0 aW5ncyk7CisgICAgaWYgKGNvdW50IDw9IDApCisgICAgICAgIHJldHVybiBTX09LOworCisgICAg T3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZbY291bnRdKTsKKyAgICBP d25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAg Q0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZhdWx0U2V0dGluZ3MsIGtleXMuZ2V0KCks IHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGNvdW50OyArK2kpCisg ICAgICAgIHNldFZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3RyaW5nUmVmPihrZXlzW2ldKSwg dmFsdWVzW2ldKTsKKworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVy ZW5jZXNPdmVycmlkZGVuKSwgZmFsc2UpOworCisgICAgcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05v dGlmaWNhdGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisKIHZvaWQgV2ViUHJlZmVyZW5j ZXM6OndpbGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1XZWJWaWV3czsKSW5kZXg6IFdl YktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlBy ZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNl cy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMjAsNiArMzIwLDE2IEBAIHB1YmxpYzoKICAgICB2aXJ0 dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2hvdWxkUGFpbnROYXRpdmVDb250cm9scygg CiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBCT09MICpzaG91bGRQYWludCk7CiAKKyAgICAvLyBU aGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMg cnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VM VCBTVERNRVRIT0RDQUxMVFlQRSBvdmVycmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0g Ki8gQlNUUiBrZXksCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBU aGlzIG1ldGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMg Zm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0 dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAv LyBXZWJQcmVmZXJlbmNlcwogCiAgICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJl bnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2Vi S2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2 aXNpb24gMzg3NTIpCisrKyBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJp dmF0ZS5pZGwJKHdvcmtpbmcgY29weSkKQEAgLTY2LDQgKzY2LDEzIEBAIGludGVyZmFjZSBJV2Vi UHJlZmVyZW5jZXNQcml2YXRlIDogSVVua24KIAogICAgIEhSRVNVTFQgc2V0TG9jYWxTdG9yYWdl RW5hYmxlZChbaW5dIEJPT0wgZW5hYmxlZCk7CiAgICAgSFJFU1VMVCBsb2NhbFN0b3JhZ2VFbmFi bGVkKFtvdXQsIHJldHZhbF0gQk9PTCAqZW5hYmxlZCk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBp cyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8g d2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQgb3ZlcnJpZGVQcmVmZXJlbmNl KFtpbl0gQlNUUiBrZXksIFtpbl0gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBp cyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1 bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIHJlc2V0VG9E ZWZhdWx0cygpOworCiB9CkluZGV4OiBXZWJLaXRUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBACisyMDA4LTEwLTA4ICBH bGVubiBXaWxzb24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAgICAgQ2hhbmdlZCBMYXlv dXRUZXN0Q29udHJvbGxlciBhbmQgRHVtcFJlbmRlclRyZWUgdG8gYWxsb3cgZm9yIG1hbnVhbAor ICAgICAgICBvdmVycmlkaW5nIG9mIGRlZmF1bHQgcHJlZmVyZW5jZXMgYXQgdGVzdCB0aW1lLiAg QWxzbyBhZGRlZCBzdXBwb3J0IGZvcgorICAgICAgICByZXNldHRpbmcgdGhlIHByZWZlcmVuY2Vz IGFmdGVyIGVhY2ggdGVzdC4gKGJ1ZyAyMDUzNCkKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcDogQWRkZWQgY2FsbGJhY2sgbWV0aG9kIGZvciBvdmVy cmlkaW5nIHByZWZlcmVuY2VzCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaDogQWRkZWQgc2lnbmF0dXJlIGZvciBjYWxsYmFjaworICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHA6IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHBy ZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwOiBBZGRlZCBKUyBvdmVycmlk ZSBmdW5jdGlvbgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5t bTogQWRkZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlmIG5l Y2Vzc2FyeQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxl ck1hYy5tbTogQWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rpb24KKwogMjAwOC0xMC0wNyAgQWRhbSBS b2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBzdXJlIHNob3J0IGZ1bmN0 aW9ucyBnZXQgaW5jbHVkZWQgaW4gQ2hhbmdlTG9nIG91dHB1dCBmb3IgZ2l0CkluZGV4OiBXZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3Bw CShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRl c3RDb250cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzIzLDYgKzMyMywyMiBAQCBzdGF0 aWMgSlNWYWx1ZVJlZiBleGVjQ29tbWFuZENhbGxiYWNrKEpTCiAgICAgcmV0dXJuIEpTVmFsdWVN YWtlVW5kZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiBvdmVycmlkZVBy ZWZlcmVuY2VDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rp b24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBK U1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYg KGFyZ3VtZW50Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQo Y29udGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5KEFkb3B0LCBKU1Zh bHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAg QVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gdmFsdWUo QWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzFdLCBleGNlcHRp b24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xs ZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4o SlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlk ZVByZWZlcmVuY2Uoa2V5LmdldCgpLCB2YWx1ZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1 ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIGtlZXBXZWJI aXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9u LCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNW YWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhh cyBtYWMgaW1wbGVtZW50YXRpb24KQEAgLTcxMCw2ICs3MjYsNyBAQCBKU1N0YXRpY0Z1bmN0aW9u KiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6CiAgICAgICAgIHsgImV4ZWNDb21tYW5kIiwgZXhlY0Nv bW1hbmRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtlZXBX ZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlm eURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5 QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBv dmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8 IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJwYXRoVG9Mb2Nh bFJlc291cmNlIiwgcGF0aFRvTG9jYWxSZXNvdXJjZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgInF1ZXVlQmFja05hdmlnYXRpb24iLCBxdWV1ZUJhY2tOYXZpZ2F0aW9uQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKICAgICAgICAgeyAicXVldWVGb3J3YXJkTmF2aWdhdGlvbiIsIHF1ZXVlRm9yd2FyZE5h dmlnYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3Bl cnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCShyZXZpc2lvbiAzNzQyNSkKKysrIFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgJKHdvcmtpbmcg Y29weSkKQEAgLTY4LDYgKzY4LDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0VXNlclN0eWxlU2hl ZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2b2lkIHNldFBlcnNpc3RlbnRVc2Vy U3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOwogICAgIHZvaWQgY2xlYXJQZXJz aXN0ZW50VXNlclN0eWxlU2hlZXQoKTsKKyAgICB2b2lkIG92ZXJyaWRlUHJlZmVyZW5jZShKU1N0 cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpOwogICAgIGludCB3aW5kb3dDb3VudCgpOwog ICAgIAogICAgIGJvb2wgZWxlbWVudERvZXNBdXRvQ29tcGxldGVGb3JFbGVtZW50V2l0aElkKEpT U3RyaW5nUmVmIGlkKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1w UmVuZGVyVHJlZS5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9t YWMvRHVtcFJlbmRlclRyZWUubW0JKHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3b3JraW5nIGNvcHkpCkBAIC05NTEs NiArOTUxLDggQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdAogICAg IFt3ZWJWaWV3IF9jbGVhck1haW5GcmFtZU5hbWVdOwogCiAgICAgV2ViUHJlZmVyZW5jZXMgKnBy ZWZlcmVuY2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOworICAgIFtwcmVmZXJlbmNlcyByZXNl dFRvRGVmYXVsdHNdOworICAgIFtwcmVmZXJlbmNlcyBzZXRFZGl0YWJsZUxpbmtCZWhhdmlvcjpX ZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleV07CiAgICAgW3ByZWZlcmVuY2Vz IHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOwogICAgIFtwcmVmZXJlbmNlcyBzZXRBdXRo b3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOwogICAgIFtwcmVmZXJlbmNlcyBzZXRKYXZhU2Ny aXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107CkluZGV4OiBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFj Lm1tCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9M YXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkod29ya2luZyBjb3B5KQpAQCAtMjMwLDYgKzIzMCwx NyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2VyU3R5bGVTCiAgICAgW1tXZWJQ cmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9u OnVybF07CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5j ZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpCit7CisgICAgUmV0YWluUHRyPENG U3RyaW5nUmVmPiBrZXlDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0 b3JEZWZhdWx0LCBrZXkpKTsKKyAgICBOU1N0cmluZyAqa2V5TlMgPSAoTlNTdHJpbmcgKilrZXlD Ri5nZXQoKTsKKwkKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGZsYWdDRihBZG9wdENGLCBK U1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBmbGFnKSk7CisgICAgTlNT dHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAqKWZsYWdDRi5nZXQoKTsKKwkKKyAgICBbW1dlYlBy ZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5jZXNdIG92ZXJyaWRlUHJlZmVyZW5jZTprZXlOUyBm bGFnOmZsYWdOU107CQorfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRQZXJzaXN0 ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBqc1VSTCkKIHsKICAgICBSZXRh aW5QdHI8Q0ZTdHJpbmdSZWY+IHVybFN0cmluZyhBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmlu ZygwLCBqc1VSTCkpOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBS ZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93 aW4vRHVtcFJlbmRlclRyZWUuY3BwCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY1 Niw2ICs2NTcsNyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAK ICAgICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVy eSwgcHJlZmVyZW5jZXMpOwogICAgICAgICBpZiAocHJlZnNQcml2YXRlKSB7CisgICAgICAgICAg ICBwcmVmc1ByaXZhdGUtPnJlc2V0VG9EZWZhdWx0cygpOwogICAgICAgICAgICAgcHJlZnNQcml2 YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsKICAgICAgICAgICAgIHBy ZWZzUHJpdmF0ZS0+c2V0RGV2ZWxvcGVyRXh0cmFzRW5hYmxlZChGQUxTRSk7CiAgICAgICAgIH0K SW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxl cldpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xh eW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCSh3b3JraW5n IGNvcHkpCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQXNzZXJ0 aW9ucy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+CiAjaW5j bHVkZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDxKYXZhU2NyaXB0 Q29yZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0Lmg+CiAjaW5j bHVkZSA8c3RyaW5nPgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+ CkBAIC01NjksMyArNTcwLDI0IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERhdGFi YXNlUXUKIHsgICAgCiAgICAgcHJpbnRmKCJFUlJPUjogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNl dERhdGFiYXNlUXVvdGEoKSBub3QgaW1wbGVtZW50ZWRcbiIpOwogfQorCit2b2lkIExheW91dFRl c3RDb250cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmlu Z1JlZiBmbGFnKQoreworICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKKyAgICBpZiAoRkFJ TEVEKGZyYW1lLT53ZWJWaWV3KCZ3ZWJWaWV3KSkpCisgICAgICAgIHJldHVybjsKKworICAgIENP TVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOworICAgIGlmIChGQUlMRUQod2ViVmll dy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpCisgICAgICAgIHJldHVybjsKKworICAgIENP TVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVu Y2VzKTsKKyAgICBpZiAoIXByZWZzUHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQlNU UiBrZXlCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihrZXkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBK U1N0cmluZ0NvcHlCU1RSKGZsYWcpOworICAgIHByZWZzUHJpdmF0ZS0+b3ZlcnJpZGVQcmVmZXJl bmNlKGtleUJTVFIsIGZsYWdCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGtleUJTVFIpOworICAg IFN5c0ZyZWVTdHJpbmcoZmxhZ0JTVFIpOworfQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0 VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4 cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZp ZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJl bmNlcyBvdmVycmlkZW4uIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2Nl cHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUu IFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMv c2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVy ZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9zY3JpcHQ+Cis8 Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxl ciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAKKyAgICBUaGlz IHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5k IGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91IHNob3VsZCBz ZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgcCA9IGRvY3Vt ZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCkuZm9udFNpemUg PT0gIjI0cHgiKQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsKKyAgICA8L3Nj cmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJy aWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9z ZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmll cyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVu Y2VzIG92ZXJyaWRkZW4uIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNj cmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYg dmlld2luZyB3aXRoIGEgYnJvd3Nlci4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJp dHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9z ZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0 VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSwxOCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93 LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVu Y2UoIldlYktpdEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAgICBm dW5jdGlvbiBsb2Fkc3RhdHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5u ZXJIVE1MPSJGQUlMIjsKKyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRzdGF0 dXMoKSI+CisgICAgPHA+VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRl c3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4u ICBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRp c2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBh IGJyb3dzZXIuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2JvZHk+ Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQt ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRl LXp6ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxl ciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0 ZXN0LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6IExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lvbiAwKQorKysg TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlm aWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQg cHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFT UyIgYmVsb3cuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNj cmlwdD4KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRN TD0iUEFTUyI7ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 25496 2008-11-25 13:54:22 -0800 2008-12-30 17:01:45 -0800 Improved possible patch for issue 20534 patch20534-final.txt text/plain 20083 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzNzQwMikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMDgtMTAtMDggIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGlu ZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5n IHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLiAoaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwNTM0KQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDoKKyAg ICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgorICAgICAgICAoLVtXZWJQcmVmZXJl bmNlcyByZXNldFRvRGVmYXVsdHNdKTogbmV3IG1ldGhvZAorICAgICAgICAoLVtXZWJQcmVmZXJl bmNlcyBvdmVycmlkZVByZWZlcmVuY2U6ZmxhZzpdKTogbmV3IG1ldGhvZAorICAgICAgICAqIFdl YlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IG5ldyBtZXRob2Qgc2lnbmF0dXJlcworCiAy MDA4LTEwLTA3ICBEYXZpZCBIeWF0dCAgPGh5YXR0QGFwcGxlLmNvbT4KIAogICAgICAgICBNb3Zl IHZpZXdsZXNzIFdlYktpdCBtZXRob2RzIHRoYXQgU2FmYXJpIG5lZWRzIGZyb20gV2ViVmlld0lu dGVybmFsIHRvIFdlYlZpZXdQcml2YXRlLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlBy ZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9X ZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvbWFj L1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTcw LDYgKzcwLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRvd25QcmVm ZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRvd24iCiAjZGVmaW5lIFdl YktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZFByZWZlcmVuY2VLZXkgQCJXZWJL aXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQiCiAjZGVmaW5lIFdlYktpdFpvb21z VGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNUZXh0T25seSIKKyNkZWZpbmUgV2Vi S2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldlYktpdERlZmF1bHRQcmVmZXJlbmNl c092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRlIGJvdGggYmVjYXVzZSBjYWxsZXJz IHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBhbmQgYmVjYXVzZSB0aGUKIC8vIGNv dmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4KSW5kZXg6IFdlYktpdC9tYWMvV2Vi Vmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcv V2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0xMDUwLDYgKzEwNTAsMjUgQEAg c3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0gbmlsOwogewogICAgIHJldHVybiBb c2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1bGxEb2N1bWVudFRlYXJkb3duUHJl ZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0RlZmF1bHRzCit7CisgICAgaWYgKCFb c2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdERlZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW5d KQorICAgICAgICByZXR1cm47CisgICAgW3NlbGYgaW5pdF07CisJCisgICAgW3NlbGYgX3NldEJv b2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbl07 CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb25dOwkKK30KKwor LSAodm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5nICopa2V5IGZsYWc6KE5TU3RyaW5n ICopcHJlZmVyZW5jZUZsYWcKK3sKKyAgICBbc2VsZiBfc2V0U3RyaW5nVmFsdWU6cHJlZmVyZW5j ZUZsYWcgZm9yS2V5OmtleV07CisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTp0cnVlIGZvcktleTpX ZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuXTsKK30KKworCisKIEBlbmQKIAogQGlt cGxlbWVudGF0aW9uIFdlYlByZWZlcmVuY2VzIChXZWJJbnRlcm5hbCkKSW5kZXg6IFdlYktpdC9t YWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQv bWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysg V2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCSh3b3JraW5nIGNvcHkp CkBAIC04Nyw2ICs4NywxNSBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZlcmVuY2VzUmVtb3Zl ZE5vCiAtIChXZWJLaXRFZGl0YWJsZUxpbmtCZWhhdmlvcillZGl0YWJsZUxpbmtCZWhhdmlvcjsK IC0gKHZvaWQpc2V0RWRpdGFibGVMaW5rQmVoYXZpb3I6KFdlYktpdEVkaXRhYmxlTGlua0JlaGF2 aW9yKWJlaGF2aW9yOwogCisvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBw cmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCist KHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAqKWtleSBmbGFnOihOU1N0cmluZyAq KWZsYWc7CisKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRl biBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHku CistKHZvaWQpcmVzZXRUb0RlZmF1bHRzOworCisKIC8vIElmIHNpdGUtc3BlY2lmaWMgc3Bvb2Zp bmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGluYXBwcm9wcmlhdGUgdXNlci1hZ2Vu dCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBhIG5vbnN0YW5kYXJkIHVzZXItYWdl bnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVjdGx5LiBUaGlzIG1ldGhvZCBtaWdo dCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4gdGhlcmUncyBubyBtb3JlIG5lZWQg Zm9yIGl0LgpJbmRleDogV2ViS2l0L3dpbi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 L3dpbi9DaGFuZ2VMb2cJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dpbi9DaGFuZ2VMb2cJ KHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNyBAQAorMjAwOC0xMC0wOCAgR2xlbm4gV2lsc29u ICA8Z3dpbHNvbkBnb29nbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZGVkIHN1cHBvcnQgZm9yIG92ZXJyaWRpbmcgZGVmYXVsdCBwcmVm ZXJlbmNlcyBwZXItdGVzdC4gKGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMDUzNCkKKyAgICAgICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9EZWZh dWx0cyBhbmQgb3ZlcnJpZGVQcmVmZXJlbmNlLgorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2Vi UHJlZmVyZW5jZXNQcml2YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICog V2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmg6IGFkZGVkIG5ldyBrZXkgZm9yIGludGVybmFsIHN0 YXRlCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAg ICAgICAoV2ViUHJlZmVyZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZSk6IG5ldyBtZXRob2QKKyAg ICAgICAgKFdlYlByZWZlcmVuY2VzOjpyZXNldFRvRGVmYXVsdHMpOiBuZXcgbWV0aG9kCisgICAg ICAgICogV2ViUHJlZmVyZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDgtMTAt MDYgIERhdmlkIEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSB2aWV3 bGVzcyBNYWMgV2ViS2l0IHRvIHBhaW50IHNvbWUgYmFzaWMgcGFnZXMuCkluZGV4OiBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4v V2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dp bi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjAsNiArNjAs NyBAQAogI2RlZmluZSBXZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0VXNl c1BhZ2VDYWNoZVByZWZlcmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVmZXJl bmNlS2V5ICJXZWJLaXRDYWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0TG9j YWxTdG9yYWdlRGF0YWJhc2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdlRGF0 YWJhc2VQYXRoIgorI2RlZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuICJX ZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJpdmF0 ZSBib3RoIGJlY2F1c2UgY2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhvZHMg YW5kIGJlY2F1c2UgdGhlCiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZhdGUu CkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJL aXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAkocmV2aXNpb24gMzc0MDIpCisrKyBXZWJLaXQvd2lu L1dlYlByZWZlcmVuY2VzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTE4NSw2ICsxMTg1LDM5IEBA IEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXMKICAgICByZXR1cm4gU19P SzsKIH0KIAorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJp ZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5n TGVuKGtleSkgfHwgIVN5c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7 CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVh dGVXaXRoQ2hhcmFjdGVycygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBTeXNT dHJpbmdMZW4oa2V5KSkpOworICAgIHNldFN0cmluZ1ZhbHVlKGtleVJlZi5nZXQoKSwgdmFsdWUp OworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlk ZGVuKSwgdHJ1ZSk7CisgICAgcmV0dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RETUVUSE9EQ0FM TFRZUEUgV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAgaWYgKCFib29s VmFsdWVGb3JLZXkoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbikpKQor ICAgICAgICByZXR1cm4gU19PSzsKKworICAgIGludCBjb3VudCA9IENGRGljdGlvbmFyeUdldENv dW50KGRlZmF1bHRTZXR0aW5ncyk7CisgICAgaWYgKGNvdW50IDw9IDApCisgICAgICAgIHJldHVy biBTX09LOworCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVSZWZb Y291bnRdKTsKKyAgICBPd25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcgQ0ZUeXBlUmVm W2NvdW50XSk7CisgICAgQ0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZhdWx0U2V0dGlu Z3MsIGtleXMuZ2V0KCksIHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBpID0gMDsgaSA8 IGNvdW50OyArK2kpCisgICAgICAgIHNldFZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3RyaW5n UmVmPihrZXlzW2ldKSwgdmFsdWVzW2ldKTsKKworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJL aXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgZmFsc2UpOworCisgICAgcG9zdFByZWZl cmVuY2VzQ2hhbmdlc05vdGlmaWNhdGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisKIHZv aWQgV2ViUHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1XZWJW aWV3czsKSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM3NDAyKQorKysgV2ViS2l0L3dp bi9XZWJQcmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMjAsNiArMzIwLDE2IEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2hvdWxkUGFpbnRO YXRpdmVDb250cm9scyggCiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBCT09MICpzaG91bGRQYWlu dCk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJl bmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAg IHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBvdmVycmlkZVByZWZlcmVuY2UoCisg ICAgICAgIC8qIFtpbl0gKi8gQlNUUiBrZXksCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1 ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRk ZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUg b25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgcmVzZXRUb0RlZmF1 bHRzKCk7CisKICAgICAvLyBXZWJQcmVmZXJlbmNlcwogCiAgICAgLy8gVGhpcyBtZXRob2QgYWNj ZXNzZXMgYSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkgdGhhbiBkZXZlbG9wZXJFeHRyYXNFbmFi bGVkLgpJbmRleDogV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUu aWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQ cml2YXRlLmlkbAkocmV2aXNpb24gMzg3NTIpCisrKyBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdl YlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJKHdvcmtpbmcgY29weSkKQEAgLTY2LDQgKzY2LDEzIEBA IGludGVyZmFjZSBJV2ViUHJlZmVyZW5jZXNQcml2YXRlIDogSVVua24KIAogICAgIEhSRVNVTFQg c2V0TG9jYWxTdG9yYWdlRW5hYmxlZChbaW5dIEJPT0wgZW5hYmxlZCk7CiAgICAgSFJFU1VMVCBs b2NhbFN0b3JhZ2VFbmFibGVkKFtvdXQsIHJldHZhbF0gQk9PTCAqZW5hYmxlZCk7CisKKyAgICAv LyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVz dHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQgb3Zl cnJpZGVQcmVmZXJlbmNlKFtpbl0gQlNUUiBrZXksIFtpbl0gQlNUUiB2YWx1ZSk7CisKKyAgICAv LyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5j ZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBI UkVTVUxUIHJlc2V0VG9EZWZhdWx0cygpOworCiB9CkluZGV4OiBXZWJLaXRUb29scy9DaGFuZ2VM b2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAzNzQyNSkK KysrIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBA CisyMDA4LTEwLTA4ICBHbGVubiBXaWxzb24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAg ICAgQ2hhbmdlZCBMYXlvdXRUZXN0Q29udHJvbGxlciBhbmQgRHVtcFJlbmRlclRyZWUgdG8gYWxs b3cgZm9yIG1hbnVhbAorICAgICAgICBvdmVycmlkaW5nIG9mIGRlZmF1bHQgcHJlZmVyZW5jZXMg YXQgdGVzdCB0aW1lLiAgQWxzbyBhZGRlZCBzdXBwb3J0IGZvcgorICAgICAgICByZXNldHRpbmcg dGhlIHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdC4gKGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMDUzNCkKKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcDogQWRkZWQgY2FsbGJhY2sgbWV0aG9kIGZvciBvdmVycmlkaW5n IHByZWZlcmVuY2VzCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuaDogQWRkZWQgc2lnbmF0dXJlIGZvciBjYWxsYmFjaworICAgICAgICAqIER1bXBSZW5kZXJU cmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHA6IEFkZGVkIGNhbGxzIHRvIHJlc2V0IHByZWZlcmVu Y2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwOiBBZGRlZCBKUyBvdmVycmlkZSBmdW5j dGlvbgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbTogQWRk ZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlmIG5lY2Vzc2Fy eQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5t bTogQWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rpb24KKwogMjAwOC0xMC0wNyAgQWRhbSBSb2JlbiAg PGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAgICAgTWFrZSBzdXJlIHNob3J0IGZ1bmN0aW9ucyBn ZXQgaW5jbHVkZWQgaW4gQ2hhbmdlTG9nIG91dHB1dCBmb3IgZ2l0CkluZGV4OiBXZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCShyZXZp c2lvbiAzNzQyNSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzIzLDYgKzMyMywyMiBAQCBzdGF0aWMgSlNW YWx1ZVJlZiBleGVjQ29tbWFuZENhbGxiYWNrKEpTCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5k ZWZpbmVkKGNvbnRleHQpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiBvdmVycmlkZVByZWZlcmVu Y2VDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpT T2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVl UmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3Vt ZW50Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4 dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5KEFkb3B0LCBKU1ZhbHVlVG9T dHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJU KCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gdmFsdWUoQWRvcHQs IEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzFdLCBleGNlcHRpb24pKTsK KyAgICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNv bnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNPYmpl Y3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlkZVByZWZl cmVuY2Uoa2V5LmdldCgpLCB2YWx1ZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1ha2VV bmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIGtlZXBXZWJIaXN0b3J5 Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09i amVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJl ZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBtYWMg aW1wbGVtZW50YXRpb24KQEAgLTcxMCw2ICs3MjYsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlv dXRUZXN0Q29udHJvbGxlcjo6CiAgICAgICAgIHsgImV4ZWNDb21tYW5kIiwgZXhlY0NvbW1hbmRD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJrZWVwV2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0 b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibm90aWZ5RG9uZSIsIG5vdGlmeURvbmVD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlk ZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1By b3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJwYXRoVG9Mb2NhbFJlc291 cmNlIiwgcGF0aFRvTG9jYWxSZXNvdXJjZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJl YWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1 ZXVlQmFja05hdmlnYXRpb24iLCBxdWV1ZUJhY2tOYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3Bl cnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwK ICAgICAgICAgeyAicXVldWVGb3J3YXJkTmF2aWdhdGlvbiIsIHF1ZXVlRm9yd2FyZE5hdmlnYXRp b25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0 cmlidXRlRG9udERlbGV0ZSB9LApJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5 b3V0VGVzdENvbnRyb2xsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCShyZXZpc2lvbiAzNzQyNSkKKysrIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkK QEAgLTY4LDYgKzY4LDcgQEAgcHVibGljOgogICAgIHZvaWQgc2V0VXNlclN0eWxlU2hlZXRMb2Nh dGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2b2lkIHNldFBlcnNpc3RlbnRVc2VyU3R5bGVT aGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOwogICAgIHZvaWQgY2xlYXJQZXJzaXN0ZW50 VXNlclN0eWxlU2hlZXQoKTsKKyAgICB2b2lkIG92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1Jl ZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpOwogICAgIGludCB3aW5kb3dDb3VudCgpOwogICAgIAog ICAgIGJvb2wgZWxlbWVudERvZXNBdXRvQ29tcGxldGVGb3JFbGVtZW50V2l0aElkKEpTU3RyaW5n UmVmIGlkKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVy VHJlZS5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVt cFJlbmRlclRyZWUubW0JKHJldmlzaW9uIDM3NDI1KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3b3JraW5nIGNvcHkpCkBAIC05NTEsNiArOTUx LDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdAogICAgIFt3ZWJW aWV3IF9jbGVhck1haW5GcmFtZU5hbWVdOwogCiAgICAgV2ViUHJlZmVyZW5jZXMgKnByZWZlcmVu Y2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOworICAgIFtwcmVmZXJlbmNlcyByZXNldFRvRGVm YXVsdHNdOwogICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsK ICAgICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsKICAg ICBbcHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseTpZ RVNdOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250 cm9sbGVyTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21h Yy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkocmV2aXNpb24gMzc0MjUpCisrKyBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtp bmcgY29weSkKQEAgLTIzMCw2ICsyMzAsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6 c2V0VXNlclN0eWxlUwogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10g c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBm bGFnKQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJp bmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcg KmtleU5TID0gKE5TU3RyaW5nICopa2V5Q0YuZ2V0KCk7CisJCisgICAgUmV0YWluUHRyPENGU3Ry aW5nUmVmPiBmbGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9y RGVmYXVsdCwgZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNTdHJpbmcgKilmbGFn Q0YuZ2V0KCk7CisJCisgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBv dmVycmlkZVByZWZlcmVuY2U6a2V5TlMgZmxhZzpmbGFnTlNdOwkKK30KKwogdm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJp bmdSZWYganNVUkwpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRv cHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsKSW5kZXg6IFdlYktpdFRvb2xz L0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAkocmV2aXNpb24g Mzc0MjUpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC02NTYsNiArNjU3LDcgQEAgc3RhdGljIHZvaWQgcmVzZXRX ZWJWaWV3VG9Db25zaXN0ZW50U3RhdAogCiAgICAgICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQ cml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKICAgICAgICAgaWYgKHBy ZWZzUHJpdmF0ZSkgeworICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5yZXNldFRvRGVmYXVsdHMo KTsKICAgICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJs ZWQoVFJVRSk7CiAgICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldERldmVsb3BlckV4dHJhc0Vu YWJsZWQoRkFMU0UpOwogICAgICAgICB9CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHJldmlz aW9uIDM3NDI1KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RD b250cm9sbGVyV2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1 ZGUgPEphdmFTY3JpcHRDb3JlL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTUmV0YWluUHRy Lmg+CisjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNTdHJpbmdSZWZCU1RSLmg+CiAjaW5jbHVk ZSA8V2ViS2l0L1dlYktpdC5oPgogI2luY2x1ZGUgPHN0cmluZz4KICNpbmNsdWRlIDxDb3JlRm91 bmRhdGlvbi9Db3JlRm91bmRhdGlvbi5oPgpAQCAtNTY5LDMgKzU3MCwyNCBAQCB2b2lkIExheW91 dFRlc3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1CiB7ICAgIAogICAgIHByaW50ZigiRVJST1I6 IExheW91dFRlc3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1b3RhKCkgbm90IGltcGxlbWVudGVk XG4iKTsKIH0KKwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNl KEpTU3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZp ZXc+IHdlYlZpZXc7CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQor ICAgICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNl czsKKyAgICBpZiAoRkFJTEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQor ICAgICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJl ZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisg ICAgICAgIHJldHVybjsKKworICAgIEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5 KTsKKyAgICBCU1RSIGZsYWdCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVm c1ByaXZhdGUtPm92ZXJyaWRlUHJlZmVyZW5jZShrZXlCU1RSLCBmbGFnQlNUUik7CisgICAgU3lz RnJlZVN0cmluZyhrZXlCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGZsYWdCU1RSKTsKK30KSW5k ZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVu Y2VzLTItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2Fu IGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVuLiBUaGlzIHRlc3QgdmVyaWZp ZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJp ZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisK K1BBU1MKSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIu aHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJl bmNlcy0yLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy0yLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTggQEAKKzxodG1s PgorPHNjcmlwdD4KKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdERlZmF1bHRGb250U2l6ZSIsICIy NCIpOworICAgIH0KKzwvc2NyaXB0PgorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVz IHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5j ZXMgb3ZlcnJpZGVuLiAgCisgICAgVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxs IGFjY2VwdCBzdHJpbmcgdmFsdWVzIGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQg c2l6ZS4gIAorICAgIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNjcmlw dD4KKyAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicCIpWzBd OworICAgICAgICBpZighd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyIHx8IHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKHApLmZvbnRTaXplID09ICIyNHB4IikKKyAgICAgICAgICAgIGRvY3VtZW50 LndyaXRlKCJQQVNTIik7CisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBM YXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt cHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1Ro aXMgaXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4g aGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZGVuLiBUaGlzIHRlc3Qgc3BlY2lm aWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNo b3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuCisKK1BBU1MK SW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRt bAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVu Y2VzLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPiAKKzxib2R5PiAK KzxzY3JpcHQ+IAorICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAg ICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCkKKyAgICAgICAgbGF5b3V0VGVzdENv bnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKCJXZWJLaXRKYXZhU2NyaXB0RW5hYmxlZCIsIGZh bHNlKTsKKyAgICB9CisgICAgCisgICAgZnVuY3Rpb24gbG9hZHN0YXR1cygpIHsKKyAgICAgICAg aWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iRkFJTCI7CisgICAgfQorPC9zY3JpcHQ+ IAorPGJvZHkgb25sb2FkPSJsb2Fkc3RhdHVzKCkiPgorICAgIDxwPlRoaXMgaXMgYSB0ZXN0IHRo YXQgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVs dCBwcmVmZXJlbmNlcyBvdmVycmlkZGVuLiAgVGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3Mg dGhhdCBKYXZhc2NyaXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNT IiBiZWxvdyBpZiB2aWV3aW5nIHdpdGggYSBicm93c2VyLjwvcD4KKyAgICA8c3BhbiBpZD0ic3Rh dHVzIj5QQVNTPC9zcGFuPgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lv biAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhh dCB0aGUgbGF5b3V0VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJl bmNlcyBhZnRlciBldmVyeSBsYXlvdXQgdGVzdC4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93 LgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQu aHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVz ZXQuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6 ei1yZXNldC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE0IEBACis8aHRtbD4gCis8Ym9k eT4gCis8c2NyaXB0PiAKKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwvc2NyaXB0PiAKKzxib2R5 PgorICAgIDxwPlRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxl ciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0 ZXN0LiAgWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c3BhbiBpZD0ic3Rh dHVzIj5GQUlMPC9zcGFuPgorICAgIDxzY3JpcHQ+CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJzdGF0dXMiKS5pbm5lckhUTUw9IlBBU1MiOyAgICAgICAgCisgICAgPC9zY3JpcHQ+ Cis8L2JvZHk+Cis8L2h0bWw+Cg== 26328 2008-12-30 17:01:45 -0800 2009-01-08 09:12:08 -0800 Revised patch to issue 20534 patch20534-redone.txt text/plain 21467 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDgtMTItMzAgIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0IFdlYlByZWZl cmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5nIHByZWZlcmVuY2VzIHRvIHRo ZWlyIGRlZmF1bHRzLgorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJp dmF0ZS5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW06CisgICAgICAgICgt W1dlYlByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0c10pOiBuZXcgbWV0aG9kCisgICAgICAgICgt W1dlYlByZWZlcmVuY2VzIG92ZXJyaWRlUHJlZmVyZW5jZTpmbGFnOl0pOiBuZXcgbWV0aG9kCisg ICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaDogbmV3IG1ldGhvZCBzaWdu YXR1cmVzCisKIDIwMDgtMTItMjYgIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2Vi Vmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJL aXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkK QEAgLTcyLDYgKzcyLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRv d25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRvd24iCiAjZGVm aW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZFByZWZlcmVuY2VLZXkg QCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQiCiAjZGVmaW5lIFdlYktp dFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNUZXh0T25seSIKKyNkZWZp bmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldlYktpdERlZmF1bHRQcmVm ZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRlIGJvdGggYmVjYXVzZSBj YWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBhbmQgYmVjYXVzZSB0aGUK IC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4KSW5kZXg6IFdlYktpdC9t YWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dl YlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0L21hYy9X ZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yOTEsMTAgKzI5MSw5 IEBAIHN0YXRpYyBXZWJDYWNoZU1vZGVsIGNhY2hlTW9kZWxGb3JNYWluQnUKICAgICByZXR1cm4g X3N0YW5kYXJkUHJlZmVyZW5jZXM7CiB9CiAKLS8vIGlmIHdlIGV2ZXIgaGF2ZSBtb3JlIHRoYW4g b25lIFdlYlByZWZlcmVuY2VzIG9iamVjdCwgdGhpcyB3b3VsZCBtb3ZlIHRvIGluaXQKLSsgKHZv aWQpaW5pdGlhbGl6ZQorKyAoTlNEaWN0aW9uYXJ5ICopZGVmYXVsdERpY3Rpb25hcnkKIHsKLSAg ICBOU0RpY3Rpb25hcnkgKmRpY3QgPSBbTlNEaWN0aW9uYXJ5IGRpY3Rpb25hcnlXaXRoT2JqZWN0 c0FuZEtleXM6CisgICAgcmV0dXJuIFtOU0RpY3Rpb25hcnkgZGljdGlvbmFyeVdpdGhPYmplY3Rz QW5kS2V5czoKICAgICAgICAgQCJUaW1lcyIsICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRT dGFuZGFyZEZvbnRQcmVmZXJlbmNlS2V5LAogICAgICAgICBAIkNvdXJpZXIiLCAgICAgICAgICAg ICAgICAgICAgIFdlYktpdEZpeGVkRm9udFByZWZlcmVuY2VLZXksCiAgICAgICAgIEAiVGltZXMi LCAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0U2VyaWZGb250UHJlZmVyZW5jZUtleSwKQEAg LTM1MSw2ICszNTAsMTIgQEAgc3RhdGljIFdlYkNhY2hlTW9kZWwgY2FjaGVNb2RlbEZvck1haW5C dQogI2VuZGlmCiAgICAgICAgIG5pbF07CiAKK30KKworLy8gaWYgd2UgZXZlciBoYXZlIG1vcmUg dGhhbiBvbmUgV2ViUHJlZmVyZW5jZXMgb2JqZWN0LCB0aGlzIHdvdWxkIG1vdmUgdG8gaW5pdAor KyAodm9pZClpbml0aWFsaXplCit7CisgICAgTlNEaWN0aW9uYXJ5ICpkaWN0ID0gW1dlYlByZWZl cmVuY2VzIGRlZmF1bHREaWN0aW9uYXJ5XTsKICAgICAvLyBUaGlzIHZhbHVlIHNob3VsZG4ndCBl dmVyIGNoYW5nZSwgd2hpY2ggaXMgYXNzdW1lZCBpbiB0aGUgaW5pdGlhbGl6YXRpb24gb2YgV2Vi S2l0UERGRGlzcGxheU1vZGVQcmVmZXJlbmNlS2V5IGFib3ZlCiAgICAgQVNTRVJUKGtQREZEaXNw bGF5U2luZ2xlUGFnZUNvbnRpbnVvdXMgPT0gMSk7CiAgICAgW1tOU1VzZXJEZWZhdWx0cyBzdGFu ZGFyZFVzZXJEZWZhdWx0c10gcmVnaXN0ZXJEZWZhdWx0czpkaWN0XTsKQEAgLTEwOTUsNiArMTEw MCwzMSBAQCBzdGF0aWMgTlNTdHJpbmcgKmNsYXNzSUJDcmVhdG9ySUQgPSBuaWw7CiB7CiAgICAg cmV0dXJuIFtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVh cmRvd25QcmVmZXJlbmNlS2V5XTsKIH0KKworLSAodm9pZClyZXNldFRvRGVmYXVsdHMKK3sKKyAg ICBpZiAoIVtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3Zl cnJpZGRlbl0pCisgICAgICAgIHJldHVybjsKKyAgICBOU0RpY3Rpb25hcnkgKmRpY3QgPSBbV2Vi UHJlZmVyZW5jZXMgZGVmYXVsdERpY3Rpb25hcnldOworCisgICAgZm9yIChpZCBrZXkgaW4gZGlj dCkKKyAgICB7CisgICAgICAgIE5TU3RyaW5nICpfa2V5ID0gS0VZKGtleSk7CisgICAgICAgIFtf cHJpdmF0ZS0+dmFsdWVzIHNldE9iamVjdDpbZGljdCBvYmplY3RGb3JLZXk6a2V5XSBmb3JLZXk6 X2tleV07CisgICAgfQorCisgICAgW3NlbGYgX3NldEJvb2xWYWx1ZTpmYWxzZSBmb3JLZXk6V2Vi S2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbl07CisgICAgW3NlbGYgX3Bvc3RQcmVmZXJl bmNlc0NoYW5nZXNOb3RpZmljYXRpb25dOworfQorCistICh2b2lkKW92ZXJyaWRlUHJlZmVyZW5j ZTooTlNTdHJpbmcgKilrZXkgZmxhZzooTlNTdHJpbmcgKilwcmVmZXJlbmNlRmxhZworeworICAg IFtzZWxmIF9zZXRTdHJpbmdWYWx1ZTpwcmVmZXJlbmNlRmxhZyBmb3JLZXk6a2V5XTsKKyAgICBb c2VsZiBfc2V0Qm9vbFZhbHVlOnRydWUgZm9yS2V5OldlYktpdERlZmF1bHRQcmVmZXJlbmNlc092 ZXJyaWRkZW5dOworfQorCisKKwogQGVuZAogCiBAaW1wbGVtZW50YXRpb24gV2ViUHJlZmVyZW5j ZXMgKFdlYkludGVybmFsKQpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2Vz UHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNl c1ByaXZhdGUuaAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJl ZmVyZW5jZXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEwMiw2ICsxMDIsMTUgQEAgZXh0 ZXJuIE5TU3RyaW5nICpXZWJQcmVmZXJlbmNlc1JlbW92ZWRObwogLSAoV2ViVGV4dERpcmVjdGlv blN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcil0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJl aGF2aW9yOwogLSAodm9pZClzZXRUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9y OihXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKWJlaGF2aW9yOwogCisv LyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVz dHMgcnVuCisvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpb3ZlcnJpZGVQcmVm ZXJlbmNlOihOU1N0cmluZyAqKWtleSBmbGFnOihOU1N0cmluZyAqKWZsYWc7CisKKy8vIFRoaXMg bWV0aG9kIGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3Ig dGVzdHMgcnVuCisvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCistKHZvaWQpcmVzZXRUb0Rl ZmF1bHRzOworCisKIC8vIElmIHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29t ZSBwYWdlcyB0aGF0IGRvIGluYXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdp bGwgYmUKIC8vIHBhc3NlZCBhIG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0 aGVtIHRvIHdvcmsgY29ycmVjdGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAv LyB0aGUgZnV0dXJlIHdoZW4gdGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpJbmRleDogV2Vi S2l0L3dpbi9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHJl dmlzaW9uIDM5NTE5KQorKysgV2ViS2l0L3dpbi9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAg LTEsMyArMSwxOCBAQAorMjAwOC0xMi0zMCAgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZGVkIHN1cHBvcnQgZm9yIG92ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4g KGJ1ZyAyMDUzNCkKKyAgICAgICAgVHdvIG5ldyBtZXRob2RzIHdlcmUgYWRkZWQ6IHJlc2V0VG9E ZWZhdWx0cyBhbmQgb3ZlcnJpZGVQcmVmZXJlbmNlLgorICAgICAgICBTZWUgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAgKiBJbnRlcmZhY2Vz L0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsOiBuZXcgbWV0aG9kIHNpZ25hdHVyZXMKKyAgICAg ICAgKiBXZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaDogYWRkZWQgbmV3IGtleSBmb3IgaW50ZXJu YWwgc3RhdGUKKyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5jcHA6IGFkZGVkIG5ldyBtZXRob2Rz CisgICAgICAgIChXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKTogbmV3IG1ldGhv ZAorICAgICAgICAoV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cyk6IG5ldyBtZXRob2QK KyAgICAgICAgKiBXZWJQcmVmZXJlbmNlcy5oOiBuZXcgbWV0aG9kIHNpZ25hdHVyZXMKKwogMjAw OC0xMi0yMCAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmll d2VkIGJ5IEFkYSBDaGFuLgpJbmRleDogV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZh dGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5o CShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRl LmgJKHdvcmtpbmcgY29weSkKQEAgLTYyLDYgKzYyLDcgQEAKICNkZWZpbmUgV2ViS2l0VXNlc1Bh Z2VDYWNoZVByZWZlcmVuY2VLZXkgIldlYktpdFVzZXNQYWdlQ2FjaGVQcmVmZXJlbmNlS2V5Igog I2RlZmluZSBXZWJLaXRDYWNoZU1vZGVsUHJlZmVyZW5jZUtleSAiV2ViS2l0Q2FjaGVNb2RlbFBy ZWZlcmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aFByZWZl cmVuY2VLZXkgIldlYktpdExvY2FsU3RvcmFnZURhdGFiYXNlUGF0aCIKKyNkZWZpbmUgV2ViS2l0 RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiAiV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3Zl cnJpZGRlbiIKIAogLy8gVGhlc2UgYXJlIHByaXZhdGUgYm90aCBiZWNhdXNlIGNhbGxlcnMgc2hv dWxkIGJlIHVzaW5nIHRoZSBjb3ZlciBtZXRob2RzIGFuZCBiZWNhdXNlIHRoZQogLy8gY292ZXIg bWV0aG9kcyB0aGVtc2VsdmVzIGFyZSBwcml2YXRlLgpJbmRleDogV2ViS2l0L3dpbi9XZWJQcmVm ZXJlbmNlcy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAJ KHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEyMjMsNiArMTIyMywzOSBAQCBIUkVTVUxUIFdlYlByZWZlcmVuY2VzOjp6 b29tc1RleHRPbmx5KEJPCiAgICAgcmV0dXJuIFNfT0s7CiB9CiAKK0hSRVNVTFQgU1RETUVUSE9E Q0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6Om92ZXJyaWRlUHJlZmVyZW5jZShCU1RSIGtleSwgQlNU UiB2YWx1ZSkKK3sKKyAgICBpZiAoIVN5c1N0cmluZ0xlbihrZXkpIHx8ICFTeXNTdHJpbmdMZW4o dmFsdWUpKQorICAgICAgICByZXR1cm4gRV9GQUlMOworICAgIFJldGFpblB0cjxDRlN0cmluZ1Jl Zj4ga2V5UmVmKEFkb3B0Q0YsIENGU3RyaW5nQ3JlYXRlV2l0aENoYXJhY3RlcnMoMCwgcmVpbnRl cnByZXRfY2FzdDxVbmlDaGFyKj4oa2V5KSwgU3lzU3RyaW5nTGVuKGtleSkpKTsKKyAgICBzZXRT dHJpbmdWYWx1ZShrZXlSZWYuZ2V0KCksIHZhbHVlKTsKKyAgICBzZXRCb29sVmFsdWUoQ0ZTVFIo V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiksIHRydWUpOworICAgIHJldHVybiBT X09LOworfQorCitIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIFdlYlByZWZlcmVuY2VzOjpyZXNl dFRvRGVmYXVsdHMoKQoreworICAgIGlmICghYm9vbFZhbHVlRm9yS2V5KENGU1RSKFdlYktpdERl ZmF1bHRQcmVmZXJlbmNlc092ZXJyaWRkZW4pKSkKKyAgICAgICAgcmV0dXJuIFNfT0s7CisKKyAg ICBpbnQgY291bnQgPSBDRkRpY3Rpb25hcnlHZXRDb3VudChkZWZhdWx0U2V0dGluZ3MpOworICAg IGlmIChjb3VudCA8PSAwKQorICAgICAgICByZXR1cm4gU19PSzsKKworICAgIE93bkFycmF5UHRy PENGVHlwZVJlZj4ga2V5cyhuZXcgQ0ZUeXBlUmVmW2NvdW50XSk7CisgICAgT3duQXJyYXlQdHI8 Q0ZUeXBlUmVmPiB2YWx1ZXMobmV3IENGVHlwZVJlZltjb3VudF0pOworICAgIENGRGljdGlvbmFy eUdldEtleXNBbmRWYWx1ZXMoZGVmYXVsdFNldHRpbmdzLCBrZXlzLmdldCgpLCB2YWx1ZXMuZ2V0 KCkpOworCisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBjb3VudDsgKytpKQorICAgICAgICBzZXRW YWx1ZUZvcktleShzdGF0aWNfY2FzdDxDRlN0cmluZ1JlZj4oa2V5c1tpXSksIHZhbHVlc1tpXSk7 CisKKyAgICBzZXRCb29sVmFsdWUoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJp ZGRlbiksIGZhbHNlKTsKKworICAgIHBvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb24o KTsKKworICAgIHJldHVybiBTX09LOworfQorCiB2b2lkIFdlYlByZWZlcmVuY2VzOjp3aWxsQWRk VG9XZWJWaWV3KCkKIHsKICAgICArK21fbnVtV2ViVmlld3M7CkluZGV4OiBXZWJLaXQvd2luL1dl YlByZWZlcmVuY2VzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5o CShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAkod29ya2lu ZyBjb3B5KQpAQCAtMzM4LDYgKzMzOCwxNiBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBIUkVTVUxU IFNURE1FVEhPRENBTExUWVBFIHpvb21zVGV4dE9ubHkoIAogICAgIC8qIFtyZXR2YWxdW291dF0g Ki8gQk9PTCAqem9vbXNUZXh0T25seSk7CiAKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBm b3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1w UmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBv dmVycmlkZVByZWZlcmVuY2UoCisgICAgICAgIC8qIFtpbl0gKi8gQlNUUiBrZXksCisgICAgICAg IC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBm b3IgcmVzZXR0aW5nIG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8v IHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9E Q0FMTFRZUEUgcmVzZXRUb0RlZmF1bHRzKCk7CisKICAgICAvLyBXZWJQcmVmZXJlbmNlcwogCiAg ICAgLy8gVGhpcyBtZXRob2QgYWNjZXNzZXMgYSBkaWZmZXJlbnQgcHJlZmVyZW5jZSBrZXkgdGhh biBkZXZlbG9wZXJFeHRyYXNFbmFibGVkLgpJbmRleDogV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lX ZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4vSW50ZXJm YWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJL aXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwJKHdvcmtpbmcgY29w eSkKQEAgLTY2LDQgKzY2LDEzIEBAIGludGVyZmFjZSBJV2ViUHJlZmVyZW5jZXNQcml2YXRlIDog SVVua24KIAogICAgIEhSRVNVTFQgc2V0TG9jYWxTdG9yYWdlRW5hYmxlZChbaW5dIEJPT0wgZW5h YmxlZCk7CiAgICAgSFJFU1VMVCBsb2NhbFN0b3JhZ2VFbmFibGVkKFtvdXQsIHJldHZhbF0gQk9P TCAqZW5hYmxlZCk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGlu ZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBv bmx5LgorICAgIEhSRVNVTFQgb3ZlcnJpZGVQcmVmZXJlbmNlKFtpbl0gQlNUUiBrZXksIFtpbl0g QlNUUiB2YWx1ZSk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3IgcmVzZXR0aW5n IG92ZXJyaWRkZW4gcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJl bmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIHJlc2V0VG9EZWZhdWx0cygpOworCiB9CkluZGV4 OiBXZWJLaXRUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvQ2hhbmdl TG9nCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdFRvb2xzL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDE5IEBACisyMDA4LTEyLTMwICBHbGVubiBXaWxzb24gIDxnd2lsc29u QGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQ2hhbmdlZCBMYXlvdXRUZXN0Q29udHJvbGxlciBhbmQgRHVtcFJlbmRlclRyZWUgdG8g YWxsb3cgZm9yIG1hbnVhbAorICAgICAgICBvdmVycmlkaW5nIG9mIGRlZmF1bHQgcHJlZmVyZW5j ZXMgYXQgdGVzdCB0aW1lLiAgQWxzbyBhZGRlZCBzdXBwb3J0IGZvcgorICAgICAgICByZXNldHRp bmcgdGhlIHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdC4KKyAgICAgICAgU2VlIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogRHVtcFJl bmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOiBBZGRlZCBjYWxsYmFjayBtZXRob2Qg Zm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oOiBBZGRlZCBzaWduYXR1cmUgZm9yIGNhbGxiYWNrCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcDogQWRkZWQgY2FsbHMgdG8g cmVzZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlmIG5lY2Vzc2FyeQorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHA6IEFkZGVkIEpT IG92ZXJyaWRlIGZ1bmN0aW9uCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5k ZXJUcmVlLm1tOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNoIHRl c3QgaWYgbmVjZXNzYXJ5CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RD b250cm9sbGVyTWFjLm1tOiBBZGRlZCBKUyBvdmVycmlkZSBmdW5jdGlvbgorCiAyMDA4LTEyLTI0 ICBNYXJrIFJvd2UgIDxtcm93ZUBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgVGlt b3RoeSBIYXRjaGVyLgpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVz dENvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTM0OCw2ICszNDgsMjIgQEAgc3RhdGljIEpTVmFsdWVSZWYgaXNDb21tYW5kRW5hYmxlZENh bGxiYQogICAgIHJldHVybiBKU1ZhbHVlTWFrZUJvb2xlYW4oY29udGV4dCwgY29udHJvbGxlci0+ aXNDb21tYW5kRW5hYmxlZChuYW1lLmdldCgpKSk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG92 ZXJyaWRlUHJlZmVyZW5jZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJl ZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQs IGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sK KyAgICBpZiAoYXJndW1lbnRDb3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVu ZGVmaW5lZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRv cHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24p KTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVm PiB2YWx1ZShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0s IGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisKKyAgICBMYXlvdXRUZXN0 Q29udHJvbGxlciogY29udHJvbGxlciA9IHJlaW50ZXJwcmV0X2Nhc3Q8TGF5b3V0VGVzdENvbnRy b2xsZXIqPihKU09iamVjdEdldFByaXZhdGUodGhpc09iamVjdCkpOworICAgIGNvbnRyb2xsZXIt Pm92ZXJyaWRlUHJlZmVyZW5jZShrZXkuZ2V0KCksIHZhbHVlLmdldCgpKTsKKworICAgIHJldHVy biBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsKK30KKwogc3RhdGljIEpTVmFsdWVSZWYg a2VlcFdlYkhpc3RvcnlDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYg ZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBj b25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCiB7CiAg ICAgLy8gSGFzIG1hYyBpbXBsZW1lbnRhdGlvbgpAQCAtODAyLDYgKzgxOCw3IEBAIEpTU3RhdGlj RnVuY3Rpb24qIExheW91dFRlc3RDb250cm9sbGVyOjoKICAgICAgICAgeyAiaXNDb21tYW5kRW5h YmxlZCIsIGlzQ29tbWFuZEVuYWJsZWRDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJrZWVw V2ViSGlzdG9yeSIsIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi bm90aWZ5RG9uZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFk T25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAorICAgICAgICB7ICJvdmVy cmlkZVByZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjaywga0pTUHJvcGVydHlB dHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAg ICAgICB7ICJwYXRoVG9Mb2NhbFJlc291cmNlIiwgcGF0aFRvTG9jYWxSZXNvdXJjZUNhbGxiYWNr LCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250 RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlQmFja05hdmlnYXRpb24iLCBxdWV1ZUJhY2tOYXZp Z2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicXVldWVGb3J3YXJkTmF2aWdhdGlv biIsIHF1ZXVlRm9yd2FyZE5hdmlnYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVS ZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LApJbmRleDogV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCShyZXZp c2lvbiAzOTUxOSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTczLDYgKzczLDcgQEAgcHVibGljOgogICAgIHZv aWQgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRoKTsKICAgICB2b2lk IHNldFBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIHBhdGgpOwog ICAgIHZvaWQgY2xlYXJQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXQoKTsKKyAgICB2b2lkIG92ZXJy aWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpOwogICAgIGlu dCB3aW5kb3dDb3VudCgpOwogICAgIAogICAgIGJvb2wgZWxlbWVudERvZXNBdXRvQ29tcGxldGVG b3JFbGVtZW50V2l0aElkKEpTU3RyaW5nUmVmIGlkKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0JKHJldmlzaW9uIDM5NTE5KQor KysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCSh3b3Jr aW5nIGNvcHkpCkBAIC05NzgsNiArOTc4LDggQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9D b25zaXN0ZW50U3RhdAogICAgIFt3ZWJWaWV3IF9jbGVhck1haW5GcmFtZU5hbWVdOwogCiAgICAg V2ViUHJlZmVyZW5jZXMgKnByZWZlcmVuY2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOworICAg IFtwcmVmZXJlbmNlcyByZXNldFRvRGVmYXVsdHNdOworICAgIFtwcmVmZXJlbmNlcyBzZXRFZGl0 YWJsZUxpbmtCZWhhdmlvcjpXZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleV07 CiAgICAgW3ByZWZlcmVuY2VzIHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOwogICAgIFtw cmVmZXJlbmNlcyBzZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOwogICAgIFtwcmVm ZXJlbmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107Cklu ZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJN YWMubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91 dFRlc3RDb250cm9sbGVyTWFjLm1tCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkod29ya2luZyBjb3B5 KQpAQCAtMjY3LDYgKzI2NywxNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRVc2Vy U3R5bGVTCiAgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBzZXRVc2Vy U3R5bGVTaGVldExvY2F0aW9uOnVybF07CiB9CiAKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6 Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpCit7 CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBrZXlDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlD RlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBrZXkpKTsKKyAgICBOU1N0cmluZyAqa2V5TlMg PSAoTlNTdHJpbmcgKilrZXlDRi5nZXQoKTsKKworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4g ZmxhZ0NGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQs IGZsYWcpKTsKKyAgICBOU1N0cmluZyAqZmxhZ05TID0gKE5TU3RyaW5nICopZmxhZ0NGLmdldCgp OworCisgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXSBvdmVycmlkZVBy ZWZlcmVuY2U6a2V5TlMgZmxhZzpmbGFnTlNdOworfQorCiB2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjpzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBqc1VS TCkKIHsKICAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHVybFN0cmluZyhBZG9wdENGLCBKU1N0 cmluZ0NvcHlDRlN0cmluZygwLCBqc1VSTCkpOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCShyZXZpc2lvbiAzOTUxOSkKKysr IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTY1Niw2ICs2NTYsNyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0Nv bnNpc3RlbnRTdGF0CiAKICAgICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHBy ZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOwogICAgICAgICBpZiAocHJlZnNQcml2YXRl KSB7CisgICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnJlc2V0VG9EZWZhdWx0cygpOwogICAgICAg ICAgICAgcHJlZnNQcml2YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsK ICAgICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0RGV2ZWxvcGVyRXh0cmFzRW5hYmxlZChGQUxT RSk7CiAgICAgICAgIH0KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlv dXRUZXN0Q29udHJvbGxlcldpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAkocmV2aXNpb24gMzk1MTkp CisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJX aW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvQXNzZXJ0aW9ucy5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3Jp cHRDb3JlLmg+CiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNs dWRlIDxKYXZhU2NyaXB0Q29yZS9KU1N0cmluZ1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQv V2ViS2l0Lmg+CiAjaW5jbHVkZSA8c3RyaW5nPgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0Nv cmVGb3VuZGF0aW9uLmg+CkBAIC02NTgsMyArNjU5LDI0IEBAIGJvb2wgTGF5b3V0VGVzdENvbnRy b2xsZXI6OnBhdXNlVHJhbnNpdGkKIHsKICAgICByZXR1cm4gZmFsc2U7IC8vIEZJWE1FOiBJbXBs ZW1lbnQgdGhpcyBvbiBXaW5kb3dzCiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om92 ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpCit7Cisg ICAgQ09NUHRyPElXZWJWaWV3PiB3ZWJWaWV3OworICAgIGlmIChGQUlMRUQoZnJhbWUtPndlYlZp ZXcoJndlYlZpZXcpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJl bmNlcz4gcHJlZmVyZW5jZXM7CisgICAgaWYgKEZBSUxFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygm cHJlZmVyZW5jZXMpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJl bmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOworICAgIGlmICgh cHJlZnNQcml2YXRlKQorICAgICAgICByZXR1cm47CisKKyAgICBCU1RSIGtleUJTVFIgPSBKU1N0 cmluZ0NvcHlCU1RSKGtleSk7CisgICAgQlNUUiBmbGFnQlNUUiA9IEpTU3RyaW5nQ29weUJTVFIo ZmxhZyk7CisgICAgcHJlZnNQcml2YXRlLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5QlNUUiwgZmxh Z0JTVFIpOworICAgIFN5c0ZyZWVTdHJpbmcoa2V5QlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhm bGFnQlNUUik7Cit9CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJl bmNlcy0yLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGxheW91dFRl c3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRlbi4g VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFjY2VwdCBzdHJpbmcgdmFsdWVz IGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6ZS4gWW91IHNob3VsZCBzZWUg IlBBU1MiIGJlbG93LgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy0yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMv c2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDE4IEBACis8aHRtbD4KKzxzY3JpcHQ+CisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKCJXZWJLaXREZWZh dWx0Rm9udFNpemUiLCAiMjQiKTsKKyAgICB9Cis8L3NjcmlwdD4KKzxib2R5PgorICAgIDxwPlRo aXMgdGVzdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBk ZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRlbi4gIAorICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0 aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0 aGUgZGVmYXVsdCBmb250IHNpemUuICAKKyAgICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cu PC9wPgorICAgIDxzY3JpcHQ+CisgICAgICAgIHZhciBwID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNC eVRhZ05hbWUoInAiKVswXTsKKyAgICAgICAgaWYoIXdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl ciB8fCB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShwKS5mb250U2l6ZSA9PSAiMjRweCIpCisgICAg ICAgICAgICBkb2N1bWVudC53cml0ZSgiUEFTUyIpOworICAgIDwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMt ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRl LXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSwzIEBACitUaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVz dENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4g VGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNhbiBiZSBkaXNh YmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5nIHdpdGggYSBi cm93c2VyLgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRl LXByZWZlcmVuY2VzLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9v dmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBACis8 aHRtbD4gCis8Ym9keT4gCis8c2NyaXB0PiAKKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpCisgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNj cmlwdEVuYWJsZWQiLCBmYWxzZSk7CisgICAgfQorICAgIAorICAgIGZ1bmN0aW9uIGxvYWRzdGF0 dXMoKSB7CisgICAgICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAg ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMiKS5pbm5lckhUTUw9IkZBSUwiOwor ICAgIH0KKzwvc2NyaXB0PiAKKzxib2R5IG9ubG9hZD0ibG9hZHN0YXR1cygpIj4KKyAgICA8cD5U aGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2Fu IGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gIFRoaXMgdGVzdCBzcGVj aWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ug c2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci48L3A+Cisg ICAgPHNwYW4gaWQ9InN0YXR1cyI+UEFTUzwvc3Bhbj4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6 IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6 ei1yZXNldC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0 ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRz IGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuIFlvdSBzaG91bGQg c2VlICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3Zl cnJpZGUtenp6LXJlc2V0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNCBA QAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8 L3NjcmlwdD4gCis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5 b3V0VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRl ciBldmVyeSBsYXlvdXQgdGVzdC4gIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+Cisg ICAgPHNwYW4gaWQ9InN0YXR1cyI+RkFJTDwvc3Bhbj4KKyAgICA8c2NyaXB0PgorICAgICAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJQQVNTIjsgICAgICAg IAorICAgIDwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 26524 2009-01-08 09:12:08 -0800 2009-01-20 15:23:23 -0800 Improved patch to issue 20534 patch20534-redone2.txt text/plain 21553 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDgtMTItMzAgIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0IFdlYlByZWZl cmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBmb3IgcmVzZXR0aW5nIHByZWZlcmVuY2VzIHRvIHRo ZWlyIGRlZmF1bHRzLgorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VLZXlzUHJp dmF0ZS5oOgorICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW06CisgICAgICAgICgt W1dlYlByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0c10pOiBuZXcgbWV0aG9kCisgICAgICAgICgt W1dlYlByZWZlcmVuY2VzIG92ZXJyaWRlUHJlZmVyZW5jZTpmbGFnOl0pOiBuZXcgbWV0aG9kCisg ICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaDogbmV3IG1ldGhvZCBzaWdu YXR1cmVzCisKIDIwMDgtMTItMjYgIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFwcGxlLmNvbT4KIAog ICAgICAgICBSZXZpZXdlZCBieSBTYW0gV2VpbmlnLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvV2Vi Vmlldy9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJL aXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHdvcmtpbmcgY29weSkK QEAgLTcyLDYgKzcyLDcgQEAKICNkZWZpbmUgV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRv d25QcmVmZXJlbmNlS2V5IEAiV2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVhcmRvd24iCiAjZGVm aW5lIFdlYktpdE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZFByZWZlcmVuY2VLZXkg QCJXZWJLaXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQiCiAjZGVmaW5lIFdlYktp dFpvb21zVGV4dE9ubHlQcmVmZXJlbmNlS2V5IEAiV2ViS2l0Wm9vbXNUZXh0T25seSIKKyNkZWZp bmUgV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbiBAIldlYktpdERlZmF1bHRQcmVm ZXJlbmNlc092ZXJyaWRkZW4iCiAKIC8vIFRoZXNlIGFyZSBwcml2YXRlIGJvdGggYmVjYXVzZSBj YWxsZXJzIHNob3VsZCBiZSB1c2luZyB0aGUgY292ZXIgbWV0aG9kcyBhbmQgYmVjYXVzZSB0aGUK IC8vIGNvdmVyIG1ldGhvZHMgdGhlbXNlbHZlcyBhcmUgcHJpdmF0ZS4KSW5kZXg6IFdlYktpdC9t YWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dl YlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0L21hYy9X ZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yOTEsMTAgKzI5MSw5 IEBAIHN0YXRpYyBXZWJDYWNoZU1vZGVsIGNhY2hlTW9kZWxGb3JNYWluQnUKICAgICByZXR1cm4g X3N0YW5kYXJkUHJlZmVyZW5jZXM7CiB9CiAKLS8vIGlmIHdlIGV2ZXIgaGF2ZSBtb3JlIHRoYW4g b25lIFdlYlByZWZlcmVuY2VzIG9iamVjdCwgdGhpcyB3b3VsZCBtb3ZlIHRvIGluaXQKLSsgKHZv aWQpaW5pdGlhbGl6ZQorKyAoTlNEaWN0aW9uYXJ5ICopZGVmYXVsdERpY3Rpb25hcnkKIHsKLSAg ICBOU0RpY3Rpb25hcnkgKmRpY3QgPSBbTlNEaWN0aW9uYXJ5IGRpY3Rpb25hcnlXaXRoT2JqZWN0 c0FuZEtleXM6CisgICAgcmV0dXJuIFtOU0RpY3Rpb25hcnkgZGljdGlvbmFyeVdpdGhPYmplY3Rz QW5kS2V5czoKICAgICAgICAgQCJUaW1lcyIsICAgICAgICAgICAgICAgICAgICAgICBXZWJLaXRT dGFuZGFyZEZvbnRQcmVmZXJlbmNlS2V5LAogICAgICAgICBAIkNvdXJpZXIiLCAgICAgICAgICAg ICAgICAgICAgIFdlYktpdEZpeGVkRm9udFByZWZlcmVuY2VLZXksCiAgICAgICAgIEAiVGltZXMi LCAgICAgICAgICAgICAgICAgICAgICAgV2ViS2l0U2VyaWZGb250UHJlZmVyZW5jZUtleSwKQEAg LTM1MSw2ICszNTAsMTIgQEAgc3RhdGljIFdlYkNhY2hlTW9kZWwgY2FjaGVNb2RlbEZvck1haW5C dQogI2VuZGlmCiAgICAgICAgIG5pbF07CiAKK30KKworLy8gaWYgd2UgZXZlciBoYXZlIG1vcmUg dGhhbiBvbmUgV2ViUHJlZmVyZW5jZXMgb2JqZWN0LCB0aGlzIHdvdWxkIG1vdmUgdG8gaW5pdAor KyAodm9pZClpbml0aWFsaXplCit7CisgICAgTlNEaWN0aW9uYXJ5ICpkaWN0ID0gW1dlYlByZWZl cmVuY2VzIGRlZmF1bHREaWN0aW9uYXJ5XTsKICAgICAvLyBUaGlzIHZhbHVlIHNob3VsZG4ndCBl dmVyIGNoYW5nZSwgd2hpY2ggaXMgYXNzdW1lZCBpbiB0aGUgaW5pdGlhbGl6YXRpb24gb2YgV2Vi S2l0UERGRGlzcGxheU1vZGVQcmVmZXJlbmNlS2V5IGFib3ZlCiAgICAgQVNTRVJUKGtQREZEaXNw bGF5U2luZ2xlUGFnZUNvbnRpbnVvdXMgPT0gMSk7CiAgICAgW1tOU1VzZXJEZWZhdWx0cyBzdGFu ZGFyZFVzZXJEZWZhdWx0c10gcmVnaXN0ZXJEZWZhdWx0czpkaWN0XTsKQEAgLTEwOTUsNiArMTEw MCwzMyBAQCBzdGF0aWMgTlNTdHJpbmcgKmNsYXNzSUJDcmVhdG9ySUQgPSBuaWw7CiB7CiAgICAg cmV0dXJuIFtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0RW5hYmxlRnVsbERvY3VtZW50VGVh cmRvd25QcmVmZXJlbmNlS2V5XTsKIH0KKworLSAodm9pZClyZXNldFRvRGVmYXVsdHMKK3sKKyAg ICBpZiAoIVtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3Zl cnJpZGRlbl0pCisgICAgICAgIHJldHVybjsKKyAgICBOU0RpY3Rpb25hcnkgKmRpY3QgPSBbV2Vi UHJlZmVyZW5jZXMgZGVmYXVsdERpY3Rpb25hcnldOworICAgIE5TRW51bWVyYXRvciAqZW51bWVy YXRvciA9IFtkaWN0IGtleUVudW1lcmF0b3JdOworICAgIGlkIGtleTsKKworICAgIHdoaWxlICgo a2V5ID0gW2VudW1lcmF0b3IgbmV4dE9iamVjdF0pKQorICAgIHsKKyAgICAgICAgTlNTdHJpbmcg Kl9rZXkgPSBLRVkoa2V5KTsKKyAgICAgICAgW19wcml2YXRlLT52YWx1ZXMgc2V0T2JqZWN0Oltk aWN0IG9iamVjdEZvcktleTprZXldIGZvcktleTpfa2V5XTsKKyAgICB9CisKKyAgICBbc2VsZiBf c2V0Qm9vbFZhbHVlOmZhbHNlIGZvcktleTpXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlk ZGVuXTsKKyAgICBbc2VsZiBfcG9zdFByZWZlcmVuY2VzQ2hhbmdlc05vdGlmaWNhdGlvbl07Cit9 CisKKy0gKHZvaWQpb3ZlcnJpZGVQcmVmZXJlbmNlOihOU1N0cmluZyAqKWtleSBmbGFnOihOU1N0 cmluZyAqKXByZWZlcmVuY2VGbGFnCit7CisgICAgW3NlbGYgX3NldFN0cmluZ1ZhbHVlOnByZWZl cmVuY2VGbGFnIGZvcktleTprZXldOworICAgIFtzZWxmIF9zZXRCb29sVmFsdWU6dHJ1ZSBmb3JL ZXk6V2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbl07Cit9CisKKworCiBAZW5kCiAK IEBpbXBsZW1lbnRhdGlvbiBXZWJQcmVmZXJlbmNlcyAoV2ViSW50ZXJuYWwpCkluZGV4OiBXZWJL aXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCShyZXZpc2lvbiAzOTUxOSkK KysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAkod29ya2luZyBj b3B5KQpAQCAtMTAyLDYgKzEwMiwxNSBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZlcmVuY2Vz UmVtb3ZlZE5vCiAtIChXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKXRl eHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3I7CiAtICh2b2lkKXNldFRleHREaXJl Y3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3I6KFdlYlRleHREaXJlY3Rpb25TdWJtZW51SW5j bHVzaW9uQmVoYXZpb3IpYmVoYXZpb3I7CiAKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZvciBv dmVycmlkaW5nIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKy8vIHdpdGggRHVtcFJlbmRlclRy ZWUgb25seS4KKy0odm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5nICopa2V5IGZsYWc6 KE5TU3RyaW5nICopZmxhZzsKKworLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIHJlc2V0dGlu ZyBvdmVycmlkZGVuIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKy8vIHdpdGggRHVtcFJlbmRl clRyZWUgb25seS4KKy0odm9pZClyZXNldFRvRGVmYXVsdHM7CisKKwogLy8gSWYgc2l0ZS1zcGVj aWZpYyBzcG9vZmluZyBpcyBlbmFibGVkLCBzb21lIHBhZ2VzIHRoYXQgZG8gaW5hcHByb3ByaWF0 ZSB1c2VyLWFnZW50IHN0cmluZyBjaGVja3Mgd2lsbCBiZQogLy8gcGFzc2VkIGEgbm9uc3RhbmRh cmQgdXNlci1hZ2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0gdG8gd29yayBjb3JyZWN0bHkuIFRoaXMg bWV0aG9kIG1pZ2h0IGJlIHJlbW92ZWQgaW4KIC8vIHRoZSBmdXR1cmUgd2hlbiB0aGVyZSdzIG5v IG1vcmUgbmVlZCBmb3IgaXQuCkluZGV4OiBXZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBXZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJLaXQvd2lu L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDA4LTEyLTMwICBH bGVubiBXaWxzb24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgc3VwcG9ydCBmb3Igb3ZlcnJpZGluZyBk ZWZhdWx0IHByZWZlcmVuY2VzIHBlci10ZXN0LiAoYnVnIDIwNTM0KQorICAgICAgICBUd28gbmV3 IG1ldGhvZHMgd2VyZSBhZGRlZDogcmVzZXRUb0RlZmF1bHRzIGFuZCBvdmVycmlkZVByZWZlcmVu Y2UuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjA1MzQKKworICAgICAgICAqIEludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGw6 IG5ldyBtZXRob2Qgc2lnbmF0dXJlcworICAgICAgICAqIFdlYlByZWZlcmVuY2VLZXlzUHJpdmF0 ZS5oOiBhZGRlZCBuZXcga2V5IGZvciBpbnRlcm5hbCBzdGF0ZQorICAgICAgICAqIFdlYlByZWZl cmVuY2VzLmNwcDogYWRkZWQgbmV3IG1ldGhvZHMKKyAgICAgICAgKFdlYlByZWZlcmVuY2VzOjpv dmVycmlkZVByZWZlcmVuY2UpOiBuZXcgbWV0aG9kCisgICAgICAgIChXZWJQcmVmZXJlbmNlczo6 cmVzZXRUb0RlZmF1bHRzKTogbmV3IG1ldGhvZAorICAgICAgICAqIFdlYlByZWZlcmVuY2VzLmg6 IG5ldyBtZXRob2Qgc2lnbmF0dXJlcworCiAyMDA4LTEyLTIwICBEYW4gQmVybnN0ZWluICA8bWl0 ekBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhIENoYW4uCkluZGV4OiBXZWJL aXQvd2luL1dlYlByZWZlcmVuY2VLZXlzUHJpdmF0ZS5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93 aW4vV2ViUHJlZmVyZW5jZUtleXNQcml2YXRlLmgJKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0 L3dpbi9XZWJQcmVmZXJlbmNlS2V5c1ByaXZhdGUuaAkod29ya2luZyBjb3B5KQpAQCAtNjIsNiAr NjIsNyBAQAogI2RlZmluZSBXZWJLaXRVc2VzUGFnZUNhY2hlUHJlZmVyZW5jZUtleSAiV2ViS2l0 VXNlc1BhZ2VDYWNoZVByZWZlcmVuY2VLZXkiCiAjZGVmaW5lIFdlYktpdENhY2hlTW9kZWxQcmVm ZXJlbmNlS2V5ICJXZWJLaXRDYWNoZU1vZGVsUHJlZmVyZW5jZUtleSIKICNkZWZpbmUgV2ViS2l0 TG9jYWxTdG9yYWdlRGF0YWJhc2VQYXRoUHJlZmVyZW5jZUtleSAiV2ViS2l0TG9jYWxTdG9yYWdl RGF0YWJhc2VQYXRoIgorI2RlZmluZSBXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVu ICJXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuIgogCiAvLyBUaGVzZSBhcmUgcHJp dmF0ZSBib3RoIGJlY2F1c2UgY2FsbGVycyBzaG91bGQgYmUgdXNpbmcgdGhlIGNvdmVyIG1ldGhv ZHMgYW5kIGJlY2F1c2UgdGhlCiAvLyBjb3ZlciBtZXRob2RzIHRoZW1zZWx2ZXMgYXJlIHByaXZh dGUuCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTIyMyw2ICsxMjIzLDM5 IEBAIEhSRVNVTFQgV2ViUHJlZmVyZW5jZXM6Onpvb21zVGV4dE9ubHkoQk8KICAgICByZXR1cm4g U19PSzsKIH0KIAorSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3Zl cnJpZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3Ry aW5nTGVuKGtleSkgfHwgIVN5c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZB SUw7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdD cmVhdGVXaXRoQ2hhcmFjdGVycygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBT eXNTdHJpbmdMZW4oa2V5KSkpOworICAgIHNldFN0cmluZ1ZhbHVlKGtleVJlZi5nZXQoKSwgdmFs dWUpOworICAgIHNldEJvb2xWYWx1ZShDRlNUUihXZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVy cmlkZGVuKSwgdHJ1ZSk7CisgICAgcmV0dXJuIFNfT0s7Cit9CisKK0hSRVNVTFQgU1RETUVUSE9E Q0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6OnJlc2V0VG9EZWZhdWx0cygpCit7CisgICAgaWYgKCFi b29sVmFsdWVGb3JLZXkoQ0ZTVFIoV2ViS2l0RGVmYXVsdFByZWZlcmVuY2VzT3ZlcnJpZGRlbikp KQorICAgICAgICByZXR1cm4gU19PSzsKKworICAgIGludCBjb3VudCA9IENGRGljdGlvbmFyeUdl dENvdW50KGRlZmF1bHRTZXR0aW5ncyk7CisgICAgaWYgKGNvdW50IDw9IDApCisgICAgICAgIHJl dHVybiBTX09LOworCisgICAgT3duQXJyYXlQdHI8Q0ZUeXBlUmVmPiBrZXlzKG5ldyBDRlR5cGVS ZWZbY291bnRdKTsKKyAgICBPd25BcnJheVB0cjxDRlR5cGVSZWY+IHZhbHVlcyhuZXcgQ0ZUeXBl UmVmW2NvdW50XSk7CisgICAgQ0ZEaWN0aW9uYXJ5R2V0S2V5c0FuZFZhbHVlcyhkZWZhdWx0U2V0 dGluZ3MsIGtleXMuZ2V0KCksIHZhbHVlcy5nZXQoKSk7CisKKyAgICBmb3IgKGludCBpID0gMDsg aSA8IGNvdW50OyArK2kpCisgICAgICAgIHNldFZhbHVlRm9yS2V5KHN0YXRpY19jYXN0PENGU3Ry aW5nUmVmPihrZXlzW2ldKSwgdmFsdWVzW2ldKTsKKworICAgIHNldEJvb2xWYWx1ZShDRlNUUihX ZWJLaXREZWZhdWx0UHJlZmVyZW5jZXNPdmVycmlkZGVuKSwgZmFsc2UpOworCisgICAgcG9zdFBy ZWZlcmVuY2VzQ2hhbmdlc05vdGlmaWNhdGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisK IHZvaWQgV2ViUHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1X ZWJWaWV3czsKSW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0 L3dpbi9XZWJQcmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zMzgsNiArMzM4LDE2IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgem9vbXNUZXh0 T25seSggCiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBCT09MICp6b29tc1RleHRPbmx5KTsKIAor ICAgIC8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZvciBvdmVycmlkaW5nIHByZWZlcmVuY2VzIGZv ciB0ZXN0cyBydW4KKyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgdmlydHVh bCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIG92ZXJyaWRlUHJlZmVyZW5jZSgKKyAgICAgICAg LyogW2luXSAqLyBCU1RSIGtleSwKKyAgICAgICAgLyogW2luXSAqLyBCU1RSIHZhbHVlKTsKKwor ICAgIC8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVm ZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5Lgor ICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSByZXNldFRvRGVmYXVsdHMoKTsK KwogICAgIC8vIFdlYlByZWZlcmVuY2VzCiAKICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3NlcyBh IGRpZmZlcmVudCBwcmVmZXJlbmNlIGtleSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQuCklu ZGV4OiBXZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUu aWRsCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVy ZW5jZXNQcml2YXRlLmlkbAkod29ya2luZyBjb3B5KQpAQCAtNjYsNCArNjYsMTMgQEAgaW50ZXJm YWNlIElXZWJQcmVmZXJlbmNlc1ByaXZhdGUgOiBJVW5rbgogCiAgICAgSFJFU1VMVCBzZXRMb2Nh bFN0b3JhZ2VFbmFibGVkKFtpbl0gQk9PTCBlbmFibGVkKTsKICAgICBIUkVTVUxUIGxvY2FsU3Rv cmFnZUVuYWJsZWQoW291dCwgcmV0dmFsXSBCT09MICplbmFibGVkKTsKKworICAgIC8vIFRoaXMg bWV0aG9kIGlzIG1lYW50IGZvciBvdmVycmlkaW5nIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4K KyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgSFJFU1VMVCBvdmVycmlkZVBy ZWZlcmVuY2UoW2luXSBCU1RSIGtleSwgW2luXSBCU1RSIHZhbHVlKTsKKworICAgIC8vIFRoaXMg bWV0aG9kIGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3Ig dGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQg cmVzZXRUb0RlZmF1bHRzKCk7CisKIH0KSW5kZXg6IFdlYktpdFRvb2xzL0NoYW5nZUxvZwo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXRUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDM5NTE5KQorKysgV2Vi S2l0VG9vbHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDgt MTItMzAgIEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBDaGFuZ2VkIExheW91dFRlc3RDb250 cm9sbGVyIGFuZCBEdW1wUmVuZGVyVHJlZSB0byBhbGxvdyBmb3IgbWFudWFsCisgICAgICAgIG92 ZXJyaWRpbmcgb2YgZGVmYXVsdCBwcmVmZXJlbmNlcyBhdCB0ZXN0IHRpbWUuICBBbHNvIGFkZGVk IHN1cHBvcnQgZm9yCisgICAgICAgIHJlc2V0dGluZyB0aGUgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFj aCB0ZXN0LgorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwNTM0CisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxl ci5jcHA6IEFkZGVkIGNhbGxiYWNrIG1ldGhvZCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcwor ICAgICAgICAqIER1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmg6IEFkZGVkIHNp Z25hdHVyZSBmb3IgY2FsbGJhY2sKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJl bmRlclRyZWUuY3BwOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVmZXJlbmNlcyBhZnRlciBlYWNo IHRlc3QgaWYgbmVjZXNzYXJ5CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRl c3RDb250cm9sbGVyV2luLmNwcDogQWRkZWQgSlMgb3ZlcnJpZGUgZnVuY3Rpb24KKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW06IEFkZGVkIGNhbGxzIHRvIHJl c2V0IHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdCBpZiBuZWNlc3NhcnkKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW06IEFkZGVkIEpTIG92 ZXJyaWRlIGZ1bmN0aW9uCisKIDIwMDgtMTItMjQgIE1hcmsgUm93ZSAgPG1yb3dlQGFwcGxlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBUaW1vdGh5IEhhdGNoZXIuCkluZGV4OiBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCShy ZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RD b250cm9sbGVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzQ4LDYgKzM0OCwyMiBAQCBzdGF0aWMg SlNWYWx1ZVJlZiBpc0NvbW1hbmRFbmFibGVkQ2FsbGJhCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtl Qm9vbGVhbihjb250ZXh0LCBjb250cm9sbGVyLT5pc0NvbW1hbmRFbmFibGVkKG5hbWUuZ2V0KCkp KTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2soSlND b250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlz T2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNb XSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQoreworICAgIGlmIChhcmd1bWVudENvdW50IDwgMikK KyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgSlNS ZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGtleShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250 ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7 CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IHZhbHVlKEFkb3B0LCBKU1ZhbHVlVG9TdHJp bmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sxXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEq ZXhjZXB0aW9uKTsKKworICAgIExheW91dFRlc3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gcmVp bnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0 aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxlci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleS5nZXQo KSwgdmFsdWUuZ2V0KCkpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRl eHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29u dGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09i amVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10s IEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9u CkBAIC04MDIsNiArODE4LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xs ZXI6OgogICAgICAgICB7ICJpc0NvbW1hbmRFbmFibGVkIiwgaXNDb21tYW5kRW5hYmxlZENhbGxi YWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVE b250RGVsZXRlIH0sCiAgICAgICAgIHsgImtlZXBXZWJIaXN0b3J5Iiwga2VlcFdlYkhpc3RvcnlD YWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmli dXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJub3RpZnlEb25lIiwgbm90aWZ5RG9uZUNhbGxi YWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVE b250RGVsZXRlIH0sCisgICAgICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJyaWRlUHJl ZmVyZW5jZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVy dHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInBhdGhUb0xvY2FsUmVzb3VyY2Ui LCBwYXRoVG9Mb2NhbFJlc291cmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicXVldWVC YWNrTmF2aWdhdGlvbiIsIHF1ZXVlQmFja05hdmlnYXRpb25DYWxsYmFjaywga0pTUHJvcGVydHlB dHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAg ICAgICB7ICJxdWV1ZUZvcndhcmROYXZpZ2F0aW9uIiwgcXVldWVGb3J3YXJkTmF2aWdhdGlvbkNh bGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1 dGVEb250RGVsZXRlIH0sCkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmgJKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0VG9vbHMv RHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAkod29ya2luZyBjb3B5KQpAQCAt NzMsNiArNzMsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9u KEpTU3RyaW5nUmVmIHBhdGgpOwogICAgIHZvaWQgc2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0 TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CiAgICAgdm9pZCBjbGVhclBlcnNpc3RlbnRVc2Vy U3R5bGVTaGVldCgpOworICAgIHZvaWQgb3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtl eSwgSlNTdHJpbmdSZWYgZmxhZyk7CiAgICAgaW50IHdpbmRvd0NvdW50KCk7CiAgICAgCiAgICAg Ym9vbCBlbGVtZW50RG9lc0F1dG9Db21wbGV0ZUZvckVsZW1lbnRXaXRoSWQoSlNTdHJpbmdSZWYg aWQpOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVl Lm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVu ZGVyVHJlZS5tbQkocmV2aXNpb24gMzk1MTkpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0JKHdvcmtpbmcgY29weSkKQEAgLTk3OCw2ICs5NzgsOCBA QCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAgICAgW3dlYlZpZXcg X2NsZWFyTWFpbkZyYW1lTmFtZV07CiAKICAgICBXZWJQcmVmZXJlbmNlcyAqcHJlZmVyZW5jZXMg PSBbd2ViVmlldyBwcmVmZXJlbmNlc107CisgICAgW3ByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0 c107CisgICAgW3ByZWZlcmVuY2VzIHNldEVkaXRhYmxlTGlua0JlaGF2aW9yOldlYktpdEVkaXRh YmxlTGlua09ubHlMaXZlV2l0aFNoaWZ0S2V5XTsKICAgICBbcHJlZmVyZW5jZXMgc2V0UHJpdmF0 ZUJyb3dzaW5nRW5hYmxlZDpOT107CiAgICAgW3ByZWZlcmVuY2VzIHNldEF1dGhvckFuZFVzZXJT dHlsZXNFbmFibGVkOllFU107CiAgICAgW3ByZWZlcmVuY2VzIHNldEphdmFTY3JpcHRDYW5PcGVu V2luZG93c0F1dG9tYXRpY2FsbHk6WUVTXTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHJldmlz aW9uIDM5NTE5KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RD b250cm9sbGVyTWFjLm1tCSh3b3JraW5nIGNvcHkpCkBAIC0yNjcsNiArMjY3LDE3IEBAIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFVzZXJTdHlsZVMKICAgICBbW1dlYlByZWZlcmVuY2Vz IHN0YW5kYXJkUHJlZmVyZW5jZXNdIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb246dXJsXTsKIH0K IAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5n UmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+ IGtleUNGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQs IGtleSkpOworICAgIE5TU3RyaW5nICprZXlOUyA9IChOU1N0cmluZyAqKWtleUNGLmdldCgpOwor CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBmbGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5 Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwgZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFn TlMgPSAoTlNTdHJpbmcgKilmbGFnQ0YuZ2V0KCk7CisKKyAgICBbW1dlYlByZWZlcmVuY2VzIHN0 YW5kYXJkUHJlZmVyZW5jZXNdIG92ZXJyaWRlUHJlZmVyZW5jZTprZXlOUyBmbGFnOmZsYWdOU107 Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBlcnNpc3RlbnRVc2VyU3R5bGVT aGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQogewogICAgIFJldGFpblB0cjxDRlN0cmlu Z1JlZj4gdXJsU3RyaW5nKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKDAsIGpzVVJMKSk7 CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVy VHJlZS5jcHAJKHJldmlzaW9uIDM5NTE5KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv d2luL0R1bXBSZW5kZXJUcmVlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjU2LDYgKzY1Niw3IEBA IHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXQKIAogICAgICAgICBDT01Q dHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNl cyk7CiAgICAgICAgIGlmIChwcmVmc1ByaXZhdGUpIHsKKyAgICAgICAgICAgIHByZWZzUHJpdmF0 ZS0+cmVzZXRUb0RlZmF1bHRzKCk7CiAgICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldEF1dGhv ckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOwogICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5z ZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkKEZBTFNFKTsKICAgICAgICAgfQpJbmRleDogV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRy b2xsZXJXaW4uY3BwCShyZXZpc2lvbiAzOTUxOSkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQx LDYgKzQxLDcgQEAKICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9Bc3NlcnRpb25zLmg+CiAjaW5j bHVkZSA8SmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUuaD4KICNpbmNsdWRlIDxKYXZhU2Ny aXB0Q29yZS9KU1JldGFpblB0ci5oPgorI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTU3RyaW5n UmVmQlNUUi5oPgogI2luY2x1ZGUgPFdlYktpdC9XZWJLaXQuaD4KICNpbmNsdWRlIDxzdHJpbmc+ CiAjaW5jbHVkZSA8Q29yZUZvdW5kYXRpb24vQ29yZUZvdW5kYXRpb24uaD4KQEAgLTY1OCwzICs2 NTksMjQgQEAgYm9vbCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6cGF1c2VUcmFuc2l0aQogewogICAg IHJldHVybiBmYWxzZTsgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzIG9uIFdpbmRvd3MKIH0KKwor dm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVm IGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+IHdlYlZpZXc7 CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAgICAgICByZXR1 cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKKyAgICBpZiAo RkFJTEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAgICAgICByZXR1 cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1 ZXJ5LCBwcmVmZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisgICAgICAgIHJldHVy bjsKKworICAgIEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5KTsKKyAgICBCU1RS IGZsYWdCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVmc1ByaXZhdGUtPm92 ZXJyaWRlUHJlZmVyZW5jZShrZXlCU1RSLCBmbGFnQlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhr ZXlCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGZsYWdCU1RSKTsKK30KSW5kZXg6IExheW91dFRl c3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0 ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJl ZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhp cyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRl ZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVuLiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUg QVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1 bHQgZm9udCBzaXplLiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6 IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWwJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNl cy0yLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPgorPHNjcmlwdD4K KyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5v dmVycmlkZVByZWZlcmVuY2UoIldlYktpdERlZmF1bHRGb250U2l6ZSIsICIyNCIpOworICAgIH0K Kzwvc2NyaXB0PgorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0 VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVu LiAgCisgICAgVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFjY2VwdCBzdHJp bmcgdmFsdWVzIGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6ZS4gIAorICAg IFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNjcmlwdD4KKyAgICAgICAg dmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicCIpWzBdOworICAgICAgICBp Zighd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyIHx8IHdpbmRvdy5nZXRDb21wdXRlZFN0eWxl KHApLmZvbnRTaXplID09ICIyNHB4IikKKyAgICAgICAgICAgIGRvY3VtZW50LndyaXRlKCJQQVNT Iik7CisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9z ZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0CShy ZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMt ZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1RoaXMgaXMgYSB0ZXN0 IHRoYXQgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVm YXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZGVuLiBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNr cyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBB U1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuCisKK1BBU1MKSW5kZXg6IExheW91 dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24g MCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMTggQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAor ICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5kdW1wQXNUZXh0KCkKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3Zl cnJpZGVQcmVmZXJlbmNlKCJXZWJLaXRKYXZhU2NyaXB0RW5hYmxlZCIsIGZhbHNlKTsKKyAgICB9 CisgICAgCisgICAgZnVuY3Rpb24gbG9hZHN0YXR1cygpIHsKKyAgICAgICAgaWYod2luZG93Lmxh eW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InN0YXR1cyIpLmlubmVySFRNTD0iRkFJTCI7CisgICAgfQorPC9zY3JpcHQ+IAorPGJvZHkgb25s b2FkPSJsb2Fkc3RhdHVzKCkiPgorICAgIDxwPlRoaXMgaXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMg dGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNl cyBvdmVycmlkZGVuLiAgVGhpcyB0ZXN0IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2Ny aXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5kIHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2 aWV3aW5nIHdpdGggYSBicm93c2VyLjwvcD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5QQVNTPC9z cGFuPgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1 cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5b3V0 VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRlciBl dmVyeSBsYXlvdXQgdGVzdC4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LgorCitQQVNTCklu ZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1s CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE0IEBACis8aHRtbD4gCis8Ym9keT4gCis8c2NyaXB0 PiAKKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwvc2NyaXB0PiAKKzxib2R5PgorICAgIDxwPlRo aXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0 IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiAgWW91IHNo b3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5GQUlMPC9z cGFuPgorICAgIDxzY3JpcHQ+CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0 dXMiKS5pbm5lckhUTUw9IlBBU1MiOyAgICAgICAgCisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8 L2h0bWw+Cg== 26874 2009-01-20 15:23:23 -0800 2009-02-03 15:57:28 -0800 Alternate patch to issue 20534 patch20534-test2.txt text/plain 21512 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiA0MDA3MikKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMjAgQEAKKzIwMDktMDEtMTYgIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZGVkIG5ldyBtZXRob2RzIGZvciBvdmVycmlkaW5nIGRlZmF1bHQgV2ViUHJl ZmVyZW5jZSB2YWx1ZXMKKyAgICAgICAgYW5kIGZvciByZXNldHRpbmcgcHJlZmVyZW5jZXMgdG8g dGhlaXIgZGVmYXVsdHMuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjA1MzQKKworICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQ cml2YXRlLmg6CisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbToKKyAgICAgICAg KC1bV2ViUHJlZmVyZW5jZXMgaW5pdFdpdGhJZGVudGlmaWVyOl0pOgorICAgICAgICAoLVtXZWJQ cmVmZXJlbmNlcyBpbml0V2l0aENvZGVyOl0pOgorICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBf dmFsdWVGb3JLZXk6XSk6CisgICAgICAgICgtW1dlYlByZWZlcmVuY2VzIHJlc2V0VG9EZWZhdWx0 c10pOiBuZXcgbWV0aG9kCisgICAgICAgICgtW1dlYlByZWZlcmVuY2VzIG92ZXJyaWRlUHJlZmVy ZW5jZTpmbGFnOl0pOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNl c1ByaXZhdGUuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDktMDEtMjAgIE5pa29sYXMg WmltbWVybWFubiAgPG5pa29sYXMuemltbWVybWFubkB0b3JjaG1vYmlsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgR2VvcmdlIFN0YWlrb3MuCkluZGV4OiBXZWJLaXQvbWFjL1dlYlZpZXcv V2ViUHJlZmVyZW5jZXMubW0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L21hYy9XZWJWaWV3L1dlYlBy ZWZlcmVuY2VzLm1tCShyZXZpc2lvbiAzOTQzNykKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQ cmVmZXJlbmNlcy5tbQkod29ya2luZyBjb3B5KQpAQCAtMTM4LDYgKzEzOCw3IEBAIHN0YXRpYyBX ZWJDYWNoZU1vZGVsIGNhY2hlTW9kZWxGb3JNYWluQnUKIHsKIEBwdWJsaWMKICAgICBOU011dGFi bGVEaWN0aW9uYXJ5ICp2YWx1ZXM7CisgICAgTlNNdXRhYmxlRGljdGlvbmFyeSAqb3ZlcnJpZGRl blZhbHVlczsKICAgICBOU1N0cmluZyAqaWRlbnRpZmllcjsKICAgICBOU1N0cmluZyAqSUJDcmVh dG9ySUQ7CiAgICAgQk9PTCBhdXRvc2F2ZXM7CkBAIC0xNTAsNiArMTUxLDcgQEAgc3RhdGljIFdl YkNhY2hlTW9kZWwgY2FjaGVNb2RlbEZvck1haW5CdQogLSAodm9pZClkZWFsbG9jCiB7CiAgICAg W3ZhbHVlcyByZWxlYXNlXTsKKyAgICBbb3ZlcnJpZGRlblZhbHVlcyByZWxlYXNlXTsKICAgICBb aWRlbnRpZmllciByZWxlYXNlXTsKICAgICBbSUJDcmVhdG9ySUQgcmVsZWFzZV07CiAgICAgW3N1 cGVyIGRlYWxsb2NdOwpAQCAtMjA3LDYgKzIwOSw3IEBAIHN0YXRpYyBXZWJDYWNoZU1vZGVsIGNh Y2hlTW9kZWxGb3JNYWluQnUKICAgICB9CiAKICAgICBfcHJpdmF0ZS0+dmFsdWVzID0gW1tOU011 dGFibGVEaWN0aW9uYXJ5IGFsbG9jXSBpbml0XTsKKyAgICBfcHJpdmF0ZS0+b3ZlcnJpZGRlblZh bHVlcyA9IFtbTlNNdXRhYmxlRGljdGlvbmFyeSBhbGxvY10gaW5pdF07CiAgICAgX3ByaXZhdGUt PmlkZW50aWZpZXIgPSBbYW5JZGVudGlmaWVyIGNvcHldOwogICAgIF9wcml2YXRlLT5hdXRvbWF0 aWNhbGx5RGV0ZWN0c0NhY2hlTW9kZWwgPSBZRVM7CiAKQEAgLTIyNiw3ICsyMjksOCBAQCBzdGF0 aWMgV2ViQ2FjaGVNb2RlbCBjYWNoZU1vZGVsRm9yTWFpbkJ1CiAgICAgX3ByaXZhdGUgPSBbW1dl YlByZWZlcmVuY2VzUHJpdmF0ZSBhbGxvY10gaW5pdF07CiAgICAgX3ByaXZhdGUtPklCQ3JlYXRv cklEID0gW1tXZWJQcmVmZXJlbmNlcyBfSUJDcmVhdG9ySURdIHJldGFpbl07CiAgICAgX3ByaXZh dGUtPmF1dG9tYXRpY2FsbHlEZXRlY3RzQ2FjaGVNb2RlbCA9IFlFUzsKLQorICAgIF9wcml2YXRl LT5vdmVycmlkZGVuVmFsdWVzID0gW1tOU011dGFibGVEaWN0aW9uYXJ5IGFsbG9jXSBpbml0XTsK KyAgICAKICAgICBAdHJ5IHsKICAgICAgICAgaWQgaWRlbnRpZmllciA9IG5pbDsKICAgICAgICAg aWQgdmFsdWVzID0gbmlsOwpAQCAtMzcwLDcgKzM3OSwxMCBAQCBzdGF0aWMgV2ViQ2FjaGVNb2Rl bCBjYWNoZU1vZGVsRm9yTWFpbkJ1CiAtIChpZClfdmFsdWVGb3JLZXk6KE5TU3RyaW5nICopa2V5 CiB7CiAgICAgTlNTdHJpbmcgKl9rZXkgPSBLRVkoa2V5KTsKLSAgICBpZCBvID0gW19wcml2YXRl LT52YWx1ZXMgb2JqZWN0Rm9yS2V5Ol9rZXldOworICAgIGlkIG8gPSBbX3ByaXZhdGUtPm92ZXJy aWRkZW5WYWx1ZXMgb2JqZWN0Rm9yS2V5Ol9rZXldOworICAgIGlmKG8pCisgICAgICAgIHJldHVy biBvOworICAgIG8gPSBbX3ByaXZhdGUtPnZhbHVlcyBvYmplY3RGb3JLZXk6X2tleV07CiAgICAg aWYgKG8pCiAgICAgICAgIHJldHVybiBvOwogICAgIG8gPSBbW05TVXNlckRlZmF1bHRzIHN0YW5k YXJkVXNlckRlZmF1bHRzXSBvYmplY3RGb3JLZXk6X2tleV07CkBAIC0xMDk1LDYgKzExMDcsMjEg QEAgc3RhdGljIE5TU3RyaW5nICpjbGFzc0lCQ3JlYXRvcklEID0gbmlsOwogewogICAgIHJldHVy biBbc2VsZiBfYm9vbFZhbHVlRm9yS2V5OldlYktpdEVuYWJsZUZ1bGxEb2N1bWVudFRlYXJkb3du UHJlZmVyZW5jZUtleV07CiB9CisKKy0gKHZvaWQpcmVzZXRUb0RlZmF1bHRzCit7CisgICAgW19w cml2YXRlLT5vdmVycmlkZGVuVmFsdWVzIHJlbW92ZUFsbE9iamVjdHNdOworICAgIFtzZWxmIF9w b3N0UHJlZmVyZW5jZXNDaGFuZ2VzTm90aWZpY2F0aW9uXTsKK30KKworLSAodm9pZClvdmVycmlk ZVByZWZlcmVuY2U6KE5TU3RyaW5nICopa2V5IGZsYWc6KE5TU3RyaW5nICopcHJlZmVyZW5jZUZs YWcKK3sKKyAgICBOU1N0cmluZyAqX2tleSA9IEtFWShrZXkpOworICAgIFtfcHJpdmF0ZS0+b3Zl cnJpZGRlblZhbHVlcyBzZXRPYmplY3Q6cHJlZmVyZW5jZUZsYWcgZm9yS2V5Ol9rZXldOworICAg IFtzZWxmIF9wb3N0UHJlZmVyZW5jZXNDaGFuZ2VzTm90aWZpY2F0aW9uXTsKK30KKworCiBAZW5k CiAKIEBpbXBsZW1lbnRhdGlvbiBXZWJQcmVmZXJlbmNlcyAoV2ViSW50ZXJuYWwpCkluZGV4OiBX ZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCShyZXZpc2lvbiAzOTQz NykKKysrIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAkod29ya2lu ZyBjb3B5KQpAQCAtMTAyLDYgKzEwMiwxNSBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZlcmVu Y2VzUmVtb3ZlZE5vCiAtIChXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9y KXRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3I7CiAtICh2b2lkKXNldFRleHRE aXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3I6KFdlYlRleHREaXJlY3Rpb25TdWJtZW51 SW5jbHVzaW9uQmVoYXZpb3IpYmVoYXZpb3I7CiAKKy8vIFRoaXMgbWV0aG9kIGlzIG1lYW50IGZv ciBvdmVycmlkaW5nIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKy8vIHdpdGggRHVtcFJlbmRl clRyZWUgb25seS4KKy0odm9pZClvdmVycmlkZVByZWZlcmVuY2U6KE5TU3RyaW5nICopa2V5IGZs YWc6KE5TU3RyaW5nICopZmxhZzsKKworLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIHJlc2V0 dGluZyBvdmVycmlkZGVuIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4KKy8vIHdpdGggRHVtcFJl bmRlclRyZWUgb25seS4KKy0odm9pZClyZXNldFRvRGVmYXVsdHM7CisKKwogLy8gSWYgc2l0ZS1z cGVjaWZpYyBzcG9vZmluZyBpcyBlbmFibGVkLCBzb21lIHBhZ2VzIHRoYXQgZG8gaW5hcHByb3By aWF0ZSB1c2VyLWFnZW50IHN0cmluZyBjaGVja3Mgd2lsbCBiZQogLy8gcGFzc2VkIGEgbm9uc3Rh bmRhcmQgdXNlci1hZ2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0gdG8gd29yayBjb3JyZWN0bHkuIFRo aXMgbWV0aG9kIG1pZ2h0IGJlIHJlbW92ZWQgaW4KIC8vIHRoZSBmdXR1cmUgd2hlbiB0aGVyZSdz IG5vIG1vcmUgbmVlZCBmb3IgaXQuCkluZGV4OiBXZWJLaXQvd2luL0NoYW5nZUxvZwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNpb24gNDAwNzIpCisrKyBXZWJLaXQv d2luL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDA5LTAxLTE2 ICBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBvdmVycmlk aW5nIGRlZmF1bHQgcHJlZmVyZW5jZXMgcGVyLXRlc3QuIChidWcgMjA1MzQpCisgICAgICAgIFR3 byBuZXcgbWV0aG9kcyB3ZXJlIGFkZGVkOiByZXNldFRvRGVmYXVsdHMgYW5kIG92ZXJyaWRlUHJl ZmVyZW5jZS4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMDUzNAorCisgICAgICAgICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRl LmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuY3Bw OiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJlZmVyZW5jZXM6OnZhbHVlRm9yS2V5 KToKKyAgICAgICAgKFdlYlByZWZlcmVuY2VzOjpvdmVycmlkZVByZWZlcmVuY2UpOiBuZXcgbWV0 aG9kCisgICAgICAgIChXZWJQcmVmZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKTogbmV3IG1ldGhv ZAorICAgICAgICAqIFdlYlByZWZlcmVuY2VzLmg6IG5ldyBtZXRob2Qgc2lnbmF0dXJlcworCiAy MDA5LTAxLTE5ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAgICAgICAgUnViYmVy LXN0YW1wZWQgYnkgR2F2aW4gQmFycmFjbG91Z2guCkluZGV4OiBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAko cmV2aXNpb24gMzk5NTYpCisrKyBXZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtMjQ2LDYgKzI0NiwxMiBAQCB2b2lkIFdlYlByZWZlcmVuY2VzOjppbml0aWFs aXplRGVmYXVsdFNlCiAKIFJldGFpblB0cjxDRlByb3BlcnR5TGlzdFJlZj4gV2ViUHJlZmVyZW5j ZXM6OnZhbHVlRm9yS2V5KENGU3RyaW5nUmVmIGtleSkKIHsKKyAgICBpZiAobV9vdmVycmlkZGVu UHJlZnMpIHsKKyAgICAgICAgUmV0YWluUHRyPENGUHJvcGVydHlMaXN0UmVmPiB2YWx1ZSA9IENG RGljdGlvbmFyeUdldFZhbHVlKG1fb3ZlcnJpZGRlblByZWZzLmdldCgpLCBrZXkpOworICAgICAg ICBpZiAodmFsdWUpCisgICAgICAgICAgICByZXR1cm4gdmFsdWU7CisgICAgfQorCiAgICAgUmV0 YWluUHRyPENGUHJvcGVydHlMaXN0UmVmPiB2YWx1ZSA9IENGRGljdGlvbmFyeUdldFZhbHVlKG1f cHJpdmF0ZVByZWZzLmdldCgpLCBrZXkpOwogICAgIGlmICh2YWx1ZSkKICAgICAgICAgcmV0dXJu IHZhbHVlOwpAQCAtMTI0OSw2ICsxMjU1LDI0IEBAIEhSRVNVTFQgV2ViUHJlZmVyZW5jZXM6Onpv b21zVGV4dE9ubHkoQk8KICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VMVCBTVERNRVRIT0RD QUxMVFlQRSBXZWJQcmVmZXJlbmNlczo6b3ZlcnJpZGVQcmVmZXJlbmNlKEJTVFIga2V5LCBCU1RS IHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5nTGVuKGtleSkgfHwgIVN5c1N0cmluZ0xlbih2 YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVm PiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hhcmFjdGVycygwLCByZWludGVy cHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBTeXNTdHJpbmdMZW4oa2V5KSkpOworICAgIENGRGlj dGlvbmFyeVNldFZhbHVlKG1fcHJpdmF0ZVByZWZzLmdldCgpLCBrZXlSZWYuZ2V0KCksIHZhbHVl KTsKKyAgICByZXR1cm4gU19PSzsKK30KKworSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBXZWJQ cmVmZXJlbmNlczo6cmVzZXRUb0RlZmF1bHRzKCkKK3sKKyAgICBDRkRpY3Rpb25hcnlSZW1vdmVB bGxWYWx1ZXMobV9vdmVycmlkZGVuUHJlZnMuZ2V0KCkpOworCisgICAgcG9zdFByZWZlcmVuY2Vz Q2hhbmdlc05vdGlmaWNhdGlvbigpOworCisgICAgcmV0dXJuIFNfT0s7Cit9CisKIHZvaWQgV2Vi UHJlZmVyZW5jZXM6OndpbGxBZGRUb1dlYlZpZXcoKQogewogICAgICsrbV9udW1XZWJWaWV3czsK SW5kZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmgJKHJldmlzaW9uIDM5OTU2KQorKysgV2ViS2l0L3dpbi9XZWJQ cmVmZXJlbmNlcy5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNDQsNiArMzQ0LDE2IEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2V0Rm9udFNtb290aGluZ0Nv bnRyYXN0KCAKICAgICAvKiBbaW5dICovIGZsb2F0IGNvbnRyYXN0KTsKIAorICAgIC8vIFRoaXMg bWV0aG9kIGlzIG1lYW50IGZvciBvdmVycmlkaW5nIHByZWZlcmVuY2VzIGZvciB0ZXN0cyBydW4K KyAgICAvLyB3aXRoIER1bXBSZW5kZXJUcmVlIG9ubHkuCisgICAgdmlydHVhbCBIUkVTVUxUIFNU RE1FVEhPRENBTExUWVBFIG92ZXJyaWRlUHJlZmVyZW5jZSgKKyAgICAgICAgLyogW2luXSAqLyBC U1RSIGtleSwKKyAgICAgICAgLyogW2luXSAqLyBCU1RSIHZhbHVlKTsKKworICAgIC8vIFRoaXMg bWV0aG9kIGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3Ig dGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwg SFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSByZXNldFRvRGVmYXVsdHMoKTsKKwogICAgIC8vIFdl YlByZWZlcmVuY2VzCiAKICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3NlcyBhIGRpZmZlcmVudCBw cmVmZXJlbmNlIGtleSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQuCkBAIC0zOTEsNiArNDAx LDcgQEAgcHJvdGVjdGVkOgogcHJvdGVjdGVkOgogICAgIFVMT05HIG1fcmVmQ291bnQ7CiAgICAg UmV0YWluUHRyPENGTXV0YWJsZURpY3Rpb25hcnlSZWY+IG1fcHJpdmF0ZVByZWZzOworICAgIFJl dGFpblB0cjxDRk11dGFibGVEaWN0aW9uYXJ5UmVmPiBtX292ZXJyaWRkZW5QcmVmczsKICAgICBX ZWJDb3JlOjpCU3RyaW5nIG1faWRlbnRpZmllcjsKICAgICBib29sIG1fYXV0b1NhdmVzOwogICAg IGJvb2wgbV9hdXRvbWF0aWNhbGx5RGV0ZWN0c0NhY2hlTW9kZWw7CkluZGV4OiBXZWJLaXQvd2lu L0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi S2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCShyZXZpc2lvbiAz OTk1NikKKysrIFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlk bAkod29ya2luZyBjb3B5KQpAQCAtNjksNCArNjksMTIgQEAgaW50ZXJmYWNlIElXZWJQcmVmZXJl bmNlc1ByaXZhdGUgOiBJVW5rbgogCiAgICAgSFJFU1VMVCBzZXRGb250U21vb3RoaW5nQ29udHJh c3QoW2luXSBmbG9hdCBjb250cmFzdCk7CiAgICAgSFJFU1VMVCBmb250U21vb3RoaW5nQ29udHJh c3QoW291dCwgcmV0dmFsXSBmbG9hdCogY29udHJhc3QpOworCisgICAgLy8gVGhpcyBtZXRob2Qg aXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8v IHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIG92ZXJyaWRlUHJlZmVyZW5j ZShbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOworIAorICAgIC8vIFRoaXMgbWV0aG9k IGlzIG1lYW50IGZvciByZXNldHRpbmcgb3ZlcnJpZGRlbiBwcmVmZXJlbmNlcyBmb3IgdGVzdHMg cnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQgcmVzZXRU b0RlZmF1bHRzKCk7CiB9CkluZGV4OiBXZWJLaXRUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA0MDA3MikKKysrIFdlYktpdFRvb2xz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE5IEBACisyMDA5LTAxLTE2ICBH bGVubiBXaWxzb24gIDxnd2lsc29uQGdvb2dsZS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQ2hhbmdlZCBMYXlvdXRUZXN0Q29udHJvbGxlciBh bmQgRHVtcFJlbmRlclRyZWUgdG8gYWxsb3cgZm9yIG1hbnVhbAorICAgICAgICBvdmVycmlkaW5n IG9mIGRlZmF1bHQgcHJlZmVyZW5jZXMgYXQgdGVzdCB0aW1lLiAgQWxzbyBhZGRlZCBzdXBwb3J0 IGZvcgorICAgICAgICByZXNldHRpbmcgdGhlIHByZWZlcmVuY2VzIGFmdGVyIGVhY2ggdGVzdC4K KyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUz NAorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOiBB ZGRlZCBjYWxsYmFjayBtZXRob2QgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMKKyAgICAgICAg KiBEdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOiBBZGRlZCBzaWduYXR1cmUg Zm9yIGNhbGxiYWNrCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVl LmNwcDogQWRkZWQgY2FsbHMgdG8gcmVzZXQgcHJlZmVyZW5jZXMgYWZ0ZXIgZWFjaCB0ZXN0IGlm IG5lY2Vzc2FyeQorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJv bGxlcldpbi5jcHA6IEFkZGVkIEpTIG92ZXJyaWRlIGZ1bmN0aW9uCisgICAgICAgICogRHVtcFJl bmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tOiBBZGRlZCBjYWxscyB0byByZXNldCBwcmVm ZXJlbmNlcyBhZnRlciBlYWNoIHRlc3QgaWYgbmVjZXNzYXJ5CisgICAgICAgICogRHVtcFJlbmRl clRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tOiBBZGRlZCBKUyBvdmVycmlkZSBm dW5jdGlvbgorCiAyMDA5LTAxLTE5ICBTYW0gV2VpbmlnICA8c2FtQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgKiBTY3JpcHRzL2RvLXdlYmNvcmUtcmVuYW1lOiBBZGQgSlNWYWx1ZVB0ciBhbmQgUHJv dGVjdGVkSlNWYWx1ZVB0ci4KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHJldmlzaW9uIDM5OTU2KQorKysgV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0zNDgsNiArMzQ4LDIyIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIGlzQ29tbWFuZEVuYWJs ZWRDYWxsYmEKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VCb29sZWFuKGNvbnRleHQsIGNvbnRyb2xs ZXItPmlzQ29tbWFuZEVuYWJsZWQobmFtZS5nZXQoKSkpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJl ZiBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmpl Y3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENv dW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24p Cit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5 KEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0 aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmlu Z1JlZj4gdmFsdWUoQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRz WzFdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0 VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91dFRlc3RD b250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9s bGVyLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5LmdldCgpLCB2YWx1ZS5nZXQoKSk7CisKKyAgICBy ZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVl UmVmIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0 UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3Vu dCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQog ewogICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRpb24KQEAgLTgyNCw2ICs4NDAsNyBAQCBKU1N0 YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6CiAgICAgICAgIHsgImlzQ29tbWFu ZEVuYWJsZWQiLCBpc0NvbW1hbmRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi a2VlcFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAg IHsgIm5vdGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAgICAgeyAi b3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtKU1Byb3Bl cnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwK ICAgICAgICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3VyY2VDYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRl RG9udERlbGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVldWVCYWNr TmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2FyZE5hdmln YXRpb24iLCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmli dXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5kZXg6IFdl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAko cmV2aXNpb24gMzk5NTYpCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3IEBAIHB1YmxpYzoKICAg ICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7CiAgICAg dm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBwYXRo KTsKICAgICB2b2lkIGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAgdm9pZCBv dmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKTsKICAg ICBpbnQgd2luZG93Q291bnQoKTsKICAgICAKICAgICBib29sIGVsZW1lbnREb2VzQXV0b0NvbXBs ZXRlRm9yRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBpZCk7CkluZGV4OiBXZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lvbiAzOTk1 NikKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQko d29ya2luZyBjb3B5KQpAQCAtOTg0LDYgKzk4NCw4IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmll d1RvQ29uc2lzdGVudFN0YXQKICAgICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1lXTsKIAog ICAgIFdlYlByZWZlcmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVuY2VzXTsK KyAgICBbcHJlZmVyZW5jZXMgcmVzZXRUb0RlZmF1bHRzXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0 RWRpdGFibGVMaW5rQmVoYXZpb3I6V2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRL ZXldOwogICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKICAg ICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsKICAgICBb cHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseTpZRVNd OwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9s bGVyTWFjLm1tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9M YXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQkocmV2aXNpb24gMzk5NTYpCisrKyBXZWJLaXRUb29s cy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtpbmcg Y29weSkKQEAgLTI4OCw2ICsyODgsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 VXNlclN0eWxlUwogICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0 VXNlclN0eWxlU2hlZXRMb2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFn KQoreworICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJpbmdD b3B5Q0ZTdHJpbmcoa0NGQWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcgKmtl eU5TID0gKE5TU3RyaW5nICopa2V5Q0YuZ2V0KCk7CisKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdS ZWY+IGZsYWdDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZh dWx0LCBmbGFnKSk7CisgICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAqKWZsYWdDRi5n ZXQoKTsKKworICAgIFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gb3ZlcnJp ZGVQcmVmZXJlbmNlOmtleU5TIGZsYWc6ZmxhZ05TXTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYg anNVUkwpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwg SlNTdHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsKSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAkocmV2aXNpb24gMzk5NTYp CisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC02NTYsNiArNjU2LDcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3 VG9Db25zaXN0ZW50U3RhdAogCiAgICAgICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2YXRl PiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKICAgICAgICAgaWYgKHByZWZzUHJp dmF0ZSkgeworICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5yZXNldFRvRGVmYXVsdHMoKTsKICAg ICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQoVFJV RSk7CiAgICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldERldmVsb3BlckV4dHJhc0VuYWJsZWQo RkFMU0UpOwogICAgICAgICB9CkluZGV4OiBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v TGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAJKHJldmlzaW9uIDM5 OTU2KQorKysgV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9s bGVyV2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDEsNiArNDEsNyBAQAogI2luY2x1ZGUgPEph dmFTY3JpcHRDb3JlL0Fzc2VydGlvbnMuaD4KICNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS5oPgogI2luY2x1ZGUgPEphdmFTY3JpcHRDb3JlL0pTUmV0YWluUHRyLmg+Cisj aW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvSlNTdHJpbmdSZWZCU1RSLmg+CiAjaW5jbHVkZSA8V2Vi S2l0L1dlYktpdC5oPgogI2luY2x1ZGUgPHN0cmluZz4KICNpbmNsdWRlIDxDb3JlRm91bmRhdGlv bi9Db3JlRm91bmRhdGlvbi5oPgpAQCAtNjc2LDMgKzY3NywyNCBAQCB1bnNpZ25lZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6bnVtYmVyT2ZBCiB7CiAgICAgcmV0dXJuIDA7IC8vIEZJWE1FOiBJbXBs ZW1lbnQgdGhpcyBvbiBXaW5kb3dzCiB9CisKK3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om92 ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpCit7Cisg ICAgQ09NUHRyPElXZWJWaWV3PiB3ZWJWaWV3OworICAgIGlmIChGQUlMRUQoZnJhbWUtPndlYlZp ZXcoJndlYlZpZXcpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJl bmNlcz4gcHJlZmVyZW5jZXM7CisgICAgaWYgKEZBSUxFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygm cHJlZmVyZW5jZXMpKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJl bmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOworICAgIGlmICgh cHJlZnNQcml2YXRlKQorICAgICAgICByZXR1cm47CisKKyAgICBCU1RSIGtleUJTVFIgPSBKU1N0 cmluZ0NvcHlCU1RSKGtleSk7CisgICAgQlNUUiBmbGFnQlNUUiA9IEpTU3RyaW5nQ29weUJTVFIo ZmxhZyk7CisgICAgcHJlZnNQcml2YXRlLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5QlNUUiwgZmxh Z0JTVFIpOworICAgIFN5c0ZyZWVTdHJpbmcoa2V5QlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhm bGFnQlNUUik7Cit9CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA0MDA3MikKKysrIExheW91dFRlc3RzL0No YW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDA5LTAxLTIwICBHbGVu biBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0cyB0byB2ZXJpZnkgdGhhdCBkZWZh dWx0IHByZWZlcmVuY2VzIGNhbiBiZSBvdmVycmlkZGVuIHBlci10ZXN0CisgICAgICAgIGFuZCB0 aGF0IG92ZXJyaWRkZW4gdmFsdWVzIGFyZSByZXNldCBiZXR3ZWVuIGVhY2ggdGVzdC4KKyAgICAg ICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAorCisg ICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbDogQWRk ZWQuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbDogQWRk ZWQuCisKIDIwMDktMDEtMjAgIE5pa29sYXMgWmltbWVybWFubiAgPG5pa29sYXMuemltbWVybWFu bkB0b3JjaG1vYmlsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgR2VvcmdlIFN0YWlrb3Mu CkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3Vy aXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVy IGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRlbi4gVGhpcyB0ZXN0IHZl cmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxsIGFjY2VwdCBzdHJpbmcgdmFsdWVzIGFuZCBhbHNvIG92 ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQgc2l6ZS4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93 LgorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNl cy0yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJl ZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3Zl cnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBACis8 aHRtbD4KKzxzY3JpcHQ+CisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKCJXZWJLaXREZWZhdWx0Rm9udFNpemUi LCAiMjQiKTsKKyAgICB9Cis8L3NjcmlwdD4KKzxib2R5PgorICAgIDxwPlRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZl cmVuY2VzIG92ZXJyaWRlbi4gIAorICAgIFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkg d2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBm b250IHNpemUuICAKKyAgICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuPC9wPgorICAgIDxz Y3JpcHQ+CisgICAgICAgIHZhciBwID0gZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInAi KVswXTsKKyAgICAgICAgaWYoIXdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlciB8fCB3aW5kb3cu Z2V0Q29tcHV0ZWRTdHlsZShwKS5mb250U2l6ZSA9PSAiMjRweCIpCisgICAgICAgICAgICBkb2N1 bWVudC53cml0ZSgiUEFTUyIpOworICAgIDwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRl eDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0 Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2Vz LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJy aWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzIEBA CitUaGlzIGlzIGEgdGVzdCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIg Y2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gVGhpcyB0ZXN0IHNw ZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5kIHlv dSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5nIHdpdGggYSBicm93c2VyLgorCitQ QVNTCkluZGV4OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1s Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2Vz Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE4IEBACis8aHRtbD4gCis8Ym9k eT4gCis8c2NyaXB0PiAKKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpCisgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJsZWQi LCBmYWxzZSk7CisgICAgfQorICAgIAorICAgIGZ1bmN0aW9uIGxvYWRzdGF0dXMoKSB7CisgICAg ICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMiKS5pbm5lckhUTUw9IkZBSUwiOworICAgIH0KKzwvc2Ny aXB0PiAKKzxib2R5IG9ubG9hZD0ibG9hZHN0YXR1cygpIj4KKyAgICA8cD5UaGlzIGlzIGEgdGVz dCB0aGF0IHZlcmlmaWVzIHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRl ZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGRlbi4gIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hl Y2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAi UEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci48L3A+CisgICAgPHNwYW4gaWQ9 InN0YXR1cyI+UEFTUzwvc3Bhbj4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3Rz L3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVz IHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJl ZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuIFlvdSBzaG91bGQgc2VlICJQQVNTIiBi ZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJl c2V0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6 LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS16enotcmVzZXQuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNCBAQAorPGh0bWw+IAor PGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cis8L3NjcmlwdD4gCis8 Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgbGF5b3V0VGVzdENvbnRy b2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBhZnRlciBldmVyeSBsYXlv dXQgdGVzdC4gIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNwYW4gaWQ9 InN0YXR1cyI+RkFJTDwvc3Bhbj4KKyAgICA8c2NyaXB0PgorICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJQQVNTIjsgICAgICAgIAorICAgIDwvc2Ny aXB0PgorPC9ib2R5PgorPC9odG1sPgo= 27296 2009-02-03 15:57:28 -0800 2009-07-10 12:44:41 -0700 Alternate patch to issue 20534 patch20534-inprogress2.txt text/plain 19701 gwilson SW5kZXg6IFdlYktpdC9tYWMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC9tYWMvQ2hh bmdlTG9nCShyZXZpc2lvbiA0MDA3MCkKKysrIFdlYktpdC9tYWMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDEtMjEgIEdsZW5uIFdpbHNvbiAgPGd3aWxz b25AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZGVkIG5ldyBtZXRob2RzIGZvciBvdmVycmlkaW5nIGRlZmF1bHQgV2ViUHJl ZmVyZW5jZSB2YWx1ZXMKKyAgICAgICAgYW5kIGZvciByZXNldHRpbmcgcHJlZmVyZW5jZXMgdG8g dGhlaXIgZGVmYXVsdHMuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjA1MzQKKworICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZUtleXNQ cml2YXRlLmg6CisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbToKKyAgICAgICAg KC1bV2ViUHJlZmVyZW5jZXMgaW5pdFdpdGhJZGVudGlmaWVyOl0pOgorICAgICAgICAoLVtXZWJQ cmVmZXJlbmNlcyBpbml0V2l0aENvZGVyOl0pOgorICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBf dmFsdWVGb3JLZXk6XSk6CisgICAgICAgICgtW1dlYlByZWZlcmVuY2VzIG92ZXJyaWRlUHJlZmVy ZW5jZTpmbGFnOl0pOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViVmlldy9XZWJQcmVmZXJlbmNl c1ByaXZhdGUuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDktMDEtMTkgIEFuZGVycyBD YXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTYW0g V2VpbmlnLgpJbmRleDogV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQkocmV2aXNpb24g NDAwNzApCisrKyBXZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0JKHdvcmtpbmcg Y29weSkKQEAgLTEwOTUsNiArMTEwMCwxMyBAQCBzdGF0aWMgTlNTdHJpbmcgKmNsYXNzSUJDcmVh dG9ySUQgPSBuaWw7CiB7CiAgICAgcmV0dXJuIFtzZWxmIF9ib29sVmFsdWVGb3JLZXk6V2ViS2l0 RW5hYmxlRnVsbERvY3VtZW50VGVhcmRvd25QcmVmZXJlbmNlS2V5XTsKIH0KKworLSAodm9pZClz ZXRQcmVmZXJlbmNlOihOU1N0cmluZyAqKWtleSBzdHJpbmdWYWx1ZTooTlNTdHJpbmcgKil2YWx1 ZQoreworICAgIE5TU3RyaW5nICpfa2V5ID0gS0VZKGtleSk7CisgICAgW3NlbGYgX3NldFN0cmlu Z1ZhbHVlOnZhbHVlIGZvcktleTpfa2V5XTsJCit9CisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9u IFdlYlByZWZlcmVuY2VzIChXZWJJbnRlcm5hbCkKSW5kZXg6IFdlYktpdC9tYWMvV2ViVmlldy9X ZWJQcmVmZXJlbmNlc1ByaXZhdGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvbWFjL1dlYlZpZXcv V2ViUHJlZmVyZW5jZXNQcml2YXRlLmgJKHJldmlzaW9uIDQwMDcwKQorKysgV2ViS2l0L21hYy9X ZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMDIsNiAr MTAyLDEwIEBAIGV4dGVybiBOU1N0cmluZyAqV2ViUHJlZmVyZW5jZXNSZW1vdmVkTm8KIC0gKFdl YlRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3IpdGV4dERpcmVjdGlvblN1Ym1l bnVJbmNsdXNpb25CZWhhdmlvcjsKIC0gKHZvaWQpc2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNs dXNpb25CZWhhdmlvcjooV2ViVGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcili ZWhhdmlvcjsKIAorLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVy ZW5jZXMgZm9yIHRlc3RzIHJ1bgorLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorLSAodm9p ZClzZXRQcmVmZXJlbmNlOihOU1N0cmluZyAqKWtleSBzdHJpbmdWYWx1ZTooTlNTdHJpbmcgKil2 YWx1ZTsKKwogLy8gSWYgc2l0ZS1zcGVjaWZpYyBzcG9vZmluZyBpcyBlbmFibGVkLCBzb21lIHBh Z2VzIHRoYXQgZG8gaW5hcHByb3ByaWF0ZSB1c2VyLWFnZW50IHN0cmluZyBjaGVja3Mgd2lsbCBi ZQogLy8gcGFzc2VkIGEgbm9uc3RhbmRhcmQgdXNlci1hZ2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0g dG8gd29yayBjb3JyZWN0bHkuIFRoaXMgbWV0aG9kIG1pZ2h0IGJlIHJlbW92ZWQgaW4KIC8vIHRo ZSBmdXR1cmUgd2hlbiB0aGVyZSdzIG5vIG1vcmUgbmVlZCBmb3IgaXQuCkluZGV4OiBXZWJLaXQv d2luL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXQvd2luL0NoYW5nZUxvZwkocmV2aXNp b24gNDAwNzApCisrKyBXZWJLaXQvd2luL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwz ICsxLDE3IEBACisyMDA5LTAxLTIxICBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRl ZCBzdXBwb3J0IGZvciBvdmVycmlkaW5nIGRlZmF1bHQgcHJlZmVyZW5jZXMgcGVyLXRlc3QuIChi dWcgMjA1MzQpCisgICAgICAgIFR3byBuZXcgbWV0aG9kcyB3ZXJlIGFkZGVkOiByZXNldFRvRGVm YXVsdHMgYW5kIG92ZXJyaWRlUHJlZmVyZW5jZS4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogSW50ZXJmYWNlcy9J V2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisgICAgICAg ICogV2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcworICAgICAgICAoV2ViUHJl ZmVyZW5jZXM6OnZhbHVlRm9yS2V5KToKKyAgICAgICAgKFdlYlByZWZlcmVuY2VzOjpvdmVycmlk ZVByZWZlcmVuY2UpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuaDogbmV3 IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDktMDEtMTkgIFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0 Lm9yZz4KIAogICAgICAgICBSdWJiZXItc3RhbXBlZCBieSBHYXZpbiBCYXJyYWNsb3VnaC4KSW5k ZXg6IFdlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93 aW4vV2ViUHJlZmVyZW5jZXMuY3BwCShyZXZpc2lvbiA0MDA3MCkKKysrIFdlYktpdC93aW4vV2Vi UHJlZmVyZW5jZXMuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMjQ5LDYgKzEyNDksMTUgQEAgSFJF U1VMVCBXZWJQcmVmZXJlbmNlczo6em9vbXNUZXh0T25seShCTwogICAgIHJldHVybiBTX09LOwog fQogCitIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIFdlYlByZWZlcmVuY2VzOjpzZXRQcmVmZXJl bmNlKEJTVFIga2V5LCBCU1RSIHZhbHVlKQoreworICAgIGlmICghU3lzU3RyaW5nTGVuKGtleSkg fHwgIVN5c1N0cmluZ0xlbih2YWx1ZSkpCisgICAgICAgIHJldHVybiBFX0ZBSUw7CisgICAgUmV0 YWluUHRyPENGU3RyaW5nUmVmPiBrZXlSZWYoQWRvcHRDRiwgQ0ZTdHJpbmdDcmVhdGVXaXRoQ2hh cmFjdGVycygwLCByZWludGVycHJldF9jYXN0PFVuaUNoYXIqPihrZXkpLCBTeXNTdHJpbmdMZW4o a2V5KSkpOworICAgIENGRGljdGlvbmFyeVNldFZhbHVlKG1fcHJpdmF0ZVByZWZzLmdldCgpLCBr ZXlSZWYuZ2V0KCksIHZhbHVlKTsKKyAgICByZXR1cm4gU19PSzsKK30KKwogdm9pZCBXZWJQcmVm ZXJlbmNlczo6d2lsbEFkZFRvV2ViVmlldygpCiB7CiAgICAgKyttX251bVdlYlZpZXdzOwpJbmRl eDogV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYktpdC93aW4v V2ViUHJlZmVyZW5jZXMuaAkocmV2aXNpb24gNDAwNzApCisrKyBXZWJLaXQvd2luL1dlYlByZWZl cmVuY2VzLmgJKHdvcmtpbmcgY29weSkKQEAgLTM0NCw2ICszNDQsMTIgQEAgcHVibGljOgogICAg IHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzZXRGb250U21vb3RoaW5nQ29udHJh c3QoIAogICAgIC8qIFtpbl0gKi8gZmxvYXQgY29udHJhc3QpOwogCisgICAgLy8gVGhpcyBtZXRo b2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAg IC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVU SE9EQ0FMTFRZUEUgc2V0UHJlZmVyZW5jZSgKKyAgICAgICAgLyogW2luXSAqLyBCU1RSIGtleSwK KyAgICAgICAgLyogW2luXSAqLyBCU1RSIHZhbHVlKTsKKwogICAgIC8vIFdlYlByZWZlcmVuY2Vz CiAKICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3NlcyBhIGRpZmZlcmVudCBwcmVmZXJlbmNlIGtl eSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQuCkluZGV4OiBXZWJLaXQvd2luL0ludGVyZmFj ZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViS2l0L3dpbi9J bnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCShyZXZpc2lvbiA0MDA3MCkKKysr IFdlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAkod29ya2lu ZyBjb3B5KQpAQCAtNjksNCArNjksOCBAQCBpbnRlcmZhY2UgSVdlYlByZWZlcmVuY2VzUHJpdmF0 ZSA6IElVbmtuCiAKICAgICBIUkVTVUxUIHNldEZvbnRTbW9vdGhpbmdDb250cmFzdChbaW5dIGZs b2F0IGNvbnRyYXN0KTsKICAgICBIUkVTVUxUIGZvbnRTbW9vdGhpbmdDb250cmFzdChbb3V0LCBy ZXR2YWxdIGZsb2F0KiBjb250cmFzdCk7CisKKyAgICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBm b3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3IgdGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1w UmVuZGVyVHJlZSBvbmx5LgorICAgIEhSRVNVTFQgc2V0UHJlZmVyZW5jZShbaW5dIEJTVFIga2V5 LCBbaW5dIEJTVFIgdmFsdWUpOyAKIH0KSW5kZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L0xheW91dFRlc3RDb250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAJKHJldmlzaW9uIDQwMDcwKQorKysg V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zNDgsNiArMzQ4LDIyIEBAIHN0YXRpYyBKU1ZhbHVlUmVmIGlzQ29tbWFu ZEVuYWJsZWRDYWxsYmEKICAgICByZXR1cm4gSlNWYWx1ZU1ha2VCb29sZWFuKGNvbnRleHQsIGNv bnRyb2xsZXItPmlzQ29tbWFuZEVuYWJsZWQobmFtZS5nZXQoKSkpOwogfQogCitzdGF0aWMgSlNW YWx1ZVJlZiBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwg SlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1 bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNl cHRpb24pCit7CisgICAgaWYgKGFyZ3VtZW50Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNW YWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1Jl Zj4ga2V5KEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwg ZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxK U1N0cmluZ1JlZj4gdmFsdWUoQWRvcHQsIEpTVmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJn dW1lbnRzWzFdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAg TGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRyb2xsZXIgPSByZWludGVycHJldF9jYXN0PExheW91 dFRlc3RDb250cm9sbGVyKj4oSlNPYmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBj b250cm9sbGVyLT5vdmVycmlkZVByZWZlcmVuY2Uoa2V5LmdldCgpLCB2YWx1ZS5nZXQoKSk7CisK KyAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBK U1ZhbHVlUmVmIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpT T2JqZWN0UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1l bnRDb3VudCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0 aW9uKQogewogICAgIC8vIEhhcyBtYWMgaW1wbGVtZW50YXRpb24KQEAgLTgyNCw2ICs4NDAsNyBA QCBKU1N0YXRpY0Z1bmN0aW9uKiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6CiAgICAgICAgIHsgImlz Q29tbWFuZEVuYWJsZWQiLCBpc0NvbW1hbmRFbmFibGVkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAg ICAgeyAia2VlcFdlYkhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0 eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAg ICAgICAgIHsgIm5vdGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0 cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKKyAgICAg ICAgeyAib3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKICAgICAgICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhUb0xvY2FsUmVzb3Vy Y2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0 cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJxdWV1ZUJhY2tOYXZpZ2F0aW9uIiwgcXVl dWVCYWNrTmF2aWdhdGlvbkNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInF1ZXVlRm9yd2Fy ZE5hdmlnYXRpb24iLCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uQ2FsbGJhY2ssIGtKU1Byb3BlcnR5 QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKSW5k ZXg6IFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xs ZXIuaAkocmV2aXNpb24gNDAwNzApCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC03NCw2ICs3NCw3IEBAIHB1Ymxp YzoKICAgICB2b2lkIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYgcGF0aCk7 CiAgICAgdm9pZCBzZXRQZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1Jl ZiBwYXRoKTsKICAgICB2b2lkIGNsZWFyUGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0KCk7CisgICAg dm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFn KTsKICAgICBpbnQgd2luZG93Q291bnQoKTsKICAgICAKICAgICBib29sIGVsZW1lbnREb2VzQXV0 b0NvbXBsZXRlRm9yRWxlbWVudFdpdGhJZChKU1N0cmluZ1JlZiBpZCk7CkluZGV4OiBXZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCShyZXZpc2lv biA0MDA3MCkKKysrIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJl ZS5tbQkod29ya2luZyBjb3B5KQpAQCAtMzMyLDkgKzMzMiw5IEBAIHN0YXRpYyB2b2lkIHNldERl ZmF1bHRzVG9Db25zaXN0ZW50VmFsdWUKIAogICAgIE5TU3RyaW5nICpsaWJyYXJ5UGF0aCA9IFtA In4vTGlicmFyeS9BcHBsaWNhdGlvbiBTdXBwb3J0L0R1bXBSZW5kZXJUcmVlIiBzdHJpbmdCeUV4 cGFuZGluZ1RpbGRlSW5QYXRoXTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0OltsaWJyYXJ5UGF0 aCBzdHJpbmdCeUFwcGVuZGluZ1BhdGhDb21wb25lbnQ6QCJEYXRhYmFzZXMiXSBmb3JLZXk6V2Vi RGF0YWJhc2VEaXJlY3RvcnlEZWZhdWx0c0tleV07Ci0gICAgCisgICAgCQogICAgIFdlYlByZWZl cmVuY2VzICpwcmVmZXJlbmNlcyA9IFtXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2Vz XTsKLQorICAgIFtwcmVmZXJlbmNlcyBzZXRBdXRvc2F2ZXM6Tk9dOwkKICAgICBbcHJlZmVyZW5j ZXMgc2V0U3RhbmRhcmRGb250RmFtaWx5OkAiVGltZXMiXTsKICAgICBbcHJlZmVyZW5jZXMgc2V0 Rml4ZWRGb250RmFtaWx5OkAiQ291cmllciJdOwogICAgIFtwcmVmZXJlbmNlcyBzZXRTZXJpZkZv bnRGYW1pbHk6QCJUaW1lcyJdOwpAQCAtMzUxLDYgKzM1MSwxNyBAQCBzdGF0aWMgdm9pZCBzZXRE ZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlCiAgICAgW3ByZWZlcmVuY2VzIHNldERPTVBhc3RlQWxs b3dlZDpZRVNdOwogICAgIFtwcmVmZXJlbmNlcyBzZXRGdWxsRG9jdW1lbnRUZWFyZG93bkVuYWJs ZWQ6WUVTXTsKICAgICBbcHJlZmVyZW5jZXMgc2V0U2hvdWxkUHJpbnRCYWNrZ3JvdW5kczpZRVNd OworICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKKyAgICBb cHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsKKyAgICBbcHJl ZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseTpZRVNdOwor ICAgIFtwcmVmZXJlbmNlcyBzZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQ6WUVT XTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0RnVsbERvY3VtZW50VGVhcmRvd25FbmFibGVkOllFU107 CisgICAgW3ByZWZlcmVuY2VzIHNldERldmVsb3BlckV4dHJhc0VuYWJsZWQ6Tk9dOworICAgIGlm IChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbikgeworICAgICAgICBbcHJlZmVyZW5j ZXMgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjpbTlNVUkwgVVJMV2l0aFN0cmluZzooTlNTdHJp bmcgKikocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpXV07CisgICAgICAg IFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQ6WUVTXTsKKyAgICB9IGVsc2UK KyAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZDpOT107CiAKICAg ICAvLyBUaGUgYmFjay9mb3J3YXJkIGNhY2hlIGlzIGNhdXNpbmcgcHJvYmxlbXMgZHVlIHRvIGxh eW91dHMgZHVyaW5nIHRyYW5zaXRpb24gZnJvbSBvbmUgcGFnZSB0byBhbm90aGVyLgogICAgIC8v IFNvLCB0dXJuIGl0IG9mZiBmb3Igbm93LCBidXQgd2UgbWlnaHQgd2FudCB0byB0dXJuIGl0IGJh Y2sgb24gc29tZSBkYXkuCkBAIC05ODIsMjAgKzk5MywxMCBAQCBzdGF0aWMgdm9pZCByZXNldFdl YlZpZXdUb0NvbnNpc3RlbnRTdGF0CiAgICAgW3dlYlZpZXcgc2V0UG9saWN5RGVsZWdhdGU6bmls XTsKICAgICBbd2ViVmlldyBfc2V0RGFzaGJvYXJkQmVoYXZpb3I6V2ViRGFzaGJvYXJkQmVoYXZp b3JVc2VCYWNrd2FyZENvbXBhdGliaWxpdHlNb2RlIHRvOk5PXTsKICAgICBbd2ViVmlldyBfY2xl YXJNYWluRnJhbWVOYW1lXTsKLQotICAgIFdlYlByZWZlcmVuY2VzICpwcmVmZXJlbmNlcyA9IFt3 ZWJWaWV3IHByZWZlcmVuY2VzXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0UHJpdmF0ZUJyb3dzaW5n RW5hYmxlZDpOT107Ci0gICAgW3ByZWZlcmVuY2VzIHNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFi bGVkOllFU107Ci0gICAgW3ByZWZlcmVuY2VzIHNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1 dG9tYXRpY2FsbHk6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0T2ZmbGluZVdlYkFwcGxpY2F0 aW9uQ2FjaGVFbmFibGVkOllFU107Ci0gICAgW3ByZWZlcmVuY2VzIHNldEZ1bGxEb2N1bWVudFRl YXJkb3duRW5hYmxlZDpZRVNdOwotICAgIFtwcmVmZXJlbmNlcyBzZXREZXZlbG9wZXJFeHRyYXNF bmFibGVkOk5PXTsKLQotICAgIGlmIChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbikg ewotICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjpbTlNVUkwg VVJMV2l0aFN0cmluZzooTlNTdHJpbmcgKikocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRp b24uZ2V0KCkpXV07Ci0gICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJs ZWQ6WUVTXTsKLSAgICB9IGVsc2UKLSAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNo ZWV0RW5hYmxlZDpOT107CisKKyAgICAvLyBEZWZhdWx0IHZhbHVlcyBtYXkgaGF2ZSBjaGFuZ2Vk IGluIHRoZSBsYXN0IHRlc3QuCisgICAgLy8gUmVzZXQgdGhlbSB0byB0aGVpciBjb3JyZWN0IGRl ZmF1bHQgdmFsdWVzIGZvciB0aGUgbmV4dCB0ZXN0LgorICAgIHNldERlZmF1bHRzVG9Db25zaXN0 ZW50VmFsdWVzRm9yVGVzdGluZygpOwogCiAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gc2V0U21h cnRJbnNlcnREZWxldGVFbmFibGVkOllFU107CiAgICAgW1tbbWFpbkZyYW1lIHdlYlZpZXddIGlu c3BlY3Rvcl0gc2V0SmF2YVNjcmlwdFByb2ZpbGluZ0VuYWJsZWQ6Tk9dOwpJbmRleDogV2ViS2l0 VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbQkocmV2aXNpb24gNDAwNzApCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMubW0JKHdvcmtpbmcgY29weSkKQEAgLTI4OCw2 ICsyODgsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0VXNlclN0eWxlUwogICAg IFtbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0VXNlclN0eWxlU2hlZXRM b2NhdGlvbjp1cmxdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlkZVBy ZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKQoreworICAgIFJldGFp blB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NG QWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcgKmtleU5TID0gKE5TU3RyaW5n ICopa2V5Q0YuZ2V0KCk7CisKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGZsYWdDRihBZG9w dENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBmbGFnKSk7Cisg ICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAqKWZsYWdDRi5nZXQoKTsKKworICAgIFtb V2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gc2V0UHJlZmVyZW5jZTprZXlOUyBz dHJpbmdWYWx1ZTpmbGFnTlNdOworfQorCiB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpzZXRQ ZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbihKU1N0cmluZ1JlZiBqc1VSTCkKIHsKICAg ICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IHVybFN0cmluZyhBZG9wdENGLCBKU1N0cmluZ0NvcHlD RlN0cmluZygwLCBqc1VSTCkpOwpJbmRleDogV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2lu L0R1bXBSZW5kZXJUcmVlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCShyZXZpc2lvbiA0MDA3MCkKKysrIFdlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTYzOSw4ICs2MzksMTcgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50 U3RhdAogICAgICAgICB3ZWJJQkFjdGlvbnMtPnJlc2V0UGFnZVpvb20oMCk7CiAgICAgfQogCisK ICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKICAgICBpZiAoU1VDQ0VF REVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKSB7CisKKyAgICAgICAgQ09N UHRyPElXZWJQcmVmZXJlbmNlcz4gbmV3UHJlZmVyZW5jZXM7CisgICAgICAgIGlmIChTVUNDRUVE RUQocHJlZmVyZW5jZXMtPnN0YW5kYXJkUHJlZmVyZW5jZXMoJm5ld1ByZWZlcmVuY2VzKSkpIHsK KyAgICAgICAgICAgIHByZWZlcmVuY2VzLnJlbGVhc2VSZWYoKTsKKyAgICAgICAgICAgIHdlYlZp ZXctPnNldFByZWZlcmVuY2VzKG5ld1ByZWZlcmVuY2VzLmdldCgpKTsKKyAgICAgICAgICAgIHdl YlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcyk7CisgICAgICAgIH0KKyAgICAgICAgcHJl ZmVyZW5jZXMtPnNldEF1dG9zYXZlcyhGQUxTRSk7CiAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRQ cml2YXRlQnJvd3NpbmdFbmFibGVkKEZBTFNFKTsKICAgICAgICAgcHJlZmVyZW5jZXMtPnNldEph dmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHkoVFJVRSk7CiAKSW5kZXg6IFdlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250 cm9sbGVyV2luLmNwcAkocmV2aXNpb24gNDAwNzApCisrKyBXZWJLaXRUb29scy9EdW1wUmVuZGVy VHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00 MSw2ICs0MSw3IEBACiAjaW5jbHVkZSA8SmF2YVNjcmlwdENvcmUvQXNzZXJ0aW9ucy5oPgogI2lu Y2x1ZGUgPEphdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLmg+CiAjaW5jbHVkZSA8SmF2YVNj cmlwdENvcmUvSlNSZXRhaW5QdHIuaD4KKyNpbmNsdWRlIDxKYXZhU2NyaXB0Q29yZS9KU1N0cmlu Z1JlZkJTVFIuaD4KICNpbmNsdWRlIDxXZWJLaXQvV2ViS2l0Lmg+CiAjaW5jbHVkZSA8c3RyaW5n PgogI2luY2x1ZGUgPENvcmVGb3VuZGF0aW9uL0NvcmVGb3VuZGF0aW9uLmg+CkBAIC02NzYsMyAr Njc3LDI0IEBAIHVuc2lnbmVkIExheW91dFRlc3RDb250cm9sbGVyOjpudW1iZXJPZkEKIHsKICAg ICByZXR1cm4gMDsgLy8gRklYTUU6IEltcGxlbWVudCB0aGlzIG9uIFdpbmRvd3MKIH0KKwordm9p ZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtl eSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+IHdlYlZpZXc7Cisg ICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAgICAgICByZXR1cm47 CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKKyAgICBpZiAoRkFJ TEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAgICAgICByZXR1cm47 CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5 LCBwcmVmZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisgICAgICAgIHJldHVybjsK KworICAgIEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5KTsKKyAgICBCU1RSIGZs YWdCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVmc1ByaXZhdGUtPnNldFBy ZWZlcmVuY2Uoa2V5QlNUUiwgZmxhZ0JTVFIpOworICAgIFN5c0ZyZWVTdHJpbmcoa2V5QlNUUik7 CisgICAgU3lzRnJlZVN0cmluZyhmbGFnQlNUUik7Cit9CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFu Z2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA0MDA3 MCkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4 IEBACisyMDA5LTAxLTIxICBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCB0ZXN0 cyB0byB2ZXJpZnkgdGhhdCBkZWZhdWx0IHByZWZlcmVuY2VzIGNhbiBiZSBvdmVycmlkZGVuIHBl ci10ZXN0CisgICAgICAgIGFuZCB0aGF0IG92ZXJyaWRkZW4gdmFsdWVzIGFyZSByZXNldCBiZXR3 ZWVuIGVhY2ggdGVzdC4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5j ZXMtMi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXBy ZWZlcmVuY2VzLTIuaHRtbDogQWRkZWQuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJl ZmVyZW5jZXMtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS16 enotcmVzZXQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlk ZS16enotcmVzZXQuaHRtbDogQWRkZWQuCisKIDIwMDktMDEtMjAgIFBpZXJyZS1PbGl2aWVyIExh dG91ciAgPHBvbEBhcHBsZS5jb20+CiAKICAgICAgICAgUHJldmlvdXNseSB1cGxvYWRlZCByZWZl cmVuY2UgaW1hZ2VzIHdlcmUgZ2VuZXJhdGVkIHdpdGggUGVyaWFuIGluc3RhbGxlZCwgd2hpY2gg YWZmZWN0ZWQgdGhlbQpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMtMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRU ZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4u IFRoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVl cyBhbmQgYWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlvdSBzaG91bGQgc2Vl ICJQQVNTIiBiZWxvdy4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtcHJlZmVyZW5jZXMtMi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5 L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3Rz L3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAs MCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0RGVm YXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9zY3JpcHQ+Cis8Ym9keT4KKyAgICA8cD5U aGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMg ZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAKKyAgICBUaGlzIHRlc3QgdmVyaWZpZXMg dGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUg dGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93 LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgcCA9IGRvY3VtZW50LmdldEVsZW1lbnRz QnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCkuZm9udFNpemUgPT0gIjI0cHgiKQorICAg ICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2Vz LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9z ZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBA IC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRl c3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4u IFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlz YWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEg YnJvd3Nlci4KKworUEFTUwpJbmRleDogTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJl ZmVyZW5jZXMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlk ZS1wcmVmZXJlbmNlcy5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2VjdXJpdHkv b3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxOCBAQAor PGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKQorICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdEphdmFT Y3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAgICBmdW5jdGlvbiBsb2Fkc3Rh dHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJGQUlMIjsK KyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRzdGF0dXMoKSI+CisgICAgPHA+ VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNh biBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uICBUaGlzIHRlc3Qgc3Bl Y2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91 IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuPC9wPgor ICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4 OiBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0Cj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16 enotcmVzZXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMgQEAKK1RoaXMg dGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0 cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiBZb3Ugc2hvdWxk IHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKSW5kZXg6IExheW91dFRlc3RzL3NlY3VyaXR5L292 ZXJyaWRlLXp6ei1yZXNldC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3NlY3VyaXR5 L292ZXJyaWRlLXp6ei1yZXNldC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvc2Vj dXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTQg QEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwor PC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIGxh eW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgYWZ0 ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuPC9wPgor ICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNjcmlwdD4KKyAgICAgICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iUEFTUyI7ICAgICAg ICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 32572 2009-07-10 12:44:41 -0700 2009-07-25 13:34:08 -0700 Fixed and cleaned patch. patch.txt text/plain 20439 dimich ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxNDVlMjNhLi5mZThjZDQ1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMDktMDct MDcgIEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZGVkIHRlc3RzIHRvIHZlcmlmeSB0 aGF0IGRlZmF1bHQgcHJlZmVyZW5jZXMgY2FuIGJlIG92ZXJyaWRkZW4gcGVyLXRlc3QKKyAgICAg ICAgYW5kIHRoYXQgb3ZlcnJpZGRlbiB2YWx1ZXMgYXJlIHJlc2V0IGJldHdlZW4gZWFjaCB0ZXN0 LgorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw NTM0CisKKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2Vz Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5o dG1sOiBBZGRlZC4KKwogMjAwOS0wNy0wNyAgQnJhZHkgRWlkc29uICA8YmVpZHNvbkBhcHBsZS5j b20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFyayBSb3dlLgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYmNjZWFhCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50 eHQKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29u dHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uIFRoaXMg dGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQg YWxzbyBvdmVycmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlvdSBzaG91bGQgc2VlICJQQVNT IiBiZWxvdy4KKworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJp ZGUtcHJlZmVyZW5jZXMtMi5odG1sIGIvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJl ZmVyZW5jZXMtMi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjIzMDU2 ZjQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS1wcmVm ZXJlbmNlcy0yLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAgIGlm KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJyaWRl UHJlZmVyZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9zY3Jp cHQ+Cis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29u dHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAKKyAg ICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1 ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91IHNo b3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIgcCA9 IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3aW5k b3cubGF5b3V0VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCkuZm9u dFNpemUgPT0gIjI0cHgiKQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsKKyAg ICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3Nl Y3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi40YzM0OGUwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEs MyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9s bGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uIFRoaXMgdGVz dCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4gYmUgZGlzYWJsZWQsIGFu ZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3aXRoIGEgYnJvd3Nlci4K KworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMuaHRtbCBiL0xheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzQwYTczOQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwK QEAgLTAsMCArMSwxOCBAQAorPGh0bWw+IAorPGJvZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2lu ZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVy LmR1bXBBc1RleHQoKQorICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZl cmVuY2UoIldlYktpdEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAg ICBmdW5jdGlvbiBsb2Fkc3RhdHVzKCkgeworICAgICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpCisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIiku aW5uZXJIVE1MPSJGQUlMIjsKKyAgICB9Cis8L3NjcmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRz dGF0dXMoKSI+CisgICAgPHA+VGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91 dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRk ZW4uICBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJl IGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0 aCBhIGJyb3dzZXIuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9zZWN1cml0eS9vdmVycmlkZS16 enotcmVzZXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6 LXJlc2V0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5k ZWUyOTJlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUt enp6LXJlc2V0LWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmll cyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHBy ZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIg YmVsb3cuCisKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRl LXp6ei1yZXNldC5odG1sIGIvTGF5b3V0VGVzdHMvc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0 Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2JlYjFlMAotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL3NlY3VyaXR5L292ZXJyaWRlLXp6ei1yZXNldC5odG1s CkBAIC0wLDAgKzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlm aWVzIHRoYXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQg cHJlZmVyZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFT UyIgYmVsb3cuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNj cmlwdD4KKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRN TD0iUEFTUyI7ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAt LWdpdCBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvV2ViS2l0L21hYy9DaGFuZ2VMb2cKaW5kZXgg MWU3MmUxNC4uOTg1ZTk0MCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cKKysrIGIv V2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAwOS0wNy0wNyAgR2xlbm4g V2lsc29uICA8Z3dpbHNvbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgbmV3IG1ldGhvZHMgZm9yIG92ZXJyaWRpbmcg ZGVmYXVsdCBXZWJQcmVmZXJlbmNlIHZhbHVlcworICAgICAgICBhbmQgZm9yIHJlc2V0dGluZyBw cmVmZXJlbmNlcyB0byB0aGVpciBkZWZhdWx0cy4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogV2ViVmlldy9XZWJQ cmVmZXJlbmNlS2V5c1ByaXZhdGUuaDoKKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2Vz Lm1tOgorICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBpbml0V2l0aElkZW50aWZpZXI6XSk6Cisg ICAgICAgICgtW1dlYlByZWZlcmVuY2VzIGluaXRXaXRoQ29kZXI6XSk6CisgICAgICAgICgtW1dl YlByZWZlcmVuY2VzIF92YWx1ZUZvcktleTpdKToKKyAgICAgICAgKC1bV2ViUHJlZmVyZW5jZXMg b3ZlcnJpZGVQcmVmZXJlbmNlOmZsYWc6XSk6IG5ldyBtZXRob2QKKyAgICAgICAgKiBXZWJWaWV3 L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oOiBuZXcgbWV0aG9kIHNpZ25hdHVyZXMKKwogMjAwOS0w Ny0wNyAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IFNhbSBXZWluaWcuCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2Vi UHJlZmVyZW5jZXMubW0gYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0KaW5k ZXggZDEwYWIxNy4uOTkyNDc3MyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlBy ZWZlcmVuY2VzLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQpA QCAtMTE1Miw2ICsxMTUyLDEzIEBAIHN0YXRpYyBOU1N0cmluZyAqY2xhc3NJQkNyZWF0b3JJRCA9 IG5pbDsKIHsKICAgICArK19wcml2YXRlLT5udW1XZWJWaWV3czsKIH0KKworLSAodm9pZClfc2V0 UHJlZmVyZW5jZTooTlNTdHJpbmcgKilrZXkgc3RyaW5nVmFsdWU6KE5TU3RyaW5nICopdmFsdWUK K3sKKyAgICBOU1N0cmluZyAqX2tleSA9IEtFWShrZXkpOworICAgIFtzZWxmIF9zZXRTdHJpbmdW YWx1ZTp2YWx1ZSBmb3JLZXk6X2tleV07CQorfQorCiBAZW5kCiAKIEBpbXBsZW1lbnRhdGlvbiBX ZWJQcmVmZXJlbmNlcyAoV2ViSW50ZXJuYWwpCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZp ZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVy ZW5jZXNQcml2YXRlLmgKaW5kZXggZDU3MTg2OS4uNjZkY2FlOCAxMDA2NDQKLS0tIGEvV2ViS2l0 L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCisrKyBiL1dlYktpdC9tYWMvV2Vi Vmlldy9XZWJQcmVmZXJlbmNlc1ByaXZhdGUuaApAQCAtMTE3LDYgKzExNywxMCBAQCBleHRlcm4g TlNTdHJpbmcgKldlYlByZWZlcmVuY2VzUmVtb3ZlZE5vdGlmaWNhdGlvbjsKIC0gKFdlYlRleHRE aXJlY3Rpb25TdWJtZW51SW5jbHVzaW9uQmVoYXZpb3IpdGV4dERpcmVjdGlvblN1Ym1lbnVJbmNs dXNpb25CZWhhdmlvcjsKIC0gKHZvaWQpc2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25C ZWhhdmlvcjooV2ViVGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciliZWhhdmlv cjsKIAorLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMg Zm9yIHRlc3RzIHJ1bgorLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorLSAodm9pZClfc2V0 UHJlZmVyZW5jZTooTlNTdHJpbmcgKilrZXkgc3RyaW5nVmFsdWU6KE5TU3RyaW5nICopdmFsdWU7 CisKIC8vIElmIHNpdGUtc3BlY2lmaWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0 aGF0IGRvIGluYXBwcm9wcmlhdGUgdXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8v IHBhc3NlZCBhIG5vbnN0YW5kYXJkIHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdv cmsgY29ycmVjdGx5LiBUaGlzIG1ldGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0 dXJlIHdoZW4gdGhlcmUncyBubyBtb3JlIG5lZWQgZm9yIGl0LgpkaWZmIC0tZ2l0IGEvV2ViS2l0 L3dpbi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwppbmRleCBlYmQyZjc5Li4yYzIx NWExIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0NoYW5nZUxvZworKysgYi9XZWJLaXQvd2luL0No YW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDA5LTA3LTA3ICBHbGVubiBXaWxzb24gIDxnd2ls c29uQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBvdmVycmlkaW5nIGRlZmF1bHQgcHJlZmVyZW5j ZXMgcGVyLXRlc3QuIChidWcgMjA1MzQpCisgICAgICAgIFR3byBuZXcgbWV0aG9kcyB3ZXJlIGFk ZGVkOiByZXNldFRvRGVmYXVsdHMgYW5kIG92ZXJyaWRlUHJlZmVyZW5jZS4KKyAgICAgICAgU2Vl IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAg ICogSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbDogbmV3IG1ldGhvZCBzaWdu YXR1cmVzCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuY3BwOiBhZGRlZCBuZXcgbWV0aG9kcwor ICAgICAgICAoV2ViUHJlZmVyZW5jZXM6OnZhbHVlRm9yS2V5KToKKyAgICAgICAgKFdlYlByZWZl cmVuY2VzOjpvdmVycmlkZVByZWZlcmVuY2UpOiBuZXcgbWV0aG9kCisgICAgICAgICogV2ViUHJl ZmVyZW5jZXMuaDogbmV3IG1ldGhvZCBzaWduYXR1cmVzCisKIDIwMDktMDctMDcgIEFkYSBDaGFu ICA8YWRhY2hhbkBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4K ZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRl LmlkbCBiL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbApp bmRleCA1NjJhNzViLi43NzJlNGUyIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0ludGVyZmFjZXMv SVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwKKysrIGIvV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lX ZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCkBAIC03MCw2ICs3MCwxMCBAQCBpbnRlcmZhY2UgSVdl YlByZWZlcmVuY2VzUHJpdmF0ZSA6IElVbmtub3duCiAgICAgSFJFU1VMVCBzZXRGb250U21vb3Ro aW5nQ29udHJhc3QoW2luXSBmbG9hdCBjb250cmFzdCk7CiAgICAgSFJFU1VMVCBmb250U21vb3Ro aW5nQ29udHJhc3QoW291dCwgcmV0dmFsXSBmbG9hdCogY29udHJhc3QpOwogCisgICAgLy8gVGhp cyBtZXRob2QgaXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1 bgorICAgIC8vIHdpdGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIHNldFByZWZl cmVuY2UoW2luXSBCU1RSIGtleSwgW2luXSBCU1RSIHZhbHVlKTsKKwogICAgIEhSRVNVTFQgaXNX ZWJTZWN1cml0eUVuYWJsZWQoW291dCwgcmV0dmFsXSBCT09MKiBlbmFibGVkKTsKICAgICBIUkVT VUxUIHNldFdlYlNlY3VyaXR5RW5hYmxlZChbaW5dIEJPT0wgZW5hYmxlZCk7CiAKZGlmZiAtLWdp dCBhL1dlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuY3BwIGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJl bmNlcy5jcHAKaW5kZXggYjkxYmQ0ZS4uNmFiOTBlYyAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9X ZWJQcmVmZXJlbmNlcy5jcHAKKysrIGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAKQEAg LTEzMDEsNiArMTMwMSwxNSBAQCBIUkVTVUxUIFdlYlByZWZlcmVuY2VzOjp6b29tc1RleHRPbmx5 KEJPT0wqIHpvb21zVGV4dE9ubHkpCiAgICAgcmV0dXJuIFNfT0s7CiB9CiAKK0hSRVNVTFQgU1RE TUVUSE9EQ0FMTFRZUEUgV2ViUHJlZmVyZW5jZXM6OnNldFByZWZlcmVuY2UoQlNUUiBrZXksIEJT VFIgdmFsdWUpCit7CisgICAgaWYgKCFTeXNTdHJpbmdMZW4oa2V5KSB8fCAhU3lzU3RyaW5nTGVu KHZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEVfRkFJTDsKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdS ZWY+IGtleVJlZihBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJlaW50 ZXJwcmV0X2Nhc3Q8VW5pQ2hhcio+KGtleSksIFN5c1N0cmluZ0xlbihrZXkpKSk7CisgICAgQ0ZE aWN0aW9uYXJ5U2V0VmFsdWUobV9wcml2YXRlUHJlZnMuZ2V0KCksIGtleVJlZi5nZXQoKSwgdmFs dWUpOworICAgIHJldHVybiBTX09LOworfQorCiB2b2lkIFdlYlByZWZlcmVuY2VzOjp3aWxsQWRk VG9XZWJWaWV3KCkKIHsKICAgICArK21fbnVtV2ViVmlld3M7CmRpZmYgLS1naXQgYS9XZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmggYi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgKaW5kZXgg MmY5NDM4Mi4uNDBjMTU0YyAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5o CisrKyBiL1dlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaApAQCAtMzQwLDEwICszNDAsMTYgQEAg cHVibGljOgogCiAgICAgdmlydHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIGZvbnRTbW9v dGhpbmdDb250cmFzdCggCiAgICAgLyogW3JldHZhbF1bb3V0XSAqLyBmbG9hdCogY29udHJhc3Qp OwotICAgIAorCiAgICAgdmlydHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIHNldEZvbnRT bW9vdGhpbmdDb250cmFzdCggCiAgICAgLyogW2luXSAqLyBmbG9hdCBjb250cmFzdCk7CiAKKyAg ICAvLyBUaGlzIG1ldGhvZCBpcyBtZWFudCBmb3Igb3ZlcnJpZGluZyBwcmVmZXJlbmNlcyBmb3Ig dGVzdHMgcnVuCisgICAgLy8gd2l0aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorICAgIHZpcnR1YWwg SFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzZXRQcmVmZXJlbmNlKAorICAgICAgICAvKiBbaW5d ICovIEJTVFIga2V5LAorICAgICAgICAvKiBbaW5dICovIEJTVFIgdmFsdWUpOworCiAgICAgdmly dHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIGlzV2ViU2VjdXJpdHlFbmFibGVkKAogICAg IC8qIFtyZXR2YWxdW291dF0gKi8gQk9PTCogZW5hYmxlZCk7CiAKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAppbmRleCAxMmMwODg4 Li43YzNjMjIyIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRU ZXN0Q29udHJvbGxlci5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwCkBAIC0zNTksNiArMzU5LDIyIEBAIHN0YXRpYyBKU1ZhbHVlUmVm IGlzQ29tbWFuZEVuYWJsZWRDYWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RS ZWYgZnVuCiAgICAgcmV0dXJuIEpTVmFsdWVNYWtlQm9vbGVhbihjb250ZXh0LCBjb250cm9sbGVy LT5pc0NvbW1hbmRFbmFibGVkKG5hbWUuZ2V0KCkpKTsKIH0KIAorc3RhdGljIEpTVmFsdWVSZWYg b3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0 UmVmIGZ1bmN0aW9uLCBKU09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3Vu dCwgY29uc3QgSlNWYWx1ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQor eworICAgIGlmIChhcmd1bWVudENvdW50IDwgMikKKyAgICAgICAgcmV0dXJuIEpTVmFsdWVNYWtl VW5kZWZpbmVkKGNvbnRleHQpOworCisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdSZWY+IGtleShB ZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMF0sIGV4Y2VwdGlv bikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisgICAgSlNSZXRhaW5QdHI8SlNTdHJpbmdS ZWY+IHZhbHVlKEFkb3B0LCBKU1ZhbHVlVG9TdHJpbmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1sx XSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEqZXhjZXB0aW9uKTsKKworICAgIExheW91dFRl c3RDb250cm9sbGVyKiBjb250cm9sbGVyID0gcmVpbnRlcnByZXRfY2FzdDxMYXlvdXRUZXN0Q29u dHJvbGxlcio+KEpTT2JqZWN0R2V0UHJpdmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxl ci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtleS5nZXQoKSwgdmFsdWUuZ2V0KCkpOworCisgICAgcmV0 dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVkKGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJl ZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJl ZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQs IGNvbnN0IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsK ICAgICAvLyBIYXMgbWFjIGltcGxlbWVudGF0aW9uCkBAIC04OTMsNiArOTA5LDcgQEAgSlNTdGF0 aWNGdW5jdGlvbiogTGF5b3V0VGVzdENvbnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAg ICAgIHsgImtlZXBXZWJIaXN0b3J5Iiwga2VlcFdlYkhpc3RvcnlDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAog ICAgICAgICB7ICJub3RpZnlEb25lIiwgbm90aWZ5RG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAg ICAgIHsgIm51bWJlck9mQWN0aXZlQW5pbWF0aW9ucyIsIG51bWJlck9mQWN0aXZlQW5pbWF0aW9u c0NhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRy aWJ1dGVEb250RGVsZXRlIH0sCisgICAgICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJy aWRlUHJlZmVyZW5jZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pT UHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInBhdGhUb0xvY2FsUmVz b3VyY2UiLCBwYXRoVG9Mb2NhbFJlc291cmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRl UmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAi cGF1c2VBbmltYXRpb25BdFRpbWVPbkVsZW1lbnRXaXRoSWQiLCBwYXVzZUFuaW1hdGlvbkF0VGlt ZU9uRWxlbWVudFdpdGhJZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwg a0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInBhdXNlVHJhbnNp dGlvbkF0VGltZU9uRWxlbWVudFdpdGhJZCIsIHBhdXNlVHJhbnNpdGlvbkF0VGltZU9uRWxlbWVu dFdpdGhJZENhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVy dHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCBiODgwZjcxLi41YjlmZjE5IDEwMDY0NAot LS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAg LTUyLDYgKzUyLDcgQEAgcHVibGljOgogICAgIGJvb2wgaXNDb21tYW5kRW5hYmxlZChKU1N0cmlu Z1JlZiBuYW1lKTsKICAgICB2b2lkIGtlZXBXZWJIaXN0b3J5KCk7CiAgICAgdm9pZCBub3RpZnlE b25lKCk7CisgICAgdm9pZCBvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0 cmluZ1JlZiBmbGFnKTsKICAgICBKU1N0cmluZ1JlZiBwYXRoVG9Mb2NhbFJlc291cmNlKEpTQ29u dGV4dFJlZiwgSlNTdHJpbmdSZWYgdXJsKTsKICAgICB2b2lkIHF1ZXVlQmFja05hdmlnYXRpb24o aW50IGhvd0ZhckJhY2t3YXJkKTsKICAgICB2b2lkIHF1ZXVlRm9yd2FyZE5hdmlnYXRpb24oaW50 IGhvd0ZhckZvcndhcmQpOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0R1bXBSZW5kZXJUcmVlLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1 bXBSZW5kZXJUcmVlLm1tCmluZGV4IDRiNjIxZTguLjNmYTc1NDQgMTAwNjQ0Ci0tLSBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQorKysgYi9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KQEAgLTM0OCw3ICszNDgs OCBAQCBzdGF0aWMgTlNTdHJpbmcgKmxpYnJhcnlQYXRoRm9yRHVtcFJlbmRlclRyZWUoKQogICAg IHJldHVybiBbQCJ+L0xpYnJhcnkvQXBwbGljYXRpb24gU3VwcG9ydC9EdW1wUmVuZGVyVHJlZSIg c3RyaW5nQnlFeHBhbmRpbmdUaWxkZUluUGF0aF07CiB9CiAKLXN0YXRpYyB2b2lkIHNldERlZmF1 bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGluZygpCisvLyBDYWxsZWQgYmVmb3JlIGVhY2gg dGVzdC4KK3N0YXRpYyB2b2lkIHJlc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoKQogewog ICAgIC8vIEdpdmUgc29tZSBjbGVhciB0byB1bmRvY3VtZW50ZWQgZGVmYXVsdHMgdmFsdWVzCiAg ICAgc3RhdGljIGNvbnN0IGludCBOb0ZvbnRTbW9vdGhpbmcgPSAwOwpAQCAtMzc4LDEyICszNzks NiBAQCBzdGF0aWMgdm9pZCBzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlc0ZvclRlc3Rpbmco KQogICAgIE5TU3RyaW5nICpwYXRoID0gbGlicmFyeVBhdGhGb3JEdW1wUmVuZGVyVHJlZSgpOwog ICAgIFtkZWZhdWx0cyBzZXRPYmplY3Q6W3BhdGggc3RyaW5nQnlBcHBlbmRpbmdQYXRoQ29tcG9u ZW50OkAiRGF0YWJhc2VzIl0gZm9yS2V5OldlYkRhdGFiYXNlRGlyZWN0b3J5RGVmYXVsdHNLZXld OwogICAgIFtkZWZhdWx0cyBzZXRPYmplY3Q6W3BhdGggc3RyaW5nQnlBcHBlbmRpbmdQYXRoQ29t cG9uZW50OkAiTG9jYWxDYWNoZSJdIGZvcktleTpXZWJLaXRMb2NhbENhY2hlRGVmYXVsdHNLZXld OwotICAgIE5TVVJMQ2FjaGUgKnNoYXJlZENhY2hlID0KLSAgICAgICAgW1tOU1VSTENhY2hlIGFs bG9jXSBpbml0V2l0aE1lbW9yeUNhcGFjaXR5OjEwMjQgKiAxMDI0Ci0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGRpc2tDYXBhY2l0eTowCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBkaXNrUGF0aDpbcGF0aCBzdHJpbmdCeUFwcGVuZGluZ1Bh dGhDb21wb25lbnQ6QCJVUkxDYWNoZSJdXTsKLSAgICBbTlNVUkxDYWNoZSBzZXRTaGFyZWRVUkxD YWNoZTpzaGFyZWRDYWNoZV07Ci0gICAgW3NoYXJlZENhY2hlIHJlbGVhc2VdOwogCiAgICAgV2Vi UHJlZmVyZW5jZXMgKnByZWZlcmVuY2VzID0gW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVy ZW5jZXNdOwogCkBAIC00MDQsMTEgKzM5OSwzOCBAQCBzdGF0aWMgdm9pZCBzZXREZWZhdWx0c1Rv Q29uc2lzdGVudFZhbHVlc0ZvclRlc3RpbmcoKQogICAgIFtwcmVmZXJlbmNlcyBzZXRTaG91bGRQ cmludEJhY2tncm91bmRzOllFU107CiAgICAgW3ByZWZlcmVuY2VzIHNldENhY2hlTW9kZWw6V2Vi Q2FjaGVNb2RlbERvY3VtZW50QnJvd3Nlcl07CiAKKyAgICBbcHJlZmVyZW5jZXMgc2V0UHJpdmF0 ZUJyb3dzaW5nRW5hYmxlZDpOT107CisgICAgW3ByZWZlcmVuY2VzIHNldEF1dGhvckFuZFVzZXJT dHlsZXNFbmFibGVkOllFU107CisgICAgW3ByZWZlcmVuY2VzIHNldEphdmFTY3JpcHRDYW5PcGVu V2luZG93c0F1dG9tYXRpY2FsbHk6WUVTXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0T2ZmbGluZVdl YkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVkOllFU107CisgICAgW3ByZWZlcmVuY2VzIHNldERldmVs b3BlckV4dHJhc0VuYWJsZWQ6Tk9dOworICAgIFtwcmVmZXJlbmNlcyBzZXRYU1NBdWRpdG9yRW5h YmxlZDpOT107CisgICAgaWYgKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKSB7Cisg ICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uOltOU1VSTCBVUkxX aXRoU3RyaW5nOihOU1N0cmluZyAqKShwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbi5n ZXQoKSldXTsKKyAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZDpZ RVNdOworICAgIH0gZWxzZQorICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRF bmFibGVkOk5PXTsKKwogICAgIC8vIFRoZSBiYWNrL2ZvcndhcmQgY2FjaGUgaXMgY2F1c2luZyBw cm9ibGVtcyBkdWUgdG8gbGF5b3V0cyBkdXJpbmcgdHJhbnNpdGlvbiBmcm9tIG9uZSBwYWdlIHRv IGFub3RoZXIuCiAgICAgLy8gU28sIHR1cm4gaXQgb2ZmIGZvciBub3csIGJ1dCB3ZSBtaWdodCB3 YW50IHRvIHR1cm4gaXQgYmFjayBvbiBzb21lIGRheS4KICAgICBbcHJlZmVyZW5jZXMgc2V0VXNl c1BhZ2VDYWNoZTpOT107CiB9CiAKKy8vIENhbGxlZCBvbmNlIG9uIER1bXBSZW5kZXJUcmVlIHN0 YXJ0dXAuCitzdGF0aWMgdm9pZCBzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlc0ZvclRlc3Rp bmcoKQoreworICAgIHJlc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoKTsKKworICAgIE5T U3RyaW5nICpwYXRoID0gbGlicmFyeVBhdGhGb3JEdW1wUmVuZGVyVHJlZSgpOworICAgIE5TVVJM Q2FjaGUgKnNoYXJlZENhY2hlID0KKyAgICAgICAgW1tOU1VSTENhY2hlIGFsbG9jXSBpbml0V2l0 aE1lbW9yeUNhcGFjaXR5OjEwMjQgKiAxMDI0CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGRpc2tDYXBhY2l0eTowCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBkaXNrUGF0aDpbcGF0aCBzdHJpbmdCeUFwcGVuZGluZ1BhdGhDb21wb25lbnQ6 QCJVUkxDYWNoZSJdXTsKKyAgICBbTlNVUkxDYWNoZSBzZXRTaGFyZWRVUkxDYWNoZTpzaGFyZWRD YWNoZV07CisgICAgW3NoYXJlZENhY2hlIHJlbGVhc2VdOworCit9CisKIHN0YXRpYyB2b2lkIGNy YXNoSGFuZGxlcihpbnQgc2lnKQogewogICAgIGNoYXIgKnNpZ25hbE5hbWUgPSBzdHJzaWduYWwo c2lnKTsKQEAgLTEwNDUsMTkgKzEwNjcsNyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0Nv bnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogICAgIFt3ZWJWaWV3IF9jbGVhck1haW5GcmFt ZU5hbWVdOwogICAgIFtbd2ViVmlldyB1bmRvTWFuYWdlcl0gcmVtb3ZlQWxsQWN0aW9uc107CiAK LSAgICBXZWJQcmVmZXJlbmNlcyAqcHJlZmVyZW5jZXMgPSBbd2ViVmlldyBwcmVmZXJlbmNlc107 Ci0gICAgW3ByZWZlcmVuY2VzIHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOwotICAgIFtw cmVmZXJlbmNlcyBzZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOwotICAgIFtwcmVm ZXJlbmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107Ci0g ICAgW3ByZWZlcmVuY2VzIHNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZDpZRVNd OwotICAgIFtwcmVmZXJlbmNlcyBzZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkOk5PXTsKLSAgICBb cHJlZmVyZW5jZXMgc2V0WFNTQXVkaXRvckVuYWJsZWQ6Tk9dOwotCi0gICAgaWYgKHBlcnNpc3Rl bnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKSB7Ci0gICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2Vy U3R5bGVTaGVldExvY2F0aW9uOltOU1VSTCBVUkxXaXRoU3RyaW5nOihOU1N0cmluZyAqKShwZXJz aXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbi5nZXQoKSldXTsKLSAgICAgICAgW3ByZWZlcmVu Y2VzIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZDpZRVNdOwotICAgIH0gZWxzZQotICAgICAgICBb cHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkOk5PXTsKKyAgICByZXNldERlZmF1 bHRzVG9Db25zaXN0ZW50VmFsdWVzKCk7CiAKICAgICBbW21haW5GcmFtZSB3ZWJWaWV3XSBzZXRT bWFydEluc2VydERlbGV0ZUVuYWJsZWQ6WUVTXTsKICAgICBbW1ttYWluRnJhbWUgd2ViVmlld10g aW5zcGVjdG9yXSBzZXRKYXZhU2NyaXB0UHJvZmlsaW5nRW5hYmxlZDpOT107CmRpZmYgLS1naXQg YS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJNYWMu bW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdENvbnRyb2xsZXJN YWMubW0KaW5kZXggNTA3NzEzNi4uODA3ZmNiNSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCisrKyBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQpAQCAtMjgx LDYgKzI4MSwxNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpkaXNwYXRjaFBlbmRpbmdM b2FkUmVxdWVzdHMoKQogICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIF9kaXNwYXRjaFBlbmRpbmdM b2FkUmVxdWVzdHNdOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlkZVBy ZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKQoreworICAgIFJldGFp blB0cjxDRlN0cmluZ1JlZj4ga2V5Q0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NG QWxsb2NhdG9yRGVmYXVsdCwga2V5KSk7CisgICAgTlNTdHJpbmcgKmtleU5TID0gKE5TU3RyaW5n ICopa2V5Q0YuZ2V0KCk7CisKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGZsYWdDRihBZG9w dENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBmbGFnKSk7Cisg ICAgTlNTdHJpbmcgKmZsYWdOUyA9IChOU1N0cmluZyAqKWZsYWdDRi5nZXQoKTsKKworICAgIFtb V2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc10gX3NldFByZWZlcmVuY2U6a2V5TlMg c3RyaW5nVmFsdWU6ZmxhZ05TXTsKK30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 UGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYganNVUkwpCiB7CiAg ICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwgSlNTdHJpbmdDb3B5 Q0ZTdHJpbmcoMCwganNVUkwpKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93 aW4vRHVtcFJlbmRlclRyZWUuY3BwCmluZGV4IDY2MjY2YjkuLjI3OTI3MzQgMTAwNjQ0Ci0tLSBh L1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIv V2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtNjcz LDggKzY3MywxNyBAQCBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJl Zm9yZVRlc3RpbmcoKQogICAgICAgICB3ZWJJQkFjdGlvbnMtPnJlc2V0UGFnZVpvb20oMCk7CiAg ICAgfQogCisKICAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKICAgICBp ZiAoU1VDQ0VFREVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKSB7CisKKyAg ICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gbmV3UHJlZmVyZW5jZXM7CisgICAgICAgIGlm IChTVUNDRUVERUQocHJlZmVyZW5jZXMtPnN0YW5kYXJkUHJlZmVyZW5jZXMoJm5ld1ByZWZlcmVu Y2VzKSkpIHsKKyAgICAgICAgICAgIHByZWZlcmVuY2VzLnJlbGVhc2VSZWYoKTsKKyAgICAgICAg ICAgIHdlYlZpZXctPnNldFByZWZlcmVuY2VzKG5ld1ByZWZlcmVuY2VzLmdldCgpKTsKKyAgICAg ICAgICAgIHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcyk7CisgICAgICAgIH0KKyAg ICAgICAgcHJlZmVyZW5jZXMtPnNldEF1dG9zYXZlcyhGQUxTRSk7CiAgICAgICAgIHByZWZlcmVu Y2VzLT5zZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkKEZBTFNFKTsKICAgICAgICAgcHJlZmVyZW5j ZXMtPnNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHkoVFJVRSk7CiAKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJv bGxlcldpbi5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENv bnRyb2xsZXJXaW4uY3BwCmluZGV4IGU1ZDIzZTEuLjYyMDZiMmQgMTAwNjQ0Ci0tLSBhL1dlYktp dFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKKysr IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2lu LmNwcApAQCAtNjk0LDYgKzY5NCwyNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpjbGVh ckFsbERhdGFiYXNlcygpCiAgICAgZGF0YWJhc2VNYW5hZ2VyLT5kZWxldGVBbGxEYXRhYmFzZXMo KTsKIH0KIAordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpT U3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+ IHdlYlZpZXc7CisgICAgaWYgKEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAg ICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsK KyAgICBpZiAoRkFJTEVEKHdlYlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAg ICAgICByZXR1cm47CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQ cml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisgICAg ICAgIHJldHVybjsKKworICAgIEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5KTsK KyAgICBCU1RSIGZsYWdCU1RSID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVmc1By aXZhdGUtPnNldFByZWZlcmVuY2Uoa2V5QlNUUiwgZmxhZ0JTVFIpOworICAgIFN5c0ZyZWVTdHJp bmcoa2V5QlNUUik7CisgICAgU3lzRnJlZVN0cmluZyhmbGFnQlNUUik7Cit9CisKIHZvaWQgTGF5 b3V0VGVzdENvbnRyb2xsZXI6OnNldERhdGFiYXNlUXVvdGEodW5zaWduZWQgbG9uZyBsb25nIHF1 b3RhKQogewogICAgIHByaW50ZigiRVJST1I6IExheW91dFRlc3RDb250cm9sbGVyOjpzZXREYXRh YmFzZVF1b3RhKCkgbm90IGltcGxlbWVudGVkXG4iKTsK 33495 2009-07-25 13:34:08 -0700 2009-07-30 23:27:12 -0700 Hopefully the final cut. patch.txt text/plain 24497 dimich ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiM2YxMGRiLi5mYmI0MTgxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMDktMDct MjIgIERtaXRyeSBUaXRvdiA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbGx5IGltcGxlbWVudGVkIGJ5 IEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AY2hyb21pdW0ub3JnPi4KKworICAgICAgICBBZGRlZCB0 ZXN0cyB0byB2ZXJpZnkgdGhhdCBkZWZhdWx0IHByZWZlcmVuY2VzIGNhbiBiZSBvdmVycmlkZGVu IHBlci10ZXN0CisgICAgICAgIGFuZCB0aGF0IG92ZXJyaWRkZW4gdmFsdWVzIGFyZSByZXNldCBi ZXR3ZWVuIGVhY2ggdGVzdC4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMtMi1leHBlY3RlZC50eHQ6CisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMtMi5odG1sOiBWZXJpZmllcyBvdmVycmlkZVByZXZlcmVuY2UoIldlYktpdERlZmF1bHRG b250U2l6ZSIsICIyNCIpCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMt ZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0 bWw6IFZlcmlmaWVzIG92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJsZWQi LCBmYWxzZSkuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbDogQmVjYXVz ZSBvZiAnenp6JyB0aGlzIHRlc3Qgd2lsbCBydW4gYWZ0ZXIgdGhlIHRlc3RzIGFib3ZlIGFuZAor ICAgICAgICB2ZXJpZnkgdGhhdCBvdmVycmlkZSBvZiBwcmVmZXJlbmNlcyBkb2VzIG5vdCAnc3Bp bGwnIHRvIHRoZSBzdWJzZXF1ZW50IHRlc3RzIGluIGEgYmF0Y2guCisKIDIwMDktMDctMjQgIE1h cmsgUm93ZSAgPG1yb3dlQGFwcGxlLmNvbT4KIAogICAgICAgICBTa2lwIGEgdGVzdCB0aGF0IGlz IGZhaWxpbmcgaW50ZXJtaXR0ZW50bHkgb24gdGhlIFdpbmRvd3MgYnVpbGQgYm90LgpkaWZmIC0t Z2l0IGEvV2ViS2l0L21hYy9DaGFuZ2VMb2cgYi9XZWJLaXQvbWFjL0NoYW5nZUxvZwppbmRleCBh YWQwZmQxLi43MzE5YWM0IDEwMDY0NAotLS0gYS9XZWJLaXQvbWFjL0NoYW5nZUxvZworKysgYi9X ZWJLaXQvbWFjL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDA5LTA3LTI1ICBEbWl0cnkg VGl0b3YgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWxseSBpbXBsZW1lbnRlZCBieSBHbGVubiBXaWxz b24gPGd3aWxzb25AY2hyb21pdW0ub3JnPi4KKworICAgICAgICBBZGRlZCBuZXcgbWV0aG9kcyBm b3Igb3ZlcnJpZGluZyBkZWZhdWx0IFdlYlByZWZlcmVuY2UgdmFsdWVzCisgICAgICAgIGFuZCBm b3IgcmVzZXR0aW5nIHByZWZlcmVuY2VzIHRvIHRoZWlyIGRlZmF1bHRzLgorICAgICAgICBTZWUg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAg KiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tOgorICAgICAgICAoLVtXZWJQcmVmZXJlbmNlcyBf c2V0UHJlZmVyZW5jZTpmbGFnOl0pOiBhZGQgX3NldFByZWZlcmVuY2UKKyAgICAgICAgKiBXZWJW aWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oOiBzYW1lLgorCiAyMDA5LTA3LTI0ICBEYXJpbiBB ZGxlciAgPGRhcmluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBNYXJrIFJvd2Uu CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0gYi9XZWJL aXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0KaW5kZXggMzc4YjI4MC4uNGQ1MzU3ZSAx MDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCisrKyBiL1dl YktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlcy5tbQpAQCAtMTE1Miw2ICsxMTUyLDEzIEBA IHN0YXRpYyBOU1N0cmluZyAqY2xhc3NJQkNyZWF0b3JJRCA9IG5pbDsKIHsKICAgICArK19wcml2 YXRlLT5udW1XZWJWaWV3czsKIH0KKworLSAodm9pZClfc2V0UHJlZmVyZW5jZTooTlNTdHJpbmcg KilrZXkgc3RyaW5nVmFsdWU6KE5TU3RyaW5nICopdmFsdWUKK3sKKyAgICBOU1N0cmluZyAqX2tl eSA9IEtFWShrZXkpOworICAgIFtzZWxmIF9zZXRTdHJpbmdWYWx1ZTp2YWx1ZSBmb3JLZXk6X2tl eV07CQorfQorCiBAZW5kCiAKIEBpbXBsZW1lbnRhdGlvbiBXZWJQcmVmZXJlbmNlcyAoV2ViSW50 ZXJuYWwpCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKaW5kZXgg ZDU3MTg2OS4uNjZkY2FlOCAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZl cmVuY2VzUHJpdmF0ZS5oCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1By aXZhdGUuaApAQCAtMTE3LDYgKzExNywxMCBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZlcmVu Y2VzUmVtb3ZlZE5vdGlmaWNhdGlvbjsKIC0gKFdlYlRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVz aW9uQmVoYXZpb3IpdGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcjsKIC0gKHZv aWQpc2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcjooV2ViVGV4dERpcmVj dGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciliZWhhdmlvcjsKIAorLy8gVGhpcyBtZXRob2Qg aXMgbWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorLy8gd2l0 aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorLSAodm9pZClfc2V0UHJlZmVyZW5jZTooTlNTdHJpbmcg KilrZXkgc3RyaW5nVmFsdWU6KE5TU3RyaW5nICopdmFsdWU7CisKIC8vIElmIHNpdGUtc3BlY2lm aWMgc3Bvb2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGluYXBwcm9wcmlhdGUg dXNlci1hZ2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBhIG5vbnN0YW5kYXJk IHVzZXItYWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVjdGx5LiBUaGlzIG1l dGhvZCBtaWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4gdGhlcmUncyBubyBt b3JlIG5lZWQgZm9yIGl0LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cgYi9XZWJL aXQvd2luL0NoYW5nZUxvZwppbmRleCBmYWZiNjY0Li5jNTUzYjgzIDEwMDY0NAotLS0gYS9XZWJL aXQvd2luL0NoYW5nZUxvZworKysgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2 IEBACisyMDA5LTA3LTIyICBEbWl0cnkgVGl0b3YgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWxseSBp bXBsZW1lbnRlZCBieSBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4uCisKKyAg ICAgICAgQWRkZWQgc3VwcG9ydCBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0IHByZWZlcmVuY2VzIHBl ci10ZXN0LiAoYnVnIDIwNTM0KQorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAgKiBJbnRlcmZhY2VzL0lXZWJQcmVmZXJl bmNlc1ByaXZhdGUuaWRsOiBhZGRlZCBuZXcgbWV0aG9kIHNldFByZWZlcmVuY2UKKyAgICAgICAg KiBXZWJQcmVmZXJlbmNlcy5jcHA6IHNhbWUuCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuaDog c2FtZS4KKwogMjAwOS0wNy0yNCAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQHdlYmtpdC5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4KZGlmZiAtLWdpdCBhL1dlYktpdC93 aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbCBiL1dlYktpdC93aW4vSW50 ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAppbmRleCA1NjJhNzViLi43NzJlNGUy IDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0 ZS5pZGwKKysrIGIvV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUu aWRsCkBAIC03MCw2ICs3MCwxMCBAQCBpbnRlcmZhY2UgSVdlYlByZWZlcmVuY2VzUHJpdmF0ZSA6 IElVbmtub3duCiAgICAgSFJFU1VMVCBzZXRGb250U21vb3RoaW5nQ29udHJhc3QoW2luXSBmbG9h dCBjb250cmFzdCk7CiAgICAgSFJFU1VMVCBmb250U21vb3RoaW5nQ29udHJhc3QoW291dCwgcmV0 dmFsXSBmbG9hdCogY29udHJhc3QpOwogCisgICAgLy8gVGhpcyBtZXRob2QgaXMgbWVhbnQgZm9y IG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdpdGggRHVtcFJl bmRlclRyZWUgb25seS4KKyAgICBIUkVTVUxUIHNldFByZWZlcmVuY2UoW2luXSBCU1RSIGtleSwg W2luXSBCU1RSIHZhbHVlKTsKKwogICAgIEhSRVNVTFQgaXNXZWJTZWN1cml0eUVuYWJsZWQoW291 dCwgcmV0dmFsXSBCT09MKiBlbmFibGVkKTsKICAgICBIUkVTVUxUIHNldFdlYlNlY3VyaXR5RW5h YmxlZChbaW5dIEJPT0wgZW5hYmxlZCk7CiAKZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vV2ViUHJl ZmVyZW5jZXMuY3BwIGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAKaW5kZXggOGVhMDMx OS4uY2JmMjY1YyAxMDA2NDQKLS0tIGEvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAKKysr IGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAKQEAgLTEzMDEsNiArMTMwMSwxNyBAQCBI UkVTVUxUIFdlYlByZWZlcmVuY2VzOjp6b29tc1RleHRPbmx5KEJPT0wqIHpvb21zVGV4dE9ubHkp CiAgICAgcmV0dXJuIFNfT0s7CiB9CiAKK0hSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgV2ViUHJl ZmVyZW5jZXM6OnNldFByZWZlcmVuY2UoQlNUUiBrZXksIEJTVFIgdmFsdWUpCit7CisgICAgaWYg KCFTeXNTdHJpbmdMZW4oa2V5KSB8fCAhU3lzU3RyaW5nTGVuKHZhbHVlKSkKKyAgICAgICAgcmV0 dXJuIEVfRkFJTDsKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleVN0cmluZyhBZG9wdENG LCBDRlN0cmluZ0NyZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJlaW50ZXJwcmV0X2Nhc3Q8VW5pQ2hh cio+KGtleSksIFN5c1N0cmluZ0xlbihrZXkpKSk7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVm PiB2YWx1ZVN0cmluZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJl aW50ZXJwcmV0X2Nhc3Q8VW5pQ2hhcio+KHZhbHVlKSwgU3lzU3RyaW5nTGVuKHZhbHVlKSkpOwor ICAgIHNldFZhbHVlRm9yS2V5KGtleVN0cmluZy5nZXQoKSwgdmFsdWVTdHJpbmcuZ2V0KCkpOwor ICAgIHBvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb24oKTsKKyAgICByZXR1cm4gU19P SzsKK30KKwogdm9pZCBXZWJQcmVmZXJlbmNlczo6d2lsbEFkZFRvV2ViVmlldygpCiB7CiAgICAg KyttX251bVdlYlZpZXdzOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5o IGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCmluZGV4IDJmOTQzODIuLjQwYzE1NGMgMTAw NjQ0Ci0tLSBhL1dlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAorKysgYi9XZWJLaXQvd2luL1dl YlByZWZlcmVuY2VzLmgKQEAgLTM0MCwxMCArMzQwLDE2IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1 YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBmb250U21vb3RoaW5nQ29udHJhc3QoIAogICAg IC8qIFtyZXR2YWxdW291dF0gKi8gZmxvYXQqIGNvbnRyYXN0KTsKLSAgICAKKwogICAgIHZpcnR1 YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzZXRGb250U21vb3RoaW5nQ29udHJhc3QoIAog ICAgIC8qIFtpbl0gKi8gZmxvYXQgY29udHJhc3QpOwogCisgICAgLy8gVGhpcyBtZXRob2QgaXMg bWVhbnQgZm9yIG92ZXJyaWRpbmcgcHJlZmVyZW5jZXMgZm9yIHRlc3RzIHJ1bgorICAgIC8vIHdp dGggRHVtcFJlbmRlclRyZWUgb25seS4KKyAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FM TFRZUEUgc2V0UHJlZmVyZW5jZSgKKyAgICAgICAgLyogW2luXSAqLyBCU1RSIGtleSwKKyAgICAg ICAgLyogW2luXSAqLyBCU1RSIHZhbHVlKTsKKwogICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRI T0RDQUxMVFlQRSBpc1dlYlNlY3VyaXR5RW5hYmxlZCgKICAgICAvKiBbcmV0dmFsXVtvdXRdICov IEJPT0wqIGVuYWJsZWQpOwogCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9M YXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggOTc0N2FhMy4uMjgzNzFhNCAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCisr KyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcApA QCAtMzYwLDYgKzM2MCwyMiBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBpc0NvbW1hbmRFbmFibGVkQ2Fs bGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bgogICAgIHJldHVybiBK U1ZhbHVlTWFrZUJvb2xlYW4oY29udGV4dCwgY29udHJvbGxlci0+aXNDb21tYW5kRW5hYmxlZChu YW1lLmdldCgpKSk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG92ZXJyaWRlUHJlZmVyZW5jZUNh bGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmpl Y3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYg YXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBpZiAoYXJndW1lbnRD b3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5lZChjb250ZXh0KTsK KworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRvcHQsIEpTVmFsdWVUb1N0cmlu Z0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAgICBBU1NFUlQoISpl eGNlcHRpb24pOworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiB2YWx1ZShBZG9wdCwgSlNW YWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2VwdGlvbikpOworICAg IEFTU0VSVCghKmV4Y2VwdGlvbik7CisKKyAgICBMYXlvdXRUZXN0Q29udHJvbGxlciogY29udHJv bGxlciA9IHJlaW50ZXJwcmV0X2Nhc3Q8TGF5b3V0VGVzdENvbnRyb2xsZXIqPihKU09iamVjdEdl dFByaXZhdGUodGhpc09iamVjdCkpOworICAgIGNvbnRyb2xsZXItPm92ZXJyaWRlUHJlZmVyZW5j ZShrZXkuZ2V0KCksIHZhbHVlLmdldCgpKTsKKworICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVm aW5lZChjb250ZXh0KTsKK30KKwogc3RhdGljIEpTVmFsdWVSZWYga2VlcFdlYkhpc3RvcnlDYWxs YmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2JqZWN0 UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVmIGFy Z3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCiB7CiAgICAgLy8gSGFzIG1hYyBpbXBs ZW1lbnRhdGlvbgpAQCAtOTIyLDYgKzkzOCw3IEBAIEpTU3RhdGljRnVuY3Rpb24qIExheW91dFRl c3RDb250cm9sbGVyOjpzdGF0aWNGdW5jdGlvbnMoKQogICAgICAgICB7ICJrZWVwV2ViSGlzdG9y eSIsIGtlZXBXZWJIaXN0b3J5Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkg fCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibm90aWZ5RG9u ZSIsIG5vdGlmeURvbmVDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtK U1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJudW1iZXJPZkFjdGl2 ZUFuaW1hdGlvbnMiLCBudW1iZXJPZkFjdGl2ZUFuaW1hdGlvbnNDYWxsYmFjaywga0pTUHJvcGVy dHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAor ICAgICAgICB7ICJvdmVycmlkZVByZWZlcmVuY2UiLCBvdmVycmlkZVByZWZlcmVuY2VDYWxsYmFj aywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9u dERlbGV0ZSB9LAogICAgICAgICB7ICJwYXRoVG9Mb2NhbFJlc291cmNlIiwgcGF0aFRvTG9jYWxS ZXNvdXJjZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVy dHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgInBhdXNlQW5pbWF0aW9uQXRUaW1l T25FbGVtZW50V2l0aElkIiwgcGF1c2VBbmltYXRpb25BdFRpbWVPbkVsZW1lbnRXaXRoSWRDYWxs YmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRl RG9udERlbGV0ZSB9LAogICAgICAgICB7ICJwYXVzZVRyYW5zaXRpb25BdFRpbWVPbkVsZW1lbnRX aXRoSWQiLCBwYXVzZVRyYW5zaXRpb25BdFRpbWVPbkVsZW1lbnRXaXRoSWRDYWxsYmFjaywga0pT UHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtKU1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0 ZSB9LApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENv bnRyb2xsZXIuaCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9s bGVyLmgKaW5kZXggZjM3YjIyMS4uNGI2MjJiMyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaAorKysgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCkBAIC01Miw2ICs1Miw3IEBAIHB1Ymxp YzoKICAgICBib29sIGlzQ29tbWFuZEVuYWJsZWQoSlNTdHJpbmdSZWYgbmFtZSk7CiAgICAgdm9p ZCBrZWVwV2ViSGlzdG9yeSgpOwogICAgIHZvaWQgbm90aWZ5RG9uZSgpOworICAgIHZvaWQgb3Zl cnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZyk7CiAgICAg SlNTdHJpbmdSZWYgcGF0aFRvTG9jYWxSZXNvdXJjZShKU0NvbnRleHRSZWYsIEpTU3RyaW5nUmVm IHVybCk7CiAgICAgdm9pZCBxdWV1ZUJhY2tOYXZpZ2F0aW9uKGludCBob3dGYXJCYWNrd2FyZCk7 CiAgICAgdm9pZCBxdWV1ZUZvcndhcmROYXZpZ2F0aW9uKGludCBob3dGYXJGb3J3YXJkKTsKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5t bSBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRl eCA4NzJhZDc5Li5jYmYwNTY3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS9tYWMvRHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0R1bXBSZW5kZXJUcmVlLm1tCkBAIC0zNDksNyArMzQ5LDggQEAgc3RhdGljIE5TU3RyaW5n ICpsaWJyYXJ5UGF0aEZvckR1bXBSZW5kZXJUcmVlKCkKICAgICByZXR1cm4gW0Aifi9MaWJyYXJ5 L0FwcGxpY2F0aW9uIFN1cHBvcnQvRHVtcFJlbmRlclRyZWUiIHN0cmluZ0J5RXhwYW5kaW5nVGls ZGVJblBhdGhdOwogfQogCi1zdGF0aWMgdm9pZCBzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVl c0ZvclRlc3RpbmcoKQorLy8gQ2FsbGVkIGJlZm9yZSBlYWNoIHRlc3QuCitzdGF0aWMgdm9pZCBy ZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKCkKIHsKICAgICAvLyBHaXZlIHNvbWUgY2xl YXIgdG8gdW5kb2N1bWVudGVkIGRlZmF1bHRzIHZhbHVlcwogICAgIHN0YXRpYyBjb25zdCBpbnQg Tm9Gb250U21vb3RoaW5nID0gMDsKQEAgLTM3OSwxMiArMzgwLDYgQEAgc3RhdGljIHZvaWQgc2V0 RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKCkKICAgICBOU1N0cmluZyAqcGF0 aCA9IGxpYnJhcnlQYXRoRm9yRHVtcFJlbmRlclRyZWUoKTsKICAgICBbZGVmYXVsdHMgc2V0T2Jq ZWN0OltwYXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpAIkRhdGFiYXNlcyJdIGZv cktleTpXZWJEYXRhYmFzZURpcmVjdG9yeURlZmF1bHRzS2V5XTsKICAgICBbZGVmYXVsdHMgc2V0 T2JqZWN0OltwYXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpAIkxvY2FsQ2FjaGUi XSBmb3JLZXk6V2ViS2l0TG9jYWxDYWNoZURlZmF1bHRzS2V5XTsKLSAgICBOU1VSTENhY2hlICpz aGFyZWRDYWNoZSA9Ci0gICAgICAgIFtbTlNVUkxDYWNoZSBhbGxvY10gaW5pdFdpdGhNZW1vcnlD YXBhY2l0eToxMDI0ICogMTAyNAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBkaXNrQ2FwYWNpdHk6MAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgZGlza1BhdGg6W3BhdGggc3RyaW5nQnlBcHBlbmRpbmdQYXRoQ29tcG9uZW50OkAiVVJMQ2Fj aGUiXV07Ci0gICAgW05TVVJMQ2FjaGUgc2V0U2hhcmVkVVJMQ2FjaGU6c2hhcmVkQ2FjaGVdOwot ICAgIFtzaGFyZWRDYWNoZSByZWxlYXNlXTsKIAogICAgIFdlYlByZWZlcmVuY2VzICpwcmVmZXJl bmNlcyA9IFtXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXTsKIApAQCAtNDA2LDEx ICs0MDEsMzggQEAgc3RhdGljIHZvaWQgc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JU ZXN0aW5nKCkKICAgICBbcHJlZmVyZW5jZXMgc2V0Q2FjaGVNb2RlbDpXZWJDYWNoZU1vZGVsRG9j dW1lbnRCcm93c2VyXTsKICAgICBbcHJlZmVyZW5jZXMgc2V0WFNTQXVkaXRvckVuYWJsZWQ6Tk9d OwogCisgICAgW3ByZWZlcmVuY2VzIHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOworICAg IFtwcmVmZXJlbmNlcyBzZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOworICAgIFtw cmVmZXJlbmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107 CisgICAgW3ByZWZlcmVuY2VzIHNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZDpZ RVNdOworICAgIFtwcmVmZXJlbmNlcyBzZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkOk5PXTsKKyAg ICBbcHJlZmVyZW5jZXMgc2V0WFNTQXVkaXRvckVuYWJsZWQ6Tk9dOworICAgIGlmIChwZXJzaXN0 ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbikgeworICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNl clN0eWxlU2hlZXRMb2NhdGlvbjpbTlNVUkwgVVJMV2l0aFN0cmluZzooTlNTdHJpbmcgKikocGVy c2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpXV07CisgICAgICAgIFtwcmVmZXJl bmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQ6WUVTXTsKKyAgICB9IGVsc2UKKyAgICAgICAg W3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZDpOT107CisKICAgICAvLyBUaGUg YmFjay9mb3J3YXJkIGNhY2hlIGlzIGNhdXNpbmcgcHJvYmxlbXMgZHVlIHRvIGxheW91dHMgZHVy aW5nIHRyYW5zaXRpb24gZnJvbSBvbmUgcGFnZSB0byBhbm90aGVyLgogICAgIC8vIFNvLCB0dXJu IGl0IG9mZiBmb3Igbm93LCBidXQgd2UgbWlnaHQgd2FudCB0byB0dXJuIGl0IGJhY2sgb24gc29t ZSBkYXkuCiAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXNQYWdlQ2FjaGU6Tk9dOwogfQogCisvLyBD YWxsZWQgb25jZSBvbiBEdW1wUmVuZGVyVHJlZSBzdGFydHVwLgorc3RhdGljIHZvaWQgc2V0RGVm YXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKCkKK3sKKyAgICByZXNldERlZmF1bHRz VG9Db25zaXN0ZW50VmFsdWVzKCk7CisKKyAgICBOU1N0cmluZyAqcGF0aCA9IGxpYnJhcnlQYXRo Rm9yRHVtcFJlbmRlclRyZWUoKTsKKyAgICBOU1VSTENhY2hlICpzaGFyZWRDYWNoZSA9CisgICAg ICAgIFtbTlNVUkxDYWNoZSBhbGxvY10gaW5pdFdpdGhNZW1vcnlDYXBhY2l0eToxMDI0ICogMTAy NAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNrQ2FwYWNpdHk6MAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlza1BhdGg6W3BhdGgg c3RyaW5nQnlBcHBlbmRpbmdQYXRoQ29tcG9uZW50OkAiVVJMQ2FjaGUiXV07CisgICAgW05TVVJM Q2FjaGUgc2V0U2hhcmVkVVJMQ2FjaGU6c2hhcmVkQ2FjaGVdOworICAgIFtzaGFyZWRDYWNoZSBy ZWxlYXNlXTsKKworfQorCiBzdGF0aWMgdm9pZCBjcmFzaEhhbmRsZXIoaW50IHNpZykKIHsKICAg ICBjaGFyICpzaWduYWxOYW1lID0gc3Ryc2lnbmFsKHNpZyk7CkBAIC0xMDQ3LDE5ICsxMDY5LDcg QEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5n KCkKICAgICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1lXTsKICAgICBbW3dlYlZpZXcgdW5k b01hbmFnZXJdIHJlbW92ZUFsbEFjdGlvbnNdOwogCi0gICAgV2ViUHJlZmVyZW5jZXMgKnByZWZl cmVuY2VzID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOwotICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2 YXRlQnJvd3NpbmdFbmFibGVkOk5PXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNl clN0eWxlc0VuYWJsZWQ6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9w ZW5XaW5kb3dzQXV0b21hdGljYWxseTpZRVNdOwotICAgIFtwcmVmZXJlbmNlcyBzZXRPZmZsaW5l V2ViQXBwbGljYXRpb25DYWNoZUVuYWJsZWQ6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0RGV2 ZWxvcGVyRXh0cmFzRW5hYmxlZDpOT107Ci0gICAgW3ByZWZlcmVuY2VzIHNldFhTU0F1ZGl0b3JF bmFibGVkOk5PXTsKLQotICAgIGlmIChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbikg ewotICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjpbTlNVUkwg VVJMV2l0aFN0cmluZzooTlNTdHJpbmcgKikocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRp b24uZ2V0KCkpXV07Ci0gICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJs ZWQ6WUVTXTsKLSAgICB9IGVsc2UKLSAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNo ZWV0RW5hYmxlZDpOT107CisgICAgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpOwog CiAgICAgW1ttYWluRnJhbWUgd2ViVmlld10gc2V0U21hcnRJbnNlcnREZWxldGVFbmFibGVkOllF U107CiAgICAgW1tbbWFpbkZyYW1lIHdlYlZpZXddIGluc3BlY3Rvcl0gc2V0SmF2YVNjcmlwdFBy b2ZpbGluZ0VuYWJsZWQ6Tk9dOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvbWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IDg5YThiZmEuLjY0NTc4 MjkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0 Q29udHJvbGxlck1hYy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KQEAgLTI4OCw2ICsyODgsMTcgQEAgdm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6ZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3RzKCkKICAgICBbW21haW5G cmFtZSB3ZWJWaWV3XSBfZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3RzXTsKIH0KIAordm9pZCBM YXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwg SlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleUNGKEFk b3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGtleSkpOwor ICAgIE5TU3RyaW5nICprZXlOUyA9IChOU1N0cmluZyAqKWtleUNGLmdldCgpOworCisgICAgUmV0 YWluUHRyPENGU3RyaW5nUmVmPiBmbGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmco a0NGQWxsb2NhdG9yRGVmYXVsdCwgZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNT dHJpbmcgKilmbGFnQ0YuZ2V0KCk7CisKKyAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJl ZmVyZW5jZXNdIF9zZXRQcmVmZXJlbmNlOmtleU5TIHN0cmluZ1ZhbHVlOmZsYWdOU107Cit9CisK IHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExv Y2F0aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQogewogICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4g dXJsU3RyaW5nKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5nKDAsIGpzVVJMKSk7CmRpZmYg LS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3Bw IGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcAppbmRl eCA2NjI2NmI5Li5hNGE2MmVmIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJl ZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVl L3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTY1Nyw2ICs2NTcsNzEgQEAgc3RhdGljIGJvb2wg c2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKGNvbnN0IGNoYXIqIHBhdGhPclVSTCkKICAgICBy ZXR1cm4gc3Ryc3RyKHBhdGhPclVSTCwgIi9sb2FkaW5nLyIpIHx8IHN0cnN0cihwYXRoT3JVUkws ICJcXGxvYWRpbmdcXCIpOwogfQogCitzdGF0aWMgdm9pZCByZXNldERlZmF1bHRzVG9Db25zaXN0 ZW50VmFsdWVzKElXZWJQcmVmZXJlbmNlcyogcHJlZmVyZW5jZXMpCit7CisjaWZkZWYgVVNFX01B Q19GT05UUworICAgIEJTVFIgc3RhbmRhcmRGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJU aW1lcyIpKTsKKyAgICBCU1RSIGZpeGVkRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQ291 cmllciIpKTsKKyAgICBCU1RSIHNhbnNTZXJpZkZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQo IkhlbHZldGljYSIpKTsKKyAgICBCU1RSIGN1cnNpdmVGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhU RVhUKCJBcHBsZSBDaGFuY2VyeSIpKTsKKyAgICBCU1RSIGZhbnRhc3lGYW1pbHkgPSBTeXNBbGxv Y1N0cmluZyhURVhUKCJQYXB5cnVzIikpOworI2Vsc2UKKyAgICBCU1RSIHN0YW5kYXJkRmFtaWx5 ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMgTmV3IFJvbWFuIikpOworICAgIEJTVFIgZml4 ZWRGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJDb3VyaWVyIE5ldyIpKTsKKyAgICBCU1RS IHNhbnNTZXJpZkZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkFyaWFsIikpOworICAgIEJT VFIgY3Vyc2l2ZUZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkNvbWljIFNhbnMgTVMiKSk7 IC8vIE5vdCBhY3R1YWxseSBjdXJzaXZlLCBidXQgaXQncyB3aGF0IElFIGFuZCBGaXJlZm94IHVz ZS4KKyAgICBCU1RSIGZhbnRhc3lGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJUaW1lcyBO ZXcgUm9tYW4iKSk7CisjZW5kaWYKKworICAgIHByZWZlcmVuY2VzLT5zZXRTdGFuZGFyZEZvbnRG YW1pbHkoc3RhbmRhcmRGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRGaXhlZEZvbnRGYW1p bHkoZml4ZWRGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRTZXJpZkZvbnRGYW1pbHkoc3Rh bmRhcmRGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRTYW5zU2VyaWZGb250RmFtaWx5KHNh bnNTZXJpZkZhbWlseSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEN1cnNpdmVGb250RmFtaWx5KGN1 cnNpdmVGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRGYW50YXN5Rm9udEZhbWlseShmYW50 YXN5RmFtaWx5KTsKKworICAgIFN5c0ZyZWVTdHJpbmcoc3RhbmRhcmRGYW1pbHkpOworICAgIFN5 c0ZyZWVTdHJpbmcoZml4ZWRGYW1pbHkpOworICAgIFN5c0ZyZWVTdHJpbmcoc2Fuc1NlcmlmRmFt aWx5KTsKKyAgICBTeXNGcmVlU3RyaW5nKGN1cnNpdmVGYW1pbHkpOworICAgIFN5c0ZyZWVTdHJp bmcoZmFudGFzeUZhbWlseSk7CisKKyAgICBwcmVmZXJlbmNlcy0+c2V0QXV0b3NhdmVzKEZBTFNF KTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0RGVmYXVsdEZvbnRTaXplKDE2KTsKKyAgICBwcmVmZXJl bmNlcy0+c2V0RGVmYXVsdEZpeGVkRm9udFNpemUoMTMpOworICAgIHByZWZlcmVuY2VzLT5zZXRN aW5pbXVtRm9udFNpemUoMSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEphdmFFbmFibGVkKEZBTFNF KTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0UGx1Z0luc0VuYWJsZWQoVFJVRSk7CisgICAgcHJlZmVy ZW5jZXMtPnNldERPTVBhc3RlQWxsb3dlZChUUlVFKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0RWRp dGFibGVMaW5rQmVoYXZpb3IoV2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRLZXkp OworICAgIHByZWZlcmVuY2VzLT5zZXRGb250U21vb3RoaW5nKEZvbnRTbW9vdGhpbmdUeXBlU3Rh bmRhcmQpOworICAgIHByZWZlcmVuY2VzLT5zZXRVc2VzUGFnZUNhY2hlKEZBTFNFKTsKKyAgICBw cmVmZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZChGQUxTRSk7CisgICAgcHJlZmVy ZW5jZXMtPnNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHkoVFJVRSk7Cisg ICAgcHJlZmVyZW5jZXMtPnNldEphdmFTY3JpcHRFbmFibGVkKFRSVUUpOworICAgIHByZWZlcmVu Y2VzLT5zZXRUYWJzVG9MaW5rcyhGQUxTRSk7CisgICAgcHJlZmVyZW5jZXMtPnNldFNob3VsZFBy aW50QmFja2dyb3VuZHMoVFJVRSk7CisKKyAgICBpZiAocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0 TG9jYXRpb24pIHsKKyAgICAgICAgVmVjdG9yPHdjaGFyX3Q+IHVybENoYXJhY3RlcnMoQ0ZTdHJp bmdHZXRMZW5ndGgocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpKTsKKyAg ICAgICAgQ0ZTdHJpbmdHZXRDaGFyYWN0ZXJzKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0 aW9uLmdldCgpLCBDRlJhbmdlTWFrZSgwLCBDRlN0cmluZ0dldExlbmd0aChwZXJzaXN0ZW50VXNl clN0eWxlU2hlZXRMb2NhdGlvbi5nZXQoKSkpLCAoVW5pQ2hhciAqKXVybENoYXJhY3RlcnMuZGF0 YSgpKTsKKyAgICAgICAgQlNUUiB1cmwgPSBTeXNBbGxvY1N0cmluZ0xlbih1cmxDaGFyYWN0ZXJz LmRhdGEoKSwgdXJsQ2hhcmFjdGVycy5zaXplKCkpOworICAgICAgICBwcmVmZXJlbmNlcy0+c2V0 VXNlclN0eWxlU2hlZXRMb2NhdGlvbih1cmwpOworICAgICAgICBTeXNGcmVlU3RyaW5nKHVybCk7 CisgICAgICAgIHByZWZlcmVuY2VzLT5zZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQoVFJVRSk7Cisg ICAgfSBlbHNlCisgICAgICAgIHByZWZlcmVuY2VzLT5zZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQo RkFMU0UpOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0 ZShRdWVyeSwgcHJlZmVyZW5jZXMpOworICAgIGlmIChwcmVmc1ByaXZhdGUpIHsKKyAgICAgICAg cHJlZnNQcml2YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZChUUlVFKTsKKyAgICAg ICAgcHJlZnNQcml2YXRlLT5zZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkKEZBTFNFKTsKKyAgICAg ICAgcHJlZnNQcml2YXRlLT5zZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKEZBTFNFKTsgLy8g RklYTUUgLSBuZWVkIHRvIG1ha2UgRFJUIHBhc3Mgd2l0aCBXaW5kb3dzIG5hdGl2ZSBjb250cm9s cyA8aHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1OTI+CisgICAgICAg IHByZWZzUHJpdmF0ZS0+c2V0WFNTQXVkaXRvckVuYWJsZWQoRkFMU0UpOworICAgICAgICBwcmVm c1ByaXZhdGUtPnNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZChGQUxTRSk7Cisg ICAgfQorfQorCiBzdGF0aWMgdm9pZCByZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9y ZVRlc3RpbmcoKQogewogICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKQEAgLTY3MywyOCAr NzM4LDEwIEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZygpCiAgICAgICAgIHdlYklCQWN0aW9ucy0+cmVzZXRQYWdlWm9vbSgwKTsKICAgICB9 CiAKKwogICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOwogICAgIGlmIChT VUNDRUVERUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpIHsKLSAgICAgICAg cHJlZmVyZW5jZXMtPnNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQoRkFMU0UpOwotICAgICAgICBw cmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxseShUUlVF KTsKLQotICAgICAgICBpZiAocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24pIHsKLSAg ICAgICAgICAgIFZlY3Rvcjx3Y2hhcl90PiB1cmxDaGFyYWN0ZXJzKENGU3RyaW5nR2V0TGVuZ3Ro KHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uLmdldCgpKSk7Ci0gICAgICAgICAgICBD RlN0cmluZ0dldENoYXJhY3RlcnMocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0 KCksIENGUmFuZ2VNYWtlKDAsIENGU3RyaW5nR2V0TGVuZ3RoKHBlcnNpc3RlbnRVc2VyU3R5bGVT aGVldExvY2F0aW9uLmdldCgpKSksIChVbmlDaGFyICopdXJsQ2hhcmFjdGVycy5kYXRhKCkpOwot ICAgICAgICAgICAgQlNUUiB1cmwgPSBTeXNBbGxvY1N0cmluZ0xlbih1cmxDaGFyYWN0ZXJzLmRh dGEoKSwgdXJsQ2hhcmFjdGVycy5zaXplKCkpOwotICAgICAgICAgICAgcHJlZmVyZW5jZXMtPnNl dFVzZXJTdHlsZVNoZWV0TG9jYXRpb24odXJsKTsKLSAgICAgICAgICAgIFN5c0ZyZWVTdHJpbmco dXJsKTsKLSAgICAgICAgICAgIHByZWZlcmVuY2VzLT5zZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQo VFJVRSk7Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJT dHlsZVNoZWV0RW5hYmxlZChGQUxTRSk7Ci0KLSAgICAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNl c1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOwotICAgICAgICBpZiAo cHJlZnNQcml2YXRlKSB7Ci0gICAgICAgICAgICBwcmVmc1ByaXZhdGUtPnNldEF1dGhvckFuZFVz ZXJTdHlsZXNFbmFibGVkKFRSVUUpOwotICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5zZXREZXZl bG9wZXJFeHRyYXNFbmFibGVkKEZBTFNFKTsKLSAgICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0 U2hvdWxkUGFpbnROYXRpdmVDb250cm9scyhGQUxTRSk7IC8vIEZJWE1FIC0gbmVlZCB0byBtYWtl IERSVCBwYXNzIHdpdGggV2luZG93cyBuYXRpdmUgY29udHJvbHMgPGh0dHA6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTkyPgotICAgICAgICAgICAgcHJlZnNQcml2YXRlLT5z ZXRYU1NBdWRpdG9yRW5hYmxlZChGQUxTRSk7Ci0gICAgICAgIH0KKyAgICAgICAgcHJlZmVyZW5j ZXMtPnJlc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoKTsKICAgICB9CiAKICAgICBDT01Q dHI8SVdlYlZpZXdFZGl0aW5nPiB2aWV3RWRpdGluZzsKQEAgLTgyOSw0NCArODc2LDYgQEAgZXhp dDoKICAgICByZXR1cm47CiB9CiAKLXN0YXRpYyB2b2lkIGluaXRpYWxpemVQcmVmZXJlbmNlcyhJ V2ViUHJlZmVyZW5jZXMqIHByZWZlcmVuY2VzKQotewotI2lmZGVmIFVTRV9NQUNfRk9OVFMKLSAg ICBCU1RSIHN0YW5kYXJkRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMiKSk7Ci0g ICAgQlNUUiBmaXhlZEZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkNvdXJpZXIiKSk7Ci0g ICAgQlNUUiBzYW5zU2VyaWZGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJIZWx2ZXRpY2Ei KSk7Ci0gICAgQlNUUiBjdXJzaXZlRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQXBwbGUg Q2hhbmNlcnkiKSk7Ci0gICAgQlNUUiBmYW50YXN5RmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVY VCgiUGFweXJ1cyIpKTsKLSNlbHNlCi0gICAgQlNUUiBzdGFuZGFyZEZhbWlseSA9IFN5c0FsbG9j U3RyaW5nKFRFWFQoIlRpbWVzIE5ldyBSb21hbiIpKTsKLSAgICBCU1RSIGZpeGVkRmFtaWx5ID0g U3lzQWxsb2NTdHJpbmcoVEVYVCgiQ291cmllciBOZXciKSk7Ci0gICAgQlNUUiBzYW5zU2VyaWZG YW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJBcmlhbCIpKTsKLSAgICBCU1RSIGN1cnNpdmVG YW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJDb21pYyBTYW5zIE1TIikpOyAvLyBOb3QgYWN0 dWFsbHkgY3Vyc2l2ZSwgYnV0IGl0J3Mgd2hhdCBJRSBhbmQgRmlyZWZveCB1c2UuCi0gICAgQlNU UiBmYW50YXN5RmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMgTmV3IFJvbWFuIikp OwotI2VuZGlmCi0KLSAgICBwcmVmZXJlbmNlcy0+c2V0U3RhbmRhcmRGb250RmFtaWx5KHN0YW5k YXJkRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0Rml4ZWRGb250RmFtaWx5KGZpeGVkRmFt aWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0U2VyaWZGb250RmFtaWx5KHN0YW5kYXJkRmFtaWx5 KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0U2Fuc1NlcmlmRm9udEZhbWlseShzYW5zU2VyaWZGYW1p bHkpOwotICAgIHByZWZlcmVuY2VzLT5zZXRDdXJzaXZlRm9udEZhbWlseShjdXJzaXZlRmFtaWx5 KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0RmFudGFzeUZvbnRGYW1pbHkoZmFudGFzeUZhbWlseSk7 Ci0KLSAgICBwcmVmZXJlbmNlcy0+c2V0QXV0b3NhdmVzKEZBTFNFKTsKLSAgICBwcmVmZXJlbmNl cy0+c2V0SmF2YUVuYWJsZWQoRkFMU0UpOwotICAgIHByZWZlcmVuY2VzLT5zZXRQbHVnSW5zRW5h YmxlZChUUlVFKTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0RE9NUGFzdGVBbGxvd2VkKFRSVUUpOwot ICAgIHByZWZlcmVuY2VzLT5zZXRFZGl0YWJsZUxpbmtCZWhhdmlvcihXZWJLaXRFZGl0YWJsZUxp bmtPbmx5TGl2ZVdpdGhTaGlmdEtleSk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldEZvbnRTbW9vdGhp bmcoRm9udFNtb290aGluZ1R5cGVTdGFuZGFyZCk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldFVzZXNQ YWdlQ2FjaGUoRkFMU0UpOwotCi0gICAgU3lzRnJlZVN0cmluZyhzdGFuZGFyZEZhbWlseSk7Ci0g ICAgU3lzRnJlZVN0cmluZyhmaXhlZEZhbWlseSk7Ci0gICAgU3lzRnJlZVN0cmluZyhzYW5zU2Vy aWZGYW1pbHkpOwotICAgIFN5c0ZyZWVTdHJpbmcoY3Vyc2l2ZUZhbWlseSk7Ci0gICAgU3lzRnJl ZVN0cmluZyhmYW50YXN5RmFtaWx5KTsKLX0KLQogc3RhdGljIEJvb2xlYW4gcHRocmVhZEVxdWFs Q2FsbGJhY2soY29uc3Qgdm9pZCogdmFsdWUxLCBjb25zdCB2b2lkKiB2YWx1ZTIpCiB7CiAgICAg cmV0dXJuIChCb29sZWFuKXB0aHJlYWRfZXF1YWwoKihwdGhyZWFkX3QqKXZhbHVlMSwgKihwdGhy ZWFkX3QqKXZhbHVlMik7CkBAIC0xMDUxLDEyICsxMDYwLDYgQEAgSVdlYlZpZXcqIGNyZWF0ZVdl YlZpZXdBbmRPZmZzY3JlZW5XaW5kb3coSFdORCogd2ViVmlld1dpbmRvdykKICAgICBpZiAoRkFJ TEVEKHdlYlZpZXctPnNldFJlc291cmNlTG9hZERlbGVnYXRlKHNoYXJlZFJlc291cmNlTG9hZERl bGVnYXRlLmdldCgpKSkpCiAgICAgICAgIHJldHVybiAwOwogCi0gICAgQ09NUHRyPElXZWJQcmVm ZXJlbmNlcz4gcHJlZmVyZW5jZXM7Ci0gICAgaWYgKEZBSUxFRCh3ZWJWaWV3LT5wcmVmZXJlbmNl cygmcHJlZmVyZW5jZXMpKSkKLSAgICAgICAgcmV0dXJuIDA7Ci0KLSAgICBpbml0aWFsaXplUHJl ZmVyZW5jZXMocHJlZmVyZW5jZXMuZ2V0KCkpOwotCiAgICAgb3BlbldpbmRvd3MoKS5hcHBlbmQo aG9zdFdpbmRvdyk7CiAgICAgd2luZG93VG9XZWJWaWV3TWFwKCkuc2V0KGhvc3RXaW5kb3csIHdl YlZpZXcpOwogICAgIHJldHVybiB3ZWJWaWV3OwpAQCAtMTEyNCwxOCArMTEyNyw2IEBAIGludCBt YWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiAgICAgc2hhcmVkRWRpdGluZ0RlbGVnYXRlLmFk b3B0UmVmKG5ldyBFZGl0aW5nRGVsZWdhdGUpOwogICAgIHNoYXJlZFJlc291cmNlTG9hZERlbGVn YXRlLmFkb3B0UmVmKG5ldyBSZXNvdXJjZUxvYWREZWxlZ2F0ZSk7CiAKLSAgICAvLyBGSVhNRSAt IG5lZWQgdG8gbWFrZSBEUlQgcGFzcyB3aXRoIFdpbmRvd3MgbmF0aXZlIGNvbnRyb2xzIDxodHRw Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTU5Mj4KLSAgICBDT01QdHI8SVdl YlByZWZlcmVuY2VzPiB0bXBQcmVmZXJlbmNlczsKLSAgICBpZiAoRkFJTEVEKFdlYktpdENyZWF0 ZUluc3RhbmNlKENMU0lEX1dlYlByZWZlcmVuY2VzLCAwLCBJSURfSVdlYlByZWZlcmVuY2VzLCBy ZWludGVycHJldF9jYXN0PHZvaWQqKj4oJnRtcFByZWZlcmVuY2VzKSkpKQotICAgICAgICByZXR1 cm4gLTE7Ci0gICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gc3RhbmRhcmRQcmVmZXJlbmNlczsK LSAgICBpZiAoRkFJTEVEKHRtcFByZWZlcmVuY2VzLT5zdGFuZGFyZFByZWZlcmVuY2VzKCZzdGFu ZGFyZFByZWZlcmVuY2VzKSkpCi0gICAgICAgIHJldHVybiAtMTsKLSAgICBDT01QdHI8SVdlYlBy ZWZlcmVuY2VzUHJpdmF0ZT4gc3RhbmRhcmRQcmVmZXJlbmNlc1ByaXZhdGU7Ci0gICAgaWYgKEZB SUxFRChzdGFuZGFyZFByZWZlcmVuY2VzLT5RdWVyeUludGVyZmFjZSgmc3RhbmRhcmRQcmVmZXJl bmNlc1ByaXZhdGUpKSkKLSAgICAgICAgcmV0dXJuIC0xOwotICAgIHN0YW5kYXJkUHJlZmVyZW5j ZXNQcml2YXRlLT5zZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKEZBTFNFKTsKLQogICAgIENP TVB0cjxJV2ViVmlldz4gd2ViVmlldyhBZG9wdENPTSwgY3JlYXRlV2ViVmlld0FuZE9mZnNjcmVl bldpbmRvdygmd2ViVmlld1dpbmRvdykpOwogICAgIGlmICghd2ViVmlldykKICAgICAgICAgcmV0 dXJuIC0xOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91 dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9M YXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggODFjMjc1MS4uODI5NzhlOSAxMDA2NDQK LS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVy V2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENv bnRyb2xsZXJXaW4uY3BwCkBAIC02OTQsNiArNjk0LDI3IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6OmNsZWFyQWxsRGF0YWJhc2VzKCkKICAgICBkYXRhYmFzZU1hbmFnZXItPmRlbGV0ZUFs bERhdGFiYXNlcygpOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlkZVBy ZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKQoreworICAgIENPTVB0 cjxJV2ViVmlldz4gd2ViVmlldzsKKyAgICBpZiAoRkFJTEVEKGZyYW1lLT53ZWJWaWV3KCZ3ZWJW aWV3KSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHBy ZWZlcmVuY2VzOworICAgIGlmIChGQUlMRUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVu Y2VzKSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXNQcml2 YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKKyAgICBpZiAoIXByZWZzUHJp dmF0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQlNUUiBrZXlCU1RSID0gSlNTdHJpbmdDb3B5 QlNUUihrZXkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBKU1N0cmluZ0NvcHlCU1RSKGZsYWcpOwor ICAgIHByZWZzUHJpdmF0ZS0+c2V0UHJlZmVyZW5jZShrZXlCU1RSLCBmbGFnQlNUUik7CisgICAg U3lzRnJlZVN0cmluZyhrZXlCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGZsYWdCU1RSKTsKK30K Kwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0YWJhc2VRdW90YSh1bnNpZ25lZCBs b25nIGxvbmcgcXVvdGEpCiB7CiAgICAgcHJpbnRmKCJFUlJPUjogTGF5b3V0VGVzdENvbnRyb2xs ZXI6OnNldERhdGFiYXNlUXVvdGEoKSBub3QgaW1wbGVtZW50ZWRcbiIpOwo= 33859 2009-07-30 23:27:12 -0700 2009-08-03 12:04:43 -0700 Patch with changes after review patch.txt text/plain 28351 dimich ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBiYmFiZmJlLi4xZDE2NGRkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMDktMDct MjIgIERtaXRyeSBUaXRvdiA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbGx5IGltcGxlbWVudGVkIGJ5 IEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AY2hyb21pdW0ub3JnPi4KKworICAgICAgICBBZGRlZCB0 ZXN0cyB0byB2ZXJpZnkgdGhhdCBkZWZhdWx0IHByZWZlcmVuY2VzIGNhbiBiZSBvdmVycmlkZGVu IHBlci10ZXN0CisgICAgICAgIGFuZCB0aGF0IG92ZXJyaWRkZW4gdmFsdWVzIGFyZSByZXNldCBi ZXR3ZWVuIGVhY2ggdGVzdC4KKyAgICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDUzNAorCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMtMi1leHBlY3RlZC50eHQ6CisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVy ZW5jZXMtMi5odG1sOiBWZXJpZmllcyBvdmVycmlkZVByZXZlcmVuY2UoIldlYktpdERlZmF1bHRG b250U2l6ZSIsICIyNCIpCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtcHJlZmVyZW5jZXMt ZXhwZWN0ZWQudHh0OgorICAgICAgICAqIHNlY3VyaXR5L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0 bWw6IFZlcmlmaWVzIG92ZXJyaWRlUHJlZmVyZW5jZSgiV2ViS2l0SmF2YVNjcmlwdEVuYWJsZWQi LCBmYWxzZSkuCisgICAgICAgICogc2VjdXJpdHkvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVk LnR4dDoKKyAgICAgICAgKiBzZWN1cml0eS9vdmVycmlkZS16enotcmVzZXQuaHRtbDogQmVjYXVz ZSBvZiAnenp6JyB0aGlzIHRlc3Qgd2lsbCBydW4gYWZ0ZXIgdGhlIHRlc3RzIGFib3ZlIGFuZAor ICAgICAgICB2ZXJpZnkgdGhhdCBvdmVycmlkZSBvZiBwcmVmZXJlbmNlcyBkb2VzIG5vdCAnc3Bp bGwnIHRvIHRoZSBzdWJzZXF1ZW50IHRlc3RzIGluIGEgYmF0Y2guCisKIDIwMDktMDctMzAgIEFk YW0gVHJlYXQgIDxhZGFtLnRyZWF0QHRvcmNobW9iaWxlLmNvbT4KIAogICAgICAgICBBZGQgZXhw ZWN0ZWQgcmVzdWx0cyBmaWxlIGZvciBuZXcgdGVzdC4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYmNjZWFhCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsMyBAQAorVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgbGF5b3V0 VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5jZXMgb3ZlcnJpZGVu LiBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2YWx1 ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiBZb3Ugc2hvdWxkIHNl ZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvaGFy bmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy0yLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5l c3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjIzMDU2ZjQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2hh cm5lc3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCkBAIC0wLDAgKzEsMTggQEAKKzxodG1s PgorPHNjcmlwdD4KKyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdERlZmF1bHRGb250U2l6ZSIsICIy NCIpOworICAgIH0KKzwvc2NyaXB0PgorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVz IHRoYXQgbGF5b3V0VGVzdENvbnRyb2xsZXIgY2FuIGhhdmUgaXRzIGRlZmF1bHQgcHJlZmVyZW5j ZXMgb3ZlcnJpZGVuLiAgCisgICAgVGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQgdGhlIEFQSSB3aWxs IGFjY2VwdCBzdHJpbmcgdmFsdWVzIGFuZCBhbHNvIG92ZXJyaWRlIHRoZSBkZWZhdWx0IGZvbnQg c2l6ZS4gIAorICAgIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy48L3A+CisgICAgPHNjcmlw dD4KKyAgICAgICAgdmFyIHAgPSBkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicCIpWzBd OworICAgICAgICBpZighd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyIHx8IHdpbmRvdy5nZXRD b21wdXRlZFN0eWxlKHApLmZvbnRTaXplID09ICIyNHB4IikKKyAgICAgICAgICAgIGRvY3VtZW50 LndyaXRlKCJQQVNTIik7CisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40YzM0OGUwCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXByZWZl cmVuY2VzLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDMgQEAKK1RoaXMgaXMgYSB0ZXN0IHRoYXQg dmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBw cmVmZXJlbmNlcyBvdmVycmlkZGVuLiBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNoZWNrcyB0aGF0 IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUgIlBBU1MiIGJl bG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuCisKK1BBU1MKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sIGIvTGF5b3V0VGVz dHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uNzQwYTczOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCkBAIC0wLDAgKzEsMTgg QEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCkK KyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKCJXZWJLaXRK YXZhU2NyaXB0RW5hYmxlZCIsIGZhbHNlKTsKKyAgICB9CisgICAgCisgICAgZnVuY3Rpb24gbG9h ZHN0YXR1cygpIHsKKyAgICAgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAg ICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iRkFJ TCI7CisgICAgfQorPC9zY3JpcHQ+IAorPGJvZHkgb25sb2FkPSJsb2Fkc3RhdHVzKCkiPgorICAg IDxwPlRoaXMgaXMgYSB0ZXN0IHRoYXQgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxl ciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZGVuLiAgVGhpcyB0ZXN0 IHNwZWNpZmljYWxseSBjaGVja3MgdGhhdCBKYXZhc2NyaXB0IGNhbiBiZSBkaXNhYmxlZCwgYW5k IHlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdyBpZiB2aWV3aW5nIHdpdGggYSBicm93c2VyLjwv cD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5QQVNTPC9zcGFuPgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXp6ei1yZXNldC1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6LXJlc2V0 LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZWUyOTJl Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXp6 ei1yZXNldC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMg dGhhdCB0aGUgbGF5b3V0VGVzdENvbnRyb2xsZXIgd2lsbCByZXNldCBpdHMgZGVmYXVsdCBwcmVm ZXJlbmNlcyBhZnRlciBldmVyeSBsYXlvdXQgdGVzdC4gWW91IHNob3VsZCBzZWUgIlBBU1MiIGJl bG93LgorCitQQVNTCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJp ZGUtenp6LXJlc2V0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6 LXJlc2V0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2JlYjFlMAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS16enot cmVzZXQuaHRtbApAQCAtMCwwICsxLDE0IEBACis8aHRtbD4gCis8Ym9keT4gCis8c2NyaXB0PiAK KyAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwvc2NyaXB0PiAKKzxib2R5PgorICAgIDxwPlRoaXMg dGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRUZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0 cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2ZXJ5IGxheW91dCB0ZXN0LiAgWW91IHNob3Vs ZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c3BhbiBpZD0ic3RhdHVzIj5GQUlMPC9zcGFu PgorICAgIDxzY3JpcHQ+CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGF0dXMi KS5pbm5lckhUTUw9IlBBU1MiOyAgICAgICAgCisgICAgPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0 bWw+CmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL0NoYW5nZUxvZyBiL1dlYktpdC9tYWMvQ2hhbmdl TG9nCmluZGV4IDM3Njc1ZjYuLjMyYTQxNWMgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvQ2hhbmdl TG9nCisrKyBiL1dlYktpdC9tYWMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDktMDct MjUgIERtaXRyeSBUaXRvdiA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbGx5IGltcGxlbWVudGVkIGJ5 IEdsZW5uIFdpbHNvbiA8Z3dpbHNvbkBjaHJvbWl1bS5vcmc+LgorCisgICAgICAgIEFkZGVkIG5l dyBtZXRob2RzIGZvciBvdmVycmlkaW5nIGRlZmF1bHQgV2ViUHJlZmVyZW5jZSB2YWx1ZXMKKyAg ICAgICAgYW5kIGZvciByZXNldHRpbmcgcHJlZmVyZW5jZXMgdG8gdGhlaXIgZGVmYXVsdHMuCisg ICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjA1MzQK KworICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW06CisgICAgICAgICgtW1dlYlBy ZWZlcmVuY2VzIF9zZXRQcmVmZXJlbmNlOmZsYWc6XSk6IGFkZCBfc2V0UHJlZmVyZW5jZQorICAg ICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmg6IHNhbWUuCisKIDIwMDktMDct MzAgIE1pY2hhZWwgTm9yZG1hbiAgPG1pY2hhZWxuQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2 aWV3ZWQgYnkgRGFyaW4gRmlzaGVyLgpkaWZmIC0tZ2l0IGEvV2ViS2l0L21hYy9XZWJWaWV3L1dl YlByZWZlcmVuY2VzLm1tIGIvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCmlu ZGV4IDM3OGIyODAuLmRhM2E2YzYgMTAwNjQ0Ci0tLSBhL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQ cmVmZXJlbmNlcy5tbQorKysgYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0K QEAgLTExNTIsNiArMTE1MiwxMiBAQCBzdGF0aWMgTlNTdHJpbmcgKmNsYXNzSUJDcmVhdG9ySUQg PSBuaWw7CiB7CiAgICAgKytfcHJpdmF0ZS0+bnVtV2ViVmlld3M7CiB9CisKKy0gKHZvaWQpX3Nl dFByZWZlcmVuY2VGb3JUZXN0V2l0aFZhbHVlOihOU1N0cmluZyAqKXZhbHVlIGZvcktleTooTlNT dHJpbmcgKilrZXkKK3sKKyAgICBbc2VsZiBfc2V0U3RyaW5nVmFsdWU6dmFsdWUgZm9yS2V5Omtl eV07CQorfQorCiBAZW5kCiAKIEBpbXBsZW1lbnRhdGlvbiBXZWJQcmVmZXJlbmNlcyAoV2ViSW50 ZXJuYWwpCmRpZmYgLS1naXQgYS9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2 YXRlLmggYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKaW5kZXgg ZDU3MTg2OS4uNzQwMGE3NyAxMDA2NDQKLS0tIGEvV2ViS2l0L21hYy9XZWJWaWV3L1dlYlByZWZl cmVuY2VzUHJpdmF0ZS5oCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNlc1By aXZhdGUuaApAQCAtMTE3LDYgKzExNywxMCBAQCBleHRlcm4gTlNTdHJpbmcgKldlYlByZWZlcmVu Y2VzUmVtb3ZlZE5vdGlmaWNhdGlvbjsKIC0gKFdlYlRleHREaXJlY3Rpb25TdWJtZW51SW5jbHVz aW9uQmVoYXZpb3IpdGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcjsKIC0gKHZv aWQpc2V0VGV4dERpcmVjdGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcjooV2ViVGV4dERpcmVj dGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvciliZWhhdmlvcjsKIAorLy8gVXNlZCB0byBzZXQg cHJlZmVyZW5jZSBzcGVjaWZpZWQgaW4gdGhlIHRlc3QgdmlhIExheW91dFRlc3RDb250cm9sbGVy Lm92ZXJyaWRlUHJlZmVyZW5jZSguLikuCisvLyBGb3IgdXNlIHdpdGggRHVtcFJlbmRlclRyZWUg b25seS4KKy0gKHZvaWQpX3NldFByZWZlcmVuY2VGb3JUZXN0V2l0aFZhbHVlOihOU1N0cmluZyAq KXZhbHVlIGZvcktleTooTlNTdHJpbmcgKilrZXk7CisKIC8vIElmIHNpdGUtc3BlY2lmaWMgc3Bv b2ZpbmcgaXMgZW5hYmxlZCwgc29tZSBwYWdlcyB0aGF0IGRvIGluYXBwcm9wcmlhdGUgdXNlci1h Z2VudCBzdHJpbmcgY2hlY2tzIHdpbGwgYmUKIC8vIHBhc3NlZCBhIG5vbnN0YW5kYXJkIHVzZXIt YWdlbnQgc3RyaW5nIHRvIGdldCB0aGVtIHRvIHdvcmsgY29ycmVjdGx5LiBUaGlzIG1ldGhvZCBt aWdodCBiZSByZW1vdmVkIGluCiAvLyB0aGUgZnV0dXJlIHdoZW4gdGhlcmUncyBubyBtb3JlIG5l ZWQgZm9yIGl0LgpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9DaGFuZ2VMb2cgYi9XZWJLaXQvd2lu L0NoYW5nZUxvZwppbmRleCA4YTY0YzJhLi40N2ZlMzNjIDEwMDY0NAotLS0gYS9XZWJLaXQvd2lu L0NoYW5nZUxvZworKysgYi9XZWJLaXQvd2luL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisy MDA5LTA3LTIyICBEbWl0cnkgVGl0b3YgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWxseSBpbXBsZW1l bnRlZCBieSBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4uCisKKyAgICAgICAg QWRkZWQgc3VwcG9ydCBmb3Igb3ZlcnJpZGluZyBkZWZhdWx0IHByZWZlcmVuY2VzIHBlci10ZXN0 LiAoYnVnIDIwNTM0KQorICAgICAgICBTZWUgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwNTM0CisKKyAgICAgICAgKiBJbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1By aXZhdGUuaWRsOiBhZGRlZCBuZXcgbWV0aG9kIHNldFByZWZlcmVuY2UKKyAgICAgICAgKiBXZWJQ cmVmZXJlbmNlcy5jcHA6IHNhbWUuCisgICAgICAgICogV2ViUHJlZmVyZW5jZXMuaDogc2FtZS4K KwogMjAwOS0wNy0yOSAgQnJpYW4gV2VpbnN0ZWluICA8YndlaW5zdGVpbkBhcHBsZS5jb20+CiAK ICAgICAgICAgV2FzIGRvaW5nIHRoZSBidWlsZCBmaXggd3JvbmcsIE5vdEltcGxlbWVudGVkLmgg aXMgaW4gV2ViQ29yZS4KZGlmZiAtLWdpdCBhL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJl ZmVyZW5jZXNQcml2YXRlLmlkbCBiL1dlYktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5j ZXNQcml2YXRlLmlkbAppbmRleCA1NjJhNzViLi5kMjZlNGU4IDEwMDY0NAotLS0gYS9XZWJLaXQv d2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2VzUHJpdmF0ZS5pZGwKKysrIGIvV2ViS2l0L3dp bi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1ByaXZhdGUuaWRsCkBAIC03OCw0ICs3OCw4IEBA IGludGVyZmFjZSBJV2ViUHJlZmVyZW5jZXNQcml2YXRlIDogSVVua25vd24KIAogICAgIEhSRVNV TFQgaXNYU1NBdWRpdG9yRW5hYmxlZChbb3V0LCByZXR2YWxdIEJPT0wgKmVuYWJsZWQpOwogICAg IEhSRVNVTFQgc2V0WFNTQXVkaXRvckVuYWJsZWQoW2luXSBCT09MIGVuYWJsZWQpOworCisgICAg Ly8gVXNlZCB0byBzZXQgcHJlZmVyZW5jZSBzcGVjaWZpZWQgYnkgYSB0ZXN0IHZpYSBMYXlvdXRU ZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoLi4pLgorICAgIC8vIFVzZWQgYnkgRHVt cFJlbmRlclRyZWUuCisgICAgSFJFU1VMVCBzZXRQcmVmZXJlbmNlRm9yVGVzdChbaW5dIEJTVFIg a2V5LCBbaW5dIEJTVFIgdmFsdWUpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJQcmVm ZXJlbmNlcy5jcHAgYi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAppbmRleCA4ZWEwMzE5 Li4xZTE1ODAwIDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcAorKysg Yi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNwcApAQCAtMTMwMSw2ICsxMzAxLDE3IEBAIEhS RVNVTFQgV2ViUHJlZmVyZW5jZXM6Onpvb21zVGV4dE9ubHkoQk9PTCogem9vbXNUZXh0T25seSkK ICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VMVCBXZWJQcmVmZXJlbmNlczo6c2V0UHJlZmVy ZW5jZUZvclRlc3QoQlNUUiBrZXksIEJTVFIgdmFsdWUpCit7CisgICAgaWYgKCFTeXNTdHJpbmdM ZW4oa2V5KSB8fCAhU3lzU3RyaW5nTGVuKHZhbHVlKSkKKyAgICAgICAgcmV0dXJuIEVfRkFJTDsK KyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleVN0cmluZyhBZG9wdENGLCBDRlN0cmluZ0Ny ZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJlaW50ZXJwcmV0X2Nhc3Q8VW5pQ2hhcio+KGtleSksIFN5 c1N0cmluZ0xlbihrZXkpKSk7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiB2YWx1ZVN0cmlu ZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJlaW50ZXJwcmV0X2Nh c3Q8VW5pQ2hhcio+KHZhbHVlKSwgU3lzU3RyaW5nTGVuKHZhbHVlKSkpOworICAgIHNldFZhbHVl Rm9yS2V5KGtleVN0cmluZy5nZXQoKSwgdmFsdWVTdHJpbmcuZ2V0KCkpOworICAgIHBvc3RQcmVm ZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb24oKTsKKyAgICByZXR1cm4gU19PSzsKK30KKwogdm9p ZCBXZWJQcmVmZXJlbmNlczo6d2lsbEFkZFRvV2ViVmlldygpCiB7CiAgICAgKyttX251bVdlYlZp ZXdzOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oIGIvV2ViS2l0L3dp bi9XZWJQcmVmZXJlbmNlcy5oCmluZGV4IDJmOTQzODIuLjA0MzIyMDUgMTAwNjQ0Ci0tLSBhL1dl YktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAorKysgYi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2Vz LmgKQEAgLTM0MCw3ICszNDAsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RE TUVUSE9EQ0FMTFRZUEUgZm9udFNtb290aGluZ0NvbnRyYXN0KCAKICAgICAvKiBbcmV0dmFsXVtv dXRdICovIGZsb2F0KiBjb250cmFzdCk7Ci0gICAgCisKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RE TUVUSE9EQ0FMTFRZUEUgc2V0Rm9udFNtb290aGluZ0NvbnRyYXN0KCAKICAgICAvKiBbaW5dICov IGZsb2F0IGNvbnRyYXN0KTsKIApAQCAtMzYyLDYgKzM2MiwxMSBAQCBwdWJsaWM6CiAgICAgdmly dHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBFIHNldFhTU0F1ZGl0b3JFbmFibGVkKAogICAg IC8qIFtpbl0gKi8gQk9PTCBlbmFibGVkKTsKIAorICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRI T0RDQUxMVFlQRSBzZXRQcmVmZXJlbmNlRm9yVGVzdCgKKyAgICAvKiBbaW5dICovIEJTVFIga2V5 LAorICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7CisKKwogICAgIC8vIFdlYlByZWZlcmVuY2Vz CiAKICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3NlcyBhIGRpZmZlcmVudCBwcmVmZXJlbmNlIGtl eSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9E dW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAgYi9XZWJLaXRUb29scy9EdW1w UmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggOTc0N2FhMy4uZTc1YTdj YiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRy b2xsZXIuY3BwCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcApAQCAtMzYwLDYgKzM2MCwyMiBAQCBzdGF0aWMgSlNWYWx1ZVJlZiBpc0NvbW1h bmRFbmFibGVkQ2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bgog ICAgIHJldHVybiBKU1ZhbHVlTWFrZUJvb2xlYW4oY29udGV4dCwgY29udHJvbGxlci0+aXNDb21t YW5kRW5hYmxlZChuYW1lLmdldCgpKSk7CiB9CiAKK3N0YXRpYyBKU1ZhbHVlUmVmIG92ZXJyaWRl UHJlZmVyZW5jZUNhbGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5j dGlvbiwgSlNPYmplY3RSZWYgdGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0 IEpTVmFsdWVSZWYgYXJndW1lbnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKK3sKKyAgICBp ZiAoYXJndW1lbnRDb3VudCA8IDIpCisgICAgICAgIHJldHVybiBKU1ZhbHVlTWFrZVVuZGVmaW5l ZChjb250ZXh0KTsKKworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiBrZXkoQWRvcHQsIEpT VmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzBdLCBleGNlcHRpb24pKTsKKyAg ICBBU1NFUlQoISpleGNlcHRpb24pOworICAgIEpTUmV0YWluUHRyPEpTU3RyaW5nUmVmPiB2YWx1 ZShBZG9wdCwgSlNWYWx1ZVRvU3RyaW5nQ29weShjb250ZXh0LCBhcmd1bWVudHNbMV0sIGV4Y2Vw dGlvbikpOworICAgIEFTU0VSVCghKmV4Y2VwdGlvbik7CisKKyAgICBMYXlvdXRUZXN0Q29udHJv bGxlciogY29udHJvbGxlciA9IHN0YXRpY19jYXN0PExheW91dFRlc3RDb250cm9sbGVyKj4oSlNP YmplY3RHZXRQcml2YXRlKHRoaXNPYmplY3QpKTsKKyAgICBjb250cm9sbGVyLT5vdmVycmlkZVBy ZWZlcmVuY2Uoa2V5LmdldCgpLCB2YWx1ZS5nZXQoKSk7CisKKyAgICByZXR1cm4gSlNWYWx1ZU1h a2VVbmRlZmluZWQoY29udGV4dCk7Cit9CisKIHN0YXRpYyBKU1ZhbHVlUmVmIGtlZXBXZWJIaXN0 b3J5Q2FsbGJhY2soSlNDb250ZXh0UmVmIGNvbnRleHQsIEpTT2JqZWN0UmVmIGZ1bmN0aW9uLCBK U09iamVjdFJlZiB0aGlzT2JqZWN0LCBzaXplX3QgYXJndW1lbnRDb3VudCwgY29uc3QgSlNWYWx1 ZVJlZiBhcmd1bWVudHNbXSwgSlNWYWx1ZVJlZiogZXhjZXB0aW9uKQogewogICAgIC8vIEhhcyBt YWMgaW1wbGVtZW50YXRpb24KQEAgLTkyMiw2ICs5MzgsNyBAQCBKU1N0YXRpY0Z1bmN0aW9uKiBM YXlvdXRUZXN0Q29udHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKCkKICAgICAgICAgeyAia2VlcFdl Ykhpc3RvcnkiLCBrZWVwV2ViSGlzdG9yeUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJl YWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm5v dGlmeURvbmUiLCBub3RpZnlEb25lQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9u bHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAibnVtYmVy T2ZBY3RpdmVBbmltYXRpb25zIiwgbnVtYmVyT2ZBY3RpdmVBbmltYXRpb25zQ2FsbGJhY2ssIGtK U1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURvbnREZWxl dGUgfSwKKyAgICAgICAgeyAib3ZlcnJpZGVQcmVmZXJlbmNlIiwgb3ZlcnJpZGVQcmVmZXJlbmNl Q2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJp YnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicGF0aFRvTG9jYWxSZXNvdXJjZSIsIHBhdGhU b0xvY2FsUmVzb3VyY2VDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtK U1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJwYXVzZUFuaW1hdGlv bkF0VGltZU9uRWxlbWVudFdpdGhJZCIsIHBhdXNlQW5pbWF0aW9uQXRUaW1lT25FbGVtZW50V2l0 aElkQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicGF1c2VUcmFuc2l0aW9uQXRUaW1lT25F bGVtZW50V2l0aElkIiwgcGF1c2VUcmFuc2l0aW9uQXRUaW1lT25FbGVtZW50V2l0aElkQ2FsbGJh Y2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZURv bnREZWxldGUgfSwKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91 dFRlc3RDb250cm9sbGVyLmggYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0 Q29udHJvbGxlci5oCmluZGV4IGYzN2IyMjEuLjRiNjIyYjMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuaApAQCAtNTIsNiArNTIsNyBA QCBwdWJsaWM6CiAgICAgYm9vbCBpc0NvbW1hbmRFbmFibGVkKEpTU3RyaW5nUmVmIG5hbWUpOwog ICAgIHZvaWQga2VlcFdlYkhpc3RvcnkoKTsKICAgICB2b2lkIG5vdGlmeURvbmUoKTsKKyAgICB2 b2lkIG92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcp OwogICAgIEpTU3RyaW5nUmVmIHBhdGhUb0xvY2FsUmVzb3VyY2UoSlNDb250ZXh0UmVmLCBKU1N0 cmluZ1JlZiB1cmwpOwogICAgIHZvaWQgcXVldWVCYWNrTmF2aWdhdGlvbihpbnQgaG93RmFyQmFj a3dhcmQpOwogICAgIHZvaWQgcXVldWVGb3J3YXJkTmF2aWdhdGlvbihpbnQgaG93RmFyRm9yd2Fy ZCk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRl clRyZWUubW0gYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUu bW0KaW5kZXggODcyYWQ3OS4uY2JmMDU2NyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJl bmRlclRyZWUvbWFjL0R1bXBSZW5kZXJUcmVlLm1tCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQpAQCAtMzQ5LDcgKzM0OSw4IEBAIHN0YXRpYyBO U1N0cmluZyAqbGlicmFyeVBhdGhGb3JEdW1wUmVuZGVyVHJlZSgpCiAgICAgcmV0dXJuIFtAIn4v TGlicmFyeS9BcHBsaWNhdGlvbiBTdXBwb3J0L0R1bXBSZW5kZXJUcmVlIiBzdHJpbmdCeUV4cGFu ZGluZ1RpbGRlSW5QYXRoXTsKIH0KIAotc3RhdGljIHZvaWQgc2V0RGVmYXVsdHNUb0NvbnNpc3Rl bnRWYWx1ZXNGb3JUZXN0aW5nKCkKKy8vIENhbGxlZCBiZWZvcmUgZWFjaCB0ZXN0Lgorc3RhdGlj IHZvaWQgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpCiB7CiAgICAgLy8gR2l2ZSBz b21lIGNsZWFyIHRvIHVuZG9jdW1lbnRlZCBkZWZhdWx0cyB2YWx1ZXMKICAgICBzdGF0aWMgY29u c3QgaW50IE5vRm9udFNtb290aGluZyA9IDA7CkBAIC0zNzksMTIgKzM4MCw2IEBAIHN0YXRpYyB2 b2lkIHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGluZygpCiAgICAgTlNTdHJp bmcgKnBhdGggPSBsaWJyYXJ5UGF0aEZvckR1bXBSZW5kZXJUcmVlKCk7CiAgICAgW2RlZmF1bHRz IHNldE9iamVjdDpbcGF0aCBzdHJpbmdCeUFwcGVuZGluZ1BhdGhDb21wb25lbnQ6QCJEYXRhYmFz ZXMiXSBmb3JLZXk6V2ViRGF0YWJhc2VEaXJlY3RvcnlEZWZhdWx0c0tleV07CiAgICAgW2RlZmF1 bHRzIHNldE9iamVjdDpbcGF0aCBzdHJpbmdCeUFwcGVuZGluZ1BhdGhDb21wb25lbnQ6QCJMb2Nh bENhY2hlIl0gZm9yS2V5OldlYktpdExvY2FsQ2FjaGVEZWZhdWx0c0tleV07Ci0gICAgTlNVUkxD YWNoZSAqc2hhcmVkQ2FjaGUgPQotICAgICAgICBbW05TVVJMQ2FjaGUgYWxsb2NdIGluaXRXaXRo TWVtb3J5Q2FwYWNpdHk6MTAyNCAqIDEwMjQKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZGlza0NhcGFjaXR5OjAKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGRpc2tQYXRoOltwYXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpA IlVSTENhY2hlIl1dOwotICAgIFtOU1VSTENhY2hlIHNldFNoYXJlZFVSTENhY2hlOnNoYXJlZENh Y2hlXTsKLSAgICBbc2hhcmVkQ2FjaGUgcmVsZWFzZV07CiAKICAgICBXZWJQcmVmZXJlbmNlcyAq cHJlZmVyZW5jZXMgPSBbV2ViUHJlZmVyZW5jZXMgc3RhbmRhcmRQcmVmZXJlbmNlc107CiAKQEAg LTQwNiwxMSArNDAxLDM4IEBAIHN0YXRpYyB2b2lkIHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFs dWVzRm9yVGVzdGluZygpCiAgICAgW3ByZWZlcmVuY2VzIHNldENhY2hlTW9kZWw6V2ViQ2FjaGVN b2RlbERvY3VtZW50QnJvd3Nlcl07CiAgICAgW3ByZWZlcmVuY2VzIHNldFhTU0F1ZGl0b3JFbmFi bGVkOk5PXTsKIAorICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkOk5P XTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQ6WUVTXTsK KyAgICBbcHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxs eTpZRVNdOworICAgIFtwcmVmZXJlbmNlcyBzZXRPZmZsaW5lV2ViQXBwbGljYXRpb25DYWNoZUVu YWJsZWQ6WUVTXTsKKyAgICBbcHJlZmVyZW5jZXMgc2V0RGV2ZWxvcGVyRXh0cmFzRW5hYmxlZDpO T107CisgICAgW3ByZWZlcmVuY2VzIHNldFhTU0F1ZGl0b3JFbmFibGVkOk5PXTsKKyAgICBpZiAo cGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24pIHsKKyAgICAgICAgW3ByZWZlcmVuY2Vz IHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb246W05TVVJMIFVSTFdpdGhTdHJpbmc6KE5TU3RyaW5n ICopKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uLmdldCgpKV1dOworICAgICAgICBb cHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRFbmFibGVkOllFU107CisgICAgfSBlbHNlCisg ICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQ6Tk9dOworCiAgICAg Ly8gVGhlIGJhY2svZm9yd2FyZCBjYWNoZSBpcyBjYXVzaW5nIHByb2JsZW1zIGR1ZSB0byBsYXlv dXRzIGR1cmluZyB0cmFuc2l0aW9uIGZyb20gb25lIHBhZ2UgdG8gYW5vdGhlci4KICAgICAvLyBT bywgdHVybiBpdCBvZmYgZm9yIG5vdywgYnV0IHdlIG1pZ2h0IHdhbnQgdG8gdHVybiBpdCBiYWNr IG9uIHNvbWUgZGF5LgogICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VzUGFnZUNhY2hlOk5PXTsKIH0K IAorLy8gQ2FsbGVkIG9uY2Ugb24gRHVtcFJlbmRlclRyZWUgc3RhcnR1cC4KK3N0YXRpYyB2b2lk IHNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzRm9yVGVzdGluZygpCit7CisgICAgcmVzZXRE ZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpOworCisgICAgTlNTdHJpbmcgKnBhdGggPSBsaWJy YXJ5UGF0aEZvckR1bXBSZW5kZXJUcmVlKCk7CisgICAgTlNVUkxDYWNoZSAqc2hhcmVkQ2FjaGUg PQorICAgICAgICBbW05TVVJMQ2FjaGUgYWxsb2NdIGluaXRXaXRoTWVtb3J5Q2FwYWNpdHk6MTAy NCAqIDEwMjQKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlza0NhcGFj aXR5OjAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRpc2tQYXRo OltwYXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpAIlVSTENhY2hlIl1dOworICAg IFtOU1VSTENhY2hlIHNldFNoYXJlZFVSTENhY2hlOnNoYXJlZENhY2hlXTsKKyAgICBbc2hhcmVk Q2FjaGUgcmVsZWFzZV07CisKK30KKwogc3RhdGljIHZvaWQgY3Jhc2hIYW5kbGVyKGludCBzaWcp CiB7CiAgICAgY2hhciAqc2lnbmFsTmFtZSA9IHN0cnNpZ25hbChzaWcpOwpAQCAtMTA0NywxOSAr MTA2OSw3IEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVudFN0YXRlQmVmb3Jl VGVzdGluZygpCiAgICAgW3dlYlZpZXcgX2NsZWFyTWFpbkZyYW1lTmFtZV07CiAgICAgW1t3ZWJW aWV3IHVuZG9NYW5hZ2VyXSByZW1vdmVBbGxBY3Rpb25zXTsKIAotICAgIFdlYlByZWZlcmVuY2Vz ICpwcmVmZXJlbmNlcyA9IFt3ZWJWaWV3IHByZWZlcmVuY2VzXTsKLSAgICBbcHJlZmVyZW5jZXMg c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZDpOT107Ci0gICAgW3ByZWZlcmVuY2VzIHNldEF1dGhv ckFuZFVzZXJTdHlsZXNFbmFibGVkOllFU107Ci0gICAgW3ByZWZlcmVuY2VzIHNldEphdmFTY3Jp cHRDYW5PcGVuV2luZG93c0F1dG9tYXRpY2FsbHk6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0 T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVkOllFU107Ci0gICAgW3ByZWZlcmVuY2Vz IHNldERldmVsb3BlckV4dHJhc0VuYWJsZWQ6Tk9dOwotICAgIFtwcmVmZXJlbmNlcyBzZXRYU1NB dWRpdG9yRW5hYmxlZDpOT107Ci0KLSAgICBpZiAocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9j YXRpb24pIHsKLSAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb246 W05TVVJMIFVSTFdpdGhTdHJpbmc6KE5TU3RyaW5nICopKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVl dExvY2F0aW9uLmdldCgpKV1dOwotICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hl ZXRFbmFibGVkOllFU107Ci0gICAgfSBlbHNlCi0gICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2Vy U3R5bGVTaGVldEVuYWJsZWQ6Tk9dOworICAgIHJlc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1 ZXMoKTsKIAogICAgIFtbbWFpbkZyYW1lIHdlYlZpZXddIHNldFNtYXJ0SW5zZXJ0RGVsZXRlRW5h YmxlZDpZRVNdOwogICAgIFtbW21haW5GcmFtZSB3ZWJWaWV3XSBpbnNwZWN0b3JdIHNldEphdmFT Y3JpcHRQcm9maWxpbmdFbmFibGVkOk5PXTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbSBiL1dlYktpdFRvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJvbGxlck1hYy5tbQppbmRleCA4OWE4YmZh Li4yMzVmYzc2IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5 b3V0VGVzdENvbnRyb2xsZXJNYWMubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCkBAIC0yODgsNiArMjg4LDE3IEBAIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OmRpc3BhdGNoUGVuZGluZ0xvYWRSZXF1ZXN0cygpCiAgICAg W1ttYWluRnJhbWUgd2ViVmlld10gX2Rpc3BhdGNoUGVuZGluZ0xvYWRSZXF1ZXN0c107CiB9CiAK K3ZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1Jl ZiBrZXksIEpTU3RyaW5nUmVmIGZsYWcpCit7CisgICAgUmV0YWluUHRyPENGU3RyaW5nUmVmPiBr ZXlDRihBZG9wdENGLCBKU1N0cmluZ0NvcHlDRlN0cmluZyhrQ0ZBbGxvY2F0b3JEZWZhdWx0LCBr ZXkpKTsKKyAgICBOU1N0cmluZyAqa2V5TlMgPSAoTlNTdHJpbmcgKilrZXlDRi5nZXQoKTsKKwor ICAgIFJldGFpblB0cjxDRlN0cmluZ1JlZj4gZmxhZ0NGKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNG U3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGZsYWcpKTsKKyAgICBOU1N0cmluZyAqZmxhZ05T ID0gKE5TU3RyaW5nICopZmxhZ0NGLmdldCgpOworCisgICAgW1tXZWJQcmVmZXJlbmNlcyBzdGFu ZGFyZFByZWZlcmVuY2VzXSBfc2V0UHJlZmVyZW5jZUZvclRlc3RXaXRoVmFsdWU6ZmxhZ05TIGZv cktleTprZXlOU107Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldFBlcnNpc3Rl bnRVc2VyU3R5bGVTaGVldExvY2F0aW9uKEpTU3RyaW5nUmVmIGpzVVJMKQogewogICAgIFJldGFp blB0cjxDRlN0cmluZ1JlZj4gdXJsU3RyaW5nKEFkb3B0Q0YsIEpTU3RyaW5nQ29weUNGU3RyaW5n KDAsIGpzVVJMKSk7CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4v RHVtcFJlbmRlclRyZWUuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0R1bXBS ZW5kZXJUcmVlLmNwcAppbmRleCA2NjI2NmI5Li45NGMyODMwIDEwMDY0NAotLS0gYS9XZWJLaXRU b29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3BwCisrKyBiL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKQEAgLTY1Nyw2ICs2NTcs NjUgQEAgc3RhdGljIGJvb2wgc2hvdWxkTG9nRnJhbWVMb2FkRGVsZWdhdGVzKGNvbnN0IGNoYXIq IHBhdGhPclVSTCkKICAgICByZXR1cm4gc3Ryc3RyKHBhdGhPclVSTCwgIi9sb2FkaW5nLyIpIHx8 IHN0cnN0cihwYXRoT3JVUkwsICJcXGxvYWRpbmdcXCIpOwogfQogCitzdGF0aWMgdm9pZCByZXNl dERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKElXZWJQcmVmZXJlbmNlcyogcHJlZmVyZW5jZXMp Cit7CisjaWZkZWYgVVNFX01BQ19GT05UUworICAgIHN0YXRpYyBCU1RSIHN0YW5kYXJkRmFtaWx5 ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMiKSk7CisgICAgc3RhdGljIEJTVFIgZml4ZWRG YW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJDb3VyaWVyIikpOworICAgIHN0YXRpYyBCU1RS IHNhbnNTZXJpZkZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkhlbHZldGljYSIpKTsKKyAg ICBzdGF0aWMgQlNUUiBjdXJzaXZlRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQXBwbGUg Q2hhbmNlcnkiKSk7CisgICAgc3RhdGljIEJTVFIgZmFudGFzeUZhbWlseSA9IFN5c0FsbG9jU3Ry aW5nKFRFWFQoIlBhcHlydXMiKSk7CisjZWxzZQorICAgIHN0YXRpYyBCU1RSIHN0YW5kYXJkRmFt aWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMgTmV3IFJvbWFuIikpOworICAgIHN0YXRp YyBCU1RSIGZpeGVkRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQ291cmllciBOZXciKSk7 CisgICAgc3RhdGljIEJTVFIgc2Fuc1NlcmlmRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgi QXJpYWwiKSk7CisgICAgc3RhdGljIEJTVFIgY3Vyc2l2ZUZhbWlseSA9IFN5c0FsbG9jU3RyaW5n KFRFWFQoIkNvbWljIFNhbnMgTVMiKSk7IC8vIE5vdCBhY3R1YWxseSBjdXJzaXZlLCBidXQgaXQn cyB3aGF0IElFIGFuZCBGaXJlZm94IHVzZS4KKyAgICBzdGF0aWMgQlNUUiBmYW50YXN5RmFtaWx5 ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGltZXMgTmV3IFJvbWFuIikpOworI2VuZGlmCisKKyAg ICBwcmVmZXJlbmNlcy0+c2V0U3RhbmRhcmRGb250RmFtaWx5KHN0YW5kYXJkRmFtaWx5KTsKKyAg ICBwcmVmZXJlbmNlcy0+c2V0Rml4ZWRGb250RmFtaWx5KGZpeGVkRmFtaWx5KTsKKyAgICBwcmVm ZXJlbmNlcy0+c2V0U2VyaWZGb250RmFtaWx5KHN0YW5kYXJkRmFtaWx5KTsKKyAgICBwcmVmZXJl bmNlcy0+c2V0U2Fuc1NlcmlmRm9udEZhbWlseShzYW5zU2VyaWZGYW1pbHkpOworICAgIHByZWZl cmVuY2VzLT5zZXRDdXJzaXZlRm9udEZhbWlseShjdXJzaXZlRmFtaWx5KTsKKyAgICBwcmVmZXJl bmNlcy0+c2V0RmFudGFzeUZvbnRGYW1pbHkoZmFudGFzeUZhbWlseSk7CisKKyAgICBwcmVmZXJl bmNlcy0+c2V0QXV0b3NhdmVzKEZBTFNFKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0RGVmYXVsdEZv bnRTaXplKDE2KTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0RGVmYXVsdEZpeGVkRm9udFNpemUoMTMp OworICAgIHByZWZlcmVuY2VzLT5zZXRNaW5pbXVtRm9udFNpemUoMSk7CisgICAgcHJlZmVyZW5j ZXMtPnNldEphdmFFbmFibGVkKEZBTFNFKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0UGx1Z0luc0Vu YWJsZWQoVFJVRSk7CisgICAgcHJlZmVyZW5jZXMtPnNldERPTVBhc3RlQWxsb3dlZChUUlVFKTsK KyAgICBwcmVmZXJlbmNlcy0+c2V0RWRpdGFibGVMaW5rQmVoYXZpb3IoV2ViS2l0RWRpdGFibGVM aW5rT25seUxpdmVXaXRoU2hpZnRLZXkpOworICAgIHByZWZlcmVuY2VzLT5zZXRGb250U21vb3Ro aW5nKEZvbnRTbW9vdGhpbmdUeXBlU3RhbmRhcmQpOworICAgIHByZWZlcmVuY2VzLT5zZXRVc2Vz UGFnZUNhY2hlKEZBTFNFKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5h YmxlZChGQUxTRSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEphdmFTY3JpcHRDYW5PcGVuV2luZG93 c0F1dG9tYXRpY2FsbHkoVFJVRSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEphdmFTY3JpcHRFbmFi bGVkKFRSVUUpOworICAgIHByZWZlcmVuY2VzLT5zZXRUYWJzVG9MaW5rcyhGQUxTRSk7CisgICAg cHJlZmVyZW5jZXMtPnNldFNob3VsZFByaW50QmFja2dyb3VuZHMoVFJVRSk7CisKKyAgICBpZiAo cGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24pIHsKKyAgICAgICAgVmVjdG9yPHdjaGFy X3Q+IHVybENoYXJhY3RlcnMoQ0ZTdHJpbmdHZXRMZW5ndGgocGVyc2lzdGVudFVzZXJTdHlsZVNo ZWV0TG9jYXRpb24uZ2V0KCkpKTsKKyAgICAgICAgQ0ZTdHJpbmdHZXRDaGFyYWN0ZXJzKHBlcnNp c3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uLmdldCgpLCBDRlJhbmdlTWFrZSgwLCBDRlN0cmlu Z0dldExlbmd0aChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbi5nZXQoKSkpLCAoVW5p Q2hhciAqKXVybENoYXJhY3RlcnMuZGF0YSgpKTsKKyAgICAgICAgQlNUUiB1cmwgPSBTeXNBbGxv Y1N0cmluZ0xlbih1cmxDaGFyYWN0ZXJzLmRhdGEoKSwgdXJsQ2hhcmFjdGVycy5zaXplKCkpOwor ICAgICAgICBwcmVmZXJlbmNlcy0+c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbih1cmwpOworICAg ICAgICBTeXNGcmVlU3RyaW5nKHVybCk7CisgICAgICAgIHByZWZlcmVuY2VzLT5zZXRVc2VyU3R5 bGVTaGVldEVuYWJsZWQoVFJVRSk7CisgICAgfSBlbHNlCisgICAgICAgIHByZWZlcmVuY2VzLT5z ZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQoRkFMU0UpOworCisgICAgQ09NUHRyPElXZWJQcmVmZXJl bmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJlZmVyZW5jZXMpOworICAgIGlmIChw cmVmc1ByaXZhdGUpIHsKKyAgICAgICAgcHJlZnNQcml2YXRlLT5zZXRBdXRob3JBbmRVc2VyU3R5 bGVzRW5hYmxlZChUUlVFKTsKKyAgICAgICAgcHJlZnNQcml2YXRlLT5zZXREZXZlbG9wZXJFeHRy YXNFbmFibGVkKEZBTFNFKTsKKyAgICAgICAgcHJlZnNQcml2YXRlLT5zZXRTaG91bGRQYWludE5h dGl2ZUNvbnRyb2xzKEZBTFNFKTsgLy8gRklYTUUgLSBuZWVkIHRvIG1ha2UgRFJUIHBhc3Mgd2l0 aCBXaW5kb3dzIG5hdGl2ZSBjb250cm9scyA8aHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU1OTI+CisgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0WFNTQXVkaXRvckVuYWJs ZWQoRkFMU0UpOworICAgICAgICBwcmVmc1ByaXZhdGUtPnNldE9mZmxpbmVXZWJBcHBsaWNhdGlv bkNhY2hlRW5hYmxlZChGQUxTRSk7CisgICAgfQorfQorCiBzdGF0aWMgdm9pZCByZXNldFdlYlZp ZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcoKQogewogICAgIENPTVB0cjxJV2ViVmll dz4gd2ViVmlldzsKQEAgLTY3MywyOCArNzMyLDEwIEBAIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmll d1RvQ29uc2lzdGVudFN0YXRlQmVmb3JlVGVzdGluZygpCiAgICAgICAgIHdlYklCQWN0aW9ucy0+ cmVzZXRQYWdlWm9vbSgwKTsKICAgICB9CiAKKwogICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+ IHByZWZlcmVuY2VzOwogICAgIGlmIChTVUNDRUVERUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnBy ZWZlcmVuY2VzKSkpIHsKLSAgICAgICAgcHJlZmVyZW5jZXMtPnNldFByaXZhdGVCcm93c2luZ0Vu YWJsZWQoRkFMU0UpOwotICAgICAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5X aW5kb3dzQXV0b21hdGljYWxseShUUlVFKTsKLQotICAgICAgICBpZiAocGVyc2lzdGVudFVzZXJT dHlsZVNoZWV0TG9jYXRpb24pIHsKLSAgICAgICAgICAgIFZlY3Rvcjx3Y2hhcl90PiB1cmxDaGFy YWN0ZXJzKENGU3RyaW5nR2V0TGVuZ3RoKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9u LmdldCgpKSk7Ci0gICAgICAgICAgICBDRlN0cmluZ0dldENoYXJhY3RlcnMocGVyc2lzdGVudFVz ZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCksIENGUmFuZ2VNYWtlKDAsIENGU3RyaW5nR2V0TGVu Z3RoKHBlcnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uLmdldCgpKSksIChVbmlDaGFyICop dXJsQ2hhcmFjdGVycy5kYXRhKCkpOwotICAgICAgICAgICAgQlNUUiB1cmwgPSBTeXNBbGxvY1N0 cmluZ0xlbih1cmxDaGFyYWN0ZXJzLmRhdGEoKSwgdXJsQ2hhcmFjdGVycy5zaXplKCkpOwotICAg ICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNoZWV0TG9jYXRpb24odXJsKTsKLSAg ICAgICAgICAgIFN5c0ZyZWVTdHJpbmcodXJsKTsKLSAgICAgICAgICAgIHByZWZlcmVuY2VzLT5z ZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQoVFJVRSk7Ci0gICAgICAgIH0gZWxzZQotICAgICAgICAg ICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZChGQUxTRSk7Ci0KLSAgICAg ICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHByZWZzUHJpdmF0ZShRdWVyeSwgcHJl ZmVyZW5jZXMpOwotICAgICAgICBpZiAocHJlZnNQcml2YXRlKSB7Ci0gICAgICAgICAgICBwcmVm c1ByaXZhdGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRSVUUpOwotICAgICAgICAg ICAgcHJlZnNQcml2YXRlLT5zZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkKEZBTFNFKTsKLSAgICAg ICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0U2hvdWxkUGFpbnROYXRpdmVDb250cm9scyhGQUxTRSk7 IC8vIEZJWE1FIC0gbmVlZCB0byBtYWtlIERSVCBwYXNzIHdpdGggV2luZG93cyBuYXRpdmUgY29u dHJvbHMgPGh0dHA6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTkyPgotICAg ICAgICAgICAgcHJlZnNQcml2YXRlLT5zZXRYU1NBdWRpdG9yRW5hYmxlZChGQUxTRSk7Ci0gICAg ICAgIH0KKyAgICAgICAgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcyhwcmVmZXJlbmNl cy5nZXQoKSk7CiAgICAgfQogCiAgICAgQ09NUHRyPElXZWJWaWV3RWRpdGluZz4gdmlld0VkaXRp bmc7CkBAIC04MjksNDQgKzg3MCw2IEBAIGV4aXQ6CiAgICAgcmV0dXJuOwogfQogCi1zdGF0aWMg dm9pZCBpbml0aWFsaXplUHJlZmVyZW5jZXMoSVdlYlByZWZlcmVuY2VzKiBwcmVmZXJlbmNlcykK LXsKLSNpZmRlZiBVU0VfTUFDX0ZPTlRTCi0gICAgQlNUUiBzdGFuZGFyZEZhbWlseSA9IFN5c0Fs bG9jU3RyaW5nKFRFWFQoIlRpbWVzIikpOwotICAgIEJTVFIgZml4ZWRGYW1pbHkgPSBTeXNBbGxv Y1N0cmluZyhURVhUKCJDb3VyaWVyIikpOwotICAgIEJTVFIgc2Fuc1NlcmlmRmFtaWx5ID0gU3lz QWxsb2NTdHJpbmcoVEVYVCgiSGVsdmV0aWNhIikpOwotICAgIEJTVFIgY3Vyc2l2ZUZhbWlseSA9 IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkFwcGxlIENoYW5jZXJ5IikpOwotICAgIEJTVFIgZmFudGFz eUZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIlBhcHlydXMiKSk7Ci0jZWxzZQotICAgIEJT VFIgc3RhbmRhcmRGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJUaW1lcyBOZXcgUm9tYW4i KSk7Ci0gICAgQlNUUiBmaXhlZEZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIkNvdXJpZXIg TmV3IikpOwotICAgIEJTVFIgc2Fuc1NlcmlmRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgi QXJpYWwiKSk7Ci0gICAgQlNUUiBjdXJzaXZlRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgi Q29taWMgU2FucyBNUyIpKTsgLy8gTm90IGFjdHVhbGx5IGN1cnNpdmUsIGJ1dCBpdCdzIHdoYXQg SUUgYW5kIEZpcmVmb3ggdXNlLgotICAgIEJTVFIgZmFudGFzeUZhbWlseSA9IFN5c0FsbG9jU3Ry aW5nKFRFWFQoIlRpbWVzIE5ldyBSb21hbiIpKTsKLSNlbmRpZgotCi0gICAgcHJlZmVyZW5jZXMt PnNldFN0YW5kYXJkRm9udEZhbWlseShzdGFuZGFyZEZhbWlseSk7Ci0gICAgcHJlZmVyZW5jZXMt PnNldEZpeGVkRm9udEZhbWlseShmaXhlZEZhbWlseSk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldFNl cmlmRm9udEZhbWlseShzdGFuZGFyZEZhbWlseSk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldFNhbnNT ZXJpZkZvbnRGYW1pbHkoc2Fuc1NlcmlmRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0Q3Vy c2l2ZUZvbnRGYW1pbHkoY3Vyc2l2ZUZhbWlseSk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldEZhbnRh c3lGb250RmFtaWx5KGZhbnRhc3lGYW1pbHkpOwotCi0gICAgcHJlZmVyZW5jZXMtPnNldEF1dG9z YXZlcyhGQUxTRSk7Ci0gICAgcHJlZmVyZW5jZXMtPnNldEphdmFFbmFibGVkKEZBTFNFKTsKLSAg ICBwcmVmZXJlbmNlcy0+c2V0UGx1Z0luc0VuYWJsZWQoVFJVRSk7Ci0gICAgcHJlZmVyZW5jZXMt PnNldERPTVBhc3RlQWxsb3dlZChUUlVFKTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0RWRpdGFibGVM aW5rQmVoYXZpb3IoV2ViS2l0RWRpdGFibGVMaW5rT25seUxpdmVXaXRoU2hpZnRLZXkpOwotICAg IHByZWZlcmVuY2VzLT5zZXRGb250U21vb3RoaW5nKEZvbnRTbW9vdGhpbmdUeXBlU3RhbmRhcmQp OwotICAgIHByZWZlcmVuY2VzLT5zZXRVc2VzUGFnZUNhY2hlKEZBTFNFKTsKLQotICAgIFN5c0Zy ZWVTdHJpbmcoc3RhbmRhcmRGYW1pbHkpOwotICAgIFN5c0ZyZWVTdHJpbmcoZml4ZWRGYW1pbHkp OwotICAgIFN5c0ZyZWVTdHJpbmcoc2Fuc1NlcmlmRmFtaWx5KTsKLSAgICBTeXNGcmVlU3RyaW5n KGN1cnNpdmVGYW1pbHkpOwotICAgIFN5c0ZyZWVTdHJpbmcoZmFudGFzeUZhbWlseSk7Ci19Ci0K IHN0YXRpYyBCb29sZWFuIHB0aHJlYWRFcXVhbENhbGxiYWNrKGNvbnN0IHZvaWQqIHZhbHVlMSwg Y29uc3Qgdm9pZCogdmFsdWUyKQogewogICAgIHJldHVybiAoQm9vbGVhbilwdGhyZWFkX2VxdWFs KCoocHRocmVhZF90Kil2YWx1ZTEsICoocHRocmVhZF90Kil2YWx1ZTIpOwpAQCAtMTA1MSwxMiAr MTA1NCw2IEBAIElXZWJWaWV3KiBjcmVhdGVXZWJWaWV3QW5kT2Zmc2NyZWVuV2luZG93KEhXTkQq IHdlYlZpZXdXaW5kb3cpCiAgICAgaWYgKEZBSUxFRCh3ZWJWaWV3LT5zZXRSZXNvdXJjZUxvYWRE ZWxlZ2F0ZShzaGFyZWRSZXNvdXJjZUxvYWREZWxlZ2F0ZS5nZXQoKSkpKQogICAgICAgICByZXR1 cm4gMDsKIAotICAgIENPTVB0cjxJV2ViUHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOwotICAgIGlm IChGQUlMRUQod2ViVmlldy0+cHJlZmVyZW5jZXMoJnByZWZlcmVuY2VzKSkpCi0gICAgICAgIHJl dHVybiAwOwotCi0gICAgaW5pdGlhbGl6ZVByZWZlcmVuY2VzKHByZWZlcmVuY2VzLmdldCgpKTsK LQogICAgIG9wZW5XaW5kb3dzKCkuYXBwZW5kKGhvc3RXaW5kb3cpOwogICAgIHdpbmRvd1RvV2Vi Vmlld01hcCgpLnNldChob3N0V2luZG93LCB3ZWJWaWV3KTsKICAgICByZXR1cm4gd2ViVmlldzsK QEAgLTExMjQsMTggKzExMjEsNiBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hhciogYXJndltdKQog ICAgIHNoYXJlZEVkaXRpbmdEZWxlZ2F0ZS5hZG9wdFJlZihuZXcgRWRpdGluZ0RlbGVnYXRlKTsK ICAgICBzaGFyZWRSZXNvdXJjZUxvYWREZWxlZ2F0ZS5hZG9wdFJlZihuZXcgUmVzb3VyY2VMb2Fk RGVsZWdhdGUpOwogCi0gICAgLy8gRklYTUUgLSBuZWVkIHRvIG1ha2UgRFJUIHBhc3Mgd2l0aCBX aW5kb3dzIG5hdGl2ZSBjb250cm9scyA8aHR0cDovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjU1OTI+Ci0gICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gdG1wUHJlZmVyZW5jZXM7 Ci0gICAgaWYgKEZBSUxFRChXZWJLaXRDcmVhdGVJbnN0YW5jZShDTFNJRF9XZWJQcmVmZXJlbmNl cywgMCwgSUlEX0lXZWJQcmVmZXJlbmNlcywgcmVpbnRlcnByZXRfY2FzdDx2b2lkKio+KCZ0bXBQ cmVmZXJlbmNlcykpKSkKLSAgICAgICAgcmV0dXJuIC0xOwotICAgIENPTVB0cjxJV2ViUHJlZmVy ZW5jZXM+IHN0YW5kYXJkUHJlZmVyZW5jZXM7Ci0gICAgaWYgKEZBSUxFRCh0bXBQcmVmZXJlbmNl cy0+c3RhbmRhcmRQcmVmZXJlbmNlcygmc3RhbmRhcmRQcmVmZXJlbmNlcykpKQotICAgICAgICBy ZXR1cm4gLTE7Ci0gICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlc1ByaXZhdGU+IHN0YW5kYXJkUHJl ZmVyZW5jZXNQcml2YXRlOwotICAgIGlmIChGQUlMRUQoc3RhbmRhcmRQcmVmZXJlbmNlcy0+UXVl cnlJbnRlcmZhY2UoJnN0YW5kYXJkUHJlZmVyZW5jZXNQcml2YXRlKSkpCi0gICAgICAgIHJldHVy biAtMTsKLSAgICBzdGFuZGFyZFByZWZlcmVuY2VzUHJpdmF0ZS0+c2V0U2hvdWxkUGFpbnROYXRp dmVDb250cm9scyhGQUxTRSk7Ci0KICAgICBDT01QdHI8SVdlYlZpZXc+IHdlYlZpZXcoQWRvcHRD T00sIGNyZWF0ZVdlYlZpZXdBbmRPZmZzY3JlZW5XaW5kb3coJndlYlZpZXdXaW5kb3cpKTsKICAg ICBpZiAoIXdlYlZpZXcpCiAgICAgICAgIHJldHVybiAtMTsKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAgYi9XZWJL aXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCmlu ZGV4IDgxYzI3NTEuLjc0MjY3NGMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJU cmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVt cFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcApAQCAtNjk0LDYgKzY5 NCwyNyBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjpjbGVhckFsbERhdGFiYXNlcygpCiAg ICAgZGF0YWJhc2VNYW5hZ2VyLT5kZWxldGVBbGxEYXRhYmFzZXMoKTsKIH0KIAordm9pZCBMYXlv dXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNT dHJpbmdSZWYgZmxhZykKK3sKKyAgICBDT01QdHI8SVdlYlZpZXc+IHdlYlZpZXc7CisgICAgaWYg KEZBSUxFRChmcmFtZS0+d2ViVmlldygmd2ViVmlldykpKQorICAgICAgICByZXR1cm47CisKKyAg ICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiBwcmVmZXJlbmNlczsKKyAgICBpZiAoRkFJTEVEKHdl YlZpZXctPnByZWZlcmVuY2VzKCZwcmVmZXJlbmNlcykpKQorICAgICAgICByZXR1cm47CisKKyAg ICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVm ZXJlbmNlcyk7CisgICAgaWYgKCFwcmVmc1ByaXZhdGUpCisgICAgICAgIHJldHVybjsKKworICAg IEJTVFIga2V5QlNUUiA9IEpTU3RyaW5nQ29weUJTVFIoa2V5KTsKKyAgICBCU1RSIGZsYWdCU1RS ID0gSlNTdHJpbmdDb3B5QlNUUihmbGFnKTsKKyAgICBwcmVmc1ByaXZhdGUtPnNldFByZWZlcmVu Y2VGb3JUZXN0KGtleUJTVFIsIGZsYWdCU1RSKTsKKyAgICBTeXNGcmVlU3RyaW5nKGtleUJTVFIp OworICAgIFN5c0ZyZWVTdHJpbmcoZmxhZ0JTVFIpOworfQorCiB2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpzZXREYXRhYmFzZVF1b3RhKHVuc2lnbmVkIGxvbmcgbG9uZyBxdW90YSkKIHsKICAg ICBwcmludGYoIkVSUk9SOiBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0RGF0YWJhc2VRdW90YSgp IG5vdCBpbXBsZW1lbnRlZFxuIik7Cg== 33995 2009-08-03 12:04:43 -0700 2009-08-10 07:38:31 -0700 Same patch with ChangeLog files updated and GTK and Wx changes. patch.txt text/plain 32267 dimich ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAzMDA3N2M0Li43MmZmNmFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMDktMDgt MDMgIERtaXRyeSBUaXRvdiAgPGRpbWljaEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgT3JpZ2luYWxseSBpbXBsZW1lbnRlZCBi eSBHbGVubiBXaWxzb24gIDxnd2lsc29uQGNocm9taXVtLm9yZz4uCisKKyAgICAgICAgQWRkZWQg dGVzdHMgdG8gdmVyaWZ5IHRoYXQgZGVmYXVsdCBwcmVmZXJlbmNlcyBjYW4gYmUgb3ZlcnJpZGRl biBwZXItdGVzdAorICAgICAgICBhbmQgdGhhdCBvdmVycmlkZGVuIHZhbHVlcyBhcmUgcmVzZXQg YmV0d2VlbiBlYWNoIHRlc3QuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA1MzQKKworICAgICAgICAqIGZhc3QvaGFybmVzcy9vdmVycmlkZS1w cmVmZXJlbmNlcy0yLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9oYXJuZXNz L292ZXJyaWRlLXByZWZlcmVuY2VzLTIuaHRtbDogQWRkZWQuIFZlcmlmaWVzIG92ZXJyaWRlUHJl dmVyZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0IikuCisgICAgICAgICogZmFzdC9o YXJuZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZmFzdC9oYXJuZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWw6IEFkZGVkLiBWZXJpZmll cyBvdmVycmlkZVByZWZlcmVuY2UoIldlYktpdEphdmFTY3JpcHRFbmFibGVkIiwgZmFsc2UpLgor ICAgICAgICAqIGZhc3QvaGFybmVzcy9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6LXJlc2V0Lmh0bWw6IEFk ZGVkLiBCZWNhdXNlIG9mICd6enonIHRoaXMgdGVzdCB3aWxsIHJ1biBhZnRlciB0aGUgdGVzdHMg YWJvdmUgYW5kCisgICAgICAgIHZlcmlmeSB0aGF0IG92ZXJyaWRlIG9mIHByZWZlcmVuY2VzIGRv ZXMgbm90ICdzcGlsbCcgdG8gdGhlIHN1YnNlcXVlbnQgdGVzdHMgaW4gYSBiYXRjaC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvU2tpcHBlZDogVGVzdHMgYWJvdmUgZGlzYWJsZWQgZm9yIEdUSyB1 bnRpbCBHVEsgRFJUIGltcGxlbWVudHMgcHJlZmVyZW5jZSBvdmVycmlkZS4KKwogMjAwOS0wNy0y NCAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBi eSBKdXN0aW4gR2FyY2lhLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292 ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJu ZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLTItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLmFiY2NlYWEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwzIEBACitUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0Q29udHJvbGxlciBj YW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uIFRoaXMgdGVzdCB2ZXJp ZmllcyB0aGF0IHRoZSBBUEkgd2lsbCBhY2NlcHQgc3RyaW5nIHZhbHVlcyBhbmQgYWxzbyBvdmVy cmlkZSB0aGUgZGVmYXVsdCBmb250IHNpemUuIFlvdSBzaG91bGQgc2VlICJQQVNTIiBiZWxvdy4K KworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXBy ZWZlcmVuY2VzLTIuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVm ZXJlbmNlcy0yLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjMwNTZm NAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS1w cmVmZXJlbmNlcy0yLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+Cis8c2NyaXB0PgorICAg IGlmKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7CisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm92ZXJy aWRlUHJlZmVyZW5jZSgiV2ViS2l0RGVmYXVsdEZvbnRTaXplIiwgIjI0Iik7CisgICAgfQorPC9z Y3JpcHQ+Cis8Ym9keT4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBsYXlvdXRUZXN0 Q29udHJvbGxlciBjYW4gaGF2ZSBpdHMgZGVmYXVsdCBwcmVmZXJlbmNlcyBvdmVycmlkZW4uICAK KyAgICBUaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCB0aGUgQVBJIHdpbGwgYWNjZXB0IHN0cmluZyB2 YWx1ZXMgYW5kIGFsc28gb3ZlcnJpZGUgdGhlIGRlZmF1bHQgZm9udCBzaXplLiAgCisgICAgWW91 IHNob3VsZCBzZWUgIlBBU1MiIGJlbG93LjwvcD4KKyAgICA8c2NyaXB0PgorICAgICAgICB2YXIg cCA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwIilbMF07CisgICAgICAgIGlmKCF3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIgfHwgd2luZG93LmdldENvbXB1dGVkU3R5bGUocCku Zm9udFNpemUgPT0gIjI0cHgiKQorICAgICAgICAgICAgZG9jdW1lbnQud3JpdGUoIlBBU1MiKTsK KyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRjMzQ4ZTAKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMyBAQAorVGhpcyBpcyBhIHRlc3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxh eW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJy aWRkZW4uIFRoaXMgdGVzdCBzcGVjaWZpY2FsbHkgY2hlY2tzIHRoYXQgSmF2YXNjcmlwdCBjYW4g YmUgZGlzYWJsZWQsIGFuZCB5b3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cgaWYgdmlld2luZyB3 aXRoIGEgYnJvd3Nlci4KKworUEFTUwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9oYXJu ZXNzL292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mv b3ZlcnJpZGUtcHJlZmVyZW5jZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi43NDBhNzM5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNz L292ZXJyaWRlLXByZWZlcmVuY2VzLmh0bWwKQEAgLTAsMCArMSwxOCBAQAorPGh0bWw+IAorPGJv ZHk+IAorPHNjcmlwdD4gCisgICAgaWYod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKQorICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UoIldlYktpdEphdmFTY3JpcHRFbmFibGVk IiwgZmFsc2UpOworICAgIH0KKyAgICAKKyAgICBmdW5jdGlvbiBsb2Fkc3RhdHVzKCkgeworICAg ICAgICBpZih3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJIVE1MPSJGQUlMIjsKKyAgICB9Cis8L3Nj cmlwdD4gCis8Ym9keSBvbmxvYWQ9ImxvYWRzdGF0dXMoKSI+CisgICAgPHA+VGhpcyBpcyBhIHRl c3QgdGhhdCB2ZXJpZmllcyB0aGF0IGxheW91dFRlc3RDb250cm9sbGVyIGNhbiBoYXZlIGl0cyBk ZWZhdWx0IHByZWZlcmVuY2VzIG92ZXJyaWRkZW4uICBUaGlzIHRlc3Qgc3BlY2lmaWNhbGx5IGNo ZWNrcyB0aGF0IEphdmFzY3JpcHQgY2FuIGJlIGRpc2FibGVkLCBhbmQgeW91IHNob3VsZCBzZWUg IlBBU1MiIGJlbG93IGlmIHZpZXdpbmcgd2l0aCBhIGJyb3dzZXIuPC9wPgorICAgIDxzcGFuIGlk PSJzdGF0dXMiPlBBU1M8L3NwYW4+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS16enotcmVzZXQtZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRlZTI5MmUKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6LXJlc2V0LWV4cGVjdGVk LnR4dApAQCAtMCwwICsxLDMgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyB0aGF0IHRoZSBsYXlvdXRU ZXN0Q29udHJvbGxlciB3aWxsIHJlc2V0IGl0cyBkZWZhdWx0IHByZWZlcmVuY2VzIGFmdGVyIGV2 ZXJ5IGxheW91dCB0ZXN0LiBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVsb3cuCisKK1BBU1MKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS16enotcmVzZXQuaHRt bCBiL0xheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9vdmVycmlkZS16enotcmVzZXQuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jYmViMWUwCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL292ZXJyaWRlLXp6ei1yZXNldC5odG1sCkBAIC0w LDAgKzEsMTQgQEAKKzxodG1sPiAKKzxib2R5PiAKKzxzY3JpcHQ+IAorICAgIGlmKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFz VGV4dCgpOworPC9zY3JpcHQ+IAorPGJvZHk+CisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRo YXQgdGhlIGxheW91dFRlc3RDb250cm9sbGVyIHdpbGwgcmVzZXQgaXRzIGRlZmF1bHQgcHJlZmVy ZW5jZXMgYWZ0ZXIgZXZlcnkgbGF5b3V0IHRlc3QuICBZb3Ugc2hvdWxkIHNlZSAiUEFTUyIgYmVs b3cuPC9wPgorICAgIDxzcGFuIGlkPSJzdGF0dXMiPkZBSUw8L3NwYW4+CisgICAgPHNjcmlwdD4K KyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXR1cyIpLmlubmVySFRNTD0iUEFT UyI7ICAgICAgICAKKyAgICA8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay9Ta2lwcGVkIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL1NraXBwZWQKaW5kZXggMGIzN2EyZi4uMTU1MGY5MyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vZ3RrL1NraXBwZWQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL1Nr aXBwZWQKQEAgLTU5OTIsMyArNTk5Miw3IEBAIGh0dHAvdGVzdHMvc2VjdXJpdHkvaXNvbGF0ZWRX b3JsZC93aW5kb3ctcHJvcGVydGllcy5odG1sCiAjIE1pc3NpbmcgRFJUIGFiaWxpdHkgcmV0dXJu IGEgbnVsbCByZXF1ZXN0IGZvciB3aWxsU2VuZFJlcXVlc3QgcmVkaXJlY3QgY2FsbHMKIGh0dHAv dGVzdHMvbWlzYy93aWxsLXNlbmQtcmVxdWVzdC1yZXR1cm5zLW51bGwtb24tcmVkaXJlY3QuaHRt bAogCisjIE1pc3NpbmcgRFJUIGFiaWxpdHkgdG8gb3ZlcnJpZGUgJ3N0YW5kYXJkJyBwcmVmZXJl bmNlcy4KK2Zhc3QvaGFybmVzcy9vdmVycmlkZS1wcmVmZXJlbmNlcy5odG1sCitmYXN0L2hhcm5l c3Mvb3ZlcnJpZGUtcHJlZmVyZW5jZXMtMi5odG1sCitmYXN0L2hhcm5lc3Mvb3ZlcnJpZGUtenp6 LXJlc2V0Lmh0bWwKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvQ2hhbmdlTG9nIGIvV2ViS2l0L21h Yy9DaGFuZ2VMb2cKaW5kZXggYzk5MzhhMy4uY2Q3NTE1NCAxMDA2NDQKLS0tIGEvV2ViS2l0L21h Yy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0L21hYy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNyBAQAor MjAwOS0wOC0wMyAgRG1pdHJ5IFRpdG92ICA8ZGltaWNoQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBPcmlnaW5hbGx5IGltcGxl bWVudGVkIGJ5IEdsZW5uIFdpbHNvbiA8Z3dpbHNvbkBjaHJvbWl1bS5vcmc+LgorCisgICAgICAg IEFkZGVkIG5ldyBtZXRob2RzIGZvciBvdmVycmlkaW5nIGRlZmF1bHQgV2ViUHJlZmVyZW5jZSB2 YWx1ZXMKKyAgICAgICAgYW5kIGZvciByZXNldHRpbmcgcHJlZmVyZW5jZXMgdG8gdGhlaXIgZGVm YXVsdHMuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjA1MzQKKworICAgICAgICAqIFdlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW06CisgICAgICAg ICgtW1dlYlByZWZlcmVuY2VzIF9zZXRQcmVmZXJlbmNlRm9yVGVzdFdpdGhWYWx1ZTp3aXRoS2V5 Ol0pOiBhZGRlZC4KKyAgICAgICAgKiBXZWJWaWV3L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oOiBz YW1lLgorCiAyMDA5LTA3LTI0ICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZ29vZ2xlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBBbmRlcnMgQ2FybHNzb24uCmRpZmYgLS1naXQgYS9XZWJL aXQvbWFjL1dlYlZpZXcvV2ViUHJlZmVyZW5jZXMubW0gYi9XZWJLaXQvbWFjL1dlYlZpZXcvV2Vi UHJlZmVyZW5jZXMubW0KaW5kZXggMzc4YjI4MC4uZGEzYTZjNiAxMDA2NDQKLS0tIGEvV2ViS2l0 L21hYy9XZWJWaWV3L1dlYlByZWZlcmVuY2VzLm1tCisrKyBiL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJQcmVmZXJlbmNlcy5tbQpAQCAtMTE1Miw2ICsxMTUyLDEyIEBAIHN0YXRpYyBOU1N0cmluZyAq Y2xhc3NJQkNyZWF0b3JJRCA9IG5pbDsKIHsKICAgICArK19wcml2YXRlLT5udW1XZWJWaWV3czsK IH0KKworLSAodm9pZClfc2V0UHJlZmVyZW5jZUZvclRlc3RXaXRoVmFsdWU6KE5TU3RyaW5nICop dmFsdWUgZm9yS2V5OihOU1N0cmluZyAqKWtleQoreworICAgIFtzZWxmIF9zZXRTdHJpbmdWYWx1 ZTp2YWx1ZSBmb3JLZXk6a2V5XTsJCit9CisKIEBlbmQKIAogQGltcGxlbWVudGF0aW9uIFdlYlBy ZWZlcmVuY2VzIChXZWJJbnRlcm5hbCkKZGlmZiAtLWdpdCBhL1dlYktpdC9tYWMvV2ViVmlldy9X ZWJQcmVmZXJlbmNlc1ByaXZhdGUuaCBiL1dlYktpdC9tYWMvV2ViVmlldy9XZWJQcmVmZXJlbmNl c1ByaXZhdGUuaAppbmRleCBkNTcxODY5Li43NDAwYTc3IDEwMDY0NAotLS0gYS9XZWJLaXQvbWFj L1dlYlZpZXcvV2ViUHJlZmVyZW5jZXNQcml2YXRlLmgKKysrIGIvV2ViS2l0L21hYy9XZWJWaWV3 L1dlYlByZWZlcmVuY2VzUHJpdmF0ZS5oCkBAIC0xMTcsNiArMTE3LDEwIEBAIGV4dGVybiBOU1N0 cmluZyAqV2ViUHJlZmVyZW5jZXNSZW1vdmVkTm90aWZpY2F0aW9uOwogLSAoV2ViVGV4dERpcmVj dGlvblN1Ym1lbnVJbmNsdXNpb25CZWhhdmlvcil0ZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lv bkJlaGF2aW9yOwogLSAodm9pZClzZXRUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2 aW9yOihXZWJUZXh0RGlyZWN0aW9uU3VibWVudUluY2x1c2lvbkJlaGF2aW9yKWJlaGF2aW9yOwog CisvLyBVc2VkIHRvIHNldCBwcmVmZXJlbmNlIHNwZWNpZmllZCBpbiB0aGUgdGVzdCB2aWEgTGF5 b3V0VGVzdENvbnRyb2xsZXIub3ZlcnJpZGVQcmVmZXJlbmNlKC4uKS4KKy8vIEZvciB1c2Ugd2l0 aCBEdW1wUmVuZGVyVHJlZSBvbmx5LgorLSAodm9pZClfc2V0UHJlZmVyZW5jZUZvclRlc3RXaXRo VmFsdWU6KE5TU3RyaW5nICopdmFsdWUgZm9yS2V5OihOU1N0cmluZyAqKWtleTsKKwogLy8gSWYg c2l0ZS1zcGVjaWZpYyBzcG9vZmluZyBpcyBlbmFibGVkLCBzb21lIHBhZ2VzIHRoYXQgZG8gaW5h cHByb3ByaWF0ZSB1c2VyLWFnZW50IHN0cmluZyBjaGVja3Mgd2lsbCBiZQogLy8gcGFzc2VkIGEg bm9uc3RhbmRhcmQgdXNlci1hZ2VudCBzdHJpbmcgdG8gZ2V0IHRoZW0gdG8gd29yayBjb3JyZWN0 bHkuIFRoaXMgbWV0aG9kIG1pZ2h0IGJlIHJlbW92ZWQgaW4KIC8vIHRoZSBmdXR1cmUgd2hlbiB0 aGVyZSdzIG5vIG1vcmUgbmVlZCBmb3IgaXQuCmRpZmYgLS1naXQgYS9XZWJLaXQvd2luL0NoYW5n ZUxvZyBiL1dlYktpdC93aW4vQ2hhbmdlTG9nCmluZGV4IGZhZmI2NjQuLmRmOTQxMWQgMTAwNjQ0 Ci0tLSBhL1dlYktpdC93aW4vQ2hhbmdlTG9nCisrKyBiL1dlYktpdC93aW4vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTYgQEAKKzIwMDktMDctMjIgIERtaXRyeSBUaXRvdiA8ZGltaWNoQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBP cmlnaW5hbGx5IGltcGxlbWVudGVkIGJ5IEdsZW5uIFdpbHNvbiAgPGd3aWxzb25AY2hyb21pdW0u b3JnPi4KKworICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBvdmVycmlkaW5nIGRlZmF1bHQgcHJl ZmVyZW5jZXMgcGVyLXRlc3QuCisgICAgICAgIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjA1MzQKKworICAgICAgICAqIEludGVyZmFjZXMvSVdlYlByZWZlcmVu Y2VzUHJpdmF0ZS5pZGw6IGFkZGVkIG5ldyBtZXRob2Qgc2V0UHJlZmVyZW5jZUZvclRlc3QKKyAg ICAgICAgKiBXZWJQcmVmZXJlbmNlcy5jcHA6IHNhbWUuCisgICAgICAgICogV2ViUHJlZmVyZW5j ZXMuaDogc2FtZS4KKwogMjAwOS0wNy0yNCAgQnJlbnQgRnVsZ2hhbSAgPGJmdWxnaGFtQHdlYmtp dC5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2ZSBIeWF0dC4KZGlmZiAtLWdpdCBhL1dl YktpdC93aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbCBiL1dlYktpdC93 aW4vSW50ZXJmYWNlcy9JV2ViUHJlZmVyZW5jZXNQcml2YXRlLmlkbAppbmRleCA1NjJhNzViLi5k MjZlNGU4IDEwMDY0NAotLS0gYS9XZWJLaXQvd2luL0ludGVyZmFjZXMvSVdlYlByZWZlcmVuY2Vz UHJpdmF0ZS5pZGwKKysrIGIvV2ViS2l0L3dpbi9JbnRlcmZhY2VzL0lXZWJQcmVmZXJlbmNlc1By aXZhdGUuaWRsCkBAIC03OCw0ICs3OCw4IEBAIGludGVyZmFjZSBJV2ViUHJlZmVyZW5jZXNQcml2 YXRlIDogSVVua25vd24KIAogICAgIEhSRVNVTFQgaXNYU1NBdWRpdG9yRW5hYmxlZChbb3V0LCBy ZXR2YWxdIEJPT0wgKmVuYWJsZWQpOwogICAgIEhSRVNVTFQgc2V0WFNTQXVkaXRvckVuYWJsZWQo W2luXSBCT09MIGVuYWJsZWQpOworCisgICAgLy8gVXNlZCB0byBzZXQgcHJlZmVyZW5jZSBzcGVj aWZpZWQgYnkgYSB0ZXN0IHZpYSBMYXlvdXRUZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVu Y2UoLi4pLgorICAgIC8vIFVzZWQgYnkgRHVtcFJlbmRlclRyZWUuCisgICAgSFJFU1VMVCBzZXRQ cmVmZXJlbmNlRm9yVGVzdChbaW5dIEJTVFIga2V5LCBbaW5dIEJTVFIgdmFsdWUpOwogfQpkaWZm IC0tZ2l0IGEvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5jcHAgYi9XZWJLaXQvd2luL1dlYlBy ZWZlcmVuY2VzLmNwcAppbmRleCA4ZWEwMzE5Li4xZTE1ODAwIDEwMDY0NAotLS0gYS9XZWJLaXQv d2luL1dlYlByZWZlcmVuY2VzLmNwcAorKysgYi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmNw cApAQCAtMTMwMSw2ICsxMzAxLDE3IEBAIEhSRVNVTFQgV2ViUHJlZmVyZW5jZXM6Onpvb21zVGV4 dE9ubHkoQk9PTCogem9vbXNUZXh0T25seSkKICAgICByZXR1cm4gU19PSzsKIH0KIAorSFJFU1VM VCBXZWJQcmVmZXJlbmNlczo6c2V0UHJlZmVyZW5jZUZvclRlc3QoQlNUUiBrZXksIEJTVFIgdmFs dWUpCit7CisgICAgaWYgKCFTeXNTdHJpbmdMZW4oa2V5KSB8fCAhU3lzU3RyaW5nTGVuKHZhbHVl KSkKKyAgICAgICAgcmV0dXJuIEVfRkFJTDsKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtl eVN0cmluZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZVdpdGhDaGFyYWN0ZXJzKDAsIHJlaW50ZXJw cmV0X2Nhc3Q8VW5pQ2hhcio+KGtleSksIFN5c1N0cmluZ0xlbihrZXkpKSk7CisgICAgUmV0YWlu UHRyPENGU3RyaW5nUmVmPiB2YWx1ZVN0cmluZyhBZG9wdENGLCBDRlN0cmluZ0NyZWF0ZVdpdGhD aGFyYWN0ZXJzKDAsIHJlaW50ZXJwcmV0X2Nhc3Q8VW5pQ2hhcio+KHZhbHVlKSwgU3lzU3RyaW5n TGVuKHZhbHVlKSkpOworICAgIHNldFZhbHVlRm9yS2V5KGtleVN0cmluZy5nZXQoKSwgdmFsdWVT dHJpbmcuZ2V0KCkpOworICAgIHBvc3RQcmVmZXJlbmNlc0NoYW5nZXNOb3RpZmljYXRpb24oKTsK KyAgICByZXR1cm4gU19PSzsKK30KKwogdm9pZCBXZWJQcmVmZXJlbmNlczo6d2lsbEFkZFRvV2Vi VmlldygpCiB7CiAgICAgKyttX251bVdlYlZpZXdzOwpkaWZmIC0tZ2l0IGEvV2ViS2l0L3dpbi9X ZWJQcmVmZXJlbmNlcy5oIGIvV2ViS2l0L3dpbi9XZWJQcmVmZXJlbmNlcy5oCmluZGV4IDJmOTQz ODIuLjA0MzIyMDUgMTAwNjQ0Ci0tLSBhL1dlYktpdC93aW4vV2ViUHJlZmVyZW5jZXMuaAorKysg Yi9XZWJLaXQvd2luL1dlYlByZWZlcmVuY2VzLmgKQEAgLTM0MCw3ICszNDAsNyBAQCBwdWJsaWM6 CiAKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgZm9udFNtb290aGluZ0Nv bnRyYXN0KCAKICAgICAvKiBbcmV0dmFsXVtvdXRdICovIGZsb2F0KiBjb250cmFzdCk7Ci0gICAg CisKICAgICB2aXJ0dWFsIEhSRVNVTFQgU1RETUVUSE9EQ0FMTFRZUEUgc2V0Rm9udFNtb290aGlu Z0NvbnRyYXN0KCAKICAgICAvKiBbaW5dICovIGZsb2F0IGNvbnRyYXN0KTsKIApAQCAtMzYyLDYg KzM2MiwxMSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBIUkVTVUxUIFNURE1FVEhPRENBTExUWVBF IHNldFhTU0F1ZGl0b3JFbmFibGVkKAogICAgIC8qIFtpbl0gKi8gQk9PTCBlbmFibGVkKTsKIAor ICAgIHZpcnR1YWwgSFJFU1VMVCBTVERNRVRIT0RDQUxMVFlQRSBzZXRQcmVmZXJlbmNlRm9yVGVz dCgKKyAgICAvKiBbaW5dICovIEJTVFIga2V5LAorICAgIC8qIFtpbl0gKi8gQlNUUiB2YWx1ZSk7 CisKKwogICAgIC8vIFdlYlByZWZlcmVuY2VzCiAKICAgICAvLyBUaGlzIG1ldGhvZCBhY2Nlc3Nl cyBhIGRpZmZlcmVudCBwcmVmZXJlbmNlIGtleSB0aGFuIGRldmVsb3BlckV4dHJhc0VuYWJsZWQu CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9DaGFuZ2VMb2cgYi9XZWJLaXRUb29scy9DaGFuZ2VM b2cKaW5kZXggOTJmZjhlMS4uMzFjYWMwOSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvQ2hhbmdl TG9nCisrKyBiL1dlYktpdFRvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDA5LTA4 LTAzICBEbWl0cnkgVGl0b3YgIDxkaW1pY2hAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsbHkgaW1wbGVtZW50ZWQg YnkgR2xlbm4gV2lsc29uICA8Z3dpbHNvbkBjaHJvbWl1bS5vcmc+LgorCisgICAgICAgIEFkZGVk IHN1cHBvcnQgZm9yIG92ZXJyaWRpbmcgZGVmYXVsdCBwcmVmZXJlbmNlcyBwZXItdGVzdC4KKyAg ICAgICAgU2VlIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDUzNAor CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAg ICAgICAob3ZlcnJpZGVQcmVmZXJlbmNlQ2FsbGJhY2spOiBhZGQgd2lyaW5nIGZvciBsYXlvdXRU ZXN0Q29udHJvbGxlci5vdmVycmlkZVByZWZlcmVuY2UuCisgICAgICAgIChMYXlvdXRUZXN0Q29u dHJvbGxlcjo6c3RhdGljRnVuY3Rpb25zKTogc2FtZS4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJl ZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOiBzYW1lLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVl L2d0ay9MYXlvdXRUZXN0Q29udHJvbGxlckd0ay5jcHA6CisgICAgICAgIChMYXlvdXRUZXN0Q29u dHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKTogYWRkZWQgZW1wdHkgb3ZlcnJpZGVQcmVmZXJl bmNlIG1ldGhvZC4KKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvRHVtcFJlbmRlclRyZWUu bW06IGltcGxlbWVudGVkIHByZWZlcmVuY2Ugb3ZlcnJpZGUuCisgICAgICAgIChyZXNldERlZmF1 bHRzVG9Db25zaXN0ZW50VmFsdWVzKTogbmV3IG1ldGhvZCwgcmVzZXRzIHByZWZlcmVuY2VzIHRv IHNhbWUgc2V0IG9mIHZhbHVlIGJlZm9yZSBldmVyeSB0ZXN0LgorICAgICAgICAoc2V0RGVmYXVs dHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKTogbmV3IG1ldGhvZCwgc2V0cyBvdGhlciBk ZXRhaWxzIG9mIHRlc3RpbmcgZW52aXJvbm1lbnQsIGV2ZXJ5IHRpbWUgIERSVCBzdGFydHMuCisg ICAgICAgIChyZXNldFdlYlZpZXdUb0NvbnNpc3RlbnRTdGF0ZUJlZm9yZVRlc3RpbmcpOiBtb3Zl IHNvbWUgcHJlZmVyZW5jZSBzZXR0aW5nIGZyb20gaGVyZSB0byBuZXcgcmVzZXREZWZhdWx0c1Rv Q29uc2lzdGVudFZhbHVlcygpLgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRU ZXN0Q29udHJvbGxlck1hYy5tbToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjpvdmVy cmlkZVByZWZlcmVuY2UpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVy VHJlZS5jcHA6CisgICAgICAgIChyZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKTogbmV3 IG1ldGhvZCwgcmVzZXRzIHByZWZlcmVuY2VzIHRvIHNhbWUgc2V0IG9mIHZhbHVlIGJlZm9yZSBl dmVyeSB0ZXN0LgorICAgICAgICAocmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVU ZXN0aW5nKTogbW92ZSBzb21lIHByZWZlcmVuY2Ugc2V0dGluZyBmcm9tIGhlcmUgdG8gbmV3IHJl c2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXMoKS4KKyAgICAgICAgKGNyZWF0ZVdlYlZpZXdB bmRPZmZzY3JlZW5XaW5kb3cpOiBzYW1lLgorICAgICAgICAobWFpbik6IHNhbWUuCisgICAgICAg ICogRHVtcFJlbmRlclRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcDoKKyAgICAg ICAgKExheW91dFRlc3RDb250cm9sbGVyOjpvdmVycmlkZVByZWZlcmVuY2UpOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL3d4L0xheW91dFRlc3RDb250cm9sbGVyV3guY3BwOgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZSk6CisKIDIwMDktMDctMjQg IEVsaSBGaWRsZXIgIDxlbGkuZmlkbGVyQHRvcmNobW9iaWxlLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBBZGFtIFRyZWF0LgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRy ZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv TGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmluZGV4IDk3NDdhYTMuLmU3NWE3Y2IgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAor KysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAK QEAgLTM2MCw2ICszNjAsMjIgQEAgc3RhdGljIEpTVmFsdWVSZWYgaXNDb21tYW5kRW5hYmxlZENh bGxiYWNrKEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW4KICAgICByZXR1cm4g SlNWYWx1ZU1ha2VCb29sZWFuKGNvbnRleHQsIGNvbnRyb2xsZXItPmlzQ29tbWFuZEVuYWJsZWQo bmFtZS5nZXQoKSkpOwogfQogCitzdGF0aWMgSlNWYWx1ZVJlZiBvdmVycmlkZVByZWZlcmVuY2VD YWxsYmFjayhKU0NvbnRleHRSZWYgY29udGV4dCwgSlNPYmplY3RSZWYgZnVuY3Rpb24sIEpTT2Jq ZWN0UmVmIHRoaXNPYmplY3QsIHNpemVfdCBhcmd1bWVudENvdW50LCBjb25zdCBKU1ZhbHVlUmVm IGFyZ3VtZW50c1tdLCBKU1ZhbHVlUmVmKiBleGNlcHRpb24pCit7CisgICAgaWYgKGFyZ3VtZW50 Q291bnQgPCAyKQorICAgICAgICByZXR1cm4gSlNWYWx1ZU1ha2VVbmRlZmluZWQoY29udGV4dCk7 CisKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4ga2V5KEFkb3B0LCBKU1ZhbHVlVG9TdHJp bmdDb3B5KGNvbnRleHQsIGFyZ3VtZW50c1swXSwgZXhjZXB0aW9uKSk7CisgICAgQVNTRVJUKCEq ZXhjZXB0aW9uKTsKKyAgICBKU1JldGFpblB0cjxKU1N0cmluZ1JlZj4gdmFsdWUoQWRvcHQsIEpT VmFsdWVUb1N0cmluZ0NvcHkoY29udGV4dCwgYXJndW1lbnRzWzFdLCBleGNlcHRpb24pKTsKKyAg ICBBU1NFUlQoISpleGNlcHRpb24pOworCisgICAgTGF5b3V0VGVzdENvbnRyb2xsZXIqIGNvbnRy b2xsZXIgPSBzdGF0aWNfY2FzdDxMYXlvdXRUZXN0Q29udHJvbGxlcio+KEpTT2JqZWN0R2V0UHJp dmF0ZSh0aGlzT2JqZWN0KSk7CisgICAgY29udHJvbGxlci0+b3ZlcnJpZGVQcmVmZXJlbmNlKGtl eS5nZXQoKSwgdmFsdWUuZ2V0KCkpOworCisgICAgcmV0dXJuIEpTVmFsdWVNYWtlVW5kZWZpbmVk KGNvbnRleHQpOworfQorCiBzdGF0aWMgSlNWYWx1ZVJlZiBrZWVwV2ViSGlzdG9yeUNhbGxiYWNr KEpTQ29udGV4dFJlZiBjb250ZXh0LCBKU09iamVjdFJlZiBmdW5jdGlvbiwgSlNPYmplY3RSZWYg dGhpc09iamVjdCwgc2l6ZV90IGFyZ3VtZW50Q291bnQsIGNvbnN0IEpTVmFsdWVSZWYgYXJndW1l bnRzW10sIEpTVmFsdWVSZWYqIGV4Y2VwdGlvbikKIHsKICAgICAvLyBIYXMgbWFjIGltcGxlbWVu dGF0aW9uCkBAIC05MjIsNiArOTM4LDcgQEAgSlNTdGF0aWNGdW5jdGlvbiogTGF5b3V0VGVzdENv bnRyb2xsZXI6OnN0YXRpY0Z1bmN0aW9ucygpCiAgICAgICAgIHsgImtlZXBXZWJIaXN0b3J5Iiwg a2VlcFdlYkhpc3RvcnlDYWxsYmFjaywga0pTUHJvcGVydHlBdHRyaWJ1dGVSZWFkT25seSB8IGtK U1Byb3BlcnR5QXR0cmlidXRlRG9udERlbGV0ZSB9LAogICAgICAgICB7ICJub3RpZnlEb25lIiwg bm90aWZ5RG9uZUNhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJv cGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCiAgICAgICAgIHsgIm51bWJlck9mQWN0aXZlQW5p bWF0aW9ucyIsIG51bWJlck9mQWN0aXZlQW5pbWF0aW9uc0NhbGxiYWNrLCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0sCisgICAg ICAgIHsgIm92ZXJyaWRlUHJlZmVyZW5jZSIsIG92ZXJyaWRlUHJlZmVyZW5jZUNhbGxiYWNrLCBr SlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVs ZXRlIH0sCiAgICAgICAgIHsgInBhdGhUb0xvY2FsUmVzb3VyY2UiLCBwYXRoVG9Mb2NhbFJlc291 cmNlQ2FsbGJhY2ssIGtKU1Byb3BlcnR5QXR0cmlidXRlUmVhZE9ubHkgfCBrSlNQcm9wZXJ0eUF0 dHJpYnV0ZURvbnREZWxldGUgfSwKICAgICAgICAgeyAicGF1c2VBbmltYXRpb25BdFRpbWVPbkVs ZW1lbnRXaXRoSWQiLCBwYXVzZUFuaW1hdGlvbkF0VGltZU9uRWxlbWVudFdpdGhJZENhbGxiYWNr LCBrSlNQcm9wZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250 RGVsZXRlIH0sCiAgICAgICAgIHsgInBhdXNlVHJhbnNpdGlvbkF0VGltZU9uRWxlbWVudFdpdGhJ ZCIsIHBhdXNlVHJhbnNpdGlvbkF0VGltZU9uRWxlbWVudFdpdGhJZENhbGxiYWNrLCBrSlNQcm9w ZXJ0eUF0dHJpYnV0ZVJlYWRPbmx5IHwga0pTUHJvcGVydHlBdHRyaWJ1dGVEb250RGVsZXRlIH0s CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJv bGxlci5oIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvTGF5b3V0VGVzdENvbnRyb2xsZXIu aAppbmRleCBmMzdiMjIxLi40YjYyMmIzIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVu ZGVyVHJlZS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL0xheW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTUyLDYgKzUyLDcgQEAgcHVibGljOgog ICAgIGJvb2wgaXNDb21tYW5kRW5hYmxlZChKU1N0cmluZ1JlZiBuYW1lKTsKICAgICB2b2lkIGtl ZXBXZWJIaXN0b3J5KCk7CiAgICAgdm9pZCBub3RpZnlEb25lKCk7CisgICAgdm9pZCBvdmVycmlk ZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFnKTsKICAgICBKU1N0 cmluZ1JlZiBwYXRoVG9Mb2NhbFJlc291cmNlKEpTQ29udGV4dFJlZiwgSlNTdHJpbmdSZWYgdXJs KTsKICAgICB2b2lkIHF1ZXVlQmFja05hdmlnYXRpb24oaW50IGhvd0ZhckJhY2t3YXJkKTsKICAg ICB2b2lkIHF1ZXVlRm9yd2FyZE5hdmlnYXRpb24oaW50IGhvd0ZhckZvcndhcmQpOwpkaWZmIC0t Z2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVy R3RrLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL2d0ay9MYXlvdXRUZXN0Q29udHJv bGxlckd0ay5jcHAKaW5kZXggMGE4NzEyYS4uMWE2MzAwNCAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvRHVtcFJlbmRlclRyZWUvZ3RrL0xheW91dFRlc3RDb250cm9sbGVyR3RrLmNwcAorKysgYi9X ZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9ndGsvTGF5b3V0VGVzdENvbnRyb2xsZXJHdGsuY3Bw CkBAIC0zNTUsMyArMzU1LDkgQEAgdW5zaWduZWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6Om51bWJl ck9mQWN0aXZlQW5pbWF0aW9ucygpIGNvbnN0CiB7CiAgICAgcmV0dXJuIHdlYmtpdF93ZWJfZnJh bWVfbnVtYmVyX29mX2FjdGl2ZV9hbmltYXRpb25zKG1haW5GcmFtZSk7CiB9CisKK3ZvaWQgTGF5 b3V0VGVzdENvbnRyb2xsZXI6Om92ZXJyaWRlUHJlZmVyZW5jZShKU1N0cmluZ1JlZiBrZXksIEpT U3RyaW5nUmVmIGZsYWcpCit7CisgICAgLy8gRklYTUUgaW1wbGVtZW50Cit9CisKZGlmZiAtLWdp dCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbSBiL1dl YktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9EdW1wUmVuZGVyVHJlZS5tbQppbmRleCA4NzJh ZDc5Li5jYmYwNTY3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMv RHVtcFJlbmRlclRyZWUubW0KKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0R1 bXBSZW5kZXJUcmVlLm1tCkBAIC0zNDksNyArMzQ5LDggQEAgc3RhdGljIE5TU3RyaW5nICpsaWJy YXJ5UGF0aEZvckR1bXBSZW5kZXJUcmVlKCkKICAgICByZXR1cm4gW0Aifi9MaWJyYXJ5L0FwcGxp Y2F0aW9uIFN1cHBvcnQvRHVtcFJlbmRlclRyZWUiIHN0cmluZ0J5RXhwYW5kaW5nVGlsZGVJblBh dGhdOwogfQogCi1zdGF0aWMgdm9pZCBzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlc0ZvclRl c3RpbmcoKQorLy8gQ2FsbGVkIGJlZm9yZSBlYWNoIHRlc3QuCitzdGF0aWMgdm9pZCByZXNldERl ZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKCkKIHsKICAgICAvLyBHaXZlIHNvbWUgY2xlYXIgdG8g dW5kb2N1bWVudGVkIGRlZmF1bHRzIHZhbHVlcwogICAgIHN0YXRpYyBjb25zdCBpbnQgTm9Gb250 U21vb3RoaW5nID0gMDsKQEAgLTM3OSwxMiArMzgwLDYgQEAgc3RhdGljIHZvaWQgc2V0RGVmYXVs dHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKCkKICAgICBOU1N0cmluZyAqcGF0aCA9IGxp YnJhcnlQYXRoRm9yRHVtcFJlbmRlclRyZWUoKTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0Oltw YXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpAIkRhdGFiYXNlcyJdIGZvcktleTpX ZWJEYXRhYmFzZURpcmVjdG9yeURlZmF1bHRzS2V5XTsKICAgICBbZGVmYXVsdHMgc2V0T2JqZWN0 OltwYXRoIHN0cmluZ0J5QXBwZW5kaW5nUGF0aENvbXBvbmVudDpAIkxvY2FsQ2FjaGUiXSBmb3JL ZXk6V2ViS2l0TG9jYWxDYWNoZURlZmF1bHRzS2V5XTsKLSAgICBOU1VSTENhY2hlICpzaGFyZWRD YWNoZSA9Ci0gICAgICAgIFtbTlNVUkxDYWNoZSBhbGxvY10gaW5pdFdpdGhNZW1vcnlDYXBhY2l0 eToxMDI0ICogMTAyNAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNr Q2FwYWNpdHk6MAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlz a1BhdGg6W3BhdGggc3RyaW5nQnlBcHBlbmRpbmdQYXRoQ29tcG9uZW50OkAiVVJMQ2FjaGUiXV07 Ci0gICAgW05TVVJMQ2FjaGUgc2V0U2hhcmVkVVJMQ2FjaGU6c2hhcmVkQ2FjaGVdOwotICAgIFtz aGFyZWRDYWNoZSByZWxlYXNlXTsKIAogICAgIFdlYlByZWZlcmVuY2VzICpwcmVmZXJlbmNlcyA9 IFtXZWJQcmVmZXJlbmNlcyBzdGFuZGFyZFByZWZlcmVuY2VzXTsKIApAQCAtNDA2LDExICs0MDEs MzggQEAgc3RhdGljIHZvaWQgc2V0RGVmYXVsdHNUb0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5n KCkKICAgICBbcHJlZmVyZW5jZXMgc2V0Q2FjaGVNb2RlbDpXZWJDYWNoZU1vZGVsRG9jdW1lbnRC cm93c2VyXTsKICAgICBbcHJlZmVyZW5jZXMgc2V0WFNTQXVkaXRvckVuYWJsZWQ6Tk9dOwogCisg ICAgW3ByZWZlcmVuY2VzIHNldFByaXZhdGVCcm93c2luZ0VuYWJsZWQ6Tk9dOworICAgIFtwcmVm ZXJlbmNlcyBzZXRBdXRob3JBbmRVc2VyU3R5bGVzRW5hYmxlZDpZRVNdOworICAgIFtwcmVmZXJl bmNlcyBzZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0aWNhbGx5OllFU107CisgICAg W3ByZWZlcmVuY2VzIHNldE9mZmxpbmVXZWJBcHBsaWNhdGlvbkNhY2hlRW5hYmxlZDpZRVNdOwor ICAgIFtwcmVmZXJlbmNlcyBzZXREZXZlbG9wZXJFeHRyYXNFbmFibGVkOk5PXTsKKyAgICBbcHJl ZmVyZW5jZXMgc2V0WFNTQXVkaXRvckVuYWJsZWQ6Tk9dOworICAgIGlmIChwZXJzaXN0ZW50VXNl clN0eWxlU2hlZXRMb2NhdGlvbikgeworICAgICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxl U2hlZXRMb2NhdGlvbjpbTlNVUkwgVVJMV2l0aFN0cmluZzooTlNTdHJpbmcgKikocGVyc2lzdGVu dFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpXV07CisgICAgICAgIFtwcmVmZXJlbmNlcyBz ZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQ6WUVTXTsKKyAgICB9IGVsc2UKKyAgICAgICAgW3ByZWZl cmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0RW5hYmxlZDpOT107CisKICAgICAvLyBUaGUgYmFjay9m b3J3YXJkIGNhY2hlIGlzIGNhdXNpbmcgcHJvYmxlbXMgZHVlIHRvIGxheW91dHMgZHVyaW5nIHRy YW5zaXRpb24gZnJvbSBvbmUgcGFnZSB0byBhbm90aGVyLgogICAgIC8vIFNvLCB0dXJuIGl0IG9m ZiBmb3Igbm93LCBidXQgd2UgbWlnaHQgd2FudCB0byB0dXJuIGl0IGJhY2sgb24gc29tZSBkYXku CiAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXNQYWdlQ2FjaGU6Tk9dOwogfQogCisvLyBDYWxsZWQg b25jZSBvbiBEdW1wUmVuZGVyVHJlZSBzdGFydHVwLgorc3RhdGljIHZvaWQgc2V0RGVmYXVsdHNU b0NvbnNpc3RlbnRWYWx1ZXNGb3JUZXN0aW5nKCkKK3sKKyAgICByZXNldERlZmF1bHRzVG9Db25z aXN0ZW50VmFsdWVzKCk7CisKKyAgICBOU1N0cmluZyAqcGF0aCA9IGxpYnJhcnlQYXRoRm9yRHVt cFJlbmRlclRyZWUoKTsKKyAgICBOU1VSTENhY2hlICpzaGFyZWRDYWNoZSA9CisgICAgICAgIFtb TlNVUkxDYWNoZSBhbGxvY10gaW5pdFdpdGhNZW1vcnlDYXBhY2l0eToxMDI0ICogMTAyNAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkaXNrQ2FwYWNpdHk6MAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlza1BhdGg6W3BhdGggc3RyaW5n QnlBcHBlbmRpbmdQYXRoQ29tcG9uZW50OkAiVVJMQ2FjaGUiXV07CisgICAgW05TVVJMQ2FjaGUg c2V0U2hhcmVkVVJMQ2FjaGU6c2hhcmVkQ2FjaGVdOworICAgIFtzaGFyZWRDYWNoZSByZWxlYXNl XTsKKworfQorCiBzdGF0aWMgdm9pZCBjcmFzaEhhbmRsZXIoaW50IHNpZykKIHsKICAgICBjaGFy ICpzaWduYWxOYW1lID0gc3Ryc2lnbmFsKHNpZyk7CkBAIC0xMDQ3LDE5ICsxMDY5LDcgQEAgc3Rh dGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50U3RhdGVCZWZvcmVUZXN0aW5nKCkKICAg ICBbd2ViVmlldyBfY2xlYXJNYWluRnJhbWVOYW1lXTsKICAgICBbW3dlYlZpZXcgdW5kb01hbmFn ZXJdIHJlbW92ZUFsbEFjdGlvbnNdOwogCi0gICAgV2ViUHJlZmVyZW5jZXMgKnByZWZlcmVuY2Vz ID0gW3dlYlZpZXcgcHJlZmVyZW5jZXNdOwotICAgIFtwcmVmZXJlbmNlcyBzZXRQcml2YXRlQnJv d3NpbmdFbmFibGVkOk5PXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0QXV0aG9yQW5kVXNlclN0eWxl c0VuYWJsZWQ6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0SmF2YVNjcmlwdENhbk9wZW5XaW5k b3dzQXV0b21hdGljYWxseTpZRVNdOwotICAgIFtwcmVmZXJlbmNlcyBzZXRPZmZsaW5lV2ViQXBw bGljYXRpb25DYWNoZUVuYWJsZWQ6WUVTXTsKLSAgICBbcHJlZmVyZW5jZXMgc2V0RGV2ZWxvcGVy RXh0cmFzRW5hYmxlZDpOT107Ci0gICAgW3ByZWZlcmVuY2VzIHNldFhTU0F1ZGl0b3JFbmFibGVk Ok5PXTsKLQotICAgIGlmIChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbikgewotICAg ICAgICBbcHJlZmVyZW5jZXMgc2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbjpbTlNVUkwgVVJMV2l0 aFN0cmluZzooTlNTdHJpbmcgKikocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0 KCkpXV07Ci0gICAgICAgIFtwcmVmZXJlbmNlcyBzZXRVc2VyU3R5bGVTaGVldEVuYWJsZWQ6WUVT XTsKLSAgICB9IGVsc2UKLSAgICAgICAgW3ByZWZlcmVuY2VzIHNldFVzZXJTdHlsZVNoZWV0RW5h YmxlZDpOT107CisgICAgcmVzZXREZWZhdWx0c1RvQ29uc2lzdGVudFZhbHVlcygpOwogCiAgICAg W1ttYWluRnJhbWUgd2ViVmlld10gc2V0U21hcnRJbnNlcnREZWxldGVFbmFibGVkOllFU107CiAg ICAgW1tbbWFpbkZyYW1lIHdlYlZpZXddIGluc3BlY3Rvcl0gc2V0SmF2YVNjcmlwdFByb2ZpbGlu Z0VuYWJsZWQ6Tk9dOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvbWFj L0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUv bWFjL0xheW91dFRlc3RDb250cm9sbGVyTWFjLm1tCmluZGV4IDg5YThiZmEuLjIzNWZjNzYgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0Q29udHJv bGxlck1hYy5tbQorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVz dENvbnRyb2xsZXJNYWMubW0KQEAgLTI4OCw2ICsyODgsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29u dHJvbGxlcjo6ZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3RzKCkKICAgICBbW21haW5GcmFtZSB3 ZWJWaWV3XSBfZGlzcGF0Y2hQZW5kaW5nTG9hZFJlcXVlc3RzXTsKIH0KIAordm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3RyaW5nUmVmIGtleSwgSlNTdHJp bmdSZWYgZmxhZykKK3sKKyAgICBSZXRhaW5QdHI8Q0ZTdHJpbmdSZWY+IGtleUNGKEFkb3B0Q0Ys IEpTU3RyaW5nQ29weUNGU3RyaW5nKGtDRkFsbG9jYXRvckRlZmF1bHQsIGtleSkpOworICAgIE5T U3RyaW5nICprZXlOUyA9IChOU1N0cmluZyAqKWtleUNGLmdldCgpOworCisgICAgUmV0YWluUHRy PENGU3RyaW5nUmVmPiBmbGFnQ0YoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoa0NGQWxs b2NhdG9yRGVmYXVsdCwgZmxhZykpOworICAgIE5TU3RyaW5nICpmbGFnTlMgPSAoTlNTdHJpbmcg KilmbGFnQ0YuZ2V0KCk7CisKKyAgICBbW1dlYlByZWZlcmVuY2VzIHN0YW5kYXJkUHJlZmVyZW5j ZXNdIF9zZXRQcmVmZXJlbmNlRm9yVGVzdFdpdGhWYWx1ZTpmbGFnTlMgZm9yS2V5OmtleU5TXTsK K30KKwogdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0UGVyc2lzdGVudFVzZXJTdHlsZVNo ZWV0TG9jYXRpb24oSlNTdHJpbmdSZWYganNVUkwpCiB7CiAgICAgUmV0YWluUHRyPENGU3RyaW5n UmVmPiB1cmxTdHJpbmcoQWRvcHRDRiwgSlNTdHJpbmdDb3B5Q0ZTdHJpbmcoMCwganNVUkwpKTsK ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJl ZS5jcHAgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93aW4vRHVtcFJlbmRlclRyZWUuY3Bw CmluZGV4IDY2MjY2YjkuLjk0YzI4MzAgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL0R1bXBSZW5k ZXJUcmVlL3dpbi9EdW1wUmVuZGVyVHJlZS5jcHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvd2luL0R1bXBSZW5kZXJUcmVlLmNwcApAQCAtNjU3LDYgKzY1Nyw2NSBAQCBzdGF0aWMg Ym9vbCBzaG91bGRMb2dGcmFtZUxvYWREZWxlZ2F0ZXMoY29uc3QgY2hhciogcGF0aE9yVVJMKQog ICAgIHJldHVybiBzdHJzdHIocGF0aE9yVVJMLCAiL2xvYWRpbmcvIikgfHwgc3Ryc3RyKHBhdGhP clVSTCwgIlxcbG9hZGluZ1xcIik7CiB9CiAKK3N0YXRpYyB2b2lkIHJlc2V0RGVmYXVsdHNUb0Nv bnNpc3RlbnRWYWx1ZXMoSVdlYlByZWZlcmVuY2VzKiBwcmVmZXJlbmNlcykKK3sKKyNpZmRlZiBV U0VfTUFDX0ZPTlRTCisgICAgc3RhdGljIEJTVFIgc3RhbmRhcmRGYW1pbHkgPSBTeXNBbGxvY1N0 cmluZyhURVhUKCJUaW1lcyIpKTsKKyAgICBzdGF0aWMgQlNUUiBmaXhlZEZhbWlseSA9IFN5c0Fs bG9jU3RyaW5nKFRFWFQoIkNvdXJpZXIiKSk7CisgICAgc3RhdGljIEJTVFIgc2Fuc1NlcmlmRmFt aWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiSGVsdmV0aWNhIikpOworICAgIHN0YXRpYyBCU1RS IGN1cnNpdmVGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJBcHBsZSBDaGFuY2VyeSIpKTsK KyAgICBzdGF0aWMgQlNUUiBmYW50YXN5RmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiUGFw eXJ1cyIpKTsKKyNlbHNlCisgICAgc3RhdGljIEJTVFIgc3RhbmRhcmRGYW1pbHkgPSBTeXNBbGxv Y1N0cmluZyhURVhUKCJUaW1lcyBOZXcgUm9tYW4iKSk7CisgICAgc3RhdGljIEJTVFIgZml4ZWRG YW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJDb3VyaWVyIE5ldyIpKTsKKyAgICBzdGF0aWMg QlNUUiBzYW5zU2VyaWZGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJBcmlhbCIpKTsKKyAg ICBzdGF0aWMgQlNUUiBjdXJzaXZlRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQ29taWMg U2FucyBNUyIpKTsgLy8gTm90IGFjdHVhbGx5IGN1cnNpdmUsIGJ1dCBpdCdzIHdoYXQgSUUgYW5k IEZpcmVmb3ggdXNlLgorICAgIHN0YXRpYyBCU1RSIGZhbnRhc3lGYW1pbHkgPSBTeXNBbGxvY1N0 cmluZyhURVhUKCJUaW1lcyBOZXcgUm9tYW4iKSk7CisjZW5kaWYKKworICAgIHByZWZlcmVuY2Vz LT5zZXRTdGFuZGFyZEZvbnRGYW1pbHkoc3RhbmRhcmRGYW1pbHkpOworICAgIHByZWZlcmVuY2Vz LT5zZXRGaXhlZEZvbnRGYW1pbHkoZml4ZWRGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRT ZXJpZkZvbnRGYW1pbHkoc3RhbmRhcmRGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRTYW5z U2VyaWZGb250RmFtaWx5KHNhbnNTZXJpZkZhbWlseSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEN1 cnNpdmVGb250RmFtaWx5KGN1cnNpdmVGYW1pbHkpOworICAgIHByZWZlcmVuY2VzLT5zZXRGYW50 YXN5Rm9udEZhbWlseShmYW50YXN5RmFtaWx5KTsKKworICAgIHByZWZlcmVuY2VzLT5zZXRBdXRv c2F2ZXMoRkFMU0UpOworICAgIHByZWZlcmVuY2VzLT5zZXREZWZhdWx0Rm9udFNpemUoMTYpOwor ICAgIHByZWZlcmVuY2VzLT5zZXREZWZhdWx0Rml4ZWRGb250U2l6ZSgxMyk7CisgICAgcHJlZmVy ZW5jZXMtPnNldE1pbmltdW1Gb250U2l6ZSgxKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YUVu YWJsZWQoRkFMU0UpOworICAgIHByZWZlcmVuY2VzLT5zZXRQbHVnSW5zRW5hYmxlZChUUlVFKTsK KyAgICBwcmVmZXJlbmNlcy0+c2V0RE9NUGFzdGVBbGxvd2VkKFRSVUUpOworICAgIHByZWZlcmVu Y2VzLT5zZXRFZGl0YWJsZUxpbmtCZWhhdmlvcihXZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdp dGhTaGlmdEtleSk7CisgICAgcHJlZmVyZW5jZXMtPnNldEZvbnRTbW9vdGhpbmcoRm9udFNtb290 aGluZ1R5cGVTdGFuZGFyZCk7CisgICAgcHJlZmVyZW5jZXMtPnNldFVzZXNQYWdlQ2FjaGUoRkFM U0UpOworICAgIHByZWZlcmVuY2VzLT5zZXRQcml2YXRlQnJvd3NpbmdFbmFibGVkKEZBTFNFKTsK KyAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdENhbk9wZW5XaW5kb3dzQXV0b21hdGljYWxs eShUUlVFKTsKKyAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YVNjcmlwdEVuYWJsZWQoVFJVRSk7Cisg ICAgcHJlZmVyZW5jZXMtPnNldFRhYnNUb0xpbmtzKEZBTFNFKTsKKyAgICBwcmVmZXJlbmNlcy0+ c2V0U2hvdWxkUHJpbnRCYWNrZ3JvdW5kcyhUUlVFKTsKKworICAgIGlmIChwZXJzaXN0ZW50VXNl clN0eWxlU2hlZXRMb2NhdGlvbikgeworICAgICAgICBWZWN0b3I8d2NoYXJfdD4gdXJsQ2hhcmFj dGVycyhDRlN0cmluZ0dldExlbmd0aChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2NhdGlvbi5n ZXQoKSkpOworICAgICAgICBDRlN0cmluZ0dldENoYXJhY3RlcnMocGVyc2lzdGVudFVzZXJTdHls ZVNoZWV0TG9jYXRpb24uZ2V0KCksIENGUmFuZ2VNYWtlKDAsIENGU3RyaW5nR2V0TGVuZ3RoKHBl cnNpc3RlbnRVc2VyU3R5bGVTaGVldExvY2F0aW9uLmdldCgpKSksIChVbmlDaGFyICopdXJsQ2hh cmFjdGVycy5kYXRhKCkpOworICAgICAgICBCU1RSIHVybCA9IFN5c0FsbG9jU3RyaW5nTGVuKHVy bENoYXJhY3RlcnMuZGF0YSgpLCB1cmxDaGFyYWN0ZXJzLnNpemUoKSk7CisgICAgICAgIHByZWZl cmVuY2VzLT5zZXRVc2VyU3R5bGVTaGVldExvY2F0aW9uKHVybCk7CisgICAgICAgIFN5c0ZyZWVT dHJpbmcodXJsKTsKKyAgICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNoZWV0RW5hYmxl ZChUUlVFKTsKKyAgICB9IGVsc2UKKyAgICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNo ZWV0RW5hYmxlZChGQUxTRSk7CisKKyAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4g cHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7CisgICAgaWYgKHByZWZzUHJpdmF0ZSkg eworICAgICAgICBwcmVmc1ByaXZhdGUtPnNldEF1dGhvckFuZFVzZXJTdHlsZXNFbmFibGVkKFRS VUUpOworICAgICAgICBwcmVmc1ByaXZhdGUtPnNldERldmVsb3BlckV4dHJhc0VuYWJsZWQoRkFM U0UpOworICAgICAgICBwcmVmc1ByaXZhdGUtPnNldFNob3VsZFBhaW50TmF0aXZlQ29udHJvbHMo RkFMU0UpOyAvLyBGSVhNRSAtIG5lZWQgdG8gbWFrZSBEUlQgcGFzcyB3aXRoIFdpbmRvd3MgbmF0 aXZlIGNvbnRyb2xzIDxodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTU5 Mj4KKyAgICAgICAgcHJlZnNQcml2YXRlLT5zZXRYU1NBdWRpdG9yRW5hYmxlZChGQUxTRSk7Cisg ICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0T2ZmbGluZVdlYkFwcGxpY2F0aW9uQ2FjaGVFbmFibGVk KEZBTFNFKTsKKyAgICB9Cit9CisKIHN0YXRpYyB2b2lkIHJlc2V0V2ViVmlld1RvQ29uc2lzdGVu dFN0YXRlQmVmb3JlVGVzdGluZygpCiB7CiAgICAgQ09NUHRyPElXZWJWaWV3PiB3ZWJWaWV3OwpA QCAtNjczLDI4ICs3MzIsMTAgQEAgc3RhdGljIHZvaWQgcmVzZXRXZWJWaWV3VG9Db25zaXN0ZW50 U3RhdGVCZWZvcmVUZXN0aW5nKCkKICAgICAgICAgd2ViSUJBY3Rpb25zLT5yZXNldFBhZ2Vab29t KDApOwogICAgIH0KIAorCiAgICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXM7 CiAgICAgaWYgKFNVQ0NFRURFRCh3ZWJWaWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkg ewotICAgICAgICBwcmVmZXJlbmNlcy0+c2V0UHJpdmF0ZUJyb3dzaW5nRW5hYmxlZChGQUxTRSk7 Ci0gICAgICAgIHByZWZlcmVuY2VzLT5zZXRKYXZhU2NyaXB0Q2FuT3BlbldpbmRvd3NBdXRvbWF0 aWNhbGx5KFRSVUUpOwotCi0gICAgICAgIGlmIChwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRMb2Nh dGlvbikgewotICAgICAgICAgICAgVmVjdG9yPHdjaGFyX3Q+IHVybENoYXJhY3RlcnMoQ0ZTdHJp bmdHZXRMZW5ndGgocGVyc2lzdGVudFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpKTsKLSAg ICAgICAgICAgIENGU3RyaW5nR2V0Q2hhcmFjdGVycyhwZXJzaXN0ZW50VXNlclN0eWxlU2hlZXRM b2NhdGlvbi5nZXQoKSwgQ0ZSYW5nZU1ha2UoMCwgQ0ZTdHJpbmdHZXRMZW5ndGgocGVyc2lzdGVu dFVzZXJTdHlsZVNoZWV0TG9jYXRpb24uZ2V0KCkpKSwgKFVuaUNoYXIgKil1cmxDaGFyYWN0ZXJz LmRhdGEoKSk7Ci0gICAgICAgICAgICBCU1RSIHVybCA9IFN5c0FsbG9jU3RyaW5nTGVuKHVybENo YXJhY3RlcnMuZGF0YSgpLCB1cmxDaGFyYWN0ZXJzLnNpemUoKSk7Ci0gICAgICAgICAgICBwcmVm ZXJlbmNlcy0+c2V0VXNlclN0eWxlU2hlZXRMb2NhdGlvbih1cmwpOwotICAgICAgICAgICAgU3lz RnJlZVN0cmluZyh1cmwpOwotICAgICAgICAgICAgcHJlZmVyZW5jZXMtPnNldFVzZXJTdHlsZVNo ZWV0RW5hYmxlZChUUlVFKTsKLSAgICAgICAgfSBlbHNlCi0gICAgICAgICAgICBwcmVmZXJlbmNl cy0+c2V0VXNlclN0eWxlU2hlZXRFbmFibGVkKEZBTFNFKTsKLQotICAgICAgICBDT01QdHI8SVdl YlByZWZlcmVuY2VzUHJpdmF0ZT4gcHJlZnNQcml2YXRlKFF1ZXJ5LCBwcmVmZXJlbmNlcyk7Ci0g ICAgICAgIGlmIChwcmVmc1ByaXZhdGUpIHsKLSAgICAgICAgICAgIHByZWZzUHJpdmF0ZS0+c2V0 QXV0aG9yQW5kVXNlclN0eWxlc0VuYWJsZWQoVFJVRSk7Ci0gICAgICAgICAgICBwcmVmc1ByaXZh dGUtPnNldERldmVsb3BlckV4dHJhc0VuYWJsZWQoRkFMU0UpOwotICAgICAgICAgICAgcHJlZnNQ cml2YXRlLT5zZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKEZBTFNFKTsgLy8gRklYTUUgLSBu ZWVkIHRvIG1ha2UgRFJUIHBhc3Mgd2l0aCBXaW5kb3dzIG5hdGl2ZSBjb250cm9scyA8aHR0cDov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1OTI+Ci0gICAgICAgICAgICBwcmVm c1ByaXZhdGUtPnNldFhTU0F1ZGl0b3JFbmFibGVkKEZBTFNFKTsKLSAgICAgICAgfQorICAgICAg ICByZXNldERlZmF1bHRzVG9Db25zaXN0ZW50VmFsdWVzKHByZWZlcmVuY2VzLmdldCgpKTsKICAg ICB9CiAKICAgICBDT01QdHI8SVdlYlZpZXdFZGl0aW5nPiB2aWV3RWRpdGluZzsKQEAgLTgyOSw0 NCArODcwLDYgQEAgZXhpdDoKICAgICByZXR1cm47CiB9CiAKLXN0YXRpYyB2b2lkIGluaXRpYWxp emVQcmVmZXJlbmNlcyhJV2ViUHJlZmVyZW5jZXMqIHByZWZlcmVuY2VzKQotewotI2lmZGVmIFVT RV9NQUNfRk9OVFMKLSAgICBCU1RSIHN0YW5kYXJkRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVY VCgiVGltZXMiKSk7Ci0gICAgQlNUUiBmaXhlZEZhbWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQo IkNvdXJpZXIiKSk7Ci0gICAgQlNUUiBzYW5zU2VyaWZGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhU RVhUKCJIZWx2ZXRpY2EiKSk7Ci0gICAgQlNUUiBjdXJzaXZlRmFtaWx5ID0gU3lzQWxsb2NTdHJp bmcoVEVYVCgiQXBwbGUgQ2hhbmNlcnkiKSk7Ci0gICAgQlNUUiBmYW50YXN5RmFtaWx5ID0gU3lz QWxsb2NTdHJpbmcoVEVYVCgiUGFweXJ1cyIpKTsKLSNlbHNlCi0gICAgQlNUUiBzdGFuZGFyZEZh bWlseSA9IFN5c0FsbG9jU3RyaW5nKFRFWFQoIlRpbWVzIE5ldyBSb21hbiIpKTsKLSAgICBCU1RS IGZpeGVkRmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiQ291cmllciBOZXciKSk7Ci0gICAg QlNUUiBzYW5zU2VyaWZGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJBcmlhbCIpKTsKLSAg ICBCU1RSIGN1cnNpdmVGYW1pbHkgPSBTeXNBbGxvY1N0cmluZyhURVhUKCJDb21pYyBTYW5zIE1T IikpOyAvLyBOb3QgYWN0dWFsbHkgY3Vyc2l2ZSwgYnV0IGl0J3Mgd2hhdCBJRSBhbmQgRmlyZWZv eCB1c2UuCi0gICAgQlNUUiBmYW50YXN5RmFtaWx5ID0gU3lzQWxsb2NTdHJpbmcoVEVYVCgiVGlt ZXMgTmV3IFJvbWFuIikpOwotI2VuZGlmCi0KLSAgICBwcmVmZXJlbmNlcy0+c2V0U3RhbmRhcmRG b250RmFtaWx5KHN0YW5kYXJkRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0Rml4ZWRGb250 RmFtaWx5KGZpeGVkRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0U2VyaWZGb250RmFtaWx5 KHN0YW5kYXJkRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0U2Fuc1NlcmlmRm9udEZhbWls eShzYW5zU2VyaWZGYW1pbHkpOwotICAgIHByZWZlcmVuY2VzLT5zZXRDdXJzaXZlRm9udEZhbWls eShjdXJzaXZlRmFtaWx5KTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0RmFudGFzeUZvbnRGYW1pbHko ZmFudGFzeUZhbWlseSk7Ci0KLSAgICBwcmVmZXJlbmNlcy0+c2V0QXV0b3NhdmVzKEZBTFNFKTsK LSAgICBwcmVmZXJlbmNlcy0+c2V0SmF2YUVuYWJsZWQoRkFMU0UpOwotICAgIHByZWZlcmVuY2Vz LT5zZXRQbHVnSW5zRW5hYmxlZChUUlVFKTsKLSAgICBwcmVmZXJlbmNlcy0+c2V0RE9NUGFzdGVB bGxvd2VkKFRSVUUpOwotICAgIHByZWZlcmVuY2VzLT5zZXRFZGl0YWJsZUxpbmtCZWhhdmlvcihX ZWJLaXRFZGl0YWJsZUxpbmtPbmx5TGl2ZVdpdGhTaGlmdEtleSk7Ci0gICAgcHJlZmVyZW5jZXMt PnNldEZvbnRTbW9vdGhpbmcoRm9udFNtb290aGluZ1R5cGVTdGFuZGFyZCk7Ci0gICAgcHJlZmVy ZW5jZXMtPnNldFVzZXNQYWdlQ2FjaGUoRkFMU0UpOwotCi0gICAgU3lzRnJlZVN0cmluZyhzdGFu ZGFyZEZhbWlseSk7Ci0gICAgU3lzRnJlZVN0cmluZyhmaXhlZEZhbWlseSk7Ci0gICAgU3lzRnJl ZVN0cmluZyhzYW5zU2VyaWZGYW1pbHkpOwotICAgIFN5c0ZyZWVTdHJpbmcoY3Vyc2l2ZUZhbWls eSk7Ci0gICAgU3lzRnJlZVN0cmluZyhmYW50YXN5RmFtaWx5KTsKLX0KLQogc3RhdGljIEJvb2xl YW4gcHRocmVhZEVxdWFsQ2FsbGJhY2soY29uc3Qgdm9pZCogdmFsdWUxLCBjb25zdCB2b2lkKiB2 YWx1ZTIpCiB7CiAgICAgcmV0dXJuIChCb29sZWFuKXB0aHJlYWRfZXF1YWwoKihwdGhyZWFkX3Qq KXZhbHVlMSwgKihwdGhyZWFkX3QqKXZhbHVlMik7CkBAIC0xMDUxLDEyICsxMDU0LDYgQEAgSVdl YlZpZXcqIGNyZWF0ZVdlYlZpZXdBbmRPZmZzY3JlZW5XaW5kb3coSFdORCogd2ViVmlld1dpbmRv dykKICAgICBpZiAoRkFJTEVEKHdlYlZpZXctPnNldFJlc291cmNlTG9hZERlbGVnYXRlKHNoYXJl ZFJlc291cmNlTG9hZERlbGVnYXRlLmdldCgpKSkpCiAgICAgICAgIHJldHVybiAwOwogCi0gICAg Q09NUHRyPElXZWJQcmVmZXJlbmNlcz4gcHJlZmVyZW5jZXM7Ci0gICAgaWYgKEZBSUxFRCh3ZWJW aWV3LT5wcmVmZXJlbmNlcygmcHJlZmVyZW5jZXMpKSkKLSAgICAgICAgcmV0dXJuIDA7Ci0KLSAg ICBpbml0aWFsaXplUHJlZmVyZW5jZXMocHJlZmVyZW5jZXMuZ2V0KCkpOwotCiAgICAgb3Blbldp bmRvd3MoKS5hcHBlbmQoaG9zdFdpbmRvdyk7CiAgICAgd2luZG93VG9XZWJWaWV3TWFwKCkuc2V0 KGhvc3RXaW5kb3csIHdlYlZpZXcpOwogICAgIHJldHVybiB3ZWJWaWV3OwpAQCAtMTEyNCwxOCAr MTEyMSw2IEBAIGludCBtYWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiAgICAgc2hhcmVkRWRp dGluZ0RlbGVnYXRlLmFkb3B0UmVmKG5ldyBFZGl0aW5nRGVsZWdhdGUpOwogICAgIHNoYXJlZFJl c291cmNlTG9hZERlbGVnYXRlLmFkb3B0UmVmKG5ldyBSZXNvdXJjZUxvYWREZWxlZ2F0ZSk7CiAK LSAgICAvLyBGSVhNRSAtIG5lZWQgdG8gbWFrZSBEUlQgcGFzcyB3aXRoIFdpbmRvd3MgbmF0aXZl IGNvbnRyb2xzIDxodHRwOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTU5Mj4K LSAgICBDT01QdHI8SVdlYlByZWZlcmVuY2VzPiB0bXBQcmVmZXJlbmNlczsKLSAgICBpZiAoRkFJ TEVEKFdlYktpdENyZWF0ZUluc3RhbmNlKENMU0lEX1dlYlByZWZlcmVuY2VzLCAwLCBJSURfSVdl YlByZWZlcmVuY2VzLCByZWludGVycHJldF9jYXN0PHZvaWQqKj4oJnRtcFByZWZlcmVuY2VzKSkp KQotICAgICAgICByZXR1cm4gLTE7Ci0gICAgQ09NUHRyPElXZWJQcmVmZXJlbmNlcz4gc3RhbmRh cmRQcmVmZXJlbmNlczsKLSAgICBpZiAoRkFJTEVEKHRtcFByZWZlcmVuY2VzLT5zdGFuZGFyZFBy ZWZlcmVuY2VzKCZzdGFuZGFyZFByZWZlcmVuY2VzKSkpCi0gICAgICAgIHJldHVybiAtMTsKLSAg ICBDT01QdHI8SVdlYlByZWZlcmVuY2VzUHJpdmF0ZT4gc3RhbmRhcmRQcmVmZXJlbmNlc1ByaXZh dGU7Ci0gICAgaWYgKEZBSUxFRChzdGFuZGFyZFByZWZlcmVuY2VzLT5RdWVyeUludGVyZmFjZSgm c3RhbmRhcmRQcmVmZXJlbmNlc1ByaXZhdGUpKSkKLSAgICAgICAgcmV0dXJuIC0xOwotICAgIHN0 YW5kYXJkUHJlZmVyZW5jZXNQcml2YXRlLT5zZXRTaG91bGRQYWludE5hdGl2ZUNvbnRyb2xzKEZB TFNFKTsKLQogICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldyhBZG9wdENPTSwgY3JlYXRlV2Vi Vmlld0FuZE9mZnNjcmVlbldpbmRvdygmd2ViVmlld1dpbmRvdykpOwogICAgIGlmICghd2ViVmll dykKICAgICAgICAgcmV0dXJuIC0xOwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRl clRyZWUvd2luL0xheW91dFRlc3RDb250cm9sbGVyV2luLmNwcCBiL1dlYktpdFRvb2xzL0R1bXBS ZW5kZXJUcmVlL3dpbi9MYXlvdXRUZXN0Q29udHJvbGxlcldpbi5jcHAKaW5kZXggODFjMjc1MS4u NzQyNjc0YyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd2luL0xheW91 dFRlc3RDb250cm9sbGVyV2luLmNwcAorKysgYi9XZWJLaXRUb29scy9EdW1wUmVuZGVyVHJlZS93 aW4vTGF5b3V0VGVzdENvbnRyb2xsZXJXaW4uY3BwCkBAIC02OTQsNiArNjk0LDI3IEBAIHZvaWQg TGF5b3V0VGVzdENvbnRyb2xsZXI6OmNsZWFyQWxsRGF0YWJhc2VzKCkKICAgICBkYXRhYmFzZU1h bmFnZXItPmRlbGV0ZUFsbERhdGFiYXNlcygpOwogfQogCit2b2lkIExheW91dFRlc3RDb250cm9s bGVyOjpvdmVycmlkZVByZWZlcmVuY2UoSlNTdHJpbmdSZWYga2V5LCBKU1N0cmluZ1JlZiBmbGFn KQoreworICAgIENPTVB0cjxJV2ViVmlldz4gd2ViVmlldzsKKyAgICBpZiAoRkFJTEVEKGZyYW1l LT53ZWJWaWV3KCZ3ZWJWaWV3KSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2Vi UHJlZmVyZW5jZXM+IHByZWZlcmVuY2VzOworICAgIGlmIChGQUlMRUQod2ViVmlldy0+cHJlZmVy ZW5jZXMoJnByZWZlcmVuY2VzKSkpCisgICAgICAgIHJldHVybjsKKworICAgIENPTVB0cjxJV2Vi UHJlZmVyZW5jZXNQcml2YXRlPiBwcmVmc1ByaXZhdGUoUXVlcnksIHByZWZlcmVuY2VzKTsKKyAg ICBpZiAoIXByZWZzUHJpdmF0ZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQlNUUiBrZXlCU1RS ID0gSlNTdHJpbmdDb3B5QlNUUihrZXkpOworICAgIEJTVFIgZmxhZ0JTVFIgPSBKU1N0cmluZ0Nv cHlCU1RSKGZsYWcpOworICAgIHByZWZzUHJpdmF0ZS0+c2V0UHJlZmVyZW5jZUZvclRlc3Qoa2V5 QlNUUiwgZmxhZ0JTVFIpOworICAgIFN5c0ZyZWVTdHJpbmcoa2V5QlNUUik7CisgICAgU3lzRnJl ZVN0cmluZyhmbGFnQlNUUik7Cit9CisKIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldERh dGFiYXNlUXVvdGEodW5zaWduZWQgbG9uZyBsb25nIHF1b3RhKQogewogICAgIHByaW50ZigiRVJS T1I6IExheW91dFRlc3RDb250cm9sbGVyOjpzZXREYXRhYmFzZVF1b3RhKCkgbm90IGltcGxlbWVu dGVkXG4iKTsKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0R1bXBSZW5kZXJUcmVlL3d4L0xheW91 dFRlc3RDb250cm9sbGVyV3guY3BwIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5 b3V0VGVzdENvbnRyb2xsZXJXeC5jcHAKaW5kZXggZmE3ZTU0MS4uYzA2YjIzYyAxMDA2NDQKLS0t IGEvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xsZXJXeC5j cHAKKysrIGIvV2ViS2l0VG9vbHMvRHVtcFJlbmRlclRyZWUvd3gvTGF5b3V0VGVzdENvbnRyb2xs ZXJXeC5jcHAKQEAgLTI2MCwzICsyNjAsOSBAQCB2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp3 YWl0Rm9yUG9saWN5RGVsZWdhdGUoKQogewogICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgdGhpcy4K IH0KKwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6b3ZlcnJpZGVQcmVmZXJlbmNlKEpTU3Ry aW5nUmVmIGtleSwgSlNTdHJpbmdSZWYgZmxhZykKK3sKKyAgICAvLyBGSVhNRSBpbXBsZW1lbnQK K30KKwo=