61947 2011-06-02 11:36:02 -0700 AudioContext needs non-blocking call to create AudioBuffer from audio file data 2011-06-22 14:14:50 -0700 1 1 1 Unclassified WebKit Web Audio 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 crogers crogers crogers ericbidelman jamesr kbr levin oldest_to_newest 414305 0 crogers 2011-06-02 11:36:02 -0700 Currently, AudioContext has a createBuffer() method taking an ArrayBuffer of audio file data as an argument. This is a blocking call on the main JavaScript thread. There needs to be an alternative method which decodes the audio data on another thread and then calls an event listener when finished. 422964 1 97669 crogers 2011-06-17 17:17:52 -0700 Created attachment 97669 Patch 422975 2 crogers 2011-06-17 17:25:57 -0700 I've tested this patch for asynchronous loading in both Chromium and Safari Mac OS X. This results in a very noticeable improvement in the web audio pages which load multiple audio assets. I wanted to get this up for review since I think the bulk of the code is in good shape, but there are two issues I'd still like to address: 1. FIXME to address possible leaks in AsyncAudioDecoder::~AsyncAudioDecoder() related to unprocessed tasks in queue. 2. the error callback should probably be a different callback type which doesn't pass an AudioBuffer back into JavaScript. 424760 3 97669 kbr 2011-06-21 14:24:26 -0700 Comment on attachment 97669 Patch This looks good to me modulo the FIXMEs. You can easily give yourself the ability to raise an exception from decodeAudioData by adding "raises(DOMException)" to the IDL. Using one of the pre-defined exception codes is easy; a custom exception requires custom bindings. 424768 4 97669 jamesr 2011-06-21 14:39:16 -0700 Comment on attachment 97669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review Sorry to override but I don't think this is correct. Do we have to pass refptr<>s to callbacks to the second thread? That seems likely to be racy since our RefCounted implementation is not threadsafe. > Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 > + OwnPtr<DecodingTask> decodingTask = adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback)); > + m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue. This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. 424861 5 kbr 2011-06-21 16:36:11 -0700 (In reply to comment #4) > (From update of attachment 97669 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review > > Sorry to override but I don't think this is correct. Do we have to pass refptr<>s to callbacks to the second thread? That seems likely to be racy since our RefCounted implementation is not threadsafe. > > > Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 > > + OwnPtr<DecodingTask> decodingTask = adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback)); > > + m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue. > > This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. Note: the DecodingTask is deleted on the main thread, which is the same thread that instantiates it. See AsyncAudioDecoder::DecodingTask::decode() and its use of callOnMainThread. The background thread is only transiently used for the decoding. 424874 6 97669 jamesr 2011-06-21 16:50:25 -0700 Comment on attachment 97669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review >>> Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 >>> + m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue. >> >> This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. > > Note: the DecodingTask is deleted on the main thread, which is the same thread that instantiates it. See AsyncAudioDecoder::DecodingTask::decode() and its use of callOnMainThread. The background thread is only transiently used for the decoding. m_audioBuffer appears to be created on the decoder thread and then used from the main thread. 424876 7 jamesr 2011-06-21 16:50:49 -0700 (+cc levin for the threading stuff, he knows more than i do about what's safe across threads and what isn't) 424891 8 crogers 2011-06-21 17:21:36 -0700 (In reply to comment #4) > (From update of attachment 97669 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review > > Sorry to override but I don't think this is correct. Do we have to pass refptr<>s to callbacks to the second thread? That seems likely to be racy since our RefCounted implementation is not threadsafe. > > > Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 > > + OwnPtr<DecodingTask> decodingTask = adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback)); > > + m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue. > > This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. Just a note - the interesting object (DecodingTask) is itself not ref-counted. Instead OwnPtr's are used... the RefPtr part seems clear enough to me, but David can have a look too... Here's how the ownership works for the DecodingTask: 1. a DecodingTask is created on the main thread and added to a MessageQueue which takes ownership. 2. AsyncAudioDecoder::runLoop() is on its own thread and re-takes ownership of the DecodingTask by calling waitForMessage() 3. The ownership is passed (still in this decoder thread) to DecodingTask::decode() (basically by making the DecodingTask responsible for deleting itself) 4. DecodingTask::decode() schedules DecodingTask::notifyComplete() to occur on the main thread. 5. on the main thread DecodingTask::notifyComplete() calls any callbacks (success or error) and then deletes itself. 6. Any DecodingTasks which were not dequeued will be deleted when the MessageQueue itself is deleted. 424893 9 crogers 2011-06-21 17:24:02 -0700 (In reply to comment #4) > (From update of attachment 97669 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review > > Sorry to override but I don't think this is correct. Do we have to pass refptr<>s to callbacks to the second thread? That seems likely to be racy since our RefCounted implementation is not threadsafe. > > > Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 > > + OwnPtr<DecodingTask> decodingTask = adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback)); > > + m_queue.append(decodingTask.release()); // note that ownership of the task is effectively taken by the queue. > > This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. To me there clearly are no raciness problems with the RefPtr part due to the nature of the synchronization. 424898 10 97669 levin 2011-06-21 17:27:36 -0700 Comment on attachment 97669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=97669&action=review > Source/WebCore/webaudio/AsyncAudioDecoder.cpp:66 > + OwnPtr<DecodingTask> decodingTask = adoptPtr(new DecodingTask(audioData, sampleRate, successCallback, errorCallback)); The constructor should be private and a static create method should be exposed which returns a PassOwnPtr<DecodingTask>. >>>> Source/WebCore/webaudio/AsyncAudioDecoder.cpp:67 >>> >>> This worries me because we're passing two RefPtr<>s to another thread. Is it safe to drop the last reference to these callbacks from somewhere other than the main thread? The answer is nearly always no, and our RefPtr<> implementation is not thread-safe without some sort of additional synchronization around the refcount. >> >> Note: the DecodingTask is deleted on the main thread, which is the same thread that instantiates it. See AsyncAudioDecoder::DecodingTask::decode() and its use of callOnMainThread. The background thread is only transiently used for the decoding. > > m_audioBuffer appears to be created on the decoder thread and then used from the main thread. I agree with James who did a most thorough job here. (I understand the lifetime here and I think it is all correct but it seems fragile in the sense that it would be easy for someone to mess it up later because it is subtle. For example, you need to understand all of the code to know that even though m_successCallback is RefCounted you better not ref count it on the other thread). I wonder if something that is not refcounted could be used for the data that is passed using AudioBuffer. > Source/WebCore/webaudio/AsyncAudioDecoder.h:59 > + WTF_MAKE_NONCOPYABLE(DecodingTask); WebKit style is to put this immediately after the class declaraction. class AsyncAudioDecoder { WTF_MAKE_NONCOPYABLE(DecodingTask); public: 424903 11 jamesr 2011-06-21 17:31:12 -0700 Reasoning about threading makes my head hurt. Ken pointed out that the callback refcounts are only manipulated from the main thread, so that seems fine, but I'm still a bit concerned about the fact that we initialize the refcount on DecoderData::m_audioData from the decoder thread and then decrement it from the main thread - is that safe? 424904 12 levin 2011-06-21 17:33:28 -0700 (In reply to comment #11) > Reasoning about threading makes my head hurt. Ken pointed out that the callback refcounts are only manipulated from the main thread, so that seems fine, but I'm still a bit concerned about the fact that we initialize the refcount on DecoderData::m_audioData from the decoder thread and then decrement it from the main thread - is that safe? Should be safe because the ref count is done before the callOnMainThread and if callOnMainThread doesn't do a memory barrier, then there would be lots of trouble. (Also there is no ref count on the AudioBuffer in m_audioData other than m_audioData itself unless the decode function is doing something very tricky.) 424906 13 jamesr 2011-06-21 17:35:12 -0700 OK cool, then this looks fine to me as well. 424912 14 crogers 2011-06-21 17:41:13 -0700 (In reply to comment #12) > (Also there is no ref count on the AudioBuffer in m_audioData other than m_audioData itself unless the decode function is doing something very tricky.) Nothing tricky there. AudioBuffer::createFromAudioFileData() returns a normal PassRefPtr<AudioBuffer> 424915 15 97669 kbr 2011-06-21 17:44:44 -0700 Comment on attachment 97669 Patch Per the discussion above I'm r+'ing this again. 425574 16 crogers 2011-06-22 14:14:50 -0700 Committed r89478: <http://trac.webkit.org/changeset/89478> 97669 2011-06-17 17:17:52 -0700 2011-06-21 17:44:44 -0700 Patch bug-61947-20110617171751.patch text/plain 28572 crogers SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDg5MTgwKQorKysgU291cmNlL1dlYkNvcmUvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMzkgQEAKKzIwMTEtMDYtMTcgIENocmlzIFJv Z2VycyAgPGNyb2dlcnNAZ29vZ2xlLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBdWRpb0NvbnRleHQgbmVlZHMgbm9uLWJsb2NraW5nIGNhbGwg dG8gY3JlYXRlIEF1ZGlvQnVmZmVyIGZyb20gYXVkaW8gZmlsZSBkYXRhCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02MTk0NworCisgICAgICAgIE5vIG5l dyB0ZXN0cyBzaW5jZSBhdWRpbyBBUEkgaXMgbm90IHlldCBpbXBsZW1lbnRlZC4KKworICAgICAg ICAqIERlcml2ZWRTb3VyY2VzLm1ha2U6CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAg ICAqIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiB3ZWJhdWRp by9Bc3luY0F1ZGlvRGVjb2Rlci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNB dWRpb0RlY29kZXI6OkFzeW5jQXVkaW9EZWNvZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5j QXVkaW9EZWNvZGVyOjp+QXN5bmNBdWRpb0RlY29kZXIpOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNBdWRpb0RlY29kZXI6OmRlY29kZUFzeW5jKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jQXVk aW9EZWNvZGVyOjp0aHJlYWRFbnRyeSk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0F1ZGlvRGVj b2Rlcjo6cnVuTG9vcCk6CisgICAgICAgIChXZWJDb3JlOjpBc3luY0F1ZGlvRGVjb2Rlcjo6RGVj b2RpbmdUYXNrOjpEZWNvZGluZ1Rhc2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNBdWRpb0Rl Y29kZXI6OkRlY29kaW5nVGFzazo6ZGVjb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jQXVk aW9EZWNvZGVyOjpEZWNvZGluZ1Rhc2s6Om5vdGlmeUNvbXBsZXRlRGlzcGF0Y2gpOgorICAgICAg ICAoV2ViQ29yZTo6QXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFzazo6bm90aWZ5Q29tcGxl dGUpOgorICAgICAgICAqIHdlYmF1ZGlvL0FzeW5jQXVkaW9EZWNvZGVyLmg6IEFkZGVkLgorICAg ICAgICAoV2ViQ29yZTo6QXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFzazo6YXVkaW9EYXRh KToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jQXVkaW9EZWNvZGVyOjpEZWNvZGluZ1Rhc2s6OnNh bXBsZVJhdGUpOgorICAgICAgICAoV2ViQ29yZTo6QXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5n VGFzazo6c3VjY2Vzc0NhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OkFzeW5jQXVkaW9EZWNv ZGVyOjpEZWNvZGluZ1Rhc2s6OmVycm9yQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6QXN5 bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFzazo6YXVkaW9CdWZmZXIpOgorICAgICAgICAqIHdl YmF1ZGlvL0F1ZGlvQnVmZmVyQ2FsbGJhY2suaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpB dWRpb0J1ZmZlckNhbGxiYWNrOjp+QXVkaW9CdWZmZXJDYWxsYmFjayk6CisgICAgICAgICogd2Vi YXVkaW8vQXVkaW9CdWZmZXJDYWxsYmFjay5pZGw6IEFkZGVkLgorICAgICAgICAqIHdlYmF1ZGlv L0F1ZGlvQ29udGV4dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb0NvbnRleHQ6OmRlY29k ZUF1ZGlvRGF0YSk6CisgICAgICAgICogd2ViYXVkaW8vQXVkaW9Db250ZXh0Lmg6CisgICAgICAg ICogd2ViYXVkaW8vQXVkaW9Db250ZXh0LmlkbDoKKwogMjAxMS0wNi0xNyAgU2hlcmlmZiBCb3Qg IDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9s bGluZyBvdXQgcjg5MTQzLgpJbmRleDogU291cmNlL1dlYkNvcmUvRGVyaXZlZFNvdXJjZXMubWFr ZQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9EZXJpdmVkU291cmNlcy5tYWtlCShyZXZp c2lvbiA4OTE3OSkKKysrIFNvdXJjZS9XZWJDb3JlL0Rlcml2ZWRTb3VyY2VzLm1ha2UJKHdvcmtp bmcgY29weSkKQEAgLTU1LDYgKzU1LDcgQEAgRE9NX0NMQVNTRVMgPSBcCiAgICAgQWJzdHJhY3RX b3JrZXIgXAogICAgIEF0dHIgXAogICAgIEF1ZGlvQnVmZmVyIFwKKyAgICBBdWRpb0J1ZmZlckNh bGxiYWNrIFwKICAgICBBdWRpb0J1ZmZlclNvdXJjZU5vZGUgXAogICAgIEF1ZGlvQ2hhbm5lbFNw bGl0dGVyIFwKICAgICBBdWRpb0NoYW5uZWxNZXJnZXIgXApJbmRleDogU291cmNlL1dlYkNvcmUv V2ViQ29yZS5neXBpCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQko cmV2aXNpb24gODkxNzkpCisrKyBTb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtpbmcg Y29weSkKQEAgLTE0MTcsNiArMTQxNyw3IEBACiAgICAgICAgICAgICAnc3RvcmFnZS9TdG9yYWdl SW5mb1F1b3RhQ2FsbGJhY2suaWRsJywKICAgICAgICAgICAgICdzdG9yYWdlL1N0b3JhZ2VJbmZv VXNhZ2VDYWxsYmFjay5pZGwnLAogICAgICAgICAgICAgJ3dlYmF1ZGlvL0F1ZGlvQnVmZmVyLmlk bCcsCisgICAgICAgICAgICAnd2ViYXVkaW8vQXVkaW9CdWZmZXJDYWxsYmFjay5pZGwnLAogICAg ICAgICAgICAgJ3dlYmF1ZGlvL0F1ZGlvQnVmZmVyU291cmNlTm9kZS5pZGwnLAogICAgICAgICAg ICAgJ3dlYmF1ZGlvL0F1ZGlvQ2hhbm5lbE1lcmdlci5pZGwnLAogICAgICAgICAgICAgJ3dlYmF1 ZGlvL0F1ZGlvQ2hhbm5lbFNwbGl0dGVyLmlkbCcsCkBAIC01OTY1LDYgKzU5NjYsNyBAQAogICAg ICAgICAgICAgJ3dlYmF1ZGlvL0F1ZGlvQmFzaWNQcm9jZXNzb3JOb2RlLmgnLAogICAgICAgICAg ICAgJ3dlYmF1ZGlvL0F1ZGlvQnVmZmVyLmNwcCcsCiAgICAgICAgICAgICAnd2ViYXVkaW8vQXVk aW9CdWZmZXIuaCcsCisgICAgICAgICAgICAnd2ViYXVkaW8vQXVkaW9CdWZmZXJDYWxsYmFjay5o JywKICAgICAgICAgICAgICd3ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuY3BwJywKICAg ICAgICAgICAgICd3ZWJhdWRpby9BdWRpb0J1ZmZlclNvdXJjZU5vZGUuaCcsCiAgICAgICAgICAg ICAnd2ViYXVkaW8vQXVkaW9DaGFubmVsTWVyZ2VyLmNwcCcsCkBAIC01OTk1LDYgKzU5OTcsOCBA QAogICAgICAgICAgICAgJ3dlYmF1ZGlvL0F1ZGlvUHJvY2Vzc2luZ0V2ZW50LmNwcCcsCiAgICAg ICAgICAgICAnd2ViYXVkaW8vQXVkaW9Qcm9jZXNzaW5nRXZlbnQuaCcsCiAgICAgICAgICAgICAn d2ViYXVkaW8vQXVkaW9Tb3VyY2VOb2RlLmgnLAorICAgICAgICAgICAgJ3dlYmF1ZGlvL0FzeW5j QXVkaW9EZWNvZGVyLmNwcCcsCisgICAgICAgICAgICAnd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29k ZXIuaCcsCiAgICAgICAgICAgICAnd2ViYXVkaW8vQmlxdWFkRFNQS2VybmVsLmNwcCcsCiAgICAg ICAgICAgICAnd2ViYXVkaW8vQmlxdWFkRFNQS2VybmVsLmgnLAogICAgICAgICAgICAgJ3dlYmF1 ZGlvL0JpcXVhZEZpbHRlck5vZGUuY3BwJywKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDg5MTc5KQorKysgU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNv cHkpCkBAIC01Nzk4LDYgKzU3OTgsOSBAQAogCQlGRDUzNzM1MzEzN0I2NTE4MDAwMDhEQ0UgLyog WmVyb1BvbGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEZENTM3MzUxMTM3QjY1MTgwMDAwOERDRSAvKiBaZXJvUG9sZS5oICovOyB9OwogCQlGRDUzNzM1 NjEzN0I2NTNCMDAwMDhEQ0UgLyogRHluYW1pY3NDb21wcmVzc29yS2VybmVsLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZENTM3MzU0MTM3QjY1M0Iw MDAwOERDRSAvKiBEeW5hbWljc0NvbXByZXNzb3JLZXJuZWwuY3BwICovOyB9OwogCQlGRDUzNzM1 NzEzN0I2NTNCMDAwMDhEQ0UgLyogRHluYW1pY3NDb21wcmVzc29yS2VybmVsLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRDUzNzM1NTEzN0I2NTNCMDAw MDhEQ0UgLyogRHluYW1pY3NDb21wcmVzc29yS2VybmVsLmggKi87IH07CisJCUZENTY4NkM5MTNB QzE4MDIwMEI2OUM2OCAvKiBBc3luY0F1ZGlvRGVjb2Rlci5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRDU2ODZDNzEzQUMxODAyMDBCNjlDNjggLyog QXN5bmNBdWRpb0RlY29kZXIuY3BwICovOyB9OworCQlGRDU2ODZDQTEzQUMxODAyMDBCNjlDNjgg LyogQXN5bmNBdWRpb0RlY29kZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEZENTY4NkM4MTNBQzE4MDIwMEI2OUM2OCAvKiBBc3luY0F1ZGlvRGVjb2Rl ci5oICovOyB9OworCQlGRDU2ODZDQzEzQUMxODE0MDBCNjlDNjggLyogQXVkaW9CdWZmZXJDYWxs YmFjay5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkQ1 Njg2Q0IxM0FDMTgxNDAwQjY5QzY4IC8qIEF1ZGlvQnVmZmVyQ2FsbGJhY2suaCAqLzsgfTsKIAkJ RkQ2RUQyQzMxMzZCOEU0MjAwM0NGMDcyIC8qIER5bmFtaWNzQ29tcHJlc3Nvck5vZGUuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkQ2RUQyQzExMzZC OEU0MjAwM0NGMDcyIC8qIER5bmFtaWNzQ29tcHJlc3Nvck5vZGUuY3BwICovOyB9OwogCQlGRDZF RDJDNDEzNkI4RTQyMDAzQ0YwNzIgLyogRHluYW1pY3NDb21wcmVzc29yTm9kZS5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkQ2RUQyQzIxMzZCOEU0MjAw M0NGMDcyIC8qIER5bmFtaWNzQ29tcHJlc3Nvck5vZGUuaCAqLzsgfTsKIAkJRkQ2RUQyQzcxMzZC OEU2NjAwM0NGMDcyIC8qIER5bmFtaWNzQ29tcHJlc3Nvci5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRDZFRDJDNTEzNkI4RTY2MDAzQ0YwNzIgLyog RHluYW1pY3NDb21wcmVzc29yLmNwcCAqLzsgfTsKQEAgLTU4NTksNiArNTg2Miw4IEBACiAJCUZE RjA5REM5MTM5OUI2MjIwMDY4OEU1QiAvKiBKU0JpcXVhZEZpbHRlck5vZGUuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZERjA5REM3MTM5OUI2MjIwMDY4 OEU1QiAvKiBKU0JpcXVhZEZpbHRlck5vZGUuaCAqLzsgfTsKIAkJRkRGNkJBRjgxMzRBNEM5ODAw ODIyOTIwIC8qIEpTT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2ZW50LmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZERjZCQUY2MTM0QTRDOTgwMDgyMjky MCAvKiBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudC5jcHAgKi87IH07CiAJCUZERjZCQUY5 MTM0QTRDOTgwMDgyMjkyMCAvKiBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRGNkJBRjcxMzRBNEM5 ODAwODIyOTIwIC8qIEpTT2ZmbGluZUF1ZGlvQ29tcGxldGlvbkV2ZW50LmggKi87IH07CisJCUZE RjdFOUMzMTNBQzIxREIwMEE1MUVBQyAvKiBKU0F1ZGlvQnVmZmVyQ2FsbGJhY2suY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRGN0U5QzExM0FDMjFE QjAwQTUxRUFDIC8qIEpTQXVkaW9CdWZmZXJDYWxsYmFjay5jcHAgKi87IH07CisJCUZERjdFOUM0 MTNBQzIxREIwMEE1MUVBQyAvKiBKU0F1ZGlvQnVmZmVyQ2FsbGJhY2suaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZERjdFOUMyMTNBQzIxREIwMEE1MUVB QyAvKiBKU0F1ZGlvQnVmZmVyQ2FsbGJhY2suaCAqLzsgfTsKIAkJRkU2RkQ0ODgwRjY3NkU1NzAw MDkyODczIC8qIENvb3JkaW5hdGVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBGRTZGRDQ4NTBGNjc2RTU3MDAwOTI4NzMgLyogQ29vcmRpbmF0ZXMuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlGRTZGRDQ4 RDBGNjc2RTkzMDAwOTI4NzMgLyogSlNDb29yZGluYXRlcy5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGRTZGRDQ4QjBGNjc2RTkzMDAwOTI4NzMgLyog SlNDb29yZGluYXRlcy5jcHAgKi87IH07CiAJCUZFNkZENDhFMEY2NzZFOTMwMDA5Mjg3MyAvKiBK U0Nvb3JkaW5hdGVzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSBGRTZGRDQ4QzBGNjc2RTkzMDAwOTI4NzMgLyogSlNDb29yZGluYXRlcy5oICovOyB9OwpA QCAtMTI0NTksNiArMTI0NjQsMTAgQEAKIAkJRkQ1MzczNTExMzdCNjUxODAwMDA4RENFIC8qIFpl cm9Qb2xlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFplcm9Qb2xlLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZENTM3MzU0MTM3QjY1M0IwMDAwOERDRSAvKiBE eW5hbWljc0NvbXByZXNzb3JLZXJuZWwuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gRHluYW1pY3NDb21wcmVzc29yS2VybmVsLmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJRkQ1MzczNTUxMzdCNjUzQjAwMDA4RENFIC8qIER5bmFtaWNzQ29tcHJlc3Nv cktlcm5lbC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBEeW5hbWljc0NvbXBy ZXNzb3JLZXJuZWwuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkQ1Njg2QzcxM0FD MTgwMjAwQjY5QzY4IC8qIEFzeW5jQXVkaW9EZWNvZGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IEFzeW5jQXVkaW9EZWNvZGVyLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJRkQ1Njg2QzgxM0FDMTgwMjAwQjY5QzY4IC8qIEFzeW5jQXVkaW9EZWNv ZGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFzeW5jQXVkaW9EZWNvZGVy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUZENTY4NkNCMTNBQzE4MTQwMEI2OUM2 OCAvKiBBdWRpb0J1ZmZlckNhbGxiYWNrLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IEF1ZGlvQnVmZmVyQ2FsbGJhY2suaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ RkQ1Njg2Q0QxM0FDMTgzRTAwQjY5QzY4IC8qIEF1ZGlvQnVmZmVyQ2FsbGJhY2suaWRsICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gdGV4dDsgcGF0aCA9IEF1ZGlvQnVmZmVyQ2FsbGJhY2suaWRsOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQlGRDZFRDJDMTEzNkI4RTQyMDAzQ0YwNzIgLyogRHluYW1pY3NDb21w cmVzc29yTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBEeW5h bWljc0NvbXByZXNzb3JOb2RlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkQ2 RUQyQzIxMzZCOEU0MjAwM0NGMDcyIC8qIER5bmFtaWNzQ29tcHJlc3Nvck5vZGUuaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRHluYW1pY3NDb21wcmVzc29yTm9kZS5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGRDZFRDJDNTEzNkI4RTY2MDAzQ0YwNzIgLyogRHlu YW1pY3NDb21wcmVzc29yLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IER5bmFtaWNzQ29tcHJlc3Nvci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0x MjUyMyw2ICsxMjUzMiw4IEBACiAJCUZERjA5REM3MTM5OUI2MjIwMDY4OEU1QiAvKiBKU0JpcXVh ZEZpbHRlck5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNCaXF1YWRG aWx0ZXJOb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZERjZCQUY2MTM0QTRD OTgwMDgyMjkyMCAvKiBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudC5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVu dC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZERjZCQUY3MTM0QTRDOTgwMDgy MjkyMCAvKiBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBKU09mZmxpbmVBdWRpb0NvbXBsZXRpb25FdmVudC5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OworCQlGREY3RTlDMTEzQUMyMURCMDBBNTFFQUMgLyogSlNBdWRp b0J1ZmZlckNhbGxiYWNrLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IEpTQXVkaW9CdWZmZXJDYWxsYmFjay5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJ CUZERjdFOUMyMTNBQzIxREIwMEE1MUVBQyAvKiBKU0F1ZGlvQnVmZmVyQ2FsbGJhY2suaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNBdWRpb0J1ZmZlckNhbGxiYWNrLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZFNDlFRjk3MERDNTE0NjIwMDQyNjZFMSAvKiBE YXNoYm9hcmRTdXBwb3J0Q1NTUHJvcGVydHlOYW1lcy5pbiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGgg PSBEYXNoYm9hcmRTdXBwb3J0Q1NTUHJvcGVydHlOYW1lcy5pbjsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJRkU2RkQ0ODUwRjY3NkU1NzAwMDkyODczIC8qIENvb3JkaW5hdGVzLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvb3JkaW5hdGVzLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUZFNkZENDg2MEY2NzZFNTcwMDA5Mjg3MyAvKiBDb29yZGluYXRl cy5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gQ29vcmRpbmF0ZXMuaWRsOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwpAQCAtMTk2OTMsMTEgKzE5NzA0LDE1IEBACiAJCUZEMzE1RkEyMTJC MDI1QjEwMEMxQTM1OSAvKiB3ZWJhdWRpbyAqLyA9IHsKIAkJCWlzYSA9IFBCWEdyb3VwOwogCQkJ Y2hpbGRyZW4gPSAoCisJCQkJRkQ1Njg2QzcxM0FDMTgwMjAwQjY5QzY4IC8qIEFzeW5jQXVkaW9E ZWNvZGVyLmNwcCAqLywKKwkJCQlGRDU2ODZDODEzQUMxODAyMDBCNjlDNjggLyogQXN5bmNBdWRp b0RlY29kZXIuaCAqLywKIAkJCQlGRDMxNUZBQzEyQjAyNjc1MDBDMUEzNTkgLyogQXVkaW9CYXNp Y1Byb2Nlc3Nvck5vZGUuY3BwICovLAogCQkJCUZEMzE1RkFEMTJCMDI2NzUwMEMxQTM1OSAvKiBB dWRpb0Jhc2ljUHJvY2Vzc29yTm9kZS5oICovLAogCQkJCUZEMzE1RkFFMTJCMDI2NzUwMEMxQTM1 OSAvKiBBdWRpb0J1ZmZlci5jcHAgKi8sCiAJCQkJRkQzMTVGQUYxMkIwMjY3NTAwQzFBMzU5IC8q IEF1ZGlvQnVmZmVyLmggKi8sCiAJCQkJRkQzMTVGQjAxMkIwMjY3NTAwQzFBMzU5IC8qIEF1ZGlv QnVmZmVyLmlkbCAqLywKKwkJCQlGRDU2ODZDQjEzQUMxODE0MDBCNjlDNjggLyogQXVkaW9CdWZm ZXJDYWxsYmFjay5oICovLAorCQkJCUZENTY4NkNEMTNBQzE4M0UwMEI2OUM2OCAvKiBBdWRpb0J1 ZmZlckNhbGxiYWNrLmlkbCAqLywKIAkJCQlGRDMxNUZCMTEyQjAyNjc1MDBDMUEzNTkgLyogQXVk aW9CdWZmZXJTb3VyY2VOb2RlLmNwcCAqLywKIAkJCQlGRDMxNUZCMjEyQjAyNjc1MDBDMUEzNTkg LyogQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmggKi8sCiAJCQkJRkQzMTVGQjMxMkIwMjY3NTAwQzFB MzU5IC8qIEF1ZGlvQnVmZmVyU291cmNlTm9kZS5pZGwgKi8sCkBAIC0xOTg3Myw2ICsxOTg4OCw4 IEBACiAJCQljaGlsZHJlbiA9ICgKIAkJCQlGREExNUU4MTEyQjAzRUUxMDAzQTU4M0EgLyogSlNB dWRpb0J1ZmZlci5jcHAgKi8sCiAJCQkJRkRBMTVFODIxMkIwM0VFMTAwM0E1ODNBIC8qIEpTQXVk aW9CdWZmZXIuaCAqLywKKwkJCQlGREY3RTlDMTEzQUMyMURCMDBBNTFFQUMgLyogSlNBdWRpb0J1 ZmZlckNhbGxiYWNrLmNwcCAqLywKKwkJCQlGREY3RTlDMjEzQUMyMURCMDBBNTFFQUMgLyogSlNB dWRpb0J1ZmZlckNhbGxiYWNrLmggKi8sCiAJCQkJRkRBMTVFODMxMkIwM0VFMTAwM0E1ODNBIC8q IEpTQXVkaW9CdWZmZXJTb3VyY2VOb2RlLmNwcCAqLywKIAkJCQlGREExNUU4NDEyQjAzRUUxMDAz QTU4M0EgLyogSlNBdWRpb0J1ZmZlclNvdXJjZU5vZGUuaCAqLywKIAkJCQlGREExNUU4NTEyQjAz RUUxMDAzQTU4M0EgLyogSlNBdWRpb0NoYW5uZWxNZXJnZXIuY3BwICovLApAQCAtMjI4OTMsNiAr MjI5MTAsOSBAQAogCQkJCTk3N0UyRTBGMTJGMEZDOUMwMEMxMzM3OSAvKiBYU1NBdWRpdG9yLmgg aW4gSGVhZGVycyAqLywKIAkJCQlGRDUzNzM1MzEzN0I2NTE4MDAwMDhEQ0UgLyogWmVyb1BvbGUu aCBpbiBIZWFkZXJzICovLAogCQkJCTk4NUJCOTZFMTNBOTQwNTgwMDdBMEI2OSAvKiBMaW5rUmVs QXR0cmlidXRlLmggaW4gSGVhZGVycyAqLywKKwkJCQlGRDU2ODZDQTEzQUMxODAyMDBCNjlDNjgg LyogQXN5bmNBdWRpb0RlY29kZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCUZENTY4NkNDMTNBQzE4 MTQwMEI2OUM2OCAvKiBBdWRpb0J1ZmZlckNhbGxiYWNrLmggaW4gSGVhZGVycyAqLywKKwkJCQlG REY3RTlDNDEzQUMyMURCMDBBNTFFQUMgLyogSlNBdWRpb0J1ZmZlckNhbGxiYWNrLmggaW4gSGVh ZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0g MDsKIAkJfTsKQEAgLTI1NjMyLDYgKzI1NjUyLDggQEAKIAkJCQk5NzdFMkUwRTEyRjBGQzlDMDBD MTMzNzkgLyogWFNTQXVkaXRvci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlGRDUzNzM1MjEzN0I2 NTE4MDAwMDhEQ0UgLyogWmVyb1BvbGUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJOTg1QkI5NkQx M0E5NDA1ODAwN0EwQjY5IC8qIExpbmtSZWxBdHRyaWJ1dGUuY3BwIGluIFNvdXJjZXMgKi8sCisJ CQkJRkQ1Njg2QzkxM0FDMTgwMjAwQjY5QzY4IC8qIEFzeW5jQXVkaW9EZWNvZGVyLmNwcCBpbiBT b3VyY2VzICovLAorCQkJCUZERjdFOUMzMTNBQzIxREIwMEE1MUVBQyAvKiBKU0F1ZGlvQnVmZmVy Q2FsbGJhY2suY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1l bnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkluZGV4OiBTb3VyY2UvV2ViQ29yZS93ZWJhdWRp by9Bc3luY0F1ZGlvRGVjb2Rlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvd2Vi YXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuY3BwCShyZXZpc2lvbiAwKQorKysgU291cmNlL1dlYkNv cmUvd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDE0MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoK KyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFOWQorICog RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVE IFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9T UyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9G IFRISVMKKyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShX RUJfQVVESU8pCisKKyNpbmNsdWRlICJBc3luY0F1ZGlvRGVjb2Rlci5oIgorCisjaW5jbHVkZSAi QXJyYXlCdWZmZXIuaCIKKyNpbmNsdWRlICJBdWRpb0J1ZmZlci5oIgorI2luY2x1ZGUgIkF1ZGlv QnVmZmVyQ2FsbGJhY2suaCIKKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisjaW5jbHVkZSA8d3Rm L1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitBc3luY0F1ZGlvRGVjb2Rl cjo6QXN5bmNBdWRpb0RlY29kZXIoKQoreworICAgIC8vIFN0YXJ0IHdvcmtlciB0aHJlYWQuCisg ICAgTXV0ZXhMb2NrZXIgbG9jayhtX3RocmVhZENyZWF0aW9uTXV0ZXgpOworICAgIG1fdGhyZWFk SUQgPSBjcmVhdGVUaHJlYWQoQXN5bmNBdWRpb0RlY29kZXI6OnRocmVhZEVudHJ5LCB0aGlzLCAi QXVkaW8gRGVjb2RlciIpOworfQorCitBc3luY0F1ZGlvRGVjb2Rlcjo6fkFzeW5jQXVkaW9EZWNv ZGVyKCkKK3sKKyAgICBtX3F1ZXVlLmtpbGwoKTsKKyAgICAKKyAgICAvLyBTdG9wIHRocmVhZC4K KyAgICB2b2lkKiBleGl0Q29kZTsKKyAgICB3YWl0Rm9yVGhyZWFkQ29tcGxldGlvbihtX3RocmVh ZElELCAmZXhpdENvZGUpOworICAgIG1fdGhyZWFkSUQgPSAwOworCisgICAgLy8gRklYTUU6Cisg ICAgLy8gTWFrZSBzdXJlIG5vdCB0byBsZWFrIGFueSByZW1haW5pbmcgdGFza3MgaW4gdGhlIHF1 ZXVlIChraWxsKCkgbWF5IGhhdmUgYmVlbiBjYWxsZWQgd2l0aCB0YXNrcyBzdGlsbCBpbiB0aGUg cXVldWUpIQorfQorCit2b2lkIEFzeW5jQXVkaW9EZWNvZGVyOjpkZWNvZGVBc3luYyhBcnJheUJ1 ZmZlciogYXVkaW9EYXRhLCBkb3VibGUgc2FtcGxlUmF0ZSwgUGFzc1JlZlB0cjxBdWRpb0J1ZmZl ckNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8QXVkaW9CdWZmZXJDYWxsYmFj az4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFT U0VSVChhdWRpb0RhdGEpOworICAgIGlmICghYXVkaW9EYXRhKQorICAgICAgICByZXR1cm47IC8v IEZJWE1FIHRocm93IGV4Y2VwdGlvbgorCisgICAgT3duUHRyPERlY29kaW5nVGFzaz4gZGVjb2Rp bmdUYXNrID0gYWRvcHRQdHIobmV3IERlY29kaW5nVGFzayhhdWRpb0RhdGEsIHNhbXBsZVJhdGUs IHN1Y2Nlc3NDYWxsYmFjaywgZXJyb3JDYWxsYmFjaykpOworICAgIG1fcXVldWUuYXBwZW5kKGRl Y29kaW5nVGFzay5yZWxlYXNlKCkpOyAvLyBub3RlIHRoYXQgb3duZXJzaGlwIG9mIHRoZSB0YXNr IGlzIGVmZmVjdGl2ZWx5IHRha2VuIGJ5IHRoZSBxdWV1ZS4KK30KKworLy8gQXN5bmNocm9ub3Vz bHkgZGVjb2RlIGluIHRoaXMgdGhyZWFkLgordm9pZCogQXN5bmNBdWRpb0RlY29kZXI6OnRocmVh ZEVudHJ5KHZvaWQqIHRocmVhZERhdGEpCit7CisgICAgQVNTRVJUKHRocmVhZERhdGEpOworICAg IEFzeW5jQXVkaW9EZWNvZGVyKiBkZWNvZGVyID0gcmVpbnRlcnByZXRfY2FzdDxBc3luY0F1ZGlv RGVjb2Rlcio+KHRocmVhZERhdGEpOworICAgIGRlY29kZXItPnJ1bkxvb3AoKTsKKyAgICByZXR1 cm4gMDsKK30KKwordm9pZCBBc3luY0F1ZGlvRGVjb2Rlcjo6cnVuTG9vcCgpCit7CisgICAgQVNT RVJUKCFpc01haW5UaHJlYWQoKSk7CisKKyAgICB7CisgICAgICAgIC8vIFdhaXQgZm9yIHVudGls IHdlIGhhdmUgbV90aHJlYWRJRCBlc3RhYmxpc2hlZCBiZWZvcmUgc3RhcnRpbmcgdGhlIHJ1biBs b29wLgorICAgICAgICBNdXRleExvY2tlciBsb2NrKG1fdGhyZWFkQ3JlYXRpb25NdXRleCk7Cisg ICAgfQorCisgICAgLy8gS2VlcCBydW5uaW5nIGRlY29kaW5nIHRhc2tzIHVudGlsIHdlJ3JlIGtp bGxlZC4KKyAgICB3aGlsZSAoT3duUHRyPERlY29kaW5nVGFzaz4gZGVjb2RpbmdUYXNrID0gbV9x dWV1ZS53YWl0Rm9yTWVzc2FnZSgpKSB7CisgICAgICAgIC8vIExldCB0aGUgdGFzayB0YWtlIGNh cmUgb2YgaXRzIG93biBvd25lcnNoaXAuCisgICAgICAgIC8vIFNlZSBEZWNvZGluZ1Rhc2s6Om5v dGlmeUNvbXBsZXRlKCkgZm9yIGNsZWFudXAuCisgICAgICAgIGRlY29kaW5nVGFzay5sZWFrUHRy KCktPmRlY29kZSgpOworICAgIH0KK30KKworQXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFz azo6RGVjb2RpbmdUYXNrKEFycmF5QnVmZmVyKiBhdWRpb0RhdGEsIGRvdWJsZSBzYW1wbGVSYXRl LCBQYXNzUmVmUHRyPEF1ZGlvQnVmZmVyQ2FsbGJhY2s+IHN1Y2Nlc3NDYWxsYmFjaywgUGFzc1Jl ZlB0cjxBdWRpb0J1ZmZlckNhbGxiYWNrPiBlcnJvckNhbGxiYWNrKQorICAgIDogbV9hdWRpb0Rh dGEoYXVkaW9EYXRhKQorICAgICwgbV9zYW1wbGVSYXRlKHNhbXBsZVJhdGUpCisgICAgLCBtX3N1 Y2Nlc3NDYWxsYmFjayhzdWNjZXNzQ2FsbGJhY2spCisgICAgLCBtX2Vycm9yQ2FsbGJhY2soZXJy b3JDYWxsYmFjaykKK3sKK30KKwordm9pZCBBc3luY0F1ZGlvRGVjb2Rlcjo6RGVjb2RpbmdUYXNr OjpkZWNvZGUoKQoreworICAgIEFTU0VSVChtX2F1ZGlvRGF0YS5nZXQoKSk7CisgICAgaWYgKCFt X2F1ZGlvRGF0YS5nZXQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gRG8gdGhlIGFjdHVh bCBkZWNvZGluZyBhbmQgaW52b2tlIHRoZSBjYWxsYmFjay4KKyAgICBtX2F1ZGlvQnVmZmVyID0g QXVkaW9CdWZmZXI6OmNyZWF0ZUZyb21BdWRpb0ZpbGVEYXRhKG1fYXVkaW9EYXRhLT5kYXRhKCks IG1fYXVkaW9EYXRhLT5ieXRlTGVuZ3RoKCksIGZhbHNlLCBzYW1wbGVSYXRlKCkpOworCisgICAg Ly8gRGVjb2RpbmcgaXMgZmluaXNoZWQsIGJ1dCB3ZSBuZWVkIHRvIGRvIHRoZSBjYWxsYmFja3Mg b24gdGhlIG1haW4gdGhyZWFkLgorICAgIGNhbGxPbk1haW5UaHJlYWQobm90aWZ5Q29tcGxldGVE aXNwYXRjaCwgdGhpcyk7Cit9CisKK3ZvaWQgQXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFz azo6bm90aWZ5Q29tcGxldGVEaXNwYXRjaCh2b2lkKiB1c2VyRGF0YSkKK3sKKyAgICBBc3luY0F1 ZGlvRGVjb2Rlcjo6RGVjb2RpbmdUYXNrKiB0YXNrID0gcmVpbnRlcnByZXRfY2FzdDxBc3luY0F1 ZGlvRGVjb2Rlcjo6RGVjb2RpbmdUYXNrKj4odXNlckRhdGEpOworICAgIEFTU0VSVCh0YXNrKTsK KyAgICBpZiAoIXRhc2spCisgICAgICAgIHJldHVybjsKKworICAgIHRhc2stPm5vdGlmeUNvbXBs ZXRlKCk7Cit9CisKK3ZvaWQgQXN5bmNBdWRpb0RlY29kZXI6OkRlY29kaW5nVGFzazo6bm90aWZ5 Q29tcGxldGUoKQoreworICAgIGlmIChhdWRpb0J1ZmZlcigpICYmIHN1Y2Nlc3NDYWxsYmFjaygp KQorICAgICAgICBzdWNjZXNzQ2FsbGJhY2soKS0+aGFuZGxlRXZlbnQoYXVkaW9CdWZmZXIoKSk7 CisgICAgZWxzZSBpZiAoZXJyb3JDYWxsYmFjaygpKQorICAgICAgICBlcnJvckNhbGxiYWNrKCkt PmhhbmRsZUV2ZW50KGF1ZGlvQnVmZmVyKCkpOworCisgICAgLy8gT3VyIG93bmVyc2hpcCB3YXMg Z2l2ZW4gdXAgaW4gQXN5bmNBdWRpb0RlY29kZXI6OnJ1bkxvb3AoKQorICAgIC8vIE1ha2Ugc3Vy ZSB0byBjbGVhbiB1cCBoZXJlLgorICAgIGRlbGV0ZSB0aGlzOworfQorCit9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoV0VCX0FVRElPKQpJbmRleDogU291cmNlL1dl YkNvcmUvd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2Uv V2ViQ29yZS93ZWJhdWRpby9Bc3luY0F1ZGlvRGVjb2Rlci5oCShyZXZpc2lvbiAwKQorKysgU291 cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuaAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw4NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSwgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFO WQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJM RSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOwor ICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFIE9GIFRISVMKKyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXN5bmNBdWRpb0RlY29kZXJfaAor I2RlZmluZSBBc3luY0F1ZGlvRGVjb2Rlcl9oCisKKyNpbmNsdWRlIDx3dGYvTWVzc2FnZVF1ZXVl Lmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+ CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQXJyYXlCdWZmZXI7CitjbGFzcyBBdWRp b0J1ZmZlcjsKK2NsYXNzIEF1ZGlvQnVmZmVyQ2FsbGJhY2s7CisKKy8vIEFzeW5jQXVkaW9EZWNv ZGVyIGFzeW5jaHJvbm91c2x5IGRlY29kZXMgYXVkaW8gZmlsZSBkYXRhIGZyb20gYW4gQXJyYXlC dWZmZXIgaW4gYSB3b3JrZXIgdGhyZWFkLgorLy8gVXBvbiBzdWNjZXNzZnVsIGRlY29kaW5nLCBh IGNvbXBsZXRpb24gY2FsbGJhY2sgd2lsbCBiZSBpbnZva2VkIHdpdGggdGhlIGRlY29kZWQgUENN IGRhdGEgaW4gYW4gQXVkaW9CdWZmZXIuCisKK2NsYXNzIEFzeW5jQXVkaW9EZWNvZGVyIHsKK3B1 YmxpYzoKKyAgICBBc3luY0F1ZGlvRGVjb2RlcigpOworICAgIH5Bc3luY0F1ZGlvRGVjb2Rlcigp OworCisgICAgLy8gTXVzdCBiZSBjYWxsZWQgb24gdGhlIG1haW4gdGhyZWFkLgorICAgIHZvaWQg ZGVjb2RlQXN5bmMoQXJyYXlCdWZmZXIqIGF1ZGlvRGF0YSwgZG91YmxlIHNhbXBsZVJhdGUsIFBh c3NSZWZQdHI8QXVkaW9CdWZmZXJDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRy PEF1ZGlvQnVmZmVyQ2FsbGJhY2s+IGVycm9yQ2FsbGJhY2spOworCitwcml2YXRlOgorICAgIGNs YXNzIERlY29kaW5nVGFzayB7CisgICAgcHVibGljOgorICAgICAgICBEZWNvZGluZ1Rhc2soQXJy YXlCdWZmZXIqIGF1ZGlvRGF0YSwgZG91YmxlIHNhbXBsZVJhdGUsIFBhc3NSZWZQdHI8QXVkaW9C dWZmZXJDYWxsYmFjaz4gc3VjY2Vzc0NhbGxiYWNrLCBQYXNzUmVmUHRyPEF1ZGlvQnVmZmVyQ2Fs bGJhY2s+IGVycm9yQ2FsbGJhY2spOworICAgICAgICAKKyAgICAgICAgdm9pZCBkZWNvZGUoKTsK KyAgICAgICAgCisgICAgcHJpdmF0ZToKKyAgICAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoRGVj b2RpbmdUYXNrKTsKKworICAgICAgICBBcnJheUJ1ZmZlciogYXVkaW9EYXRhKCkgeyByZXR1cm4g bV9hdWRpb0RhdGEuZ2V0KCk7IH0KKyAgICAgICAgZG91YmxlIHNhbXBsZVJhdGUoKSBjb25zdCB7 IHJldHVybiBtX3NhbXBsZVJhdGU7IH0KKyAgICAgICAgQXVkaW9CdWZmZXJDYWxsYmFjayogc3Vj Y2Vzc0NhbGxiYWNrKCkgeyByZXR1cm4gbV9zdWNjZXNzQ2FsbGJhY2suZ2V0KCk7IH0KKyAgICAg ICAgQXVkaW9CdWZmZXJDYWxsYmFjayogZXJyb3JDYWxsYmFjaygpIHsgcmV0dXJuIG1fZXJyb3JD YWxsYmFjay5nZXQoKTsgfQorICAgICAgICBBdWRpb0J1ZmZlciogYXVkaW9CdWZmZXIoKSB7IHJl dHVybiBtX2F1ZGlvQnVmZmVyLmdldCgpOyB9CisKKyAgICAgICAgc3RhdGljIHZvaWQgbm90aWZ5 Q29tcGxldGVEaXNwYXRjaCh2b2lkKiB1c2VyRGF0YSk7CisgICAgICAgIHZvaWQgbm90aWZ5Q29t cGxldGUoKTsKKworICAgICAgICBSZWZQdHI8QXJyYXlCdWZmZXI+IG1fYXVkaW9EYXRhOworICAg ICAgICBkb3VibGUgbV9zYW1wbGVSYXRlOworICAgICAgICBSZWZQdHI8QXVkaW9CdWZmZXJDYWxs YmFjaz4gbV9zdWNjZXNzQ2FsbGJhY2s7CisgICAgICAgIFJlZlB0cjxBdWRpb0J1ZmZlckNhbGxi YWNrPiBtX2Vycm9yQ2FsbGJhY2s7CisgICAgICAgIFJlZlB0cjxBdWRpb0J1ZmZlcj4gbV9hdWRp b0J1ZmZlcjsKKyAgICB9OworICAgIAorICAgIHN0YXRpYyB2b2lkKiB0aHJlYWRFbnRyeSh2b2lk KiB0aHJlYWREYXRhKTsKKyAgICB2b2lkIHJ1bkxvb3AoKTsKKworICAgIFdURjo6VGhyZWFkSWRl bnRpZmllciBtX3RocmVhZElEOworICAgIE11dGV4IG1fdGhyZWFkQ3JlYXRpb25NdXRleDsKKyAg ICBNZXNzYWdlUXVldWU8RGVjb2RpbmdUYXNrPiBtX3F1ZXVlOworfTsKKworfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQXN5bmNBdWRpb0RlY29kZXJfaApJbmRleDogU291cmNl L1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9CdWZmZXJDYWxsYmFjay5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyQ2FsbGJhY2suaAkocmV2aXNpb24gMCkK KysrIFNvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvQnVmZmVyQ2FsbGJhY2suaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw0NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSwgR29vZ2xl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFIE9GIFRISVMKKyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgQXVkaW9CdWZmZXJD YWxsYmFja19oCisjZGVmaW5lIEF1ZGlvQnVmZmVyQ2FsbGJhY2tfaAorCisjaWYgRU5BQkxFKFdF Ql9BVURJTykKKworI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworY2xhc3MgQXVkaW9CdWZmZXI7CisKK2NsYXNzIEF1ZGlvQnVmZmVyQ2FsbGJhY2sg OiBwdWJsaWMgUmVmQ291bnRlZDxBdWRpb0J1ZmZlckNhbGxiYWNrPiB7CitwdWJsaWM6CisgICAg dmlydHVhbCB+QXVkaW9CdWZmZXJDYWxsYmFjaygpIHsgfQorICAgIHZpcnR1YWwgYm9vbCBoYW5k bGVFdmVudChBdWRpb0J1ZmZlciopID0gMDsKK307CisKK30gLy8gbmFtZXNwYWNlCisKKyNlbmRp ZiAvLyBFTkFCTEUoV0VCX0FVRElPKQorCisjZW5kaWYgLy8gQXVkaW9CdWZmZXJDYWxsYmFja19o CkluZGV4OiBTb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb0J1ZmZlckNhbGxiYWNrLmlkbAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb0J1ZmZlckNhbGxiYWNr LmlkbAkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvQnVmZmVy Q2FsbGJhY2suaWRsCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDExLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMg Q09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KKyAq IEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUworICogU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor bW9kdWxlIGF1ZGlvIHsKKyAgICBpbnRlcmZhY2UgWworICAgICAgICBDb25kaXRpb25hbD1XRUJf QVVESU8sCisgICAgICAgIEdlbmVyYXRlVG9KUywKKyAgICAgICAgQ2FsbGJhY2sKKyAgICBdIEF1 ZGlvQnVmZmVyQ2FsbGJhY2sgeworICAgICAgICBib29sZWFuIGhhbmRsZUV2ZW50KGluIEF1ZGlv QnVmZmVyIGF1ZGlvQnVmZmVyKTsKKyAgICB9OworfQpJbmRleDogU291cmNlL1dlYkNvcmUvd2Vi YXVkaW8vQXVkaW9Db250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS93ZWJh dWRpby9BdWRpb0NvbnRleHQuY3BwCShyZXZpc2lvbiA4OTE3OSkKKysrIFNvdXJjZS9XZWJDb3Jl L3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI5LDcgKzI5LDkg QEAKICNpbmNsdWRlICJBdWRpb0NvbnRleHQuaCIKIAogI2luY2x1ZGUgIkFycmF5QnVmZmVyLmgi CisjaW5jbHVkZSAiQXN5bmNBdWRpb0RlY29kZXIuaCIKICNpbmNsdWRlICJBdWRpb0J1ZmZlci5o IgorI2luY2x1ZGUgIkF1ZGlvQnVmZmVyQ2FsbGJhY2suaCIKICNpbmNsdWRlICJBdWRpb0J1ZmZl clNvdXJjZU5vZGUuaCIKICNpbmNsdWRlICJBdWRpb0NoYW5uZWxNZXJnZXIuaCIKICNpbmNsdWRl ICJBdWRpb0NoYW5uZWxTcGxpdHRlci5oIgpAQCAtMjQ2LDYgKzI0OCwxMSBAQCBQYXNzUmVmUHRy PEF1ZGlvQnVmZmVyPiBBdWRpb0NvbnRleHQ6OmNyCiAgICAgcmV0dXJuIEF1ZGlvQnVmZmVyOjpj cmVhdGVGcm9tQXVkaW9GaWxlRGF0YShhcnJheUJ1ZmZlci0+ZGF0YSgpLCBhcnJheUJ1ZmZlci0+ Ynl0ZUxlbmd0aCgpLCBtaXhUb01vbm8sIHNhbXBsZVJhdGUoKSk7CiB9CiAKK3ZvaWQgQXVkaW9D b250ZXh0OjpkZWNvZGVBdWRpb0RhdGEoQXJyYXlCdWZmZXIqIGF1ZGlvRGF0YSwgUGFzc1JlZlB0 cjxBdWRpb0J1ZmZlckNhbGxiYWNrPiBzdWNjZXNzQ2FsbGJhY2ssIFBhc3NSZWZQdHI8QXVkaW9C dWZmZXJDYWxsYmFjaz4gZXJyb3JDYWxsYmFjaykKK3sKKyAgICBtX2F1ZGlvRGVjb2Rlci5kZWNv ZGVBc3luYyhhdWRpb0RhdGEsIHNhbXBsZVJhdGUoKSwgc3VjY2Vzc0NhbGxiYWNrLCBlcnJvckNh bGxiYWNrKTsKK30KKwogUGFzc1JlZlB0cjxBdWRpb0J1ZmZlclNvdXJjZU5vZGU+IEF1ZGlvQ29u dGV4dDo6Y3JlYXRlQnVmZmVyU291cmNlKCkKIHsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkp OwpJbmRleDogU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgJKHJldmlzaW9uIDg5 MTc5KQorKysgU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Db250ZXh0LmgJKHdvcmtpbmcg Y29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNkZWZpbmUgQXVkaW9Db250ZXh0X2gKIAogI2luY2x1 ZGUgIkFjdGl2ZURPTU9iamVjdC5oIgorI2luY2x1ZGUgIkFzeW5jQXVkaW9EZWNvZGVyLmgiCiAj aW5jbHVkZSAiQXVkaW9CdXMuaCIKICNpbmNsdWRlICJBdWRpb0Rlc3RpbmF0aW9uTm9kZS5oIgog I2luY2x1ZGUgIkV2ZW50TGlzdGVuZXIuaCIKQEAgLTQ0LDYgKzQ1LDcgQEAgbmFtZXNwYWNlIFdl YkNvcmUgewogCiBjbGFzcyBBcnJheUJ1ZmZlcjsKIGNsYXNzIEF1ZGlvQnVmZmVyOworY2xhc3Mg QXVkaW9CdWZmZXJDYWxsYmFjazsKIGNsYXNzIEF1ZGlvQnVmZmVyU291cmNlTm9kZTsKIGNsYXNz IEF1ZGlvQ2hhbm5lbE1lcmdlcjsKIGNsYXNzIEF1ZGlvQ2hhbm5lbFNwbGl0dGVyOwpAQCAtOTMs NiArOTUsOSBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxBdWRpb0J1ZmZlcj4gY3JlYXRlQnVm ZmVyKHVuc2lnbmVkIG51bWJlck9mQ2hhbm5lbHMsIHNpemVfdCBudW1iZXJPZkZyYW1lcywgZG91 YmxlIHNhbXBsZVJhdGUpOwogICAgIFBhc3NSZWZQdHI8QXVkaW9CdWZmZXI+IGNyZWF0ZUJ1ZmZl cihBcnJheUJ1ZmZlciogYXJyYXlCdWZmZXIsIGJvb2wgbWl4VG9Nb25vKTsKIAorICAgIC8vIEFz eW5jaHJvbm91cyBhdWRpbyBmaWxlIGRhdGEgZGVjb2RpbmcuCisgICAgdm9pZCBkZWNvZGVBdWRp b0RhdGEoQXJyYXlCdWZmZXIqLCBQYXNzUmVmUHRyPEF1ZGlvQnVmZmVyQ2FsbGJhY2s+ID0gMCwg UGFzc1JlZlB0cjxBdWRpb0J1ZmZlckNhbGxiYWNrPiA9IDApOworCiAgICAgLy8gS2VlcCB0cmFj ayBvZiB0aGlzIGJ1ZmZlciBzbyB3ZSBjYW4gcmVsZWFzZSBtZW1vcnkgYWZ0ZXIgdGhlIGNvbnRl eHQgaXMgc2h1dCBkb3duLi4uCiAgICAgdm9pZCByZWZCdWZmZXIoUGFzc1JlZlB0cjxBdWRpb0J1 ZmZlcj4gYnVmZmVyKTsKIApAQCAtMjkxLDYgKzI5Niw4IEBAIHByaXZhdGU6CiAgICAgUmVmUHRy PEF1ZGlvQnVmZmVyPiBtX3JlbmRlclRhcmdldDsKICAgICAKICAgICBib29sIG1faXNPZmZsaW5l Q29udGV4dDsKKworICAgIEFzeW5jQXVkaW9EZWNvZGVyIG1fYXVkaW9EZWNvZGVyOwogfTsKIAog fSAvLyBXZWJDb3JlCkluZGV4OiBTb3VyY2UvV2ViQ29yZS93ZWJhdWRpby9BdWRpb0NvbnRleHQu aWRsCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3dlYmF1ZGlvL0F1ZGlvQ29udGV4dC5p ZGwJKHJldmlzaW9uIDg5MTc5KQorKysgU291cmNlL1dlYkNvcmUvd2ViYXVkaW8vQXVkaW9Db250 ZXh0LmlkbAkod29ya2luZyBjb3B5KQpAQCAtNTIsNiArNTIsOSBAQCBtb2R1bGUgd2ViYXVkaW8g ewogICAgICAgICAvLyBBdWRpb0J1ZmZlciBjcmVhdGVCdWZmZXIoaW4gQXJyYXlCdWZmZXIgYnVm ZmVyLCBpbiBib29sZWFuIG1peFRvTW9ubyk7CiAgICAgICAgIFtDdXN0b21dIEF1ZGlvQnVmZmVy IGNyZWF0ZUJ1ZmZlcigpCiAgICAgICAgICAgICByYWlzZXMoRE9NRXhjZXB0aW9uKTsKKyAgICAg ICAgICAgIAorICAgICAgICAvLyBBc3luY2hyb25vdXMgYXVkaW8gZmlsZSBkYXRhIGRlY29kaW5n LgorICAgICAgICB2b2lkIGRlY29kZUF1ZGlvRGF0YShpbiBBcnJheUJ1ZmZlciBhdWRpb0RhdGEs IGluIFtDYWxsYmFja10gQXVkaW9CdWZmZXJDYWxsYmFjayBzdWNjZXNzQ2FsbGJhY2ssIGluIFtP cHRpb25hbCwgQ2FsbGJhY2tdIEF1ZGlvQnVmZmVyQ2FsbGJhY2sgZXJyb3JDYWxsYmFjayk7CiAK ICAgICAgICAgLy8gU291cmNlCiAgICAgICAgIEF1ZGlvQnVmZmVyU291cmNlTm9kZSBjcmVhdGVC dWZmZXJTb3VyY2UoKTsK