96614 2012-09-13 00:45:14 -0700 Need to clear exception in JSDictionary for operations that might have. 2012-12-18 16:11:39 -0800 1 1 1 Unclassified WebKit WebCore JavaScript 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 96739 101852 104596 1 charles.wei charles.wei abarth alecflett darin dglazkov ggaren gyuyoung.kim haraken hausmann japhet jiyeon0402.kim jsbell michael ojan.autocc ossy PeterHWang rakuco rwlbuis sam staikos tonikitoo tony webkit.review.bot yong.li.webkit oldest_to_newest 719165 0 charles.wei 2012-09-13 00:45:14 -0700 https://bugs.webkit.org/show_bug.cgi?id=84207 introduced array-type keyPath support. So when creating a indexeddb, the IDBDatabase::createObjectStore will first try if the keyPath is an array, if not, it then tries it as a JSValue of String type. Code below: @@ -95,18 +95,26 @@ PassRefPtr<IDBObjectStore> IDBDatabase::createObjectStore(const String& name, co IDBKeyPath keyPath; if (!options.isUndefinedOrNull()) { String keyPathString; - if (options.getWithUndefinedOrNullCheck("keyPath", keyPathString)) + Vector<String> keyPathArray; + if (options.get("keyPath", keyPathArray)) + keyPath = IDBKeyPath(keyPathArray); + else if (options.getWithUndefinedOrNullCheck("keyPath", keyPathString)) But if the Javascript tries to create the IDB with a non-array type key type below: db.createObjectStore("people", {keyPath: "id"}); the first try as a keyPathArray in above native code will fail and leaves an exception in current ExecState, and that will be carried over to the following check as a keyPathString with "else if (options.getWithUndefinedOrNullCheck("keyPath", keyPathString))", in which it will check if there's any exception in current ExecState, and fail if there is exception. The exception carried over will fail it. So we need to clear any exception in getWithUndefinedOrNullCheck() to make sure no exception is carried over. 719198 1 163809 charles.wei 2012-09-13 01:12:44 -0700 Created attachment 163809 Patch 719514 2 yong.li.webkit 2012-09-13 08:17:43 -0700 This patch does not only affect blackberry port, does it? 719535 3 163809 yong.li.webkit 2012-09-13 08:35:30 -0700 Comment on attachment 163809 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=163809&action=review > Source/WebCore/ChangeLog:16 > + IndexedDB now supports both array-type keyPath and string type keyPath, > + it will first try array type, if that fails, it will try the string type > + by calling JSDictionary::getWithUndefinedOrNullCheck, but the fail as > + array type will generate an execption in ExecState and will carried over. > + We need to clear the exception to avoid the impact to the check as a string. > + I'm not an expert here. But according to this description, it should be IDBDatabase's responsibility to clear exception. I see webkit usually clears exception immediately after calling into JSC, rather than before. 719541 4 163809 haraken 2012-09-13 08:40:24 -0700 Comment on attachment 163809 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=163809&action=review >> Source/WebCore/ChangeLog:16 >> + > > I'm not an expert here. But according to this description, it should be IDBDatabase's responsibility to clear exception. I see webkit usually clears exception immediately after calling into JSC, rather than before. Yong is right. Would you update the patch? 720403 5 charles.wei 2012-09-14 00:27:23 -0700 (In reply to comment #3) > (From update of attachment 163809 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=163809&action=review > > > Source/WebCore/ChangeLog:16 > > + IndexedDB now supports both array-type keyPath and string type keyPath, > > + it will first try array type, if that fails, it will try the string type > > + by calling JSDictionary::getWithUndefinedOrNullCheck, but the fail as > > + array type will generate an execption in ExecState and will carried over. > > + We need to clear the exception to avoid the impact to the check as a string. > > + > > I'm not an expert here. But according to this description, it should be IDBDatabase's responsibility to clear exception. I see webkit usually clears exception immediately after calling into JSC, rather than before. Thanks, Yong, for the review, and the suggestion. No, it couldn't be the IDBDatabase's responsibility, the IDBDatabase doesn't know how the Dictionary is implemented, and doesn't know that Dictionary is actually storing the original ExecState and JSValue inside. The Dictionary (and internal JSDictionary) is responsible to clear the exception. The Dictionary is an internal data and should not contaminate the ExecState by leaving an exception there. I moved the clearException() right after where it happens in the new patch, following your suggestions, but still (and have to be) inside JSDictionary. 720405 6 164065 charles.wei 2012-09-14 00:31:33 -0700 Created attachment 164065 Patch 720413 7 164065 haraken 2012-09-14 00:42:22 -0700 Comment on attachment 164065 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=164065&action=review OK. > Source/WebCore/bindings/js/JSDictionary.h:150 > + m_exec->clearException(); > return ExceptionThrown; At first I thought that this will make it impossible to retrieve the exception later. But the fact that we return 'ExceptionThrown' means that we're no longer interested in what exception was thrown. In that sense, clearing the exception here would make sense. 720415 8 164065 charles.wei 2012-09-14 00:48:15 -0700 Comment on attachment 164065 Patch Thanks, Kentaro. 720428 9 164065 webkit.review.bot 2012-09-14 01:26:42 -0700 Comment on attachment 164065 Patch Clearing flags on attachment: 164065 Committed r128568: <http://trac.webkit.org/changeset/128568> 720429 10 webkit.review.bot 2012-09-14 01:26:46 -0700 All reviewed patches have been landed. Closing bug. 720472 11 webkit.review.bot 2012-09-14 02:29:20 -0700 Re-opened since this is blocked by 96739 720481 12 ossy 2012-09-14 02:44:36 -0700 (In reply to comment #11) > Re-opened since this is blocked by 96739 Rolled out by https://trac.webkit.org/changeset/128574 , because it broke 3 tests everywhere (at leaset on GTK, Qt, EFL) - fast/dom/Geolocation/argument-types.html started to crash: ------------------------------------------------------------- crash log for DumpRenderTree (pid 17744): STDOUT: <empty> STDERR: 1 0xf6a0dbbc /home/webkitbuildbot/slaves/release32bit-NRWT/buildslave/qt-linux-32-release-NRWT/build/WebKitBuild/Release/lib/libQtWebKit.so.5(+0x1786bbc) [0xf6a0dbbc] STDERR: 2 0xf77e0400 [0xf77e0400] ... - fast/events/constructors/message-event-constructor.html started to fail: --------------------------------------------------------------------------- --- /home/webkitbuildbot/slaves/release32bit-NRWT/buildslave/qt-linux-32-release-NRWT/build/layout-test-results/fast/events/constructors/message-event-constructor-expected.txt +++ /home/webkitbuildbot/slaves/release32bit-NRWT/buildslave/qt-linux-32-release-NRWT/build/layout-test-results/fast/events/constructors/message-event-constructor-actual.txt @@ -80,19 +80,19 @@ PASS new MessageEvent('eventType', { ports: [] }).ports is [] PASS new MessageEvent('eventType', { ports: undefined }).ports is [] PASS new MessageEvent('eventType', { ports: null }).ports is [] -PASS new MessageEvent('eventType', { ports: [1, 2, 3] }).ports[2] threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: test_object }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: document }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: false }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: true }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: '' }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: 'chocolate' }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: 12345 }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: 18446744073709551615 }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { ports: NaN }).ports threw exception TypeError: Type error. -PASS new MessageEvent('eventType', { get ports() { return 123; } }).ports threw exception TypeError: Type error. +PASS new MessageEvent('eventType', { ports: [1, 2, 3] }).ports[2] threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: [1, 2, 3] }).ports'). +PASS new MessageEvent('eventType', { ports: test_object }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: test_object }).ports'). +PASS new MessageEvent('eventType', { ports: document }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: document }).ports'). +PASS new MessageEvent('eventType', { ports: false }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: false }).ports'). +PASS new MessageEvent('eventType', { ports: true }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: true }).ports'). +PASS new MessageEvent('eventType', { ports: '' }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: '' }).ports'). +PASS new MessageEvent('eventType', { ports: 'chocolate' }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: 'chocolate' }).ports'). +PASS new MessageEvent('eventType', { ports: 12345 }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: 12345 }).ports'). +PASS new MessageEvent('eventType', { ports: 18446744073709551615 }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: 18446744073709551615 }).ports'). +PASS new MessageEvent('eventType', { ports: NaN }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: NaN }).ports'). +PASS new MessageEvent('eventType', { get ports() { return 123; } }).ports threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { get ports() { return 123; } }).ports'). PASS new MessageEvent('eventType', { get ports() { throw 'MessageEvent Error'; } }) threw exception MessageEvent Error. -PASS new MessageEvent('eventType', { ports: {valueOf: function () { return [channel.port1, channel.port2, channel.port2]; } } }).ports[0] threw exception TypeError: Type error. +PASS new MessageEvent('eventType', { ports: {valueOf: function () { return [channel.port1, channel.port2, channel.port2]; } } }).ports[0] threw exception TypeError: 'undefined' is not an object (evaluating 'new MessageEvent('eventType', { ports: {valueOf: function () { return [channel.port1, channel.port2, channel.port2]; } } }).ports'). PASS new MessageEvent('eventType', { bubbles: true, cancelable: true, data: test_object, origin: 'wonderful', lastEventId: 'excellent', source: window, ports: [channel.port1, channel.port2, channel2.port1] }).bubbles is true PASS new MessageEvent('eventType', { bubbles: true, cancelable: true, data: test_object, origin: 'wonderful', lastEventId: 'excellent', source: window, ports: [channel.port1, channel.port2, channel2.port1] }).cancelable is true PASS new MessageEvent('eventType', { bubbles: true, cancelable: true, data: test_object, origin: 'wonderful', lastEventId: 'excellent', source: window, ports: [channel.port1, channel.port2, channel2.port1] }).data is test_object - fast/files/blob-constructor.html started to fail: ---------------------------------------------------- --- /home/webkitbuildbot/slaves/release32bit-NRWT/buildslave/qt-linux-32-release-NRWT/build/layout-test-results/fast/files/blob-constructor-expected.txt +++ /home/webkitbuildbot/slaves/release32bit-NRWT/buildslave/qt-linux-32-release-NRWT/build/layout-test-results/fast/files/blob-constructor-actual.txt @@ -25,11 +25,11 @@ PASS new Blob([throwingObj]) threw exception Error. PASS (new Blob([], {unknownKey:'value'})) instanceof window.Blob is true PASS new Blob([], {endings:'illegalValue'}) threw exception TypeError: The endings property must be either "transparent" or "native". -PASS new Blob([], {endings:throwingObj}) threw exception Error. -PASS new Blob([], {type:throwingObj}) threw exception Error. +FAIL new Blob([], {endings:throwingObj}) should throw Error. Was [object Blob]. +FAIL new Blob([], {type:throwingObj}) should throw Error. Was [object Blob]. PASS new Blob([], {type:'helloĂŽ'}) threw exception SyntaxError: type must consist of ASCII characters. -PASS new Blob([], {endings:throwingObj1, type:throwingObj2}) threw exception Error 1. -PASS new Blob([], {type:throwingObj2, endings:throwingObj1}) threw exception Error 1. +FAIL new Blob([], {endings:throwingObj1, type:throwingObj2}) should throw Error 1. Was [object Blob]. +FAIL new Blob([], {type:throwingObj2, endings:throwingObj1}) should throw Error 1. Was [object Blob]. PASS new Blob([], {type:throwingObj2, endings:'illegal'}) threw exception TypeError: The endings property must be either "transparent" or "native". PASS (new Blob([], null)) instanceof window.Blob threw exception TypeError: Second argument of the constructor is not of type Object. PASS (new Blob([], undefined)) instanceof window.Blob threw exception TypeError: Second argument of the constructor is not of type Object. 720487 13 charles.wei 2012-09-14 02:59:34 -0700 hmmm, will look into the test cases broken. 762784 14 173253 charles.wei 2012-11-09 03:14:58 -0800 Created attachment 173253 Patch 762806 15 173253 webkit.review.bot 2012-11-09 03:41:15 -0800 Comment on attachment 173253 Patch Attachment 173253 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/14777385 762815 16 173261 charles.wei 2012-11-09 04:13:19 -0800 Created attachment 173261 Patch 762828 17 173261 charles.wei 2012-11-09 04:29:48 -0800 Comment on attachment 173261 Patch Tried to introduce an API Dictionary::clearException() with last patch so that the IndexedDB can call that to clear the exceptions between 2 calls of Dictionary::get() and Dictionary::getWithUndefinedOrNullCheck(), that doesn't seem good because 1) Needs to have both API for both V8 and JSC porting, even though V8 porting doesn't need that at all; 2) exposes the implementation details of Dictionary to external world; 3) violates the const syntax of the dictionary object. So I decided to clear the exception inside JSDictionary::getWithUndefinedOrNullCheck(), which is affected by last query failure of JSDictionary::get(). JSDictionary::getWithUndefinedOrNullCheck() is only referenced by indexeddb, and the problem only shows for indexeddb, so we clear the exception in it to minimize the impact to other parts. 762842 18 haraken 2012-11-09 04:52:10 -0800 How about calling clearException() at the head of JSDictionary::tryGetProperty()? What we really need to do is to clear exceptions before JSDictionary::tryGetProperty() starts checking exceptions, doesn't it? 762848 19 charles.wei 2012-11-09 04:55:23 -0800 (In reply to comment #18) > How about calling clearException() at the head of JSDictionary::tryGetProperty()? What we really need to do is to clear exceptions before JSDictionary::tryGetProperty() starts checking exceptions, doesn't it? That seems breaks some test cases of QT and EFL porting, which seems are expecting the exceptions. I don't have an environment to test these portings. This patch has minimal impact and won't break anything while works for our JSC binding for IndexedDB. 762850 20 haraken 2012-11-09 04:59:58 -0800 (In reply to comment #19) > (In reply to comment #18) > > How about calling clearException() at the head of JSDictionary::tryGetProperty()? What we really need to do is to clear exceptions before JSDictionary::tryGetProperty() starts checking exceptions, doesn't it? > > That seems breaks some test cases of QT and EFL porting, which seems are expecting the exceptions. I don't have an environment to test these portings. This patch has minimal impact and won't break anything while works for our JSC binding for IndexedDB. It would have minimal impact, but it looks like you're making a wrong change. > That seems breaks some test cases of QT and EFL porting, which seems are expecting the exceptions. I would guess you need to figure out the cause and update the test results if needed. It doesn't make sense to me not to clear exceptions at the head of tryGetProperty(). 762853 21 charles.wei 2012-11-09 05:03:18 -0800 (In reply to comment #20) > (In reply to comment #19) > > (In reply to comment #18) > > > How about calling clearException() at the head of JSDictionary::tryGetProperty()? What we really need to do is to clear exceptions before JSDictionary::tryGetProperty() starts checking exceptions, doesn't it? > > > > That seems breaks some test cases of QT and EFL porting, which seems are expecting the exceptions. I don't have an environment to test these portings. This patch has minimal impact and won't break anything while works for our JSC binding for IndexedDB. > > It would have minimal impact, but it looks like you're making a wrong change. > I don't agree that it's wrong, it might not address all the problems , but I don't think it's wrong. > > That seems breaks some test cases of QT and EFL porting, which seems are expecting the exceptions. > > I would guess you need to figure out the cause and update the test results if needed. It doesn't make sense to me not to clear exceptions at the head of tryGetProperty(). 762856 22 173261 staikos 2012-11-09 05:06:52 -0800 Comment on attachment 173261 Patch Er - no reviewed by line? I don't think you can use commit queue then? 762861 23 haraken 2012-11-09 05:12:23 -0800 (In reply to comment #21) > I don't agree that it's wrong, it might not address all the problems , but I don't think it's wrong. I don't think the change itself is wrong but the change is inappropriate in that the change hides a potential bug. For example, it doesn't make sense to add clearException() to JSDictionary::getWithUndefinedOrNullCheck() but not add JSDictionary::get(). You don't want to add it just because it is not necessary for your IDB change and it will break other port tests for some reason --- which wouldn't be a right way to fix the problem. 762867 24 charles.wei 2012-11-09 05:19:56 -0800 (In reply to comment #23) > (In reply to comment #21) > > I don't agree that it's wrong, it might not address all the problems , but I don't think it's wrong. > > I don't think the change itself is wrong but the change is inappropriate in that the change hides a potential bug. For example, it doesn't make sense to add clearException() to JSDictionary::getWithUndefinedOrNullCheck() but not add JSDictionary::get(). You don't want to add it just because it is not necessary for your IDB change and it will break other port tests for some reason --- which wouldn't be a right way to fix the problem. You can't expect me to solve all the problems even for those that I don't have an environment to test and verify :-) 762877 25 haraken 2012-11-09 05:24:38 -0800 (In reply to comment #24) > > I don't think the change itself is wrong but the change is inappropriate in that the change hides a potential bug. For example, it doesn't make sense to add clearException() to JSDictionary::getWithUndefinedOrNullCheck() but not add JSDictionary::get(). You don't want to add it just because it is not necessary for your IDB change and it will break other port tests for some reason --- which wouldn't be a right way to fix the problem. > > You can't expect me to solve all the problems even for those that I don't have an environment to test and verify :-) How much is it critical to make the fix? If you are in a hurry, you can land the patch as is and should ask Qt/EFL folks for help after that. Otherwise, let's ask them for help first. Either way I think you should fix the problem at some point. (BTW, building the Qt port would not be so difficult if you have Linux.) 762878 26 charles.wei 2012-11-09 05:24:59 -0800 (In reply to comment #24) > (In reply to comment #23) > > (In reply to comment #21) > > > I don't agree that it's wrong, it might not address all the problems , but I don't think it's wrong. > > > > I don't think the change itself is wrong but the change is inappropriate in that the change hides a potential bug. For example, it doesn't make sense to add clearException() to JSDictionary::getWithUndefinedOrNullCheck() but not add JSDictionary::get(). You don't want to add it just because it is not necessary for your IDB change and it will break other port tests for some reason --- which wouldn't be a right way to fix the problem. > > You can't expect me to solve all the problems even for those that I don't have an environment to test and verify :-) Actually I kind of agree with you , Dictionary should clear exception before each new query, because otherwise, the last query will be carried over to the next query. But seems some portings do expect this exception with their test cases, which is wrong. I don't want to submit a patch that will be reverted just because it breaks some test cases that I don't have access to and can't verify because I don't have corresponding porting environment. So I would like to submit a patch that won't break them while works for us also. 762883 27 charles.wei 2012-11-09 05:31:24 -0800 (In reply to comment #25) > (In reply to comment #24) > > > I don't think the change itself is wrong but the change is inappropriate in that the change hides a potential bug. For example, it doesn't make sense to add clearException() to JSDictionary::getWithUndefinedOrNullCheck() but not add JSDictionary::get(). You don't want to add it just because it is not necessary for your IDB change and it will break other port tests for some reason --- which wouldn't be a right way to fix the problem. > > > > You can't expect me to solve all the problems even for those that I don't have an environment to test and verify :-) > > How much is it critical to make the fix? If you are in a hurry, you can land the patch as is and should ask Qt/EFL folks for help after that. Otherwise, let's ask them for help first. Either way I think you should fix the problem at some point. > > (BTW, building the Qt port would not be so difficult if you have Linux.) The fix is critical for our product, and I also tried to setup a QT environement. But because of the poor network environement, I already spent 2 days to grab the QT source code to build, still didn't finish yet and it fails many times and I have to start over again everytime (poor network in my office and home in Beijing) 762887 28 haraken 2012-11-09 05:35:26 -0800 (In reply to comment #27) > The fix is critical for our product, and I also tried to setup a QT environement. But because of the poor network environement, I already spent 2 days to grab the QT source code to build, still didn't finish yet and it fails many times and I have to start over again everytime (poor network in my office and home in Beijing) Then I don't object to landing the patch as is, although the change is inappropriate. But please do fix the problem soon anyway. If it is difficult for you to fix Qt/EFL problems by yourself, you should ask Qt/EFL experts for help (here or in IRC). 762890 29 charles.wei 2012-11-09 05:37:31 -0800 (In reply to comment #28) > (In reply to comment #27) > > The fix is critical for our product, and I also tried to setup a QT environement. But because of the poor network environement, I already spent 2 days to grab the QT source code to build, still didn't finish yet and it fails many times and I have to start over again everytime (poor network in my office and home in Beijing) > > Then I don't object to landing the patch as is, although the change is inappropriate. But please do fix the problem soon anyway. If it is difficult for you to fix Qt/EFL problems by yourself, you should ask Qt/EFL experts for help (here or in IRC). Thanks for your understanding, will talk to Qt/EFL guys later with a more appropritate fix that won't break their test case (or they have to fix their test case). 762896 30 173261 haraken 2012-11-09 05:40:47 -0800 Comment on attachment 173261 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173261&action=review > Source/WebCore/bindings/js/JSDictionary.cpp:220 > + if (m_exec->hadException()) // Clear exceptions that might have been caused by previous query. Please add a comment about the current situation (and fix it sooner or later): // FIXME: This check should be moved to the head of JSDictionary::tryGetProperty(). // Currently we cannot move the check there because it breaks some Qt/EFL tests for some reason. 762902 31 haraken 2012-11-09 05:48:43 -0800 I'm leaving today. Feel free to cq+ it after adding the FIXME. 762994 32 173304 charles.wei 2012-11-09 07:26:29 -0800 Created attachment 173304 Patch 763001 33 173306 charles.wei 2012-11-09 07:30:34 -0800 Created attachment 173306 Patch 763009 34 173306 charles.wei 2012-11-09 07:34:41 -0800 Comment on attachment 173306 Patch Commit it after review by George and Kentaro Hara. 763024 35 173306 webkit.review.bot 2012-11-09 07:57:28 -0800 Comment on attachment 173306 Patch Clearing flags on attachment: 173306 Committed r134069: <http://trac.webkit.org/changeset/134069> 763025 36 webkit.review.bot 2012-11-09 07:57:34 -0800 All reviewed patches have been landed. Closing bug. 763498 37 darin 2012-11-09 17:41:50 -0800 This change looks completely wrong to me. When can we do a real fix? 763728 38 sam 2012-11-10 14:35:14 -0800 (In reply to comment #37) > This change looks completely wrong to me. When can we do a real fix? I agree. Changes like this should not be landed. 763751 39 ggaren 2012-11-10 15:38:25 -0800 Kentaro, it is your responsibility as a reviewer to maintain a high standard of coding quality in the WebKit project. You have failed in that responsibility here. 763759 40 haraken 2012-11-10 16:40:24 -0800 Let me roll it out in hours. 763761 41 webkit.review.bot 2012-11-10 16:50:55 -0800 Re-opened since this is blocked by bug 101852 763864 42 staikos 2012-11-11 10:25:22 -0800 (In reply to comment #30) > (From update of attachment 173261 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=173261&action=review > > > Source/WebCore/bindings/js/JSDictionary.cpp:220 > > + if (m_exec->hadException()) // Clear exceptions that might have been caused by previous query. > > Please add a comment about the current situation (and fix it sooner or later): > > // FIXME: This check should be moved to the head of JSDictionary::tryGetProperty(). > // Currently we cannot move the check there because it breaks some Qt/EFL tests for some reason. So why don't we just break Qt/EFL tests if their tests are wrong and they are not fixing it? There's a boatload of time being wasted here for no net gain to anyone. Simon can someone fix Qt? 763941 43 charles.wei 2012-11-11 17:43:42 -0800 (In reply to comment #42) > (In reply to comment #30) > > (From update of attachment 173261 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=173261&action=review > > > > > Source/WebCore/bindings/js/JSDictionary.cpp:220 > > > + if (m_exec->hadException()) // Clear exceptions that might have been caused by previous query. > > > > Please add a comment about the current situation (and fix it sooner or later): > > > > // FIXME: This check should be moved to the head of JSDictionary::tryGetProperty(). > > // Currently we cannot move the check there because it breaks some Qt/EFL tests for some reason. > > So why don't we just break Qt/EFL tests if their tests are wrong and they are not fixing it? There's a boatload of time being wasted here for no net gain to anyone. > > Simon can someone fix Qt? Ok, let me have a real fix which might break Qt/EFL. If it does, Qt/EFL should fix their test case. 763942 44 haraken 2012-11-11 17:48:30 -0800 (In reply to comment #43) > > Simon can someone fix Qt? > > Ok, let me have a real fix which might break Qt/EFL. If it does, Qt/EFL should fix their test case. I would recommend you should contact Qt/EFL folks first and investigate the problem. It is not a good idea to update test cases just because "my change would be correct in theory" before understanding the problem. 763983 45 173540 charles.wei 2012-11-11 19:33:32 -0800 Created attachment 173540 Patch 763985 46 173540 charles.wei 2012-11-11 19:36:23 -0800 Comment on attachment 173540 Patch I am now contacting Qt/EFL guys to ask for their help to verify this patch to make sure it doesn't break their test cases. 764188 47 173540 charles.wei 2012-11-12 03:08:40 -0800 Comment on attachment 173540 Patch With the help of a colleague who happened to have a QT environment and helped to verify the patch, no QT regression with this patch. 764191 48 haraken 2012-11-12 03:10:41 -0800 (In reply to comment #47) > (From update of attachment 173540 [details]) > With the help of a colleague who happened to have a QT environment and helped to verify the patch, no QT regression with this patch. What was the cause of the Qt failure we observed before? 764205 49 charles.wei 2012-11-12 03:22:29 -0800 (In reply to comment #48) > (In reply to comment #47) > > (From update of attachment 173540 [details] [details]) > > With the help of a colleague who happened to have a QT environment and helped to verify the patch, no QT regression with this patch. > > What was the cause of the Qt failure we observed before? Don't know . Look at comment #12. 764554 50 173540 darin 2012-11-12 10:36:07 -0800 Comment on attachment 173540 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173540&action=review > Source/WebCore/bindings/js/JSDictionary.cpp:56 > + if (m_exec->hadException()) // Clear exceptions, if any, left by last query. > + m_exec->clearException(); This is just the same change as before. This is not the correct idiom for use of exceptions in the JavaScriptCore ExecState. What’s really going on here? We need to get to the heart of the problem and fix that, not just clear an exception in an ExecState in one particular binding. 765010 51 173540 charles.wei 2012-11-12 17:16:43 -0800 Comment on attachment 173540 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173540&action=review With the help of a colleague who happened to have a QT environment and helped to verify the patch, no QT regression with this patch. >> Source/WebCore/bindings/js/JSDictionary.cpp:56 >> + m_exec->clearException(); > > This is just the same change as before. This is not the correct idiom for use of exceptions in the JavaScriptCore ExecState. What’s really going on here? We need to get to the heart of the problem and fix that, not just clear an exception in an ExecState in one particular binding. Well, the root cause is crystal clear as described in comment #1, to be more precise, if you have 2 consecutive query to the Dictionary, with the first failure, which will leave the ExecState of the JSDictionary in Exception state, that will affect the 2nd query even though the 2nd query will succeed otherwise. IndexedDB supports 2 types of KeyPath, String or StringArray, so it will first try StringArry type, if fails, it will then try the String type. Suppose the Dictionary has {keyPath, "id"}, Dictionary::get("keyPath", Vector<String> StringArray); fails. Not because getting the attribute, but when trying to convert the attribute to a Vector<String> at void JSDictionary::convertValue(ExecState* exec, JSValue value, Vector<String>& result); and that leaves the ExecState with Exception. This exception will be carried over to the next query: Dictionary::(keyPath", String value); which should succeed but the exception carried over from last query makes it fail. JSDictionary as an internal data structure, should not affect the ExecState by leaving it in exception state which will also affect the Javascript run later. So clear the exception is necessary. If you want to get the heart of the problem and fix that, I believe we need to move the implementation of Dictionary/Dictionary away from JavaScript JSValue based , which is a big task and not the scope of this PR. Based on above explanation, I hope it's clear that this patch is necessary. Currently the problem only shows up for IndexedDB because IndexedDB code is trying to query the Dictionary for different types, other code doesn't show the problem because they are not using Dictionary the same way as IndexedDB, but if they do later, they will have the same problem. I am raising the review flag again. 765655 52 jsbell 2012-11-13 08:51:25 -0800 *** Bug 92828 has been marked as a duplicate of this bug. *** 766255 53 charles.wei 2012-11-13 17:58:43 -0800 Any comments to this ? 766257 54 charles.wei 2012-11-13 18:00:16 -0800 Any comments to this ?(In reply to comment #52) > *** Bug 92828 has been marked as a duplicate of this bug. *** I was not aware this is already reported with 92828. 766280 55 jiyeon0402.kim 2012-11-13 18:22:49 -0800 (In reply to comment #54) > Any comments to this ?(In reply to comment #52) > > *** Bug 92828 has been marked as a duplicate of this bug. *** > > I was not aware this is already reported with 92828. It's ok. I think your patch is what I want. I try to enable indexed database for efl port. And then, I found this issue also. 768042 56 yong.li.webkit 2012-11-15 07:10:02 -0800 It seems JSDictionary::tryGetProperty is also used by JSGeolocationCustom. I still think it should be IDBDatabase's responsibility to clear the exception or tell getWithUndefinedOrNullCheck to clear it. How about adding a new argument "bool clearException" to getWithUndefinedOrNullCheck? 768171 57 jsbell 2012-11-15 09:24:49 -0800 (In reply to comment #56) > It seems JSDictionary::tryGetProperty is also used by JSGeolocationCustom. I still think it should be IDBDatabase's responsibility to clear the exception or tell getWithUndefinedOrNullCheck to clear it. How about adding a new argument "bool clearException" to getWithUndefinedOrNullCheck? We want Dictionary to behave the same between v8 and js implementations. The v8 implementation never sets a persistent exception state; the js implementation does, and that's the root of the problem. Hiding the JS behavior behind a flag won't solve the problem unless similar behavior is added on the v8 side. Setting a persistent exception state from behind WebCore code seems strange and fragile to me - the code using it can't determine if should terminate or continue processing. I'd much prefer having the Dictionary methods return an ExceptionCode which could be ignored or thrown. It looks like several methods have been added to the both implementations to return errors (e.g. MediaKeyError). These look like type-specific errors (which is strange...), but I think this is a better model. The caller can decide how to proceed. ... Getting back to the original suggestion: If JS-specific code is relying on this behavior (i.e. JSGeolocationCustom) then it should be a JS-specific API. So perhaps the getWithUndefinedOrNullCheck() should clear the exception by default, and there's an optional raiseException argument only in the JS version that JSGeolocationCustom calls? 768941 58 charles.wei 2012-11-15 22:36:57 -0800 (In reply to comment #56) > It seems JSDictionary::tryGetProperty is also used by JSGeolocationCustom. I still think it should be IDBDatabase's responsibility to clear the exception or tell getWithUndefinedOrNullCheck to clear it. How about adding a new argument "bool clearException" to getWithUndefinedOrNullCheck? As pointed out in comment #57 by Joshua, this is a JSC porting specific problem, V8 doesn't have the same problem (leaving the ExecState of JSDictionary in exception state). If we add a new argument, we are changing the API for both JSC binding and V8 binding, and it makes no sense to V8 binding at all. While it's OK for me, but I don't think it will get approved for V8 binding. 769245 59 yong.li.webkit 2012-11-16 07:19:43 -0800 (In reply to comment #57) > (In reply to comment #56) > > We want Dictionary to behave the same between v8 and js implementations. The v8 implementation never sets a persistent exception state; the js implementation does, and that's the root of the problem. > This means we will get more and more similar troubles in the future until the root issue is solved. Can V8 binding and JSC binding gurus sit down and get this settled? Probably there could be an abstract layer on top of both bindings? 771656 60 charles.wei 2012-11-20 01:20:15 -0800 I ran webkit-run-tests on Mac to test if any regression with this patch. It turned out that this patch brings no regression, instead , if fixes some test failures, with details below: Tests that failed text/pixel/audio diff (13) : same as without the patch. Tests that had stderr output (6): it was 8 without the patch. Flaky tests (failed the first run and passed on retry) (12): it was 17 without the patch. Tests expected to fail but passed (5): same as without the patch. 774725 61 173540 sam 2012-11-23 16:15:35 -0800 Comment on attachment 173540 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173540&action=review >>> Source/WebCore/bindings/js/JSDictionary.cpp:56 >>> + m_exec->clearException(); >> >> This is just the same change as before. This is not the correct idiom for use of exceptions in the JavaScriptCore ExecState. What’s really going on here? We need to get to the heart of the problem and fix that, not just clear an exception in an ExecState in one particular binding. > > Well, the root cause is crystal clear as described in comment #1, to be more precise, if you have 2 consecutive query to the Dictionary, with the first failure, which will leave the ExecState of the JSDictionary in Exception state, that will affect the 2nd query even though the 2nd query will succeed otherwise. > > IndexedDB supports 2 types of KeyPath, String or StringArray, so it will first try StringArry type, if fails, it will then try the String type. > > Suppose the Dictionary has {keyPath, "id"}, Dictionary::get("keyPath", Vector<String> StringArray); fails. Not because getting the attribute, but when trying to convert the attribute to a Vector<String> at void JSDictionary::convertValue(ExecState* exec, JSValue value, Vector<String>& result); and that leaves the ExecState with Exception. This exception will be carried over to the next query: Dictionary::(keyPath", String value); which should succeed but the exception carried over from last query makes it fail. > > JSDictionary as an internal data structure, should not affect the ExecState by leaving it in exception state which will also affect the Javascript run later. So clear the exception is necessary. If you want to get the heart of the problem and fix that, I believe we need to move the implementation of Dictionary/Dictionary away from JavaScript JSValue based , which is a big task and not the scope of this PR. > > Based on above explanation, I hope it's clear that this patch is necessary. Currently the problem only shows up for IndexedDB because IndexedDB code is trying to query the Dictionary for different types, other code doesn't show the problem because they are not using Dictionary the same way as IndexedDB, but if they do later, they will have the same problem. > > I am raising the review flag again. This still makes no sense to me. If we had an exception, the right thing is almost always to propagate it up to the JS environment. Can you show me a reduced test case where this is necessary. 774755 62 charles.wei 2012-11-23 20:22:11 -0800 > > This still makes no sense to me. If we had an exception, the right thing is almost always to propagate it up to the JS environment. Can you show me a reduced test case where this is necessary. As said in comment #1, this happens for IndexedDB. Any test cases in LayoutTest/storage/indexeddb are test cases for this. Please try (So far we are the only JSC-based webkit porting, you guys don't have the problem so far because you are not enabling the indexedDB yet). Look at bug 92828 from Samsung who had the same problem trying to enable indexedDB on their porting. If you don't agree with my patch, please have a proposal to solve this problem. 774756 63 173540 charles.wei 2012-11-23 20:23:03 -0800 Comment on attachment 173540 Patch With the help of a colleague who happened to have a QT environment and helped to verify the patch, no QT regression with this patch. 774783 64 sam 2012-11-23 22:55:17 -0800 (In reply to comment #62) > > > > This still makes no sense to me. If we had an exception, the right thing is almost always to propagate it up to the JS environment. Can you show me a reduced test case where this is necessary. > > As said in comment #1, this happens for IndexedDB. Any test cases in LayoutTest/storage/indexeddb are test cases for this. Please try (So far we are the only JSC-based webkit porting, you guys don't have the problem so far because you are not enabling the indexedDB yet). Look at bug 92828 from Samsung who had the same problem trying to enable indexedDB on their porting. > > If you don't agree with my patch, please have a proposal to solve this problem. I asked for a reduced test case. It is very hard to consider this in the abstract. 775705 65 173540 alecflett 2012-11-26 11:27:56 -0800 Comment on attachment 173540 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173540&action=review >>>> Source/WebCore/bindings/js/JSDictionary.cpp:56 >>>> + m_exec->clearException(); >>> >>> This is just the same change as before. This is not the correct idiom for use of exceptions in the JavaScriptCore ExecState. What’s really going on here? We need to get to the heart of the problem and fix that, not just clear an exception in an ExecState in one particular binding. >> >> Well, the root cause is crystal clear as described in comment #1, to be more precise, if you have 2 consecutive query to the Dictionary, with the first failure, which will leave the ExecState of the JSDictionary in Exception state, that will affect the 2nd query even though the 2nd query will succeed otherwise. >> >> IndexedDB supports 2 types of KeyPath, String or StringArray, so it will first try StringArry type, if fails, it will then try the String type. >> >> Suppose the Dictionary has {keyPath, "id"}, Dictionary::get("keyPath", Vector<String> StringArray); fails. Not because getting the attribute, but when trying to convert the attribute to a Vector<String> at void JSDictionary::convertValue(ExecState* exec, JSValue value, Vector<String>& result); and that leaves the ExecState with Exception. This exception will be carried over to the next query: Dictionary::(keyPath", String value); which should succeed but the exception carried over from last query makes it fail. >> >> JSDictionary as an internal data structure, should not affect the ExecState by leaving it in exception state which will also affect the Javascript run later. So clear the exception is necessary. If you want to get the heart of the problem and fix that, I believe we need to move the implementation of Dictionary/Dictionary away from JavaScript JSValue based , which is a big task and not the scope of this PR. >> >> Based on above explanation, I hope it's clear that this patch is necessary. Currently the problem only shows up for IndexedDB because IndexedDB code is trying to query the Dictionary for different types, other code doesn't show the problem because they are not using Dictionary the same way as IndexedDB, but if they do later, they will have the same problem. >> >> I am raising the review flag again. > > This still makes no sense to me. If we had an exception, the right thing is almost always to propagate it up to the JS environment. Can you show me a reduced test case where this is necessary. (from an IDB perspective, not knowing a huge amount about JSC) I agree that clearing the exception seems totally wrong here... at least in the context of JSDictionary itself. The issue here is the way the JSC-based IDB code is calling into the dictionary, not the dictionary itself, and this will almost certainly break other consumers of JSDictionary. Not really knowing the JSC Dictionary API, IDB should be probing the dictionary looking for keys, and if it needs to "catch" an exception, then it needs to look something like this, in the IDB bindings code: // assuming 'exec' holds the same ExecState: JSValue val; if (!dictionary->tryGetProperty("keyPath", val)) return false; // now we know the key is present and valid Vector<String> stringArray; if (!dictionary->tryGetProperty("keyPath", stringArray) { exec->clearException(); String stringVal; if (!dictionary->tryGetProperty("keyPath", stringVal)) return false; .. deal with stringVal here return true; } .. deal with stringArray here I'm making assumptions here that it's cheap to keep calling tryGetProperty() - if its not, then the original value from the first tryGetProperty should be manually converted into each appropriate type. 775846 66 sam 2012-11-26 13:46:35 -0800 r-'ing, as this still seems wrong. 775933 67 173540 darin 2012-11-26 14:58:24 -0800 Comment on attachment 173540 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=173540&action=review >>>>> Source/WebCore/bindings/js/JSDictionary.cpp:56 >>>>> + m_exec->clearException(); >>>> >>>> This is just the same change as before. This is not the correct idiom for use of exceptions in the JavaScriptCore ExecState. What’s really going on here? We need to get to the heart of the problem and fix that, not just clear an exception in an ExecState in one particular binding. >>> >>> Well, the root cause is crystal clear as described in comment #1, to be more precise, if you have 2 consecutive query to the Dictionary, with the first failure, which will leave the ExecState of the JSDictionary in Exception state, that will affect the 2nd query even though the 2nd query will succeed otherwise. >>> >>> IndexedDB supports 2 types of KeyPath, String or StringArray, so it will first try StringArry type, if fails, it will then try the String type. >>> >>> Suppose the Dictionary has {keyPath, "id"}, Dictionary::get("keyPath", Vector<String> StringArray); fails. Not because getting the attribute, but when trying to convert the attribute to a Vector<String> at void JSDictionary::convertValue(ExecState* exec, JSValue value, Vector<String>& result); and that leaves the ExecState with Exception. This exception will be carried over to the next query: Dictionary::(keyPath", String value); which should succeed but the exception carried over from last query makes it fail. >>> >>> JSDictionary as an internal data structure, should not affect the ExecState by leaving it in exception state which will also affect the Javascript run later. So clear the exception is necessary. If you want to get the heart of the problem and fix that, I believe we need to move the implementation of Dictionary/Dictionary away from JavaScript JSValue based , which is a big task and not the scope of this PR. >>> >>> Based on above explanation, I hope it's clear that this patch is necessary. Currently the problem only shows up for IndexedDB because IndexedDB code is trying to query the Dictionary for different types, other code doesn't show the problem because they are not using Dictionary the same way as IndexedDB, but if they do later, they will have the same problem. >>> >>> I am raising the review flag again. >> >> This still makes no sense to me. If we had an exception, the right thing is almost always to propagate it up to the JS environment. Can you show me a reduced test case where this is necessary. > > (from an IDB perspective, not knowing a huge amount about JSC) > I agree that clearing the exception seems totally wrong here... at least in the context of JSDictionary itself. The issue here is the way the JSC-based IDB code is calling into the dictionary, not the dictionary itself, and this will almost certainly break other consumers of JSDictionary. > > Not really knowing the JSC Dictionary API, IDB should be probing the dictionary looking for keys, and if it needs to "catch" an exception, then it needs to look something like this, in the IDB bindings code: > > // assuming 'exec' holds the same ExecState: > > JSValue val; > if (!dictionary->tryGetProperty("keyPath", val)) > return false; > > // now we know the key is present and valid > Vector<String> stringArray; > if (!dictionary->tryGetProperty("keyPath", stringArray) { > exec->clearException(); > String stringVal; > if (!dictionary->tryGetProperty("keyPath", stringVal)) > return false; > .. deal with stringVal here > return true; > } > .. deal with stringArray here > > I'm making assumptions here that it's cheap to keep calling tryGetProperty() - if its not, then the original value from the first tryGetProperty should be manually converted into each appropriate type. Alec’s comments seem correct. The problem here is in IndexedDB code using JavaScriptCore functions incorrectly, not a bug in the JSDictionary wrapper class. That’s where it needs to be fixed. 781985 68 haraken 2012-12-03 15:54:21 -0800 *** Bug 95563 has been marked as a duplicate of this bug. *** 782140 69 darin 2012-12-03 19:36:16 -0800 I’m getting really mixed up about this. What is the JSDictionary class? It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. If that is so, then maybe I was wrong all along and the exception clearing does belong in JSDictionary. Who created JSDictionary and can explain its purpose? 782146 70 haraken 2012-12-03 19:47:20 -0800 (In reply to comment #69) > It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. In my understanding, this is correct. One confusion would come from that JSC has JSDictionary and Dictionary. Previously JSC has JSDictionary only and V8 has Dictionary only. Then, in order to make interfaces consistent between JSC and V8, we introduced js/Dictionary, which has the same interfaces as v8/Dictionary. Although we wanted to kill JSDictionary at some point, we haven't yet done it because we haven't reach a consensus on the interfaces of js/Dictionary. 782172 71 charles.wei 2012-12-03 20:22:25 -0800 (In reply to comment #69) > I’m getting really mixed up about this. What is the JSDictionary class? It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. If that is so, then maybe I was wrong all along and the exception clearing does belong in JSDictionary. > > Who created JSDictionary and can explain its purpose? Yes, JSDictionary is a native helper class to work with JavaScript objects as a the backend of Dictionary, it should hide it's implementation to external world, but it's now implemented with JSValue, and querying the JSDictionary will leave the JSC in exception state, which is really not what we want. Somebody say(like comment #65) we should clear the exception outside of JSDictionary, like in where it's used (IndexedDB), but the external world really should not know how Dictionary is implemented, and they shouldn't know that query the dictionary will impact the JSC state, which is also wrong. Further, V8 doesn't have the same problem because they have a different way of implement the Dictionary. we shouldn't clear the unexpected exception in the common code for both V8 and JSC. The patch doesn't bring any regression, in the contrast, it fixes some DRT issues for Safari/Mac and for us (see comment #60). 782239 72 sam 2012-12-03 22:56:06 -0800 (In reply to comment #69) > I’m getting really mixed up about this. What is the JSDictionary class? It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. If that is so, then maybe I was wrong all along and the exception clearing does belong in JSDictionary. > > Who created JSDictionary and can explain its purpose? It was I! If memory serves, I added it to make adding Event constructors easier to write, and to clean up other code that took vanilla JS objects and treated them like dictionaries, for instance the Geolocation PositionOptions. The basic usage of the object was intended to look like this: JSDictionary dictionary(exec, object); double timeoutValue; if (!dictionary.tryGetProperty("timeout", timeoutValue)) { // An exception occurred! return; } .... If a user wants to eat the exception, they can do so if tryGetProperty returns false, but the object should not do it for you, since in the most common case, you want it to propagate up. 782242 73 sam 2012-12-03 22:58:30 -0800 Note: I am not clear on the history behind the similarly named, yet different Dictionary class, that seems to wrap a JSDictionary. Its existence worries me. 782527 74 yong.li.webkit 2012-12-04 07:25:03 -0800 (In reply to comment #70) > (In reply to comment #69) > > It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. > > In my understanding, this is correct. > > One confusion would come from that JSC has JSDictionary and Dictionary. Previously JSC has JSDictionary only and V8 has Dictionary only. Then, in order to make interfaces consistent between JSC and V8, we introduced js/Dictionary, which has the same interfaces as v8/Dictionary. Although we wanted to kill JSDictionary at some point, we haven't yet done it because we haven't reach a consensus on the interfaces of js/Dictionary. So it sounds the exception should be cleared by js/Dictionary, if its existence is to "make interfaces consistent between JSC and V8". 782712 75 sam 2012-12-04 10:54:02 -0800 (In reply to comment #74) > (In reply to comment #70) > > (In reply to comment #69) > > > It seems to be an interface to help people work with JavaScript objects as a dictionary, hiding implementation details like exceptions. > > > > In my understanding, this is correct. > > > > One confusion would come from that JSC has JSDictionary and Dictionary. Previously JSC has JSDictionary only and V8 has Dictionary only. Then, in order to make interfaces consistent between JSC and V8, we introduced js/Dictionary, which has the same interfaces as v8/Dictionary. Although we wanted to kill JSDictionary at some point, we haven't yet done it because we haven't reach a consensus on the interfaces of js/Dictionary. > > So it sounds the exception should be cleared by js/Dictionary, if its existence is to "make interfaces consistent between JSC and V8". I'm still having trouble understanding this in abstract. Can someone give me a small test case, ~5 lines of JavaScript, that demonstrates this code path? I find it hard to understand when an exception should not be propagated out to the JS caller. 782725 76 jsbell 2012-12-04 11:03:05 -0800 (In reply to comment #75) > I'm still having trouble understanding this in abstract. Can someone give me a small test case, ~5 lines of JavaScript, that demonstrates this code path? I find it hard to understand when an exception should not be propagated out to the JS caller. var req = indexedDB.open('db'+Date.now()); req.onupgradeneeded = function() { var db = req.result; var funky = {toString: function() { return "hello"; }}; db.createObjectStore('s1', {keyPath: 'string'}); // Shouldn't throw - string is used db.createObjectStore('s2', {keyPath: ['string']}); // Shouldn't throw - Array of string is used db.createObjectStore('s3', {keyPath: funky); // Shouldn't throw - converted to string "hello" }; Spec: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#widl-IDBDatabase-createObjectStore-IDBObjectStore-DOMString-name-IDBObjectStoreParameters-optionalParameters "If the optionalParameters argument is specified and has a keyPath property which is not undefined or null, then set keyPath to the value of this property. If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." 782762 77 ggaren 2012-12-04 11:42:41 -0800 <snip> > var req = indexedDB.open('db'+Date.now()); </snip> I don't see any code here that would throw an exception, which should then be swallowed. What am I missing? > "If the optionalParameters argument is specified and has a keyPath property which is not undefined or null, then set keyPath to the value of this property. If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." I don't see any specification here that an exception should be swallowed. What am I missing? 782859 78 jsbell 2012-12-04 13:31:10 -0800 (In reply to comment #77) > I don't see any code here that would throw an exception, which should then be swallowed. What am I missing? I don't think you're missing anything. My code was demonstrating the reverse, where we would not expect exceptions to be thrown when passing options with different value types to a method using the WebIDL Dictionary type. The V8 implementation of Dictionary allows the method to be implemented e.g. by calling get("keyPath", Vector<String>) then (on failure) get("keyPath", String) with no need to clear exceptions. The JSC implementation of Dictionary sets an exception when get("keyPath", Vector<String>) is called, and requires the method calling into Dictionary to clear the exception. For this scenario, V8's Dictionary API makes more sense to me as the API for Dictionary, and callers that are interacting at a lower level would use JSDictionary. ... This case also comes to mind: var req = indexedDB.open('db'+Date.now()); req.onupgradeneeded = function() { var db = req.result; var bad = {toString: function() { throw new Error('Oops!'); }}; try { db.createObjectStore('s3', {keyPath: bad}); } catch (ex) { alert(ex); } }; I guess I'd expect an exception to be thrown here c/o the finer points of DOMString conversion as defined in WebIDL and ECMA-262's definition of ToString. And.... it alerts w/ V8. 782913 79 sam 2012-12-04 14:05:00 -0800 (In reply to comment #78) > (In reply to comment #77) > > I don't see any code here that would throw an exception, which should then be swallowed. What am I missing? > > I don't think you're missing anything. My code was demonstrating the reverse, where we would not expect exceptions to be thrown when passing options with different value types to a method using the WebIDL Dictionary type. > > The V8 implementation of Dictionary allows the method to be implemented e.g. by calling get("keyPath", Vector<String>) then (on failure) get("keyPath", String) with no need to clear exceptions. > > The JSC implementation of Dictionary sets an exception when get("keyPath", Vector<String>) is called, and requires the method calling into Dictionary to clear the exception. > > For this scenario, V8's Dictionary API makes more sense to me as the API for Dictionary, and callers that are interacting at a lower level would use JSDictionary. I finally understand (I hope). The codes in question, IDBDatabase::createObjectStore, is attempting to use exceptions to influence control flow. e.g. if the options.get("keyPath", keyPathArray) fails (due to an exception) try something else, options.getWithUndefinedOrNullCheck("keyPath", keyPathString). This is a fragile idiom, and not one I think that makes sense to use. Instead, we should be explicit in our assumption. Something like: Vector<String> keyPathArray; String keyPathString; if (options.isJSSequence("keyPath")) { if (options.get("keyPath", keyPathArray) { // An exception occurred, propagate it up. return; } } if (!options.getWithUndefinedOrNullCheck("keyPath", keyPathString)) .... This idiom could cleaned up and be put into a function that did the type checking for you, but it would have to be named explicitly. 782955 80 jsbell 2012-12-04 14:36:58 -0800 (In reply to comment #79) > > I finally understand (I hope). The codes in question, IDBDatabase::createObjectStore, is attempting to use exceptions to influence control flow. e.g. if the options.get("keyPath", keyPathArray) fails (due to an exception) try something else, options.getWithUndefinedOrNullCheck("keyPath", keyPathString). Where are exceptions coming into play? The code in v8/Dictionary.cpp is: bool Dictionary::get(const String& key, Vector<String>& value) const { v8::Local<v8::Value> v8Value; if (!getKey(key, v8Value)) return false; if (!v8Value->IsArray()) return false; v8::Local<v8::Array> v8Array = v8::Local<v8::Array>::Cast(v8Value); /* stringify and copy members over */ return true; } > This is a fragile idiom, and not one I think that makes sense to use. Instead, we should be explicit in our assumption. Something like: > > Vector<String> keyPathArray; > String keyPathString; > > if (options.isJSSequence("keyPath")) { > if (options.get("keyPath", keyPathArray) { > // An exception occurred, propagate it up. > return; > } > } > > if (!options.getWithUndefinedOrNullCheck("keyPath", keyPathString)) > .... > > This idiom could cleaned up and be put into a function that did the type checking for you, but it would have to be named explicitly. So the v8 version of Dictionary::get(String, Vector<String>) is providing this "isJSSequence?" functionality implicitly. That said, this approach - adding an explicit Dictionary::isSequence(propertyName) - seems reasonable to me, although it would require changes to v8/Dictionary's get(String, Vector<String>) implementation to raise a TypeError if it's not a sequence. 783842 81 alecflett 2012-12-05 09:38:26 -0800 *** Bug 88287 has been marked as a duplicate of this bug. *** 783961 82 177806 michael 2012-12-05 12:05:50 -0800 Created attachment 177806 Patch Here's a patch which checks whether the property being accessed is an array before attempting to convert the value to an array. The patch doesn't clear exceptions and requires no changes to existing IDB code. With this patch and another fixing odd-length data in SerializedScriptValue, WebKitGtk+ passes 157 out of 196 layout tests in storage/indexeddb. 784209 83 177806 haraken 2012-12-05 15:46:07 -0800 Comment on attachment 177806 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=177806&action=review > Source/WebCore/ChangeLog:13 > + JSDictionary should check whether the property being accessed in get() > + is an array before attempting to convert the value to an array. > + > + Previously calling get() with a result type of Vector<String> when > + the named property could not be converted to an array would generate > + an exception. I guess you can fix JSDictionary::convertValue(ExecState* exec, JSValue value, Vector<String>& result), instead of implementing yet another get(). 784264 84 177865 michael 2012-12-05 16:43:32 -0800 Created attachment 177865 Patch 784283 85 177865 haraken 2012-12-05 16:52:44 -0800 Comment on attachment 177865 Patch The change looks reasonable. Let's hear thoughts of sam, darin, ggaren before landing. 784310 86 177865 haraken 2012-12-05 17:15:28 -0800 Comment on attachment 177865 Patch sam: any comments on this patch? 784318 87 177865 ggaren 2012-12-05 17:22:38 -0800 Comment on attachment 177865 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=177865&action=review This patch looks good to me, and I think it resolves the problem of swallowing exceptions. > Source/WebCore/bindings/js/JSDictionary.h:159 > if (m_exec->hadException()) > return ExceptionThrown; > > + if (!success) > + return ConversionFailed; Might be nice to move the test for exception inside the !success test. This is slightly more efficient, and it helps show the reader that we always check the return value before proceeding. 784473 88 177906 michael 2012-12-05 18:53:04 -0800 Created attachment 177906 Patch I've cleaned up the flow of control in tryGetPropertyAndResult(). 784474 89 177906 haraken 2012-12-05 18:56:51 -0800 Comment on attachment 177906 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=177906&action=review > Source/WebCore/bindings/js/JSDictionary.h:163 > + case ConversionFailed: As mentioned above, I'd like to add ASSERT_NOT_REACHED() to ConversionFailed. 784479 90 177907 michael 2012-12-05 19:03:29 -0800 Created attachment 177907 Patch I've added ASSERT_NOT_REACHED() to verify that tryGetProperty() never returns ConversionFailed. 784481 91 177907 haraken 2012-12-05 19:04:13 -0800 Comment on attachment 177907 Patch ok, thanks! 784711 92 177907 charles.wei 2012-12-06 00:39:04 -0800 Comment on attachment 177907 Patch wohoo, eventually get it resolved, the other way. 784720 93 177907 webkit.review.bot 2012-12-06 00:51:52 -0800 Comment on attachment 177907 Patch Clearing flags on attachment: 177907 Committed r136817: <http://trac.webkit.org/changeset/136817> 784721 94 webkit.review.bot 2012-12-06 00:52:02 -0800 All reviewed patches have been landed. Closing bug. 786992 95 sam 2012-12-09 22:23:25 -0800 I don't think this was the right way to go. My biggest gripe is that JSDictionary used to cleanly map to the WebIDL dictionary type and now doesn't. If this is really needed, I would rather it be in the IndexDB code, rather than polluting the general case. 786993 96 sam 2012-12-09 22:27:00 -0800 Does anyone have a link to where IndexDB actually asks for an sequence or a String here? The spec at http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#options-object-concept seems to only call for a keyPath of type DOMString?. Is that different in another version of the spec? Is there a more up-to-date version I should be referencing? 787001 97 michael 2012-12-09 22:33:42 -0800 (In reply to comment #96) > Does anyone have a link to where IndexDB actually asks for an sequence or a String here? The spec at http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#options-object-concept seems to only call for a keyPath of type DOMString?. Is that different in another version of the spec? Is there a more up-to-date version I should be referencing? Section 3.2.4 of the specification describes the handling of the keyPath property in the optionalParameters argument to createObjectStore(): http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface "If the optionalParameters argument is specified and has a keyPath property which is not undefined or null, then set keyPath to the value of this property. If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." 787004 98 sam 2012-12-09 22:40:40 -0800 (In reply to comment #97) > (In reply to comment #96) > > Does anyone have a link to where IndexDB actually asks for an sequence or a String here? The spec at http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#options-object-concept seems to only call for a keyPath of type DOMString?. Is that different in another version of the spec? Is there a more up-to-date version I should be referencing? > > Section 3.2.4 of the specification describes the handling of the keyPath property in the optionalParameters argument to createObjectStore(): > > http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface > > "If the optionalParameters argument is specified and has a keyPath property which is not undefined or null, then set keyPath to the value of this property. If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." Thanks, that is very helpful. It is odd/unfortunate that the IDL does not match the prose. Given this, I think it is more reasonable that this be implemented as a quirk in the IndexDB bindings and not in JSDictionary. Please revert. 787012 99 haraken 2012-12-09 22:50:00 -0800 (In reply to comment #95) > My biggest gripe is that JSDictionary used to cleanly map to the WebIDL dictionary type and now doesn't. Would you elaborate on this? I don't figure out how this change violates the spec: Spec: http://dev.w3.org/2006/webapi/WebIDL/#es-dictionary This patch just changes a return value of JSDictionary::tryGetPropertyAndResult() so that callers of (JS)Dictionary can correctly judge if an exception was thrown or not. This information is useful for callers to handle exceptions (e.g. Indexed DB code). Also I don't think this behavior violates the WebIDL spec. 787509 100 sam 2012-12-10 10:38:08 -0800 (In reply to comment #99) > (In reply to comment #95) > > My biggest gripe is that JSDictionary used to cleanly map to the WebIDL dictionary type and now doesn't. > > Would you elaborate on this? I don't figure out how this change violates the spec: > > Spec: http://dev.w3.org/2006/webapi/WebIDL/#es-dictionary > > This patch just changes a return value of JSDictionary::tryGetPropertyAndResult() so that callers of (JS)Dictionary can correctly judge if an exception was thrown or not. This information is useful for callers to handle exceptions (e.g. Indexed DB code). Also I don't think this behavior violates the WebIDL spec. Its not a question of violation, its the mapping of concepts. As far as I can tell, in WebIDL there is no concept of converting failing due to not being the correct type. Also, since I had issue with the original patch, it would have been polite to email me to ask for a final review here. I realize you asked in the bug, but I am cc'd on many bugs and don't get to them immediately all the time. 787530 101 jsbell 2012-12-10 10:48:21 -0800 Re: the IDL - yeah, there are outstanding W3C-tracker bugs on updating the IDLs in the spec. I'll make sure there is one for this dictionary. The WebIDL for this specific Dictionary in the spec should be written to match the prose, i.e.: dictionary IDBObjectStoreParameters { (sequence<DOMString> or DOMString)? keyPath = null; boolean autoIncrement = false; }; ... of course, WebKitIDL doesn't support unions yet. Presumably that would allow the generated binding code to throw if necessary (anything that can't convert to DOMString), and createObjectStore callback would use e.g. IDLUnion<Vector<String>, String> keyPath; // Just made this up options.get(keyPath); // If we got this far, shouldn't throw if (keyPath.isFirstType()) { ... } // Or something, don't design this here 788077 102 178728 michael 2012-12-10 23:25:50 -0800 Created attachment 178728 Patch 788625 103 178728 sam 2012-12-11 11:24:26 -0800 Comment on attachment 178728 Patch This is still not right. The special casing should be in the IndexDB code. In fact, the IndexDB code is the odd duck here, the conversion from js object to c++ object should be happening in the bindings layer, not in the c++ layer. See the Event constructors for the correct way to do this. 789531 104 179040 michael 2012-12-12 07:40:30 -0800 Created attachment 179040 Patch With this patch I've implemented custom JSC bindings for parsing options in IDBDatabase.createObjectStore() and IDBObjectStore.createIndex(). This patch makes no changes to Dictionary or JSDictionary. 789845 105 179040 alecflett 2012-12-12 13:23:29 -0800 Comment on attachment 179040 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179040&action=review > Source/WebCore/Modules/indexeddb/IDBDatabase.cpp:154 > + bool autoIncrement = false; This seems like an odd factoring of this code - perhaps move the autoIncrement above the first (!options.isUndefinedOrNull()) and put the options.get("autoIncrement",..) there too? Other than that, the non-JSC code looks good to me, I like the way this is factored. 790108 106 179158 michael 2012-12-12 17:32:18 -0800 Created attachment 179158 Patch I've updated IDBDatabase::createObjectStore() to move parsing of the autoIncrement property to the same block as parsing of the keyPath property as Alec suggested. 790214 107 179158 darin 2012-12-12 19:51:56 -0800 Comment on attachment 179158 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179158&action=review This is OK if we can’t fix the Dictionary class. But I think it would have been OK to fix Dictionary too. It’s just that it was wrong to change JSDictionary. review- because the bindings have multiple small mistakes in them > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:52 > + ExceptionCode ec = 0; This should be moved down to the end of the function where it’s used rather than declaring it way up here. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:54 > + JSValue nameValue = exec->argument(0); > + String name = nameValue.toString(exec)->value(exec); There's no reason to put nameValue into a local variable. This can all be done on one line. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:58 > + JSValue optionsValue = MAYBE_MISSING_PARAMETER(exec, 1, DefaultIsUndefined); This is overkill. The argument function already does this without requiring any macro help. The way to write this is: JSValue optionsValue = exec->argument(1); > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:60 > + if (!optionsValue.isUndefinedOrNull() && !optionsValue.isObject()) > + return throwTypeError(exec, "Not an object."); Is this type check really needed? Are there tests that cover this? Does the specification ask for it? Normally in JavaScript you can try to get the properties of anything, and there's no need to require that a JavaScript value be an object just to get its properties. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:62 > + JSDictionary options(exec, optionsValue.getObject()); It's not idiomatic to use JSDictionary here. Why not just use JavaScriptCore functions directly on optionsValue? > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:67 > + if (options.isValid() && options.get("keyPath", keyPathScriptValue)) { > + JSValue keyPathValue = keyPathScriptValue.jsValue(); This should just be: JSValue keyPathValue = optionsValue.get(exec, PropertyName("keyPath")); Or something along those lines. JSDictionary does not add value here. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:68 > + if (isJSArray(keyPathValue)) It’s surprising that a JavaScript array behaves differently than a non-array JavaScript object with the same properties as the array. That’s not a conventional distinction made in JavaScript in most cases. I guess IDB is unusual in that respect? Is that really what’s specified? Do we have test cases that pass a non-array object that has array-like properties to test this? > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:82 > + bool autoIncrement = false; > + if (options.isValid()) > + options.get("autoIncrement", autoIncrement); > + > + if (exec->hadException()) > + return jsUndefined(); This should just be: JSValue autoIncrementValue = optionsValue.get(exec, PropertyName("autoIncrement")); if (exec->hadException()) return jsUndefined(); bool autoIncrement = autoIncrementValue.toBoolean(exec); if (exec->hadException()) return jsUndefined(); Again, JSDictionary does not help us. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:84 > + JSValue result = toJS(exec, globalObject(), WTF::getPtr(impl()->createObjectStore(name, keyPath, autoIncrement, ec))); Please use get() instead of WTF::getPtr. WTF::getPtr just exists so the generator can make code that works correctly without knowing if the return value from createObjectStore is a PassRefPtr or a raw pointer. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:51 > + ExceptionCode ec = 0; Same comment about moving the ec definition down to where it's used. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:54 > + ScriptExecutionContext* context = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext(); > + if (!context) > + return jsUndefined(); We don’t want to throw an exception or log to the console in this case? Just fail silently? > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:57 > + JSValue nameValue = exec->argument(0); > + String name = nameValue.toString(exec)->value(exec); There's no reason to put nameValue into a local variable. This can all be done on one line. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:62 > + IDBKeyPath keyPath; Conversion of a JSValue into an IDBKeyPath is complex enough that I’d like these two classes to share a helper function that does it. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:63 > + if (keyPathValue.isObject() && isJSArray(keyPathValue)) The isObject() check here is not needed or helpful. The isJSArray function will return false for any non-object value. It’s surprising that a JavaScript array behaves differently than a non-array JavaScript object with the same properties as the array. That’s not a conventional distinction made in JavaScript in most cases. I guess IDB is unusual in that respect? Is that really what’s specified? Do we have test cases that pass a non-array object that has array-like properties to test this? > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:70 > + JSValue optionsValue = MAYBE_MISSING_PARAMETER(exec, 2, DefaultIsUndefined); As in a similar case above, this should just be: JSValue optionsValue = exec->argument(2); > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:72 > + if (!optionsValue.isUndefinedOrNull() && !optionsValue.isObject()) > + return throwTypeError(exec, "Not an object."); Is this type check really needed? Are there tests that cover this? Does the specification ask for it? Normally in JavaScript you can try to get the properties of anything, and there's no need to require that a JavaScript value be an object just to get its properties. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:74 > + JSDictionary options(exec, optionsValue.getObject()); No need to use JSDictionary here. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:78 > + bool unique = false; > + if (options.isValid()) > + options.get("unique", unique); This should just be: JSValue uniqueValue = unique.get(exec, PropertyName("unique")); if (exec->hadException()) return jsUndefined(); bool unique = uniqueValue.toBoolean(exec); if (exec->hadException()) return jsUndefined(); JSDictionary does not help us. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:85 > + bool multiEntry = false; > + if (options.isValid()) > + options.get("multiEntry", multiEntry); > + > + if (exec->hadException()) > + return jsUndefined(); This should just be: JSValue multiEntryValue = multiEntry.get(exec, PropertyName("multiEntry")); if (exec->hadException()) return jsUndefined(); bool multiEntry = multiEntryValue.toBoolean(exec); if (exec->hadException()) return jsUndefined(); JSDictionary does not help us. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:87 > + JSValue result = toJS(exec, globalObject(), WTF::getPtr(impl()->createIndex(context, name, keyPath, unique, multiEntry, ec))); Please use get() instead of WTF::getPtr. WTF::getPtr just exists so the generator can make code that works correctly without knowing if the return value from createObjectStore is a PassRefPtr or a raw pointer. 790589 108 darin 2012-12-13 07:15:28 -0800 (In reply to comment #107) > This is OK if we can’t fix the Dictionary class. But I think it would have been OK to fix Dictionary too. It’s just that it was wrong to change JSDictionary. No, I changed my mind. This idea of the bindings passing a Dictionary to a DOM class is not right. It’s not how we want to do JavaScript binding. The order that we evaluate things from the dictionary is observable in JavaScript. It’s not OK to have that mixed in with the job of the DOM function at an arbitrary time. It needs to be part of the binding. The relationship of JavaScript and DOM here was done wrong. So this latest patch is the right direction. 790870 109 michael 2012-12-13 13:43:04 -0800 (In reply to comment #107) > > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:60 > > + if (!optionsValue.isUndefinedOrNull() && !optionsValue.isObject()) > > + return throwTypeError(exec, "Not an object."); > > Is this type check really needed? Are there tests that cover this? Does the specification ask for it? Normally in JavaScript you can try to get the properties of anything, and there's no need to require that a JavaScript value be an object just to get its properties. This check is required by the Web IDL specification: http://www.w3.org/TR/2011/WD-WebIDL-20110927/#es-dictionary "IDL dictionary type values are represented by ECMAScript Object values." This check matches that on line 1827 of CodeGeneratorV8.pm. This check is tested in storage/indexeddb/create-object-store-options.html. > > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:68 > > + if (isJSArray(keyPathValue)) > > It’s surprising that a JavaScript array behaves differently than a non-array JavaScript object with the same properties as the array. That’s not a conventional distinction made in JavaScript in most cases. I guess IDB is unusual in that respect? Is that really what’s specified? > > Do we have test cases that pass a non-array object that has array-like properties to test this? The IndexedDB specification does make such a distinction: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#database-interface "If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." Converting an object to a string results in the string "[object Object]", which is not a valid key path since this string is not a valid JavaScript identifier: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#key-path-construct Key paths consisting of array-like objects are prohibited by the IndexedDB specification and are rejected with a syntax error exception by WebKit/Chromium and Firefox. 790883 110 179326 michael 2012-12-13 13:52:53 -0800 Created attachment 179326 Patch I've removed the use of JSDictionary, simplified accessing arguments, and changed WTF::getPtr() to .get(). I've also added a utility function for converting a JSValue into an IDBKeyPath and updated the check for a script execution context to throw an exception if no context is present. 790905 111 jsbell 2012-12-13 14:04:24 -0800 (In reply to comment #109) > "If keyPath is an Array, then each item in the array is converted to a string. If keyPath is not an Array, it is converted to a string." ... > Key paths consisting of array-like objects are prohibited by the IndexedDB specification and are rejected with a syntax error exception by WebKit/Chromium and Firefox. It's unfortunate that this does not match the WebIDL/ECMAScript binding for sequence<T> (which allows Array-like w/ |length| property etc). Fortunately, moving to that would be a backwards compatible change for the IDB spec in the sense that no currently valid key paths would be rejected if we started accepting {'length': 2, '0': 'identifier1', '1': 'identifier2'. I'll raise this on public-webapps soon. 791275 112 179326 darin 2012-12-13 20:17:06 -0800 Comment on attachment 179326 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179326&action=review > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:54 > + if (exec->argumentCount() < 1) > + return throwError(exec, createNotEnoughArgumentsError(exec)); > + String name = exec->argument(0).toString(exec)->value(exec); > + if (exec->hadException()) > + return jsUndefined(); I suggest breaking this into two paragraphs. The argument count check seems separate from extracting the first argument. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:62 > + if (optionsValue.isObject()) { Why do we have this check? I believe we’ll get the same behavior without it since the get calls will return undefined values, and I would prefer that we omit it to streamline the code, and move the definitions of the variables closer to the code that sets them up. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:71 > + if (!keyPathValue.isUndefinedOrNull()) > + keyPath = idbKeyPathFromValue(exec, keyPathValue); > + > + if (exec->hadException()) > + return jsUndefined(); I suggest nesting the second if statement inside the first to make it clear the relationship between the function that might have created an exception and the need for the if statement for the early return. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:74 > + JSValue autoIncrementValue = optionsValue.get(exec, Identifier(exec, "autoIncrement")); > + autoIncrement = autoIncrementValue.toBoolean(exec); This would read better without the autoIncrementValue local variable. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:60 > + IDBKeyPath keyPath = idbKeyPathFromValue(exec, exec->argument(1)); This will convert undefined to the string "undefined" and null to the string "null". I assume that’s the behavior we want. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:70 > + if (optionsValue.isObject()) { Why do we have this check? I believe we’ll get the same behavior without it since the get calls will return undefined values, and I would prefer that we omit it to streamline the code. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:72 > + JSValue uniqueValue = optionsValue.get(exec, Identifier(exec, "unique")); > + unique = uniqueValue.toBoolean(exec); This would read better without the uniqueValue local variable. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:77 > + JSValue multiEntryValue = optionsValue.get(exec, Identifier(exec, "multiEntry")); > + multiEntry = multiEntryValue.toBoolean(exec); This would read better without the multiEntryValue local variable. 791276 113 179326 darin 2012-12-13 20:18:19 -0800 Comment on attachment 179326 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179326&action=review > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:42 > +#include "IDBBindingUtilities.h" > +#include "IDBDatabase.h" > +#include "IDBKeyPath.h" > +#include "IDBObjectStore.h" > +#include "JSIDBObjectStore.h" > + > +#include <runtime/Error.h> > +#include <runtime/JSArray.h> > +#include <runtime/JSString.h> WebKit coding style puts these into a single paragraph, not two. > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:48 > +JSValue JSIDBDatabase::createObjectStore(JSC::ExecState* exec) Given the "using namespace JSC" above, this can just be ExecState rather than JSC::ExecState. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:41 > +#include "IDBBindingUtilities.h" > +#include "IDBKeyPath.h" > +#include "IDBObjectStore.h" > +#include "JSIDBIndex.h" > + > +#include <runtime/Error.h> > +#include <runtime/JSArray.h> > +#include <runtime/JSString.h> WebKit coding style puts these into a single paragraph, not two. > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:47 > +JSValue JSIDBObjectStore::createIndex(JSC::ExecState* exec) Given the "using namespace JSC" above, this can just be ExecState rather than JSC::ExecState. 791367 114 michael 2012-12-13 23:23:40 -0800 (In reply to comment #112) > > Source/WebCore/bindings/js/JSIDBDatabaseCustom.cpp:62 > > + if (optionsValue.isObject()) { > > Why do we have this check? I believe we’ll get the same behavior without it since the get calls will return undefined values, and I would prefer that we omit it to streamline the code, and move the definitions of the variables closer to the code that sets them up. This check ensures that accessing properties on optionsValue does not result in an exception being thrown, as will be the case if optionsValue is null or undefined, which are its only other possible values. Perhaps changing this check from isObject() to !isUndefinedOrNull() would make this more clear. > > Source/WebCore/bindings/js/JSIDBObjectStoreCustom.cpp:60 > > + IDBKeyPath keyPath = idbKeyPathFromValue(exec, exec->argument(1)); > > This will convert undefined to the string "undefined" and null to the string "null". I assume that’s the behavior we want. Yes that is the specified behavior: http://dvcs.w3.org/hg/IndexedDB/raw-file/tip/Overview.html#widl-IDBObjectStoreSync-createIndex-IDBIndexSync-DOMString-name-any-keyPath-IDBIndexParameters-optionalParameters "If the keyPath argument is an Array, then each item in the array is converted to a DOMString. If keyPath is not an Array, it is converted to a DOMString." This behavior is tested in storage/indexeddb/keypath-basics.html. 791491 115 179456 michael 2012-12-14 02:41:18 -0800 Created attachment 179456 Patch I've updated formatting and elided temporary variables in value conversion. 794136 116 179456 webkit.review.bot 2012-12-18 16:11:26 -0800 Comment on attachment 179456 Patch Clearing flags on attachment: 179456 Committed r138081: <http://trac.webkit.org/changeset/138081> 794137 117 webkit.review.bot 2012-12-18 16:11:39 -0800 All reviewed patches have been landed. Closing bug. 163809 2012-09-13 01:12:44 -0700 2012-09-14 00:31:25 -0700 Patch bug-96614-20120913161214.patch text/plain 2148 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTI4NDA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODc3OGIzNTMxNGQyOThj N2MzOGE5YTg1ZWQzNDhkMTI2MjBlYTczZi4uMTQ3YjRhZThhOGNiYzlmZmExZjk5YjIyOWMwN2Ji OTMxMzU3NDE2MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTA5LTEzICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBbQmxh Y2tCZXJyeV0gTmVlZCB0byBjbGVhciBleGNlcHRpb24gaW4gSlNEaWN0aW9uYXJ5OjpnZXRXaXRo VW5kZWZpbmVkT3JOdWxsQ2hlY2soKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9OTY2MTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBDbGVhciBhbnkgZXhjZXB0aW9uIGluIEpTRGljdGlvbmFyeTo6Z2V0V2l0 aFVuZGVmaW5lZE9yTnVsbENoZWNrLCB0byByZW1vdmUgYW55IGV4Y2VwdGlvbgorICAgICAgICB3 aGljaCBtaWdodCBoYXZlIGJlZW4gY2FycmllZCBvdmVyIGZyb20gbGFzdCB0cnkuCisKKyAgICAg ICAgSW5kZXhlZERCIG5vdyBzdXBwb3J0cyBib3RoIGFycmF5LXR5cGUga2V5UGF0aCBhbmQgc3Ry aW5nIHR5cGUga2V5UGF0aCwKKyAgICAgICAgaXQgd2lsbCBmaXJzdCB0cnkgYXJyYXkgdHlwZSwg aWYgdGhhdCBmYWlscywgaXQgd2lsbCB0cnkgdGhlIHN0cmluZyB0eXBlCisgICAgICAgIGJ5IGNh bGxpbmcgSlNEaWN0aW9uYXJ5OjpnZXRXaXRoVW5kZWZpbmVkT3JOdWxsQ2hlY2ssIGJ1dCB0aGUg ZmFpbCBhcyAKKyAgICAgICAgYXJyYXkgdHlwZSB3aWxsIGdlbmVyYXRlIGFuIGV4ZWNwdGlvbiBp biBFeGVjU3RhdGUgYW5kIHdpbGwgY2FycmllZCBvdmVyLgorICAgICAgICBXZSBuZWVkIHRvIGNs ZWFyIHRoZSBleGNlcHRpb24gdG8gYXZvaWQgdGhlIGltcGFjdCB0byB0aGUgY2hlY2sgYXMgYSBz dHJpbmcuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLCB0aGUgZXhpc3RpbmcgdGVzdCBjYXNlIGF0 IExheW91dFRlc3RzL3N0b3JhZ2UvaW5kZXhlZGRiL3R1dG9yaWFsLmh0bWwgc2hvdWxkIG5vdyBw YXNzLgorCisgICAgICAgICogYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkpTRGljdGlvbmFyeTo6Z2V0V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKToKKwog MjAxMi0wOS0xMiAgQ2hyaXMgRmxlaXphY2ggIDxjZmxlaXphY2hAYXBwbGUuY29tPgogCiAgICAg ICAgIEFYOiBzdmc6aW1hZ2Ugbm90IGFjY2Vzc2libGUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy9qcy9KU0RpY3Rpb25hcnkuY3BwCmluZGV4IGQ0ZTIyNjQ3Mzk2NDhjZmJlMjcwNWQzYjFkNTE3 Y2QzMmZlNGJmMjIuLjBjZmQxN2JhYjlhNmY4ODMzMWVkYzFjZmViNWViYzI1NjliZWRiNjYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcApAQCAtMTk4LDYg KzE5OCwxMCBAQCB2b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhl YywgSlNWYWx1ZSB2YWx1ZSwgQXJyYXlWYWx1ZSYgcmVzdQogYm9vbCBKU0RpY3Rpb25hcnk6Omdl dFdpdGhVbmRlZmluZWRPck51bGxDaGVjayhjb25zdCBTdHJpbmcmIHByb3BlcnR5TmFtZSwgU3Ry aW5nJiByZXN1bHQpIGNvbnN0CiB7CiAgICAgQVNTRVJUKGlzVmFsaWQoKSk7CisKKyAgICBpZiAo bV9leGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgbV9leGVjLT5jbGVhckV4Y2VwdGlvbigp OworCiAgICAgSlNWYWx1ZSB2YWx1ZTsKICAgICBpZiAodHJ5R2V0UHJvcGVydHkocHJvcGVydHlO YW1lLnV0ZjgoKS5kYXRhKCksIHZhbHVlKSAhPSBQcm9wZXJ0eUZvdW5kIHx8IHZhbHVlLmlzVW5k ZWZpbmVkT3JOdWxsKCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsK 164065 2012-09-14 00:31:33 -0700 2012-11-09 03:14:52 -0800 Patch bug-96614-20120914153103.patch text/plain 1710 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTI4NTY0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWI5NTVhYTE1ZWU0ZDE4 NmJiYTUwNjQwNzc0MGQzZWI2NjBjOTA4Ni4uNDcwOGVkZDNkYWJlMGM3ZGM2MmM5OWE4YmQ3ODNi NTc2ZDQ1ZmU3ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA5LTE0ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgZm9yIG9wZXJhdGlvbnMgdGhhdCBt aWdodCBoYXZlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9OTY2MTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBDbGVhciB0aGUgZXhjZXB0aW9uIGlmIGZhaWxlZCB0byBjb252ZXJ0IHRoZSB2YWx1ZSBpbnNp ZGUgdGhlIEpTRGljdGlvbmFyeS4gCisgICAgICAgIE90aGVyd2lzZSwgaXQgbWlnaHQgaW1wYWN0 IHRoZSBmb2xsb3dpbmcgb3BlcmF0aW9ucyBvbiB0aGUgZGljdGlvbmFyeS4KKworICAgICAgICBO byBuZXcgdGVzdHMsIHRoZSBleGlzdGluZyB0ZXN0IGF0IExheW91dFRlc3Qvc3RvcmFnZS9pbmRl eGVkZGIvdHV0b3JpYWwuaHRtbCBzaG91bGQgd29yayBmb3IgSlNDIGJpbmRpbmcuCisKKyAgICAg ICAgKiBiaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaDoKKyAgICAgICAgKFdlYkNvcmU6OkpTRGlj dGlvbmFyeTo6dHJ5R2V0UHJvcGVydHlBbmRSZXN1bHQpOgorCiAyMDEyLTA5LTEzICBQYXRyaWNr IEdhbnN0ZXJlciAgPHBhcm9nYUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldXNlIGZsb2F0aW5n IHBvaW50IGZvcm1hdHRpbmcgb2YgVGV4dFN0cmVhbSBpbiBbU1ZHXVJlbmRlclRyZWVBc1RleHQu Y3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnku aCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oCmluZGV4IGZlYmU5 MjQ3MmEyNDNkODAxNWNhNWYzNmI5Zjc1ZDg1NGUyMjNkMTIuLjYzMzBkZjhjN2VmMmE3MzMyMWVm YzEwMjg2NDBiYTNjOTI1YmQxNjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTRGljdGlvbmFyeS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGlj dGlvbmFyeS5oCkBAIC0xNDUsOCArMTQ1LDEwIEBAIEpTRGljdGlvbmFyeTo6R2V0UHJvcGVydHlS ZXN1bHQgSlNEaWN0aW9uYXJ5Ojp0cnlHZXRQcm9wZXJ0eUFuZFJlc3VsdChjb25zdCBjaGFyCiAg ICAgICAgIFJlc3VsdCByZXN1bHQ7CiAgICAgICAgIGNvbnZlcnRWYWx1ZShtX2V4ZWMsIHZhbHVl LCByZXN1bHQpOwogCi0gICAgICAgIGlmIChtX2V4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAg ICBpZiAobV9leGVjLT5oYWRFeGNlcHRpb24oKSkgeworICAgICAgICAgICAgbV9leGVjLT5jbGVh ckV4Y2VwdGlvbigpOwogICAgICAgICAgICAgcmV0dXJuIEV4Y2VwdGlvblRocm93bjsKKyAgICAg ICAgfQogCiAgICAgICAgIHNldHRlcihjb250ZXh0LCByZXN1bHQpOwogICAgICAgICBicmVhazsK 173253 2012-11-09 03:14:58 -0800 2012-11-09 04:13:13 -0800 Patch bug-96614-20121109191305.patch text/plain 3776 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0MDM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmFmN2ExYWU3MGIxNzM1 MzdlNDY0YTIyNzkxZDhhZDYyODA0MDFhOC4uOTFkZmY0ZWYwNjY1YmQ0MjA2M2Q1YzEwMzg1MTY3 ZmRmMjIwYjg0MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDEyLTExLTA5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgaW4gSW5kZXhlZERCIGJldHdlZW4g MiBxdWVyeS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTk2NjE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg SW5kZXhlZERCIElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZSBzdXBwb3J0cyBib3RoIFN0 cmluZyB0eXBlIG9mIEtleVBhdGggYW5kCisgICAgICAgIFN0cmluZyBBcnJheSB0eXBlIG9mIEtl eVBhdGguIEl0IHdpbGwgZmlyc3QgdHJ5IHRvIGdldCB0aGUga2V5UGF0aCBhcyBhIFN0cmluZyBB cnJheSwKKyAgICAgICAgaWYgZmFpbHMsIGl0IHdpbGwgdHJ5IHRvIGdldCBLZXlQYXRoIGFzIGEg U3RyaW5nLCBmcm9tIHRoZSBEaWN0aW9uYXJ5LiBUaGUgZmlyc3QgZ2V0CisgICAgICAgIHdpbGwg bGVhdmUgdGhlIGludGVybmFsIEV4ZWNTdGF0ZSBvZiBEaWN0aW9uYXJ5IGluIGV4Y2VwdGlvbiBz dGF0ZS4gV2UgbmVlZCB0byBjbGVhcgorICAgICAgICB0aGUgZXhjZXB0aW9uIHN0YXRlIGJlZm9y ZSB0aGUgMm5kIHF1ZXJ5LCBvdGhlcndpc2UgdGhlIHNlY29uZCBxdWVyeSB3aWxsIGFsc28gZmFp bC4KKworICAgICAgICBObyBuZXcgdGVzdHMuIFRoZSBleGlzdGluZyB0ZXN0IGNhc2UgTGF5b3V0 VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHV0b3JpYWwuaHRtbCBzaG91bGQKKyAgICAgICAgbm93 IHdvcmsgd2l0aCB0aGlzIHBhdGNoLgorCisgICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIvSURC RGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2U6OmNyZWF0ZU9iamVj dFN0b3JlKToKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9EaWN0aW9uYXJ5LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkRpY3Rpb25hcnk6OmNsZWFyRXhjZXB0aW9uKToKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAqIGJpbmRpbmdzL2pzL0RpY3Rpb25hcnkuaDoKKyAgICAgICAgKERpY3Rpb25h cnkpOgorCiAyMDEyLTExLTA5ICBWc2V2b2xvZCBWbGFzb3YgIDx2c2V2aWtAY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IEFkZCBtZWFuaW5nZnVsIGVycm9yIG1lc3NhZ2Ug d2hlbiByZXF1ZXN0IGNvbnRlbnQgd2FzIGV2aWN0ZWQgZnJvbSBpbnNwZWN0b3IgY2FjaGUuCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5jcHAKaW5k ZXggZmNjYjQ1NmM1ZDY4YTIxNDY3ZjU4ZjA5Y2RjNjI3ZmMzMGZkOTc4Mi4uNWU0NWE2ZWY2MmFi ZTMyYzQyZWUxYjUzYmQ0NWE5MjQ1YTIwNWU0YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv TW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcApAQCAtMTM4LDggKzEzOCwxMSBAQCBQYXNz UmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29u c3QgU3RyaW5nJiBuYW1lLCBjbwogICAgICAgICBWZWN0b3I8U3RyaW5nPiBrZXlQYXRoQXJyYXk7 CiAgICAgICAgIGlmIChvcHRpb25zLmdldCgia2V5UGF0aCIsIGtleVBhdGhBcnJheSkpCiAgICAg ICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoQXJyYXkpOwotICAgICAgICBlbHNl IGlmIChvcHRpb25zLmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVjaygia2V5UGF0aCIsIGtleVBh dGhTdHJpbmcpKQotICAgICAgICAgICAga2V5UGF0aCA9IElEQktleVBhdGgoa2V5UGF0aFN0cmlu Zyk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgb3B0aW9ucy5jbGVhckV4Y2VwdGlvbigp OyAvLyBDbGVhciBhbnkgZXhjZXB0aW9uIGFib3ZlIHN0ZXAgbWlnaHQgaGF2ZSBjYXVzZWQuCisg ICAgICAgICAgICBpZiAob3B0aW9ucy5nZXRXaXRoVW5kZWZpbmVkT3JOdWxsQ2hlY2soImtleVBh dGgiLCBrZXlQYXRoU3RyaW5nKSkKKyAgICAgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0 aChrZXlQYXRoU3RyaW5nKTsKKyAgICAgICAgfQogICAgIH0KIAogICAgIGlmIChtX21ldGFkYXRh LmNvbnRhaW5zT2JqZWN0U3RvcmUobmFtZSkpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0RpY3Rpb25hcnkuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMv RGljdGlvbmFyeS5jcHAKaW5kZXggNWM4MWYyMDI1Y2U0Mjg1NjZlNGZjYzQ5YjkyZWExMDA4NGY4 NDliOS4uNmJmYzVkODE3MzZjMzczMGM5MGY0ZDU1MGIxYzg3MDVlNjdiMTQ3NyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvRGljdGlvbmFyeS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvRGljdGlvbmFyeS5jcHAKQEAgLTEwMyw0ICsxMDMsMTEgQEAg Ym9vbCBEaWN0aW9uYXJ5OjpnZXRXaXRoVW5kZWZpbmVkT3JOdWxsQ2hlY2soY29uc3QgU3RyaW5n JiBwcm9wZXJ0eU5hbWUsIFN0cmluZyYKICAgICByZXR1cm4gbV9kaWN0aW9uYXJ5LmdldFdpdGhV bmRlZmluZWRPck51bGxDaGVjayhwcm9wZXJ0eU5hbWUsIHZhbHVlKTsKIH0KIAordm9pZCBEaWN0 aW9uYXJ5OjpjbGVhckV4Y2VwdGlvbigpIGNvbnN0Cit7CisgICAgRXhlY1N0YXRlKiBleGVjID0g bV9kaWN0aW9uYXJ5LmV4ZWNTdGF0ZSgpOworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkK KyAgICAgICAgZXhlYy0+Y2xlYXJFeGNlcHRpb24oKTsKK30KKwogfTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0RpY3Rpb25hcnkuaCBiL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0RpY3Rpb25hcnkuaAppbmRleCA5NGRhODc4ZmY2YjZiZmFjODAyMTRhODdiNDdl YTNmZWM2Zjg1OTNjLi5kMWM4MjI5MjBmMWFjYzI5MmI4Nzg2ODU0NTdjOTBiNWQ3NGUzYWQ1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9EaWN0aW9uYXJ5LmgKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvRGljdGlvbmFyeS5oCkBAIC02Myw2ICs2Myw3IEBA IHB1YmxpYzoKICAgICBib29sIGdldE93blByb3BlcnRpZXNBc1N0cmluZ0hhc2hNYXAoSGFzaE1h cDxTdHJpbmcsIFN0cmluZz4mKSBjb25zdDsKICAgICBib29sIGdldE93blByb3BlcnR5TmFtZXMo VmVjdG9yPFN0cmluZz4mKSBjb25zdDsKICAgICBib29sIGdldFdpdGhVbmRlZmluZWRPck51bGxD aGVjayhjb25zdCBTdHJpbmcmIHByb3BlcnR5TmFtZSwgU3RyaW5nJiB2YWx1ZSkgY29uc3Q7Cisg ICAgdm9pZCBjbGVhckV4Y2VwdGlvbigpIGNvbnN0OwogCiBwcml2YXRlOgogICAgIHRlbXBsYXRl IDx0eXBlbmFtZSBUPgo= 173261 2012-11-09 04:13:19 -0800 2012-11-09 07:26:13 -0800 Patch bug-96614-20121109201125.patch text/plain 2072 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0MDM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmFmN2ExYWU3MGIxNzM1 MzdlNDY0YTIyNzkxZDhhZDYyODA0MDFhOC4uZDQyYzA4OWUxMjRhMDlhYzlmZTYyYTJkZTkxNGI2 OTkyMGM5OGVkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTExLTA5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgdGhhdCBtaWdodCBoYXZlIGJlZW4g Y2F1c2VkIGJ5IHByZXZpb3VzIG9wZXJhdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTk2NjE0CisKKyAgICAgICAgSW5kZXhlZERCIElEQkRhdGFi YXNlOjpjcmVhdGVPYmplY3RTdG9yZSBzdXBwb3J0cyBib3RoIFN0cmluZyB0eXBlIG9mIEtleVBh dGggYW5kCisgICAgICAgIFN0cmluZyBBcnJheSB0eXBlIG9mIEtleVBhdGguIEl0IHdpbGwgZmly c3QgdHJ5IHRvIGdldCB0aGUga2V5UGF0aCBhcyBhIFN0cmluZyBBcnJheSwKKyAgICAgICAgaWYg ZmFpbHMsIGl0IHdpbGwgdHJ5IHRvIGdldCBLZXlQYXRoIGFzIGEgU3RyaW5nLCBmcm9tIHRoZSBE aWN0aW9uYXJ5LiBUaGUgZmlyc3QgZ2V0CisgICAgICAgIHdpbGwgbGVhdmUgdGhlIGludGVybmFs IEV4ZWNTdGF0ZSBvZiBEaWN0aW9uYXJ5IGluIGV4Y2VwdGlvbiBzdGF0ZS4gV2UgbmVlZCB0byBj bGVhcgorICAgICAgICB0aGUgZXhjZXB0aW9uIHN0YXRlIGJlZm9yZSB0aGUgMm5kIHF1ZXJ5LCBv dGhlcndpc2UgdGhlIHNlY29uZCBxdWVyeSB3aWxsIGFsc28gZmFpbC4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIFRoZSBleGlzdGluZyB0ZXN0IGNhc2UgTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRl eGVkZGIvdHV0b3JpYWwuaHRtbCBzaG91bGQKKyAgICAgICAgbm93IHdvcmsgd2l0aCB0aGlzIHBh dGNoLiAKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SlNEaWN0aW9uYXJ5OjpnZXRXaXRoVW5kZWZpbmVkT3JOdWxsQ2hlY2spOgorCiAy MDEyLTExLTA5ICBWc2V2b2xvZCBWbGFzb3YgIDx2c2V2aWtAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFdlYiBJbnNwZWN0b3I6IEFkZCBtZWFuaW5nZnVsIGVycm9yIG1lc3NhZ2Ugd2hlbiByZXF1 ZXN0IGNvbnRlbnQgd2FzIGV2aWN0ZWQgZnJvbSBpbnNwZWN0b3IgY2FjaGUuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAppbmRleCBmNDc2ZDcyNjhlMmE3M2Qz ZDQzZDBhN2ZmZmQ2MDQxOTA3YzVhZjAxLi5mMGJiZTM3YzA3ZGJjMjY4YzUzZDA0MzIxYzU4MTRi NjQ1YWM3ZjNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rp b25hcnkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5j cHAKQEAgLTIxNiw2ICsyMTYsOSBAQCBib29sIEpTRGljdGlvbmFyeTo6Z2V0V2l0aFVuZGVmaW5l ZE9yTnVsbENoZWNrKGNvbnN0IFN0cmluZyYgcHJvcGVydHlOYW1lLCBTdHJpbgogewogICAgIEFT U0VSVChpc1ZhbGlkKCkpOwogICAgIEpTVmFsdWUgdmFsdWU7CisKKyAgICBpZiAobV9leGVjLT5o YWRFeGNlcHRpb24oKSkgLy8gQ2xlYXIgZXhjZXB0aW9ucyB0aGF0IG1pZ2h0IGhhdmUgYmVlbiBj YXVzZWQgYnkgcHJldmlvdXMgcXVlcnkuCisgICAgICAgIG1fZXhlYy0+Y2xlYXJFeGNlcHRpb24o KTsKICAgICBpZiAodHJ5R2V0UHJvcGVydHkocHJvcGVydHlOYW1lLnV0ZjgoKS5kYXRhKCksIHZh bHVlKSAhPSBQcm9wZXJ0eUZvdW5kIHx8IHZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkpCiAgICAg ICAgIHJldHVybiBmYWxzZTsKIAo= 173304 2012-11-09 07:26:29 -0800 2012-11-09 07:30:16 -0800 Patch bug-96614-20121109232432.patch text/plain 2289 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0MDM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmFmN2ExYWU3MGIxNzM1 MzdlNDY0YTIyNzkxZDhhZDYyODA0MDFhOC4uZGI1Y2EzZDU2MTRlZDI5ZWU2Y2NkNGNlMjNlNTA1 YjgzMjMxNTM4OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEyLTExLTA5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgdGhhdCBtaWdodCBoYXZlIGJlZW4g Y2F1c2VkIGJ5IHByZXZpb3VzIG9wZXJhdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTk2NjE0CisKKyAgICAgICAgSW5kZXhlZERCIElEQkRhdGFi YXNlOjpjcmVhdGVPYmplY3RTdG9yZSBzdXBwb3J0cyBib3RoIFN0cmluZyB0eXBlIG9mIEtleVBh dGggYW5kCisgICAgICAgIFN0cmluZyBBcnJheSB0eXBlIG9mIEtleVBhdGguIEl0IHdpbGwgZmly c3QgdHJ5IHRvIGdldCB0aGUga2V5UGF0aCBhcyBhIFN0cmluZyBBcnJheSwKKyAgICAgICAgaWYg ZmFpbHMsIGl0IHdpbGwgdHJ5IHRvIGdldCBLZXlQYXRoIGFzIGEgU3RyaW5nLCBmcm9tIHRoZSBE aWN0aW9uYXJ5LiBUaGUgZmlyc3QgZ2V0CisgICAgICAgIHdpbGwgbGVhdmUgdGhlIGludGVybmFs IEV4ZWNTdGF0ZSBvZiBEaWN0aW9uYXJ5IGluIGV4Y2VwdGlvbiBzdGF0ZS4gV2UgbmVlZCB0byBj bGVhcgorICAgICAgICB0aGUgZXhjZXB0aW9uIHN0YXRlIGJlZm9yZSB0aGUgMm5kIHF1ZXJ5LCBv dGhlcndpc2UgdGhlIHNlY29uZCBxdWVyeSB3aWxsIGFsc28gZmFpbC4KKworICAgICAgICBObyBu ZXcgdGVzdHMuIFRoZSBleGlzdGluZyB0ZXN0IGNhc2UgTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRl eGVkZGIvdHV0b3JpYWwuaHRtbCBzaG91bGQKKyAgICAgICAgbm93IHdvcmsgd2l0aCB0aGlzIHBh dGNoLgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpKU0RpY3Rpb25hcnk6OmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVjayk6CisKIDIw MTItMTEtMDkgIFZzZXZvbG9kIFZsYXNvdiAgPHZzZXZpa0BjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgV2ViIEluc3BlY3RvcjogQWRkIG1lYW5pbmdmdWwgZXJyb3IgbWVzc2FnZSB3aGVuIHJlcXVl c3QgY29udGVudCB3YXMgZXZpY3RlZCBmcm9tIGluc3BlY3RvciBjYWNoZS4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCmluZGV4IGY0NzZkNzI2OGUyYTczZDNk NDNkMGE3ZmZmZDYwNDE5MDdjNWFmMDEuLmFkMTdhOTZkNDZiYTNmMDBkYjAxMmU3ODIxMWE2MGQx N2ZiNmRhOTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlv bmFyeS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNw cApAQCAtMjE2LDYgKzIxNiwxMSBAQCBib29sIEpTRGljdGlvbmFyeTo6Z2V0V2l0aFVuZGVmaW5l ZE9yTnVsbENoZWNrKGNvbnN0IFN0cmluZyYgcHJvcGVydHlOYW1lLCBTdHJpbgogewogICAgIEFT U0VSVChpc1ZhbGlkKCkpOwogICAgIEpTVmFsdWUgdmFsdWU7CisKKyAgICAvLyBGSVhNRTogVGhp cyBjaGVjayBzaG91bGQgYmUgbW92ZWQgdG8gdGhlIGhlYWQgb2YgSlNEaWN0aW9uYXJ5Ojp0cnlH ZXRQcm9wZXJ0eShwcm9wZXJ0eU5hbWUsIEpTVmFsdWUmKQorICAgIC8vIEN1cnJlbnRseSB3ZSBj YW4ndCBtb3ZlIHRoZSBjaGVjayB0aGVyZSBiZWNhdXNlIGl0IHNlZW1zIGJyZWFrcyBzb21lIFF0 L0VGTCB0ZXN0cyBmb3Igc29tZSByZWFzb24uCisgICAgaWYgKG1fZXhlYy0+aGFkRXhjZXB0aW9u KCkpIC8vIENsZWFyIGV4Y2VwdGlvbnMgdGhhdCBtaWdodCBoYXZlIGJlZW4gY2F1c2VkIGJ5IHBy ZXZpb3VzIHF1ZXJ5LgorICAgICAgICBtX2V4ZWMtPmNsZWFyRXhjZXB0aW9uKCk7CiAgICAgaWYg KHRyeUdldFByb3BlcnR5KHByb3BlcnR5TmFtZS51dGY4KCkuZGF0YSgpLCB2YWx1ZSkgIT0gUHJv cGVydHlGb3VuZCB8fCB2YWx1ZS5pc1VuZGVmaW5lZE9yTnVsbCgpKQogICAgICAgICByZXR1cm4g ZmFsc2U7CiAK 173306 2012-11-09 07:30:34 -0800 2012-11-11 19:33:23 -0800 Patch bug-96614-20121109232834.patch text/plain 2328 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0MDM3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmFmN2ExYWU3MGIxNzM1 MzdlNDY0YTIyNzkxZDhhZDYyODA0MDFhOC4uMjFkYWMxYjg5MjM3MWM2MjNkMjE0OTM4YzBiY2Iy M2JkMjQxM2IxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTExLTA5ICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgdGhhdCBtaWdodCBoYXZlIGJlZW4g Y2F1c2VkIGJ5IHByZXZpb3VzIG9wZXJhdGlvbi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTk2NjE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgR2Vvcmdl IFN0YWlrb3MuCisKKyAgICAgICAgSW5kZXhlZERCIElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RT dG9yZSBzdXBwb3J0cyBib3RoIFN0cmluZyB0eXBlIG9mIEtleVBhdGggYW5kCisgICAgICAgIFN0 cmluZyBBcnJheSB0eXBlIG9mIEtleVBhdGguIEl0IHdpbGwgZmlyc3QgdHJ5IHRvIGdldCB0aGUg a2V5UGF0aCBhcyBhIFN0cmluZyBBcnJheSwKKyAgICAgICAgaWYgZmFpbHMsIGl0IHdpbGwgdHJ5 IHRvIGdldCBLZXlQYXRoIGFzIGEgU3RyaW5nLCBmcm9tIHRoZSBEaWN0aW9uYXJ5LiBUaGUgZmly c3QgZ2V0CisgICAgICAgIHdpbGwgbGVhdmUgdGhlIGludGVybmFsIEV4ZWNTdGF0ZSBvZiBEaWN0 aW9uYXJ5IGluIGV4Y2VwdGlvbiBzdGF0ZS4gV2UgbmVlZCB0byBjbGVhcgorICAgICAgICB0aGUg ZXhjZXB0aW9uIHN0YXRlIGJlZm9yZSB0aGUgMm5kIHF1ZXJ5LCBvdGhlcndpc2UgdGhlIHNlY29u ZCBxdWVyeSB3aWxsIGFsc28gZmFpbC4KKworICAgICAgICBObyBuZXcgdGVzdHMuIFRoZSBleGlz dGluZyB0ZXN0IGNhc2UgTGF5b3V0VGVzdHMvc3RvcmFnZS9pbmRleGVkZGIvdHV0b3JpYWwuaHRt bCBzaG91bGQKKyAgICAgICAgbm93IHdvcmsgd2l0aCB0aGlzIHBhdGNoLgorICAgICAgICAqIGJp bmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpKU0RpY3Rpb25h cnk6OmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVjayk6CisKIDIwMTItMTEtMDkgIFZzZXZvbG9k IFZsYXNvdiAgPHZzZXZpa0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3Rvcjog QWRkIG1lYW5pbmdmdWwgZXJyb3IgbWVzc2FnZSB3aGVuIHJlcXVlc3QgY29udGVudCB3YXMgZXZp Y3RlZCBmcm9tIGluc3BlY3RvciBjYWNoZS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9K U0RpY3Rpb25hcnkuY3BwCmluZGV4IGY0NzZkNzI2OGUyYTczZDNkNDNkMGE3ZmZmZDYwNDE5MDdj NWFmMDEuLmFkMTdhOTZkNDZiYTNmMDBkYjAxMmU3ODIxMWE2MGQxN2ZiNmRhOTMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcApAQCAtMjE2LDYgKzIxNiwx MSBAQCBib29sIEpTRGljdGlvbmFyeTo6Z2V0V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKGNvbnN0 IFN0cmluZyYgcHJvcGVydHlOYW1lLCBTdHJpbgogewogICAgIEFTU0VSVChpc1ZhbGlkKCkpOwog ICAgIEpTVmFsdWUgdmFsdWU7CisKKyAgICAvLyBGSVhNRTogVGhpcyBjaGVjayBzaG91bGQgYmUg bW92ZWQgdG8gdGhlIGhlYWQgb2YgSlNEaWN0aW9uYXJ5Ojp0cnlHZXRQcm9wZXJ0eShwcm9wZXJ0 eU5hbWUsIEpTVmFsdWUmKQorICAgIC8vIEN1cnJlbnRseSB3ZSBjYW4ndCBtb3ZlIHRoZSBjaGVj ayB0aGVyZSBiZWNhdXNlIGl0IHNlZW1zIGJyZWFrcyBzb21lIFF0L0VGTCB0ZXN0cyBmb3Igc29t ZSByZWFzb24uCisgICAgaWYgKG1fZXhlYy0+aGFkRXhjZXB0aW9uKCkpIC8vIENsZWFyIGV4Y2Vw dGlvbnMgdGhhdCBtaWdodCBoYXZlIGJlZW4gY2F1c2VkIGJ5IHByZXZpb3VzIHF1ZXJ5LgorICAg ICAgICBtX2V4ZWMtPmNsZWFyRXhjZXB0aW9uKCk7CiAgICAgaWYgKHRyeUdldFByb3BlcnR5KHBy b3BlcnR5TmFtZS51dGY4KCkuZGF0YSgpLCB2YWx1ZSkgIT0gUHJvcGVydHlGb3VuZCB8fCB2YWx1 ZS5pc1VuZGVmaW5lZE9yTnVsbCgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAK 173540 2012-11-11 19:33:32 -0800 2012-11-26 14:58:24 -0800 Patch bug-96614-20121112113134.patch text/plain 1735 charles.wei U3VidmVyc2lvbiBSZXZpc2lvbjogMTM0MTgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODM2ZDk3ZTI0ZGNmZTBj YWEwZWNkOTFiYWUxMTA2ODM0MDc2OGNkYy4uOTQxMGQyMjM4YTE2YTk5OWJhNmJjZjk4MDhmMDhj M2MwODNhZmJhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEyLTExLTExICBDaGFy bGVzIFdlaSAgPGNoYXJsZXMud2VpQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBOZWVk IHRvIGNsZWFyIGV4Y2VwdGlvbiBpbiBKU0RpY3Rpb25hcnkgZm9yIG9wZXJhdGlvbnMgdGhhdCBt aWdodCBoYXZlLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9OTY2MTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBXZSBuZWVkIHRvIGNsZWFyIGFueSBleGNlcHRpb25zIGJlZm9yZSBxdWVyeWluZyB0aGUgSlNE aWN0aW9uYXJ5IHRvIGF2b2lkIHRoZQorICAgICAgICBpbnRlcmZlcmVuY2Ugb2YgbGFzdCBxdWVy eSB3aGljaCBtaWdodCBsZWF2ZSB0aGUgRXhlY1N0YXRlIG9mIEpTRGljdGlvbmFyeSBpbgorICAg ICAgICBFeGNlcHRpb24gc3RhdGUuIAorCisgICAgICAgIFRoZSBleGlzdGluZyB0ZXN0IGNhc2Ug TGF5b3V0VGVzdC9zdG9yYWdlL2luZGV4ZWRkYi90dXRvcmlhbC5odG1sIHNob3VsZCB3b3JrCisg ICAgICAgIHdpdGggdGhpcyBwYXRjaCBmb3IgSlNDIGJpbmRpbmcuCisKKyAgICAgICAgKiBiaW5k aW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SlNEaWN0aW9uYXJ5 Ojp0cnlHZXRQcm9wZXJ0eSk6CisKIDIwMTItMTEtMTEgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJl dmlldy5ib3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIx MzQxNDQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25h cnkuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAppbmRl eCBmNDc2ZDcyNjhlMmE3M2QzZDQzZDBhN2ZmZmQ2MDQxOTA3YzVhZjAxLi5mYjgwMTRmZDM3NGQ2 MzlmMzE3MmMyNTBjOGI0NmZhN2YyZjEzODcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTRGljdGlvbmFyeS5jcHAKQEAgLTUyLDYgKzUyLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogSlNEaWN0aW9uYXJ5OjpHZXRQcm9wZXJ0eVJlc3VsdCBKU0RpY3Rpb25hcnk6OnRyeUdldFBy b3BlcnR5KGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgSlNWYWx1ZSYgZmluYWxSZXN1bHQpIGNv bnN0CiB7CiAgICAgQVNTRVJUKGlzVmFsaWQoKSk7CisgICAgaWYgKG1fZXhlYy0+aGFkRXhjZXB0 aW9uKCkpIC8vIENsZWFyIGV4Y2VwdGlvbnMsIGlmIGFueSwgbGVmdCBieSBsYXN0IHF1ZXJ5Lgor ICAgICAgICBtX2V4ZWMtPmNsZWFyRXhjZXB0aW9uKCk7CisKICAgICBJZGVudGlmaWVyIGlkZW50 aWZpZXIobV9leGVjLCBwcm9wZXJ0eU5hbWUpOwogICAgIFByb3BlcnR5U2xvdCBzbG90KG1faW5p dGlhbGl6ZXJPYmplY3QuZ2V0KCkpOwogCg== 177806 2012-12-05 12:05:50 -0800 2012-12-05 18:53:04 -0800 Patch jsc-jsdictionary-array.patch text/plain 3470 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCA1IERlYyAy MDEyIDExOjUxOjUyIC0wODAwClN1YmplY3Q6IFtKU0NdIENoZWNrIHdoZXRoZXIgcHJvcGVydHkg aXMgYW4gYXJyYXkgYmVmb3JlIGF0dGVtcHRpbmcgY29udmVyc2lvbiB0byBhcnJheSBpbiBKU0Rp Y3Rpb25hcnkKCi0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICB8ICAgMjIgKysrKysrKysrKysrKysrKysrKysrKwogU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNEaWN0aW9uYXJ5LmNwcCB8ICAgMTcgKysrKysrKysrKysrKysrKysKIFNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oICAgfCAgICAzICsrKwogMyBmaWxlcyBjaGFu Z2VkLCA0MiBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDc3Y2JhOGYuLjJkOGY1YTMgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyNSBAQAorMjAxMi0xMi0wNSAgTWljaGFlbCBQcnVldHQgIDxt aWNoYWVsQDY4ay5vcmc+CisKKyAgICAgICAgW0pTQ10gQ2hlY2sgd2hldGhlciBwcm9wZXJ0eSBp cyBhbiBhcnJheSBiZWZvcmUgYXR0ZW1wdGluZyBjb252ZXJzaW9uIHRvIGFycmF5IGluIEpTRGlj dGlvbmFyeQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 OTY2MTQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBK U0RpY3Rpb25hcnkgc2hvdWxkIGNoZWNrIHdoZXRoZXIgdGhlIHByb3BlcnR5IGJlaW5nIGFjY2Vz c2VkIGluIGdldCgpCisgICAgICAgIGlzIGFuIGFycmF5IGJlZm9yZSBhdHRlbXB0aW5nIHRvIGNv bnZlcnQgdGhlIHZhbHVlIHRvIGFuIGFycmF5LgorCisgICAgICAgIFByZXZpb3VzbHkgY2FsbGlu ZyBnZXQoKSB3aXRoIGEgcmVzdWx0IHR5cGUgb2YgVmVjdG9yPFN0cmluZz4gd2hlbgorICAgICAg ICB0aGUgbmFtZWQgcHJvcGVydHkgY291bGQgbm90IGJlIGNvbnZlcnRlZCB0byBhbiBhcnJheSB3 b3VsZCBnZW5lcmF0ZQorICAgICAgICBhbiBleGNlcHRpb24uCisKKyAgICAgICAgVGVzdHM6IHN0 b3JhZ2UvaW5kZXhlZGRiLyoKKworICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5j cHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkpTRGljdGlvbmFyeTo6 Z2V0KToKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaDoKKyAgICAgICAgKFdl YkNvcmUpOgorCiAyMDEyLTEyLTA1ICBSb2JlcnQgSG9nYW4gIDxyb2JlcnRAd2Via2l0Lm9yZz4K IAogICAgICAgICBSRUdSRVNTSU9OKHIxMjY2ODMpOiBUYWJsZSBjZWxsIGFyZSBnZXR0aW5nIGJv cmRlcnMgd2hlbiB0aGUgc3R5bGUgZG9lc24ndCBtZW50aW9uIGFueQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKaW5kZXggNGUyZGQ0Yy4uOTc0NmQxYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCkBAIC0xLDUgKzEs NiBAQAogLyoKICAqIENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhr Lm9yZz4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtMjI4LDQgKzIyOSwyMCBA QCBib29sIEpTRGljdGlvbmFyeTo6Z2V0V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKGNvbnN0IFN0 cmluZyYgcHJvcGVydHlOYW1lLCBTdHJpbgogICAgIHJldHVybiB0cnVlOwogfQogCit0ZW1wbGF0 ZSA8PgorYm9vbCBKU0RpY3Rpb25hcnk6OmdldChjb25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIFZl Y3RvcjxTdHJpbmc+JiByZXN1bHQpIGNvbnN0Cit7CisgICAgSlNWYWx1ZSB2YWx1ZTsKKyAgICBH ZXRQcm9wZXJ0eVJlc3VsdCBnZXRQcm9wZXJ0eVJlc3VsdCA9IHRyeUdldFByb3BlcnR5KHByb3Bl cnR5TmFtZSwgdmFsdWUpOworICAgIGlmIChnZXRQcm9wZXJ0eVJlc3VsdCAhPSBQcm9wZXJ0eUZv dW5kKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCF2YWx1ZS5pc09iamVjdCgpKQor ICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgSlNPYmplY3QqIG9iamVjdCA9IGFzT2JqZWN0KHZh bHVlKTsKKyAgICBpZiAoIWlzSlNBcnJheShvYmplY3QpICYmICFvYmplY3QtPmluaGVyaXRzKCZK U0FycmF5OjpzX2luZm8pKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgY29udmVydFZhbHVl KG1fZXhlYywgdmFsdWUsIHJlc3VsdCk7CisgICAgcmV0dXJuIG1fZXhlYy0+aGFkRXhjZXB0aW9u KCk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNEaWN0aW9uYXJ5LmgKaW5kZXggZTE3Zjg2OC4uMjlkNjQ0YyAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmgKKysrIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmgKQEAgLTEzOSw2ICsxMzksOSBAQCBib29sIEpT RGljdGlvbmFyeTo6Z2V0KGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgUmVzdWx0JiBmaW5hbFJl c3VsdCkgY29uc3QKICAgICByZXR1cm4gdHJ5R2V0UHJvcGVydHlBbmRSZXN1bHQocHJvcGVydHlO YW1lLCAmZmluYWxSZXN1bHQsIElkZW50aXR5U2V0dGVyPFJlc3VsdD46OmlkZW50aXR5U2V0dGVy KSA9PSBQcm9wZXJ0eUZvdW5kOwogfQogCit0ZW1wbGF0ZSA8PgorYm9vbCBKU0RpY3Rpb25hcnk6 OmdldChjb25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIFZlY3RvcjxTdHJpbmc+JiByZXN1bHQpIGNv bnN0OworCiB0ZW1wbGF0ZSA8dHlwZW5hbWUgVCwgdHlwZW5hbWUgUmVzdWx0PgogSlNEaWN0aW9u YXJ5OjpHZXRQcm9wZXJ0eVJlc3VsdCBKU0RpY3Rpb25hcnk6OnRyeUdldFByb3BlcnR5QW5kUmVz dWx0KGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgVCogY29udGV4dCwgdm9pZCAoKnNldHRlciko VCogY29udGV4dCwgY29uc3QgUmVzdWx0JikpIGNvbnN0CiB7Ci0tIAoxLjcuOS41Cgo= 177865 2012-12-05 16:43:32 -0800 2012-12-05 18:53:04 -0800 Patch jsc-jsdictionary-array.patch text/plain 14263 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCA1IERlYyAy MDEyIDE2OjM3OjQ4IC0wODAwClN1YmplY3Q6IFtKU0NdIENoZWNrIHdoZXRoZXIgcHJvcGVydHkg aXMgYW4gYXJyYXkgYmVmb3JlIGF0dGVtcHRpbmcgY29udmVyc2lvbiB0byBhcnJheSBpbiBKU0Rp Y3Rpb25hcnkKCi0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICB8ICAgMjEgKysrKysrKwogU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5 LmNwcCB8ICAgOTEgKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiBTb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaCAgIHwgICA1MyArKysrKysrKystLS0tLS0tCiAzIGZp bGVzIGNoYW5nZWQsIDExMSBpbnNlcnRpb25zKCspLCA1NCBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cK aW5kZXggNzdjYmE4Zi4uMmJmYjRiYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEy LTEyLTA1ICBNaWNoYWVsIFBydWV0dCAgPG1pY2hhZWxANjhrLm9yZz4KKworICAgICAgICBbSlND XSBDaGVjayB3aGV0aGVyIHByb3BlcnR5IGlzIGFuIGFycmF5IGJlZm9yZSBhdHRlbXB0aW5nIGNv bnZlcnNpb24gdG8gYXJyYXkgaW4gSlNEaWN0aW9uYXJ5CisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NjYxNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIEpTRGljdGlvbmFyeSBzaG91bGQgY2hlY2sgd2hldGhl ciB0aGUgcHJvcGVydHkgYmVpbmcgYWNjZXNzZWQgaW4gZ2V0KCkKKyAgICAgICAgaXMgYW4gYXJy YXkgYmVmb3JlIGF0dGVtcHRpbmcgdG8gY29udmVydCB0aGUgdmFsdWUgdG8gYW4gYXJyYXkuCisK KyAgICAgICAgUHJldmlvdXNseSBjYWxsaW5nIGdldCgpIHdpdGggYSByZXN1bHQgdHlwZSBvZiBW ZWN0b3I8U3RyaW5nPiB3aGVuCisgICAgICAgIHRoZSBuYW1lZCBwcm9wZXJ0eSBjb3VsZCBub3Qg YmUgY29udmVydGVkIHRvIGFuIGFycmF5IHdvdWxkIGdlbmVyYXRlCisgICAgICAgIGFuIGV4Y2Vw dGlvbi4KKworICAgICAgICBUZXN0czogc3RvcmFnZS9pbmRleGVkZGIvKgorCisgICAgICAgICog YmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkpTRGljdGlv bmFyeTo6Y29udmVydFZhbHVlKToKKyAgICAgICAgKiBiaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnku aDoKKyAgICAgICAgKFdlYkNvcmU6OkpTRGljdGlvbmFyeTo6dHJ5R2V0UHJvcGVydHlBbmRSZXN1 bHQpOgorCiAyMDEyLTEyLTA1ICBSb2JlcnQgSG9nYW4gIDxyb2JlcnRAd2Via2l0Lm9yZz4KIAog ICAgICAgICBSRUdSRVNTSU9OKHIxMjY2ODMpOiBUYWJsZSBjZWxsIGFyZSBnZXR0aW5nIGJvcmRl cnMgd2hlbiB0aGUgc3R5bGUgZG9lc24ndCBtZW50aW9uIGFueQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKaW5kZXggNGUyZGQ0Yy4uZWVjNTE3ZSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCkBAIC0xLDUgKzEsNiBA QAogLyoKICAqIENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9y Zz4KICAqCiAgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKICAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwpAQCAtNjgsMTUyICs2OSwxODIgQEAg SlNEaWN0aW9uYXJ5OjpHZXRQcm9wZXJ0eVJlc3VsdCBKU0RpY3Rpb25hcnk6OnRyeUdldFByb3Bl cnR5KGNvbnN0IGNoYXIqIHByb3BlcnQKICAgICByZXR1cm4gUHJvcGVydHlGb3VuZDsKIH0KIAot dm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUg dmFsdWUsIGJvb2wmIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhl Y1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBib29sJiByZXN1bHQpCiB7CiAgICAgcmVzdWx0 ID0gdmFsdWUudG9Cb29sZWFuKGV4ZWMpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpT RGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwg aW50JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSog ZXhlYywgSlNWYWx1ZSB2YWx1ZSwgaW50JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdmFsdWUu dG9JbnQzMihleGVjKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6 OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVuc2lnbmVkJiBy ZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywg SlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQmIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB2YWx1ZS50 b1VJbnQzMihleGVjKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6 OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVuc2lnbmVkIHNo b3J0JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSog ZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQgc2hvcnQmIHJlc3VsdCkKIHsKICAgICByZXN1 bHQgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBzaG9ydD4odmFsdWUudG9VSW50MzIoZXhlYykpOwor ICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4 ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQgbG9uZyYgcmVzdWx0KQorYm9v bCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFs dWUsIHVuc2lnbmVkIGxvbmcmIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSBzdGF0aWNfY2FzdDx1 bnNpZ25lZCBsb25nPih2YWx1ZS50b1VJbnQzMihleGVjKSk7CisgICAgcmV0dXJuIHRydWU7CiB9 CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1Zh bHVlIHZhbHVlLCB1bnNpZ25lZCBsb25nIGxvbmcmIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5 Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCB1bnNpZ25lZCBs b25nIGxvbmcmIHJlc3VsdCkKIHsKICAgICBkb3VibGUgZCA9IHZhbHVlLnRvTnVtYmVyKGV4ZWMp OwogICAgIGRvdWJsZVRvSW50ZWdlcihkLCByZXN1bHQpOworICAgIHJldHVybiB0cnVlOwogfQog Ci12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1 ZSB2YWx1ZSwgZG91YmxlJiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVl KEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgZG91YmxlJiByZXN1bHQpCiB7CiAgICAg cmVzdWx0ID0gdmFsdWUudG9OdW1iZXIoZXhlYyk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZv aWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqIGV4ZWMsIEpTQzo6 SlNWYWx1ZSB2YWx1ZSwgRGljdGlvbmFyeSYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNv bnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSogZXhlYywgSlNDOjpKU1ZhbHVlIHZhbHVlLCBEaWN0 aW9uYXJ5JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gRGljdGlvbmFyeShleGVjLCB2YWx1ZSk7 CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUo RXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBTdHJpbmcmIHJlc3VsdCkKK2Jvb2wgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBT dHJpbmcmIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB2YWx1ZS50b1N0cmluZyhleGVjKS0+dmFs dWUoZXhlYyk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252 ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBWZWN0b3I8U3RyaW5nPiYg cmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMs IEpTVmFsdWUgdmFsdWUsIFZlY3RvcjxTdHJpbmc+JiByZXN1bHQpCiB7CiAgICAgaWYgKHZhbHVl LmlzVW5kZWZpbmVkT3JOdWxsKCkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZh bHNlOworCisgICAgaWYgKCF2YWx1ZS5pc09iamVjdCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgSlNPYmplY3QqIG9iamVjdCA9IGFzT2JqZWN0KHZhbHVlKTsKKyAgICBpZiAoIWlzSlNB cnJheShvYmplY3QpICYmICFvYmplY3QtPmluaGVyaXRzKCZKU0FycmF5OjpzX2luZm8pKQorICAg ICAgICByZXR1cm4gZmFsc2U7CiAKICAgICB1bnNpZ25lZCBsZW5ndGggPSAwOwotICAgIEpTT2Jq ZWN0KiBvYmplY3QgPSB0b0pTU2VxdWVuY2UoZXhlYywgdmFsdWUsIGxlbmd0aCk7CisgICAgb2Jq ZWN0ID0gdG9KU1NlcXVlbmNlKGV4ZWMsIHZhbHVlLCBsZW5ndGgpOwogICAgIGlmIChleGVjLT5o YWRFeGNlcHRpb24oKSkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1cm4gZmFsc2U7CiAK ICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwIDsgaSA8IGxlbmd0aDsgKytpKSB7CiAgICAgICAgIEpT VmFsdWUgaXRlbVZhbHVlID0gb2JqZWN0LT5nZXQoZXhlYywgaSk7CiAgICAgICAgIGlmIChleGVj LT5oYWRFeGNlcHRpb24oKSkKLSAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICAgIHJldHVy biBmYWxzZTsKICAgICAgICAgcmVzdWx0LmFwcGVuZChpdGVtVmFsdWUudG9TdHJpbmcoZXhlYykt PnZhbHVlKGV4ZWMpKTsKICAgICB9CisKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0Rp Y3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIFNj cmlwdFZhbHVlJiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNT dGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgU2NyaXB0VmFsdWUmIHJlc3VsdCkKIHsKICAgICBy ZXN1bHQgPSBTY3JpcHRWYWx1ZShleGVjLT5nbG9iYWxEYXRhKCksIHZhbHVlKTsKKyAgICByZXR1 cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUq IGV4ZWMsIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+JiByZXN1 bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNW YWx1ZSB2YWx1ZSwgUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4mIHJlc3VsdCkKIHsKICAg ICByZXN1bHQgPSBTZXJpYWxpemVkU2NyaXB0VmFsdWU6OmNyZWF0ZShleGVjLCB2YWx1ZSwgMCwg MCk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFs dWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPERPTVdpbmRvdz4mIHJlc3VsdCkK K2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1 ZSwgUmVmUHRyPERPTVdpbmRvdz4mIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB0b0RPTVdpbmRv dyh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252 ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPEV2ZW50VGFyZ2V0PiYg cmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqLCBKU1Zh bHVlIHZhbHVlLCBSZWZQdHI8RXZlbnRUYXJnZXQ+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0g dG9FdmVudFRhcmdldCh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0 aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPE5v ZGU+JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSos IEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxOb2RlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IHRv Tm9kZSh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpj b252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPFN0b3JhZ2U+JiBy ZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFs dWUgdmFsdWUsIFJlZlB0cjxTdG9yYWdlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IHRvU3Rv cmFnZSh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpj b252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBNZXNzYWdlUG9ydEFy cmF5JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSog ZXhlYywgSlNWYWx1ZSB2YWx1ZSwgTWVzc2FnZVBvcnRBcnJheSYgcmVzdWx0KQogewogICAgIEFy cmF5QnVmZmVyQXJyYXkgYXJyYXlCdWZmZXJzOwogICAgIGZpbGxNZXNzYWdlUG9ydEFycmF5KGV4 ZWMsIHZhbHVlLCByZXN1bHQsIGFycmF5QnVmZmVycyk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAK ICNpZiBFTkFCTEUoVklERU9fVFJBQ0spCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVl KEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQpCiti b29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUs IFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdG9UcmFjayh2YWx1 ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAjZW5kaWYKIAogI2lmIEVOQUJMRShNVVRBVElPTl9P QlNFUlZFUlMpIHx8IEVOQUJMRShXRUJfSU5URU5UUykKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252 ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBIYXNoU2V0PEF0b21pY1N0 cmluZz4mIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRl KiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBIYXNoU2V0PEF0b21pY1N0cmluZz4mIHJlc3VsdCkKIHsK ICAgICByZXN1bHQuY2xlYXIoKTsKIAogICAgIGlmICh2YWx1ZS5pc1VuZGVmaW5lZE9yTnVsbCgp KQotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIHVuc2lnbmVk IGxlbmd0aCA9IDA7CiAgICAgSlNPYmplY3QqIG9iamVjdCA9IHRvSlNTZXF1ZW5jZShleGVjLCB2 YWx1ZSwgbGVuZ3RoKTsKICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCi0gICAgICAgIHJl dHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgZm9yICh1bnNpZ25lZCBpID0gMCA7 IGkgPCBsZW5ndGg7ICsraSkgewogICAgICAgICBKU1ZhbHVlIGl0ZW1WYWx1ZSA9IG9iamVjdC0+ Z2V0KGV4ZWMsIGkpOwogICAgICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCi0gICAgICAg ICAgICByZXR1cm47CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgIHJlc3VsdC5h ZGQoaXRlbVZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSk7CiAgICAgfQorCisgICAg cmV0dXJuIHRydWU7CiB9CiAjZW5kaWYKIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1 ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIEFycmF5VmFsdWUmIHJlc3VsdCkKK2Jv b2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZh bHVlLCBBcnJheVZhbHVlJiByZXN1bHQpCiB7CiAgICAgaWYgKHZhbHVlLmlzVW5kZWZpbmVkT3JO dWxsKCkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgcmVz dWx0ID0gQXJyYXlWYWx1ZShleGVjLCB2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZv aWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFs dWUgdmFsdWUsIFJlZlB0cjxVaW50OEFycmF5PiYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6 OmNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSB2YWx1ZSwgUmVmUHRy PFVpbnQ4QXJyYXk+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdG9VaW50OEFycmF5KHZhbHVl KTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogI2lmIEVOQUJMRShFTkNSWVBURURfTUVESUEpCi12 b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1Zh bHVlIHZhbHVlLCBSZWZQdHI8TWVkaWFLZXlFcnJvcj4mIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9u YXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUgdmFsdWUsIFJl ZlB0cjxNZWRpYUtleUVycm9yPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IHRvTWVkaWFLZXlF cnJvcih2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmggYi9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaAppbmRleCBlMTdmODY4Li5kYzE0MzE4IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaApAQCAtODEsNDAgKzgxLDQx IEBAIHByaXZhdGU6CiAgICAgZW51bSBHZXRQcm9wZXJ0eVJlc3VsdCB7CiAgICAgICAgIEV4Y2Vw dGlvblRocm93biwKICAgICAgICAgTm9Qcm9wZXJ0eUZvdW5kLAotICAgICAgICBQcm9wZXJ0eUZv dW5kCisgICAgICAgIFByb3BlcnR5Rm91bmQsCisgICAgICAgIENvbnZlcnNpb25GYWlsZWQKICAg ICB9OwogICAgIAogICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBULCB0eXBlbmFtZSBSZXN1bHQ+CiAg ICAgR2V0UHJvcGVydHlSZXN1bHQgdHJ5R2V0UHJvcGVydHlBbmRSZXN1bHQoY29uc3QgY2hhciog cHJvcGVydHlOYW1lLCBUKiBjb250ZXh0LCB2b2lkICgqc2V0dGVyKShUKiBjb250ZXh0LCBjb25z dCBSZXN1bHQmKSkgY29uc3Q7CiAgICAgR2V0UHJvcGVydHlSZXN1bHQgdHJ5R2V0UHJvcGVydHko Y29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBKU0M6OkpTVmFsdWUmKSBjb25zdDsKIAotICAgIHN0 YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgYm9v bCYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUq LCBKU0M6OkpTVmFsdWUsIGludCYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFs dWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVuc2lnbmVkJiByZXN1bHQpOwotICAg IHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg dW5zaWduZWQgc2hvcnQmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpT Qzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBsb25nJiByZXN1bHQpOwotICAg IHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg dW5zaWduZWQgbG9uZyBsb25nJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1 ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgZG91YmxlJiByZXN1bHQpOwotICAgIHN0 YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgRGlj dGlvbmFyeSYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVj U3RhdGUqLCBKU0M6OkpTVmFsdWUsIFN0cmluZyYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBj b252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFNjcmlwdFZhbHVlJiBy ZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpT Qzo6SlNWYWx1ZSwgVmVjdG9yPFN0cmluZz4mIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29u dmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8U2VyaWFsaXpl ZFNjcmlwdFZhbHVlPiYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlND OjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxET01XaW5kb3c+JiByZXN1bHQpOwot ICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1 ZSwgUmVmUHRyPEV2ZW50VGFyZ2V0PiYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0 VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxOb2RlPiYgcmVzdWx0 KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpT VmFsdWUsIFJlZlB0cjxTdG9yYWdlPiYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0 VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIE1lc3NhZ2VQb3J0QXJyYXkmIHJl c3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlND OjpKU1ZhbHVlLCBib29sJiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShK U0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgaW50JiByZXN1bHQpOworICAgIHN0YXRpYyBi b29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgdW5zaWduZWQm IHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwg SlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBzaG9ydCYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBj b252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVuc2lnbmVkIGxvbmcm IHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwg SlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBsb25nIGxvbmcmIHJlc3VsdCk7CisgICAgc3RhdGljIGJv b2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBkb3VibGUmIHJl c3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlND OjpKU1ZhbHVlLCBEaWN0aW9uYXJ5JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRW YWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgU3RyaW5nJiByZXN1bHQpOworICAg IHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg U2NyaXB0VmFsdWUmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6 RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBWZWN0b3I8U3RyaW5nPiYgcmVzdWx0KTsKKyAgICBz dGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJl ZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNv bnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPERPTVdpbmRv dz4mIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRl KiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8RXZlbnRUYXJnZXQ+JiByZXN1bHQpOworICAgIHN0YXRp YyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRy PE5vZGU+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNT dGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFN0b3JhZ2U+JiByZXN1bHQpOworICAgIHN0YXRp YyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgTWVzc2Fn ZVBvcnRBcnJheSYgcmVzdWx0KTsKICNpZiBFTkFCTEUoVklERU9fVFJBQ0spCi0gICAgc3RhdGlj IHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8 VHJhY2tCYXNlPiYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpF eGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQpOwogI2Vu ZGlmCiAjaWYgRU5BQkxFKE1VVEFUSU9OX09CU0VSVkVSUykgfHwgRU5BQkxFKFdFQl9JTlRFTlRT KQotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNW YWx1ZSwgSGFzaFNldDxBdG9taWNTdHJpbmc+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNv bnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgSGFzaFNldDxBdG9taWNT dHJpbmc+JiByZXN1bHQpOwogI2VuZGlmCi0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpT Qzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBBcnJheVZhbHVlJiByZXN1bHQpOwotICAgIHN0 YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVm UHRyPFVpbnQ4QXJyYXk+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShK U0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgQXJyYXlWYWx1ZSYgcmVzdWx0KTsKKyAgICBz dGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJl ZlB0cjxVaW50OEFycmF5PiYgcmVzdWx0KTsKICNpZiBFTkFCTEUoRU5DUllQVEVEX01FRElBKQot ICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1 ZSwgUmVmUHRyPE1lZGlhS2V5RXJyb3I+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZl cnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPE1lZGlhS2V5RXJy b3I+JiByZXN1bHQpOwogI2VuZGlmCiAKICAgICBKU0M6OkV4ZWNTdGF0ZSogbV9leGVjOwpAQCAt MTQ5LDE1ICsxNTAsMTkgQEAgSlNEaWN0aW9uYXJ5OjpHZXRQcm9wZXJ0eVJlc3VsdCBKU0RpY3Rp b25hcnk6OnRyeUdldFByb3BlcnR5QW5kUmVzdWx0KGNvbnN0IGNoYXIKICAgICAgICAgcmV0dXJu IGdldFByb3BlcnR5UmVzdWx0OwogICAgIGNhc2UgUHJvcGVydHlGb3VuZDogewogICAgICAgICBS ZXN1bHQgcmVzdWx0OwotICAgICAgICBjb252ZXJ0VmFsdWUobV9leGVjLCB2YWx1ZSwgcmVzdWx0 KTsKKyAgICAgICAgYm9vbCBzdWNjZXNzID0gY29udmVydFZhbHVlKG1fZXhlYywgdmFsdWUsIHJl c3VsdCk7CiAKICAgICAgICAgaWYgKG1fZXhlYy0+aGFkRXhjZXB0aW9uKCkpCiAgICAgICAgICAg ICByZXR1cm4gRXhjZXB0aW9uVGhyb3duOwogCisgICAgICAgIGlmICghc3VjY2VzcykKKyAgICAg ICAgICAgIHJldHVybiBDb252ZXJzaW9uRmFpbGVkOworCiAgICAgICAgIHNldHRlcihjb250ZXh0 LCByZXN1bHQpOwogICAgICAgICBicmVhazsKICAgICB9CiAgICAgY2FzZSBOb1Byb3BlcnR5Rm91 bmQ6CisgICAgY2FzZSBDb252ZXJzaW9uRmFpbGVkOgogICAgICAgICBicmVhazsKICAgICB9CiAK LS0gCjEuNy45LjUKCg== 177906 2012-12-05 18:53:04 -0800 2012-12-05 19:03:29 -0800 Patch jsc-jsdictionary-array.patch text/plain 14115 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCA1IERlYyAy MDEyIDE4OjQ4OjEwIC0wODAwClN1YmplY3Q6IFtKU0NdIENoZWNrIHdoZXRoZXIgcHJvcGVydHkg aXMgYW4gYXJyYXkgYmVmb3JlIGF0dGVtcHRpbmcgY29udmVyc2lvbiB0byBhcnJheSBpbiBKU0Rp Y3Rpb25hcnkKCi0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICB8ICAgMjEgKysrKysrKwogU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5 LmNwcCB8ICAgOTAgKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiBTb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaCAgIHwgICA1NyArKysrKysrKystLS0tLS0tLQogMyBm aWxlcyBjaGFuZ2VkLCAxMTEgaW5zZXJ0aW9ucygrKSwgNTcgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CmluZGV4IDc3Y2JhOGYuLjJiZmI0YmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAx Mi0xMi0wNSAgTWljaGFlbCBQcnVldHQgIDxtaWNoYWVsQDY4ay5vcmc+CisKKyAgICAgICAgW0pT Q10gQ2hlY2sgd2hldGhlciBwcm9wZXJ0eSBpcyBhbiBhcnJheSBiZWZvcmUgYXR0ZW1wdGluZyBj b252ZXJzaW9uIHRvIGFycmF5IGluIEpTRGljdGlvbmFyeQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTY2MTQKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBKU0RpY3Rpb25hcnkgc2hvdWxkIGNoZWNrIHdoZXRo ZXIgdGhlIHByb3BlcnR5IGJlaW5nIGFjY2Vzc2VkIGluIGdldCgpCisgICAgICAgIGlzIGFuIGFy cmF5IGJlZm9yZSBhdHRlbXB0aW5nIHRvIGNvbnZlcnQgdGhlIHZhbHVlIHRvIGFuIGFycmF5Lgor CisgICAgICAgIFByZXZpb3VzbHkgY2FsbGluZyBnZXQoKSB3aXRoIGEgcmVzdWx0IHR5cGUgb2Yg VmVjdG9yPFN0cmluZz4gd2hlbgorICAgICAgICB0aGUgbmFtZWQgcHJvcGVydHkgY291bGQgbm90 IGJlIGNvbnZlcnRlZCB0byBhbiBhcnJheSB3b3VsZCBnZW5lcmF0ZQorICAgICAgICBhbiBleGNl cHRpb24uCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhlZGRiLyoKKworICAgICAgICAq IGJpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpKU0RpY3Rp b25hcnk6OmNvbnZlcnRWYWx1ZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5 Lmg6CisgICAgICAgIChXZWJDb3JlOjpKU0RpY3Rpb25hcnk6OnRyeUdldFByb3BlcnR5QW5kUmVz dWx0KToKKwogMjAxMi0xMi0wNSAgUm9iZXJ0IEhvZ2FuICA8cm9iZXJ0QHdlYmtpdC5vcmc+CiAK ICAgICAgICAgUkVHUkVTU0lPTihyMTI2NjgzKTogVGFibGUgY2VsbCBhcmUgZ2V0dGluZyBib3Jk ZXJzIHdoZW4gdGhlIHN0eWxlIGRvZXNuJ3QgbWVudGlvbiBhbnkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCmluZGV4IDRlMmRkNGMuLmQ5MzliMDIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcApAQCAtNjgsMTUyICs2 OCwxODIgQEAgSlNEaWN0aW9uYXJ5OjpHZXRQcm9wZXJ0eVJlc3VsdCBKU0RpY3Rpb25hcnk6OnRy eUdldFByb3BlcnR5KGNvbnN0IGNoYXIqIHByb3BlcnQKICAgICByZXR1cm4gUHJvcGVydHlGb3Vu ZDsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMs IEpTVmFsdWUgdmFsdWUsIGJvb2wmIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0 VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBib29sJiByZXN1bHQpCiB7CiAg ICAgcmVzdWx0ID0gdmFsdWUudG9Cb29sZWFuKGV4ZWMpOworICAgIHJldHVybiB0cnVlOwogfQog Ci12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1 ZSB2YWx1ZSwgaW50JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4 ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgaW50JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0 ID0gdmFsdWUudG9JbnQzMihleGVjKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0Rp Y3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVu c2lnbmVkJiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0 ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQmIHJlc3VsdCkKIHsKICAgICByZXN1bHQg PSB2YWx1ZS50b1VJbnQzMihleGVjKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0Rp Y3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVu c2lnbmVkIHNob3J0JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4 ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQgc2hvcnQmIHJlc3VsdCkKIHsK ICAgICByZXN1bHQgPSBzdGF0aWNfY2FzdDx1bnNpZ25lZCBzaG9ydD4odmFsdWUudG9VSW50MzIo ZXhlYykpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVy dFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQgbG9uZyYgcmVz dWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpT VmFsdWUgdmFsdWUsIHVuc2lnbmVkIGxvbmcmIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSBzdGF0 aWNfY2FzdDx1bnNpZ25lZCBsb25nPih2YWx1ZS50b1VJbnQzMihleGVjKSk7CisgICAgcmV0dXJu IHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBl eGVjLCBKU1ZhbHVlIHZhbHVlLCB1bnNpZ25lZCBsb25nIGxvbmcmIHJlc3VsdCkKK2Jvb2wgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCB1 bnNpZ25lZCBsb25nIGxvbmcmIHJlc3VsdCkKIHsKICAgICBkb3VibGUgZCA9IHZhbHVlLnRvTnVt YmVyKGV4ZWMpOwogICAgIGRvdWJsZVRvSW50ZWdlcihkLCByZXN1bHQpOworICAgIHJldHVybiB0 cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhl YywgSlNWYWx1ZSB2YWx1ZSwgZG91YmxlJiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29u dmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgZG91YmxlJiByZXN1bHQp CiB7CiAgICAgcmVzdWx0ID0gdmFsdWUudG9OdW1iZXIoZXhlYyk7CisgICAgcmV0dXJuIHRydWU7 CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqIGV4 ZWMsIEpTQzo6SlNWYWx1ZSB2YWx1ZSwgRGljdGlvbmFyeSYgcmVzdWx0KQorYm9vbCBKU0RpY3Rp b25hcnk6OmNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSogZXhlYywgSlNDOjpKU1ZhbHVlIHZh bHVlLCBEaWN0aW9uYXJ5JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gRGljdGlvbmFyeShleGVj LCB2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252 ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBTdHJpbmcmIHJlc3VsdCkK K2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVl IHZhbHVlLCBTdHJpbmcmIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB2YWx1ZS50b1N0cmluZyhl eGVjKS0+dmFsdWUoZXhlYyk7CisgICAgcmV0dXJuICFleGVjLT5oYWRFeGNlcHRpb24oKTsKIH0K IAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFs dWUgdmFsdWUsIFZlY3RvcjxTdHJpbmc+JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29u dmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgVmVjdG9yPFN0cmluZz4m IHJlc3VsdCkKIHsKICAgICBpZiAodmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSkKLSAgICAgICAg cmV0dXJuOworICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAoIXZhbHVlLmlzT2JqZWN0 KCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBKU09iamVjdCogb2JqZWN0ID0gYXNPYmpl Y3QodmFsdWUpOworICAgIGlmICghaXNKU0FycmF5KG9iamVjdCkgJiYgIW9iamVjdC0+aW5oZXJp dHMoJkpTQXJyYXk6OnNfaW5mbykpCisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIHVuc2ln bmVkIGxlbmd0aCA9IDA7Ci0gICAgSlNPYmplY3QqIG9iamVjdCA9IHRvSlNTZXF1ZW5jZShleGVj LCB2YWx1ZSwgbGVuZ3RoKTsKKyAgICBvYmplY3QgPSB0b0pTU2VxdWVuY2UoZXhlYywgdmFsdWUs IGxlbmd0aCk7CiAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQotICAgICAgICByZXR1cm47 CisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIGZvciAodW5zaWduZWQgaSA9IDAgOyBpIDwg bGVuZ3RoOyArK2kpIHsKICAgICAgICAgSlNWYWx1ZSBpdGVtVmFsdWUgPSBvYmplY3QtPmdldChl eGVjLCBpKTsKICAgICAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQotICAgICAgICAgICAg cmV0dXJuOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICByZXN1bHQuYXBwZW5k KGl0ZW1WYWx1ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhlYykpOwogICAgIH0KKworICAgIHJl dHVybiAhZXhlYy0+aGFkRXhjZXB0aW9uKCk7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252 ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBTY3JpcHRWYWx1ZSYgcmVz dWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpT VmFsdWUgdmFsdWUsIFNjcmlwdFZhbHVlJiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gU2NyaXB0 VmFsdWUoZXhlYy0+Z2xvYmFsRGF0YSgpLCB2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAK LXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVl IHZhbHVlLCBSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiYgcmVzdWx0KQorYm9vbCBKU0Rp Y3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIFJl ZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gU2Vy aWFsaXplZFNjcmlwdFZhbHVlOjpjcmVhdGUoZXhlYywgdmFsdWUsIDAsIDApOworICAgIHJldHVy biAhZXhlYy0+aGFkRXhjZXB0aW9uKCk7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0 VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPERPTVdpbmRvdz4mIHJlc3Vs dCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2 YWx1ZSwgUmVmUHRyPERPTVdpbmRvdz4mIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB0b0RPTVdp bmRvdyh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpj b252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPEV2ZW50VGFyZ2V0 PiYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqLCBK U1ZhbHVlIHZhbHVlLCBSZWZQdHI8RXZlbnRUYXJnZXQ+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0 ID0gdG9FdmVudFRhcmdldCh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRy PE5vZGU+JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0 ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxOb2RlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9 IHRvTm9kZSh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5 Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwgSlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPFN0b3JhZ2U+ JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpT VmFsdWUgdmFsdWUsIFJlZlB0cjxTdG9yYWdlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IHRv U3RvcmFnZSh2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5 Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBNZXNzYWdlUG9y dEFycmF5JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0 ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgTWVzc2FnZVBvcnRBcnJheSYgcmVzdWx0KQogewogICAg IEFycmF5QnVmZmVyQXJyYXkgYXJyYXlCdWZmZXJzOwogICAgIGZpbGxNZXNzYWdlUG9ydEFycmF5 KGV4ZWMsIHZhbHVlLCByZXN1bHQsIGFycmF5QnVmZmVycyk7CisgICAgcmV0dXJuIHRydWU7CiB9 CiAKICNpZiBFTkFCTEUoVklERU9fVFJBQ0spCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZh bHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQp Citib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFs dWUsIFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdG9UcmFjayh2 YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAjZW5kaWYKIAogI2lmIEVOQUJMRShNVVRBVElP Tl9PQlNFUlZFUlMpIHx8IEVOQUJMRShXRUJfSU5URU5UUykKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpj b252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBIYXNoU2V0PEF0b21p Y1N0cmluZz4mIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0 YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBIYXNoU2V0PEF0b21pY1N0cmluZz4mIHJlc3VsdCkK IHsKICAgICByZXN1bHQuY2xlYXIoKTsKIAogICAgIGlmICh2YWx1ZS5pc1VuZGVmaW5lZE9yTnVs bCgpKQotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIHVuc2ln bmVkIGxlbmd0aCA9IDA7CiAgICAgSlNPYmplY3QqIG9iamVjdCA9IHRvSlNTZXF1ZW5jZShleGVj LCB2YWx1ZSwgbGVuZ3RoKTsKICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCi0gICAgICAg IHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgZm9yICh1bnNpZ25lZCBpID0g MCA7IGkgPCBsZW5ndGg7ICsraSkgewogICAgICAgICBKU1ZhbHVlIGl0ZW1WYWx1ZSA9IG9iamVj dC0+Z2V0KGV4ZWMsIGkpOwogICAgICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCi0gICAg ICAgICAgICByZXR1cm47CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgIHJlc3Vs dC5hZGQoaXRlbVZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKSk7CiAgICAgfQorCisg ICAgcmV0dXJuICFleGVjLT5oYWRFeGNlcHRpb24oKTsKIH0KICNlbmRpZgogCi12b2lkIEpTRGlj dGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgQXJy YXlWYWx1ZSYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3Rh dGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIEFycmF5VmFsdWUmIHJlc3VsdCkKIHsKICAgICBpZiAo dmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1 cm4gZmFsc2U7CiAKICAgICByZXN1bHQgPSBBcnJheVZhbHVlKGV4ZWMsIHZhbHVlKTsKKyAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShKU0M6OkV4 ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPFVpbnQ4QXJyYXk+JiByZXN1bHQp Citib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpK U1ZhbHVlIHZhbHVlLCBSZWZQdHI8VWludDhBcnJheT4mIHJlc3VsdCkKIHsKICAgICByZXN1bHQg PSB0b1VpbnQ4QXJyYXkodmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCiAjaWYgRU5BQkxF KEVOQ1JZUFRFRF9NRURJQSkKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpF eGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUgdmFsdWUsIFJlZlB0cjxNZWRpYUtleUVycm9yPiYgcmVz dWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpT Qzo6SlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPE1lZGlhS2V5RXJyb3I+JiByZXN1bHQpCiB7CiAgICAg cmVzdWx0ID0gdG9NZWRpYUtleUVycm9yKHZhbHVlKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KICNl bmRpZgogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25h cnkuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oCmluZGV4IGUx N2Y4NjguLjU5Y2U2NTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pT RGljdGlvbmFyeS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFy eS5oCkBAIC04MSw0MCArODEsNDEgQEAgcHJpdmF0ZToKICAgICBlbnVtIEdldFByb3BlcnR5UmVz dWx0IHsKICAgICAgICAgRXhjZXB0aW9uVGhyb3duLAogICAgICAgICBOb1Byb3BlcnR5Rm91bmQs Ci0gICAgICAgIFByb3BlcnR5Rm91bmQKKyAgICAgICAgUHJvcGVydHlGb3VuZCwKKyAgICAgICAg Q29udmVyc2lvbkZhaWxlZAogICAgIH07CiAgICAgCiAgICAgdGVtcGxhdGUgPHR5cGVuYW1lIFQs IHR5cGVuYW1lIFJlc3VsdD4KICAgICBHZXRQcm9wZXJ0eVJlc3VsdCB0cnlHZXRQcm9wZXJ0eUFu ZFJlc3VsdChjb25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIFQqIGNvbnRleHQsIHZvaWQgKCpzZXR0 ZXIpKFQqIGNvbnRleHQsIGNvbnN0IFJlc3VsdCYpKSBjb25zdDsKICAgICBHZXRQcm9wZXJ0eVJl c3VsdCB0cnlHZXRQcm9wZXJ0eShjb25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIEpTQzo6SlNWYWx1 ZSYpIGNvbnN0OwogCi0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRl KiwgSlNDOjpKU1ZhbHVlLCBib29sJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRW YWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgaW50JiByZXN1bHQpOwotICAgIHN0 YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgdW5z aWduZWQmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0 YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBzaG9ydCYgcmVzdWx0KTsKLSAgICBzdGF0aWMg dm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVuc2lnbmVk IGxvbmcmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0 YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBsb25nIGxvbmcmIHJlc3VsdCk7Ci0gICAgc3Rh dGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBkb3Vi bGUmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRl KiwgSlNDOjpKU1ZhbHVlLCBEaWN0aW9uYXJ5JiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNv bnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgU3RyaW5nJiByZXN1bHQp OwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNW YWx1ZSwgU2NyaXB0VmFsdWUmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVl KEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBWZWN0b3I8U3RyaW5nPiYgcmVzdWx0KTsK LSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFs dWUsIFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+JiByZXN1bHQpOwotICAgIHN0YXRpYyB2 b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPERP TVdpbmRvdz4mIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhl Y1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8RXZlbnRUYXJnZXQ+JiByZXN1bHQpOwotICAg IHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg UmVmUHRyPE5vZGU+JiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6 OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFN0b3JhZ2U+JiByZXN1bHQpOwotICAg IHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg TWVzc2FnZVBvcnRBcnJheSYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUo SlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIGJvb2wmIHJlc3VsdCk7CisgICAgc3RhdGlj IGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBpbnQmIHJl c3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlND OjpKU1ZhbHVlLCB1bnNpZ25lZCYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFs dWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVuc2lnbmVkIHNob3J0JiByZXN1bHQp OworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNW YWx1ZSwgdW5zaWduZWQgbG9uZyYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFs dWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVuc2lnbmVkIGxvbmcgbG9uZyYgcmVz dWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6 OkpTVmFsdWUsIGRvdWJsZSYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUo SlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIERpY3Rpb25hcnkmIHJlc3VsdCk7CisgICAg c3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBT dHJpbmcmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0 YXRlKiwgSlNDOjpKU1ZhbHVlLCBTY3JpcHRWYWx1ZSYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9v bCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFZlY3RvcjxTdHJp bmc+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0 ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4mIHJlc3VsdCk7 CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1Zh bHVlLCBSZWZQdHI8RE9NV2luZG93PiYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0 VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxFdmVudFRhcmdldD4m IHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwg SlNDOjpKU1ZhbHVlLCBSZWZQdHI8Tm9kZT4mIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29u dmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8U3RvcmFnZT4m IHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwg SlNDOjpKU1ZhbHVlLCBNZXNzYWdlUG9ydEFycmF5JiByZXN1bHQpOwogI2lmIEVOQUJMRShWSURF T19UUkFDSykKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBK U0M6OkpTVmFsdWUsIFJlZlB0cjxUcmFja0Jhc2U+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29s IGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFRyYWNr QmFzZT4mIHJlc3VsdCk7CiAjZW5kaWYKICNpZiBFTkFCTEUoTVVUQVRJT05fT0JTRVJWRVJTKSB8 fCBFTkFCTEUoV0VCX0lOVEVOVFMpCi0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6 RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBIYXNoU2V0PEF0b21pY1N0cmluZz4mIHJlc3VsdCk7 CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1Zh bHVlLCBIYXNoU2V0PEF0b21pY1N0cmluZz4mIHJlc3VsdCk7CiAjZW5kaWYKLSAgICBzdGF0aWMg dm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIEFycmF5VmFs dWUmIHJlc3VsdCk7Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRl KiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8VWludDhBcnJheT4mIHJlc3VsdCk7CisgICAgc3RhdGlj IGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBBcnJheVZh bHVlJiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0 ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFVpbnQ4QXJyYXk+JiByZXN1bHQpOwogI2lmIEVOQUJM RShFTkNSWVBURURfTUVESUEpCi0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhl Y1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8TWVkaWFLZXlFcnJvcj4mIHJlc3VsdCk7Cisg ICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVl LCBSZWZQdHI8TWVkaWFLZXlFcnJvcj4mIHJlc3VsdCk7CiAjZW5kaWYKIAogICAgIEpTQzo6RXhl Y1N0YXRlKiBtX2V4ZWM7CkBAIC0xNDksMTUgKzE1MCwxNyBAQCBKU0RpY3Rpb25hcnk6OkdldFBy b3BlcnR5UmVzdWx0IEpTRGljdGlvbmFyeTo6dHJ5R2V0UHJvcGVydHlBbmRSZXN1bHQoY29uc3Qg Y2hhcgogICAgICAgICByZXR1cm4gZ2V0UHJvcGVydHlSZXN1bHQ7CiAgICAgY2FzZSBQcm9wZXJ0 eUZvdW5kOiB7CiAgICAgICAgIFJlc3VsdCByZXN1bHQ7Ci0gICAgICAgIGNvbnZlcnRWYWx1ZSht X2V4ZWMsIHZhbHVlLCByZXN1bHQpOwotCi0gICAgICAgIGlmIChtX2V4ZWMtPmhhZEV4Y2VwdGlv bigpKQotICAgICAgICAgICAgcmV0dXJuIEV4Y2VwdGlvblRocm93bjsKKyAgICAgICAgaWYgKCFj b252ZXJ0VmFsdWUobV9leGVjLCB2YWx1ZSwgcmVzdWx0KSkgeworICAgICAgICAgICAgaWYgKG1f ZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgICAgICAgICAgcmV0dXJuIEV4Y2VwdGlvblRo cm93bjsKKyAgICAgICAgICAgIHJldHVybiBDb252ZXJzaW9uRmFpbGVkOworICAgICAgICB9CiAK ICAgICAgICAgc2V0dGVyKGNvbnRleHQsIHJlc3VsdCk7CiAgICAgICAgIGJyZWFrOwogICAgIH0K ICAgICBjYXNlIE5vUHJvcGVydHlGb3VuZDoKKyAgICBjYXNlIENvbnZlcnNpb25GYWlsZWQ6CiAg ICAgICAgIGJyZWFrOwogICAgIH0KIAotLSAKMS43LjkuNQoK 177907 2012-12-05 19:03:29 -0800 2012-12-10 23:25:50 -0800 Patch jsc-jsdictionary-array.patch text/plain 14194 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCA1IERlYyAy MDEyIDE4OjU2OjM5IC0wODAwClN1YmplY3Q6IFtKU0NdIENoZWNrIHdoZXRoZXIgcHJvcGVydHkg aXMgYW4gYXJyYXkgYmVmb3JlIGF0dGVtcHRpbmcgY29udmVyc2lvbiB0byBhcnJheSBpbiBKU0Rp Y3Rpb25hcnkKCi0tLQogU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAg ICB8ICAgMjEgKysrKysrKwogU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5 LmNwcCB8ICAgOTAgKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiBTb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaCAgIHwgICA1OSArKysrKysrKysrLS0tLS0tLS0KIDMg ZmlsZXMgY2hhbmdlZCwgMTEzIGluc2VydGlvbnMoKyksIDU3IGRlbGV0aW9ucygtKQoKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCA3N2NiYThmLi4yYmZiNGJhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIw MTItMTItMDUgIE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgorCisgICAgICAgIFtK U0NdIENoZWNrIHdoZXRoZXIgcHJvcGVydHkgaXMgYW4gYXJyYXkgYmVmb3JlIGF0dGVtcHRpbmcg Y29udmVyc2lvbiB0byBhcnJheSBpbiBKU0RpY3Rpb25hcnkKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTk2NjE0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSlNEaWN0aW9uYXJ5IHNob3VsZCBjaGVjayB3aGV0 aGVyIHRoZSBwcm9wZXJ0eSBiZWluZyBhY2Nlc3NlZCBpbiBnZXQoKQorICAgICAgICBpcyBhbiBh cnJheSBiZWZvcmUgYXR0ZW1wdGluZyB0byBjb252ZXJ0IHRoZSB2YWx1ZSB0byBhbiBhcnJheS4K KworICAgICAgICBQcmV2aW91c2x5IGNhbGxpbmcgZ2V0KCkgd2l0aCBhIHJlc3VsdCB0eXBlIG9m IFZlY3RvcjxTdHJpbmc+IHdoZW4KKyAgICAgICAgdGhlIG5hbWVkIHByb3BlcnR5IGNvdWxkIG5v dCBiZSBjb252ZXJ0ZWQgdG8gYW4gYXJyYXkgd291bGQgZ2VuZXJhdGUKKyAgICAgICAgYW4gZXhj ZXB0aW9uLgorCisgICAgICAgIFRlc3RzOiBzdG9yYWdlL2luZGV4ZWRkYi8qCisKKyAgICAgICAg KiBiaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SlNEaWN0 aW9uYXJ5Ojpjb252ZXJ0VmFsdWUpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRGljdGlvbmFy eS5oOgorICAgICAgICAoV2ViQ29yZTo6SlNEaWN0aW9uYXJ5Ojp0cnlHZXRQcm9wZXJ0eUFuZFJl c3VsdCk6CisKIDIwMTItMTItMDUgIFJvYmVydCBIb2dhbiAgPHJvYmVydEB3ZWJraXQub3JnPgog CiAgICAgICAgIFJFR1JFU1NJT04ocjEyNjY4Myk6IFRhYmxlIGNlbGwgYXJlIGdldHRpbmcgYm9y ZGVycyB3aGVuIHRoZSBzdHlsZSBkb2Vzbid0IG1lbnRpb24gYW55CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwIGIvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAppbmRleCA0ZTJkZDRjLi5kOTM5YjAyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAKQEAgLTY4LDE1MiAr NjgsMTgyIEBAIEpTRGljdGlvbmFyeTo6R2V0UHJvcGVydHlSZXN1bHQgSlNEaWN0aW9uYXJ5Ojp0 cnlHZXRQcm9wZXJ0eShjb25zdCBjaGFyKiBwcm9wZXJ0CiAgICAgcmV0dXJuIFByb3BlcnR5Rm91 bmQ7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVj LCBKU1ZhbHVlIHZhbHVlLCBib29sJiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVy dFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgYm9vbCYgcmVzdWx0KQogewog ICAgIHJlc3VsdCA9IHZhbHVlLnRvQm9vbGVhbihleGVjKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0K IAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFs dWUgdmFsdWUsIGludCYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShF eGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIGludCYgcmVzdWx0KQogewogICAgIHJlc3Vs dCA9IHZhbHVlLnRvSW50MzIoZXhlYyk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCB1 bnNpZ25lZCYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3Rh dGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVuc2lnbmVkJiByZXN1bHQpCiB7CiAgICAgcmVzdWx0 ID0gdmFsdWUudG9VSW50MzIoZXhlYyk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCB1 bnNpZ25lZCBzaG9ydCYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShF eGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVuc2lnbmVkIHNob3J0JiByZXN1bHQpCiB7 CiAgICAgcmVzdWx0ID0gc3RhdGljX2Nhc3Q8dW5zaWduZWQgc2hvcnQ+KHZhbHVlLnRvVUludDMy KGV4ZWMpKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZl cnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIHVuc2lnbmVkIGxvbmcmIHJl c3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBK U1ZhbHVlIHZhbHVlLCB1bnNpZ25lZCBsb25nJiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gc3Rh dGljX2Nhc3Q8dW5zaWduZWQgbG9uZz4odmFsdWUudG9VSW50MzIoZXhlYykpOworICAgIHJldHVy biB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSog ZXhlYywgSlNWYWx1ZSB2YWx1ZSwgdW5zaWduZWQgbG9uZyBsb25nJiByZXN1bHQpCitib29sIEpT RGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwg dW5zaWduZWQgbG9uZyBsb25nJiByZXN1bHQpCiB7CiAgICAgZG91YmxlIGQgPSB2YWx1ZS50b051 bWJlcihleGVjKTsKICAgICBkb3VibGVUb0ludGVnZXIoZCwgcmVzdWx0KTsKKyAgICByZXR1cm4g dHJ1ZTsKIH0KIAotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4 ZWMsIEpTVmFsdWUgdmFsdWUsIGRvdWJsZSYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNv bnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIGRvdWJsZSYgcmVzdWx0 KQogewogICAgIHJlc3VsdCA9IHZhbHVlLnRvTnVtYmVyKGV4ZWMpOworICAgIHJldHVybiB0cnVl OwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiBl eGVjLCBKU0M6OkpTVmFsdWUgdmFsdWUsIERpY3Rpb25hcnkmIHJlc3VsdCkKK2Jvb2wgSlNEaWN0 aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqIGV4ZWMsIEpTQzo6SlNWYWx1ZSB2 YWx1ZSwgRGljdGlvbmFyeSYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IERpY3Rpb25hcnkoZXhl YywgdmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29u dmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgU3RyaW5nJiByZXN1bHQp Citib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1 ZSB2YWx1ZSwgU3RyaW5nJiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdmFsdWUudG9TdHJpbmco ZXhlYyktPnZhbHVlKGV4ZWMpOworICAgIHJldHVybiAhZXhlYy0+aGFkRXhjZXB0aW9uKCk7CiB9 CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1Zh bHVlIHZhbHVlLCBWZWN0b3I8U3RyaW5nPiYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNv bnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIFZlY3RvcjxTdHJpbmc+ JiByZXN1bHQpCiB7CiAgICAgaWYgKHZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkpCi0gICAgICAg IHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCF2YWx1ZS5pc09iamVj dCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgSlNPYmplY3QqIG9iamVjdCA9IGFzT2Jq ZWN0KHZhbHVlKTsKKyAgICBpZiAoIWlzSlNBcnJheShvYmplY3QpICYmICFvYmplY3QtPmluaGVy aXRzKCZKU0FycmF5OjpzX2luZm8pKQorICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICB1bnNp Z25lZCBsZW5ndGggPSAwOwotICAgIEpTT2JqZWN0KiBvYmplY3QgPSB0b0pTU2VxdWVuY2UoZXhl YywgdmFsdWUsIGxlbmd0aCk7CisgICAgb2JqZWN0ID0gdG9KU1NlcXVlbmNlKGV4ZWMsIHZhbHVl LCBsZW5ndGgpOwogICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKLSAgICAgICAgcmV0dXJu OworICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwIDsgaSA8 IGxlbmd0aDsgKytpKSB7CiAgICAgICAgIEpTVmFsdWUgaXRlbVZhbHVlID0gb2JqZWN0LT5nZXQo ZXhlYywgaSk7CiAgICAgICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKLSAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICAgICAgcmVzdWx0LmFwcGVu ZChpdGVtVmFsdWUudG9TdHJpbmcoZXhlYyktPnZhbHVlKGV4ZWMpKTsKICAgICB9CisKKyAgICBy ZXR1cm4gIWV4ZWMtPmhhZEV4Y2VwdGlvbigpOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29u dmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgU2NyaXB0VmFsdWUmIHJl c3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBK U1ZhbHVlIHZhbHVlLCBTY3JpcHRWYWx1ZSYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IFNjcmlw dFZhbHVlKGV4ZWMtPmdsb2JhbERhdGEoKSwgdmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQog Ci12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1 ZSB2YWx1ZSwgUmVmUHRyPFNlcmlhbGl6ZWRTY3JpcHRWYWx1ZT4mIHJlc3VsdCkKK2Jvb2wgSlNE aWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBS ZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IFNl cmlhbGl6ZWRTY3JpcHRWYWx1ZTo6Y3JlYXRlKGV4ZWMsIHZhbHVlLCAwLCAwKTsKKyAgICByZXR1 cm4gIWV4ZWMtPmhhZEV4Y2VwdGlvbigpOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVy dFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxET01XaW5kb3c+JiByZXN1 bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUg dmFsdWUsIFJlZlB0cjxET01XaW5kb3c+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0ID0gdG9ET01X aW5kb3codmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFyeTo6 Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxFdmVudFRhcmdl dD4mIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0YXRlKiwg SlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPEV2ZW50VGFyZ2V0PiYgcmVzdWx0KQogewogICAgIHJlc3Vs dCA9IHRvRXZlbnRUYXJnZXQodmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpT RGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0 cjxOb2RlPiYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3Rh dGUqLCBKU1ZhbHVlIHZhbHVlLCBSZWZQdHI8Tm9kZT4mIHJlc3VsdCkKIHsKICAgICByZXN1bHQg PSB0b05vZGUodmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFy eTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSosIEpTVmFsdWUgdmFsdWUsIFJlZlB0cjxTdG9yYWdl PiYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqLCBK U1ZhbHVlIHZhbHVlLCBSZWZQdHI8U3RvcmFnZT4mIHJlc3VsdCkKIHsKICAgICByZXN1bHQgPSB0 b1N0b3JhZ2UodmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogCi12b2lkIEpTRGljdGlvbmFy eTo6Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgTWVzc2FnZVBv cnRBcnJheSYgcmVzdWx0KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3Rh dGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIE1lc3NhZ2VQb3J0QXJyYXkmIHJlc3VsdCkKIHsKICAg ICBBcnJheUJ1ZmZlckFycmF5IGFycmF5QnVmZmVyczsKICAgICBmaWxsTWVzc2FnZVBvcnRBcnJh eShleGVjLCB2YWx1ZSwgcmVzdWx0LCBhcnJheUJ1ZmZlcnMpOworICAgIHJldHVybiB0cnVlOwog fQogCiAjaWYgRU5BQkxFKFZJREVPX1RSQUNLKQotdm9pZCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRW YWx1ZShFeGVjU3RhdGUqLCBKU1ZhbHVlIHZhbHVlLCBSZWZQdHI8VHJhY2tCYXNlPiYgcmVzdWx0 KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqLCBKU1ZhbHVlIHZh bHVlLCBSZWZQdHI8VHJhY2tCYXNlPiYgcmVzdWx0KQogewogICAgIHJlc3VsdCA9IHRvVHJhY2so dmFsdWUpOworICAgIHJldHVybiB0cnVlOwogfQogI2VuZGlmCiAKICNpZiBFTkFCTEUoTVVUQVRJ T05fT0JTRVJWRVJTKSB8fCBFTkFCTEUoV0VCX0lOVEVOVFMpCi12b2lkIEpTRGljdGlvbmFyeTo6 Y29udmVydFZhbHVlKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgSGFzaFNldDxBdG9t aWNTdHJpbmc+JiByZXN1bHQpCitib29sIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEV4ZWNT dGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSwgSGFzaFNldDxBdG9taWNTdHJpbmc+JiByZXN1bHQp CiB7CiAgICAgcmVzdWx0LmNsZWFyKCk7CiAKICAgICBpZiAodmFsdWUuaXNVbmRlZmluZWRPck51 bGwoKSkKLSAgICAgICAgcmV0dXJuOworICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICB1bnNp Z25lZCBsZW5ndGggPSAwOwogICAgIEpTT2JqZWN0KiBvYmplY3QgPSB0b0pTU2VxdWVuY2UoZXhl YywgdmFsdWUsIGxlbmd0aCk7CiAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQotICAgICAg ICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKIAogICAgIGZvciAodW5zaWduZWQgaSA9 IDAgOyBpIDwgbGVuZ3RoOyArK2kpIHsKICAgICAgICAgSlNWYWx1ZSBpdGVtVmFsdWUgPSBvYmpl Y3QtPmdldChleGVjLCBpKTsKICAgICAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQotICAg ICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgICAgICByZXN1 bHQuYWRkKGl0ZW1WYWx1ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhlYykpOwogICAgIH0KKwor ICAgIHJldHVybiAhZXhlYy0+aGFkRXhjZXB0aW9uKCk7CiB9CiAjZW5kaWYKIAotdm9pZCBKU0Rp Y3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShFeGVjU3RhdGUqIGV4ZWMsIEpTVmFsdWUgdmFsdWUsIEFy cmF5VmFsdWUmIHJlc3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoRXhlY1N0 YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlLCBBcnJheVZhbHVlJiByZXN1bHQpCiB7CiAgICAgaWYg KHZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkpCi0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0 dXJuIGZhbHNlOwogCiAgICAgcmVzdWx0ID0gQXJyYXlWYWx1ZShleGVjLCB2YWx1ZSk7CisgICAg cmV0dXJuIHRydWU7CiB9CiAKLXZvaWQgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpF eGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUgdmFsdWUsIFJlZlB0cjxVaW50OEFycmF5PiYgcmVzdWx0 KQorYm9vbCBKU0RpY3Rpb25hcnk6OmNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6 SlNWYWx1ZSB2YWx1ZSwgUmVmUHRyPFVpbnQ4QXJyYXk+JiByZXN1bHQpCiB7CiAgICAgcmVzdWx0 ID0gdG9VaW50OEFycmF5KHZhbHVlKTsKKyAgICByZXR1cm4gdHJ1ZTsKIH0KIAogI2lmIEVOQUJM RShFTkNSWVBURURfTUVESUEpCi12b2lkIEpTRGljdGlvbmFyeTo6Y29udmVydFZhbHVlKEpTQzo6 RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlIHZhbHVlLCBSZWZQdHI8TWVkaWFLZXlFcnJvcj4mIHJl c3VsdCkKK2Jvb2wgSlNEaWN0aW9uYXJ5Ojpjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBK U0M6OkpTVmFsdWUgdmFsdWUsIFJlZlB0cjxNZWRpYUtleUVycm9yPiYgcmVzdWx0KQogewogICAg IHJlc3VsdCA9IHRvTWVkaWFLZXlFcnJvcih2YWx1ZSk7CisgICAgcmV0dXJuIHRydWU7CiB9CiAj ZW5kaWYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9u YXJ5LmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaAppbmRleCBl MTdmODY4Li5lOTZiYThjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9K U0RpY3Rpb25hcnkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25h cnkuaApAQCAtODEsNDAgKzgxLDQxIEBAIHByaXZhdGU6CiAgICAgZW51bSBHZXRQcm9wZXJ0eVJl c3VsdCB7CiAgICAgICAgIEV4Y2VwdGlvblRocm93biwKICAgICAgICAgTm9Qcm9wZXJ0eUZvdW5k LAotICAgICAgICBQcm9wZXJ0eUZvdW5kCisgICAgICAgIFByb3BlcnR5Rm91bmQsCisgICAgICAg IENvbnZlcnNpb25GYWlsZWQKICAgICB9OwogICAgIAogICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBU LCB0eXBlbmFtZSBSZXN1bHQ+CiAgICAgR2V0UHJvcGVydHlSZXN1bHQgdHJ5R2V0UHJvcGVydHlB bmRSZXN1bHQoY29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBUKiBjb250ZXh0LCB2b2lkICgqc2V0 dGVyKShUKiBjb250ZXh0LCBjb25zdCBSZXN1bHQmKSkgY29uc3Q7CiAgICAgR2V0UHJvcGVydHlS ZXN1bHQgdHJ5R2V0UHJvcGVydHkoY29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBKU0M6OkpTVmFs dWUmKSBjb25zdDsKIAotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0 ZSosIEpTQzo6SlNWYWx1ZSwgYm9vbCYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0 VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIGludCYgcmVzdWx0KTsKLSAgICBz dGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIHVu c2lnbmVkJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNT dGF0ZSosIEpTQzo6SlNWYWx1ZSwgdW5zaWduZWQgc2hvcnQmIHJlc3VsdCk7Ci0gICAgc3RhdGlj IHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25l ZCBsb25nJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNT dGF0ZSosIEpTQzo6SlNWYWx1ZSwgdW5zaWduZWQgbG9uZyBsb25nJiByZXN1bHQpOwotICAgIHN0 YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgZG91 YmxlJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0 ZSosIEpTQzo6SlNWYWx1ZSwgRGljdGlvbmFyeSYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBj b252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFN0cmluZyYgcmVzdWx0 KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpT VmFsdWUsIFNjcmlwdFZhbHVlJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1 ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgVmVjdG9yPFN0cmluZz4mIHJlc3VsdCk7 Ci0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1Zh bHVlLCBSZWZQdHI8U2VyaWFsaXplZFNjcmlwdFZhbHVlPiYgcmVzdWx0KTsKLSAgICBzdGF0aWMg dm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxE T01XaW5kb3c+JiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4 ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPEV2ZW50VGFyZ2V0PiYgcmVzdWx0KTsKLSAg ICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUs IFJlZlB0cjxOb2RlPiYgcmVzdWx0KTsKLSAgICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlND OjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxTdG9yYWdlPiYgcmVzdWx0KTsKLSAg ICBzdGF0aWMgdm9pZCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUs IE1lc3NhZ2VQb3J0QXJyYXkmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVl KEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBib29sJiByZXN1bHQpOworICAgIHN0YXRp YyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgaW50JiBy ZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpT Qzo6SlNWYWx1ZSwgdW5zaWduZWQmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZh bHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBzaG9ydCYgcmVzdWx0 KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpT VmFsdWUsIHVuc2lnbmVkIGxvbmcmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZh bHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCB1bnNpZ25lZCBsb25nIGxvbmcmIHJl c3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlND OjpKU1ZhbHVlLCBkb3VibGUmIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVydFZhbHVl KEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBEaWN0aW9uYXJ5JiByZXN1bHQpOworICAg IHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwg U3RyaW5nJiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNT dGF0ZSosIEpTQzo6SlNWYWx1ZSwgU2NyaXB0VmFsdWUmIHJlc3VsdCk7CisgICAgc3RhdGljIGJv b2wgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBWZWN0b3I8U3Ry aW5nPiYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3Rh dGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxTZXJpYWxpemVkU2NyaXB0VmFsdWU+JiByZXN1bHQp OworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNW YWx1ZSwgUmVmUHRyPERPTVdpbmRvdz4mIHJlc3VsdCk7CisgICAgc3RhdGljIGJvb2wgY29udmVy dFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBSZWZQdHI8RXZlbnRUYXJnZXQ+ JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSos IEpTQzo6SlNWYWx1ZSwgUmVmUHRyPE5vZGU+JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNv bnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFN0b3JhZ2U+ JiByZXN1bHQpOworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSos IEpTQzo6SlNWYWx1ZSwgTWVzc2FnZVBvcnRBcnJheSYgcmVzdWx0KTsKICNpZiBFTkFCTEUoVklE RU9fVFJBQ0spCi0gICAgc3RhdGljIHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwg SlNDOjpKU1ZhbHVlLCBSZWZQdHI8VHJhY2tCYXNlPiYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9v bCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3RhdGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxUcmFj a0Jhc2U+JiByZXN1bHQpOwogI2VuZGlmCiAjaWYgRU5BQkxFKE1VVEFUSU9OX09CU0VSVkVSUykg fHwgRU5BQkxFKFdFQl9JTlRFTlRTKQotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6 OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgSGFzaFNldDxBdG9taWNTdHJpbmc+JiByZXN1bHQp OworICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNW YWx1ZSwgSGFzaFNldDxBdG9taWNTdHJpbmc+JiByZXN1bHQpOwogI2VuZGlmCi0gICAgc3RhdGlj IHZvaWQgY29udmVydFZhbHVlKEpTQzo6RXhlY1N0YXRlKiwgSlNDOjpKU1ZhbHVlLCBBcnJheVZh bHVlJiByZXN1bHQpOwotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0 ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPFVpbnQ4QXJyYXk+JiByZXN1bHQpOworICAgIHN0YXRp YyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgQXJyYXlW YWx1ZSYgcmVzdWx0KTsKKyAgICBzdGF0aWMgYm9vbCBjb252ZXJ0VmFsdWUoSlNDOjpFeGVjU3Rh dGUqLCBKU0M6OkpTVmFsdWUsIFJlZlB0cjxVaW50OEFycmF5PiYgcmVzdWx0KTsKICNpZiBFTkFC TEUoRU5DUllQVEVEX01FRElBKQotICAgIHN0YXRpYyB2b2lkIGNvbnZlcnRWYWx1ZShKU0M6OkV4 ZWNTdGF0ZSosIEpTQzo6SlNWYWx1ZSwgUmVmUHRyPE1lZGlhS2V5RXJyb3I+JiByZXN1bHQpOwor ICAgIHN0YXRpYyBib29sIGNvbnZlcnRWYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1 ZSwgUmVmUHRyPE1lZGlhS2V5RXJyb3I+JiByZXN1bHQpOwogI2VuZGlmCiAKICAgICBKU0M6OkV4 ZWNTdGF0ZSogbV9leGVjOwpAQCAtMTQ5LDE2ICsxNTAsMjAgQEAgSlNEaWN0aW9uYXJ5OjpHZXRQ cm9wZXJ0eVJlc3VsdCBKU0RpY3Rpb25hcnk6OnRyeUdldFByb3BlcnR5QW5kUmVzdWx0KGNvbnN0 IGNoYXIKICAgICAgICAgcmV0dXJuIGdldFByb3BlcnR5UmVzdWx0OwogICAgIGNhc2UgUHJvcGVy dHlGb3VuZDogewogICAgICAgICBSZXN1bHQgcmVzdWx0OwotICAgICAgICBjb252ZXJ0VmFsdWUo bV9leGVjLCB2YWx1ZSwgcmVzdWx0KTsKLQotICAgICAgICBpZiAobV9leGVjLT5oYWRFeGNlcHRp b24oKSkKLSAgICAgICAgICAgIHJldHVybiBFeGNlcHRpb25UaHJvd247CisgICAgICAgIGlmICgh Y29udmVydFZhbHVlKG1fZXhlYywgdmFsdWUsIHJlc3VsdCkpIHsKKyAgICAgICAgICAgIGlmICht X2V4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICAgICAgICAgIHJldHVybiBFeGNlcHRpb25U aHJvd247CisgICAgICAgICAgICByZXR1cm4gQ29udmVyc2lvbkZhaWxlZDsKKyAgICAgICAgfQog CiAgICAgICAgIHNldHRlcihjb250ZXh0LCByZXN1bHQpOwogICAgICAgICBicmVhazsKICAgICB9 CiAgICAgY2FzZSBOb1Byb3BlcnR5Rm91bmQ6CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgQ29u dmVyc2lvbkZhaWxlZDoKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIGJy ZWFrOwogICAgIH0KIAogICAgIHJldHVybiBnZXRQcm9wZXJ0eVJlc3VsdDsKLS0gCjEuNy45LjUK Cg== 178728 2012-12-10 23:25:50 -0800 2012-12-12 07:40:30 -0800 Patch idb-array-check.patch text/plain 6567 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogTW9uLCAxMCBEZWMg MjAxMiAyMzoyMjozOSAtMDgwMApTdWJqZWN0OiBJbmRleGVkREI6IENoZWNrIHdoZXRoZXIga2V5 UGF0aCBpcyBhbiBhcnJheSBiZWZvcmUgYWNjZXNzaW5nIGFzIGFycmF5CgotLS0KIFNvdXJjZS9X ZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMzEgKysrKysrKysr KysrKysrKysrKysrKwogU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJh c2UuY3BwIHwgICAgMiArLQogU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvRGljdGlvbmFyeS5j cHAgICAgICAgIHwgICAgNSArKysrCiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9EaWN0aW9u YXJ5LmggICAgICAgICAgfCAgICAyICsrCiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0Rp Y3Rpb25hcnkuY3BwICAgICAgfCAgIDIxICsrKysrKysrKysrKysrKwogU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmggICAgICAgIHwgICAgMiArKwogU291cmNlL1dlYkNv cmUvYmluZGluZ3MvdjgvRGljdGlvbmFyeS5jcHAgICAgICAgIHwgICAgOSArKysrKysrCiBTb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy92OC9EaWN0aW9uYXJ5LmggICAgICAgICAgfCAgICAyICsrCiA4 IGZpbGVzIGNoYW5nZWQsIDczIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cK aW5kZXggYmU4MTIwNi4uOGJlNDRmZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM0IEBACisyMDEy LTEyLTEwICBNaWNoYWVsIFBydWV0dCAgPG1pY2hhZWxANjhrLm9yZz4KKworICAgICAgICBJbmRl eGVkREI6IENoZWNrIHdoZXRoZXIga2V5UGF0aCBpcyBhbiBhcnJheSBiZWZvcmUgYWNjZXNzaW5n IGFzIGFycmF5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD05NjYxNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZSgpIHNob3VsZCBjaGVjayB3aGV0aGVyIHRo ZSBrZXlQYXRoCisgICAgICAgIHByb3BlcnR5IGluIHRoZSBvcHRpb25zIGRpY3Rpb25hcnkgaXMg YW4gYXJyYXkgYmVmb3JlIGFjY2Vzc2luZyB0aGUKKyAgICAgICAgcHJvcGVydHkgYXMgYW4gYXJy YXkuCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhlZGRiLyoKKworICAgICAgICAqIE1v ZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQkRh dGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZSk6CisgICAgICAgICogYmluZGluZ3MvanMvRGljdGlv bmFyeS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEaWN0aW9uYXJ5Ojppc1NlcXVlbmNlKToKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0RpY3Rpb25hcnkuaDoKKyAg ICAgICAgKERpY3Rpb25hcnkpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpKU0RpY3Rpb25hcnk6OmlzU2VxdWVuY2UpOgorICAgICAg ICAoV2ViQ29yZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5Lmg6CisgICAg ICAgIChKU0RpY3Rpb25hcnkpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L0RpY3Rpb25hcnkuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6RGljdGlvbmFyeTo6aXNTZXF1ZW5jZSk6CisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKiBiaW5kaW5ncy92OC9EaWN0aW9uYXJ5Lmg6CisgICAgICAgIChE aWN0aW9uYXJ5KToKKwogMjAxMi0xMi0xMCAgS3l1bmdUYWUgS2ltICA8a3RmLmtpbUBzYW1zdW5n LmNvbT4KIAogICAgICAgICBCdWlsZCBmaXggYWZ0ZXIgcjEzNzIyMQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwCmluZGV4IDFiZDViODguLmM2 ODEzZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRh dGFiYXNlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRh YmFzZS5jcHAKQEAgLTE1NCw3ICsxNTQsNyBAQCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJ REJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjbwogICAg IGlmICghb3B0aW9ucy5pc1VuZGVmaW5lZE9yTnVsbCgpKSB7CiAgICAgICAgIFN0cmluZyBrZXlQ YXRoU3RyaW5nOwogICAgICAgICBWZWN0b3I8U3RyaW5nPiBrZXlQYXRoQXJyYXk7Ci0gICAgICAg IGlmIChvcHRpb25zLmdldCgia2V5UGF0aCIsIGtleVBhdGhBcnJheSkpCisgICAgICAgIGlmIChv cHRpb25zLmlzU2VxdWVuY2UoImtleVBhdGgiKSAmJiBvcHRpb25zLmdldCgia2V5UGF0aCIsIGtl eVBhdGhBcnJheSkpCiAgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoQXJy YXkpOwogICAgICAgICBlbHNlIGlmIChvcHRpb25zLmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVj aygia2V5UGF0aCIsIGtleVBhdGhTdHJpbmcpKQogICAgICAgICAgICAga2V5UGF0aCA9IElEQktl eVBhdGgoa2V5UGF0aFN0cmluZyk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy9qcy9EaWN0aW9uYXJ5LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0RpY3Rpb25h cnkuY3BwCmluZGV4IDVjODFmMjAuLjY5NjQ2YTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0RpY3Rpb25hcnkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0RpY3Rpb25hcnkuY3BwCkBAIC0xMDMsNCArMTAzLDkgQEAgYm9vbCBEaWN0aW9uYXJ5Ojpn ZXRXaXRoVW5kZWZpbmVkT3JOdWxsQ2hlY2soY29uc3QgU3RyaW5nJiBwcm9wZXJ0eU5hbWUsIFN0 cmluZyYKICAgICByZXR1cm4gbV9kaWN0aW9uYXJ5LmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVj ayhwcm9wZXJ0eU5hbWUsIHZhbHVlKTsKIH0KIAorYm9vbCBEaWN0aW9uYXJ5Ojppc1NlcXVlbmNl KGNvbnN0IFN0cmluZyYgcHJvcGVydHlOYW1lKSBjb25zdAoreworICAgIHJldHVybiBtX2RpY3Rp b25hcnkuaXNTZXF1ZW5jZShwcm9wZXJ0eU5hbWUpOworfQorCiB9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvRGljdGlvbmFyeS5oIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvanMvRGljdGlvbmFyeS5oCmluZGV4IDk0ZGE4NzguLjRjYTViN2MgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0RpY3Rpb25hcnkuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9EaWN0aW9uYXJ5LmgKQEAgLTY0LDYgKzY0LDggQEAgcHVibGljOgog ICAgIGJvb2wgZ2V0T3duUHJvcGVydHlOYW1lcyhWZWN0b3I8U3RyaW5nPiYpIGNvbnN0OwogICAg IGJvb2wgZ2V0V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKGNvbnN0IFN0cmluZyYgcHJvcGVydHlO YW1lLCBTdHJpbmcmIHZhbHVlKSBjb25zdDsKIAorICAgIGJvb2wgaXNTZXF1ZW5jZShjb25zdCBT dHJpbmcmIHByb3BlcnR5TmFtZSkgY29uc3Q7CisKIHByaXZhdGU6CiAgICAgdGVtcGxhdGUgPHR5 cGVuYW1lIFQ+CiAgICAgSlNDOjpKU09iamVjdCogYXNKU09iamVjdChUKikgY29uc3Q7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuY3BwIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNEaWN0aW9uYXJ5LmNwcAppbmRleCA0ZTJkZDRjLi5k ZjA3ODY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25h cnkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5jcHAK QEAgLTIyOCw0ICsyMjgsMjUgQEAgYm9vbCBKU0RpY3Rpb25hcnk6OmdldFdpdGhVbmRlZmluZWRP ck51bGxDaGVjayhjb25zdCBTdHJpbmcmIHByb3BlcnR5TmFtZSwgU3RyaW4KICAgICByZXR1cm4g dHJ1ZTsKIH0KIAorYm9vbCBKU0RpY3Rpb25hcnk6OmlzU2VxdWVuY2UoY29uc3QgU3RyaW5nJiBw cm9wZXJ0eU5hbWUpIGNvbnN0Cit7CisgICAgQVNTRVJUKGlzVmFsaWQoKSk7CisgICAgSlNWYWx1 ZSB2YWx1ZTsKKyAgICBpZiAodHJ5R2V0UHJvcGVydHkocHJvcGVydHlOYW1lLnV0ZjgoKS5kYXRh KCksIHZhbHVlKSAhPSBQcm9wZXJ0eUZvdW5kKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg aWYgKCF2YWx1ZS5pc09iamVjdCgpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBKU09i amVjdCogb2JqZWN0ID0gdmFsdWUuZ2V0T2JqZWN0KCk7CisgICAgSlNWYWx1ZSBsZW5ndGhWYWx1 ZSA9IG9iamVjdC0+Z2V0KG1fZXhlYywgbV9leGVjLT5wcm9wZXJ0eU5hbWVzKCkubGVuZ3RoKTsK KyAgICBpZiAobV9leGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIGlmIChsZW5ndGhWYWx1ZS5pc1VuZGVmaW5lZE9yTnVsbCgpKQorICAgICAgICByZXR1cm4g ZmFsc2U7CisgICAgbGVuZ3RoVmFsdWUudG9VSW50MzIobV9leGVjKTsKKyAgICBpZiAobV9leGVj LT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIHJldHVybiB0cnVl OworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9KU0RpY3Rpb25hcnkuaCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTRGljdGlvbmFyeS5oCmluZGV4IGUxN2Y4NjguLjYxNzU3MTEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL2pzL0pTRGljdGlvbmFyeS5oCkBAIC02NSw2ICs2NSw4IEBAIHB1YmxpYzoKICAg ICBib29sIGdldChjb25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIFJlc3VsdCYpIGNvbnN0OwogICAg IGJvb2wgZ2V0V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKGNvbnN0IFN0cmluZyYgcHJvcGVydHlO YW1lLCBTdHJpbmcmIHZhbHVlKSBjb25zdDsKIAorICAgIGJvb2wgaXNTZXF1ZW5jZShjb25zdCBT dHJpbmcmIHByb3BlcnR5TmFtZSkgY29uc3Q7CisKICAgICBKU0M6OkV4ZWNTdGF0ZSogZXhlY1N0 YXRlKCkgY29uc3QgeyByZXR1cm4gbV9leGVjOyB9CiAgICAgSlNDOjpKU09iamVjdCogaW5pdGlh bGl6ZXJPYmplY3QoKSBjb25zdCB7IHJldHVybiBtX2luaXRpYWxpemVyT2JqZWN0LmdldCgpOyB9 CiAgICAgYm9vbCBpc1ZhbGlkKCkgY29uc3QgeyByZXR1cm4gbV9leGVjICYmIG1faW5pdGlhbGl6 ZXJPYmplY3Q7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L0RpY3Rp b25hcnkuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvRGljdGlvbmFyeS5jcHAKaW5k ZXggNmI4NTU1MS4uNWQ5N2IxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv djgvRGljdGlvbmFyeS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvRGljdGlv bmFyeS5jcHAKQEAgLTUzMSw0ICs1MzEsMTMgQEAgYm9vbCBEaWN0aW9uYXJ5OjpnZXRPd25Qcm9w ZXJ0eU5hbWVzKFZlY3RvcjxTdHJpbmc+JiBuYW1lcykgY29uc3QKICAgICByZXR1cm4gdHJ1ZTsK IH0KIAorYm9vbCBEaWN0aW9uYXJ5Ojppc1NlcXVlbmNlKGNvbnN0IFN0cmluZyYga2V5KSBjb25z dAoreworICAgIHY4OjpMb2NhbDx2ODo6VmFsdWU+IHY4VmFsdWU7CisgICAgaWYgKCFnZXRLZXko a2V5LCB2OFZhbHVlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIHY4VmFs dWUtPklzQXJyYXkoKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvRGljdGlvbmFyeS5oIGIvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvdjgvRGljdGlvbmFyeS5oCmluZGV4IGNmZDEzNzEuLmJlNjA1ZTcgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L0RpY3Rpb25hcnkuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy92OC9EaWN0aW9uYXJ5LmgKQEAgLTk3LDYgKzk3LDggQEAgcHVibGlj OgogCiAgICAgUGFzc1JlZlB0cjxFdmVudExpc3RlbmVyPiBnZXRFdmVudExpc3RlbmVyKGNvbnN0 IFN0cmluZyYsIE5vdGlmaWNhdGlvbiopIGNvbnN0IHsgcmV0dXJuIDA7IH0KIAorICAgIGJvb2wg aXNTZXF1ZW5jZShjb25zdCBTdHJpbmcmKSBjb25zdDsKKwogcHJpdmF0ZToKICAgICBib29sIGdl dEtleShjb25zdCBTdHJpbmcmIGtleSwgdjg6OkxvY2FsPHY4OjpWYWx1ZT4mKSBjb25zdDsKIAot LSAKMS43LjkuNQoK 179040 2012-12-12 07:40:30 -0800 2012-12-12 17:32:18 -0800 Patch idb-options.patch text/plain 18682 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCAxMiBEZWMg MjAxMiAwNzozNDo1MCAtMDgwMApTdWJqZWN0OiBJbmRleGVkREI6IEltcGxlbWVudCBjdXN0b20g YmluZGluZ3MgZm9yIHBhcnNpbmcgb3B0aW9ucwoKLS0tCiBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMzMgKysrKysrKwogU291cmNlL1dlYkNv cmUvR05VbWFrZWZpbGUubGlzdC5hbSAgICAgICAgICAgICAgICAgfCAgICAyICsKIFNvdXJjZS9X ZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcCAgIHwgICAzMSArKysrLS0t CiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oICAgICB8ICAg IDEgKwogU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsICAg fCAgICAyICstCiAuLi4vV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5j cHAgICB8ICAgMTcgKystLQogU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2Jq ZWN0U3RvcmUuaCAgfCAgICAzICstCiAuLi4vV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwgICB8ICAgIDQgKy0KIFNvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFrZSAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9q cy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcCB8ICAgOTEgKysrKysrKysrKysrKysrKysrKwogLi4u L1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAgfCAgIDk0ICsr KysrKysrKysrKysrKysrKysrCiAxMSBmaWxlcyBjaGFuZ2VkLCAyNTcgaW5zZXJ0aW9ucygrKSwg MjMgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNwcAoKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpp bmRleCBiOGU5NGUyLi5jMzk3NDQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTIt MTItMTIgIE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgorCisgICAgICAgIEluZGV4 ZWREQjogSW1wbGVtZW50IGN1c3RvbSBiaW5kaW5ncyBmb3IgcGFyc2luZyBvcHRpb25zCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NjYxNAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBhcnNpbmcgdGhlIG9w dGlvbnMgZGljdGlvbmFyeSBpbiBJREJEYXRhYmFzZS5jcmVhdGVPYmplY3RTdG9yZSgpCisgICAg ICAgIGFuZCBJREJPYmplY3RTdG9yZS5jcmVhdGVJbmRleCgpIHJlcXVpcmVzIGN1c3RvbSBiaW5k aW5ncyBpbiBKU0MuCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhlZGRiLyoKKworICAg ICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIv SURCRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2U6OmNyZWF0ZU9i amVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhl ZGRiL0lEQkRhdGFiYXNlLmg6CisgICAgICAgIChJREJEYXRhYmFzZSk6CisgICAgICAgICogTW9k dWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhl ZGRiL0lEQk9iamVjdFN0b3JlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3Jl OjpjcmVhdGVJbmRleCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBNb2R1bGVzL2lu ZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oOgorICAgICAgICAoSURCT2JqZWN0U3RvcmUpOgorICAg ICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbDoKKyAgICAgICAgKiBV c2VKU0MuY21ha2U6CisgICAgICAgICogYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpKU0lEQkRh dGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSlNJREJP YmplY3RTdG9yZUN1c3RvbS5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChXZWJDb3JlOjpKU0lEQk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleCk6CisKIDIwMTItMTItMTEg IE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgogCiAgICAgICAgIEluZGV4ZWREQjog RG9uJ3QgdXNlIHN0cmluZ3MgdG8gcmVwcmVzZW50IHNlcmlhbGl6ZWQgdmFsdWVzCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUv R05VbWFrZWZpbGUubGlzdC5hbQppbmRleCAyMzdlNzIzLi4xZTA4MjVlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0KQEAgLTIzMzcsNyArMjMzNyw5IEBAIHdlYmNvcmVfc291cmNlcyAr PSBcCiAJU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNIaXN0b3J5Q3VzdG9tLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNIaXN0b3J5Q3VzdG9tLmggXAogCVNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCQW55Q3VzdG9tLmNwcCBcCisJU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTSURCS2V5Q3VzdG9tLmNwcCBcCisJU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTSW1hZ2VDb25zdHJ1Y3Rvci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTSW1hZ2VDb25zdHJ1Y3Rvci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lt YWdlRGF0YUN1c3RvbS5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9p bmRleGVkZGIvSURCRGF0YWJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVk ZGIvSURCRGF0YWJhc2UuY3BwCmluZGV4IDFiZDViODguLjYzM2I2YjYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5jcHAKQEAgLTE0MSwxNSAr MTQxLDYgQEAgUGFzc1JlZlB0cjxJREJBbnk+IElEQkRhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QK IAogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0 b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgRXhjZXB0 aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYgKCFtX3ZlcnNpb25DaGFuZ2VUcmFuc2FjdGlvbikgewot ICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkU3RhdGVFcnJvcjsKLSAg ICAgICAgcmV0dXJuIDA7Ci0gICAgfQotICAgIGlmICghbV92ZXJzaW9uQ2hhbmdlVHJhbnNhY3Rp b24tPmlzQWN0aXZlKCkpIHsKLSAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6VHJh bnNhY3Rpb25JbmFjdGl2ZUVycm9yOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KICAgICBJ REJLZXlQYXRoIGtleVBhdGg7CiAgICAgaWYgKCFvcHRpb25zLmlzVW5kZWZpbmVkT3JOdWxsKCkp IHsKICAgICAgICAgU3RyaW5nIGtleVBhdGhTdHJpbmc7CkBAIC0xNjAsNiArMTUxLDI0IEBAIFBh c3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvCiAgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChr ZXlQYXRoU3RyaW5nKTsKICAgICB9CiAKKyAgICBib29sIGF1dG9JbmNyZW1lbnQgPSBmYWxzZTsK KyAgICBpZiAoIW9wdGlvbnMuaXNVbmRlZmluZWRPck51bGwoKSkKKyAgICAgICAgb3B0aW9ucy5n ZXQoImF1dG9JbmNyZW1lbnQiLCBhdXRvSW5jcmVtZW50KTsKKworICAgIHJldHVybiBjcmVhdGVP YmplY3RTdG9yZShuYW1lLCBrZXlQYXRoLCBhdXRvSW5jcmVtZW50LCBlYyk7Cit9CisKK1Bhc3NS ZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShjb25z dCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgsIGJvb2wgYXV0b0luY3Jl bWVudCwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFtX3ZlcnNpb25DaGFuZ2VUcmFu c2FjdGlvbikgeworICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkU3Rh dGVFcnJvcjsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIGlmICghbV92ZXJzaW9uQ2hh bmdlVHJhbnNhY3Rpb24tPmlzQWN0aXZlKCkpIHsKKyAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4 Y2VwdGlvbjo6VHJhbnNhY3Rpb25JbmFjdGl2ZUVycm9yOworICAgICAgICByZXR1cm4gMDsKKyAg ICB9CisKICAgICBpZiAoY29udGFpbnNPYmplY3RTdG9yZShuYW1lKSkgewogICAgICAgICBlYyA9 IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpDb25zdHJhaW50RXJyb3I7CiAgICAgICAgIHJldHVybiAw OwpAQCAtMTcwLDEwICsxNzksNiBAQCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJEYXRh YmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjbwogICAgICAgICBy ZXR1cm4gMDsKICAgICB9CiAKLSAgICBib29sIGF1dG9JbmNyZW1lbnQgPSBmYWxzZTsKLSAgICBp ZiAoIW9wdGlvbnMuaXNVbmRlZmluZWRPck51bGwoKSkKLSAgICAgICAgb3B0aW9ucy5nZXQoImF1 dG9JbmNyZW1lbnQiLCBhdXRvSW5jcmVtZW50KTsKLQogICAgIGlmIChhdXRvSW5jcmVtZW50ICYm ICgoa2V5UGF0aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6U3RyaW5nVHlwZSAmJiBrZXlQYXRoLnN0 cmluZygpLmlzRW1wdHkoKSkgfHwga2V5UGF0aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6QXJyYXlU eXBlKSkgewogICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkQWNjZXNz RXJyb3I7CiAgICAgICAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5k ZXhlZGRiL0lEQkRhdGFiYXNlLmgKaW5kZXggMWM5Nzc5Ni4uYTljNGM1YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oCkBAIC02NSw2ICs2NSw3 IEBAIHB1YmxpYzoKICAgICBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlTmFt ZXMoKSBjb25zdDsKIAogICAgIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IGNyZWF0ZU9iamVj dFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRGljdGlvbmFyeSYsIEV4Y2VwdGlvbkNv ZGUmKTsKKyAgICBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBjcmVhdGVPYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmLCBib29sIGF1dG9JbmNyZW1lbnQs IEV4Y2VwdGlvbkNvZGUmKTsKICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uPiB0cmFuc2Fj dGlvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPERPTVN0cmlu Z0xpc3Q+IHNjb3BlLCBjb25zdCBTdHJpbmcmIG1vZGUsIEV4Y2VwdGlvbkNvZGUmIGVjKSB7IHJl dHVybiB0cmFuc2FjdGlvbihjb250ZXh0LCAqc2NvcGUsIG1vZGUsIGVjKTsgfQogICAgIFBhc3NS ZWZQdHI8SURCVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBjb25zdCBWZWN0b3I8U3RyaW5nPiYsIGNvbnN0IFN0cmluZyYgbW9kZSwgRXhjZXB0aW9uQ29k ZSYpOwogICAgIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIG1vZGUsIEV4Y2Vw dGlvbkNvZGUmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQkRhdGFiYXNlLmlkbCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRh dGFiYXNlLmlkbAppbmRleCA1MGY3ZTYzLi4xMzQ4NTQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwKKysrIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsCkBAIC0zOCw3ICszOCw3IEBACiAg ICAgYXR0cmlidXRlIEV2ZW50TGlzdGVuZXIgb25lcnJvcjsKICAgICBhdHRyaWJ1dGUgRXZlbnRM aXN0ZW5lciBvbnZlcnNpb25jaGFuZ2U7CiAKLSAgICBJREJPYmplY3RTdG9yZSBjcmVhdGVPYmpl Y3RTdG9yZShpbiBET01TdHJpbmcgbmFtZSwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlv bnMpCisgICAgW0pTQ3VzdG9tXSBJREJPYmplY3RTdG9yZSBjcmVhdGVPYmplY3RTdG9yZShpbiBE T01TdHJpbmcgbmFtZSwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAg IHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKICAgICB2b2lkIGRlbGV0ZU9iamVjdFN0b3JlKGluIERP TVN0cmluZyBuYW1lKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAKaW5kZXgg MThlN2ViMi4uZmE5ZTI5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRl eGVkZGIvSURCT2JqZWN0U3RvcmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5k ZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcApAQCAtMzU0LDYgKzM1NCwxNyBAQCBwcml2YXRlOgog CiBQYXNzUmVmUHRyPElEQkluZGV4PiBJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJREJL ZXlQYXRoJiBrZXlQYXRoLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBFeGNlcHRpb25Db2Rl JiBlYykKIHsKKyAgICBib29sIHVuaXF1ZSA9IGZhbHNlOworICAgIG9wdGlvbnMuZ2V0KCJ1bmlx dWUiLCB1bmlxdWUpOworCisgICAgYm9vbCBtdWx0aUVudHJ5ID0gZmFsc2U7CisgICAgb3B0aW9u cy5nZXQoIm11bHRpRW50cnkiLCBtdWx0aUVudHJ5KTsKKworICAgIHJldHVybiBjcmVhdGVJbmRl eChjb250ZXh0LCBuYW1lLCBrZXlQYXRoLCB1bmlxdWUsIG11bHRpRW50cnksIGVjKTsKK30KKwor UGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZUluZGV4KFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5 UGF0aCYga2V5UGF0aCwgYm9vbCB1bmlxdWUsIGJvb2wgbXVsdGlFbnRyeSwgRXhjZXB0aW9uQ29k ZSYgZWMpCit7CiAgICAgSURCX1RSQUNFKCJJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgiKTsK ICAgICBpZiAoIW1fdHJhbnNhY3Rpb24tPmlzVmVyc2lvbkNoYW5nZSgpIHx8IG1fZGVsZXRlZCkg ewogICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkU3RhdGVFcnJvcjsK QEAgLTM3NiwxMiArMzg3LDYgQEAgUGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0U3RvcmU6 OmNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQKICAgICAgICAgcmV0 dXJuIDA7CiAgICAgfQogCi0gICAgYm9vbCB1bmlxdWUgPSBmYWxzZTsKLSAgICBvcHRpb25zLmdl dCgidW5pcXVlIiwgdW5pcXVlKTsKLQotICAgIGJvb2wgbXVsdGlFbnRyeSA9IGZhbHNlOwotICAg IG9wdGlvbnMuZ2V0KCJtdWx0aUVudHJ5IiwgbXVsdGlFbnRyeSk7Ci0KICAgICBpZiAoa2V5UGF0 aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6QXJyYXlUeXBlICYmIG11bHRpRW50cnkpIHsKICAgICAg ICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6SW52YWxpZEFjY2Vzc0Vycm9yOwogICAgICAg ICByZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQk9iamVjdFN0b3JlLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5oCmluZGV4IGRjYjk5ODEuLmZjYjQzNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmgKKysrIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaApAQCAtODQsNyArODQsOCBA QCBwdWJsaWM6CiAKICAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBjcmVhdGVJbmRleChTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmlu ZyYga2V5UGF0aCwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgRXhjZXB0aW9uQ29kZSYgZWMp IHsgcmV0dXJuIGNyZWF0ZUluZGV4KGNvbnRleHQsIG5hbWUsIElEQktleVBhdGgoa2V5UGF0aCks IG9wdGlvbnMsIGVjKTsgfQogICAgIFBhc3NSZWZQdHI8SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3Qg VmVjdG9yPFN0cmluZz4mIGtleVBhdGgsIGNvbnN0IERpY3Rpb25hcnkmIG9wdGlvbnMsIEV4Y2Vw dGlvbkNvZGUmIGVjKSB7IHJldHVybiBjcmVhdGVJbmRleChjb250ZXh0LCBuYW1lLCBJREJLZXlQ YXRoKGtleVBhdGgpLCBvcHRpb25zLCBlYyk7IH0KLSAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBj cmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiwgY29uc3Qg SURCS2V5UGF0aCYsIGNvbnN0IERpY3Rpb25hcnkmLCBFeGNlcHRpb25Db2RlJik7CisgICAgUGFz c1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0aCYsIGNvbnN0IERpY3Rpb25hcnkmLCBF eGNlcHRpb25Db2RlJik7CisgICAgUGFzc1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0 aCYsIGJvb2wgdW5pcXVlLCBib29sIG11bHRpRW50cnksIEV4Y2VwdGlvbkNvZGUmKTsKIAogICAg IFBhc3NSZWZQdHI8SURCSW5kZXg+IGluZGV4KGNvbnN0IFN0cmluZyYgbmFtZSwgRXhjZXB0aW9u Q29kZSYpOwogICAgIHZvaWQgZGVsZXRlSW5kZXgoY29uc3QgU3RyaW5nJiBuYW1lLCBFeGNlcHRp b25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9J REJPYmplY3RTdG9yZS5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwKaW5kZXggMzk2NDJjMi4uM2QyOGU5YyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbApAQCAtNTIsOSAr NTIsOSBAQAogICAgIFtDYWxsV2l0aD1TY3JpcHRFeGVjdXRpb25Db250ZXh0XSBJREJSZXF1ZXN0 IG9wZW5DdXJzb3IoaW4gSURCS2V5IGtleSwgaW4gW09wdGlvbmFsXSBET01TdHJpbmcgZGlyZWN0 aW9uKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CiAKLSAgICBbQ2FsbFdpdGg9U2Ny aXB0RXhlY3V0aW9uQ29udGV4dF0gSURCSW5kZXggY3JlYXRlSW5kZXgoaW4gRE9NU3RyaW5nIG5h bWUsIGluIHNlcXVlbmNlPERPTVN0cmluZz4ga2V5UGF0aCwgaW4gW09wdGlvbmFsXSBEaWN0aW9u YXJ5IG9wdGlvbnMpCisgICAgW0NhbGxXaXRoPVNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIEpTQ3Vz dG9tXSBJREJJbmRleCBjcmVhdGVJbmRleChpbiBET01TdHJpbmcgbmFtZSwgaW4gc2VxdWVuY2U8 RE9NU3RyaW5nPiBrZXlQYXRoLCBpbiBbT3B0aW9uYWxdIERpY3Rpb25hcnkgb3B0aW9ucykKICAg ICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwotICAgIFtDYWxsV2l0aD1TY3JpcHRFeGVjdXRp b25Db250ZXh0XSBJREJJbmRleCBjcmVhdGVJbmRleChpbiBET01TdHJpbmcgbmFtZSwgaW4gRE9N U3RyaW5nIGtleVBhdGgsIGluIFtPcHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtD YWxsV2l0aD1TY3JpcHRFeGVjdXRpb25Db250ZXh0LCBKU0N1c3RvbV0gSURCSW5kZXggY3JlYXRl SW5kZXgoaW4gRE9NU3RyaW5nIG5hbWUsIGluIERPTVN0cmluZyBrZXlQYXRoLCBpbiBbT3B0aW9u YWxdIERpY3Rpb25hcnkgb3B0aW9ucykKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwog ICAgIElEQkluZGV4IGluZGV4KGluIERPTVN0cmluZyBuYW1lKQogICAgICAgICByYWlzZXMgKERP TUV4Y2VwdGlvbik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UgYi9T b3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKaW5kZXggODlmZjhjYi4uZDMwNGZiNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1Vz ZUpTQy5jbWFrZQpAQCAtMjAyLDcgKzIwMiw5IEBAIGlmIChFTkFCTEVfSU5ERVhFRF9EQVRBQkFT RSkKICAgICBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICAgICAgYmluZGluZ3MvanMv SURCQmluZGluZ1V0aWxpdGllcy5jcHAKICAgICAgICAgYmluZGluZ3MvanMvSlNJREJBbnlDdXN0 b20uY3BwCisgICAgICAgIGJpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwCiAgICAg ICAgIGJpbmRpbmdzL2pzL0pTSURCS2V5Q3VzdG9tLmNwcAorICAgICAgICBiaW5kaW5ncy9qcy9K U0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNwcAogICAgICkKIGVuZGlmICgpCiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmVhNzMwMgotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwCkBAIC0wLDAg KzEsOTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWljaGFlbCBQcnVldHQgPG1pY2hh ZWxANjhrLm9yZz4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorCisjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCisKKyNpbmNsdWRlICJKU0lEQkRhdGFi YXNlLmgiCisKKyNpbmNsdWRlICJJREJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIklEQktleVBhdGgu aCIKKyNpbmNsdWRlICJJREJPYmplY3RTdG9yZS5oIgorI2luY2x1ZGUgIkpTRGljdGlvbmFyeS5o IgorI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKworI2luY2x1ZGUgPHJ1bnRpbWUvRXJy b3IuaD4KKyNpbmNsdWRlIDxydW50aW1lL0pTQXJyYXkuaD4KKyNpbmNsdWRlIDxydW50aW1lL0pT U3RyaW5nLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworSlNWYWx1ZSBKU0lEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShKU0M6OkV4ZWNTdGF0 ZSogZXhlYykKK3sKKyAgICBpZiAoZXhlYy0+YXJndW1lbnRDb3VudCgpIDwgMSkKKyAgICAgICAg cmV0dXJuIHRocm93RXJyb3IoZXhlYywgY3JlYXRlTm90RW5vdWdoQXJndW1lbnRzRXJyb3IoZXhl YykpOworICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgIEpTVmFsdWUgbmFtZVZhbHVlID0g ZXhlYy0+YXJndW1lbnQoMCk7CisgICAgU3RyaW5nIG5hbWUgPSBuYW1lVmFsdWUudG9TdHJpbmco ZXhlYyktPnZhbHVlKGV4ZWMpOworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAg ICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG9wdGlvbnNWYWx1ZSA9IE1B WUJFX01JU1NJTkdfUEFSQU1FVEVSKGV4ZWMsIDEsIERlZmF1bHRJc1VuZGVmaW5lZCk7CisgICAg aWYgKCFvcHRpb25zVmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSAmJiAhb3B0aW9uc1ZhbHVlLmlz T2JqZWN0KCkpCisgICAgICAgIHJldHVybiB0aHJvd1R5cGVFcnJvcihleGVjLCAiTm90IGFuIG9i amVjdC4iKTsKKworICAgIEpTRGljdGlvbmFyeSBvcHRpb25zKGV4ZWMsIG9wdGlvbnNWYWx1ZS5n ZXRPYmplY3QoKSk7CisKKyAgICBJREJLZXlQYXRoIGtleVBhdGg7CisgICAgU2NyaXB0VmFsdWUg a2V5UGF0aFNjcmlwdFZhbHVlOworICAgIGlmIChvcHRpb25zLmlzVmFsaWQoKSAmJiBvcHRpb25z LmdldCgia2V5UGF0aCIsIGtleVBhdGhTY3JpcHRWYWx1ZSkpIHsKKyAgICAgICAgSlNWYWx1ZSBr ZXlQYXRoVmFsdWUgPSBrZXlQYXRoU2NyaXB0VmFsdWUuanNWYWx1ZSgpOworICAgICAgICBpZiAo aXNKU0FycmF5KGtleVBhdGhWYWx1ZSkpCisgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0 aCh0b05hdGl2ZUFycmF5PFN0cmluZz4oZXhlYywga2V5UGF0aFZhbHVlKSk7CisgICAgICAgIGVs c2UgaWYgKCFrZXlQYXRoVmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSkKKyAgICAgICAgICAgIGtl eVBhdGggPSBJREJLZXlQYXRoKGtleVBhdGhWYWx1ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhl YykpOworICAgIH0KKworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgcmV0 dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBib29sIGF1dG9JbmNyZW1lbnQgPSBmYWxzZTsKKyAg ICBpZiAob3B0aW9ucy5pc1ZhbGlkKCkpCisgICAgICAgIG9wdGlvbnMuZ2V0KCJhdXRvSW5jcmVt ZW50IiwgYXV0b0luY3JlbWVudCk7CisKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisg ICAgICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSByZXN1bHQgPSB0b0pT KGV4ZWMsIGdsb2JhbE9iamVjdCgpLCBXVEY6OmdldFB0cihpbXBsKCktPmNyZWF0ZU9iamVjdFN0 b3JlKG5hbWUsIGtleVBhdGgsIGF1dG9JbmNyZW1lbnQsIGVjKSkpOworICAgIHNldERPTUV4Y2Vw dGlvbihleGVjLCBlYyk7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKworfQorCisjZW5kaWYKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0 b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3Rv bS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWYyNTRiNwotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVD dXN0b20uY3BwCkBAIC0wLDAgKzEsOTQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWlj aGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQor ICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklC VVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z CisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCisKKyNp bmNsdWRlICJKU0lEQk9iamVjdFN0b3JlLmgiCisKKyNpbmNsdWRlICJJREJLZXlQYXRoLmgiCisj aW5jbHVkZSAiSURCT2JqZWN0U3RvcmUuaCIKKyNpbmNsdWRlICJKU0RpY3Rpb25hcnkuaCIKKyNp bmNsdWRlICJKU0lEQkluZGV4LmgiCisKKyNpbmNsdWRlIDxydW50aW1lL0Vycm9yLmg+CisjaW5j bHVkZSA8cnVudGltZS9KU0FycmF5Lmg+CisjaW5jbHVkZSA8cnVudGltZS9KU1N0cmluZy5oPgor Cit1c2luZyBuYW1lc3BhY2UgSlNDOworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0pTVmFsdWUg SlNJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgoSlNDOjpFeGVjU3RhdGUqIGV4ZWMpCit7Cisg ICAgaWYgKGV4ZWMtPmFyZ3VtZW50Q291bnQoKSA8IDIpCisgICAgICAgIHJldHVybiB0aHJvd0Vy cm9yKGV4ZWMsIGNyZWF0ZU5vdEVub3VnaEFyZ3VtZW50c0Vycm9yKGV4ZWMpKTsKKyAgICBFeGNl cHRpb25Db2RlIGVjID0gMDsKKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0ID0g anNDYXN0PEpTRE9NR2xvYmFsT2JqZWN0Kj4oZXhlYy0+bGV4aWNhbEdsb2JhbE9iamVjdCgpKS0+ c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpOworICAgIGlmICghY29udGV4dCkKKyAgICAgICAgcmV0 dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG5hbWVWYWx1ZSA9IGV4ZWMtPmFyZ3Vt ZW50KDApOworICAgIFN0cmluZyBuYW1lID0gbmFtZVZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1 ZShleGVjKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgIHJldHVybiBq c1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSBrZXlQYXRoVmFsdWUgPSBleGVjLT5hcmd1bWVu dCgxKTsKKyAgICBJREJLZXlQYXRoIGtleVBhdGg7CisgICAgaWYgKGtleVBhdGhWYWx1ZS5pc09i amVjdCgpICYmIGlzSlNBcnJheShrZXlQYXRoVmFsdWUpKQorICAgICAgICBrZXlQYXRoID0gSURC S2V5UGF0aCh0b05hdGl2ZUFycmF5PFN0cmluZz4oZXhlYywga2V5UGF0aFZhbHVlKSk7CisgICAg ZWxzZQorICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoVmFsdWUudG9TdHJpbmco ZXhlYyktPnZhbHVlKGV4ZWMpKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAg ICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSBvcHRpb25zVmFsdWUgPSBN QVlCRV9NSVNTSU5HX1BBUkFNRVRFUihleGVjLCAyLCBEZWZhdWx0SXNVbmRlZmluZWQpOworICAg IGlmICghb3B0aW9uc1ZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkgJiYgIW9wdGlvbnNWYWx1ZS5p c09iamVjdCgpKQorICAgICAgICByZXR1cm4gdGhyb3dUeXBlRXJyb3IoZXhlYywgIk5vdCBhbiBv YmplY3QuIik7CisKKyAgICBKU0RpY3Rpb25hcnkgb3B0aW9ucyhleGVjLCBvcHRpb25zVmFsdWUu Z2V0T2JqZWN0KCkpOworCisgICAgYm9vbCB1bmlxdWUgPSBmYWxzZTsKKyAgICBpZiAob3B0aW9u cy5pc1ZhbGlkKCkpCisgICAgICAgIG9wdGlvbnMuZ2V0KCJ1bmlxdWUiLCB1bmlxdWUpOworCisg ICAgYm9vbCBtdWx0aUVudHJ5ID0gZmFsc2U7CisgICAgaWYgKG9wdGlvbnMuaXNWYWxpZCgpKQor ICAgICAgICBvcHRpb25zLmdldCgibXVsdGlFbnRyeSIsIG11bHRpRW50cnkpOworCisgICAgaWYg KGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsKKwor ICAgIEpTVmFsdWUgcmVzdWx0ID0gdG9KUyhleGVjLCBnbG9iYWxPYmplY3QoKSwgV1RGOjpnZXRQ dHIoaW1wbCgpLT5jcmVhdGVJbmRleChjb250ZXh0LCBuYW1lLCBrZXlQYXRoLCB1bmlxdWUsIG11 bHRpRW50cnksIGVjKSkpOworICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CisgICAgcmV0 dXJuIHJlc3VsdDsKK30KKworfQorCisjZW5kaWYKLS0gCjEuNy45LjUKCg== 179158 2012-12-12 17:32:18 -0800 2012-12-13 13:52:53 -0800 Patch idb-options.patch text/plain 18739 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogV2VkLCAxMiBEZWMg MjAxMiAxNzoyNTowNiAtMDgwMApTdWJqZWN0OiBJbmRleGVkREI6IEltcGxlbWVudCBjdXN0b20g YmluZGluZ3MgZm9yIHBhcnNpbmcgb3B0aW9ucwoKLS0tCiBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMzMgKysrKysrKwogU291cmNlL1dlYkNv cmUvR05VbWFrZWZpbGUubGlzdC5hbSAgICAgICAgICAgICAgICAgfCAgICAyICsKIFNvdXJjZS9X ZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcCAgIHwgICAzMCArKysrLS0t CiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oICAgICB8ICAg IDEgKwogU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsICAg fCAgICAyICstCiAuLi4vV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5j cHAgICB8ICAgMTcgKystLQogU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2Jq ZWN0U3RvcmUuaCAgfCAgICAzICstCiAuLi4vV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwgICB8ICAgIDQgKy0KIFNvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFrZSAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCiBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9q cy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcCB8ICAgOTEgKysrKysrKysrKysrKysrKysrKwogLi4u L1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAgfCAgIDk0ICsr KysrKysrKysrKysrKysrKysrCiAxMSBmaWxlcyBjaGFuZ2VkLCAyNTYgaW5zZXJ0aW9ucygrKSwg MjMgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKIGNyZWF0ZSBtb2RlIDEwMDY0NCBTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNwcAoKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpp bmRleCBiOGU5NGUyLi5jMzk3NDQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzYgQEAKKzIwMTIt MTItMTIgIE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgorCisgICAgICAgIEluZGV4 ZWREQjogSW1wbGVtZW50IGN1c3RvbSBiaW5kaW5ncyBmb3IgcGFyc2luZyBvcHRpb25zCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05NjYxNAorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBhcnNpbmcgdGhlIG9w dGlvbnMgZGljdGlvbmFyeSBpbiBJREJEYXRhYmFzZS5jcmVhdGVPYmplY3RTdG9yZSgpCisgICAg ICAgIGFuZCBJREJPYmplY3RTdG9yZS5jcmVhdGVJbmRleCgpIHJlcXVpcmVzIGN1c3RvbSBiaW5k aW5ncyBpbiBKU0MuCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhlZGRiLyoKKworICAg ICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIv SURCRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJhc2U6OmNyZWF0ZU9i amVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhl ZGRiL0lEQkRhdGFiYXNlLmg6CisgICAgICAgIChJREJEYXRhYmFzZSk6CisgICAgICAgICogTW9k dWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhl ZGRiL0lEQk9iamVjdFN0b3JlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklEQk9iamVjdFN0b3Jl OjpjcmVhdGVJbmRleCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBNb2R1bGVzL2lu ZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oOgorICAgICAgICAoSURCT2JqZWN0U3RvcmUpOgorICAg ICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbDoKKyAgICAgICAgKiBV c2VKU0MuY21ha2U6CisgICAgICAgICogYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpKU0lEQkRh dGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZSk6CisgICAgICAgICogYmluZGluZ3MvanMvSlNJREJP YmplY3RTdG9yZUN1c3RvbS5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChXZWJDb3JlOjpKU0lEQk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleCk6CisKIDIwMTItMTItMTEg IE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgogCiAgICAgICAgIEluZGV4ZWREQjog RG9uJ3QgdXNlIHN0cmluZ3MgdG8gcmVwcmVzZW50IHNlcmlhbGl6ZWQgdmFsdWVzCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUv R05VbWFrZWZpbGUubGlzdC5hbQppbmRleCAyMzdlNzIzLi4xZTA4MjVlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0KQEAgLTIzMzcsNyArMjMzNyw5IEBAIHdlYmNvcmVfc291cmNlcyAr PSBcCiAJU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNIaXN0b3J5Q3VzdG9tLmNwcCBcCiAJ U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNIaXN0b3J5Q3VzdG9tLmggXAogCVNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCQW55Q3VzdG9tLmNwcCBcCisJU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0pTSURCS2V5Q3VzdG9tLmNwcCBcCisJU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTSW1hZ2VDb25zdHJ1Y3Rvci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTSW1hZ2VDb25zdHJ1Y3Rvci5oIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lt YWdlRGF0YUN1c3RvbS5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9p bmRleGVkZGIvSURCRGF0YWJhc2UuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVk ZGIvSURCRGF0YWJhc2UuY3BwCmluZGV4IDFiZDViODguLmViZGUwZjEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5jcHAKQEAgLTE0MSwxNiAr MTQxLDggQEAgUGFzc1JlZlB0cjxJREJBbnk+IElEQkRhdGFiYXNlOjp2ZXJzaW9uKCkgY29uc3QK IAogUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0 b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgRXhjZXB0 aW9uQ29kZSYgZWMpCiB7Ci0gICAgaWYgKCFtX3ZlcnNpb25DaGFuZ2VUcmFuc2FjdGlvbikgewot ICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkU3RhdGVFcnJvcjsKLSAg ICAgICAgcmV0dXJuIDA7Ci0gICAgfQotICAgIGlmICghbV92ZXJzaW9uQ2hhbmdlVHJhbnNhY3Rp b24tPmlzQWN0aXZlKCkpIHsKLSAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6VHJh bnNhY3Rpb25JbmFjdGl2ZUVycm9yOwotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0KICAgICBJ REJLZXlQYXRoIGtleVBhdGg7CisgICAgYm9vbCBhdXRvSW5jcmVtZW50ID0gZmFsc2U7CiAgICAg aWYgKCFvcHRpb25zLmlzVW5kZWZpbmVkT3JOdWxsKCkpIHsKICAgICAgICAgU3RyaW5nIGtleVBh dGhTdHJpbmc7CiAgICAgICAgIFZlY3RvcjxTdHJpbmc+IGtleVBhdGhBcnJheTsKQEAgLTE1OCw2 ICsxNTAsMjIgQEAgUGFzc1JlZlB0cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6OmNyZWF0 ZU9iamVjdFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY28KICAgICAgICAgICAgIGtleVBhdGgg PSBJREJLZXlQYXRoKGtleVBhdGhBcnJheSk7CiAgICAgICAgIGVsc2UgaWYgKG9wdGlvbnMuZ2V0 V2l0aFVuZGVmaW5lZE9yTnVsbENoZWNrKCJrZXlQYXRoIiwga2V5UGF0aFN0cmluZykpCiAgICAg ICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoU3RyaW5nKTsKKworICAgICAgICBv cHRpb25zLmdldCgiYXV0b0luY3JlbWVudCIsIGF1dG9JbmNyZW1lbnQpOworICAgIH0KKworICAg IHJldHVybiBjcmVhdGVPYmplY3RTdG9yZShuYW1lLCBrZXlQYXRoLCBhdXRvSW5jcmVtZW50LCBl Yyk7Cit9CisKK1Bhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElEQkRhdGFiYXNlOjpjcmVhdGVP YmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgs IGJvb2wgYXV0b0luY3JlbWVudCwgRXhjZXB0aW9uQ29kZSYgZWMpCit7CisgICAgaWYgKCFtX3Zl cnNpb25DaGFuZ2VUcmFuc2FjdGlvbikgeworICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0 aW9uOjpJbnZhbGlkU3RhdGVFcnJvcjsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorICAgIGlm ICghbV92ZXJzaW9uQ2hhbmdlVHJhbnNhY3Rpb24tPmlzQWN0aXZlKCkpIHsKKyAgICAgICAgZWMg PSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6VHJhbnNhY3Rpb25JbmFjdGl2ZUVycm9yOworICAgICAg ICByZXR1cm4gMDsKICAgICB9CiAKICAgICBpZiAoY29udGFpbnNPYmplY3RTdG9yZShuYW1lKSkg ewpAQCAtMTcwLDEwICsxNzgsNiBAQCBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBJREJEYXRh YmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjbwogICAgICAgICBy ZXR1cm4gMDsKICAgICB9CiAKLSAgICBib29sIGF1dG9JbmNyZW1lbnQgPSBmYWxzZTsKLSAgICBp ZiAoIW9wdGlvbnMuaXNVbmRlZmluZWRPck51bGwoKSkKLSAgICAgICAgb3B0aW9ucy5nZXQoImF1 dG9JbmNyZW1lbnQiLCBhdXRvSW5jcmVtZW50KTsKLQogICAgIGlmIChhdXRvSW5jcmVtZW50ICYm ICgoa2V5UGF0aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6U3RyaW5nVHlwZSAmJiBrZXlQYXRoLnN0 cmluZygpLmlzRW1wdHkoKSkgfHwga2V5UGF0aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6QXJyYXlU eXBlKSkgewogICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkQWNjZXNz RXJyb3I7CiAgICAgICAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5k ZXhlZGRiL0lEQkRhdGFiYXNlLmgKaW5kZXggMWM5Nzc5Ni4uYTljNGM1YiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oCkBAIC02NSw2ICs2NSw3 IEBAIHB1YmxpYzoKICAgICBQYXNzUmVmUHRyPERPTVN0cmluZ0xpc3Q+IG9iamVjdFN0b3JlTmFt ZXMoKSBjb25zdDsKIAogICAgIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IGNyZWF0ZU9iamVj dFN0b3JlKGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRGljdGlvbmFyeSYsIEV4Y2VwdGlvbkNv ZGUmKTsKKyAgICBQYXNzUmVmUHRyPElEQk9iamVjdFN0b3JlPiBjcmVhdGVPYmplY3RTdG9yZShj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmLCBib29sIGF1dG9JbmNyZW1lbnQs IEV4Y2VwdGlvbkNvZGUmKTsKICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uPiB0cmFuc2Fj dGlvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBQYXNzUmVmUHRyPERPTVN0cmlu Z0xpc3Q+IHNjb3BlLCBjb25zdCBTdHJpbmcmIG1vZGUsIEV4Y2VwdGlvbkNvZGUmIGVjKSB7IHJl dHVybiB0cmFuc2FjdGlvbihjb250ZXh0LCAqc2NvcGUsIG1vZGUsIGVjKTsgfQogICAgIFBhc3NS ZWZQdHI8SURCVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq LCBjb25zdCBWZWN0b3I8U3RyaW5nPiYsIGNvbnN0IFN0cmluZyYgbW9kZSwgRXhjZXB0aW9uQ29k ZSYpOwogICAgIFBhc3NSZWZQdHI8SURCVHJhbnNhY3Rpb24+IHRyYW5zYWN0aW9uKFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIG1vZGUsIEV4Y2Vw dGlvbkNvZGUmKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQkRhdGFiYXNlLmlkbCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRh dGFiYXNlLmlkbAppbmRleCA1MGY3ZTYzLi4xMzQ4NTQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwKKysrIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsCkBAIC0zOCw3ICszOCw3IEBACiAg ICAgYXR0cmlidXRlIEV2ZW50TGlzdGVuZXIgb25lcnJvcjsKICAgICBhdHRyaWJ1dGUgRXZlbnRM aXN0ZW5lciBvbnZlcnNpb25jaGFuZ2U7CiAKLSAgICBJREJPYmplY3RTdG9yZSBjcmVhdGVPYmpl Y3RTdG9yZShpbiBET01TdHJpbmcgbmFtZSwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlv bnMpCisgICAgW0pTQ3VzdG9tXSBJREJPYmplY3RTdG9yZSBjcmVhdGVPYmplY3RTdG9yZShpbiBE T01TdHJpbmcgbmFtZSwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAg IHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKICAgICB2b2lkIGRlbGV0ZU9iamVjdFN0b3JlKGluIERP TVN0cmluZyBuYW1lKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAKaW5kZXgg MThlN2ViMi4uZmE5ZTI5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRl eGVkZGIvSURCT2JqZWN0U3RvcmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5k ZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcApAQCAtMzU0LDYgKzM1NCwxNyBAQCBwcml2YXRlOgog CiBQYXNzUmVmUHRyPElEQkluZGV4PiBJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgoU2NyaXB0 RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJREJL ZXlQYXRoJiBrZXlQYXRoLCBjb25zdCBEaWN0aW9uYXJ5JiBvcHRpb25zLCBFeGNlcHRpb25Db2Rl JiBlYykKIHsKKyAgICBib29sIHVuaXF1ZSA9IGZhbHNlOworICAgIG9wdGlvbnMuZ2V0KCJ1bmlx dWUiLCB1bmlxdWUpOworCisgICAgYm9vbCBtdWx0aUVudHJ5ID0gZmFsc2U7CisgICAgb3B0aW9u cy5nZXQoIm11bHRpRW50cnkiLCBtdWx0aUVudHJ5KTsKKworICAgIHJldHVybiBjcmVhdGVJbmRl eChjb250ZXh0LCBuYW1lLCBrZXlQYXRoLCB1bmlxdWUsIG11bHRpRW50cnksIGVjKTsKK30KKwor UGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0U3RvcmU6OmNyZWF0ZUluZGV4KFNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5 UGF0aCYga2V5UGF0aCwgYm9vbCB1bmlxdWUsIGJvb2wgbXVsdGlFbnRyeSwgRXhjZXB0aW9uQ29k ZSYgZWMpCit7CiAgICAgSURCX1RSQUNFKCJJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgiKTsK ICAgICBpZiAoIW1fdHJhbnNhY3Rpb24tPmlzVmVyc2lvbkNoYW5nZSgpIHx8IG1fZGVsZXRlZCkg ewogICAgICAgICBlYyA9IElEQkRhdGFiYXNlRXhjZXB0aW9uOjpJbnZhbGlkU3RhdGVFcnJvcjsK QEAgLTM3NiwxMiArMzg3LDYgQEAgUGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0U3RvcmU6 OmNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQKICAgICAgICAgcmV0 dXJuIDA7CiAgICAgfQogCi0gICAgYm9vbCB1bmlxdWUgPSBmYWxzZTsKLSAgICBvcHRpb25zLmdl dCgidW5pcXVlIiwgdW5pcXVlKTsKLQotICAgIGJvb2wgbXVsdGlFbnRyeSA9IGZhbHNlOwotICAg IG9wdGlvbnMuZ2V0KCJtdWx0aUVudHJ5IiwgbXVsdGlFbnRyeSk7Ci0KICAgICBpZiAoa2V5UGF0 aC50eXBlKCkgPT0gSURCS2V5UGF0aDo6QXJyYXlUeXBlICYmIG11bHRpRW50cnkpIHsKICAgICAg ICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6SW52YWxpZEFjY2Vzc0Vycm9yOwogICAgICAg ICByZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQk9iamVjdFN0b3JlLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5oCmluZGV4IGRjYjk5ODEuLmZjYjQzNzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmgKKysrIGIvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaApAQCAtODQsNyArODQsOCBA QCBwdWJsaWM6CiAKICAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBjcmVhdGVJbmRleChTY3JpcHRF eGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFN0cmlu ZyYga2V5UGF0aCwgY29uc3QgRGljdGlvbmFyeSYgb3B0aW9ucywgRXhjZXB0aW9uQ29kZSYgZWMp IHsgcmV0dXJuIGNyZWF0ZUluZGV4KGNvbnRleHQsIG5hbWUsIElEQktleVBhdGgoa2V5UGF0aCks IG9wdGlvbnMsIGVjKTsgfQogICAgIFBhc3NSZWZQdHI8SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3Qg VmVjdG9yPFN0cmluZz4mIGtleVBhdGgsIGNvbnN0IERpY3Rpb25hcnkmIG9wdGlvbnMsIEV4Y2Vw dGlvbkNvZGUmIGVjKSB7IHJldHVybiBjcmVhdGVJbmRleChjb250ZXh0LCBuYW1lLCBJREJLZXlQ YXRoKGtleVBhdGgpLCBvcHRpb25zLCBlYyk7IH0KLSAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBj cmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiwgY29uc3Qg SURCS2V5UGF0aCYsIGNvbnN0IERpY3Rpb25hcnkmLCBFeGNlcHRpb25Db2RlJik7CisgICAgUGFz c1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCosIGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0aCYsIGNvbnN0IERpY3Rpb25hcnkmLCBF eGNlcHRpb25Db2RlJik7CisgICAgUGFzc1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2Ny aXB0RXhlY3V0aW9uQ29udGV4dCosIGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0 aCYsIGJvb2wgdW5pcXVlLCBib29sIG11bHRpRW50cnksIEV4Y2VwdGlvbkNvZGUmKTsKIAogICAg IFBhc3NSZWZQdHI8SURCSW5kZXg+IGluZGV4KGNvbnN0IFN0cmluZyYgbmFtZSwgRXhjZXB0aW9u Q29kZSYpOwogICAgIHZvaWQgZGVsZXRlSW5kZXgoY29uc3QgU3RyaW5nJiBuYW1lLCBFeGNlcHRp b25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9J REJPYmplY3RTdG9yZS5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwKaW5kZXggMzk2NDJjMi4uM2QyOGU5YyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbApAQCAtNTIsOSAr NTIsOSBAQAogICAgIFtDYWxsV2l0aD1TY3JpcHRFeGVjdXRpb25Db250ZXh0XSBJREJSZXF1ZXN0 IG9wZW5DdXJzb3IoaW4gSURCS2V5IGtleSwgaW4gW09wdGlvbmFsXSBET01TdHJpbmcgZGlyZWN0 aW9uKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CiAKLSAgICBbQ2FsbFdpdGg9U2Ny aXB0RXhlY3V0aW9uQ29udGV4dF0gSURCSW5kZXggY3JlYXRlSW5kZXgoaW4gRE9NU3RyaW5nIG5h bWUsIGluIHNlcXVlbmNlPERPTVN0cmluZz4ga2V5UGF0aCwgaW4gW09wdGlvbmFsXSBEaWN0aW9u YXJ5IG9wdGlvbnMpCisgICAgW0NhbGxXaXRoPVNjcmlwdEV4ZWN1dGlvbkNvbnRleHQsIEpTQ3Vz dG9tXSBJREJJbmRleCBjcmVhdGVJbmRleChpbiBET01TdHJpbmcgbmFtZSwgaW4gc2VxdWVuY2U8 RE9NU3RyaW5nPiBrZXlQYXRoLCBpbiBbT3B0aW9uYWxdIERpY3Rpb25hcnkgb3B0aW9ucykKICAg ICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwotICAgIFtDYWxsV2l0aD1TY3JpcHRFeGVjdXRp b25Db250ZXh0XSBJREJJbmRleCBjcmVhdGVJbmRleChpbiBET01TdHJpbmcgbmFtZSwgaW4gRE9N U3RyaW5nIGtleVBhdGgsIGluIFtPcHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtD YWxsV2l0aD1TY3JpcHRFeGVjdXRpb25Db250ZXh0LCBKU0N1c3RvbV0gSURCSW5kZXggY3JlYXRl SW5kZXgoaW4gRE9NU3RyaW5nIG5hbWUsIGluIERPTVN0cmluZyBrZXlQYXRoLCBpbiBbT3B0aW9u YWxdIERpY3Rpb25hcnkgb3B0aW9ucykKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwog ICAgIElEQkluZGV4IGluZGV4KGluIERPTVN0cmluZyBuYW1lKQogICAgICAgICByYWlzZXMgKERP TUV4Y2VwdGlvbik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UgYi9T b3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKaW5kZXggODlmZjhjYi4uZDMwNGZiNiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1Vz ZUpTQy5jbWFrZQpAQCAtMjAyLDcgKzIwMiw5IEBAIGlmIChFTkFCTEVfSU5ERVhFRF9EQVRBQkFT RSkKICAgICBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMKICAgICAgICAgYmluZGluZ3MvanMv SURCQmluZGluZ1V0aWxpdGllcy5jcHAKICAgICAgICAgYmluZGluZ3MvanMvSlNJREJBbnlDdXN0 b20uY3BwCisgICAgICAgIGJpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwCiAgICAg ICAgIGJpbmRpbmdzL2pzL0pTSURCS2V5Q3VzdG9tLmNwcAorICAgICAgICBiaW5kaW5ncy9qcy9K U0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNwcAogICAgICkKIGVuZGlmICgpCiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmVhNzMwMgotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwCkBAIC0wLDAg KzEsOTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWljaGFlbCBQcnVldHQgPG1pY2hh ZWxANjhrLm9yZz4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorCisjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCisKKyNpbmNsdWRlICJKU0lEQkRhdGFi YXNlLmgiCisKKyNpbmNsdWRlICJJREJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIklEQktleVBhdGgu aCIKKyNpbmNsdWRlICJJREJPYmplY3RTdG9yZS5oIgorI2luY2x1ZGUgIkpTRGljdGlvbmFyeS5o IgorI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKworI2luY2x1ZGUgPHJ1bnRpbWUvRXJy b3IuaD4KKyNpbmNsdWRlIDxydW50aW1lL0pTQXJyYXkuaD4KKyNpbmNsdWRlIDxydW50aW1lL0pT U3RyaW5nLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworSlNWYWx1ZSBKU0lEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShKU0M6OkV4ZWNTdGF0 ZSogZXhlYykKK3sKKyAgICBpZiAoZXhlYy0+YXJndW1lbnRDb3VudCgpIDwgMSkKKyAgICAgICAg cmV0dXJuIHRocm93RXJyb3IoZXhlYywgY3JlYXRlTm90RW5vdWdoQXJndW1lbnRzRXJyb3IoZXhl YykpOworICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgIEpTVmFsdWUgbmFtZVZhbHVlID0g ZXhlYy0+YXJndW1lbnQoMCk7CisgICAgU3RyaW5nIG5hbWUgPSBuYW1lVmFsdWUudG9TdHJpbmco ZXhlYyktPnZhbHVlKGV4ZWMpOworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAg ICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG9wdGlvbnNWYWx1ZSA9IE1B WUJFX01JU1NJTkdfUEFSQU1FVEVSKGV4ZWMsIDEsIERlZmF1bHRJc1VuZGVmaW5lZCk7CisgICAg aWYgKCFvcHRpb25zVmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSAmJiAhb3B0aW9uc1ZhbHVlLmlz T2JqZWN0KCkpCisgICAgICAgIHJldHVybiB0aHJvd1R5cGVFcnJvcihleGVjLCAiTm90IGFuIG9i amVjdC4iKTsKKworICAgIEpTRGljdGlvbmFyeSBvcHRpb25zKGV4ZWMsIG9wdGlvbnNWYWx1ZS5n ZXRPYmplY3QoKSk7CisKKyAgICBJREJLZXlQYXRoIGtleVBhdGg7CisgICAgU2NyaXB0VmFsdWUg a2V5UGF0aFNjcmlwdFZhbHVlOworICAgIGlmIChvcHRpb25zLmlzVmFsaWQoKSAmJiBvcHRpb25z LmdldCgia2V5UGF0aCIsIGtleVBhdGhTY3JpcHRWYWx1ZSkpIHsKKyAgICAgICAgSlNWYWx1ZSBr ZXlQYXRoVmFsdWUgPSBrZXlQYXRoU2NyaXB0VmFsdWUuanNWYWx1ZSgpOworICAgICAgICBpZiAo aXNKU0FycmF5KGtleVBhdGhWYWx1ZSkpCisgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0 aCh0b05hdGl2ZUFycmF5PFN0cmluZz4oZXhlYywga2V5UGF0aFZhbHVlKSk7CisgICAgICAgIGVs c2UgaWYgKCFrZXlQYXRoVmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSkKKyAgICAgICAgICAgIGtl eVBhdGggPSBJREJLZXlQYXRoKGtleVBhdGhWYWx1ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhl YykpOworICAgIH0KKworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgcmV0 dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBib29sIGF1dG9JbmNyZW1lbnQgPSBmYWxzZTsKKyAg ICBpZiAob3B0aW9ucy5pc1ZhbGlkKCkpCisgICAgICAgIG9wdGlvbnMuZ2V0KCJhdXRvSW5jcmVt ZW50IiwgYXV0b0luY3JlbWVudCk7CisKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisg ICAgICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSByZXN1bHQgPSB0b0pT KGV4ZWMsIGdsb2JhbE9iamVjdCgpLCBXVEY6OmdldFB0cihpbXBsKCktPmNyZWF0ZU9iamVjdFN0 b3JlKG5hbWUsIGtleVBhdGgsIGF1dG9JbmNyZW1lbnQsIGVjKSkpOworICAgIHNldERPTUV4Y2Vw dGlvbihleGVjLCBlYyk7CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKworfQorCisjZW5kaWYKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0 b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3Rv bS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZWYyNTRiNwotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVD dXN0b20uY3BwCkBAIC0wLDAgKzEsOTQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgTWlj aGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICog UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQor ICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklC VVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z CisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKElOREVYRURfREFUQUJBU0UpCisKKyNp bmNsdWRlICJKU0lEQk9iamVjdFN0b3JlLmgiCisKKyNpbmNsdWRlICJJREJLZXlQYXRoLmgiCisj aW5jbHVkZSAiSURCT2JqZWN0U3RvcmUuaCIKKyNpbmNsdWRlICJKU0RpY3Rpb25hcnkuaCIKKyNp bmNsdWRlICJKU0lEQkluZGV4LmgiCisKKyNpbmNsdWRlIDxydW50aW1lL0Vycm9yLmg+CisjaW5j bHVkZSA8cnVudGltZS9KU0FycmF5Lmg+CisjaW5jbHVkZSA8cnVudGltZS9KU1N0cmluZy5oPgor Cit1c2luZyBuYW1lc3BhY2UgSlNDOworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0pTVmFsdWUg SlNJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgoSlNDOjpFeGVjU3RhdGUqIGV4ZWMpCit7Cisg ICAgaWYgKGV4ZWMtPmFyZ3VtZW50Q291bnQoKSA8IDIpCisgICAgICAgIHJldHVybiB0aHJvd0Vy cm9yKGV4ZWMsIGNyZWF0ZU5vdEVub3VnaEFyZ3VtZW50c0Vycm9yKGV4ZWMpKTsKKyAgICBFeGNl cHRpb25Db2RlIGVjID0gMDsKKyAgICBTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0ID0g anNDYXN0PEpTRE9NR2xvYmFsT2JqZWN0Kj4oZXhlYy0+bGV4aWNhbEdsb2JhbE9iamVjdCgpKS0+ c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpOworICAgIGlmICghY29udGV4dCkKKyAgICAgICAgcmV0 dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG5hbWVWYWx1ZSA9IGV4ZWMtPmFyZ3Vt ZW50KDApOworICAgIFN0cmluZyBuYW1lID0gbmFtZVZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1 ZShleGVjKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgIHJldHVybiBq c1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSBrZXlQYXRoVmFsdWUgPSBleGVjLT5hcmd1bWVu dCgxKTsKKyAgICBJREJLZXlQYXRoIGtleVBhdGg7CisgICAgaWYgKGtleVBhdGhWYWx1ZS5pc09i amVjdCgpICYmIGlzSlNBcnJheShrZXlQYXRoVmFsdWUpKQorICAgICAgICBrZXlQYXRoID0gSURC S2V5UGF0aCh0b05hdGl2ZUFycmF5PFN0cmluZz4oZXhlYywga2V5UGF0aFZhbHVlKSk7CisgICAg ZWxzZQorICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoVmFsdWUudG9TdHJpbmco ZXhlYyktPnZhbHVlKGV4ZWMpKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAg ICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgSlNWYWx1ZSBvcHRpb25zVmFsdWUgPSBN QVlCRV9NSVNTSU5HX1BBUkFNRVRFUihleGVjLCAyLCBEZWZhdWx0SXNVbmRlZmluZWQpOworICAg IGlmICghb3B0aW9uc1ZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkgJiYgIW9wdGlvbnNWYWx1ZS5p c09iamVjdCgpKQorICAgICAgICByZXR1cm4gdGhyb3dUeXBlRXJyb3IoZXhlYywgIk5vdCBhbiBv YmplY3QuIik7CisKKyAgICBKU0RpY3Rpb25hcnkgb3B0aW9ucyhleGVjLCBvcHRpb25zVmFsdWUu Z2V0T2JqZWN0KCkpOworCisgICAgYm9vbCB1bmlxdWUgPSBmYWxzZTsKKyAgICBpZiAob3B0aW9u cy5pc1ZhbGlkKCkpCisgICAgICAgIG9wdGlvbnMuZ2V0KCJ1bmlxdWUiLCB1bmlxdWUpOworCisg ICAgYm9vbCBtdWx0aUVudHJ5ID0gZmFsc2U7CisgICAgaWYgKG9wdGlvbnMuaXNWYWxpZCgpKQor ICAgICAgICBvcHRpb25zLmdldCgibXVsdGlFbnRyeSIsIG11bHRpRW50cnkpOworCisgICAgaWYg KGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsKKwor ICAgIEpTVmFsdWUgcmVzdWx0ID0gdG9KUyhleGVjLCBnbG9iYWxPYmplY3QoKSwgV1RGOjpnZXRQ dHIoaW1wbCgpLT5jcmVhdGVJbmRleChjb250ZXh0LCBuYW1lLCBrZXlQYXRoLCB1bmlxdWUsIG11 bHRpRW50cnksIGVjKSkpOworICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CisgICAgcmV0 dXJuIHJlc3VsdDsKK30KKworfQorCisjZW5kaWYKLS0gCjEuNy45LjUKCg== 179326 2012-12-13 13:52:53 -0800 2012-12-14 02:41:18 -0800 Patch idb-options.patch text/plain 20572 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogVGh1LCAxMyBEZWMg MjAxMiAxMzo0MToxNSAtMDgwMApTdWJqZWN0OiBJbmRleGVkREI6IEltcGxlbWVudCBjdXN0b20g YmluZGluZ3MgZm9yIHBhcnNpbmcgb3B0aW9ucwoKLS0tCiBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMzggKysrKysrKysrCiBTb3VyY2UvV2Vi Q29yZS9HTlVtYWtlZmlsZS5saXN0LmFtICAgICAgICAgICAgICAgICB8ICAgIDIgKwogU291cmNl L1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwICAgfCAgIDMwICsrKyst LS0KIFNvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmggICAgIHwg ICAgMSArCiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwg ICB8ICAgIDIgKy0KIC4uLi9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3Jl LmNwcCAgIHwgICAxNyArKy0tCiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5oICB8ICAgIDMgKy0KIC4uLi9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lE Qk9iamVjdFN0b3JlLmlkbCAgIHwgICAgNCArLQogU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtl ICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwIHwgICAxMCArKysKIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuaCAgIHwgICAgMiArCiBTb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcCB8ICAgODggKysrKysrKysrKysr KysrKysrKwogLi4uL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5j cHAgfCAgIDkwICsrKysrKysrKysrKysrKysrKysrCiAxMyBmaWxlcyBjaGFuZ2VkLCAyNjYgaW5z ZXJ0aW9ucygrKSwgMjMgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKIGNyZWF0ZSBtb2RlIDEw MDY0NCBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNw cAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCBiOGU5NGUyLi42ZTdmMTY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs NDEgQEAKKzIwMTItMTItMTMgIE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgorCisg ICAgICAgIEluZGV4ZWREQjogSW1wbGVtZW50IGN1c3RvbSBiaW5kaW5ncyBmb3IgcGFyc2luZyBv cHRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 NjYxNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBh cnNpbmcgdGhlIG9wdGlvbnMgZGljdGlvbmFyeSBpbiBJREJEYXRhYmFzZS5jcmVhdGVPYmplY3RT dG9yZSgpCisgICAgICAgIGFuZCBJREJPYmplY3RTdG9yZS5jcmVhdGVJbmRleCgpIHJlcXVpcmVz IGN1c3RvbSBiaW5kaW5ncyBpbiBKU0MuCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhl ZGRiLyoKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogTW9kdWxl cy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJh c2U6OmNyZWF0ZU9iamVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIE1v ZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmg6CisgICAgICAgIChJREJEYXRhYmFzZSk6Cisg ICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsOgorICAgICAgICAqIE1v ZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklE Qk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KiBNb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oOgorICAgICAgICAoSURCT2JqZWN0 U3RvcmUpOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbDoK KyAgICAgICAgKiBVc2VKU0MuY21ha2U6CisgICAgICAgICogYmluZGluZ3MvanMvSURCQmluZGlu Z1V0aWxpdGllcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjppZGJLZXlQYXRoRnJvbVZhbHVlKTog QWRkZWQgdXRpbGl0eSBmdW5jdGlvbiBmb3IgY29udmVydGluZyBhIEpTVmFsdWUgdG8gYW4gSURC S2V5UGF0aC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0lEQkJp bmRpbmdVdGlsaXRpZXMuaDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGJpbmRpbmdz L2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6SlNJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUpOgorICAg ICAgICAqIGJpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0b20uY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6SlNJREJPYmplY3RTdG9yZTo6Y3Jl YXRlSW5kZXgpOgorCiAyMDEyLTEyLTExICBNaWNoYWVsIFBydWV0dCAgPG1pY2hhZWxANjhrLm9y Zz4KIAogICAgICAgICBJbmRleGVkREI6IERvbid0IHVzZSBzdHJpbmdzIHRvIHJlcHJlc2VudCBz ZXJpYWxpemVkIHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUu bGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggMjM3ZTcy My4uMWUwODI1ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5h bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0yMzM3LDcgKzIz MzcsOSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTSGlzdG9yeUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSGlz dG9yeUN1c3RvbS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQkFueUN1c3Rv bS5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20u Y3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQktleUN1c3RvbS5jcHAgXAor CVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0b20uY3BwIFwK IAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0ltYWdlQ29uc3RydWN0b3IuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0ltYWdlQ29uc3RydWN0b3IuaCBcCiAJU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNJbWFnZURhdGFDdXN0b20uY3BwIFwKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcAppbmRleCAxYmQ1Yjg4 Li5lYmRlMGYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9J REJEYXRhYmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURC RGF0YWJhc2UuY3BwCkBAIC0xNDEsMTYgKzE0MSw4IEBAIFBhc3NSZWZQdHI8SURCQW55PiBJREJE YXRhYmFzZTo6dmVyc2lvbigpIGNvbnN0CiAKIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElE QkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IERp Y3Rpb25hcnkmIG9wdGlvbnMsIEV4Y2VwdGlvbkNvZGUmIGVjKQogewotICAgIGlmICghbV92ZXJz aW9uQ2hhbmdlVHJhbnNhY3Rpb24pIHsKLSAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlv bjo6SW52YWxpZFN0YXRlRXJyb3I7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLSAgICBpZiAo IW1fdmVyc2lvbkNoYW5nZVRyYW5zYWN0aW9uLT5pc0FjdGl2ZSgpKSB7Ci0gICAgICAgIGVjID0g SURCRGF0YWJhc2VFeGNlcHRpb246OlRyYW5zYWN0aW9uSW5hY3RpdmVFcnJvcjsKLSAgICAgICAg cmV0dXJuIDA7Ci0gICAgfQotCiAgICAgSURCS2V5UGF0aCBrZXlQYXRoOworICAgIGJvb2wgYXV0 b0luY3JlbWVudCA9IGZhbHNlOwogICAgIGlmICghb3B0aW9ucy5pc1VuZGVmaW5lZE9yTnVsbCgp KSB7CiAgICAgICAgIFN0cmluZyBrZXlQYXRoU3RyaW5nOwogICAgICAgICBWZWN0b3I8U3RyaW5n PiBrZXlQYXRoQXJyYXk7CkBAIC0xNTgsNiArMTUwLDIyIEBAIFBhc3NSZWZQdHI8SURCT2JqZWN0 U3RvcmU+IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUs IGNvCiAgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoQXJyYXkpOwogICAg ICAgICBlbHNlIGlmIChvcHRpb25zLmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVjaygia2V5UGF0 aCIsIGtleVBhdGhTdHJpbmcpKQogICAgICAgICAgICAga2V5UGF0aCA9IElEQktleVBhdGgoa2V5 UGF0aFN0cmluZyk7CisKKyAgICAgICAgb3B0aW9ucy5nZXQoImF1dG9JbmNyZW1lbnQiLCBhdXRv SW5jcmVtZW50KTsKKyAgICB9CisKKyAgICByZXR1cm4gY3JlYXRlT2JqZWN0U3RvcmUobmFtZSwg a2V5UGF0aCwgYXV0b0luY3JlbWVudCwgZWMpOworfQorCitQYXNzUmVmUHRyPElEQk9iamVjdFN0 b3JlPiBJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBJREJLZXlQYXRoJiBrZXlQYXRoLCBib29sIGF1dG9JbmNyZW1lbnQsIEV4Y2VwdGlvbkNv ZGUmIGVjKQoreworICAgIGlmICghbV92ZXJzaW9uQ2hhbmdlVHJhbnNhY3Rpb24pIHsKKyAgICAg ICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6SW52YWxpZFN0YXRlRXJyb3I7CisgICAgICAg IHJldHVybiAwOworICAgIH0KKyAgICBpZiAoIW1fdmVyc2lvbkNoYW5nZVRyYW5zYWN0aW9uLT5p c0FjdGl2ZSgpKSB7CisgICAgICAgIGVjID0gSURCRGF0YWJhc2VFeGNlcHRpb246OlRyYW5zYWN0 aW9uSW5hY3RpdmVFcnJvcjsKKyAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCiAgICAgaWYgKGNv bnRhaW5zT2JqZWN0U3RvcmUobmFtZSkpIHsKQEAgLTE3MCwxMCArMTc4LDYgQEAgUGFzc1JlZlB0 cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0 cmluZyYgbmFtZSwgY28KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgYm9vbCBhdXRv SW5jcmVtZW50ID0gZmFsc2U7Ci0gICAgaWYgKCFvcHRpb25zLmlzVW5kZWZpbmVkT3JOdWxsKCkp Ci0gICAgICAgIG9wdGlvbnMuZ2V0KCJhdXRvSW5jcmVtZW50IiwgYXV0b0luY3JlbWVudCk7Ci0K ICAgICBpZiAoYXV0b0luY3JlbWVudCAmJiAoKGtleVBhdGgudHlwZSgpID09IElEQktleVBhdGg6 OlN0cmluZ1R5cGUgJiYga2V5UGF0aC5zdHJpbmcoKS5pc0VtcHR5KCkpIHx8IGtleVBhdGgudHlw ZSgpID09IElEQktleVBhdGg6OkFycmF5VHlwZSkpIHsKICAgICAgICAgZWMgPSBJREJEYXRhYmFz ZUV4Y2VwdGlvbjo6SW52YWxpZEFjY2Vzc0Vycm9yOwogICAgICAgICByZXR1cm4gMDsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmggYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oCmluZGV4IDFjOTc3 OTYuLmE5YzRjNWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQkRhdGFiYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURC RGF0YWJhc2UuaApAQCAtNjUsNiArNjUsNyBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxET01T dHJpbmdMaXN0PiBvYmplY3RTdG9yZU5hbWVzKCkgY29uc3Q7CiAKICAgICBQYXNzUmVmUHRyPElE Qk9iamVjdFN0b3JlPiBjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IERpY3Rpb25hcnkmLCBFeGNlcHRpb25Db2RlJik7CisgICAgUGFzc1JlZlB0cjxJREJPYmplY3RT dG9yZT4gY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJREJLZXlQ YXRoJiwgYm9vbCBhdXRvSW5jcmVtZW50LCBFeGNlcHRpb25Db2RlJik7CiAgICAgUGFzc1JlZlB0 cjxJREJUcmFuc2FjdGlvbj4gdHJhbnNhY3Rpb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBzY29wZSwgY29uc3QgU3RyaW5nJiBtb2Rl LCBFeGNlcHRpb25Db2RlJiBlYykgeyByZXR1cm4gdHJhbnNhY3Rpb24oY29udGV4dCwgKnNjb3Bl LCBtb2RlLCBlYyk7IH0KICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uPiB0cmFuc2FjdGlv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgVmVjdG9yPFN0cmluZz4mLCBjb25zdCBT dHJpbmcmIG1vZGUsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0 aW9uPiB0cmFuc2FjdGlvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiwg Y29uc3QgU3RyaW5nJiBtb2RlLCBFeGNlcHRpb25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwKaW5kZXggNTBmN2U2My4uMTM0ODU0 OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJh c2UuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNl LmlkbApAQCAtMzgsNyArMzgsNyBAQAogICAgIGF0dHJpYnV0ZSBFdmVudExpc3RlbmVyIG9uZXJy b3I7CiAgICAgYXR0cmlidXRlIEV2ZW50TGlzdGVuZXIgb252ZXJzaW9uY2hhbmdlOwogCi0gICAg SURCT2JqZWN0U3RvcmUgY3JlYXRlT2JqZWN0U3RvcmUoaW4gRE9NU3RyaW5nIG5hbWUsIGluIFtP cHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtKU0N1c3RvbV0gSURCT2JqZWN0U3Rv cmUgY3JlYXRlT2JqZWN0U3RvcmUoaW4gRE9NU3RyaW5nIG5hbWUsIGluIFtPcHRpb25hbF0gRGlj dGlvbmFyeSBvcHRpb25zKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CiAgICAgdm9p ZCBkZWxldGVPYmplY3RTdG9yZShpbiBET01TdHJpbmcgbmFtZSkKICAgICAgICAgcmFpc2VzIChE T01FeGNlcHRpb24pOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVk ZGIvSURCT2JqZWN0U3RvcmUuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIv SURCT2JqZWN0U3RvcmUuY3BwCmluZGV4IDE4ZTdlYjIuLmZhOWUyOWUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAKQEAgLTM1 NCw2ICszNTQsMTcgQEAgcHJpdmF0ZToKIAogUGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0 U3RvcmU6OmNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0 IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0aCYga2V5UGF0aCwgY29uc3QgRGljdGlvbmFy eSYgb3B0aW9ucywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CisgICAgYm9vbCB1bmlxdWUgPSBmYWxz ZTsKKyAgICBvcHRpb25zLmdldCgidW5pcXVlIiwgdW5pcXVlKTsKKworICAgIGJvb2wgbXVsdGlF bnRyeSA9IGZhbHNlOworICAgIG9wdGlvbnMuZ2V0KCJtdWx0aUVudHJ5IiwgbXVsdGlFbnRyeSk7 CisKKyAgICByZXR1cm4gY3JlYXRlSW5kZXgoY29udGV4dCwgbmFtZSwga2V5UGF0aCwgdW5pcXVl LCBtdWx0aUVudHJ5LCBlYyk7Cit9CisKK1Bhc3NSZWZQdHI8SURCSW5kZXg+IElEQk9iamVjdFN0 b3JlOjpjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgsIGJvb2wgdW5pcXVlLCBib29s IG11bHRpRW50cnksIEV4Y2VwdGlvbkNvZGUmIGVjKQorewogICAgIElEQl9UUkFDRSgiSURCT2Jq ZWN0U3RvcmU6OmNyZWF0ZUluZGV4Iik7CiAgICAgaWYgKCFtX3RyYW5zYWN0aW9uLT5pc1ZlcnNp b25DaGFuZ2UoKSB8fCBtX2RlbGV0ZWQpIHsKICAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2Vw dGlvbjo6SW52YWxpZFN0YXRlRXJyb3I7CkBAIC0zNzYsMTIgKzM4Nyw2IEBAIFBhc3NSZWZQdHI8 SURCSW5kZXg+IElEQk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBjb250ZXh0CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIGJvb2wgdW5pcXVl ID0gZmFsc2U7Ci0gICAgb3B0aW9ucy5nZXQoInVuaXF1ZSIsIHVuaXF1ZSk7Ci0KLSAgICBib29s IG11bHRpRW50cnkgPSBmYWxzZTsKLSAgICBvcHRpb25zLmdldCgibXVsdGlFbnRyeSIsIG11bHRp RW50cnkpOwotCiAgICAgaWYgKGtleVBhdGgudHlwZSgpID09IElEQktleVBhdGg6OkFycmF5VHlw ZSAmJiBtdWx0aUVudHJ5KSB7CiAgICAgICAgIGVjID0gSURCRGF0YWJhc2VFeGNlcHRpb246Oklu dmFsaWRBY2Nlc3NFcnJvcjsKICAgICAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaAppbmRleCBkY2I5OTgxLi5mY2I0 Mzc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmpl Y3RTdG9yZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVj dFN0b3JlLmgKQEAgLTg0LDcgKzg0LDggQEAgcHVibGljOgogCiAgICAgUGFzc1JlZlB0cjxJREJJ bmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3Qg U3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGNvbnN0IERpY3Rpb25hcnkmIG9w dGlvbnMsIEV4Y2VwdGlvbkNvZGUmIGVjKSB7IHJldHVybiBjcmVhdGVJbmRleChjb250ZXh0LCBu YW1lLCBJREJLZXlQYXRoKGtleVBhdGgpLCBvcHRpb25zLCBlYyk7IH0KICAgICBQYXNzUmVmUHRy PElEQkluZGV4PiBjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFZlY3RvcjxTdHJpbmc+JiBrZXlQYXRoLCBjb25zdCBE aWN0aW9uYXJ5JiBvcHRpb25zLCBFeGNlcHRpb25Db2RlJiBlYykgeyByZXR1cm4gY3JlYXRlSW5k ZXgoY29udGV4dCwgbmFtZSwgSURCS2V5UGF0aChrZXlQYXRoKSwgb3B0aW9ucywgZWMpOyB9Ci0g ICAgUGFzc1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IElEQktleVBhdGgmLCBjb25zdCBEaWN0aW9uYXJ5Jiwg RXhjZXB0aW9uQ29kZSYpOworICAgIFBhc3NSZWZQdHI8SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBh dGgmLCBjb25zdCBEaWN0aW9uYXJ5JiwgRXhjZXB0aW9uQ29kZSYpOworICAgIFBhc3NSZWZQdHI8 SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmLCBib29sIHVuaXF1ZSwgYm9vbCBtdWx0aUVudHJ5 LCBFeGNlcHRpb25Db2RlJik7CiAKICAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBpbmRleChjb25z dCBTdHJpbmcmIG5hbWUsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIGRlbGV0ZUluZGV4KGNv bnN0IFN0cmluZyYgbmFtZSwgRXhjZXB0aW9uQ29kZSYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsCmluZGV4IDM5NjQyYzIuLjNk MjhlOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9i amVjdFN0b3JlLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwKQEAgLTUyLDkgKzUyLDkgQEAKICAgICBbQ2FsbFdpdGg9U2NyaXB0RXhl Y3V0aW9uQ29udGV4dF0gSURCUmVxdWVzdCBvcGVuQ3Vyc29yKGluIElEQktleSBrZXksIGluIFtP cHRpb25hbF0gRE9NU3RyaW5nIGRpcmVjdGlvbikKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRp b24pOwogCi0gICAgW0NhbGxXaXRoPVNjcmlwdEV4ZWN1dGlvbkNvbnRleHRdIElEQkluZGV4IGNy ZWF0ZUluZGV4KGluIERPTVN0cmluZyBuYW1lLCBpbiBzZXF1ZW5jZTxET01TdHJpbmc+IGtleVBh dGgsIGluIFtPcHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtDYWxsV2l0aD1TY3Jp cHRFeGVjdXRpb25Db250ZXh0LCBKU0N1c3RvbV0gSURCSW5kZXggY3JlYXRlSW5kZXgoaW4gRE9N U3RyaW5nIG5hbWUsIGluIHNlcXVlbmNlPERPTVN0cmluZz4ga2V5UGF0aCwgaW4gW09wdGlvbmFs XSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAgIHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKLSAg ICBbQ2FsbFdpdGg9U2NyaXB0RXhlY3V0aW9uQ29udGV4dF0gSURCSW5kZXggY3JlYXRlSW5kZXgo aW4gRE9NU3RyaW5nIG5hbWUsIGluIERPTVN0cmluZyBrZXlQYXRoLCBpbiBbT3B0aW9uYWxdIERp Y3Rpb25hcnkgb3B0aW9ucykKKyAgICBbQ2FsbFdpdGg9U2NyaXB0RXhlY3V0aW9uQ29udGV4dCwg SlNDdXN0b21dIElEQkluZGV4IGNyZWF0ZUluZGV4KGluIERPTVN0cmluZyBuYW1lLCBpbiBET01T dHJpbmcga2V5UGF0aCwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAg IHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKICAgICBJREJJbmRleCBpbmRleChpbiBET01TdHJpbmcg bmFtZSkKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvVXNlSlNDLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlCmluZGV4 IDg5ZmY4Y2IuLmQzMDRmYjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFr ZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKQEAgLTIwMiw3ICsyMDIsOSBAQCBp ZiAoRU5BQkxFX0lOREVYRURfREFUQUJBU0UpCiAgICAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VS Q0VTCiAgICAgICAgIGJpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCiAgICAgICAg IGJpbmRpbmdzL2pzL0pTSURCQW55Q3VzdG9tLmNwcAorICAgICAgICBiaW5kaW5ncy9qcy9KU0lE QkRhdGFiYXNlQ3VzdG9tLmNwcAogICAgICAgICBiaW5kaW5ncy9qcy9KU0lEQktleUN1c3RvbS5j cHAKKyAgICAgICAgYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAKICAgICAp CiBlbmRpZiAoKQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJC aW5kaW5nVXRpbGl0aWVzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRp bmdVdGlsaXRpZXMuY3BwCmluZGV4IGVmODE5ZmMuLjM0Yzc3YmYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCkBAIC0xMTgsNiAr MTE4LDE2IEBAIFBhc3NSZWZQdHI8SURCS2V5PiBjcmVhdGVJREJLZXlGcm9tVmFsdWUoRXhlY1N0 YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlKQogICAgIHJldHVybiBJREJLZXk6OmNyZWF0ZUludmFs aWQoKTsKIH0KIAorSURCS2V5UGF0aCBpZGJLZXlQYXRoRnJvbVZhbHVlKEV4ZWNTdGF0ZSogZXhl YywgSlNWYWx1ZSBrZXlQYXRoVmFsdWUpCit7CisgICAgSURCS2V5UGF0aCBrZXlQYXRoOworICAg IGlmIChpc0pTQXJyYXkoa2V5UGF0aFZhbHVlKSkKKyAgICAgICAga2V5UGF0aCA9IElEQktleVBh dGgodG9OYXRpdmVBcnJheTxTdHJpbmc+KGV4ZWMsIGtleVBhdGhWYWx1ZSkpOworICAgIGVsc2UK KyAgICAgICAga2V5UGF0aCA9IElEQktleVBhdGgoa2V5UGF0aFZhbHVlLnRvU3RyaW5nKGV4ZWMp LT52YWx1ZShleGVjKSk7CisgICAgcmV0dXJuIGtleVBhdGg7Cit9CisKIHN0YXRpYyBKU1ZhbHVl IGdldE50aFZhbHVlT25LZXlQYXRoKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSByb290VmFsdWUs IGNvbnN0IFZlY3RvcjxTdHJpbmc+JiBrZXlQYXRoRWxlbWVudHMsIHNpemVfdCBpbmRleCkKIHsK ICAgICBKU1ZhbHVlIGN1cnJlbnRWYWx1ZShyb290VmFsdWUpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oCmluZGV4IDZlODI4OGUuLjk5Nzhj YzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGls aXRpZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0 aWVzLmgKQEAgLTQwLDYgKzQwLDggQEAgY2xhc3MgSURCS2V5UGF0aDsKIAogUGFzc1JlZlB0cjxJ REJLZXk+IGNyZWF0ZUlEQktleUZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1 ZSk7CiAKK0lEQktleVBhdGggaWRiS2V5UGF0aEZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpT Qzo6SlNWYWx1ZSk7CisKIGJvb2wgaW5qZWN0SURCS2V5SW50b1NjcmlwdFZhbHVlKERPTVJlcXVl c3RTdGF0ZSosIFBhc3NSZWZQdHI8SURCS2V5PiwgU2NyaXB0VmFsdWUmLCBjb25zdCBJREJLZXlQ YXRoJik7CiBQYXNzUmVmUHRyPElEQktleT4gY3JlYXRlSURCS2V5RnJvbVNjcmlwdFZhbHVlQW5k S2V5UGF0aChET01SZXF1ZXN0U3RhdGUqLCBjb25zdCBTY3JpcHRWYWx1ZSYsIGNvbnN0IElEQktl eVBhdGgmKTsKIGJvb2wgY2FuSW5qZWN0SURCS2V5SW50b1NjcmlwdFZhbHVlKERPTVJlcXVlc3RT dGF0ZSosIGNvbnN0IFNjcmlwdFZhbHVlJiwgY29uc3QgSURCS2V5UGF0aCYpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40OGQ1YzUwCi0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKQEAgLTAs MCArMSw4OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBNaWNoYWVsIFBydWV0dCA8bWlj aGFlbEA2OGsub3JnPgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKKworI2luY2x1ZGUgIkpTSURCRGF0 YWJhc2UuaCIKKworI2luY2x1ZGUgIklEQkJpbmRpbmdVdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJJ REJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIklEQktleVBhdGguaCIKKyNpbmNsdWRlICJJREJPYmpl Y3RTdG9yZS5oIgorI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKworI2luY2x1ZGUgPHJ1 bnRpbWUvRXJyb3IuaD4KKyNpbmNsdWRlIDxydW50aW1lL0pTQXJyYXkuaD4KKyNpbmNsdWRlIDxy dW50aW1lL0pTU3RyaW5nLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworSlNWYWx1ZSBKU0lEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShKU0M6 OkV4ZWNTdGF0ZSogZXhlYykKK3sKKyAgICBpZiAoZXhlYy0+YXJndW1lbnRDb3VudCgpIDwgMSkK KyAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoZXhlYywgY3JlYXRlTm90RW5vdWdoQXJndW1lbnRz RXJyb3IoZXhlYykpOworICAgIFN0cmluZyBuYW1lID0gZXhlYy0+YXJndW1lbnQoMCkudG9TdHJp bmcoZXhlYyktPnZhbHVlKGV4ZWMpOworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAg ICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG9wdGlvbnNWYWx1ZSA9 IGV4ZWMtPmFyZ3VtZW50KDEpOworICAgIGlmICghb3B0aW9uc1ZhbHVlLmlzVW5kZWZpbmVkT3JO dWxsKCkgJiYgIW9wdGlvbnNWYWx1ZS5pc09iamVjdCgpKQorICAgICAgICByZXR1cm4gdGhyb3dU eXBlRXJyb3IoZXhlYywgIk5vdCBhbiBvYmplY3QuIik7CisKKyAgICBJREJLZXlQYXRoIGtleVBh dGg7CisgICAgYm9vbCBhdXRvSW5jcmVtZW50ID0gZmFsc2U7CisgICAgaWYgKG9wdGlvbnNWYWx1 ZS5pc09iamVjdCgpKSB7CisgICAgICAgIEpTVmFsdWUga2V5UGF0aFZhbHVlID0gb3B0aW9uc1Zh bHVlLmdldChleGVjLCBJZGVudGlmaWVyKGV4ZWMsICJrZXlQYXRoIikpOworICAgICAgICBpZiAo ZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsK KworICAgICAgICBpZiAoIWtleVBhdGhWYWx1ZS5pc1VuZGVmaW5lZE9yTnVsbCgpKQorICAgICAg ICAgICAga2V5UGF0aCA9IGlkYktleVBhdGhGcm9tVmFsdWUoZXhlYywga2V5UGF0aFZhbHVlKTsK KworICAgICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgICAgICByZXR1cm4g anNVbmRlZmluZWQoKTsKKworICAgICAgICBKU1ZhbHVlIGF1dG9JbmNyZW1lbnRWYWx1ZSA9IG9w dGlvbnNWYWx1ZS5nZXQoZXhlYywgSWRlbnRpZmllcihleGVjLCAiYXV0b0luY3JlbWVudCIpKTsK KyAgICAgICAgYXV0b0luY3JlbWVudCA9IGF1dG9JbmNyZW1lbnRWYWx1ZS50b0Jvb2xlYW4oZXhl Yyk7CisKKyAgICAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICAgICAgcmV0 dXJuIGpzVW5kZWZpbmVkKCk7CisgICAgfQorCisgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7Cisg ICAgSlNWYWx1ZSByZXN1bHQgPSB0b0pTKGV4ZWMsIGdsb2JhbE9iamVjdCgpLCBpbXBsKCktPmNy ZWF0ZU9iamVjdFN0b3JlKG5hbWUsIGtleVBhdGgsIGF1dG9JbmNyZW1lbnQsIGVjKS5nZXQoKSk7 CisgICAgc2V0RE9NRXhjZXB0aW9uKGV4ZWMsIGVjKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQor Cit9CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJ REJPYmplY3RTdG9yZUN1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lE Qk9iamVjdFN0b3JlQ3VzdG9tLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5jMzVhODc3Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMv SlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMiBNaWNoYWVsIFBydWV0dCA8bWljaGFlbEA2OGsub3JnPgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhP TERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICog QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRI RSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywg UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us CisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoSU5ERVhF RF9EQVRBQkFTRSkKKworI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKworI2luY2x1ZGUg IklEQkJpbmRpbmdVdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJJREJLZXlQYXRoLmgiCisjaW5jbHVk ZSAiSURCT2JqZWN0U3RvcmUuaCIKKyNpbmNsdWRlICJKU0lEQkluZGV4LmgiCisKKyNpbmNsdWRl IDxydW50aW1lL0Vycm9yLmg+CisjaW5jbHVkZSA8cnVudGltZS9KU0FycmF5Lmg+CisjaW5jbHVk ZSA8cnVudGltZS9KU1N0cmluZy5oPgorCit1c2luZyBuYW1lc3BhY2UgSlNDOworCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK0pTVmFsdWUgSlNJREJPYmplY3RTdG9yZTo6Y3JlYXRlSW5kZXgoSlND OjpFeGVjU3RhdGUqIGV4ZWMpCit7CisgICAgU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4 dCA9IGpzQ2FzdDxKU0RPTUdsb2JhbE9iamVjdCo+KGV4ZWMtPmxleGljYWxHbG9iYWxPYmplY3Qo KSktPnNjcmlwdEV4ZWN1dGlvbkNvbnRleHQoKTsKKyAgICBpZiAoIWNvbnRleHQpCisgICAgICAg IHJldHVybiB0aHJvd0Vycm9yKGV4ZWMsIGNyZWF0ZVJlZmVyZW5jZUVycm9yKGV4ZWMsICJJREJP YmplY3RTdG9yZSBzY3JpcHQgZXhlY3V0aW9uIGNvbnRleHQgaXMgdW5hdmFpbGFibGUiKSk7CisK KyAgICBpZiAoZXhlYy0+YXJndW1lbnRDb3VudCgpIDwgMikKKyAgICAgICAgcmV0dXJuIHRocm93 RXJyb3IoZXhlYywgY3JlYXRlTm90RW5vdWdoQXJndW1lbnRzRXJyb3IoZXhlYykpOworCisgICAg U3RyaW5nIG5hbWUgPSBleGVjLT5hcmd1bWVudCgwKS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhl Yyk7CisgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICByZXR1cm4ganNVbmRl ZmluZWQoKTsKKworICAgIElEQktleVBhdGgga2V5UGF0aCA9IGlkYktleVBhdGhGcm9tVmFsdWUo ZXhlYywgZXhlYy0+YXJndW1lbnQoMSkpOworICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkK KyAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICBKU1ZhbHVlIG9wdGlvbnNWYWx1 ZSA9IGV4ZWMtPmFyZ3VtZW50KDIpOworICAgIGlmICghb3B0aW9uc1ZhbHVlLmlzVW5kZWZpbmVk T3JOdWxsKCkgJiYgIW9wdGlvbnNWYWx1ZS5pc09iamVjdCgpKQorICAgICAgICByZXR1cm4gdGhy b3dUeXBlRXJyb3IoZXhlYywgIk5vdCBhbiBvYmplY3QuIik7CisKKyAgICBib29sIHVuaXF1ZSA9 IGZhbHNlOworICAgIGJvb2wgbXVsdGlFbnRyeSA9IGZhbHNlOworICAgIGlmIChvcHRpb25zVmFs dWUuaXNPYmplY3QoKSkgeworICAgICAgICBKU1ZhbHVlIHVuaXF1ZVZhbHVlID0gb3B0aW9uc1Zh bHVlLmdldChleGVjLCBJZGVudGlmaWVyKGV4ZWMsICJ1bmlxdWUiKSk7CisgICAgICAgIHVuaXF1 ZSA9IHVuaXF1ZVZhbHVlLnRvQm9vbGVhbihleGVjKTsKKyAgICAgICAgaWYgKGV4ZWMtPmhhZEV4 Y2VwdGlvbigpKQorICAgICAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7CisKKyAgICAgICAg SlNWYWx1ZSBtdWx0aUVudHJ5VmFsdWUgPSBvcHRpb25zVmFsdWUuZ2V0KGV4ZWMsIElkZW50aWZp ZXIoZXhlYywgIm11bHRpRW50cnkiKSk7CisgICAgICAgIG11bHRpRW50cnkgPSBtdWx0aUVudHJ5 VmFsdWUudG9Cb29sZWFuKGV4ZWMpOworICAgICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkp CisgICAgICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsKKyAgICB9CisKKyAgICBFeGNlcHRp b25Db2RlIGVjID0gMDsKKyAgICBKU1ZhbHVlIHJlc3VsdCA9IHRvSlMoZXhlYywgZ2xvYmFsT2Jq ZWN0KCksIGltcGwoKS0+Y3JlYXRlSW5kZXgoY29udGV4dCwgbmFtZSwga2V5UGF0aCwgdW5pcXVl LCBtdWx0aUVudHJ5LCBlYykuZ2V0KCkpOworICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7 CisgICAgcmV0dXJuIHJlc3VsdDsKK30KKworfQorCisjZW5kaWYKLS0gCjEuNy45LjUKCg== 179456 2012-12-14 02:41:18 -0800 2012-12-18 16:11:26 -0800 Patch idb-options.patch text/plain 20383 michael RnJvbTogTWljaGFlbCBQcnVldHQgPG1pY2hhZWxANjhrLm9yZz4KRGF0ZTogRnJpLCAxNCBEZWMg MjAxMiAwMjoyNzo1OCAtMDgwMApTdWJqZWN0OiBJbmRleGVkREI6IEltcGxlbWVudCBjdXN0b20g YmluZGluZ3MgZm9yIHBhcnNpbmcgb3B0aW9ucwoKLS0tCiBTb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMzggKysrKysrKysrCiBTb3VyY2UvV2Vi Q29yZS9HTlVtYWtlZmlsZS5saXN0LmFtICAgICAgICAgICAgICAgICB8ICAgIDIgKwogU291cmNl L1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwICAgfCAgIDMwICsrKyst LS0KIFNvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmggICAgIHwg ICAgMSArCiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwg ICB8ICAgIDIgKy0KIC4uLi9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3Jl LmNwcCAgIHwgICAxNyArKy0tCiBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5oICB8ICAgIDMgKy0KIC4uLi9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lE Qk9iamVjdFN0b3JlLmlkbCAgIHwgICAgNCArLQogU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtl ICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICsKIFNvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwIHwgICAxMCArKysKIFNvdXJjZS9XZWJDb3JlL2Jp bmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuaCAgIHwgICAgMiArCiBTb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9qcy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcCB8ICAgODUgKysrKysrKysrKysr KysrKysrKwogLi4uL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5j cHAgfCAgIDg2ICsrKysrKysrKysrKysrKysrKysrCiAxMyBmaWxlcyBjaGFuZ2VkLCAyNTkgaW5z ZXJ0aW9ucygrKSwgMjMgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgU291cmNlL1dl YkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKIGNyZWF0ZSBtb2RlIDEw MDY0NCBTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQk9iamVjdFN0b3JlQ3VzdG9tLmNw cAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCBiZjEyN2ZmLi4yZjliY2FkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEs NDEgQEAKKzIwMTItMTItMTQgIE1pY2hhZWwgUHJ1ZXR0ICA8bWljaGFlbEA2OGsub3JnPgorCisg ICAgICAgIEluZGV4ZWREQjogSW1wbGVtZW50IGN1c3RvbSBiaW5kaW5ncyBmb3IgcGFyc2luZyBv cHRpb25zCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05 NjYxNAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFBh cnNpbmcgdGhlIG9wdGlvbnMgZGljdGlvbmFyeSBpbiBJREJEYXRhYmFzZS5jcmVhdGVPYmplY3RT dG9yZSgpCisgICAgICAgIGFuZCBJREJPYmplY3RTdG9yZS5jcmVhdGVJbmRleCgpIHJlcXVpcmVz IGN1c3RvbSBiaW5kaW5ncyBpbiBKU0MuCisKKyAgICAgICAgVGVzdHM6IHN0b3JhZ2UvaW5kZXhl ZGRiLyoKKworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogTW9kdWxl cy9pbmRleGVkZGIvSURCRGF0YWJhc2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SURCRGF0YWJh c2U6OmNyZWF0ZU9iamVjdFN0b3JlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIE1v ZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmg6CisgICAgICAgIChJREJEYXRhYmFzZSk6Cisg ICAgICAgICogTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJhc2UuaWRsOgorICAgICAgICAqIE1v ZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OklE Qk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAg KiBNb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oOgorICAgICAgICAoSURCT2JqZWN0 U3RvcmUpOgorICAgICAgICAqIE1vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmlkbDoK KyAgICAgICAgKiBVc2VKU0MuY21ha2U6CisgICAgICAgICogYmluZGluZ3MvanMvSURCQmluZGlu Z1V0aWxpdGllcy5jcHA6CisgICAgICAgIChXZWJDb3JlOjppZGJLZXlQYXRoRnJvbVZhbHVlKTog QWRkZWQgdXRpbGl0eSBmdW5jdGlvbiBmb3IgY29udmVydGluZyBhIEpTVmFsdWUgdG8gYW4gSURC S2V5UGF0aC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGJpbmRpbmdzL2pzL0lEQkJp bmRpbmdVdGlsaXRpZXMuaDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGJpbmRpbmdz L2pzL0pTSURCRGF0YWJhc2VDdXN0b20uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgor ICAgICAgICAoV2ViQ29yZTo6SlNJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUpOgorICAg ICAgICAqIGJpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0b20uY3BwOiBBZGRlZC4KKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6SlNJREJPYmplY3RTdG9yZTo6Y3Jl YXRlSW5kZXgpOgorCiAyMDEyLTEyLTExICBNaWNoYWVsIFBydWV0dCAgPG1pY2hhZWxANjhrLm9y Zz4KIAogICAgICAgICBJbmRleGVkREI6IERvbid0IHVzZSBzdHJpbmdzIHRvIHJlcHJlc2VudCBz ZXJpYWxpemVkIHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUu bGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KaW5kZXggMzYzNTcw NS4uYzk1OTY2MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5h bQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCkBAIC0yMzQ0LDcgKzIz NDQsOSBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pz L0pTSGlzdG9yeUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSGlz dG9yeUN1c3RvbS5oIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQkFueUN1c3Rv bS5jcHAgXAorCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCRGF0YWJhc2VDdXN0b20u Y3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQktleUN1c3RvbS5jcHAgXAor CVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTSURCT2JqZWN0U3RvcmVDdXN0b20uY3BwIFwK IAlTb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0ltYWdlQ29uc3RydWN0b3IuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0ltYWdlQ29uc3RydWN0b3IuaCBcCiAJU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNJbWFnZURhdGFDdXN0b20uY3BwIFwKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmNwcAppbmRleCAxYmQ1Yjg4 Li5lYmRlMGYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9J REJEYXRhYmFzZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURC RGF0YWJhc2UuY3BwCkBAIC0xNDEsMTYgKzE0MSw4IEBAIFBhc3NSZWZQdHI8SURCQW55PiBJREJE YXRhYmFzZTo6dmVyc2lvbigpIGNvbnN0CiAKIFBhc3NSZWZQdHI8SURCT2JqZWN0U3RvcmU+IElE QkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IERp Y3Rpb25hcnkmIG9wdGlvbnMsIEV4Y2VwdGlvbkNvZGUmIGVjKQogewotICAgIGlmICghbV92ZXJz aW9uQ2hhbmdlVHJhbnNhY3Rpb24pIHsKLSAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlv bjo6SW52YWxpZFN0YXRlRXJyb3I7Ci0gICAgICAgIHJldHVybiAwOwotICAgIH0KLSAgICBpZiAo IW1fdmVyc2lvbkNoYW5nZVRyYW5zYWN0aW9uLT5pc0FjdGl2ZSgpKSB7Ci0gICAgICAgIGVjID0g SURCRGF0YWJhc2VFeGNlcHRpb246OlRyYW5zYWN0aW9uSW5hY3RpdmVFcnJvcjsKLSAgICAgICAg cmV0dXJuIDA7Ci0gICAgfQotCiAgICAgSURCS2V5UGF0aCBrZXlQYXRoOworICAgIGJvb2wgYXV0 b0luY3JlbWVudCA9IGZhbHNlOwogICAgIGlmICghb3B0aW9ucy5pc1VuZGVmaW5lZE9yTnVsbCgp KSB7CiAgICAgICAgIFN0cmluZyBrZXlQYXRoU3RyaW5nOwogICAgICAgICBWZWN0b3I8U3RyaW5n PiBrZXlQYXRoQXJyYXk7CkBAIC0xNTgsNiArMTUwLDIyIEBAIFBhc3NSZWZQdHI8SURCT2JqZWN0 U3RvcmU+IElEQkRhdGFiYXNlOjpjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUs IGNvCiAgICAgICAgICAgICBrZXlQYXRoID0gSURCS2V5UGF0aChrZXlQYXRoQXJyYXkpOwogICAg ICAgICBlbHNlIGlmIChvcHRpb25zLmdldFdpdGhVbmRlZmluZWRPck51bGxDaGVjaygia2V5UGF0 aCIsIGtleVBhdGhTdHJpbmcpKQogICAgICAgICAgICAga2V5UGF0aCA9IElEQktleVBhdGgoa2V5 UGF0aFN0cmluZyk7CisKKyAgICAgICAgb3B0aW9ucy5nZXQoImF1dG9JbmNyZW1lbnQiLCBhdXRv SW5jcmVtZW50KTsKKyAgICB9CisKKyAgICByZXR1cm4gY3JlYXRlT2JqZWN0U3RvcmUobmFtZSwg a2V5UGF0aCwgYXV0b0luY3JlbWVudCwgZWMpOworfQorCitQYXNzUmVmUHRyPElEQk9iamVjdFN0 b3JlPiBJREJEYXRhYmFzZTo6Y3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBj b25zdCBJREJLZXlQYXRoJiBrZXlQYXRoLCBib29sIGF1dG9JbmNyZW1lbnQsIEV4Y2VwdGlvbkNv ZGUmIGVjKQoreworICAgIGlmICghbV92ZXJzaW9uQ2hhbmdlVHJhbnNhY3Rpb24pIHsKKyAgICAg ICAgZWMgPSBJREJEYXRhYmFzZUV4Y2VwdGlvbjo6SW52YWxpZFN0YXRlRXJyb3I7CisgICAgICAg IHJldHVybiAwOworICAgIH0KKyAgICBpZiAoIW1fdmVyc2lvbkNoYW5nZVRyYW5zYWN0aW9uLT5p c0FjdGl2ZSgpKSB7CisgICAgICAgIGVjID0gSURCRGF0YWJhc2VFeGNlcHRpb246OlRyYW5zYWN0 aW9uSW5hY3RpdmVFcnJvcjsKKyAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCiAgICAgaWYgKGNv bnRhaW5zT2JqZWN0U3RvcmUobmFtZSkpIHsKQEAgLTE3MCwxMCArMTc4LDYgQEAgUGFzc1JlZlB0 cjxJREJPYmplY3RTdG9yZT4gSURCRGF0YWJhc2U6OmNyZWF0ZU9iamVjdFN0b3JlKGNvbnN0IFN0 cmluZyYgbmFtZSwgY28KICAgICAgICAgcmV0dXJuIDA7CiAgICAgfQogCi0gICAgYm9vbCBhdXRv SW5jcmVtZW50ID0gZmFsc2U7Ci0gICAgaWYgKCFvcHRpb25zLmlzVW5kZWZpbmVkT3JOdWxsKCkp Ci0gICAgICAgIG9wdGlvbnMuZ2V0KCJhdXRvSW5jcmVtZW50IiwgYXV0b0luY3JlbWVudCk7Ci0K ICAgICBpZiAoYXV0b0luY3JlbWVudCAmJiAoKGtleVBhdGgudHlwZSgpID09IElEQktleVBhdGg6 OlN0cmluZ1R5cGUgJiYga2V5UGF0aC5zdHJpbmcoKS5pc0VtcHR5KCkpIHx8IGtleVBhdGgudHlw ZSgpID09IElEQktleVBhdGg6OkFycmF5VHlwZSkpIHsKICAgICAgICAgZWMgPSBJREJEYXRhYmFz ZUV4Y2VwdGlvbjo6SW52YWxpZEFjY2Vzc0Vycm9yOwogICAgICAgICByZXR1cm4gMDsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNlLmggYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5oCmluZGV4IDFjOTc3 OTYuLmE5YzRjNWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRi L0lEQkRhdGFiYXNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURC RGF0YWJhc2UuaApAQCAtNjUsNiArNjUsNyBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxET01T dHJpbmdMaXN0PiBvYmplY3RTdG9yZU5hbWVzKCkgY29uc3Q7CiAKICAgICBQYXNzUmVmUHRyPElE Qk9iamVjdFN0b3JlPiBjcmVhdGVPYmplY3RTdG9yZShjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IERpY3Rpb25hcnkmLCBFeGNlcHRpb25Db2RlJik7CisgICAgUGFzc1JlZlB0cjxJREJPYmplY3RT dG9yZT4gY3JlYXRlT2JqZWN0U3RvcmUoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJREJLZXlQ YXRoJiwgYm9vbCBhdXRvSW5jcmVtZW50LCBFeGNlcHRpb25Db2RlJik7CiAgICAgUGFzc1JlZlB0 cjxJREJUcmFuc2FjdGlvbj4gdHJhbnNhY3Rpb24oU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgUGFzc1JlZlB0cjxET01TdHJpbmdMaXN0PiBzY29wZSwgY29uc3QgU3RyaW5nJiBtb2Rl LCBFeGNlcHRpb25Db2RlJiBlYykgeyByZXR1cm4gdHJhbnNhY3Rpb24oY29udGV4dCwgKnNjb3Bl LCBtb2RlLCBlYyk7IH0KICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0aW9uPiB0cmFuc2FjdGlv bihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgVmVjdG9yPFN0cmluZz4mLCBjb25zdCBT dHJpbmcmIG1vZGUsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICBQYXNzUmVmUHRyPElEQlRyYW5zYWN0 aW9uPiB0cmFuc2FjdGlvbihTY3JpcHRFeGVjdXRpb25Db250ZXh0KiwgY29uc3QgU3RyaW5nJiwg Y29uc3QgU3RyaW5nJiBtb2RlLCBFeGNlcHRpb25Db2RlJik7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJEYXRhYmFzZS5pZGwKaW5kZXggNTBmN2U2My4uMTM0ODU0 OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCRGF0YWJh c2UuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQkRhdGFiYXNl LmlkbApAQCAtMzgsNyArMzgsNyBAQAogICAgIGF0dHJpYnV0ZSBFdmVudExpc3RlbmVyIG9uZXJy b3I7CiAgICAgYXR0cmlidXRlIEV2ZW50TGlzdGVuZXIgb252ZXJzaW9uY2hhbmdlOwogCi0gICAg SURCT2JqZWN0U3RvcmUgY3JlYXRlT2JqZWN0U3RvcmUoaW4gRE9NU3RyaW5nIG5hbWUsIGluIFtP cHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtKU0N1c3RvbV0gSURCT2JqZWN0U3Rv cmUgY3JlYXRlT2JqZWN0U3RvcmUoaW4gRE9NU3RyaW5nIG5hbWUsIGluIFtPcHRpb25hbF0gRGlj dGlvbmFyeSBvcHRpb25zKQogICAgICAgICByYWlzZXMgKERPTUV4Y2VwdGlvbik7CiAgICAgdm9p ZCBkZWxldGVPYmplY3RTdG9yZShpbiBET01TdHJpbmcgbmFtZSkKICAgICAgICAgcmFpc2VzIChE T01FeGNlcHRpb24pOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVk ZGIvSURCT2JqZWN0U3RvcmUuY3BwIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy9pbmRleGVkZGIv SURCT2JqZWN0U3RvcmUuY3BwCmluZGV4IDE4ZTdlYjIuLmZhOWUyOWUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVjdFN0b3JlLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5jcHAKQEAgLTM1 NCw2ICszNTQsMTcgQEAgcHJpdmF0ZToKIAogUGFzc1JlZlB0cjxJREJJbmRleD4gSURCT2JqZWN0 U3RvcmU6OmNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIGNvbnN0 IFN0cmluZyYgbmFtZSwgY29uc3QgSURCS2V5UGF0aCYga2V5UGF0aCwgY29uc3QgRGljdGlvbmFy eSYgb3B0aW9ucywgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CisgICAgYm9vbCB1bmlxdWUgPSBmYWxz ZTsKKyAgICBvcHRpb25zLmdldCgidW5pcXVlIiwgdW5pcXVlKTsKKworICAgIGJvb2wgbXVsdGlF bnRyeSA9IGZhbHNlOworICAgIG9wdGlvbnMuZ2V0KCJtdWx0aUVudHJ5IiwgbXVsdGlFbnRyeSk7 CisKKyAgICByZXR1cm4gY3JlYXRlSW5kZXgoY29udGV4dCwgbmFtZSwga2V5UGF0aCwgdW5pcXVl LCBtdWx0aUVudHJ5LCBlYyk7Cit9CisKK1Bhc3NSZWZQdHI8SURCSW5kZXg+IElEQk9iamVjdFN0 b3JlOjpjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBjb25zdCBT dHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmIGtleVBhdGgsIGJvb2wgdW5pcXVlLCBib29s IG11bHRpRW50cnksIEV4Y2VwdGlvbkNvZGUmIGVjKQorewogICAgIElEQl9UUkFDRSgiSURCT2Jq ZWN0U3RvcmU6OmNyZWF0ZUluZGV4Iik7CiAgICAgaWYgKCFtX3RyYW5zYWN0aW9uLT5pc1ZlcnNp b25DaGFuZ2UoKSB8fCBtX2RlbGV0ZWQpIHsKICAgICAgICAgZWMgPSBJREJEYXRhYmFzZUV4Y2Vw dGlvbjo6SW52YWxpZFN0YXRlRXJyb3I7CkBAIC0zNzYsMTIgKzM4Nyw2IEBAIFBhc3NSZWZQdHI8 SURCSW5kZXg+IElEQk9iamVjdFN0b3JlOjpjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBjb250ZXh0CiAgICAgICAgIHJldHVybiAwOwogICAgIH0KIAotICAgIGJvb2wgdW5pcXVl ID0gZmFsc2U7Ci0gICAgb3B0aW9ucy5nZXQoInVuaXF1ZSIsIHVuaXF1ZSk7Ci0KLSAgICBib29s IG11bHRpRW50cnkgPSBmYWxzZTsKLSAgICBvcHRpb25zLmdldCgibXVsdGlFbnRyeSIsIG11bHRp RW50cnkpOwotCiAgICAgaWYgKGtleVBhdGgudHlwZSgpID09IElEQktleVBhdGg6OkFycmF5VHlw ZSAmJiBtdWx0aUVudHJ5KSB7CiAgICAgICAgIGVjID0gSURCRGF0YWJhc2VFeGNlcHRpb246Oklu dmFsaWRBY2Nlc3NFcnJvcjsKICAgICAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmplY3RTdG9yZS5oIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaAppbmRleCBkY2I5OTgxLi5mY2I0 Mzc5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJPYmpl Y3RTdG9yZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9iamVj dFN0b3JlLmgKQEAgLTg0LDcgKzg0LDggQEAgcHVibGljOgogCiAgICAgUGFzc1JlZlB0cjxJREJJ bmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29udGV4dCwgY29uc3Qg U3RyaW5nJiBuYW1lLCBjb25zdCBTdHJpbmcmIGtleVBhdGgsIGNvbnN0IERpY3Rpb25hcnkmIG9w dGlvbnMsIEV4Y2VwdGlvbkNvZGUmIGVjKSB7IHJldHVybiBjcmVhdGVJbmRleChjb250ZXh0LCBu YW1lLCBJREJLZXlQYXRoKGtleVBhdGgpLCBvcHRpb25zLCBlYyk7IH0KICAgICBQYXNzUmVmUHRy PElEQkluZGV4PiBjcmVhdGVJbmRleChTY3JpcHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBj b25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IFZlY3RvcjxTdHJpbmc+JiBrZXlQYXRoLCBjb25zdCBE aWN0aW9uYXJ5JiBvcHRpb25zLCBFeGNlcHRpb25Db2RlJiBlYykgeyByZXR1cm4gY3JlYXRlSW5k ZXgoY29udGV4dCwgbmFtZSwgSURCS2V5UGF0aChrZXlQYXRoKSwgb3B0aW9ucywgZWMpOyB9Ci0g ICAgUGFzc1JlZlB0cjxJREJJbmRleD4gY3JlYXRlSW5kZXgoU2NyaXB0RXhlY3V0aW9uQ29udGV4 dCosIGNvbnN0IFN0cmluZyYsIGNvbnN0IElEQktleVBhdGgmLCBjb25zdCBEaWN0aW9uYXJ5Jiwg RXhjZXB0aW9uQ29kZSYpOworICAgIFBhc3NSZWZQdHI8SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElEQktleVBh dGgmLCBjb25zdCBEaWN0aW9uYXJ5JiwgRXhjZXB0aW9uQ29kZSYpOworICAgIFBhc3NSZWZQdHI8 SURCSW5kZXg+IGNyZWF0ZUluZGV4KFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQqLCBjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IElEQktleVBhdGgmLCBib29sIHVuaXF1ZSwgYm9vbCBtdWx0aUVudHJ5 LCBFeGNlcHRpb25Db2RlJik7CiAKICAgICBQYXNzUmVmUHRyPElEQkluZGV4PiBpbmRleChjb25z dCBTdHJpbmcmIG5hbWUsIEV4Y2VwdGlvbkNvZGUmKTsKICAgICB2b2lkIGRlbGV0ZUluZGV4KGNv bnN0IFN0cmluZyYgbmFtZSwgRXhjZXB0aW9uQ29kZSYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy9pbmRleGVkZGIvSURCT2JqZWN0U3RvcmUuaWRsCmluZGV4IDM5NjQyYzIuLjNk MjhlOWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvaW5kZXhlZGRiL0lEQk9i amVjdFN0b3JlLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL2luZGV4ZWRkYi9JREJP YmplY3RTdG9yZS5pZGwKQEAgLTUyLDkgKzUyLDkgQEAKICAgICBbQ2FsbFdpdGg9U2NyaXB0RXhl Y3V0aW9uQ29udGV4dF0gSURCUmVxdWVzdCBvcGVuQ3Vyc29yKGluIElEQktleSBrZXksIGluIFtP cHRpb25hbF0gRE9NU3RyaW5nIGRpcmVjdGlvbikKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRp b24pOwogCi0gICAgW0NhbGxXaXRoPVNjcmlwdEV4ZWN1dGlvbkNvbnRleHRdIElEQkluZGV4IGNy ZWF0ZUluZGV4KGluIERPTVN0cmluZyBuYW1lLCBpbiBzZXF1ZW5jZTxET01TdHJpbmc+IGtleVBh dGgsIGluIFtPcHRpb25hbF0gRGljdGlvbmFyeSBvcHRpb25zKQorICAgIFtDYWxsV2l0aD1TY3Jp cHRFeGVjdXRpb25Db250ZXh0LCBKU0N1c3RvbV0gSURCSW5kZXggY3JlYXRlSW5kZXgoaW4gRE9N U3RyaW5nIG5hbWUsIGluIHNlcXVlbmNlPERPTVN0cmluZz4ga2V5UGF0aCwgaW4gW09wdGlvbmFs XSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAgIHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKLSAg ICBbQ2FsbFdpdGg9U2NyaXB0RXhlY3V0aW9uQ29udGV4dF0gSURCSW5kZXggY3JlYXRlSW5kZXgo aW4gRE9NU3RyaW5nIG5hbWUsIGluIERPTVN0cmluZyBrZXlQYXRoLCBpbiBbT3B0aW9uYWxdIERp Y3Rpb25hcnkgb3B0aW9ucykKKyAgICBbQ2FsbFdpdGg9U2NyaXB0RXhlY3V0aW9uQ29udGV4dCwg SlNDdXN0b21dIElEQkluZGV4IGNyZWF0ZUluZGV4KGluIERPTVN0cmluZyBuYW1lLCBpbiBET01T dHJpbmcga2V5UGF0aCwgaW4gW09wdGlvbmFsXSBEaWN0aW9uYXJ5IG9wdGlvbnMpCiAgICAgICAg IHJhaXNlcyAoRE9NRXhjZXB0aW9uKTsKICAgICBJREJJbmRleCBpbmRleChpbiBET01TdHJpbmcg bmFtZSkKICAgICAgICAgcmFpc2VzIChET01FeGNlcHRpb24pOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvVXNlSlNDLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlCmluZGV4 IDg5ZmY4Y2IuLmQzMDRmYjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFr ZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKQEAgLTIwMiw3ICsyMDIsOSBAQCBp ZiAoRU5BQkxFX0lOREVYRURfREFUQUJBU0UpCiAgICAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VS Q0VTCiAgICAgICAgIGJpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCiAgICAgICAg IGJpbmRpbmdzL2pzL0pTSURCQW55Q3VzdG9tLmNwcAorICAgICAgICBiaW5kaW5ncy9qcy9KU0lE QkRhdGFiYXNlQ3VzdG9tLmNwcAogICAgICAgICBiaW5kaW5ncy9qcy9KU0lEQktleUN1c3RvbS5j cHAKKyAgICAgICAgYmluZGluZ3MvanMvSlNJREJPYmplY3RTdG9yZUN1c3RvbS5jcHAKICAgICAp CiBlbmRpZiAoKQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJC aW5kaW5nVXRpbGl0aWVzLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRp bmdVdGlsaXRpZXMuY3BwCmluZGV4IGVmODE5ZmMuLjM0Yzc3YmYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGlsaXRpZXMuY3BwCkBAIC0xMTgsNiAr MTE4LDE2IEBAIFBhc3NSZWZQdHI8SURCS2V5PiBjcmVhdGVJREJLZXlGcm9tVmFsdWUoRXhlY1N0 YXRlKiBleGVjLCBKU1ZhbHVlIHZhbHVlKQogICAgIHJldHVybiBJREJLZXk6OmNyZWF0ZUludmFs aWQoKTsKIH0KIAorSURCS2V5UGF0aCBpZGJLZXlQYXRoRnJvbVZhbHVlKEV4ZWNTdGF0ZSogZXhl YywgSlNWYWx1ZSBrZXlQYXRoVmFsdWUpCit7CisgICAgSURCS2V5UGF0aCBrZXlQYXRoOworICAg IGlmIChpc0pTQXJyYXkoa2V5UGF0aFZhbHVlKSkKKyAgICAgICAga2V5UGF0aCA9IElEQktleVBh dGgodG9OYXRpdmVBcnJheTxTdHJpbmc+KGV4ZWMsIGtleVBhdGhWYWx1ZSkpOworICAgIGVsc2UK KyAgICAgICAga2V5UGF0aCA9IElEQktleVBhdGgoa2V5UGF0aFZhbHVlLnRvU3RyaW5nKGV4ZWMp LT52YWx1ZShleGVjKSk7CisgICAgcmV0dXJuIGtleVBhdGg7Cit9CisKIHN0YXRpYyBKU1ZhbHVl IGdldE50aFZhbHVlT25LZXlQYXRoKEV4ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSByb290VmFsdWUs IGNvbnN0IFZlY3RvcjxTdHJpbmc+JiBrZXlQYXRoRWxlbWVudHMsIHNpemVfdCBpbmRleCkKIHsK ICAgICBKU1ZhbHVlIGN1cnJlbnRWYWx1ZShyb290VmFsdWUpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvanMvSURCQmluZGluZ1V0aWxpdGllcy5oCmluZGV4IDZlODI4OGUuLjk5Nzhj YzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0lEQkJpbmRpbmdVdGls aXRpZXMuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9JREJCaW5kaW5nVXRpbGl0 aWVzLmgKQEAgLTQwLDYgKzQwLDggQEAgY2xhc3MgSURCS2V5UGF0aDsKIAogUGFzc1JlZlB0cjxJ REJLZXk+IGNyZWF0ZUlEQktleUZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpTQzo6SlNWYWx1 ZSk7CiAKK0lEQktleVBhdGggaWRiS2V5UGF0aEZyb21WYWx1ZShKU0M6OkV4ZWNTdGF0ZSosIEpT Qzo6SlNWYWx1ZSk7CisKIGJvb2wgaW5qZWN0SURCS2V5SW50b1NjcmlwdFZhbHVlKERPTVJlcXVl c3RTdGF0ZSosIFBhc3NSZWZQdHI8SURCS2V5PiwgU2NyaXB0VmFsdWUmLCBjb25zdCBJREJLZXlQ YXRoJik7CiBQYXNzUmVmUHRyPElEQktleT4gY3JlYXRlSURCS2V5RnJvbVNjcmlwdFZhbHVlQW5k S2V5UGF0aChET01SZXF1ZXN0U3RhdGUqLCBjb25zdCBTY3JpcHRWYWx1ZSYsIGNvbnN0IElEQktl eVBhdGgmKTsKIGJvb2wgY2FuSW5qZWN0SURCS2V5SW50b1NjcmlwdFZhbHVlKERPTVJlcXVlc3RT dGF0ZSosIGNvbnN0IFNjcmlwdFZhbHVlJiwgY29uc3QgSURCS2V5UGF0aCYpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQkRhdGFiYXNlQ3VzdG9tLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGRjMzRmCi0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJEYXRhYmFzZUN1c3RvbS5jcHAKQEAgLTAs MCArMSw4NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBNaWNoYWVsIFBydWV0dCA8bWlj aGFlbEA2OGsub3JnPgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElT IiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJV VE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICog U1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBP UiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVT UyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBM SUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQK KyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmln LmgiCisKKyNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFTRSkKKworI2luY2x1ZGUgIkpTSURCRGF0 YWJhc2UuaCIKKworI2luY2x1ZGUgIklEQkJpbmRpbmdVdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJJ REJEYXRhYmFzZS5oIgorI2luY2x1ZGUgIklEQktleVBhdGguaCIKKyNpbmNsdWRlICJJREJPYmpl Y3RTdG9yZS5oIgorI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKyNpbmNsdWRlIDxydW50 aW1lL0Vycm9yLmg+CisjaW5jbHVkZSA8cnVudGltZS9KU1N0cmluZy5oPgorCit1c2luZyBuYW1l c3BhY2UgSlNDOworCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0pTVmFsdWUgSlNJREJEYXRhYmFz ZTo6Y3JlYXRlT2JqZWN0U3RvcmUoRXhlY1N0YXRlKiBleGVjKQoreworICAgIGlmIChleGVjLT5h cmd1bWVudENvdW50KCkgPCAxKQorICAgICAgICByZXR1cm4gdGhyb3dFcnJvcihleGVjLCBjcmVh dGVOb3RFbm91Z2hBcmd1bWVudHNFcnJvcihleGVjKSk7CisKKyAgICBTdHJpbmcgbmFtZSA9IGV4 ZWMtPmFyZ3VtZW50KDApLnRvU3RyaW5nKGV4ZWMpLT52YWx1ZShleGVjKTsKKyAgICBpZiAoZXhl Yy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAg SlNWYWx1ZSBvcHRpb25zVmFsdWUgPSBleGVjLT5hcmd1bWVudCgxKTsKKyAgICBpZiAoIW9wdGlv bnNWYWx1ZS5pc1VuZGVmaW5lZE9yTnVsbCgpICYmICFvcHRpb25zVmFsdWUuaXNPYmplY3QoKSkK KyAgICAgICAgcmV0dXJuIHRocm93VHlwZUVycm9yKGV4ZWMsICJOb3QgYW4gb2JqZWN0LiIpOwor CisgICAgSURCS2V5UGF0aCBrZXlQYXRoOworICAgIGJvb2wgYXV0b0luY3JlbWVudCA9IGZhbHNl OworICAgIGlmICghb3B0aW9uc1ZhbHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkpIHsKKyAgICAgICAg SlNWYWx1ZSBrZXlQYXRoVmFsdWUgPSBvcHRpb25zVmFsdWUuZ2V0KGV4ZWMsIElkZW50aWZpZXIo ZXhlYywgImtleVBhdGgiKSk7CisgICAgICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAg ICAgICAgICAgIHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgICAgIGlmICgha2V5UGF0aFZh bHVlLmlzVW5kZWZpbmVkT3JOdWxsKCkpIHsKKyAgICAgICAgICAgIGtleVBhdGggPSBpZGJLZXlQ YXRoRnJvbVZhbHVlKGV4ZWMsIGtleVBhdGhWYWx1ZSk7CisgICAgICAgICAgICBpZiAoZXhlYy0+ aGFkRXhjZXB0aW9uKCkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGpzVW5kZWZpbmVkKCk7Cisg ICAgICAgIH0KKworICAgICAgICBhdXRvSW5jcmVtZW50ID0gb3B0aW9uc1ZhbHVlLmdldChleGVj LCBJZGVudGlmaWVyKGV4ZWMsICJhdXRvSW5jcmVtZW50IikpLnRvQm9vbGVhbihleGVjKTsKKyAg ICAgICAgaWYgKGV4ZWMtPmhhZEV4Y2VwdGlvbigpKQorICAgICAgICAgICAgcmV0dXJuIGpzVW5k ZWZpbmVkKCk7CisgICAgfQorCisgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CisgICAgSlNWYWx1 ZSByZXN1bHQgPSB0b0pTKGV4ZWMsIGdsb2JhbE9iamVjdCgpLCBpbXBsKCktPmNyZWF0ZU9iamVj dFN0b3JlKG5hbWUsIGtleVBhdGgsIGF1dG9JbmNyZW1lbnQsIGVjKS5nZXQoKSk7CisgICAgc2V0 RE9NRXhjZXB0aW9uKGV4ZWMsIGVjKTsKKyAgICByZXR1cm4gcmVzdWx0OworfQorCit9CisKKyNl bmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmplY3RT dG9yZUN1c3RvbS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU0lEQk9iamVjdFN0 b3JlQ3VzdG9tLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NGM5ZDYw Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNJREJPYmpl Y3RTdG9yZUN1c3RvbS5jcHAKQEAgLTAsMCArMSw4NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykg MjAxMiBNaWNoYWVsIFBydWV0dCA8bWljaGFlbEA2OGsub3JnPgorICoKKyAqIFJlZGlzdHJpYnV0 aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAor ICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2lu ZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoSU5ERVhFRF9EQVRBQkFT RSkKKworI2luY2x1ZGUgIkpTSURCT2JqZWN0U3RvcmUuaCIKKworI2luY2x1ZGUgIklEQkJpbmRp bmdVdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJJREJLZXlQYXRoLmgiCisjaW5jbHVkZSAiSURCT2Jq ZWN0U3RvcmUuaCIKKyNpbmNsdWRlICJKU0lEQkluZGV4LmgiCisjaW5jbHVkZSA8cnVudGltZS9F cnJvci5oPgorI2luY2x1ZGUgPHJ1bnRpbWUvSlNTdHJpbmcuaD4KKwordXNpbmcgbmFtZXNwYWNl IEpTQzsKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitKU1ZhbHVlIEpTSURCT2JqZWN0U3RvcmU6 OmNyZWF0ZUluZGV4KEV4ZWNTdGF0ZSogZXhlYykKK3sKKyAgICBTY3JpcHRFeGVjdXRpb25Db250 ZXh0KiBjb250ZXh0ID0ganNDYXN0PEpTRE9NR2xvYmFsT2JqZWN0Kj4oZXhlYy0+bGV4aWNhbEds b2JhbE9iamVjdCgpKS0+c2NyaXB0RXhlY3V0aW9uQ29udGV4dCgpOworICAgIGlmICghY29udGV4 dCkKKyAgICAgICAgcmV0dXJuIHRocm93RXJyb3IoZXhlYywgY3JlYXRlUmVmZXJlbmNlRXJyb3Io ZXhlYywgIklEQk9iamVjdFN0b3JlIHNjcmlwdCBleGVjdXRpb24gY29udGV4dCBpcyB1bmF2YWls YWJsZSIpKTsKKworICAgIGlmIChleGVjLT5hcmd1bWVudENvdW50KCkgPCAyKQorICAgICAgICBy ZXR1cm4gdGhyb3dFcnJvcihleGVjLCBjcmVhdGVOb3RFbm91Z2hBcmd1bWVudHNFcnJvcihleGVj KSk7CisKKyAgICBTdHJpbmcgbmFtZSA9IGV4ZWMtPmFyZ3VtZW50KDApLnRvU3RyaW5nKGV4ZWMp LT52YWx1ZShleGVjKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgIHJl dHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgSURCS2V5UGF0aCBrZXlQYXRoID0gaWRiS2V5UGF0 aEZyb21WYWx1ZShleGVjLCBleGVjLT5hcmd1bWVudCgxKSk7CisgICAgaWYgKGV4ZWMtPmhhZEV4 Y2VwdGlvbigpKQorICAgICAgICByZXR1cm4ganNVbmRlZmluZWQoKTsKKworICAgIEpTVmFsdWUg b3B0aW9uc1ZhbHVlID0gZXhlYy0+YXJndW1lbnQoMik7CisgICAgaWYgKCFvcHRpb25zVmFsdWUu aXNVbmRlZmluZWRPck51bGwoKSAmJiAhb3B0aW9uc1ZhbHVlLmlzT2JqZWN0KCkpCisgICAgICAg IHJldHVybiB0aHJvd1R5cGVFcnJvcihleGVjLCAiTm90IGFuIG9iamVjdC4iKTsKKworICAgIGJv b2wgdW5pcXVlID0gZmFsc2U7CisgICAgYm9vbCBtdWx0aUVudHJ5ID0gZmFsc2U7CisgICAgaWYg KCFvcHRpb25zVmFsdWUuaXNVbmRlZmluZWRPck51bGwoKSkgeworICAgICAgICB1bmlxdWUgPSBv cHRpb25zVmFsdWUuZ2V0KGV4ZWMsIElkZW50aWZpZXIoZXhlYywgInVuaXF1ZSIpKS50b0Jvb2xl YW4oZXhlYyk7CisgICAgICAgIGlmIChleGVjLT5oYWRFeGNlcHRpb24oKSkKKyAgICAgICAgICAg IHJldHVybiBqc1VuZGVmaW5lZCgpOworCisgICAgICAgIG11bHRpRW50cnkgPSBvcHRpb25zVmFs dWUuZ2V0KGV4ZWMsIElkZW50aWZpZXIoZXhlYywgIm11bHRpRW50cnkiKSkudG9Cb29sZWFuKGV4 ZWMpOworICAgICAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpCisgICAgICAgICAgICByZXR1 cm4ganNVbmRlZmluZWQoKTsKKyAgICB9CisKKyAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAg ICBKU1ZhbHVlIHJlc3VsdCA9IHRvSlMoZXhlYywgZ2xvYmFsT2JqZWN0KCksIGltcGwoKS0+Y3Jl YXRlSW5kZXgoY29udGV4dCwgbmFtZSwga2V5UGF0aCwgdW5pcXVlLCBtdWx0aUVudHJ5LCBlYyku Z2V0KCkpOworICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CisgICAgcmV0dXJuIHJlc3Vs dDsKK30KKworfQorCisjZW5kaWYKLS0gCjEuNy45LjUKCg==