25898 2009-05-20 16:14:17 -0700 [Gtk] object:text-changed events should be emitted for entries and password text 2010-09-24 11:43:59 -0700 1 1 1 Unclassified WebKit Accessibility 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 25531 0 jdiggs webkit-unassigned apinheiro cfleizach commit-queue ctguil dglazkov enrica eric gustavo jmillan mario mrobinson rniwa walker.willie webkit-ews webkit.review.bot xan.lopez oldest_to_newest 122218 0 jdiggs 2009-05-20 16:14:17 -0700 At the moment, inserting and deleting entry text causes object:text-caret-moved events to be emitted. (Thanks!) In addition, object:text-changed:{insert,delete} should be emitted to inform ATs of: * the offset at which the change took place (detail1) * the length of the inserted/deleted text (detail2) * the string which was inserted or removed (any_data) See http://library.gnome.org/devel/atk/unstable/AtkText.html#AtkText-text-changed for more info. 248500 1 mario 2010-07-08 13:41:56 -0700 I was working on this bug for some time and at the end I manage to find a way that, hopefully, would make sense to allow notifying AT's when a piece of text is modified, by sending the apropriate signals, as described by Joanmarie. What I did was basically to follow the lead of what it was done with the text-caret-moved signal for GTK, which uses a dummy function in WebCore/editing/SelectionController.h for other platforms, providing a specific implementation for GTK through a WebCore/editing/gtk/SelectionControllerGtk.h file. Hence, after detecting that for the case of text-changed signal a11y should be notified from four commands (InsertIntoTextNode, DeleteFromTextNode, InsertNodeBefore and AppendNode), I followed the same idea and added a new notifyAccessibility() function to the header files in WebCore/editing for those four commands, implementing them through four new GTK-specific files under WebCore/editing/gtk. Most likely, you'll see some refactorization would be in place as the code in those 4 files is very similar, but at this stage (showing my patches) I preferred to keep everything separated to ease reviewing and understanding the patches. Last, but not least, I also needed to make a couple of small changes in WebCore/edition/DeleteSelectionCommand.cpp to ensure the DeleteFromTextNodeCommand is executed always when removing a text node, so accessibility could be notified as well in that case (I found that, without this change, at some situations a11y wouldn't have a way to notice when text is deleted, e.g., when deleting all the text in a field at once). Hence, I'm now attaching 5 patches, the first one implementing the changes in DeleteSelectionCommand.cpp I mentioned above and the other 4 implementing the modifications to each of those 4 commands: InsertIntoTextNode, DeleteFromTextNode, InsertNodeBefore and AppendNode. Eager to get some feedback! :-) PS: I've run all the layout tests with and without my changes and no regressions appeared, so I feel confident this shouldn't break anything, but you know... life is unpredictable :-) 248502 2 60944 mario 2010-07-08 13:44:00 -0700 Created attachment 60944 1. Call deleteTextFromNode() when needed while removing text nodes Do it even when removeNode() is going to be called afterwards, in order to allow accessibility to get properly notified about the text being removed alongside with that node. 248503 3 60945 mario 2010-07-08 13:44:39 -0700 Created attachment 60945 2. New InsertIntoTextNodeCommand::notifyAccessibility() private method Added a dummy version for all platforms but GTK, which comes with a specific implementation to handle the text-changed events 248504 4 60946 mario 2010-07-08 13:45:13 -0700 Created attachment 60946 3. New DeleteFromTextNodeCommand::notifyAccessibility() private method Added a dummy version for all platforms but GTK, which comes with a specific implementation to handle the text-changed events 248505 5 60947 mario 2010-07-08 13:45:54 -0700 Created attachment 60947 4. New InsertNodeBeforeCommand::notifyAccessibility() private method Added a dummy version for all platforms but GTK, which comes with a specific implementation to handle the text-changed events 248506 6 60948 mario 2010-07-08 13:46:30 -0700 Created attachment 60948 5. New AppendNodeCommand::notifyAccessibility() private method Added a dummy version for all platforms but GTK, which comes with a specific implementation to handle the text-changed events 248611 7 cfleizach 2010-07-08 16:13:52 -0700 How come the existing methods that handle value changing (you can find by searching for AXValueChange) are not catching these cases? i think have the notifyAccessibility code in a gtk Text handler is pretty limiting. it should probably work within the existing notification system that AX has, by calling postNotification directly or a specific handler within AXObjectCache 248772 8 mario 2010-07-08 23:47:24 -0700 Hi Chris, first of all thanks a lot for your comment. I'm pretty new to this WebKit a11y world and I appreciate a lot these kind of comments, really helpful indeed. (In reply to comment #7) > How come the existing methods that handle value changing (you can find by > searching for AXValueChange) are not catching these cases? Didn't say those methods are not handling that, I've just didn't know of them so perhaps they're working and nothing of this mess I did was needed after all. I'll check it out right now as I'd be more than glad if I could find a better and not so ad-hoce solution to this problem, specially considering it touches the core, and not just the gtk layer. > i think have the notifyAccessibility code in a gtk Text handler is pretty > limiting. it should probably work within the existing notification system > that AX has, by calling postNotification directly or a specific handler > within AXObjectCache I'll try this out as I also agree my current implementation it's pretty limiting... but at least it achieved one of its functions: to trigget some discussion and get some feedback to head towards the right direction :-) Thanks! 248776 9 cfleizach 2010-07-08 23:51:18 -0700 > (In reply to comment #7) > > How come the existing methods that handle value changing (you can find by > > searching for AXValueChange) are not catching these cases? > > Didn't say those methods are not handling that, I've just didn't know of them so perhaps they're working and nothing of this mess I did was needed after all. > I'll check it out right now as I'd be more than glad if I could find a better and not so ad-hoce solution to this problem, specially considering it touches the core, and not just the gtk layer. > Great. I think the existing value change notifications are pretty good chokepoints for handling text changes, but there might be missing cases. Is this to address when you're doing something like <div contenteditable=true> and want to know text changes or does GTK have true cursor support and navigation? 248789 10 mario 2010-07-09 00:26:52 -0700 (In reply to comment #9) > Great. I think the existing value change notifications are pretty good > chokepoints for handling text changes, but there might be missing cases. Indeed. Actually I've just found there's a nice function -already GTK specific- called postPlatformNotification() that looks like the way to go, at least for notifying of text insertions (I'm not so sure about deletions as typically, at least in gtk & clutter, those notifications should be emitted *before* the actual deletion happen). Let's see how it works. > Is this to address when you're doing something like <div contenteditable=true> > and want to know text changes or does GTK have true cursor support and > navigation? Not sure what you mean here. The idea is just to allow ATs get notified about text insertions and deletions (that includes typing new text, deleting individual char, replacing/deleting selections, copying from clipboard...) through the proper signal, specifying the offset and length of the piece of text being inserted or deleted. Once this info is emitted, the ATs will use that (offset, length) pair to find the piece of text being inserted/deleted in the platform-specific a11y object (an AtkObject, in GTK port). That's exactly why notifications about deletions should happen before the actual deletion: to find the text which is going to be deleted with the original text + the (offset, length) pair coming with the signal. Have I answered, at least partially or indirectly, your question? 248834 11 mario 2010-07-09 01:40:34 -0700 (In reply to comment #10) > (In reply to comment #9) > > Great. I think the existing value change notifications are pretty good > > chokepoints for handling text changes, but there might be missing cases. > > Indeed. Actually I've just found there's a nice function -already GTK specific- > called postPlatformNotification() that looks like the way to go, at least for > notifying of text insertions (I'm not so sure about deletions as typically, at > least in gtk & clutter, those notifications should be emitted *before* the > actual deletion happen). > > Let's see how it works. Hmm... I found another problem when trying to implement this (I mean, apart from the issue of having to emit the signal before deleting text): For properly emitting this signal, I need to know both the offset and the length of the piece of text being inserted or deleted, which is a kind of information I do have clearly available when implementing this through the notifyAccessibility() method in InsertIntoTextNodeCommand, DeleteFromTextNodeCommand, InsertNodeBeforeCommand and AppendNodeCommand. However, when I try to extract this information from AXObjectCache::postPlatformNotification(), I'm having a hard time to do it so since that information seems to have got lost up in the backtrace, far before calling to AXObjectCache::postNotification() in the first place, and I wonder if, given this requirements, perhaps after all the initial approach of doing this more ad-hoc in WebCore/editing could be the right way to do. Or perhaps there's actually a way to know both the offset and length for insertions and deletions from AXObjectCache that I'm missing... don't know yet. Perhaps, this is the same rationale behind the WebCore/editing/gtk/SelectionControllerGtk.cpp file, used to properly emit the text-caret-moved signal... Xan, could you please comment a bit on this? Thanks 249042 12 cfleizach 2010-07-09 09:24:52 -0700 > Hmm... I found another problem when trying to implement this (I mean, apart from the issue of having to emit the signal before deleting text): > > For properly emitting this signal, I need to know both the offset and the length of the piece of text being inserted or deleted, which is a kind of information I do have clearly available when implementing this through the notifyAccessibility() method in InsertIntoTextNodeCommand, DeleteFromTextNodeCommand, InsertNodeBeforeCommand and AppendNodeCommand. > > However, when I try to extract this information from AXObjectCache::postPlatformNotification(), I'm having a hard time to do it so since that information seems to have got lost up in the backtrace, far before calling to AXObjectCache::postNotification() in the first place, and I wonder if, given this requirements, perhaps after all the initial approach of doing this more ad-hoc in WebCore/editing could be the right way to do. Or perhaps there's actually a way to know both the offset and length for insertions and deletions from AXObjectCache that I'm missing... don't know yet. > > Perhaps, this is the same rationale behind the WebCore/editing/gtk/SelectionControllerGtk.cpp file, used to properly emit the text-caret-moved signal... Xan, could you please comment a bit on this? > > Thanks On the Mac side, its up to the screen reader to determine what has changed. the screen reader is only notified that the value has changed (that design decision was made a long time ago). If however, GTK needs more explicit information then your method of adding accessibility calls in each specific place is a reasonable approach, but I think you should either a) make specific methods for each type of text iteration in AXObjectCache that handles it b) make a new kind of AXNotification for each type of thing you need if need be, you might have to add a parameter argument to one of the postNotification methods i'd just like to see the code be in a common WebCore method so that other platforms could use if necessary 251024 13 mario 2010-07-14 01:33:58 -0700 First of all, sorry for not coming back to you before... I was busy with other matters this day and couldn't come to this earlier (In reply to comment #12) > [...] > On the Mac side, its up to the screen reader to determine what has changed. the screen reader is only notified that the value has changed (that design decision was made a long time ago). Thanks for the feedback, now I better understand the whole picture. > If however, GTK needs more explicit information then your method of adding accessibility calls in each specific place is a reasonable approach, but I think you should either > a) make specific methods for each type of text iteration in AXObjectCache that handles it > b) make a new kind of AXNotification for each type of thing you need > if need be, you might have to add a parameter argument to one of the postNotification methods > > i'd just like to see the code be in a common WebCore method so that other platforms could use if necessary I'm not really sure about what you mean with the points above... could you ellaborate a bit more on them? Thanks in advance 251682 14 cfleizach 2010-07-14 22:56:11 -0700 > > If however, GTK needs more explicit information then your method of adding accessibility calls in each specific place is a reasonable approach, but I think you should either > > a) make specific methods for each type of text iteration in AXObjectCache that handles it > > b) make a new kind of AXNotification for each type of thing you need > > if need be, you might have to add a parameter argument to one of the postNotification methods > > > > i'd just like to see the code be in a common WebCore method so that other platforms could use if necessary > > I'm not really sure about what you mean with the points above... could you ellaborate a bit more on them? > If sending out a ValueChange notification alone is not sufficient, I recommend putting void AppendNodeCommand::notifyAccessibility(bool isUndo) inside of AXObjectCache then having the GTK specific code live in either AXObjectCacheGTK or AccessibilityObjectGTK > Thanks in advance 252410 15 61782 mario 2010-07-16 01:52:49 -0700 Created attachment 61782 2. New functions in AXObjectCache to call when text changes in a node Added two new functions to allow notifying something changed in a text node either through a RenderObject or an AccessibilityObject, making those functions dependant on the platform-specific implementation, provided through a protected function. Also, provided a GTK implementation of the platform-specific function (as this change was motivated by the GTK port), as well as dummy implementations for the other ports with accessibility support, that is, mac and win ports. 252411 16 61783 mario 2010-07-16 01:53:28 -0700 Created attachment 61783 3. Notify accessibility when something changes in a text node Call to AXObjectCache::nodeTextChangeNotification() to notify when text was inserted/deleted when applying/unapplying a text edition command, along with the offset in the original text where the change took place and the number of characters that got affected. 252412 17 mario 2010-07-16 01:56:57 -0700 (In reply to comment #14) > [...] > > If sending out a ValueChange notification alone is not sufficient, I recommend > putting > > void AppendNodeCommand::notifyAccessibility(bool isUndo) > > inside of AXObjectCache > > then having the GTK specific code live in either AXObjectCacheGTK or > AccessibilityObjectGTK Thanks for the clarification, Chris. As you can see I've attached two new patches replacing the old 2-5 patches (1st patch would be still valid as it is), hopefully properly addressing your suggestion of centralizing code in AXObjectCache and AXObjectCacheGtk. I've tried this new way of doign things out and it works exactly the same, passing both the API and Layout tests as well, at least in the gtk build (I couldn't try to compile for other ports but the dummy implementation of nodeTextChangePlatformNotification for win and mac shouldn't be an issue) 252414 18 webkit-ews 2010-07-16 02:03:05 -0700 Attachment 61783 did not build on qt: Build output: http://webkit-commit-queue.appspot.com/results/3559063 252415 19 webkit.review.bot 2010-07-16 02:21:55 -0700 Attachment 61783 did not build on gtk: Build output: http://webkit-commit-queue.appspot.com/results/3581053 252423 20 mario 2010-07-16 02:38:18 -0700 (In reply to comment #18) > Attachment 61783 [details] did not build on qt: > Build output: http://webkit-commit-queue.appspot.com/results/3559063 (In reply to comment #19) > Attachment 61783 [details] did not build on gtk: > Build output: http://webkit-commit-queue.appspot.com/results/3581053 I was shocked at first with these messages but then I understood what's going on here is just that the WK bot is compiling the three patches separately, so obviously the third one won't compile as it depends on the second one. I guess there's nothing I could do for this apart of merging both patches in a single one, but I don't think that would be a good idea as those are clearly two different patches IMHO. Anyway, if someone knows something better to be done wrt this, please speak up :-) 252427 21 webkit.review.bot 2010-07-16 02:46:37 -0700 Attachment 61783 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/3577057 252468 22 webkit.review.bot 2010-07-16 06:05:14 -0700 Attachment 61783 did not build on win: Build output: http://webkit-commit-queue.appspot.com/results/3412420 252564 23 61782 cfleizach 2010-07-16 09:43:32 -0700 Comment on attachment 61782 2. New functions in AXObjectCache to call when text changes in a node This patch is just about there. I'm putting review- just because i'd like to see it one more time before it goes through. thanks! WebCore/accessibility/AXObjectCache.cpp:473 + } it looks like you don't really need this method, since its only used by the RenderObject version. WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:68 + This looks like a roundabout way to get object->parentObject()->wrapper(). WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:73 + identation is wrong WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:88 + identation is wrong WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:94 + } looks like you should use a switch statement here which sets a char* or String to "text-change*". then you'd only have to call g_signal* one time. WebCore/accessibility/win/AXObjectCacheWin.cpp:113 + 1.7.0.4 extra line removal not needed WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:65 + identation 252567 24 61783 cfleizach 2010-07-16 09:49:05 -0700 Comment on attachment 61783 3. Notify accessibility when something changes in a text node Adding r=me. I think the changes you need to make are straightforward for this one. I think calling these methods can be mostly reduce to two lines for each instance if (AXObjectCache::) document()->axCache()->nodeTextChange() WebCore/editing/AppendNodeCommand.cpp:60 + 0, len); indentation WebCore/editing/AppendNodeCommand.cpp:61 + } do you need the line breaking here in nodeTextChangeNotification? WebCore/editing/AppendNodeCommand.cpp:78 + } I think the len > 0, node->nodeValue() != "\n" should go into the logic inside AXObjectCache. Different platforms may want to process those, so i think it should be left up to AX code to handle those cases. it will also make these code snippets much simpler WebCore/editing/DeleteFromTextNodeCommand.cpp:63 + for one line if statements, no braces needed WebCore/editing/DeleteFromTextNodeCommand.cpp:82 + } no braces needed WebCore/editing/InsertIntoTextNodeCommand.cpp:57 + } no braces needed WebCore/editing/InsertIntoTextNodeCommand.cpp:71 + no braces needed WebCore/editing/InsertNodeBeforeCommand.cpp:62 + } same comments, let the AX code handle whether it should process this based on length or not WebCore/editing/InsertNodeBeforeCommand.cpp:78 + } ditto as above WebCore/editing/InsertNodeBeforeCommand.cpp:84 + 1.7.0.4 extra line removed, should not be 252569 25 60944 cfleizach 2010-07-16 09:51:05 -0700 Comment on attachment 60944 1. Call deleteTextFromNode() when needed while removing text nodes Someone more familiar with text editing should take a look at this one 252751 26 61859 mario 2010-07-16 16:36:35 -0700 Created attachment 61859 2. New functions in AXObjectCache to call when text changes in a node First of all, thanks for reviewing and sorry for marking the patch you set as review+ as obsolete, but I had to do it since I couldn't commit the changes by myself anyway (I'm not committer). So I'm now just replacing the old version of the patch with a new one so you could review it and, if it's correct, both mark it as review+ and commit-queue+ :-) (In reply to comment #23) > (From update of attachment 61782 [details]) > This patch is just about there. I'm putting review- just because i'd like to see it one more time before it goes through. thanks! > > WebCore/accessibility/AXObjectCache.cpp:473 > + } > it looks like you don't really need this method, since its only used by the RenderObject version. Sure, you're right. I did it that way following the lead of the AXObject::postNotification() method, thinking that perhaps that was the way to go because of some yet-unknown reason to me... but I normally think needed methods should get in, and if you think the same that's a good reason for me to remove it. So... done. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:68 > + > This looks like a roundabout way to get object->parentObject()->wrapper(). True. I'm still getting used to this forest of trees in WK and sometimes I get a bit lost... as in this case :-). Thanks for pointing it out, I've tried your suggestion and works also as a charm (but cleaner). Done. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:73 > + > identation is wrong > > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:88 > + > identation is wrong Fixed all indentation issues in all files. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:94 > + } > looks like you should use a switch statement here which sets a char* or String to "text-change*". then you'd only have to call g_signal* one time. Done (I've used a GOwnPtr to avoid using g_free(), hope that's the right thing to do) > WebCore/accessibility/win/AXObjectCacheWin.cpp:113 > + 1.7.0.4 > extra line removal not needed Not sure I understand this one... Isn't it just the end of the patch file? > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:65 > + > identation Fixed. Thanks for the review. As I said at the beginning here you have attached a new patch addressing these issues 252760 27 61861 mario 2010-07-16 16:49:32 -0700 Created attachment 61861 3. Notify accessibility when something changes in a text node Now attaching a new patch to replace this one as well... (In reply to comment #24) > (From update of attachment 61783 [details]) > Adding r=me. I think the changes you need to make are straightforward for this one. I think calling these methods can be mostly reduce to two lines for each instance > if (AXObjectCache::) > document()->axCache()->nodeTextChange() As I said in my previous comment, I'm not a committer so if you're ok with this new patch I'd appreciate that, if possible, you set the commit-queue+ flag alongside with the review+ (supposing it's correct!). > WebCore/editing/AppendNodeCommand.cpp:60 > + 0, len); > indentation Fixed, alongside with the rest of the indentation issues. > WebCore/editing/AppendNodeCommand.cpp:61 > + } > do you need the line breaking here in nodeTextChangeNotification? I'm very used not to trespass the 80 line whenever possible so that's why I broke it. Anyway, I was checking other files and it seems in WK code it's not that strange to find long lines every now and then, so I've just changed this to one line as well. > WebCore/editing/AppendNodeCommand.cpp:78 > + } > I think the len > 0, node->nodeValue() != "\n" should go into the logic inside AXObjectCache. Different platforms may want to process those, so i think it should be left up to AX code to handle those cases. > it will also make these code snippets much simpler Absolutely. The length check should be in the platform specific code (and it actually is already there!), and doing it outside it's just plain useless and unneeded. However, I need to leave the "\n" check in AppendNodeCommand since that's there to avoid to notify a11y twice, as in that case it happens that the InserNodeBeforeCommand will be always executed whenever a linebreak is done (while AppendNodecommand is only run when making a linebreak at the end of the text), so there's no need to do it also here (and it would even be a mistake IMHO) > WebCore/editing/DeleteFromTextNodeCommand.cpp:63 > + > for one line if statements, no braces needed Done. > WebCore/editing/DeleteFromTextNodeCommand.cpp:82 > + } > no braces needed Done > WebCore/editing/InsertIntoTextNodeCommand.cpp:57 > + } > no braces needed Done > WebCore/editing/InsertIntoTextNodeCommand.cpp:71 > + > no braces needed Done > > WebCore/editing/InsertNodeBeforeCommand.cpp:62 > + } > same comments, let the AX code handle whether it should process this based on length or not > > WebCore/editing/InsertNodeBeforeCommand.cpp:78 > + } > ditto as above > Done > WebCore/editing/InsertNodeBeforeCommand.cpp:84 > + 1.7.0.4 > extra line removed, should not be As I said in the previous command, I don't understand this thing :-) 252761 28 webkit-ews 2010-07-16 16:55:04 -0700 Attachment 61861 did not build on qt: Build output: http://webkit-commit-queue.appspot.com/results/3590065 252762 29 webkit.review.bot 2010-07-16 16:55:22 -0700 Attachment 61861 did not build on gtk: Build output: http://webkit-commit-queue.appspot.com/results/3584083 252764 30 webkit.review.bot 2010-07-16 16:58:54 -0700 Attachment 61861 did not build on chromium: Build output: http://webkit-commit-queue.appspot.com/results/3378507 252769 31 cfleizach 2010-07-16 17:03:56 -0700 (In reply to comment #30) > Attachment 61861 [details] did not build on chromium: > Build output: http://webkit-commit-queue.appspot.com/results/3378507 Can you fix this build failure for chromium 252770 32 cfleizach 2010-07-16 17:04:54 -0700 (In reply to comment #31) > (In reply to comment #30) > > Attachment 61861 [details] [details] did not build on chromium: > > Build output: http://webkit-commit-queue.appspot.com/results/3378507 > > Can you fix this build failure for chromium can't remember right now if chromium has their own AXObjectCache version that needs to be updated 252771 33 61859 cfleizach 2010-07-16 17:05:41 -0700 Comment on attachment 61859 2. New functions in AXObjectCache to call when text changes in a node patch looks ok r=me 252772 34 61861 cfleizach 2010-07-16 17:06:45 -0700 Comment on attachment 61861 3. Notify accessibility when something changes in a text node patch looks ok r=me 252775 35 60944 cfleizach 2010-07-16 17:07:18 -0700 Comment on attachment 60944 1. Call deleteTextFromNode() when needed while removing text nodes Can you add a layout test for this, now that the groundwork is in place? 252783 36 61859 commit-queue 2010-07-16 17:31:07 -0700 Comment on attachment 61859 2. New functions in AXObjectCache to call when text changes in a node Rejecting patch 61859 from commit-queue. Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 Last 500 characters of output: /bin/yacc /bin/sh -c /Users/eseidel/Projects/CommitQueue/WebKitBuild/WebCore.build/Debug/WebCore.build/Script-5DF50887116F3077005202AB.sh ** BUILD FAILED ** The following build commands failed: WebCore: Distributed-CompileC /Users/eseidel/Projects/CommitQueue/WebKitBuild/WebCore.build/Debug/WebCore.build/Objects-normal/i386/AXObjectCacheMac.o /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm normal i386 objective-c++ com.apple.compilers.gcc.4_2 (1 failure) Full output: http://webkit-commit-queue.appspot.com/results/3365513 252786 37 cfleizach 2010-07-16 17:33:56 -0700 > > Full output: http://webkit-commit-queue.appspot.com/results/3365513 /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'object' /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'textChange' /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'offset' /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'count' please submit a new patch 252791 38 61861 commit-queue 2010-07-16 17:49:20 -0700 Comment on attachment 61861 3. Notify accessibility when something changes in a text node Rejecting patch 61861 from commit-queue. Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 Last 500 characters of output: ild/WebCore.build/Debug/WebCore.build/Objects-normal/i386/InsertNodeBeforeCommand.o /Users/eseidel/Projects/CommitQueue/WebCore/editing/InsertNodeBeforeCommand.cpp normal i386 c++ com.apple.compilers.gcc.4_2 Distributed-CompileC /Users/eseidel/Projects/CommitQueue/WebKitBuild/WebCore.build/Debug/WebCore.build/Objects-normal/i386/DeleteFromTextNodeCommand.o /Users/eseidel/Projects/CommitQueue/WebCore/editing/DeleteFromTextNodeCommand.cpp normal i386 c++ com.apple.compilers.gcc.4_2 (4 failures) Full output: http://webkit-commit-queue.appspot.com/results/3366511 252858 39 61880 mario 2010-07-17 02:30:55 -0700 Created attachment 61880 2. New functions in AXObjectCache to call when text changes in a node (In reply to comment #32) > (In reply to comment #31) > > (In reply to comment #30) > > > Attachment 61861 [details] [details] [details] did not build on chromium: > > > Build output: http://webkit-commit-queue.appspot.com/results/3378507 > > > > Can you fix this build failure for chromium > > can't remember right now if chromium has their own AXObjectCache version that needs to be updated You're right, sorry for not realizing before: $ find . -name "AXObject*" ./WebCore/accessibility/gtk/AXObjectCacheAtk.cpp ./WebCore/accessibility/mac/AXObjectCacheMac.mm ./WebCore/accessibility/chromium/AXObjectCacheChromium.cpp ./WebCore/accessibility/win/AXObjectCacheWin.cpp ./WebCore/accessibility/AXObjectCache.cpp ./WebCore/accessibility/AXObjectCache.h Added dummy implementation for chromium in the patch being attached now (as the root problem actually belonged to patch 61859, not 61861) (In reply to comment #37) > > > > Full output: http://webkit-commit-queue.appspot.com/results/3365513 > > /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'object' > /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'textChange' > /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'offset' > /Users/eseidel/Projects/CommitQueue/WebCore/accessibility/mac/AXObjectCacheMac.mm:117: warning: unused parameter 'count' > > please submit a new patch Damm it... I didn't realize about the function header's params, sorry. Fixed in this patch for all dummy implementations (mac, win and chromium), as well as the inline declarations in AXObjectCache.h for those platforms which !HAVE(ACCESSIBILITY) Sorry for the inconvenience... working till very late yesterday :-) 252859 40 mario 2010-07-17 02:32:49 -0700 (In reply to comment #35) > (From update of attachment 60944 [details]) > Can you add a layout test for this, now that the groundwork is in place? Not sure whether a layout test would be needed, nor what exactly should I test if it was... could you (or anyone else) please give me a tip on this, if possible (so I could work on Monday on it)? Thanks in advance. 252860 41 mario 2010-07-17 02:35:46 -0700 (In reply to comment #38) > (From update of attachment 61861 [details]) > Rejecting patch 61861 from commit-queue. > > Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 > Last 500 characters of output: > ild/WebCore.build/Debug/WebCore.build/Objects-normal/i386/InsertNodeBeforeCommand.o /Users/eseidel/Projects/CommitQueue/WebCore/editing/InsertNodeBeforeCommand.cpp normal i386 c++ com.apple.compilers.gcc.4_2 > Distributed-CompileC /Users/eseidel/Projects/CommitQueue/WebKitBuild/WebCore.build/Debug/WebCore.build/Objects-normal/i386/DeleteFromTextNodeCommand.o /Users/eseidel/Projects/CommitQueue/WebCore/editing/DeleteFromTextNodeCommand.cpp normal i386 c++ com.apple.compilers.gcc.4_2 > (4 failures) > > > Full output: http://webkit-commit-queue.appspot.com/results/3366511 This error looks to me like "normal" as this third patch couldn't be applied without having applied the second one first (as it was the case cause it got review-). But if I'm wrong in my guessing just let me know and I'll happily work on fixing whatever is needed. 252861 42 mario 2010-07-17 02:37:33 -0700 (In reply to comment #40) > (In reply to comment #35) > > (From update of attachment 60944 [details] [details]) > > Can you add a layout test for this, now that the groundwork is in place? > > Not sure whether a layout test would be needed, nor what exactly should I test if it was... could you (or anyone else) please give me a tip on this, if possible (so I could work on Monday on it)? > > Thanks in advance. Btw, this first patch is needed for the other two to work correctly so I'd recommend not setting commit-queue+ on those until we feel this first one is absolutely complete and done. Now time to start the weekend. See you on Monday 252920 43 61880 cfleizach 2010-07-17 16:23:08 -0700 Comment on attachment 61880 2. New functions in AXObjectCache to call when text changes in a node r=me 254320 44 mario 2010-07-21 08:57:19 -0700 (In reply to comment #25) > (From update of attachment 60944 [details]) > Someone more familiar with text editing should take a look at this one Just a small question, as I'm seeing this patch is the only one pending to be reviewed to fix this bug... who could I ask for reviewing this patch? Guess there's not a big hurry for the time being, but I'd like to know whether I need to do something or not in order not to leave this bug stalled :-) 254338 45 cfleizach 2010-07-21 09:24:23 -0700 (In reply to comment #44) > (In reply to comment #25) > > (From update of attachment 60944 [details] [details]) > > Someone more familiar with text editing should take a look at this one > > Just a small question, as I'm seeing this patch is the only one pending to be reviewed to fix this bug... who could I ask for reviewing this patch? > > Guess there's not a big hurry for the time being, but I'd like to know whether I need to do something or not in order not to leave this bug stalled :-) good question. maybe xan lopez 254364 46 mario 2010-07-21 09:53:35 -0700 (In reply to comment #45) > [...] > > Guess there's not a big hurry for the time being, but I'd like to know whether I need to do > something or not in order not to leave this bug stalled :-) > > good question. maybe xan lopez Great. I'll annoy him with this issue next week in GUADEC :-) Thanks Chris for your help 254885 47 60944 ojan 2010-07-22 11:01:09 -0700 Comment on attachment 60944 1. Call deleteTextFromNode() when needed while removing text nodes Can you add a test for the new behavior? 255126 48 61783 eric 2010-07-22 18:19:28 -0700 Comment on attachment 61783 3. Notify accessibility when something changes in a text node Cleared Chris Fleizach's review+ from obsolete attachment 61783 so that this bug does not appear in http://webkit.org/pending-commit. 255127 49 61859 eric 2010-07-22 18:19:48 -0700 Comment on attachment 61859 2. New functions in AXObjectCache to call when text changes in a node Cleared Chris Fleizach's review+ from obsolete attachment 61859 so that this bug does not appear in http://webkit.org/pending-commit. 256894 50 mario 2010-07-27 15:30:02 -0700 (In reply to comment #47) > (From update of attachment 60944 [details]) > Can you add a test for the new behavior? As I said above, not sure what should I test here... could you please provide some tips? Thanks in advance 257582 51 mario 2010-07-29 01:10:08 -0700 (In reply to comment #50) > (In reply to comment #47) > > (From update of attachment 60944 [details] [details]) > > Can you add a test for the new behavior? > > As I said above, not sure what should I test here... could you please provide some tips? I talked to Xan about this in GUADEC and he didn't have a clue either about how to test this, although he agrees that a test could be needed anyway to test the changes done so deep in the WebCore/editing area. So, I'm now adding Enrica Casucci to CC as recommended by Xan, to see whether she (hopefully) could help me understand which kind of test should be done here (if any) in order to move this stuff forward. Thanks in advance 258767 52 mario 2010-08-02 03:35:19 -0700 (In reply to comment #51) > So, I'm now adding Enrica Casucci to CC as recommended by Xan, to see whether > she (hopefully) could help me understand which kind of test should be done here > (if any) in order to move this stuff forward. Looks like I forgot to actually add her to CC :-$. Now doing it so. 259024 53 enrica 2010-08-02 11:58:52 -0700 (In reply to comment #52) > (In reply to comment #51) > > So, I'm now adding Enrica Casucci to CC as recommended by Xan, to see whether > > she (hopefully) could help me understand which kind of test should be done here > > (if any) in order to move this stuff forward. > > Looks like I forgot to actually add her to CC :-$. Now doing it so. Mario, I would greatly appreciate if you could merge all the patches into one. I have a hard time understanding now which ones are in an which ones are out. I'll be happy to review the editing specific part. I would like to be able to assess the impact on these changes for platforms other than Gtk. As far as testing, use as reference the folder accessibility under LayoutTests. You can find a lot of examples of tests for accessibility related stuff. Take a look at the source code of dumpRenderTree to get more details on the accessibilityController object and its capabilities. 259338 54 mario 2010-08-03 03:04:42 -0700 (In reply to comment #53) > Mario, I would greatly appreciate if you could merge all the patches into > one. I did it in separate patches because I thought it would be better for reviewing them. But I do not have any problem squashing them all into just one patch, I'll upload it as soon as I have it done and tested. > I have a hard time understanding now which ones are in an which ones are out. Basically, none of them are in now. Patches (2) and (3) are currently review+ but not committed yet since they're dependant on patch (1), the one I was actually asking you for reviewing it :-) > I'll be happy to review the editing specific part. Great, thanks! > I would like to be able to assess the impact on these changes for platforms > other than Gtk. Currently I just can test this for the GTK platform. I'll try to somehow measure the performance to see whether there's some regression on that regard. > As far as testing, use as reference the folder accessibility under > LayoutTests. You can find a lot of examples of tests for accessibility > related stuff. Take a look at the source code of dumpRenderTree to get more > details on the accessibilityController object and its capabilities. Been there, done that :-), actually my question was more about what kind of test I could do to check whether these changes are correct or not, I mean... whether you could have an idea of what kind of assertions, situations and so forth I should test to make sure the change is correct. So far I've checked no regressions happened neither in the current Layout tests nor in the unit tests, not sure whether that's enough, though. Thanks for the feedback, I'll be back soon with the squashed patch 259345 55 63314 mario 2010-08-03 03:20:04 -0700 Created attachment 63314 Single patch for fixing this bug (In reply to comment #54) > Thanks for the feedback, I'll be back soon with the squashed patch As promised, attached a single patch for this 259795 56 61861 eric 2010-08-03 18:48:58 -0700 Comment on attachment 61861 3. Notify accessibility when something changes in a text node Cleared Chris Fleizach's review+ from obsolete attachment 61861 so that this bug does not appear in http://webkit.org/pending-commit. 259796 57 61880 eric 2010-08-03 18:49:05 -0700 Comment on attachment 61880 2. New functions in AXObjectCache to call when text changes in a node Cleared Chris Fleizach's review+ from obsolete attachment 61880 so that this bug does not appear in http://webkit.org/pending-commit. 259941 58 mario 2010-08-04 02:45:15 -0700 (In reply to comment #55) > Created an attachment (id=63314) [details] > Single patch for fixing this bug > > (In reply to comment #54) > > Thanks for the feedback, I'll be back soon with the squashed patch > > As promised, attached a single patch for this I was doing some tests deleting huge amounts of text at once from input text fields (text areas), in order to see if my patch (specially because of the changes in WebCore/editing/DeleteSelectionCommand) degraded at some extent the performance, and the results are good, even quite surprising, I'd say: #chars BEFORE AFTER ================================ 10000 2 ms 2 ms 20000 3 ms 1 ms 30000 2 ms 1 ms 40000 4 ms 1 ms 50000 4 ms 2 ms 60000 6 ms 1 ms 70000 5 ms 2 ms 80000 6 ms 2 ms 90000 7 ms 2 ms 100000 8 ms 2 ms ... ... ... 250000 18 ms 5 ms ... ... ... 500000 36 ms 9 ms ... ... ... 750000 51 ms 14 ms ... ... ... 900000 63 ms 17 ms 910000 63 ms 17 ms 920000 64 ms 16 ms 930000 64 ms 16 ms 940000 65 ms 17 ms 950000 66 ms 16 ms 960000 65 ms 17 ms 970000 67 ms 17 ms 980000 67 ms 16 ms 990000 69 ms 17 ms 1000000 69 ms 17 ms Explanation: - #chars: total number of characters in a text node which is going to be emptied - BEFORE: time involved in removing all the text in a row, WITHOUT the patch - AFTER: time involved in removing all the text in a row, WITH the patch Notice that results are shown over 10000 characters being deleted because under that value the differences were practically inexistent. As you can see there's no performance regression with the patch, but even an improvement, so I guess the patch is fine wrt performance. However, such an improvement is something I hardly can explain at this point, sorry... just let me say that I repeated this tests several times and the results were always similar for each situation. Perhaps, based on this information, someone else with more knowledge in how editing works can drop some light on this... or perhaps my tests are just crap, who knows :-) Hope this information helps 260646 59 63314 cfleizach 2010-08-05 09:01:07 -0700 Comment on attachment 63314 Single patch for fixing this bug All the accessibility code looks good. If someone can just review the changes in DeleteSelectionCommmand.cpp, this patch can be r+ 260650 60 63314 eric 2010-08-05 09:12:15 -0700 Comment on attachment 63314 Single patch for fixing this bug WebCore/accessibility/AXObjectCache.cpp:463 + RefPtr<AccessibilityObject> object = getOrCreate(renderer); getOrCreate needlessly returns a PassRefPtr, sadly. Not your fault, but sad that it does here since it holds the reference itself. WebCore/accessibility/AXObjectCache.h:132 + void nodeTextChangeNotification(RenderObject*, AXTextChange, unsigned offset, unsigned count); Can this be a more specific type than RenderObject*? We're trying to move to a more strongly typed RenderTree usage. The AX code is currently the worse offender. WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:62 + AccessibilityRenderObject* renderObject = static_cast<AccessibilityRenderObject*>(object); Do we not have a toAccessibiltyRenderObject() function to do this cast more safely? WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:63 + RenderObject* renderer = renderObject->renderer(); This is confusing to names the ax renderer "renderObject". I would have called it axRenderObject or axRenderer or similar. WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:66 + Node* node = renderer->node(); I'm surprised that AccessibilityRenderObject doesn't already have a node() helper method? WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:68 + // Calculate global offset (in the whole text, not just in the current node) Please put this in a helper function. WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:80 + // Emit the right signal Please put this in a helper function too. WebCore/editing/AppendNodeCommand.cpp:58 + document()->axObjectCache()->nodeTextChangeNotification(m_node->renderer(), AXObjectCache::AXTextInserted, 0, len); Can we pass a more specific type here? WebCore/editing/AppendNodeCommand.cpp:54 + if (AXObjectCache::accessibilityEnabled()) { It seems this block should be a helper function "sendAXTextChangedIngnoringLineBreaks" Obviously you'd pass the type of notification. If you wanted to share with the non-ignoring linebreaks case, you'd use an enum ShouldIgnoreLineBreaks { IgnoreLineBreaks, IncludingLineBreaks } and make "IncludingLineBreaks" the default value. WebCore/editing/AppendNodeCommand.cpp:68 + if (AXObjectCache::accessibilityEnabled()) { Copy/paste code is work of the devil. :p WebCore/editing/DeleteSelectionCommand.cpp:  + } else if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { Was this an ordered else-if for a reason? WebCore/editing/DeleteSelectionCommand.cpp:459 + // just delete This comment isn't helpful. 260992 61 enrica 2010-08-05 17:45:46 -0700 I'm not sure I understand why you need to call deleteTextFromNode instead of removing the node as before and make there the notification for the accessibility. Am I missing something? I also don't fully the get the meaning of the change in the order of the checks. I'll apply the patch and look at the modified code. 261133 62 mario 2010-08-06 00:11:54 -0700 (In reply to comment #61) > I'm not sure I understand why you need to call deleteTextFromNode instead of > removing the node as before and make there the notification for the > accessibility. Am I missing something? When I wrote that I wanted to support the needs of the signal to be emmitted (which need the offset and count values for a given deletion) both in the case of actively deleting a piece of text as in the case of undoing such an operation. Hence, as those pieces of information are inside the the DeleteFromTextNode command there, which also provides both the doApply() and doUnapply() methods, I thought that would be the right place to notify accessibility, which makes it also coherent with the cases of InsertIntoTextNode, AppendNode and InsertNodeBefore commands. But perhaps there's a way also to implement this, both working with do's and undo's, right there in DeleteSelectionCommand. Not sure yet, though. Any thought on this? > I also don't fully the get the meaning of the change in the order of the > checks. The change in the order is just to make sure we execute the "else if" branches where deleteFromTextNode() is present, even in the case the main "if" branch would be the way to go when removing all the text from a node (so we'd just remove the node, not the text from it first). So actually there's no new logic there in the general case, just an extra step in the case when removing the node would be needed (removing the text first). > I'll apply the patch and look at the modified code. Thanks a lot for your time, Enrica. I'm not 100% sure either about the editing part (that's why I asked you directly) and I really appreciate you trying to help with this stuff. 261187 63 63712 mario 2010-08-06 04:24:55 -0700 Created attachment 63712 Single patch for fixing this bug (In reply to comment #60) > (From update of attachment 63314 [details]) > WebCore/accessibility/AXObjectCache.cpp:463 > + RefPtr<AccessibilityObject> object = getOrCreate(renderer); > getOrCreate needlessly returns a PassRefPtr, sadly. Not your fault, but sad that it does here since it holds the reference itself. Actually, getOrCreate() is handling and returning a RefPtr, not a PassRefPtr, so I guess the only problem in the code is actually my fault and a matter of changing the following line in AXObjectCache.cpp: RefPtr<AccessibilityObject> object = getOrCreate(renderer); ...into something like this: AccessibilityObject* object = getOrCreate(renderer); ...which is what it's done all over the place and seems to me like the right way to go (done in current new attachment) > WebCore/accessibility/AXObjectCache.h:132 > + void nodeTextChangeNotification(RenderObject*, AXTextChange, unsigned offset, unsigned count); > Can this be a more specific type than RenderObject*? We're trying to move to a more strongly typed RenderTree usage. The AX code is currently the worse offender. As far as I can see, it can't, because using an specific subclass like RenderText would be not correct, as other subclasses of RenderObject (such as RenderTextControl, which is NOT a subclass of RenderText) would also be valid for this method. So, I guess there's no best option here than accepting a RenderObject and later on checking whether is actually the right kind of object depending on the context (for the gtk port the rule of thumb would be that the associated platform-dependant a11y object (the wrapper) should implement the AtkText interface. Also, looking for something else in AXObjectCache.h that could help me with this I think I found a similar situation with the AXObjectCache::contentChanged() method: // Called by a node when text or a text equivalent (e.g. alt) attribute is changed. void contentChanged(RenderObject*); Looks like it could use a RenderObject because of a similar reason, not 100% sure though. Anyway, feel free to point out that I'm completely wrong if you think so. I'll appreciate that. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:62 > + AccessibilityRenderObject* renderObject = static_cast<AccessibilityRenderObject*>(object); > Do we not have a toAccessibiltyRenderObject() function to do this cast more safely? Added to AccessibilityRenderObject.h, following the lead of other similar ones, such as toRenderText() > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:63 > + RenderObject* renderer = renderObject->renderer(); > This is confusing to names the ax renderer "renderObject". I would have called it axRenderObject or axRenderer or similar. Taken into account (although no longer a problem) in the new patch. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:66 > + Node* node = renderer->node(); > I'm surprised that AccessibilityRenderObject doesn't already have a node() helper method? Fixed. > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:68 > + // Calculate global offset (in the whole text, not just in the current node) > Please put this in a helper function. > > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:80 > + // Emit the right signal > Please put this in a helper function too. Done (both). > WebCore/editing/AppendNodeCommand.cpp:58 > + document()->axObjectCache()->nodeTextChangeNotification(m_node->renderer(), AXObjectCache::AXTextInserted, 0, len); > Can we pass a more specific type here? I think we can't in this case. See rationale above. > WebCore/editing/AppendNodeCommand.cpp:54 > + if (AXObjectCache::accessibilityEnabled()) { > It seems this block should be a helper function "sendAXTextChangedIngnoringLineBreaks" > Obviously you'd pass the type of notification. Done that way > If you wanted to share with the non-ignoring linebreaks case, you'd use an enum ShouldIgnoreLineBreaks { IgnoreLineBreaks, IncludingLineBreaks } and make "IncludingLineBreaks" the default value. I thought about that, but in this case I think it's more than enough (and even cleaner) to implement it the other way. > WebCore/editing/AppendNodeCommand.cpp:68 > + if (AXObjectCache::accessibilityEnabled()) { > Copy/paste code is work of the devil. :p Agreed, copy/paste along with "premature optimizations" are the "root of all evil". Fixed. > WebCore/editing/DeleteSelectionCommand.cpp:  > + } else if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { > Was this an ordered else-if for a reason? As explained in comments #1 and #62 (and maybe somewhere else as well), the idea is to make sure the deleteFromTextNode() function gets executed even when removing all the text of a node, so that "else if" must become a normal "if" and moved above the "if (removing-all-text) { removeNode() }" branch, to make sure it gets executed before removing the node. > WebCore/editing/DeleteSelectionCommand.cpp:459 > + // just delete > This comment isn't helpful. I missed this one, thanks for the catch. As you can see I'm now attaching a new patch addressing all the issues commented above but the thing about being more specific with the RenderObject parameter, as explained above. Hope this new patch gets closer to the good solution, and thanks a lot for your thoroughful review, Eric. 261336 64 eric 2010-08-06 10:33:37 -0700 This looks OK to me now. Sounds like you're still waiting for a response from Enrica, but I'm happy to r+ it once that conversation is over (or she's welcome to). 261686 65 mario 2010-08-07 00:55:01 -0700 (In reply to comment #64) > This looks OK to me now. Sounds like you're still waiting for a response from > Enrica, but I'm happy to r+ it once that conversation is over (or she's welcome > to). Great, let's wait for Enrica's opinion then. 263078 66 mario 2010-08-11 00:06:57 -0700 (In reply to comment #65) > [...] > Great, let's wait for Enrica's opinion then. I hate being perhaps too insistent with this so please Enrica accept my apologies in advance with regard to this comment O:-) Just pointing out that I'll be off for two weeks starting next Monday so it would be great, if possible, to get some feedback on this patch before the end of this week. But please don't take me wrong, I'm not trying to put any extra pressure on this. Thanks! 273379 67 66367 mario 2010-09-02 07:18:43 -0700 Created attachment 66367 Single patch for fixing this bug (In reply to comment #66) > [...] > Just pointing out that I'll be off for two weeks starting next Monday so it would be great, if possible, to get some feedback on this patch before the end of this week. But please don't take me wrong, I'm not trying to put any extra pressure on this. Attaching new patch rebased against lates version of trunk, as the old one was not applying at this moment. 275100 68 eric 2010-09-07 09:53:28 -0700 Can someone explain to me (ideally in the ChangeLog) why Gtk is the only platform to need this change? How do mac/win accomplish similar AX-related feats? 275133 69 66367 enrica 2010-09-07 10:27:41 -0700 Comment on attachment 66367 Single patch for fixing this bug > +// Calculate global offset (in the whole text, not just in the current node) > +static unsigned calculateGlobalOffset(AccessibilityRenderObject* object, unsigned offset) > +{ > + Node* node = object->node(); > + unsigned globalOffset = offset; > + for (Node* n = node->parentNode()->firstChild(); n && (n != node); n = n->nextSibling()) { > + if (n->isTextNode()) > + globalOffset += n->nodeValue().length(); > + } > + return globalOffset; > +} > + This is not the right way to do it. You should use the TextIterator class for this purpose. Your function doesn't take into account visibility of the text. > +void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityRenderObject* object, AXTextChange textChange, unsigned offset, unsigned count) > +{ > + // Sanity check > + if (!object || count < 1) > + return; > + > + unsigned globalOffset = calculateGlobalOffset(object, offset); There is no need to declare a variable here. You call emitTextChanged calling calculateGlobalOffset. > + emitTextChanged(object, textChange, globalOffset, count); > +} > + > > } // namespace WebCore > diff --git a/WebCore/editing/DeleteSelectionCommand.cpp b/WebCore/editing/DeleteSelectionCommand.cpp > index e57895c..71595f1 100644 > --- a/WebCore/editing/DeleteSelectionCommand.cpp > +++ b/WebCore/editing/DeleteSelectionCommand.cpp > @@ -443,11 +443,7 @@ void DeleteSelectionCommand::handleGeneralDelete() > return; > > if (startNode == m_downstreamEnd.node()) { > - // The selection to delete is all in one node. > - if (!startNode->renderer() || (startOffset == 0 && m_downstreamEnd.atLastEditingPositionForNode())) { > - // just delete > - removeNode(startNode); > - } else if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { > + if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { > if (startNode->isTextNode()) { > // in a text node that needs to be trimmed > Text* text = static_cast<Text*>(startNode); > @@ -457,6 +453,10 @@ void DeleteSelectionCommand::handleGeneralDelete() > m_endingPosition = m_upstreamStart; > } > } > + > + // The selection to delete is all in one node. > + if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode())) > + removeNode(startNode); > } > else { > bool startNodeWasDescendantOfEndNode = m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()); > @@ -472,6 +472,9 @@ void DeleteSelectionCommand::handleGeneralDelete() > } else { > node = startNode->childNode(startOffset); > } > + } else if (startNode == m_upstreamEnd.node() && startNode->isTextNode()) { > + Text* text = static_cast<Text*>(m_upstreamEnd.node()); > + deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset()); > } > This is not clear to me. Could you explain what you're trying to do here? Maybe some additional comments would help. } > diff --git a/WebCore/editing/InsertNodeBeforeCommand.cpp b/WebCore/editing/InsertNodeBeforeCommand.cpp > index 2ce9846..6f16e08 100644 > --- a/WebCore/editing/InsertNodeBeforeCommand.cpp > +++ b/WebCore/editing/InsertNodeBeforeCommand.cpp > @@ -26,6 +26,7 @@ > #include "config.h" > #include "InsertNodeBeforeCommand.h" > > +#include "AXObjectCache.h" > #include "htmlediting.h" > > namespace WebCore { > @@ -51,6 +52,11 @@ void InsertNodeBeforeCommand::doApply() > > ExceptionCode ec; > parent->insertBefore(m_insertChild.get(), m_refChild.get(), ec); > + > + if (AXObjectCache::accessibilityEnabled()) { > + unsigned len = m_insertChild->nodeValue().length(); No need to declare len. > + document()->axObjectCache()->nodeTextChangeNotification(m_insertChild->renderer(), AXObjectCache::AXTextInserted, 0, len); > + } > } > > void InsertNodeBeforeCommand::doUnapply() > @@ -58,6 +64,12 @@ void InsertNodeBeforeCommand::doUnapply() > if (!m_insertChild->isContentEditable()) > return; > > + // Need to notify this before actually deleting the text > + if (AXObjectCache::accessibilityEnabled()) { > + unsigned len = m_insertChild->nodeValue().length(); Same as above. > + document()->axObjectCache()->nodeTextChangeNotification(m_insertChild->renderer(), AXObjectCache::AXTextDeleted, 0, len); > + } > + > ExceptionCode ec; > m_insertChild->remove(ec); > } > -- > 1.7.0.4 > 275136 70 66367 eric 2010-09-07 10:32:18 -0700 Comment on attachment 66367 Single patch for fixing this bug r- based on above. 275240 71 mario 2010-09-07 13:17:47 -0700 (In reply to comment #68) > Can someone explain to me (ideally in the ChangeLog) why Gtk is the only platform to need > this change? How do mac/win accomplish similar AX-related feats? I don't know about win, but in Mac it works completely different so there's no need to emit some values with the signal (count and offset) as just emitting the signal would be enough (see Chris's explanation in comment #12). But for the GTK port, if we want to provide an ATK-compliant solution, these changes are needed in order to emit that extra info along with the signal, so the AT technologies can be aware of exactly which parts of the text have changed. 275742 72 mario 2010-09-08 04:14:16 -0700 (In reply to comment #69) > (From update of attachment 66367 [details]) > > +// Calculate global offset (in the whole text, not just in the current node) > > +static unsigned calculateGlobalOffset(AccessibilityRenderObject* object, unsigned offset) > > +{ > > + Node* node = object->node(); > > + unsigned globalOffset = offset; > > + for (Node* n = node->parentNode()->firstChild(); n && (n != node); n = n->nextSibling()) { > > + if (n->isTextNode()) > > + globalOffset += n->nodeValue().length(); > > + } > > + return globalOffset; > > +} > > + > This is not the right way to do it. You should use the TextIterator class for this purpose. Your function doesn't take into account visibility of the text. I'm afraid you're right, although I still can't see clearly how to do that in the way you suggest. For instance, how do I get the range associated to the full text in a text entry so I can truly know the offset for a given position, even if that text is internally represented by different text nodes? If you could ellaborate a bit more on this topic, I'd certainly appreciate it quite a lot. Thanks in advance. > > +void AXObjectCache::nodeTextChangePlatformNotification(AccessibilityRenderObject* object, AXTextChange textChange, unsigned offset, unsigned count) > > +{ > > + // Sanity check > > + if (!object || count < 1) > > + return; > > + > > + unsigned globalOffset = calculateGlobalOffset(object, offset); > > There is no need to declare a variable here. You call emitTextChanged calling calculateGlobalOffset. Yes, I know, I did it here just in order not to get a too long line, that's all. But I don't mind removing that extra variable if getting a long line is not a problem. > > } // namespace WebCore > > diff --git a/WebCore/editing/DeleteSelectionCommand.cpp b/WebCore/editing/DeleteSelectionCommand.cpp > > index e57895c..71595f1 100644 > > --- a/WebCore/editing/DeleteSelectionCommand.cpp > > +++ b/WebCore/editing/DeleteSelectionCommand.cpp > > @@ -443,11 +443,7 @@ void DeleteSelectionCommand::handleGeneralDelete() > > return; > > > > if (startNode == m_downstreamEnd.node()) { > > - // The selection to delete is all in one node. > > - if (!startNode->renderer() || (startOffset == 0 && m_downstreamEnd.atLastEditingPositionForNode())) { > > - // just delete > > - removeNode(startNode); > > - } else if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { > > + if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { > > if (startNode->isTextNode()) { > > // in a text node that needs to be trimmed > > Text* text = static_cast<Text*>(startNode); > > @@ -457,6 +453,10 @@ void DeleteSelectionCommand::handleGeneralDelete() > > m_endingPosition = m_upstreamStart; > > } > > } > > + > > + // The selection to delete is all in one node. > > + if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode())) > > + removeNode(startNode); > > } > > else { > > bool startNodeWasDescendantOfEndNode = m_upstreamStart.node()->isDescendantOf(m_downstreamEnd.node()); > > @@ -472,6 +472,9 @@ void DeleteSelectionCommand::handleGeneralDelete() > > } else { > > node = startNode->childNode(startOffset); > > } > > + } else if (startNode == m_upstreamEnd.node() && startNode->isTextNode()) { > > + Text* text = static_cast<Text*>(m_upstreamEnd.node()); > > + deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset()); > > } > > > This is not clear to me. Could you explain what you're trying to do here? Maybe some additional comments would help. See comment #62, but wrapping up what I'm doing here is just ensuring that deleteTextFromNode is going to be called always when deleting text (so I can emit the signal with the needed info -offset and count- for ATK-based AT technologies), even when we're deleting all the text from a node (so just removing the node could be enough). > } > > diff --git a/WebCore/editing/InsertNodeBeforeCommand.cpp b/WebCore/editing/InsertNodeBeforeCommand.cpp > > index 2ce9846..6f16e08 100644 > > --- a/WebCore/editing/InsertNodeBeforeCommand.cpp > > +++ b/WebCore/editing/InsertNodeBeforeCommand.cpp > > @@ -26,6 +26,7 @@ > > #include "config.h" > > #include "InsertNodeBeforeCommand.h" > > > > +#include "AXObjectCache.h" > > #include "htmlediting.h" > > > > namespace WebCore { > > @@ -51,6 +52,11 @@ void InsertNodeBeforeCommand::doApply() > > > > ExceptionCode ec; > > parent->insertBefore(m_insertChild.get(), m_refChild.get(), ec); > > + > > + if (AXObjectCache::accessibilityEnabled()) { > > + unsigned len = m_insertChild->nodeValue().length(); > > No need to declare len. Same reason here: not to get too long lines. I'll change it anyway > > + document()->axObjectCache()->nodeTextChangeNotification(m_insertChild->renderer(), AXObjectCache::AXTextInserted, 0, len); > > + } > > } > > > > void InsertNodeBeforeCommand::doUnapply() > > @@ -58,6 +64,12 @@ void InsertNodeBeforeCommand::doUnapply() > > if (!m_insertChild->isContentEditable()) > > return; > > > > + // Need to notify this before actually deleting the text > > + if (AXObjectCache::accessibilityEnabled()) { > > + unsigned len = m_insertChild->nodeValue().length(); > > Same as above. Likewise. Thanks a lot for the review Enrica, I think now we're really close to fix this bug once and for all. But first I need to address these issues, specially the one about calculateGlobalOffset() which is where I have more doubts. If you could put some light on that I'd appreciate it quite a lot. 275916 73 enrica 2010-09-08 10:27:23 -0700 > I'm afraid you're right, although I still can't see clearly how to do that in the way you suggest. For instance, how do I get the range associated to the full text in a text entry so I can truly know the offset for a given position, even if that text is internally represented by different text nodes? > > If you could ellaborate a bit more on this topic, I'd certainly appreciate it quite a lot. > Thanks in advance. Take a look at the static methods in TextIterator: static int rangeLength(const Range*, bool spacesForReplacedElements = false); static PassRefPtr<Range> rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength, bool spacesForReplacedElements = false); static PassRefPtr<Range> subrange(Range* entireRange, int characterOffset, int characterCount); Examples of their use can be found in various places in the editing code. Take a look at IndentOutdentCommand.cpp for an example of use of rangeFromLocationAndLength. CompositeEditCommand.cpp has examples of use of rangeLenght, that should be fairly close to what you need. > 275920 74 mario 2010-09-08 10:33:28 -0700 (In reply to comment #73) > > I'm afraid you're right, although I still can't see clearly how to do that in the way you suggest. For instance, how do I get the range associated to the full text in a text entry so I can truly know the offset for a given position, even if that text is internally represented by different text nodes? > > > > If you could ellaborate a bit more on this topic, I'd certainly appreciate it quite a lot. > > Thanks in advance. > > Take a look at the static methods in TextIterator: > static int rangeLength(const Range*, bool spacesForReplacedElements = false); > static PassRefPtr<Range> rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength, bool spacesForReplacedElements = false); > static PassRefPtr<Range> subrange(Range* entireRange, int characterOffset, int characterCount); > Examples of their use can be found in various places in the editing code. Take a look at IndentOutdentCommand.cpp for an example of use of rangeFromLocationAndLength. > CompositeEditCommand.cpp has examples of use of rangeLenght, that should be fairly close to what you need. > > Thanks Enrica, that's just what I needed. As soon as I finish addressing other issues in other patches I'll try this out. 278423 75 67463 mario 2010-09-13 13:16:21 -0700 Created attachment 67463 Single patch for fixing this bug (In reply to comment #74) > [...] > Thanks Enrica, that's just what I needed. As soon as I finish addressing other issues in other patches I'll try this out. I'm now attaching a new patch addressing all the issues you (Enrica) pointed out so I hope this new patch to be better and, hopefully, closer to help fixing this bug :-) Wrt the calculateGlobalOffset() function you (Enrica) were definitely right: I was messing too much with a loop iterating over nodes while TextIterator::rangeLength() would basically do everything I needed in a way better and cleaner fashion. Hence I removed that function in this new patch and just added the three-line code in the only place it was needed. So, now asking for review once again. Hopefully this will be the last or one of the last times I bother you all with this stuff :-) Anyway, don't hesitate to ask whatever you want, of course. PS: If you review+ it, please set the cq+ flag as well. Thanks! 279734 76 enrica 2010-09-15 14:38:45 -0700 This looks good to me. 279989 77 mario 2010-09-16 02:56:44 -0700 (In reply to comment #76) > This looks good to me. Thanks Enrica. It seems this was the last bit of the patch pending on review so, unless someone else wanted to point something else out now and if you all agree, it would be great if someone could add the r+ and cq+ flags (I'm not a committer). 281557 78 67463 mrobinson 2010-09-20 08:18:00 -0700 Comment on attachment 67463 Single patch for fixing this bug View in context: https://bugs.webkit.org/attachment.cgi?id=67463&action=prettypatch > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:78 > + gchar* detailStr = detail.get(); > + if (detailStr) > + g_signal_emit_by_name(wrapper, detailStr, offset, count); > +} This is unnecessary, because GOwnPtr has a implicit bool cast. if (detail) g_signal_emit_by_name(wrapper, detail.get(), offset, count); > WebCore/editing/AppendNodeCommand.cpp:51 > + if (nodeValue != "\n") I think this should be an early return. This look good otherwise, but I'd be more comfortable if someone more familiar with a11y reviewed the platform-independent parts. 281632 79 68105 mario 2010-09-20 10:16:19 -0700 Created attachment 68105 Single patch for fixing this bug (In reply to comment #78) > (From update of attachment 67463 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=67463&action=prettypatch > > > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:78 > > + gchar* detailStr = detail.get(); > > + if (detailStr) > > + g_signal_emit_by_name(wrapper, detailStr, offset, count); > > +} > > This is unnecessary, because GOwnPtr has a implicit bool cast. > if (detail) > g_signal_emit_by_name(wrapper, detail.get(), offset, count); Fixed > > WebCore/editing/AppendNodeCommand.cpp:51 > > + if (nodeValue != "\n") > > I think this should be an early return. > Done > This look good otherwise, but I'd be more comfortable if someone more familiar with a11y reviewed the platform-independent parts. I'm attaching a new patch now, asking for review over it, which I guess should be pretty straightforward since now it looks now both Chris and Enrica are ok with the changes in the a11y code and the text editing part, respectively (Besides, I guess both Eric and you will be ok with the current patch, after addressing the issues pointed by you two as well) 281637 80 68105 mrobinson 2010-09-20 10:22:16 -0700 Comment on attachment 68105 Single patch for fixing this bug Based on Enrica's previous comment, I'd say this patch seems good. 281732 81 68105 commit-queue 2010-09-20 12:17:36 -0700 Comment on attachment 68105 Single patch for fixing this bug Rejecting patch 68105 from commit-queue. Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 Last 500 characters of output: OR 0320 setenv YACC /Developer/usr/bin/yacc /bin/sh -c /Users/abarth/git/webkit-queue/WebKitBuild/WebCore.build/Debug/WebCore.build/Script-5DF50887116F3077005202AB.sh ** BUILD FAILED ** The following build commands failed: WebCore: CompileC /Users/abarth/git/webkit-queue/WebKitBuild/WebCore.build/Debug/WebCore.build/Objects-normal/x86_64/AppendNodeCommand.o /Users/abarth/git/webkit-queue/WebCore/editing/AppendNodeCommand.cpp normal x86_64 c++ com.apple.compilers.gcc.4_2 (1 failure) Full output: http://queues.webkit.org/results/4094011 281872 82 mario 2010-09-20 15:53:13 -0700 (In reply to comment #81) > (From update of attachment 68105 [details]) > Rejecting patch 68105 from commit-queue. > > Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 > Last 500 characters of output: > OR 0320 > setenv YACC /Developer/usr/bin/yacc > /bin/sh -c /Users/abarth/git/webkit-queue/WebKitBuild/WebCore.build/Debug/WebCore.build/Script-5DF50887116F3077005202AB.sh > > ** BUILD FAILED ** > > > The following build commands failed: > WebCore: > CompileC /Users/abarth/git/webkit-queue/WebKitBuild/WebCore.build/Debug/WebCore.build/Objects-normal/x86_64/AppendNodeCommand.o /Users/abarth/git/webkit-queue/WebCore/editing/AppendNodeCommand.cpp normal x86_64 c++ com.apple.compilers.gcc.4_2 > (1 failure) > > > Full output: http://queues.webkit.org/results/4094011 I don't get this... What does it mean? Is it a problem in my patch or in the commit-queue scripts and does it require manual landing then? Please let me know if there's anything I need to do from my side. Thanks! 281874 83 cfleizach 2010-09-20 15:55:05 -0700 (In reply to comment #82) build failed because of cc1plus: warnings being treated as errors /Users/abarth/git/webkit-queue/WebCore/editing/AppendNodeCommand.cpp:46: warning: unused parameter 'textChange' 282149 84 68201 mario 2010-09-21 01:52:17 -0700 Created attachment 68201 Single patch for fixing this bug (In reply to comment #83) > (In reply to comment #82) > > build failed because of > > > cc1plus: warnings being treated as errors > /Users/abarth/git/webkit-queue/WebCore/editing/AppendNodeCommand.cpp:46: warning: unused parameter 'textChange' Argh! Didn't see that, sorry. Attaching new patch fixing that smal issue (the variable should actually be used, not hardcoded.) 282400 85 68201 commit-queue 2010-09-21 10:27:00 -0700 Comment on attachment 68201 Single patch for fixing this bug Rejecting patch 68201 from commit-queue. Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 Last 500 characters of output: VERSION_MINOR 0320 setenv YACC /Developer/usr/bin/yacc /bin/sh -c /Users/abarth/git/webkit-queue/WebKitBuild/WebKit.build/Debug/WebKit.build/Script-5D88EE6C11407DE800BC3ABC.sh ** BUILD FAILED ** The following build commands failed: WebKit: CompileC /Users/abarth/git/webkit-queue/WebKitBuild/WebKit.build/Debug/WebKit.build/Objects-normal/x86_64/WebFrame.o /Users/abarth/git/webkit-queue/WebKit/mac/WebView/WebFrame.mm normal x86_64 objective-c++ com.apple.compilers.gcc.4_2 (1 failure) Full output: http://queues.webkit.org/results/4097013 282436 86 68263 mario 2010-09-21 11:05:56 -0700 Created attachment 68263 Single patch for fixing this bug (In reply to comment #85) > (From update of attachment 68201 [details]) > Rejecting patch 68201 from commit-queue. > [...] > > Full output: http://queues.webkit.org/results/4097013 I'm definitely doomed with this patch... Looks the error is this: In file included from /Users/abarth/git/webkit-queue/WebKit/mac/WebView/WebFrame.mm:56: /Users/abarth/git/webkit-queue/WebKitBuild/Debug/WebCore.framework/PrivateHeaders/AXObjectCache.h:29:39: error: AccessibilityRenderObject.h: No such file or directory In file included from /Users/abarth/git/webkit-queue/WebKit/mac/WebView/WebFrame.mm:56: [...] And I bet it's because of this part of my patch: --- a/WebCore/accessibility/AXObjectCache.h +++ b/WebCore/accessibility/AXObjectCache.h @@ -26,7 +26,7 @@ #ifndef AXObjectCache_h #define AXObjectCache_h -#include "AccessibilityObject.h" +#include "AccessibilityRenderObject.h" [...] I think it was a mistake (my mistake) to remove #include "AccessibilityObject.h", even if it was ok to compile it in my local machine, and that's what is causing all that mess in the WebKit/mac/WebView/WebFrame.mm. Now attaching a new patch that does not remove that line, and just adds "AccessibilityRenderObject.h" instead. 282523 87 68263 commit-queue 2010-09-21 13:34:11 -0700 Comment on attachment 68263 Single patch for fixing this bug Rejecting patch 68263 from commit-queue. Failed to run "['WebKitTools/Scripts/build-webkit', '--debug']" exit_code: 1 Last 500 characters of output: AJOR 0300 setenv XCODE_VERSION_MINOR 0320 setenv YACC /Developer/usr/bin/yacc /bin/sh -c /Projects/CommitQueue/WebKitBuild/WebKit.build/Debug/WebKit.build/Script-5D88EE6C11407DE800BC3ABC.sh ** BUILD FAILED ** The following build commands failed: WebKit: CompileC /Projects/CommitQueue/WebKitBuild/WebKit.build/Debug/WebKit.build/Objects-normal/x86_64/WebFrame.o /Projects/CommitQueue/WebKit/mac/WebView/WebFrame.mm normal x86_64 objective-c++ com.apple.compilers.gcc.4_2 (1 failure) Full output: http://queues.webkit.org/results/4050085 282573 88 mario 2010-09-21 14:53:19 -0700 (In reply to comment #87) > (From update of attachment 68263 [details]) > Rejecting patch 68263 from commit-queue. [...] > Full output: http://queues.webkit.org/results/4050085 After the last patch it's obvious the situation improved but still it keeps pouring the following error: In file included from /Projects/CommitQueue/WebKit/mac/WebView/WebFrame.mm:56: /Projects/CommitQueue/WebKitBuild/Debug/WebCore.framework/PrivateHeaders/AXObjectCache.h:30:39: error: AccessibilityRenderObject.h: No such file or directory In file included from /Projects/CommitQueue/WebKit/mac/WebView/WebFrame.mm:56: /Projects/CommitQueue/WebKitBuild/Debug/WebCore.framework/PrivateHeaders/AXObjectCache.h:140: error: 'AccessibilityRenderObject' has not been declared PhaseScriptExecution "Check For Framework Include Consistency" /Projects/CommitQueue/WebKitBuild/WebKit.build/Debug/WebKit.build/Script-5D88EE6C11407DE800BC3ABC.sh At this point, it looks to me like some kind of mac-specific error, as if something were missing in some declaration (AccessibilityRenderObject.h in PrivateHeaders?) or something like that. Could someone working in the mac port drop some light on this? That would be really helpful. Thanks! 282577 89 cfleizach 2010-09-21 15:01:13 -0700 (In reply to comment #88) AccessibilityRenderObject.cpp is not exported as a header, and I don't think it should be. Really, anyone using Accessibility in WebKit, should only know about AXObjectCache and AccessibilityObject. 282825 90 68346 mario 2010-09-22 01:05:09 -0700 Created attachment 68346 Single patch for fixing this bug (In reply to comment #89) > (In reply to comment #88) > > AccessibilityRenderObject.cpp is not exported as a header, and I don't think it should be. > > Really, anyone using Accessibility in WebKit, should only know about AXObjectCache and AccessibilityObject. That makes sense, and now that I look in AXObjectCache.h, I see the new functions I'm adding there are the only ones requiring AccessibilityRenderObject's as parameters, instead of just AccessibilityObject's. Hence, attaching a new patch (hope this is the last strike!) where I changed the type of those parameters, letting the platform specific code to do the additional checks to make sure an AccessibilityRenderObject is being passed to nodeTextChangePlatformNotification in the case of GTK. Sorry for so much hassle with this. 282911 91 68346 mrobinson 2010-09-22 07:10:00 -0700 Comment on attachment 68346 Single patch for fixing this bug View in context: https://bugs.webkit.org/attachment.cgi?id=68346&action=review On further consideration, I'm pretty nervous that this does not hava test attached to it? Is it possible to write one? > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:73 > + GOwnPtr<gchar> detail; > + switch (textChange) { > + case AXObjectCache::AXTextInserted: > + detail.set(g_strdup("text-changed::insert")); > + break; > + case AXObjectCache::AXTextDeleted: > + detail.set(g_strdup("text-changed::delete")); > + break; > + } Please use CString here. Sorry I didn't notice this before. 283193 92 68427 mario 2010-09-22 13:18:57 -0700 Created attachment 68427 Single patch for fixing this bug + Unit test (In reply to comment #91) > (From update of attachment 68346 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=68346&action=review > > On further consideration, I'm pretty nervous that this does not hava test attached to it? Is it possible to write one? Attaching a new patch with a new unit case in testatk.c to check this works as expected. > > WebCore/accessibility/gtk/AXObjectCacheAtk.cpp:73 > > + GOwnPtr<gchar> detail; > > + switch (textChange) { > > + case AXObjectCache::AXTextInserted: > > + detail.set(g_strdup("text-changed::insert")); > > + break; > > + case AXObjectCache::AXTextDeleted: > > + detail.set(g_strdup("text-changed::delete")); > > + break; > > + } > > Please use CString here. Sorry I didn't notice this before. No problem. Done. Let's see this time... :-) 283195 93 68427 mrobinson 2010-09-22 13:20:39 -0700 Comment on attachment 68427 Single patch for fixing this bug + Unit test Thanks! 283216 94 68427 commit-queue 2010-09-22 13:43:41 -0700 Comment on attachment 68427 Single patch for fixing this bug + Unit test Clearing flags on attachment: 68427 Committed r68078: <http://trac.webkit.org/changeset/68078> 283217 95 commit-queue 2010-09-22 13:43:53 -0700 All reviewed patches have been landed. Closing bug. 60944 2010-07-08 13:44:00 -0700 2010-08-03 03:20:04 -0700 1. Call deleteTextFromNode() when needed while removing text nodes 0001-2010-07-08-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 3803 mario RnJvbSBiMTczYmYxOTVlNmQ4ZDM5N2NmZTdmZjVlNzEwNGJiYWYxMDJjZGEyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDggSnVsIDIwMTAgMTU6MjY6MzEgKzAyMDAKU3ViamVjdDogW1BBVENI IDEvNV0gMjAxMC0wNy0wOCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBv YmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBh bmQgcGFzc3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9kZSgpIHdoZW4gbmVl ZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMKCiAgICAgICAgRG8gaXQgZXZlbiB3aGVuIHJl bW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywgaW4KICAgICAgICBv cmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBub3RpZmllZCBhYm91 dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdpdGggdGhhdCBub2Rl LgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHA6CiAgICAgICAg KFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUpOgot LS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTYgKysr KysrKysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3Bw IHwgICAxNSArKysrKysrKysrLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMjYgaW5zZXJ0aW9ucygr KSwgNSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNv cmUvQ2hhbmdlTG9nCmluZGV4IDA0MWUyZTMuLjZiODdkMDMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv Q2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTAt MDctMDggIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0 ZXh0LWNoYW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNz d29yZCB0ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yNTg5OAorCisgICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2RlKCkgd2hlbiBuZWVkZWQg d2hpbGUgcmVtb3ZpbmcgdGV4dCBub2RlcworCisgICAgICAgIERvIGl0IGV2ZW4gd2hlbiByZW1v dmVOb2RlKCkgaXMgZ29pbmcgdG8gYmUgY2FsbGVkIGFmdGVyd2FyZHMsIGluCisgICAgICAgIG9y ZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5vdGlmaWVkIGFib3V0 IHRoZQorICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdpdGggdGhhdCBub2Rl LgorCisgICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUp OgorCiAyMDEwLTA3LTA4ICBYYW4gTG9wZXogIDx4bG9wZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBHdXN0YXZvIE5vcm9uaGEuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRp bmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2Vs ZWN0aW9uQ29tbWFuZC5jcHAKaW5kZXggNjIzYjE4OC4uYjJiZmIyOCAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRp dGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcApAQCAtNDQzLDExICs0NDMsNyBAQCB2b2lk IERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICBy ZXR1cm47CiAKICAgICBpZiAoc3RhcnROb2RlID09IG1fZG93bnN0cmVhbUVuZC5ub2RlKCkpIHsK LSAgICAgICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxldGUgaXMgYWxsIGluIG9uZSBub2RlLgot ICAgICAgICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8fCAoc3RhcnRPZmZzZXQgPT0gMCAm JiBtX2Rvd25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bvc2l0aW9uRm9yTm9kZSgpKSkgewotICAg ICAgICAgICAgLy8ganVzdCBkZWxldGUKLSAgICAgICAgICAgIHJlbW92ZU5vZGUoc3RhcnROb2Rl KTsKLSAgICAgICAgfSBlbHNlIGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdP ZmZzZXQoKSAtIHN0YXJ0T2Zmc2V0ID4gMCkgeworICAgICAgICBpZiAobV9kb3duc3RyZWFtRW5k LmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCkgLSBzdGFydE9mZnNldCA+IDApIHsKICAgICAgICAg ICAgIGlmIChzdGFydE5vZGUtPmlzVGV4dE5vZGUoKSkgewogICAgICAgICAgICAgICAgIC8vIGlu IGEgdGV4dCBub2RlIHRoYXQgbmVlZHMgdG8gYmUgdHJpbW1lZAogICAgICAgICAgICAgICAgIFRl eHQqIHRleHQgPSBzdGF0aWNfY2FzdDxUZXh0Kj4oc3RhcnROb2RlKTsKQEAgLTQ1Nyw2ICs0NTMs MTIgQEAgdm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkK ICAgICAgICAgICAgICAgICBtX2VuZGluZ1Bvc2l0aW9uID0gbV91cHN0cmVhbVN0YXJ0OwogICAg ICAgICAgICAgfQogICAgICAgICB9CisKKyAgICAgICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxl dGUgaXMgYWxsIGluIG9uZSBub2RlLgorICAgICAgICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIo KSB8fCAoIXN0YXJ0T2Zmc2V0ICYmIG1fZG93bnN0cmVhbUVuZC5hdExhc3RFZGl0aW5nUG9zaXRp b25Gb3JOb2RlKCkpKSB7CisgICAgICAgICAgICAvLyBqdXN0IGRlbGV0ZQorICAgICAgICAgICAg cmVtb3ZlTm9kZShzdGFydE5vZGUpOworICAgICAgICB9CiAgICAgfQogICAgIGVsc2UgewogICAg ICAgICBib29sIHN0YXJ0Tm9kZVdhc0Rlc2NlbmRhbnRPZkVuZE5vZGUgPSBtX3Vwc3RyZWFtU3Rh cnQubm9kZSgpLT5pc0Rlc2NlbmRhbnRPZihtX2Rvd25zdHJlYW1FbmQubm9kZSgpKTsKQEAgLTQ3 Miw2ICs0NzQsOSBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxE ZWxldGUoKQogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICBub2RlID0gc3Rh cnROb2RlLT5jaGlsZE5vZGUoc3RhcnRPZmZzZXQpOwogICAgICAgICAgICAgfQorICAgICAgICB9 IGVsc2UgaWYgKHN0YXJ0Tm9kZSA9PSBtX3Vwc3RyZWFtRW5kLm5vZGUoKSAmJiBzdGFydE5vZGUt PmlzVGV4dE5vZGUoKSkgeworICAgICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19jYXN0PFRl eHQqPihtX3Vwc3RyZWFtRW5kLm5vZGUoKSk7CisgICAgICAgICAgICBkZWxldGVUZXh0RnJvbU5v ZGUodGV4dCwgMCwgbV91cHN0cmVhbUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpKTsKICAg ICAgICAgfQogICAgICAgICAKICAgICAgICAgLy8gaGFuZGxlIGRlbGV0aW5nIGFsbCBub2RlcyB0 aGF0IGFyZSBjb21wbGV0ZWx5IHNlbGVjdGVkCi0tIAoxLjcuMC40Cgo= 60945 2010-07-08 13:44:39 -0700 2010-07-16 01:50:41 -0700 2. New InsertIntoTextNodeCommand::notifyAccessibility() private method 0002-2010-07-08-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 7053 mario RnJvbSBjMGViMDNiZjA5NjkxNWE2NzVlNjYyZjIwNzI5ZmMzM2Y3NzQ3ZDZkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDggSnVsIDIwMTAgMTU6MzA6MTAgKzAyMDAKU3ViamVjdDogW1BBVENI IDIvNV0gMjAxMC0wNy0wOCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBv YmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBh bmQgcGFzc3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAoKICAgICAgICBOZXcgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6bm90 aWZ5QWNjZXNzaWJpbGl0eSgpIHByaXZhdGUgbWV0aG9kCgogICAgICAgIEFkZGVkIGEgZHVtbXkg dmVyc2lvbiBmb3IgYWxsIHBsYXRmb3JtcyBidXQgR1RLLCB3aGljaCBjb21lcyB3aXRoCiAgICAg ICAgYSBzcGVjaWZpYyBpbXBsZW1lbnRhdGlvbiB0byBoYW5kbGUgdGhlIHRleHQtY2hhbmdlZCBl dmVudHMKCiAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0 SW50b1RleHROb2RlQ29tbWFuZC5jcHA6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0 Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5v ZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAgICogZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5v ZGVDb21tYW5kLmg6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6 Om5vdGlmeUFjY2Vzc2liaWxpdHkpOgogICAgICAgICogZWRpdGluZy9ndGsvSW5zZXJ0SW50b1Rl eHROb2RlQ29tbWFuZEd0ay5jcHA6IEFkZGVkLgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRv VGV4dE5vZGVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmlsaXR5KToKLS0tCiBXZWJDb3JlL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjEgKysrKysrKwogV2Vi Q29yZS9HTlVtYWtlZmlsZS5hbSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAxICsK IFdlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcCAgICAgIHwgICAg NCArCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5oICAgICAgICB8 ICAgIDggKysrCiAuLi4vZWRpdGluZy9ndGsvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZEd0ay5j cHAgICB8ICAgNjEgKysrKysrKysrKysrKysrKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgOTUgaW5z ZXJ0aW9ucygrKSwgMCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBXZWJDb3JlL2Vk aXRpbmcvZ3RrL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmRHdGsuY3BwCgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2Yjg3ZDAzLi5kNmFi YmNkIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtNSw2ICs1LDI3IEBACiAgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNoYW5nZWQgZXZl bnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0ZXh0CiAgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5OAogCisgICAg ICAgIE5ldyBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmlsaXR5KCkg cHJpdmF0ZSBtZXRob2QKKworICAgICAgICBBZGRlZCBhIGR1bW15IHZlcnNpb24gZm9yIGFsbCBw bGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aAorICAgICAgICBhIHNwZWNpZmljIGlt cGxlbWVudGF0aW9uIHRvIGhhbmRsZSB0aGUgdGV4dC1jaGFuZ2VkIGV2ZW50cworCisgICAgICAg ICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6 OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQu aDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6Om5vdGlmeUFj Y2Vzc2liaWxpdHkpOgorICAgICAgICAqIGVkaXRpbmcvZ3RrL0luc2VydEludG9UZXh0Tm9kZUNv bW1hbmRHdGsuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9k ZUNvbW1hbmQ6Om5vdGlmeUFjY2Vzc2liaWxpdHkpOgorCisyMDEwLTA3LTA4ICBNYXJpbyBTYW5j aGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50 cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKwogICAgICAg ICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9kZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRl eHQgbm9kZXMKIAogICAgICAgICBEbyBpdCBldmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5n IHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBpbgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggZGJiZjBjZi4uYTI1NmIwMSAx MDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2Vm aWxlLmFtCkBAIC0xMDUwLDYgKzEwNTAsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNv cmUvZWRpdGluZy9tYXJrdXAuaCBcCiAJV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3Bw IFwKIAlXZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0cy5oIFwKKwlXZWJDb3JlL2VkaXRpbmcv Z3RrL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmRHdGsuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcv Z3RrL1NlbGVjdGlvbkNvbnRyb2xsZXJHdGsuY3BwIFwKIAlXZWJDb3JlL2hpc3RvcnkvQmFja0Zv cndhcmRDb250cm9sbGVyLmNwcCBcCiAJV2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkQ29udHJv bGxlci5oIFwKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNw cAppbmRleCA5YzM0MjNhLi5iZjI1NDY5IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydElu dG9UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC00OCw2ICs0OCw4IEBAIHZvaWQgSW5zZXJ0SW50b1Rl eHROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAg ICBtX25vZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgbm90aWZ5 QWNjZXNzaWJpbGl0eShmYWxzZSk7CiB9CiAKIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFu ZDo6ZG9VbmFwcGx5KCkKQEAgLTU1LDYgKzU3LDggQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9ub2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgp KQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIG5vdGlmeUFjY2Vzc2liaWxpdHkodHJ1 ZSk7CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29m ZnNldCwgbV90ZXh0Lmxlbmd0aCgpLCBlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRp bmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5oIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydElu dG9UZXh0Tm9kZUNvbW1hbmQuaAppbmRleCA0OWNiNThiLi43YTUzOTg4IDEwMDY0NAotLS0gYS9X ZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5oCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmgKQEAgLTQ1LDExICs0NSwxOSBAQCBw cml2YXRlOgogICAgIHZpcnR1YWwgdm9pZCBkb0FwcGx5KCk7CiAgICAgdmlydHVhbCB2b2lkIGRv VW5hcHBseSgpOwogCisgICAgdm9pZCBub3RpZnlBY2Nlc3NpYmlsaXR5KGJvb2wgaXNVbmRvKTsK KwogICAgIFJlZlB0cjxUZXh0PiBtX25vZGU7CiAgICAgdW5zaWduZWQgbV9vZmZzZXQ7CiAgICAg U3RyaW5nIG1fdGV4dDsKIH07CiAKKyNpZiAhUExBVEZPUk0oR1RLKQoraW5saW5lIHZvaWQgSW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eShib29sIGlzVW5kbykK K3sKK30KKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBJbnNl cnRJbnRvVGV4dE5vZGVDb21tYW5kX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9ndGsv SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZEd0ay5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvZ3RrL0lu c2VydEludG9UZXh0Tm9kZUNvbW1hbmRHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLmY2ZWQwNzMKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJDb3JlL2VkaXRpbmcvZ3Rr L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmRHdGsuY3BwCkBAIC0wLDAgKzEsNjEgQEAKKy8qCisg KiBDb3B5cmlnaHQgKEMpIDIwMTAgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkg aXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICog TGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55 IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRo ZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAq IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAq IFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVy YWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZp bGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9z dG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKyAKKyNpbmNsdWRlICJjb25maWcuaCIKKyNp bmNsdWRlICJJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmgiCisKKyNpbmNsdWRlICJBWE9iamVj dENhY2hlLmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuaCIKKyNp bmNsdWRlICJUZXh0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBJbnNlcnRJbnRv VGV4dE5vZGVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmlsaXR5KGJvb2wgaXNVbmRvKQoreworICAg IGlmICghQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgVGV4dCogbm9kZSA9IG1fbm9kZS5nZXQoKTsKKyAgICBOb2RlKiBwYXJlbnQg PSBub2RlLT5wYXJlbnROb2RlKCk7CisgICAgUmVuZGVyT2JqZWN0KiB0ZXh0UmVuZGVyZXIgPSBw YXJlbnQtPnJlbmRlcmVyKCk7CisgICAgaWYgKCF0ZXh0UmVuZGVyZXIpCisgICAgICAgIHJldHVy bjsKKworICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGF4T2JqZWN0ID0gZG9jdW1lbnQoKS0+YXhP YmplY3RDYWNoZSgpLT5nZXRPckNyZWF0ZSh0ZXh0UmVuZGVyZXIpOworICAgIGlmICghYXhPYmpl Y3QpCisgICAgICAgIHJldHVybjsKKworICAgIEF0a09iamVjdCogd3JhcHBlciA9IGF4T2JqZWN0 LT53cmFwcGVyKCk7CisgICAgaWYgKEFUS19JU19URVhUKHdyYXBwZXIpICYmIG1fdGV4dC5sZW5n dGgoKSA+IDApIHsKKyAgICAgICAgLy8gQ2FsY3VsYXRlIG9mZnNldAorICAgICAgICBsb25nIG9m ZnNldCA9IDA7CisgICAgICAgIGZvciAoTm9kZSAqbiA9IHBhcmVudC0+Zmlyc3RDaGlsZCgpOyBu ICYmIChuICE9IG5vZGUpOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkgeworICAgICAgICAgICAgaWYg KG4tPmlzVGV4dE5vZGUoKSkKKyAgICAgICAgICAgICAgICBvZmZzZXQgKz0gbi0+bm9kZVZhbHVl KCkubGVuZ3RoKCk7CisgICAgICAgIH0KKyAgICAgICAgb2Zmc2V0ICs9IG1fb2Zmc2V0OworCisg ICAgICAgIGlmIChpc1VuZG8pCisgICAgICAgICAgICBnX3NpZ25hbF9lbWl0X2J5X25hbWUod3Jh cHBlciwgInRleHQtY2hhbmdlZDo6ZGVsZXRlIiwgb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCkpOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBnX3NpZ25hbF9lbWl0X2J5X25hbWUod3JhcHBlciwg InRleHQtY2hhbmdlZDo6aW5zZXJ0Iiwgb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCkpOworICAgIH0K K30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQotLSAKMS43LjAuNAoK 60946 2010-07-08 13:45:13 -0700 2010-07-16 01:50:44 -0700 3. New DeleteFromTextNodeCommand::notifyAccessibility() private method 0003-2010-07-08-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 6796 mario RnJvbSAyOWQ3MGFjM2U2NmRhNDlhMWNhMDcwMDBkM2EwZjgzMTIzY2U5NWQ1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDggSnVsIDIwMTAgMTM6MTM6NTEgKzAyMDAKU3ViamVjdDogW1BBVENI IDMvNV0gMjAxMC0wNy0wOCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBv YmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBh bmQgcGFzc3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAoKICAgICAgICBOZXcgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6bm90 aWZ5QWNjZXNzaWJpbGl0eSgpIHByaXZhdGUgbWV0aG9kCgogICAgICAgIEFkZGVkIGEgZHVtbXkg dmVyc2lvbiBmb3IgYWxsIHBsYXRmb3JtcyBidXQgR1RLLCB3aGljaCBjb21lcyB3aXRoCiAgICAg ICAgYSBzcGVjaWZpYyBpbXBsZW1lbnRhdGlvbiB0byBoYW5kbGUgdGhlIHRleHQtY2hhbmdlZCBl dmVudHMKCiAgICAgICAgKiBHTlVtYWtlZmlsZS5hbToKICAgICAgICAqIGVkaXRpbmcvRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5v ZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAgICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5v ZGVDb21tYW5kLmg6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6 Om5vdGlmeUFjY2Vzc2liaWxpdHkpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAxOSArKysrKysKIFdlYkNvcmUvR05VbWFrZWZpbGUu YW0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJDb3JlL2VkaXRpbmcv RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAgICAgICB8ICAgIDUgKysKIFdlYkNvcmUvZWRp dGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmggICAgICAgIHwgICAgOCArKysKIC4uLi9l ZGl0aW5nL2d0ay9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kR3RrLmNwcCAgIHwgICA2MSArKysr KysrKysrKysrKysrKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA5NCBpbnNlcnRpb25zKCspLCAwIGRl bGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFdlYkNvcmUvZWRpdGluZy9ndGsvRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZEd0ay5jcHAKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxv ZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IGQ2YWJiY2QuLmQ0YmQ1MGIgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC01LDYgKzUsMjUg QEAKICAgICAgICAgW0d0a10gb2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVt aXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBhc3N3b3JkIHRleHQKICAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1ODk4CiAKKyAgICAgICAgTmV3IERlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQ6Om5vdGlmeUFjY2Vzc2liaWxpdHkoKSBwcml2YXRlIG1ldGhvZAor CisgICAgICAgIEFkZGVkIGEgZHVtbXkgdmVyc2lvbiBmb3IgYWxsIHBsYXRmb3JtcyBidXQgR1RL LCB3aGljaCBjb21lcyB3aXRoCisgICAgICAgIGEgc3BlY2lmaWMgaW1wbGVtZW50YXRpb24gdG8g aGFuZGxlIHRoZSB0ZXh0LWNoYW5nZWQgZXZlbnRzCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5h bToKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAg ICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAg ICAgICAqIGVkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oOgorICAgICAgICAoV2Vi Q29yZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eSk6CisK KzIwMTAtMDctMDggIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9i amVjdDp0ZXh0LWNoYW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFu ZCBwYXNzd29yZCB0ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAorCiAgICAgICAgIE5ldyBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpu b3RpZnlBY2Nlc3NpYmlsaXR5KCkgcHJpdmF0ZSBtZXRob2QKIAogICAgICAgICBBZGRlZCBhIGR1 bW15IHZlcnNpb24gZm9yIGFsbCBwbGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aApk aWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUu YW0KaW5kZXggYTI1NmIwMS4uN2Q0ZmJiZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmls ZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCkBAIC0xMDUwLDYgKzEwNTAsNyBAQCB3 ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNvcmUvZWRpdGluZy9tYXJrdXAuaCBcCiAJV2ViQ29y ZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91 bml0cy5oIFwKKwlXZWJDb3JlL2VkaXRpbmcvZ3RrL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmRH dGsuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvZ3RrL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmRH dGsuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvZ3RrL1NlbGVjdGlvbkNvbnRyb2xsZXJHdGsuY3Bw IFwKIAlXZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRDb250cm9sbGVyLmNwcCBcCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJD b3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKaW5kZXggZjFkNzlhZi4u ZmY3ZWFmOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5k LmNwcApAQCAtNTMsNiArNTMsOSBAQCB2b2lkIERlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRv QXBwbHkoKQogICAgIGlmIChlYykKICAgICAgICAgcmV0dXJuOwogICAgIAorICAgIC8vIEFjY2Vz c2liaWxpdHkgbXVzdCBiZSBub3RpZmllZCBCRUZPUkUgbW9kaWZ5aW5nIHRoZSBub2RlCisgICAg bm90aWZ5QWNjZXNzaWJpbGl0eShmYWxzZSk7CisKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9v ZmZzZXQsIG1fY291bnQsIGVjKTsKIH0KIApAQCAtNjUsNiArNjgsOCBAQCB2b2lkIERlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNv ZGUgZWM7CiAgICAgbV9ub2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKwor ICAgIG5vdGlmeUFjY2Vzc2liaWxpdHkodHJ1ZSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5k LmggYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oCmluZGV4IDBk MTQ1ZjUuLmNkZDQ3NzEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kLmgKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQuaApAQCAtNDUsMTIgKzQ1LDIwIEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCB2b2lkIGRv QXBwbHkoKTsKICAgICB2aXJ0dWFsIHZvaWQgZG9VbmFwcGx5KCk7CiAKKyAgICB2b2lkIG5vdGlm eUFjY2Vzc2liaWxpdHkoYm9vbCBpc1VuZG8pOworCiAgICAgUmVmUHRyPFRleHQ+IG1fbm9kZTsK ICAgICB1bnNpZ25lZCBtX29mZnNldDsKICAgICB1bnNpZ25lZCBtX2NvdW50OwogICAgIFN0cmlu ZyBtX3RleHQ7CiB9OwogCisjaWYgIVBMQVRGT1JNKEdUSykKK2lubGluZSB2b2lkIERlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQ6Om5vdGlmeUFjY2Vzc2liaWxpdHkoYm9vbCBpc1VuZG8pCit7Cit9 CisjZW5kaWYKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRGVsZXRlRnJv bVRleHROb2RlQ29tbWFuZF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvZ3RrL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmRHdGsuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL2d0ay9EZWxldGVG cm9tVGV4dE5vZGVDb21tYW5kR3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi41MWZlOWMyCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9lZGl0aW5nL2d0ay9EZWxl dGVGcm9tVGV4dE5vZGVDb21tYW5kR3RrLmNwcApAQCAtMCwwICsxLDYxIEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDEwIElnYWxpYSBTLkwuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwKKyAqIEJvc3Rvbiwg TUEgMDIxMTAtMTMwMSwgVVNBLgorICovCisgCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVk ZSAiRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oIgorCisjaW5jbHVkZSAiQVhPYmplY3RDYWNo ZS5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmgiCisjaW5jbHVk ZSAiVGV4dC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgRGVsZXRlRnJvbVRleHRO b2RlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eShib29sIGlzVW5kbykKK3sKKyAgICBpZiAo IUFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIHJldHVybjsK KworICAgIFRleHQqIG5vZGUgPSBtX25vZGUuZ2V0KCk7CisgICAgTm9kZSogcGFyZW50ID0gbm9k ZS0+cGFyZW50Tm9kZSgpOworICAgIFJlbmRlck9iamVjdCogdGV4dFJlbmRlcmVyID0gcGFyZW50 LT5yZW5kZXJlcigpOworICAgIGlmICghdGV4dFJlbmRlcmVyKQorICAgICAgICByZXR1cm47CisK KyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBheE9iamVjdCA9IGRvY3VtZW50KCktPmF4T2JqZWN0 Q2FjaGUoKS0+Z2V0T3JDcmVhdGUodGV4dFJlbmRlcmVyKTsKKyAgICBpZiAoIWF4T2JqZWN0KQor ICAgICAgICByZXR1cm47CisKKyAgICBBdGtPYmplY3QqIHdyYXBwZXIgPSBheE9iamVjdC0+d3Jh cHBlcigpOworICAgIGlmIChBVEtfSVNfVEVYVCh3cmFwcGVyKSAmJiBtX2NvdW50ID4gMCkgewor ICAgICAgICAvLyBDYWxjdWxhdGUgb2Zmc2V0CisgICAgICAgIGxvbmcgb2Zmc2V0ID0gMDsKKyAg ICAgICAgZm9yIChOb2RlICpuID0gcGFyZW50LT5maXJzdENoaWxkKCk7IG4gJiYgKG4gIT0gbm9k ZSk7IG4gPSBuLT5uZXh0U2libGluZygpKSB7CisgICAgICAgICAgICBpZiAobi0+aXNUZXh0Tm9k ZSgpKQorICAgICAgICAgICAgICAgIG9mZnNldCArPSBuLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsK KyAgICAgICAgfQorICAgICAgICBvZmZzZXQgKz0gbV9vZmZzZXQ7CisKKyAgICAgICAgaWYgKGlz VW5kbykKKyAgICAgICAgICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCAidGV4dC1j aGFuZ2VkOjppbnNlcnQiLCBvZmZzZXQsIG1fY291bnQpOworICAgICAgICBlbHNlCisgICAgICAg ICAgICBnX3NpZ25hbF9lbWl0X2J5X25hbWUod3JhcHBlciwgInRleHQtY2hhbmdlZDo6ZGVsZXRl Iiwgb2Zmc2V0LCBtX2NvdW50KTsKKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUK LS0gCjEuNy4wLjQKCg== 60947 2010-07-08 13:45:54 -0700 2010-07-16 01:50:48 -0700 4. New InsertNodeBeforeCommand::notifyAccessibility() private method 0004-2010-07-08-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 6861 mario RnJvbSA4ODE1ZmI1YTBhNGFjMGQwZTM3YTU2M2M3N2NmYmZkNjZhYThjM2U3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDggSnVsIDIwMTAgMTM6MTc6MDkgKzAyMDAKU3ViamVjdDogW1BBVENI IDQvNV0gMjAxMC0wNy0wOCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBv YmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBh bmQgcGFzc3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAoKICAgICAgICBOZXcgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6Om5vdGlm eUFjY2Vzc2liaWxpdHkoKSBwcml2YXRlIG1ldGhvZAoKICAgICAgICBBZGRlZCBhIGR1bW15IHZl cnNpb24gZm9yIGFsbCBwbGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aAogICAgICAg IGEgc3BlY2lmaWMgaW1wbGVtZW50YXRpb24gdG8gaGFuZGxlIHRoZSB0ZXh0LWNoYW5nZWQgZXZl bnRzCgogICAgICAgICogR05VbWFrZWZpbGUuYW06CiAgICAgICAgKiBlZGl0aW5nL0luc2VydE5v ZGVCZWZvcmVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNv bW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFu ZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQu aDoKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6Om5vdGlmeUFjY2Vz c2liaWxpdHkpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgICAxOSArKysrKysKIFdlYkNvcmUvR05VbWFrZWZpbGUuYW0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJl Zm9yZUNvbW1hbmQuY3BwICAgICAgICB8ICAgIDQgKwogV2ViQ29yZS9lZGl0aW5nL0luc2VydE5v ZGVCZWZvcmVDb21tYW5kLmggICAgICAgICAgfCAgICA4ICsrKwogV2ViQ29yZS9lZGl0aW5nL2d0 ay9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZEd0ay5jcHAgfCAgIDY1ICsrKysrKysrKysrKysrKysr KysrCiA1IGZpbGVzIGNoYW5nZWQsIDk3IGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL2d0ay9JbnNlcnROb2RlQmVmb3JlQ29t bWFuZEd0ay5jcHAKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hh bmdlTG9nCmluZGV4IGQ0YmQ1MGIuLjdjMzI5N2YgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdl TG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC01LDYgKzUsMjUgQEAKICAgICAgICAgW0d0 a10gb2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJp ZXMgYW5kIHBhc3N3b3JkIHRleHQKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTI1ODk4CiAKKyAgICAgICAgTmV3IEluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpub3RpZnlBY2Nlc3NpYmlsaXR5KCkgcHJpdmF0ZSBtZXRob2QKKworICAgICAgICBBZGRlZCBh IGR1bW15IHZlcnNpb24gZm9yIGFsbCBwbGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0 aAorICAgICAgICBhIHNwZWNpZmljIGltcGxlbWVudGF0aW9uIHRvIGhhbmRsZSB0aGUgdGV4dC1j aGFuZ2VkIGV2ZW50cworCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogZWRp dGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNl cnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRO b2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydE5v ZGVCZWZvcmVDb21tYW5kLmg6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eSk6CisKKzIwMTAtMDctMDggIE1hcmlvIFNhbmNoZXog UHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNoYW5nZWQgZXZlbnRzIHNo b3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0ZXh0CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5OAorCiAgICAgICAgIE5l dyBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmlsaXR5KCkgcHJpdmF0 ZSBtZXRob2QKIAogICAgICAgICBBZGRlZCBhIGR1bW15IHZlcnNpb24gZm9yIGFsbCBwbGF0Zm9y bXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9HTlVtYWtl ZmlsZS5hbSBiL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KaW5kZXggN2Q0ZmJiZS4uMTM5ZDU5ZiAx MDA2NDQKLS0tIGEvV2ViQ29yZS9HTlVtYWtlZmlsZS5hbQorKysgYi9XZWJDb3JlL0dOVW1ha2Vm aWxlLmFtCkBAIC0xMDUyLDYgKzEwNTIsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVdlYkNv cmUvZWRpdGluZy92aXNpYmxlX3VuaXRzLmggXAogCVdlYkNvcmUvZWRpdGluZy9ndGsvRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZEd0ay5jcHAgXAogCVdlYkNvcmUvZWRpdGluZy9ndGsvSW5zZXJ0 SW50b1RleHROb2RlQ29tbWFuZEd0ay5jcHAgXAorCVdlYkNvcmUvZWRpdGluZy9ndGsvSW5zZXJ0 Tm9kZUJlZm9yZUNvbW1hbmRHdGsuY3BwIFwKIAlXZWJDb3JlL2VkaXRpbmcvZ3RrL1NlbGVjdGlv bkNvbnRyb2xsZXJHdGsuY3BwIFwKIAlXZWJDb3JlL2hpc3RvcnkvQmFja0ZvcndhcmRDb250cm9s bGVyLmNwcCBcCiAJV2ViQ29yZS9oaXN0b3J5L0JhY2tGb3J3YXJkQ29udHJvbGxlci5oIFwKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAgYi9X ZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCmluZGV4IDJjZTk4NDYu LjNkNTE4ZTQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29t bWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNw cApAQCAtNTEsNiArNTEsOCBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5 KCkKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgcGFyZW50LT5pbnNlcnRCZWZvcmUobV9p bnNlcnRDaGlsZC5nZXQoKSwgbV9yZWZDaGlsZC5nZXQoKSwgZWMpOworCisgICAgbm90aWZ5QWNj ZXNzaWJpbGl0eShmYWxzZSk7CiB9CiAKIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRv VW5hcHBseSgpCkBAIC01OCw2ICs2MCw4IEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6 OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX2luc2VydENoaWxkLT5pc0NvbnRlbnRFZGl0YWJsZSgp KQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIG5vdGlmeUFjY2Vzc2liaWxpdHkodHJ1 ZSk7CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1faW5zZXJ0Q2hpbGQtPnJlbW92ZShl Yyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1h bmQuaCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5oCmluZGV4IDA5 MDQ1MDIuLmVjMDY4OGYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVm b3JlQ29tbWFuZC5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFu ZC5oCkBAIC00MywxMCArNDMsMTggQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIHZvaWQgZG9BcHBs eSgpOwogICAgIHZpcnR1YWwgdm9pZCBkb1VuYXBwbHkoKTsKIAorICAgIHZvaWQgbm90aWZ5QWNj ZXNzaWJpbGl0eShib29sIGlzVW5kbyk7CisKICAgICBSZWZQdHI8Tm9kZT4gbV9pbnNlcnRDaGls ZDsKICAgICBSZWZQdHI8Tm9kZT4gbV9yZWZDaGlsZDsgCiB9OwogCisjaWYgIVBMQVRGT1JNKEdU SykKK2lubGluZSB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmls aXR5KGJvb2wgaXNVbmRvKQoreworfQorI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK IAogI2VuZGlmIC8vIEluc2VydE5vZGVCZWZvcmVDb21tYW5kX2gKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9ndGsvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmRHdGsuY3BwIGIvV2ViQ29yZS9l ZGl0aW5nL2d0ay9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uZjVhNzM1NgotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9ndGsvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmRHdGsuY3BwCkBAIC0wLDAgKzEsNjUg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBz ZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuCisgKi8KKyAKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJJbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5oIgorCisjaW5jbHVkZSAi QVhPYmplY3RDYWNoZS5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRr LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFu ZDo6bm90aWZ5QWNjZXNzaWJpbGl0eShib29sIGlzVW5kbykKK3sKKyAgICBpZiAoIUFYT2JqZWN0 Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIE5v ZGUqIG5vZGUgPSBtX2luc2VydENoaWxkLmdldCgpOworICAgIGlmICghbm9kZS0+aXNUZXh0Tm9k ZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBOb2RlKiBwYXJlbnQgPSBub2RlLT5wYXJlbnRO b2RlKCk7CisgICAgUmVuZGVyT2JqZWN0KiB0ZXh0UmVuZGVyZXIgPSBwYXJlbnQtPnJlbmRlcmVy KCk7CisgICAgaWYgKCF0ZXh0UmVuZGVyZXIpCisgICAgICAgIHJldHVybjsKKworICAgIEFjY2Vz c2liaWxpdHlPYmplY3QqIGF4T2JqZWN0ID0gZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5n ZXRPckNyZWF0ZSh0ZXh0UmVuZGVyZXIpOworICAgIGlmICghYXhPYmplY3QpCisgICAgICAgIHJl dHVybjsKKworICAgIEF0a09iamVjdCogd3JhcHBlciA9IGF4T2JqZWN0LT53cmFwcGVyKCk7Cisg ICAgaWYgKEFUS19JU19URVhUKHdyYXBwZXIpKSB7CisgICAgICAgIHVuc2lnbmVkIGxlbiA9IG5v ZGUtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpOworICAgICAgICBpZiAobGVuID4gMCkgeworICAgICAg ICAgICAgLy8gQ2FsY3VsYXRlIG9mZnNldAorICAgICAgICAgICAgbG9uZyBvZmZzZXQgPSAwOwor ICAgICAgICAgICAgZm9yIChOb2RlICpuID0gcGFyZW50LT5maXJzdENoaWxkKCk7IG4gJiYgKG4g IT0gbm9kZSk7IG4gPSBuLT5uZXh0U2libGluZygpKSB7CisgICAgICAgICAgICAgICAgaWYgKG4t PmlzVGV4dE5vZGUoKSkKKyAgICAgICAgICAgICAgICAgICAgb2Zmc2V0ICs9IG4tPm5vZGVWYWx1 ZSgpLmxlbmd0aCgpOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICBpZiAoaXNVbmRvKQor ICAgICAgICAgICAgICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCAidGV4dC1jaGFu Z2VkOjpkZWxldGUiLCBvZmZzZXQsIGxlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdyYXBwZXIsICJ0ZXh0LWNoYW5nZWQ6Omluc2Vy dCIsIG9mZnNldCwgbGVuKTsKKyAgICAgICAgfQorICAgIH0KK30KKworfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQotLSAKMS43LjAuNAoK 60948 2010-07-08 13:46:30 -0700 2010-07-16 01:50:52 -0700 5. New AppendNodeCommand::notifyAccessibility() private method 0005-2010-07-08-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 6670 mario RnJvbSA5Y2JhOTZmZWYxZDVlN2ZmNDAwNWJkYjMyYzcyYTRkNDMwMGI4ZTAxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDggSnVsIDIwMTAgMTM6MTk6NDMgKzAyMDAKU3ViamVjdDogW1BBVENI IDUvNV0gMjAxMC0wNy0wOCAgTWFyaW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5j b20+CgogICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBv YmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBh bmQgcGFzc3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAoKICAgICAgICBOZXcgQXBwZW5kTm9kZUNvbW1hbmQ6Om5vdGlmeUFjY2Vz c2liaWxpdHkoKSBwcml2YXRlIG1ldGhvZAoKICAgICAgICBBZGRlZCBhIGR1bW15IHZlcnNpb24g Zm9yIGFsbCBwbGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aAogICAgICAgIGEgc3Bl Y2lmaWMgaW1wbGVtZW50YXRpb24gdG8gaGFuZGxlIHRoZSB0ZXh0LWNoYW5nZWQgZXZlbnRzCgog ICAgICAgICogR05VbWFrZWZpbGUuYW06CiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21t YW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgog ICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAq IGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuaDoKICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9k ZUNvbW1hbmQ6Om5vdGlmeUFjY2Vzc2liaWxpdHkpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxOSArKysrKysrCiBXZWJDb3JlL0dOVW1ha2Vm aWxlLmFtICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViQ29yZS9lZGl0aW5nL0Fw cGVuZE5vZGVDb21tYW5kLmNwcCAgICAgICAgfCAgICA0ICsrCiBXZWJDb3JlL2VkaXRpbmcvQXBw ZW5kTm9kZUNvbW1hbmQuaCAgICAgICAgICB8ICAgIDkgKysrKwogV2ViQ29yZS9lZGl0aW5nL2d0 ay9BcHBlbmROb2RlQ29tbWFuZEd0ay5jcHAgfCAgIDY2ICsrKysrKysrKysrKysrKysrKysrKysr KysrCiA1IGZpbGVzIGNoYW5nZWQsIDk5IGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgV2ViQ29yZS9lZGl0aW5nL2d0ay9BcHBlbmROb2RlQ29tbWFuZEd0 ay5jcHAKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9n CmluZGV4IDdjMzI5N2YuLmIwODZhNjIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisr KyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC01LDYgKzUsMjUgQEAKICAgICAgICAgW0d0a10gb2Jq ZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5k IHBhc3N3b3JkIHRleHQKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTI1ODk4CiAKKyAgICAgICAgTmV3IEFwcGVuZE5vZGVDb21tYW5kOjpub3RpZnlBY2Nl c3NpYmlsaXR5KCkgcHJpdmF0ZSBtZXRob2QKKworICAgICAgICBBZGRlZCBhIGR1bW15IHZlcnNp b24gZm9yIGFsbCBwbGF0Zm9ybXMgYnV0IEdUSywgd2hpY2ggY29tZXMgd2l0aAorICAgICAgICBh IHNwZWNpZmljIGltcGxlbWVudGF0aW9uIHRvIGhhbmRsZSB0aGUgdGV4dC1jaGFuZ2VkIGV2ZW50 cworCisgICAgICAgICogR05VbWFrZWZpbGUuYW06CisgICAgICAgICogZWRpdGluZy9BcHBlbmRO b2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9B cHBseSk6CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToK KyAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmg6CisgICAgICAgIChXZWJDb3Jl OjpBcHBlbmROb2RlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eSk6CisKKzIwMTAtMDctMDgg IE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNo YW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0 ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5 OAorCiAgICAgICAgIE5ldyBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJp bGl0eSgpIHByaXZhdGUgbWV0aG9kCiAKICAgICAgICAgQWRkZWQgYSBkdW1teSB2ZXJzaW9uIGZv ciBhbGwgcGxhdGZvcm1zIGJ1dCBHVEssIHdoaWNoIGNvbWVzIHdpdGgKZGlmZiAtLWdpdCBhL1dl YkNvcmUvR05VbWFrZWZpbGUuYW0gYi9XZWJDb3JlL0dOVW1ha2VmaWxlLmFtCmluZGV4IDEzOWQ1 OWYuLjc3Njk4NzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvR05VbWFrZWZpbGUuYW0KKysrIGIvV2Vi Q29yZS9HTlVtYWtlZmlsZS5hbQpAQCAtMTA1MCw2ICsxMDUwLDcgQEAgd2ViY29yZV9zb3VyY2Vz ICs9IFwKIAlXZWJDb3JlL2VkaXRpbmcvbWFya3VwLmggXAogCVdlYkNvcmUvZWRpdGluZy92aXNp YmxlX3VuaXRzLmNwcCBcCiAJV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuaCBcCisJV2Vi Q29yZS9lZGl0aW5nL2d0ay9BcHBlbmROb2RlQ29tbWFuZEd0ay5jcHAgXAogCVdlYkNvcmUvZWRp dGluZy9ndGsvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZEd0ay5jcHAgXAogCVdlYkNvcmUvZWRp dGluZy9ndGsvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZEd0ay5jcHAgXAogCVdlYkNvcmUvZWRp dGluZy9ndGsvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmRHdGsuY3BwIFwKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvQXBw ZW5kTm9kZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLmNhZjZkODkgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5n L0FwcGVuZE5vZGVDb21tYW5kLmNwcApAQCAtNDksNiArNDksOCBAQCB2b2lkIEFwcGVuZE5vZGVD b21tYW5kOjpkb0FwcGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBt X3BhcmVudC0+YXBwZW5kQ2hpbGQobV9ub2RlLmdldCgpLCBlYyk7CisKKyAgICBub3RpZnlBY2Nl c3NpYmlsaXR5KGZhbHNlKTsKIH0KIAogdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5 KCkKQEAgLTU2LDYgKzU4LDggQEAgdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkK ICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47 CiAgICAgICAgIAorICAgIG5vdGlmeUFjY2Vzc2liaWxpdHkodHJ1ZSk7CisKICAgICBFeGNlcHRp b25Db2RlIGVjOwogICAgIG1fbm9kZS0+cmVtb3ZlKGVjKTsKIH0KZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5oIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5v ZGVDb21tYW5kLmgKaW5kZXggNWZmYjg4MS4uMDc1MTlhYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmgKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5v ZGVDb21tYW5kLmgKQEAgLTQzLDEwICs0MywxOSBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgdm9p ZCBkb0FwcGx5KCk7CiAgICAgdmlydHVhbCB2b2lkIGRvVW5hcHBseSgpOwogCisgICAgdm9pZCBu b3RpZnlBY2Nlc3NpYmlsaXR5KGJvb2wgaXNVbmRvKTsKKwogICAgIFJlZlB0cjxFbGVtZW50PiBt X3BhcmVudDsKICAgICBSZWZQdHI8Tm9kZT4gbV9ub2RlOwogfTsKIAorCisjaWYgIVBMQVRGT1JN KEdUSykKK2lubGluZSB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpub3RpZnlBY2Nlc3NpYmlsaXR5 KGJvb2wgaXNVbmRvKQoreworfQorI2VuZGlmCisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAog I2VuZGlmIC8vIEFwcGVuZE5vZGVDb21tYW5kX2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9ndGsvQXBwZW5kTm9kZUNvbW1hbmRHdGsuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL2d0ay9BcHBl bmROb2RlQ29tbWFuZEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MmQyYzZjYwotLS0gL2Rldi9udWxsCisrKyBiL1dlYkNvcmUvZWRpdGluZy9ndGsvQXBwZW5kTm9k ZUNvbW1hbmRHdGsuY3BwCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTAgSWdhbGlhIFMuTC4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIg b2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisg KgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UK KyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJ ZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1 MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLAorICogQm9zdG9uLCBNQSAwMjExMC0xMzAx LCBVU0EuCisgKi8KKyAKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJBcHBlbmROb2Rl Q29tbWFuZC5oIgorCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgorI2luY2x1ZGUgIkFjY2Vz c2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9p ZCBBcHBlbmROb2RlQ29tbWFuZDo6bm90aWZ5QWNjZXNzaWJpbGl0eShib29sIGlzVW5kbykKK3sK KyAgICBpZiAoIUFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAg IHJldHVybjsKKworICAgIE5vZGUqIG5vZGUgPSBtX25vZGUuZ2V0KCk7CisgICAgaWYgKCFub2Rl LT5pc1RleHROb2RlKCkpCisgICAgICAgIHJldHVybjsKKworICAgIE5vZGUqIHBhcmVudCA9IG5v ZGUtPnBhcmVudE5vZGUoKTsKKyAgICBSZW5kZXJPYmplY3QqIHRleHRSZW5kZXJlciA9IHBhcmVu dC0+cmVuZGVyZXIoKTsKKyAgICBpZiAoIXRleHRSZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOwor CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYXhPYmplY3QgPSBkb2N1bWVudCgpLT5heE9iamVj dENhY2hlKCktPmdldE9yQ3JlYXRlKHRleHRSZW5kZXJlcik7CisgICAgaWYgKCFheE9iamVjdCkK KyAgICAgICAgcmV0dXJuOworCisgICAgQXRrT2JqZWN0KiB3cmFwcGVyID0gYXhPYmplY3QtPndy YXBwZXIoKTsKKyAgICBpZiAoQVRLX0lTX1RFWFQod3JhcHBlcikpIHsKKyAgICAgICAgdW5zaWdu ZWQgbGVuID0gbm9kZS0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgICAgIC8vIERvbid0IGNv bnNpZGVyIGxpbmVicmVha3MgaW4gdGhpcyBjb21tYW5kCisgICAgICAgIGlmIChsZW4gPiAwICYm IG5vZGUtPm5vZGVWYWx1ZSgpICE9ICJcbiIpIHsKKyAgICAgICAgICAgIC8vIENhbGN1bGF0ZSBv ZmZzZXQKKyAgICAgICAgICAgIGxvbmcgb2Zmc2V0ID0gMDsKKyAgICAgICAgICAgIGZvciAoTm9k ZSAqbiA9IHBhcmVudC0+Zmlyc3RDaGlsZCgpOyBuICYmIChuICE9IG5vZGUpOyBuID0gbi0+bmV4 dFNpYmxpbmcoKSkgeworICAgICAgICAgICAgICAgIGlmIChuLT5pc1RleHROb2RlKCkpCisgICAg ICAgICAgICAgICAgICAgIG9mZnNldCArPSBuLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAg ICAgICAgIH0KKworICAgICAgICAgICAgaWYgKGlzVW5kbykKKyAgICAgICAgICAgICAgICBnX3Np Z25hbF9lbWl0X2J5X25hbWUod3JhcHBlciwgInRleHQtY2hhbmdlZDo6ZGVsZXRlIiwgb2Zmc2V0 LCBsZW4pOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGdfc2lnbmFsX2VtaXRf YnlfbmFtZSh3cmFwcGVyLCAidGV4dC1jaGFuZ2VkOjppbnNlcnQiLCBvZmZzZXQsIGxlbik7Cisg ICAgICAgIH0KKyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKLS0gCjEuNy4wLjQK Cg== 61782 2010-07-16 01:52:49 -0700 2010-07-16 16:36:35 -0700 2. New functions in AXObjectCache to call when text changes in a node 0002-2010-07-16-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 10977 mario RnJvbSBjNjg0MDliN2E4OTAzMDE1YTA3MjlkNzNmY2Q5YzNkNjI0MTQwZGU0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBGcmksIDE2IEp1bCAyMDEwIDA5OjU0OjAwICswMjAwClN1YmplY3Q6IFtQQVRD SCAyLzNdIDIwMTAtMDctMTYgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10g b2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMg YW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTmV3IGZ1bmN0aW9ucyBpbiBBWE9iamVjdENhY2hlIHRv IGNhbGwgd2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlCgogICAgICAgIEFkZGVkIHR3byBuZXcg ZnVuY3Rpb25zIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAg ICAgdGV4dCBub2RlIGVpdGhlciB0aHJvdWdoIGEgUmVuZGVyT2JqZWN0IG9yIGFuIEFjY2Vzc2li aWxpdHlPYmplY3QsCiAgICAgICAgbWFraW5nIHRob3NlIGZ1bmN0aW9ucyBkZXBlbmRhbnQgb24g dGhlIHBsYXRmb3JtLXNwZWNpZmljCiAgICAgICAgaW1wbGVtZW50YXRpb24sIHByb3ZpZGVkIHRo cm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rpb24uCgogICAgICAgIEFsc28sIHByb3ZpZGVkIGEgR1RL IGltcGxlbWVudGF0aW9uIG9mIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYwogICAgICAgIGZ1bmN0aW9u IChhcyB0aGlzIGNoYW5nZSB3YXMgbW90aXZhdGVkIGJ5IHRoZSBHVEsgcG9ydCksIGFzIHdlbGwK ICAgICAgICBhcyBkdW1teSBpbXBsZW1lbnRhdGlvbnMgZm9yIHRoZSBvdGhlciBwb3J0cyB3aXRo IGFjY2Vzc2liaWxpdHkKICAgICAgICBzdXBwb3J0LCB0aGF0IGlzLCBtYWMgYW5kIHdpbiBwb3J0 cy4KCiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6 OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENoYW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90 aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hl QXRrLmNwcDoKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhP YmplY3RDYWNoZU1hYy5tbToKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0 eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKLS0tCiBXZWJDb3Jl L0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzMiArKysrKysrKysr KysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwICAgICAgICB8 ICAgMTggKysrKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCAg ICAgICAgICB8ICAgMTIgKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVj dENhY2hlQXRrLmNwcCB8ICAgNDMgKysrKysrKysrKysrKysrKysrKysrKysrCiBXZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gIHwgICAgNCArKwogV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCB8ICAgIDQgKysKIDYgZmlsZXMg Y2hhbmdlZCwgMTEzIGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMmRmODBhLi5kN2Jh MDBiIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDM1IEBACisyMDEwLTA3LTE2ICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNh bmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1p dHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKworICAgICAgICBOZXcgZnVuY3Rpb25z IGluIEFYT2JqZWN0Q2FjaGUgdG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUKKwor ICAgICAgICBBZGRlZCB0d28gbmV3IGZ1bmN0aW9ucyB0byBhbGxvdyBub3RpZnlpbmcgc29tZXRo aW5nIGNoYW5nZWQgaW4gYQorICAgICAgICB0ZXh0IG5vZGUgZWl0aGVyIHRocm91Z2ggYSBSZW5k ZXJPYmplY3Qgb3IgYW4gQWNjZXNzaWJpbGl0eU9iamVjdCwKKyAgICAgICAgbWFraW5nIHRob3Nl IGZ1bmN0aW9ucyBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljCisgICAgICAgIGlt cGxlbWVudGF0aW9uLCBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9uLgorCisg ICAgICAgIEFsc28sIHByb3ZpZGVkIGEgR1RLIGltcGxlbWVudGF0aW9uIG9mIHRoZSBwbGF0Zm9y bS1zcGVjaWZpYworICAgICAgICBmdW5jdGlvbiAoYXMgdGhpcyBjaGFuZ2Ugd2FzIG1vdGl2YXRl ZCBieSB0aGUgR1RLIHBvcnQpLCBhcyB3ZWxsCisgICAgICAgIGFzIGR1bW15IGltcGxlbWVudGF0 aW9ucyBmb3IgdGhlIG90aGVyIHBvcnRzIHdpdGggYWNjZXNzaWJpbGl0eQorICAgICAgICBzdXBw b3J0LCB0aGF0IGlzLCBtYWMgYW5kIHdpbiBwb3J0cy4KKworICAgICAgICAqIGFjY2Vzc2liaWxp dHkvQVhPYmplY3RDYWNoZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5oOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0 Q2hhbmdlKTogTmV3IGVudW1lcmF0aW9uCisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAoV2ViQ29yZTo6QVhP YmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwOgorICAgICAgICAo V2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlv bik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06 CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3Jt Tm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RD YWNoZVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENo YW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisKIDIwMTAtMDctMDggIE1hcmlvIFNhbmNo ZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0 Q2FjaGUuY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4 IDc1MGM2MTEuLmZiZGIxMTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9i amVjdENhY2hlLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5j cHAKQEAgLTQ1Myw2ICs0NTMsMjQgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxk cmVuQ2hhbmdlZChSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIC8vIHRvIGZpbmQgdGhlIGNv bnRhaW5lciB3aGljaCBzaG91bGQgc2VuZCBvdXQgdGhlIG5vdGlmaWNhdGlvbi4KICAgICBwb3N0 Tm90aWZpY2F0aW9uKHJlbmRlcmVyLCBBWFNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkLCBmYWxzZSk7 CiB9CisKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVu ZGVyT2JqZWN0KiByZW5kZXJlciwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9m ZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0 dXJuOworCisgICAgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+IG9iamVjdCA9IGdldE9yQ3Jl YXRlKHJlbmRlcmVyKTsKKyAgICBub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihvYmplY3QuZ2V0 KCksIHRleHRDaGFuZ2UsIG9mZnNldCwgY291bnQpOworfQorCit2b2lkIEFYT2JqZWN0Q2FjaGU6 Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iamVjdCwg QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQp Cit7CisgICAgaWYgKCFvYmplY3QpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIERlbGVnYXRl IG9uIHRoZSByaWdodCBwbGF0Zm9ybQorICAgIG5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24ob2JqZWN0LCB0ZXh0Q2hhbmdlLCBvZmZzZXQsIGNvdW50KTsKK30KICNlbmRpZgogCiAj aWYgSEFWRShBQ0NFU1NJQklMSVRZKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuaCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgK aW5kZXggZjE4ZDA4YS4uOWM4YzZlNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuaAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNo ZS5oCkBAIC0xMjQsMTAgKzEyNCwxOSBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0Tm90aWZpY2F0 aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBv c3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3RpZmljYXRpb24o QWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9z dFRvRWxlbWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisgICAgZW51bSBB WFRleHRDaGFuZ2UgeworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAgQVhUZXh0RGVs ZXRlZCwKKyAgICB9OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5k ZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQp OworICAgIHZvaWQgbm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVj dCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CisKICAg ICBib29sIG5vZGVIYXNSb2xlKE5vZGUqLCBjb25zdCBBdG9taWNTdHJpbmcmIHJvbGUpOwogCiBw cm90ZWN0ZWQ6CiAgICAgdm9pZCBwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0 eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKTsKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdlUGxhdGZv cm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWdu ZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CiAKIHByaXZhdGU6CiAgICAgSGFzaE1hcDxBWElE LCBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gPiBtX29iamVjdHM7CkBAIC0xNTUsNiArMTY0 LDkgQEAgaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQo UmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0Tm90aWZp Y2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQs IFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3ROb3RpZmljYXRp b24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJvb2wg cG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6 cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWE5vdGlmaWNh dGlvbikgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlm aWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5z aWduZWQgY291bnQpIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFu Z2VOb3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWdu ZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3Qq LCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpIHsgfQogaW5s aW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVu ZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hl OjpoYW5kbGVTY3JvbGxlZFRvQW5jaG9yKGNvbnN0IE5vZGUqKSB7IH0KIGlubGluZSB2b2lkIEFY T2JqZWN0Q2FjaGU6OmNvbnRlbnRDaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcCBiL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKaW5kZXggYzMwYjAwNi4u M2Y0OTAxZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENh Y2hlQXRrLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVB dGsuY3BwCkBAIC0yMiw2ICsyMiw3IEBACiAKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0 LmgiCiAjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuaCIKKyNpbmNsdWRl ICJBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApA QCAtNTAsNiArNTEsNDggQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmlj YXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAgICB9CiB9CiAKK3Zv aWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nl c3NpYmlsaXR5T2JqZWN0KiBvYmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25l ZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVjaworICAgIGlm IChvZmZzZXQgPCAwIHx8IGNvdW50IDw9IDAgfHwgIW9iamVjdCB8fCAhb2JqZWN0LT5pc0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gR2V0IHRo ZSBhc3NvY2lhdGVkIG5vZGUKKyAgICBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiByZW5kZXJP YmplY3QgPSBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsK KyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gcmVuZGVyT2JqZWN0LT5yZW5kZXJlcigpOwor ICAgIGlmICghcmVuZGVyZXIpCisgICAgICByZXR1cm47CisKKyAgICBOb2RlKiBub2RlID0gcmVu ZGVyZXItPm5vZGUoKTsKKyAgICBOb2RlKiBwYXJlbnROb2RlID0gbm9kZS0+cGFyZW50Tm9kZSgp OworCisgICAgLy8gR2V0IHRoZSBheE9iamVjdCBmb3IgdGhlIHBhcmVudCBub2RlCisgICAgUmVu ZGVyT2JqZWN0KiBwYXJlbnRSZW5kZXJlciA9IHBhcmVudE5vZGUtPnJlbmRlcmVyKCk7CisgICAg aWYgKCFwYXJlbnRSZW5kZXJlcikKKyAgICAgIHJldHVybjsKKworICAgIEFjY2Vzc2liaWxpdHlP YmplY3QqIGF4T2JqZWN0ID0gZ2V0T3JDcmVhdGUocGFyZW50UmVuZGVyZXIpOworICAgIGlmICgh YXhPYmplY3QpCisgICAgICAgIHJldHVybjsKKworICAgIEF0a09iamVjdCogd3JhcHBlciA9IGF4 T2JqZWN0LT53cmFwcGVyKCk7CisgICAgaWYgKCF3cmFwcGVyIHx8ICFBVEtfSVNfVEVYVCh3cmFw cGVyKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gQ2FsY3VsYXRlIGdsb2JhbCBvZmZzZXQg KGluIHRoZSB3aG9sZSB0ZXh0LCBub3QganVzdCBpbiB0aGUgY3VycmVudCBub2RlKQorICAgIHVu c2lnbmVkIGdsb2JhbE9mZnNldCA9IG9mZnNldDsKKyAgICBmb3IgKE5vZGUgKm4gPSBwYXJlbnRO b2RlLT5maXJzdENoaWxkKCk7IG4gJiYgKG4gIT0gbm9kZSk7IG4gPSBuLT5uZXh0U2libGluZygp KSB7CisgICAgICBpZiAobi0+aXNUZXh0Tm9kZSgpKQorICAgICAgICBnbG9iYWxPZmZzZXQgKz0g bi0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgfQorCisgICAgLy8gRW1pdCB0aGUgcmlnaHQg c2lnbmFsCisgICAgaWYgKHRleHRDaGFuZ2UgPT0gQVhUZXh0SW5zZXJ0ZWQpCisgICAgICAgIGdf c2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCAidGV4dC1jaGFuZ2VkOjppbnNlcnQiLCBnbG9i YWxPZmZzZXQsIGNvdW50KTsKKyAgICBlbHNlIGlmICh0ZXh0Q2hhbmdlID09IEFYVGV4dERlbGV0 ZWQpCisgICAgICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCAidGV4dC1jaGFuZ2Vk OjpkZWxldGUiLCBnbG9iYWxPZmZzZXQsIGNvdW50KTsKK30KKwogdm9pZCBBWE9iamVjdENhY2hl OjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqIG9sZEZvY3VzZWRS ZW5kZXIsIFJlbmRlck9iamVjdCogbmV3Rm9jdXNlZFJlbmRlcikKIHsKICAgICBSZWZQdHI8QWNj ZXNzaWJpbGl0eU9iamVjdD4gb2xkT2JqZWN0ID0gZ2V0T3JDcmVhdGUob2xkRm9jdXNlZFJlbmRl cik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVN YWMubW0gYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KaW5k ZXggYTAyYmM3NS4uMjJhMTJmMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21h Yy9BWE9iamVjdENhY2hlTWFjLm1tCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhP YmplY3RDYWNoZU1hYy5tbQpAQCAtMTE0LDYgKzExNCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6 OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90 aWZpYwogICAgIFtvYmotPndyYXBwZXIoKSBhY2Nlc3NpYmlsaXR5UG9zdGVkTm90aWZpY2F0aW9u Om1hY05vdGlmaWNhdGlvbl07CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFu Z2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QsIEFYVGV4 dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQorewor fQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJl bmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiAgICAgW1tXZWJDb3JlVmlld0ZhY3Rvcnkg c2hhcmVkRmFjdG9yeV0gYWNjZXNzaWJpbGl0eUhhbmRsZUZvY3VzQ2hhbmdlZF07CmRpZmYgLS1n aXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwIGIvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcAppbmRleCAyMWU2MWQ5 Li40ZjAyMjk4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0 Q2FjaGVXaW4uY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNo ZVdpbi5jcHAKQEAgLTEwMyw2ICsxMDMsMTAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqLCBBWE5vdGlmaWMKICAg ICBOb3RpZnlXaW5FdmVudChtc2FhRXZlbnQsIHBhZ2UtPmNocm9tZSgpLT5wbGF0Zm9ybVBhZ2VD bGllbnQoKSwgT0JKSURfQ0xJRU5ULCAtc3RhdGljX2Nhc3Q8TE9ORz4ob2JqLT5heE9iamVjdElE KCkpKTsKIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90 aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iamVjdCwgQVhUZXh0Q2hhbmdlIHRleHRD aGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7Cit9CisKIEFYSUQgQVhP YmplY3RDYWNoZTo6cGxhdGZvcm1HZW5lcmF0ZUFYSUQoKSBjb25zdAogewogICAgIHN0YXRpYyBB WElEIGxhc3RVc2VkSUQgPSAwOwotLSAKMS43LjAuNAoK 61783 2010-07-16 01:53:28 -0700 2010-07-22 18:19:28 -0700 3. Notify accessibility when something changes in a text node 0003-2010-07-16-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 9913 mario RnJvbSA1NmE3MjQyN2U5ODZmMTI4NDE1Y2E0ZmUxYzVmMjdhMTUyMGY3NDAwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBGcmksIDE2IEp1bCAyMDEwIDEwOjAzOjMzICswMjAwClN1YmplY3Q6IFtQQVRD SCAzLzNdIDIwMTAtMDctMTYgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10g b2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMg YW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTm90aWZ5IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhp bmcgY2hhbmdlcyBpbiBhIHRleHQgbm9kZS4KCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4 dCB3YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVk aXRpb24KICAgICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdp bmFsIHRleHQgd2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1i ZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0Fw cGVuZE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6 OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5 KToKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CiAgICAg ICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAg IChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVm b3JlQ29tbWFuZDo6ZG9VbmFwcGx5KToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfCAgIDI3ICsrKysrKysrKysrKysrKysrKysrKysrKysKIFdlYkNv cmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICB8ICAgMjIgKysrKysrKysr KysrKysrKysrKysKIFdlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNw cCB8ICAgMTQgKysrKysrKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9k ZUNvbW1hbmQuY3BwIHwgICAxNCArKysrKysrKysrKysrCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 Tm9kZUJlZm9yZUNvbW1hbmQuY3BwICAgfCAgIDIwICsrKysrKysrKysrKysrKysrKwogNSBmaWxl cyBjaGFuZ2VkLCA5NyBpbnNlcnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDdiYTAwYi4uMDVj YWRiMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VM b2cKQEAgLTUsNiArNSwzMyBAQAogICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2 ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAogICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKIAorICAg ICAgICBOb3RpZnkgYWNjZXNzaWJpbGl0eSB3aGVuIHNvbWV0aGluZyBjaGFuZ2VzIGluIGEgdGV4 dCBub2RlLgorCisgICAgICAgIENhbGwgdG8gQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VO b3RpZmljYXRpb24oKSB0byBub3RpZnkgd2hlbgorICAgICAgICB0ZXh0IHdhcyBpbnNlcnRlZC9k ZWxldGVkIHdoZW4gYXBwbHlpbmcvdW5hcHBseWluZyBhIHRleHQgZWRpdGlvbgorICAgICAgICBj b21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQgd2hlcmUg dGhlCisgICAgICAgIGNoYW5nZSB0b29rIHBsYWNlIGFuZCB0aGUgbnVtYmVyIG9mIGNoYXJhY3Rl cnMgdGhhdCBnb3QgYWZmZWN0ZWQuCisKKyAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KToK KyAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAg ICAqIGVkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJD b3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNv cmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRp dGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Oklu c2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0lu c2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVC ZWZvcmVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZv cmVDb21tYW5kOjpkb1VuYXBwbHkpOgorCisyMDEwLTA3LTE2ICBNYXJpbyBTYW5jaGV6IFByYWRh ICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQg YmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKwogICAgICAgICBOZXcgZnVu Y3Rpb25zIGluIEFYT2JqZWN0Q2FjaGUgdG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5v ZGUKIAogICAgICAgICBBZGRlZCB0d28gbmV3IGZ1bmN0aW9ucyB0byBhbGxvdyBub3RpZnlpbmcg c29tZXRoaW5nIGNoYW5nZWQgaW4gYQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVu ZE5vZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAK aW5kZXggNjE3ODY0MS4uYzFiMDAyYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVu ZE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQu Y3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiQXBw ZW5kTm9kZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRl ICJodG1sZWRpdGluZy5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00OSw2ICs1MCwxNiBA QCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0 aW9uQ29kZSBlYzsKICAgICBtX3BhcmVudC0+YXBwZW5kQ2hpbGQobV9ub2RlLmdldCgpLCBlYyk7 CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkgeworICAg ICAgICB1bnNpZ25lZCBsZW4gPSBtX25vZGUtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpOworICAgICAg ICAvLyBEb24ndCBjb25zaWRlciBsaW5lYnJlYWtzIGluIHRoaXMgY29tbWFuZAorICAgICAgICBp ZiAobGVuID4gMCAmJiBtX25vZGUtPm5vZGVWYWx1ZSgpICE9ICJcbiIpIHsKKyAgICAgICAgICBk b2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1f bm9kZS0+cmVuZGVyZXIoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVk LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgMCwgbGVuKTsKKyAgICAgICAgfQorICAgIH0KIH0KIAogdm9pZCBBcHBlbmRO b2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU2LDYgKzY3LDE3IEBAIHZvaWQgQXBwZW5kTm9k ZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX3BhcmVudC0+aXNDb250ZW50RWRpdGFi bGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0 aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENh Y2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIHVuc2lnbmVkIGxlbiA9IG1f bm9kZS0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgICAgIC8vIERvbid0IGNvbnNpZGVyIGxp bmVicmVha3MgaW4gdGhpcyBjb21tYW5kCisgICAgICAgIGlmIChsZW4gPiAwICYmIG1fbm9kZS0+ bm9kZVZhbHVlKCkgIT0gIlxuIikgeworICAgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2Fj aGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIGxlbik7Cisg ICAgICAgIH0KKyAgICB9CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+cmVt b3ZlKGVjKTsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5v ZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5k LmNwcAppbmRleCBmMWQ3OWFmLi41NTQyNTg5IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcv RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29u ZmlnLmgiCiAjaW5jbHVkZSAiRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVk ZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgIlRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtNTMsNiArNTQsMTMgQEAgdm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpk b0FwcGx5KCkKICAgICBpZiAoZWMpCiAgICAgICAgIHJldHVybjsKICAgICAKKyAgICAvLyBOZWVk IHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlm IChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIGRvY3Vt ZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2Rl LT5yZW5kZXJlcigpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgbV9vZmZzZXQsIG1fY291bnQpOworICAgIH0KKwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YSht X29mZnNldCwgbV9jb3VudCwgZWMpOwogfQogCkBAIC02NSw2ICs3MywxMiBAQCB2b2lkIERlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlv bkNvZGUgZWM7CiAgICAgbV9ub2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsK KworICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAg ICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRp b24obV9ub2RlLT5yZW5kZXJlcigpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2Vy dGVkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG1fb2Zmc2V0LCBtX2NvdW50KTsKKyAgICB9CiB9CiAKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5v ZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5k LmNwcAppbmRleCA5YzM0MjNhLi43OTBlY2FhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcv SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29u ZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVk ZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgIlRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewpAQCAtNDgsNiArNDksMTIgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpk b0FwcGx5KCkKICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+aW5zZXJ0 RGF0YShtX29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNj ZXNzaWJpbGl0eUVuYWJsZWQoKSkgeworICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hl KCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX29mZnNldCwgbV90ZXh0 Lmxlbmd0aCgpKTsKKyAgICB9CiB9CiAKIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KCkKQEAgLTU1LDYgKzYyLDEzIEBAIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29t bWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fbm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkK ICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJl Zm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjph Y2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2Fj aGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9vZmZzZXQsIG1fdGV4 dC5sZW5ndGgoKSk7CisgICAgfQorCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUt PmRlbGV0ZURhdGEobV9vZmZzZXQsIG1fdGV4dC5sZW5ndGgoKSwgZWMpOwogfQpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcCBiL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAKaW5kZXggMmNlOTg0Ni4uNDhhZjll MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNw cAorKysgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCkBAIC0y Niw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0Tm9kZUJl Zm9yZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJo dG1sZWRpdGluZy5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC01MSw2ICs1MiwxNSBAQCB2 b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5KCkKIAogICAgIEV4Y2VwdGlvbkNv ZGUgZWM7CiAgICAgcGFyZW50LT5pbnNlcnRCZWZvcmUobV9pbnNlcnRDaGlsZC5nZXQoKSwgbV9y ZWZDaGlsZC5nZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxp dHlFbmFibGVkKCkpIHsKKyAgICAgICAgdW5zaWduZWQgbGVuID0gbV9pbnNlcnRDaGlsZC0+bm9k ZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgICAgIGlmIChsZW4gPiAwKSB7CisgICAgICAgICAgICBk b2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1f aW5zZXJ0Q2hpbGQtPnJlbmRlcmVyKCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFYT2JqZWN0Q2FjaGU6OkFYVGV4 dEluc2VydGVkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAwLCBsZW4pOworICAgICAgICB9CisgICAgfQogfQogCiB2 b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTgsNiArNjgsMTYg QEAgdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1f aW5zZXJ0Q2hpbGQtPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybjsKICAgICAg ICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcg dGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkg eworICAgICAgICB1bnNpZ25lZCBsZW4gPSBtX2luc2VydENoaWxkLT5ub2RlVmFsdWUoKS5sZW5n dGgoKTsKKyAgICAgICAgaWYgKGxlbiA+IDApIHsKKyAgICAgICAgICAgIGRvY3VtZW50KCktPmF4 T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+ cmVuZGVyZXIoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgMCwgbGVuKTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIEV4Y2VwdGlvbkNvZGUg ZWM7CiAgICAgbV9pbnNlcnRDaGlsZC0+cmVtb3ZlKGVjKTsKIH0KLS0gCjEuNy4wLjQKCg== 61859 2010-07-16 16:36:35 -0700 2010-07-22 18:19:48 -0700 2. New functions in AXObjectCache to call when text changes in a node 0002-2010-07-17-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 10373 mario RnJvbSA3ZmIzZjVkMGI0OTIyOWM0NzlkYzcxNDFhN2MyNDBmMGZlZjdhOGYzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBTYXQsIDE3IEp1bCAyMDEwIDAwOjMzOjAyICswMjAwClN1YmplY3Q6IFtQQVRD SCAyLzNdIDIwMTAtMDctMTcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10g b2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMg YW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTmV3IGZ1bmN0aW9uIGluIEFYT2JqZWN0Q2FjaGUgdG8g Y2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUuCgogICAgICAgIEFkZGVkIG9uZSBuZXcg ZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKICAgICAg ICB0ZXh0IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBz dWNoIGEKICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmlj IGltcGxlbWVudGF0aW9uLAogICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVu Y3Rpb24uCgogICAgICAgIEFsc28sIHByb3ZpZGVkIGEgR1RLIGltcGxlbWVudGF0aW9uIG9mIHRo ZSBwbGF0Zm9ybS1zcGVjaWZpYwogICAgICAgIGZ1bmN0aW9uIChhcyB0aGlzIGNoYW5nZSB3YXMg bW90aXZhdGVkIGJ5IHRoZSBHVEsgcG9ydCksIGFzIHdlbGwKICAgICAgICBhcyBkdW1teSBpbXBs ZW1lbnRhdGlvbnMgZm9yIHRoZSBvdGhlciBwb3J0cyB3aXRoIGFjY2Vzc2liaWxpdHkKICAgICAg ICBzdXBwb3J0LCB0aGF0IGlzLCBtYWMgYW5kIHdpbiBwb3J0cy4KCiAgICAgICAgKiBhY2Nlc3Np YmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4 dENoYW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9i amVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAg ICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcDoKICAgICAgICAoV2Vi Q29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6 IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbToKICAg ICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlm aWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdp bi5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICAzMiArKysrKysrKysrKysrKysrKwogV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwICAgICAgICB8ICAgMTAgKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmggICAgICAgICAgfCAgIDEwICsrKysrCiBXZWJD b3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIHwgICA0MyArKysrKysr KysrKysrKysrKysrKysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNo ZU1hYy5tbSAgfCAgICA0ICsrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2Fj aGVXaW4uY3BwIHwgICAgNCArKwogNiBmaWxlcyBjaGFuZ2VkLCAxMDMgaW5zZXJ0aW9ucygrKSwg MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDAyZGY4MGEuLjYwNzJkYzIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAKKzIwMTAtMDct MTcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0 LWNoYW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29y ZCB0ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y NTg5OAorCisgICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRvIGNhbGwgd2hl biB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgorCisgICAgICAgIEFkZGVkIG9uZSBuZXcgZnVuY3Rp b24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKKyAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CisgICAgICAgIGZ1bmN0aW9uIGRlcGVuZGFudCBvbiB0aGUgcGxhdGZvcm0tc3BlY2lmaWMgaW1w bGVtZW50YXRpb24sCisgICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rp b24uCisKKyAgICAgICAgQWxzbywgcHJvdmlkZWQgYSBHVEsgaW1wbGVtZW50YXRpb24gb2YgdGhl IHBsYXRmb3JtLXNwZWNpZmljCisgICAgICAgIGZ1bmN0aW9uIChhcyB0aGlzIGNoYW5nZSB3YXMg bW90aXZhdGVkIGJ5IHRoZSBHVEsgcG9ydCksIGFzIHdlbGwKKyAgICAgICAgYXMgZHVtbXkgaW1w bGVtZW50YXRpb25zIGZvciB0aGUgb3RoZXIgcG9ydHMgd2l0aCBhY2Nlc3NpYmlsaXR5CisgICAg ICAgIHN1cHBvcnQsIHRoYXQgaXMsIG1hYyBhbmQgd2luIHBvcnRzLgorCisgICAgICAgICogYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNz aWJpbGl0eS9BWE9iamVjdENhY2hlLmg6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl OjpBWFRleHRDaGFuZ2UpOiBOZXcgZW51bWVyYXRpb24KKyAgICAgICAgKFdlYkNvcmU6OkFYT2Jq ZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgIChXZWJD b3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTog TmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90 aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNo ZU1hYy5tbToKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdl UGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L3dpbi9B WE9iamVjdENhY2hlV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKwogMjAxMC0wNy0wOCAgTWFy aW8gU2FuY2hleiBQcmFkYSAgPG1zYW5jaGV6QGlnYWxpYS5jb20+CiAKICAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5j cHAKaW5kZXggNzUwYzYxMS4uYmFiMzFiYiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmNwcApAQCAtNDUzLDYgKzQ1MywxNiBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVj dGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRlck9iamVjdCogcmVuZGVyZXIpCiAgICAgLy8gdG8gZmlu ZCB0aGUgY29udGFpbmVyIHdoaWNoIHNob3VsZCBzZW5kIG91dCB0aGUgbm90aWZpY2F0aW9uLgog ICAgIHBvc3ROb3RpZmljYXRpb24ocmVuZGVyZXIsIEFYU2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQs IGZhbHNlKTsKIH0KKwordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNh dGlvbihSZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5z aWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkKK3sKKyAgICBpZiAoIXJlbmRlcmVyKQorICAg ICAgICByZXR1cm47CisKKyAgICAvLyBEZWxlZ2F0ZSBvbiB0aGUgcmlnaHQgcGxhdGZvcm0KKyAg ICBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gb2JqZWN0ID0gZ2V0T3JDcmVhdGUocmVuZGVy ZXIpOworICAgIG5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24ob2JqZWN0LmdldCgp LCB0ZXh0Q2hhbmdlLCBvZmZzZXQsIGNvdW50KTsKK30KICNlbmRpZgogCiAjaWYgSEFWRShBQ0NF U1NJQklMSVRZKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2Fj aGUuaCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKaW5kZXggZjE4ZDA4 YS4uZjgxNDg4NiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2Fj aGUuaAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCkBAIC0xMjQs MTAgKzEyNCwxOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0Tm90aWZpY2F0aW9uKFJlbmRlck9i amVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlID0gUG9z dEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3RpZmljYXRpb24oQWNjZXNzaWJpbGl0 eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwg UG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisgICAgZW51bSBBWFRleHRDaGFuZ2Ug eworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAgQVhUZXh0RGVsZXRlZCwKKyAgICB9 OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBB WFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOworCiAgICAgYm9v bCBub2RlSGFzUm9sZShOb2RlKiwgY29uc3QgQXRvbWljU3RyaW5nJiByb2xlKTsKIAogcHJvdGVj dGVkOgogICAgIHZvaWQgcG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmpl Y3QqLCBBWE5vdGlmaWNhdGlvbik7CisgICAgdm9pZCBub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90 aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9m ZnNldCwgdW5zaWduZWQgY291bnQpOwogCiBwcml2YXRlOgogICAgIEhhc2hNYXA8QVhJRCwgUmVm UHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ID4gbV9vYmplY3RzOwpAQCAtMTU1LDYgKzE2Myw4IEBA IGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRl ck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlv bihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0 VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0Tm90aWZpY2F0aW9uKEFj Y2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RU b0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhOb3RpZmljYXRpb24p IHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRp b24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVk IGNvdW50KSB7IH0KK2lubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5z aWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENh Y2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJP YmplY3QqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZVNjcm9sbGVkVG9B bmNob3IoY29uc3QgTm9kZSopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6Y29udGVu dENoYW5nZWQoUmVuZGVyT2JqZWN0KikgeyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0 ay9BWE9iamVjdENhY2hlQXRrLmNwcAppbmRleCBjMzBiMDA2Li5mNTZkZTg3IDEwMDY0NAotLS0g YS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwCisrKyBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKQEAgLTIyLDYgKzIy LDggQEAKIAogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNsdWRlICJBY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IApAQCAtNTAsNiArNTIsNDcgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3Rp ZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAgICB9CiB9CiAK K3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihB Y2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNp Z25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVjaworICAg IGlmIChjb3VudCA8IDEgfHwgIW9iamVjdCB8fCAhb2JqZWN0LT5pc0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gR2V0IHRoZSBhc3NvY2lhdGVk IG5vZGUKKyAgICBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiByZW5kZXJPYmplY3QgPSBzdGF0 aWNfY2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsKKyAgICBSZW5kZXJP YmplY3QqIHJlbmRlcmVyID0gcmVuZGVyT2JqZWN0LT5yZW5kZXJlcigpOworICAgIGlmICghcmVu ZGVyZXIpCisgICAgICAgIHJldHVybjsKKyAgICBOb2RlKiBub2RlID0gcmVuZGVyZXItPm5vZGUo KTsKKworICAgIC8vIENhbGN1bGF0ZSBnbG9iYWwgb2Zmc2V0IChpbiB0aGUgd2hvbGUgdGV4dCwg bm90IGp1c3QgaW4gdGhlIGN1cnJlbnQgbm9kZSkKKyAgICB1bnNpZ25lZCBnbG9iYWxPZmZzZXQg PSBvZmZzZXQ7CisgICAgZm9yIChOb2RlICpuID0gbm9kZS0+cGFyZW50Tm9kZSgpLT5maXJzdENo aWxkKCk7IG4gJiYgKG4gIT0gbm9kZSk7IG4gPSBuLT5uZXh0U2libGluZygpKSB7CisgICAgICAg IGlmIChuLT5pc1RleHROb2RlKCkpCisgICAgICAgICAgICBnbG9iYWxPZmZzZXQgKz0gbi0+bm9k ZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgfQorCisgICAgLy8gR2V0IHRoZSBheE9iamVjdCBmb3Ig dGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3QqIHdyYXBwZXIgPSBvYmplY3QtPnBhcmVu dE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7CisgICAgaWYgKCF3cmFwcGVyIHx8ICFBVEtf SVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gRW1pdCB0aGUgcmln aHQgc2lnbmFsCisgICAgR093blB0cjxnY2hhcj4gZGV0YWlsOworICAgIHN3aXRjaCAodGV4dENo YW5nZSkgeworICAgIGNhc2UgQVhUZXh0SW5zZXJ0ZWQ6CisgICAgICAgIGRldGFpbC5zZXQoZ19z dHJkdXAoInRleHQtY2hhbmdlZDo6aW5zZXJ0IikpOworICAgICAgICBicmVhazsKKyAgICBjYXNl IEFYVGV4dERlbGV0ZWQ6CisgICAgICAgIGRldGFpbC5zZXQoZ19zdHJkdXAoInRleHQtY2hhbmdl ZDo6ZGVsZXRlIikpOworICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBnY2hhciogZGV0YWls U3RyID0gZGV0YWlsLmdldCgpOworICAgIGlmIChkZXRhaWxTdHIpCisgICAgICAgIGdfc2lnbmFs X2VtaXRfYnlfbmFtZSh3cmFwcGVyLCBkZXRhaWxTdHIsIGdsb2JhbE9mZnNldCwgY291bnQpOwor fQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJl bmRlck9iamVjdCogb2xkRm9jdXNlZFJlbmRlciwgUmVuZGVyT2JqZWN0KiBuZXdGb2N1c2VkUmVu ZGVyKQogewogICAgIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiBvbGRPYmplY3QgPSBnZXRP ckNyZWF0ZShvbGRGb2N1c2VkUmVuZGVyKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbSBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMv QVhPYmplY3RDYWNoZU1hYy5tbQppbmRleCBhMDJiYzc1Li4yMmExMmYwIDEwMDY0NAotLS0gYS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KKysrIGIvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCkBAIC0xMTQsNiArMTE0LDEw IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2li aWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAgICAgW29iai0+d3JhcHBlcigpIGFjY2Vzc2li aWxpdHlQb3N0ZWROb3RpZmljYXRpb246bWFjTm90aWZpY2F0aW9uXTsKIH0KIAordm9pZCBBWE9i amVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxp dHlPYmplY3QqIG9iamVjdCwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNl dCwgdW5zaWduZWQgY291bnQpCit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9j dXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikKIHsKICAg ICBbW1dlYkNvcmVWaWV3RmFjdG9yeSBzaGFyZWRGYWN0b3J5XSBhY2Nlc3NpYmlsaXR5SGFuZGxl Rm9jdXNDaGFuZ2VkXTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhP YmplY3RDYWNoZVdpbi5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2Fj aGVXaW4uY3BwCmluZGV4IDIxZTYxZDkuLjRmMDIyOTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcApAQCAtMTAzLDYgKzEwMywxMCBAQCB2b2lk IEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2Jq ZWN0KiBvYmosIEFYTm90aWZpYwogICAgIE5vdGlmeVdpbkV2ZW50KG1zYWFFdmVudCwgcGFnZS0+ Y2hyb21lKCktPnBsYXRmb3JtUGFnZUNsaWVudCgpLCBPQkpJRF9DTElFTlQsIC1zdGF0aWNfY2Fz dDxMT05HPihvYmotPmF4T2JqZWN0SUQoKSkpOwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2Jq ZWN0LCBBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBj b3VudCkKK3sKK30KKwogQVhJRCBBWE9iamVjdENhY2hlOjpwbGF0Zm9ybUdlbmVyYXRlQVhJRCgp IGNvbnN0CiB7CiAgICAgc3RhdGljIEFYSUQgbGFzdFVzZWRJRCA9IDA7Ci0tIAoxLjcuMC40Cgo= 61861 2010-07-16 16:49:32 -0700 2010-08-03 18:48:58 -0700 3. Notify accessibility when something changes in a text node 0003-2010-07-17-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 8663 mario RnJvbSA1YjAxMzY3Yjc2ZWRjNmE3YjZhZDQ5MDA5MzU3MGQ0ZWQ1YjFhNWVlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBTYXQsIDE3IEp1bCAyMDEwIDAxOjA3OjIwICswMjAwClN1YmplY3Q6IFtQQVRD SCAzLzNdIDIwMTAtMDctMTcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10g b2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMg YW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTm90aWZ5IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhp bmcgY2hhbmdlcyBpbiBhIHRleHQgbm9kZS4KCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4 dCB3YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVk aXRpb24KICAgICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdp bmFsIHRleHQgd2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1i ZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0Fw cGVuZE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6 OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5 KToKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CiAgICAg ICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAg IChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVm b3JlQ29tbWFuZDo6ZG9VbmFwcGx5KToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfCAgIDI3ICsrKysrKysrKysrKysrKysrKysrKysrKysKIFdlYkNv cmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICB8ICAgMTYgKysrKysrKysr KysrKysKIFdlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCB8ICAg IDggKysrKysrKwogV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3Bw IHwgICAgOCArKysrKysrCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQu Y3BwICAgfCAgIDEyICsrKysrKysrKysrCiA1IGZpbGVzIGNoYW5nZWQsIDcxIGluc2VydGlvbnMo KyksIDAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCA2MDcyZGMyLi5hNGVhNTZlIDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtNSw2ICs1LDMzIEBACiAgICAg ICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNoYW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZv ciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0ZXh0CiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5OAogCisgICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5 IHdoZW4gc29tZXRoaW5nIGNoYW5nZXMgaW4gYSB0ZXh0IG5vZGUuCisKKyAgICAgICAgQ2FsbCB0 byBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3 aGVuCisgICAgICAgIHRleHQgd2FzIGluc2VydGVkL2RlbGV0ZWQgd2hlbiBhcHBseWluZy91bmFw cGx5aW5nIGEgdGV4dCBlZGl0aW9uCisgICAgICAgIGNvbW1hbmQsIGFsb25nIHdpdGggdGhlIG9m ZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKKyAgICAgICAgY2hhbmdlIHRvb2sg cGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KKwor ICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6QXBwZW5k Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9EZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHROb2RlQ29t bWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6 ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpk b1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkpOgor ICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisK KzIwMTAtMDctMTcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEuY29tPgor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9i amVjdDp0ZXh0LWNoYW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFu ZCBwYXNzd29yZCB0ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yNTg5OAorCiAgICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRv IGNhbGwgd2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgogCiAgICAgICAgIEFkZGVkIG9uZSBu ZXcgZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLmNhMDA3YTggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2Vi Q29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkFwcGVuZE5vZGVDb21tYW5kLmgiCiAKKyNpbmNs dWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNw YWNlIFdlYkNvcmUgewpAQCAtNDksNiArNTAsMTMgQEAgdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6 ZG9BcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9wYXJlbnQt PmFwcGVuZENoaWxkKG1fbm9kZS5nZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6 OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpIHsKKyAgICAgICAgdW5zaWduZWQgbGVuID0gbV9ub2Rl LT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAgICAgLy8gRG9uJ3QgY29uc2lkZXIgbGluZWJy ZWFrcyBpbiB0aGlzIGNvbW1hbmQKKyAgICAgICAgaWYgKG1fbm9kZS0+bm9kZVZhbHVlKCkgIT0g IlxuIikKKyAgICAgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRD aGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRl eHRJbnNlcnRlZCwgMCwgbGVuKTsKKyAgICB9CiB9CiAKIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6 OmRvVW5hcHBseSgpCkBAIC01Niw2ICs2NCwxNCBAQCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpk b1VuYXBwbHkoKQogICAgIGlmICghbV9wYXJlbnQtPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAg ICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUg YWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNz aWJpbGl0eUVuYWJsZWQoKSkgeworICAgICAgICB1bnNpZ25lZCBsZW4gPSBtX25vZGUtPm5vZGVW YWx1ZSgpLmxlbmd0aCgpOworICAgICAgICAvLyBEb24ndCBjb25zaWRlciBsaW5lYnJlYWtzIGlu IHRoaXMgY29tbWFuZAorICAgICAgICBpZiAobV9ub2RlLT5ub2RlVmFsdWUoKSAhPSAiXG4iKQor ICAgICAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5v dGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0 ZWQsIDAsIGxlbik7CisgICAgfQorCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUt PnJlbW92ZShlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29t bWFuZC5jcHAKaW5kZXggZjFkNzlhZi4uZmU1NzJlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0 aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9E ZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUg ImNvbmZpZy5oIgogI2luY2x1ZGUgIkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCIKIAorI2lu Y2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKQEAgLTUzLDYgKzU0LDEwIEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFu ZDo6ZG9BcHBseSgpCiAgICAgaWYgKGVjKQogICAgICAgICByZXR1cm47CiAgICAgCisgICAgLy8g TmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAg ICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9j dW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25v ZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0LCBt X2NvdW50KTsKKwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV9jb3VudCwgZWMp OwogfQogCkBAIC02NSw2ICs3MCw5IEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUt Pmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2Fj aGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0 Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBB WE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fY291bnQpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 SW50b1RleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZC5jcHAKaW5kZXggOWMzNDIzYS4uOWI3NzYxYyAxMDA2NDQKLS0tIGEvV2ViQ29y ZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRp dGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2lu Y2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuaCIK IAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKQEAgLTQ4LDYgKzQ5LDkgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb0FwcGx5KCkKICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9k ZS0+aW5zZXJ0RGF0YShtX29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RD YWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmpl Y3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCks IEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgp KTsKIH0KIAogdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAt NTUsNiArNTksMTAgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHko KQogICAgIGlmICghbV9ub2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47 CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRl bGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFi bGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFu Z2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRE ZWxldGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUg ZWM7CiAgICAgbV9ub2RlLT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCksIGVj KTsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFu ZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCmluZGV4 IDJjZTk4NDYuLjZmMTZlMDggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2Rl QmVmb3JlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVD b21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIkluc2VydE5vZGVCZWZvcmVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hl LmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAt NTEsNiArNTIsMTEgQEAgdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9BcHBseSgpCiAK ICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIHBhcmVudC0+aW5zZXJ0QmVmb3JlKG1faW5zZXJ0 Q2hpbGQuZ2V0KCksIG1fcmVmQ2hpbGQuZ2V0KCksIGVjKTsKKworICAgIGlmIChBWE9iamVjdENh Y2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIHVuc2lnbmVkIGxlbiA9IG1f aW5zZXJ0Q2hpbGQtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpOworICAgICAgICBkb2N1bWVudCgpLT5h eE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5zZXJ0Q2hpbGQt PnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCAwLCBsZW4pOworICAg IH0KIH0KIAogdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU4 LDYgKzY0LDEyIEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAg ICAgaWYgKCFtX2luc2VydENoaWxkLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1 cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5 IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlF bmFibGVkKCkpIHsKKyAgICAgICAgdW5zaWduZWQgbGVuID0gbV9pbnNlcnRDaGlsZC0+bm9kZVZh bHVlKCkubGVuZ3RoKCk7CisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9k ZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIoKSwgQVhPYmpl Y3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgMCwgbGVuKTsKKyAgICB9CisKICAgICBFeGNlcHRpb25D b2RlIGVjOwogICAgIG1faW5zZXJ0Q2hpbGQtPnJlbW92ZShlYyk7CiB9Ci0tIAoxLjcuMC40Cgo= 61880 2010-07-17 02:30:55 -0700 2010-08-03 18:49:05 -0700 2. New functions in AXObjectCache to call when text changes in a node 0002-2010-07-17-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 11289 mario RnJvbSBiZDFlMTI4NzM1NDQ0NzBjNTQ2MTdlMzRhOTA3YmEzZTg5ZjQwZWEzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBTYXQsIDE3IEp1bCAyMDEwIDAwOjMzOjAyICswMjAwClN1YmplY3Q6IFtQQVRD SCAyLzNdIDIwMTAtMDctMTcgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10g b2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMg YW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTmV3IGZ1bmN0aW9uIGluIEFYT2JqZWN0Q2FjaGUgdG8g Y2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUuCgogICAgICAgIEFkZGVkIG9uZSBuZXcg ZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKICAgICAg ICB0ZXh0IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBz dWNoIGEKICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmlj IGltcGxlbWVudGF0aW9uLAogICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVu Y3Rpb24uCgogICAgICAgIEFsc28sIHByb3ZpZGVkIGEgR1RLIGltcGxlbWVudGF0aW9uIG9mIHRo ZSBwbGF0Zm9ybS1zcGVjaWZpYwogICAgICAgIGZ1bmN0aW9uIChhcyB0aGlzIGNoYW5nZSB3YXMg bW90aXZhdGVkIGJ5IHRoZSBHVEsgcG9ydCksIGFzIHdlbGwKICAgICAgICBhcyBkdW1teSBpbXBs ZW1lbnRhdGlvbnMgZm9yIHRoZSBvdGhlciBwb3J0cyB3aXRoIGFjY2Vzc2liaWxpdHkKICAgICAg ICBzdXBwb3J0LCB0aGF0IGlzLCBtYWMgYW5kIHdpbiBwb3J0cy4KCiAgICAgICAgKiBhY2Nlc3Np YmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4 dENoYW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9i amVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAg ICAgKiBhY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHA6CiAg ICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3Rp ZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVB dGsuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBs YXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L21hYy9BWE9i amVjdENhY2hlTWFjLm1tOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5 L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcDoKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNo ZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwotLS0KIFdlYkNvcmUv Q2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzNCArKysrKysr KysrKysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAg ICAgIHwgICAxMCArKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCAg ICAgICAgICAgICAgfCAgIDEwICsrKysrCiAuLi4vY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9t aXVtLmNwcCAgICAgICAgICAgICB8ICAgIDQgKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsv QVhPYmplY3RDYWNoZUF0ay5jcHAgICAgIHwgICA0MyArKysrKysrKysrKysrKysrKysrKwogV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tICAgICAgfCAgICA0ICsr CiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwICAgICB8ICAg IDQgKysKIDcgZmlsZXMgY2hhbmdlZCwgMTA5IGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRl eCAwMmRmODBhLi43NWQzNWQ1IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9X ZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEwLTA3LTE3ICBNYXJpbyBTYW5j aGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50 cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKworICAgICAg ICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxsIHdoZW4gdGV4dCBjaGFuZ2Vz IGluIGEgbm9kZS4KKworICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0aW9uIHRvIGFsbG93IG5v dGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCisgICAgICAgIHRleHQgbm9kZSB0aHJvdWdo IHRoZSBhc3NvY2lhdGVkIFJlbmRlck9iamVjdCwgbWFraW5nIHN1Y2ggYQorICAgICAgICBmdW5j dGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljIGltcGxlbWVudGF0aW9uLAor ICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9uLgorCisgICAgICAg IEFsc28sIHByb3ZpZGVkIGEgR1RLIGltcGxlbWVudGF0aW9uIG9mIHRoZSBwbGF0Zm9ybS1zcGVj aWZpYworICAgICAgICBmdW5jdGlvbiAoYXMgdGhpcyBjaGFuZ2Ugd2FzIG1vdGl2YXRlZCBieSB0 aGUgR1RLIHBvcnQpLCBhcyB3ZWxsCisgICAgICAgIGFzIGR1bW15IGltcGxlbWVudGF0aW9ucyBm b3IgdGhlIG90aGVyIHBvcnRzIHdpdGggYWNjZXNzaWJpbGl0eQorICAgICAgICBzdXBwb3J0LCB0 aGF0IGlzLCBtYWMgYW5kIHdpbiBwb3J0cy4KKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQVhP YmplY3RDYWNoZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQVhPYmpl Y3RDYWNoZS5oOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdl KTogTmV3IGVudW1lcmF0aW9uCisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2Rl VGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RD YWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAq IGFjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRr LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L21hYy9BWE9i amVjdENhY2hlTWFjLm1tOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RD YWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworCiAyMDEwLTA3 LTA4ICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmNwcAppbmRleCA3NTBjNjExLi5iYWIzMWJiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuY3BwCkBAIC00NTMsNiArNDUzLDE2IEBAIHZvaWQgQVhPYmplY3RDYWNo ZTo6c2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQoUmVuZGVyT2JqZWN0KiByZW5kZXJlcikKICAgICAv LyB0byBmaW5kIHRoZSBjb250YWluZXIgd2hpY2ggc2hvdWxkIHNlbmQgb3V0IHRoZSBub3RpZmlj YXRpb24uCiAgICAgcG9zdE5vdGlmaWNhdGlvbihyZW5kZXJlciwgQVhTZWxlY3RlZENoaWxkcmVu Q2hhbmdlZCwgZmFsc2UpOwogfQorCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdl Tm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCogcmVuZGVyZXIsIEFYVGV4dENoYW5nZSB0ZXh0Q2hh bmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIGlmICghcmVuZGVy ZXIpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIERlbGVnYXRlIG9uIHRoZSByaWdodCBwbGF0 Zm9ybQorICAgIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiBvYmplY3QgPSBnZXRPckNyZWF0 ZShyZW5kZXJlcik7CisgICAgbm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihvYmpl Y3QuZ2V0KCksIHRleHRDaGFuZ2UsIG9mZnNldCwgY291bnQpOworfQogI2VuZGlmCiAKICNpZiBI QVZFKEFDQ0VTU0lCSUxJVFkpCmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhP YmplY3RDYWNoZS5oIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAppbmRl eCBmMThkMDhhLi5lOThlNzM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhP YmplY3RDYWNoZS5oCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgK QEAgLTEyNCwxMCArMTI0LDE4IEBAIHB1YmxpYzoKICAgICB2b2lkIHBvc3ROb3RpZmljYXRpb24o UmVuZGVyT2JqZWN0KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5 cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogICAgIHZvaWQgcG9zdE5vdGlmaWNhdGlvbihBY2Nl c3NpYmlsaXR5T2JqZWN0KiwgRG9jdW1lbnQqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0VG9F bGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3luY2hyb25vdXNseSk7CiAKKyAgICBlbnVtIEFYVGV4 dENoYW5nZSB7CisgICAgICAgIEFYVGV4dEluc2VydGVkLAorICAgICAgICBBWFRleHREZWxldGVk LAorICAgIH07CisKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRlck9i amVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CisK ICAgICBib29sIG5vZGVIYXNSb2xlKE5vZGUqLCBjb25zdCBBdG9taWNTdHJpbmcmIHJvbGUpOwog CiBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJp bGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKTsKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5z aWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CiAKIHByaXZhdGU6CiAgICAgSGFzaE1hcDxB WElELCBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gPiBtX29iamVjdHM7CkBAIC0xNTUsNiAr MTYzLDggQEAgaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRDaGlsZHJlbkNoYW5n ZWQoUmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0Tm90 aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1l bnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3ROb3RpZmlj YXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJv b2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNo ZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWE5vdGlm aWNhdGlvbikgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5v dGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25l ZCkgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3Jt Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVk LCB1bnNpZ25lZCkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2Vk VUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3QqKSB7IH0KIGlubGlu ZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZVNjcm9sbGVkVG9BbmNob3IoY29uc3QgTm9kZSop IHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6Y29udGVudENoYW5nZWQoUmVuZGVyT2Jq ZWN0KikgeyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhP YmplY3RDYWNoZUNocm9taXVtLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9B WE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCmluZGV4IDQxMThjNjMuLjNjYTZjNmUgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0u Y3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hy b21pdW0uY3BwCkBAIC02Nyw2ICs2NywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0 Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAg ICAgICBjbGllbnQtPmRpZENoYW5nZUFjY2Vzc2liaWxpdHlPYmplY3RTdGF0ZShvYmopOwogfQog Cit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24o QWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQor eworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2Vk KFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcAppbmRleCBjMzBiMDA2Li5mNTZkZTg3IDEw MDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKQEAg LTIyLDYgKzIyLDggQEAKIAogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNs dWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtNTAsNiArNTIsNDcgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAg ICB9CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlm aWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hh bmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIFNhbml0eSBj aGVjaworICAgIGlmIChjb3VudCA8IDEgfHwgIW9iamVjdCB8fCAhb2JqZWN0LT5pc0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gR2V0IHRoZSBh c3NvY2lhdGVkIG5vZGUKKyAgICBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiByZW5kZXJPYmpl Y3QgPSBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsKKyAg ICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gcmVuZGVyT2JqZWN0LT5yZW5kZXJlcigpOworICAg IGlmICghcmVuZGVyZXIpCisgICAgICAgIHJldHVybjsKKyAgICBOb2RlKiBub2RlID0gcmVuZGVy ZXItPm5vZGUoKTsKKworICAgIC8vIENhbGN1bGF0ZSBnbG9iYWwgb2Zmc2V0IChpbiB0aGUgd2hv bGUgdGV4dCwgbm90IGp1c3QgaW4gdGhlIGN1cnJlbnQgbm9kZSkKKyAgICB1bnNpZ25lZCBnbG9i YWxPZmZzZXQgPSBvZmZzZXQ7CisgICAgZm9yIChOb2RlICpuID0gbm9kZS0+cGFyZW50Tm9kZSgp LT5maXJzdENoaWxkKCk7IG4gJiYgKG4gIT0gbm9kZSk7IG4gPSBuLT5uZXh0U2libGluZygpKSB7 CisgICAgICAgIGlmIChuLT5pc1RleHROb2RlKCkpCisgICAgICAgICAgICBnbG9iYWxPZmZzZXQg Kz0gbi0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgfQorCisgICAgLy8gR2V0IHRoZSBheE9i amVjdCBmb3IgdGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3QqIHdyYXBwZXIgPSBvYmpl Y3QtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7CisgICAgaWYgKCF3cmFwcGVy IHx8ICFBVEtfSVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gRW1p dCB0aGUgcmlnaHQgc2lnbmFsCisgICAgR093blB0cjxnY2hhcj4gZGV0YWlsOworICAgIHN3aXRj aCAodGV4dENoYW5nZSkgeworICAgIGNhc2UgQVhUZXh0SW5zZXJ0ZWQ6CisgICAgICAgIGRldGFp bC5zZXQoZ19zdHJkdXAoInRleHQtY2hhbmdlZDo6aW5zZXJ0IikpOworICAgICAgICBicmVhazsK KyAgICBjYXNlIEFYVGV4dERlbGV0ZWQ6CisgICAgICAgIGRldGFpbC5zZXQoZ19zdHJkdXAoInRl eHQtY2hhbmdlZDo6ZGVsZXRlIikpOworICAgICAgICBicmVhazsKKyAgICB9CisKKyAgICBnY2hh ciogZGV0YWlsU3RyID0gZGV0YWlsLmdldCgpOworICAgIGlmIChkZXRhaWxTdHIpCisgICAgICAg IGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCBkZXRhaWxTdHIsIGdsb2JhbE9mZnNldCwg Y291bnQpOworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRD aGFuZ2VkKFJlbmRlck9iamVjdCogb2xkRm9jdXNlZFJlbmRlciwgUmVuZGVyT2JqZWN0KiBuZXdG b2N1c2VkUmVuZGVyKQogewogICAgIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiBvbGRPYmpl Y3QgPSBnZXRPckNyZWF0ZShvbGRGb2N1c2VkUmVuZGVyKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbSBiL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQppbmRleCBhMDJiYzc1Li5lNjUxYTc1IDEwMDY0 NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KKysr IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCkBAIC0xMTQs NiArMTE0LDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9u KEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAgICAgW29iai0+d3JhcHBlcigp IGFjY2Vzc2liaWxpdHlQb3N0ZWROb3RpZmljYXRpb246bWFjTm90aWZpY2F0aW9uXTsKIH0KIAor dm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFj Y2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkKK3sK K30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChS ZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3QqKQogewogICAgIFtbV2ViQ29yZVZpZXdGYWN0b3J5 IHNoYXJlZEZhY3RvcnldIGFjY2Vzc2liaWxpdHlIYW5kbGVGb2N1c0NoYW5nZWRdOwpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKaW5kZXggMjFlNjFk OS4uYjIwYjUxYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVj dENhY2hlV2luLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2Fj aGVXaW4uY3BwCkBAIC0xMDMsNiArMTAzLDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBs YXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAg ICAgTm90aWZ5V2luRXZlbnQobXNhYUV2ZW50LCBwYWdlLT5jaHJvbWUoKS0+cGxhdGZvcm1QYWdl Q2xpZW50KCksIE9CSklEX0NMSUVOVCwgLXN0YXRpY19jYXN0PExPTkc+KG9iai0+YXhPYmplY3RJ RCgpKSk7CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5v dGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwg dW5zaWduZWQpCit7Cit9CisKIEFYSUQgQVhPYmplY3RDYWNoZTo6cGxhdGZvcm1HZW5lcmF0ZUFY SUQoKSBjb25zdAogewogICAgIHN0YXRpYyBBWElEIGxhc3RVc2VkSUQgPSAwOwotLSAKMS43LjAu NAoK 63314 2010-08-03 03:20:04 -0700 2010-08-06 04:24:55 -0700 Single patch for fixing this bug 0001-2010-08-03-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 21384 mario RnJvbSA2ZDVkOTk3ZjJmMDk3OTMyYzI4Yzc3ZDMwY2JjZGEyYjY5NjU2M2I2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUdWUsIDMgQXVnIDIwMTAgMTI6MTc6NDMgKzAyMDAKU3ViamVjdDogW1BBVENI XSAyMDEwLTA4LTAzIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+Cgog ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBvYmplY3Q6 dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFz c3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yNTg5OAoKICAgICAgICBJbXBsZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBl bWlzc2lvbiBmb3IgdGhlIEdUSyBwb3J0CgogICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2Rl KCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KICAgICAgICBEbyBpdCBl dmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBp bgogICAgICAgIG9yZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5v dGlmaWVkIGFib3V0IHRoZQogICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUgd2l0 aCB0aGF0IG5vZGUuCgogICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNw cDoKICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJh bERlbGV0ZSk6CgogICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRvIGNhbGwg d2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgogICAgICAgIEFkZGVkIG9uZSBuZXcgZnVuY3Rp b24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKICAgICAgICB0ZXh0 IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBzdWNoIGEK ICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljIGltcGxl bWVudGF0aW9uLAogICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rpb24g KHByb3ZpZGVkIGEgcHJvcGVyCiAgICAgICAgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBHVEsgcG9y dCBhbmQgYSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgoKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvQVhPYmplY3RDYWNoZS5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FY T2JqZWN0Q2FjaGUuaDoKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hh bmdlKTogTmV3IGVudW1lcmF0aW9uCiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAq IGFjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAg ICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNh dGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZv cm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0 Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hh bmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFjY2Vzc2liaWxpdHkvd2lu L0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CgogICAgICAgIE5vdGlmeSBh Y2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5nZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAg ICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRv IG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5 aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAgICAgICBjb21tYW5kLCBhbG9uZyB3aXRo IHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQgd2hlcmUgdGhlCiAgICAgICAgY2hhbmdl IHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZlY3Rl ZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2Vi Q29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpBcHBl bmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZC5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21t YW5kOjpkb1VuYXBwbHkpOgogICAgICAgICogZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21t YW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9B cHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5h cHBseSk6CiAgICAgICAgKiBlZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcDoKICAg ICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkpOgogICAgICAg IChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAo V2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSk6Ci0t LQogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAg IDU5ICsrKysrKysrKysrKysrKysrKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RD YWNoZS5jcHAgICAgICAgICAgICB8ICAgMTAgKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhP YmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTAgKysrCiAuLi4vY2hyb21pdW0vQVhPYmpl Y3RDYWNoZUNocm9taXVtLmNwcCAgICAgICAgICAgICB8ICAgIDQgKwogV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcCAgICAgfCAgIDQzICsrKysrKysrKysrKysr CiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gICAgICB8ICAg IDQgKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCAgICAg fCAgICA0ICsKIFdlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICAg ICAgIHwgICAxNiArKysrKwogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1h bmQuY3BwICAgICAgfCAgICA4ICsrKwogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNv bW1hbmQuY3BwICAgICAgICAgfCAgIDE1ICsrKy0tCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZC5jcHAgICAgICB8ICAgIDggKysrCiBXZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwICAgICAgICB8ICAgMTIgKysrKwogMTIgZmlsZXMgY2hh bmdlZCwgMTg4IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1MzZiNDIyLi43YTc1NmZj IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDYyIEBACisyMDEwLTA4LTAzIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6 QGlnYWxpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgW0d0a10gb2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQg Zm9yIGVudHJpZXMgYW5kIHBhc3N3b3JkIHRleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI1ODk4CisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciAn dGV4dC1jaGFuZ2VkJyBzaWduYWwgZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAorCisgICAgICAg IENhbGwgZGVsZXRlVGV4dEZyb21Ob2RlKCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4 dCBub2Rlcy4KKyAgICAgICAgRG8gaXQgZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0 byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywgaW4KKyAgICAgICAgb3JkZXIgdG8gYWxsb3cgYWNjZXNz aWJpbGl0eSB0byBnZXQgcHJvcGVybHkgbm90aWZpZWQgYWJvdXQgdGhlCisgICAgICAgIHRleHQg YmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUgd2l0aCB0aGF0IG5vZGUuCisKKyAgICAgICAgKiBlZGl0 aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRl U2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSk6CisKKyAgICAgICAgTmV3IGZ1 bmN0aW9uIGluIEFYT2JqZWN0Q2FjaGUgdG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5v ZGUuCisgICAgICAgIEFkZGVkIG9uZSBuZXcgZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNv bWV0aGluZyBjaGFuZ2VkIGluIGEKKyAgICAgICAgdGV4dCBub2RlIHRocm91Z2ggdGhlIGFzc29j aWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBhCisgICAgICAgIGZ1bmN0aW9uIGRlcGVu ZGFudCBvbiB0aGUgcGxhdGZvcm0tc3BlY2lmaWMgaW1wbGVtZW50YXRpb24sCisgICAgICAgIHBy b3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rpb24gKHByb3ZpZGVkIGEgcHJvcGVyCisg ICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBvcnQgYW5kIGEgZHVtbXkgb25lIGZv ciB0aGUgb3RoZXJzKS4KKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlm aWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oOgor ICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlKTogTmV3IGVudW1l cmF0aW9uCisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5v dGlmaWNhdGlvbik6IE5ldworICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcK KyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFj Lm1tOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0 Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2Jq ZWN0Q2FjaGVXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworCisgICAgICAgIE5vdGlmeSBhY2Nl c3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5nZXMgaW4gYSB0ZXh0IG5vZGUuCisgICAgICAg IENhbGwgdG8gQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oKSB0byBu b3RpZnkgd2hlbgorICAgICAgICB0ZXh0IHdhcyBpbnNlcnRlZC9kZWxldGVkIHdoZW4gYXBwbHlp bmcvdW5hcHBseWluZyBhIHRleHQgZWRpdGlvbgorICAgICAgICBjb21tYW5kLCBhbG9uZyB3aXRo IHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQgd2hlcmUgdGhlCisgICAgICAgIGNoYW5n ZSB0b29rIHBsYWNlIGFuZCB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMgdGhhdCBnb3QgYWZmZWN0 ZWQuCisKKyAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6 OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRJbnRvVGV4 dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNv bW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29t bWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0Fw cGx5KToKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb1VuYXBw bHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2Vu ZXJhbERlbGV0ZSk6CisKIDIwMTAtMDgtMDEgIE5pa29sYXMgWmltbWVybWFubiAgPG56aW1tZXJt YW5uQHJpbS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGlyayBTY2h1bHplLgpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwIGIvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4IDc1MGM2MTEuLmJhYjMxYmIgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAorKysgYi9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKQEAgLTQ1Myw2ICs0NTMsMTYg QEAgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChSZW5kZXJPYmpl Y3QqIHJlbmRlcmVyKQogICAgIC8vIHRvIGZpbmQgdGhlIGNvbnRhaW5lciB3aGljaCBzaG91bGQg c2VuZCBvdXQgdGhlIG5vdGlmaWNhdGlvbi4KICAgICBwb3N0Tm90aWZpY2F0aW9uKHJlbmRlcmVy LCBBWFNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkLCBmYWxzZSk7CiB9CisKK3ZvaWQgQVhPYmplY3RD YWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiByZW5kZXJlciwg QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQp Cit7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gRGVsZWdh dGUgb24gdGhlIHJpZ2h0IHBsYXRmb3JtCisgICAgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ IG9iamVjdCA9IGdldE9yQ3JlYXRlKHJlbmRlcmVyKTsKKyAgICBub2RlVGV4dENoYW5nZVBsYXRm b3JtTm90aWZpY2F0aW9uKG9iamVjdC5nZXQoKSwgdGV4dENoYW5nZSwgb2Zmc2V0LCBjb3VudCk7 Cit9CiAjZW5kaWYKIAogI2lmIEhBVkUoQUNDRVNTSUJJTElUWSkKZGlmZiAtLWdpdCBhL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmggYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5oCmluZGV4IGYxOGQwOGEuLmU5OGU3MzkgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuaApAQCAtMTI0LDEwICsxMjQsMTggQEAgcHVibGljOgogICAgIHZv aWQgcG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBw b3N0VG9FbGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3luY2hyb25vdXNseSk7CiAgICAgdm9pZCBw b3N0Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCosIEFYTm90aWZp Y2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5 KTsKIAorICAgIGVudW0gQVhUZXh0Q2hhbmdlIHsKKyAgICAgICAgQVhUZXh0SW5zZXJ0ZWQsCisg ICAgICAgIEFYVGV4dERlbGV0ZWQsCisgICAgfTsKKworICAgIHZvaWQgbm9kZVRleHRDaGFuZ2VO b3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQs IHVuc2lnbmVkIGNvdW50KTsKKwogICAgIGJvb2wgbm9kZUhhc1JvbGUoTm9kZSosIGNvbnN0IEF0 b21pY1N0cmluZyYgcm9sZSk7CiAKIHByb3RlY3RlZDoKICAgICB2b2lkIHBvc3RQbGF0Zm9ybU5v dGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhOb3RpZmljYXRpb24pOworICAgIHZv aWQgbm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0 KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KTsKIAogcHJp dmF0ZToKICAgICBIYXNoTWFwPEFYSUQsIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiA+IG1f b2JqZWN0czsKQEAgLTE1NSw2ICsxNjMsOCBAQCBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpz ZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChSZW5kZXJPYmplY3QqKSB7IH0KIGlubGluZSB2b2lkIEFY T2JqZWN0Q2FjaGU6OnBvc3ROb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhOb3RpZmljYXRp b24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQgQVhPYmpl Y3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgRG9jdW1lbnQq LCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxp bmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJp bGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKSB7IH0KK2lubGluZSB2b2lkIEFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYVGV4dENoYW5n ZSwgdW5zaWduZWQsIHVuc2lnbmVkKSB7IH0KK2lubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFY VGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0 Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRl ck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlU2Nyb2xsZWRU b0FuY2hvcihjb25zdCBOb2RlKikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpjb250 ZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqKSB7IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAKaW5kZXggNDExOGM2 My4uM2NhNmM2ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FY T2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9t aXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAKQEAgLTY3LDYgKzY3LDEwIEBAIHZvaWQgQVhP YmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3Qq IG9iaiwgQVhOb3RpZmljCiAgICAgICAgIGNsaWVudC0+ZGlkQ2hhbmdlQWNjZXNzaWJpbGl0eU9i amVjdFN0YXRlKG9iaik7CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1 bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9j dXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikKIHsKIH0K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5j cHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwCmluZGV4 IGMzMGIwMDYuLmY1NmRlODcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsv QVhPYmplY3RDYWNoZUF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9i amVjdENhY2hlQXRrLmNwcApAQCAtMjIsNiArMjIsOCBAQAogCiAjaW5jbHVkZSAiQWNjZXNzaWJp bGl0eU9iamVjdC5oIgogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmgi CisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIgorI2luY2x1ZGUgIkdPd25Q dHIuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01MCw2ICs1Miw0NyBAQCB2b2lkIEFY T2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0 KiBjb3JlT2JqZWN0LCBBWAogICAgIH0KIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iamVjdCwg QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQp Cit7CisgICAgLy8gU2FuaXR5IGNoZWNrCisgICAgaWYgKGNvdW50IDwgMSB8fCAhb2JqZWN0IHx8 ICFvYmplY3QtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKQorICAgICAgICByZXR1cm47 CisKKyAgICAvLyBHZXQgdGhlIGFzc29jaWF0ZWQgbm9kZQorICAgIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QqIHJlbmRlck9iamVjdCA9IHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QqPihvYmplY3QpOworICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSByZW5kZXJPYmpl Y3QtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOworICAg IE5vZGUqIG5vZGUgPSByZW5kZXJlci0+bm9kZSgpOworCisgICAgLy8gQ2FsY3VsYXRlIGdsb2Jh bCBvZmZzZXQgKGluIHRoZSB3aG9sZSB0ZXh0LCBub3QganVzdCBpbiB0aGUgY3VycmVudCBub2Rl KQorICAgIHVuc2lnbmVkIGdsb2JhbE9mZnNldCA9IG9mZnNldDsKKyAgICBmb3IgKE5vZGUgKm4g PSBub2RlLT5wYXJlbnROb2RlKCktPmZpcnN0Q2hpbGQoKTsgbiAmJiAobiAhPSBub2RlKTsgbiA9 IG4tPm5leHRTaWJsaW5nKCkpIHsKKyAgICAgICAgaWYgKG4tPmlzVGV4dE5vZGUoKSkKKyAgICAg ICAgICAgIGdsb2JhbE9mZnNldCArPSBuLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICB9CisK KyAgICAvLyBHZXQgdGhlIGF4T2JqZWN0IGZvciB0aGUgcGFyZW50IG9iamVjdAorICAgIEF0a09i amVjdCogd3JhcHBlciA9IG9iamVjdC0+cGFyZW50T2JqZWN0VW5pZ25vcmVkKCktPndyYXBwZXIo KTsKKyAgICBpZiAoIXdyYXBwZXIgfHwgIUFUS19JU19URVhUKHdyYXBwZXIpKQorICAgICAgICBy ZXR1cm47CisKKyAgICAvLyBFbWl0IHRoZSByaWdodCBzaWduYWwKKyAgICBHT3duUHRyPGdjaGFy PiBkZXRhaWw7CisgICAgc3dpdGNoICh0ZXh0Q2hhbmdlKSB7CisgICAgY2FzZSBBWFRleHRJbnNl cnRlZDoKKyAgICAgICAgZGV0YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2VkOjppbnNlcnQi KSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgQVhUZXh0RGVsZXRlZDoKKyAgICAgICAgZGV0 YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2VkOjpkZWxldGUiKSk7CisgICAgICAgIGJyZWFr OworICAgIH0KKworICAgIGdjaGFyKiBkZXRhaWxTdHIgPSBkZXRhaWwuZ2V0KCk7CisgICAgaWYg KGRldGFpbFN0cikKKyAgICAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdyYXBwZXIsIGRldGFp bFN0ciwgZ2xvYmFsT2Zmc2V0LCBjb3VudCk7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFu ZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiBvbGRGb2N1c2VkUmVuZGVy LCBSZW5kZXJPYmplY3QqIG5ld0ZvY3VzZWRSZW5kZXIpCiB7CiAgICAgUmVmUHRyPEFjY2Vzc2li aWxpdHlPYmplY3Q+IG9sZE9iamVjdCA9IGdldE9yQ3JlYXRlKG9sZEZvY3VzZWRSZW5kZXIpOwpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1t IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCmluZGV4IGEw MmJjNzUuLmU2NTFhNzUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhP YmplY3RDYWNoZU1hYy5tbQorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0 Q2FjaGVNYWMubW0KQEAgLTExNCw2ICsxMTQsMTAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0 UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqLCBBWE5vdGlmaWMK ICAgICBbb2JqLT53cmFwcGVyKCkgYWNjZXNzaWJpbGl0eVBvc3RlZE5vdGlmaWNhdGlvbjptYWNO b3RpZmljYXRpb25dOwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5z aWduZWQsIHVuc2lnbmVkKQoreworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3Vz ZWRVSUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiAgICAg W1tXZWJDb3JlVmlld0ZhY3Rvcnkgc2hhcmVkRmFjdG9yeV0gYWNjZXNzaWJpbGl0eUhhbmRsZUZv Y3VzQ2hhbmdlZF07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2Jq ZWN0Q2FjaGVXaW4uY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hl V2luLmNwcAppbmRleCAyMWU2MWQ5Li5iMjBiNTFhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKQEAgLTEwMyw2ICsxMDMsMTAgQEAgdm9pZCBB WE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVj dCogb2JqLCBBWE5vdGlmaWMKICAgICBOb3RpZnlXaW5FdmVudChtc2FhRXZlbnQsIHBhZ2UtPmNo cm9tZSgpLT5wbGF0Zm9ybVBhZ2VDbGllbnQoKSwgT0JKSURfQ0xJRU5ULCAtc3RhdGljX2Nhc3Q8 TE9ORz4ob2JqLT5heE9iamVjdElEKCkpKTsKIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2Rl VGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRl eHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkKK3sKK30KKwogQVhJRCBBWE9iamVjdENhY2hl OjpwbGF0Zm9ybUdlbmVyYXRlQVhJRCgpIGNvbnN0CiB7CiAgICAgc3RhdGljIEFYSUQgbGFzdFVz ZWRJRCA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQu Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcAppbmRleCA2MTc4NjQx Li5jYTAwN2E4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQu Y3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYg KzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJBcHBlbmROb2RlQ29tbWFu ZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5n LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQ5LDYgKzUwLDEzIEBAIHZvaWQgQXBwZW5k Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwog ICAgIG1fcGFyZW50LT5hcHBlbmRDaGlsZChtX25vZGUuZ2V0KCksIGVjKTsKKworICAgIGlmIChB WE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIHVuc2lnbmVk IGxlbiA9IG1fbm9kZS0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAgICAgIC8vIERvbid0IGNv bnNpZGVyIGxpbmVicmVha3MgaW4gdGhpcyBjb21tYW5kCisgICAgICAgIGlmIChtX25vZGUtPm5v ZGVWYWx1ZSgpICE9ICJcbiIpCisgICAgICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hl KCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmpl Y3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAsIGxlbik7CisgICAgfQogfQogCiB2b2lkIEFwcGVu ZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTYsNiArNjQsMTQgQEAgdm9pZCBBcHBlbmRO b2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0 YWJsZSgpKQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5 IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0 Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpIHsKKyAgICAgICAgdW5zaWduZWQgbGVuID0g bV9ub2RlLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAgICAgLy8gRG9uJ3QgY29uc2lkZXIg bGluZWJyZWFrcyBpbiB0aGlzIGNvbW1hbmQKKyAgICAgICAgaWYgKG1fbm9kZS0+bm9kZVZhbHVl KCkgIT0gIlxuIikKKyAgICAgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9k ZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hl OjpBWFRleHREZWxldGVkLCAwLCBsZW4pOworICAgIH0KKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7 CiAgICAgbV9ub2RlLT5yZW1vdmUoZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5n L0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQuY3BwCmluZGV4IGYxZDc5YWYuLmZlNTcyZTEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJD b3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcg QEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJEZWxldGVGcm9tVGV4dE5vZGVDb21t YW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC01Myw2ICs1NCwxMCBAQCB2b2lkIERlbGV0ZUZyb21U ZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgIGlmIChlYykKICAgICAgICAgcmV0dXJuOwog ICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5n IHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkp CisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3Rp ZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVk LCBtX29mZnNldCwgbV9jb3VudCk7CisKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9vZmZzZXQs IG1fY291bnQsIGVjKTsKIH0KIApAQCAtNjUsNiArNzAsOSBAQCB2b2lkIERlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7 CiAgICAgbV9ub2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKworICAgIGlm IChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVu dCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+ cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIG1fb2Zmc2V0LCBtX2Nv dW50KTsKIH0KIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9l ZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCmluZGV4IGMzN2IwZmMuLmNjNjlmMzEgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9XZWJDb3Jl L2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKQEAgLTQ0MywxMSArNDQzLDcgQEAg dm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAg ICAgcmV0dXJuOwogCiAgICAgaWYgKHN0YXJ0Tm9kZSA9PSBtX2Rvd25zdHJlYW1FbmQubm9kZSgp KSB7Ci0gICAgICAgIC8vIFRoZSBzZWxlY3Rpb24gdG8gZGVsZXRlIGlzIGFsbCBpbiBvbmUgbm9k ZS4KLSAgICAgICAgaWYgKCFzdGFydE5vZGUtPnJlbmRlcmVyKCkgfHwgKHN0YXJ0T2Zmc2V0ID09 IDAgJiYgbV9kb3duc3RyZWFtRW5kLmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUoKSkpIHsK LSAgICAgICAgICAgIC8vIGp1c3QgZGVsZXRlCi0gICAgICAgICAgICByZW1vdmVOb2RlKHN0YXJ0 Tm9kZSk7Ci0gICAgICAgIH0gZWxzZSBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0 aW5nT2Zmc2V0KCkgLSBzdGFydE9mZnNldCA+IDApIHsKKyAgICAgICAgaWYgKG1fZG93bnN0cmVh bUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpIC0gc3RhcnRPZmZzZXQgPiAwKSB7CiAgICAg ICAgICAgICBpZiAoc3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKICAgICAgICAgICAgICAgICAv LyBpbiBhIHRleHQgbm9kZSB0aGF0IG5lZWRzIHRvIGJlIHRyaW1tZWQKICAgICAgICAgICAgICAg ICBUZXh0KiB0ZXh0ID0gc3RhdGljX2Nhc3Q8VGV4dCo+KHN0YXJ0Tm9kZSk7CkBAIC00NTcsNiAr NDUzLDEyIEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0 ZSgpCiAgICAgICAgICAgICAgICAgbV9lbmRpbmdQb3NpdGlvbiA9IG1fdXBzdHJlYW1TdGFydDsK ICAgICAgICAgICAgIH0KICAgICAgICAgfQorCisgICAgICAgIC8vIFRoZSBzZWxlY3Rpb24gdG8g ZGVsZXRlIGlzIGFsbCBpbiBvbmUgbm9kZS4KKyAgICAgICAgaWYgKCFzdGFydE5vZGUtPnJlbmRl cmVyKCkgfHwgKCFzdGFydE9mZnNldCAmJiBtX2Rvd25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bv c2l0aW9uRm9yTm9kZSgpKSkgeworICAgICAgICAgICAgLy8ganVzdCBkZWxldGUKKyAgICAgICAg ICAgIHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKKyAgICAgICAgfQogICAgIH0KICAgICBlbHNlIHsK ICAgICAgICAgYm9vbCBzdGFydE5vZGVXYXNEZXNjZW5kYW50T2ZFbmROb2RlID0gbV91cHN0cmVh bVN0YXJ0Lm5vZGUoKS0+aXNEZXNjZW5kYW50T2YobV9kb3duc3RyZWFtRW5kLm5vZGUoKSk7CkBA IC00NzIsNiArNDc0LDkgQEAgdm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5l cmFsRGVsZXRlKCkKICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgbm9kZSA9 IHN0YXJ0Tm9kZS0+Y2hpbGROb2RlKHN0YXJ0T2Zmc2V0KTsKICAgICAgICAgICAgIH0KKyAgICAg ICAgfSBlbHNlIGlmIChzdGFydE5vZGUgPT0gbV91cHN0cmVhbUVuZC5ub2RlKCkgJiYgc3RhcnRO b2RlLT5pc1RleHROb2RlKCkpIHsKKyAgICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0aWNfY2Fz dDxUZXh0Kj4obV91cHN0cmVhbUVuZC5ub2RlKCkpOworICAgICAgICAgICAgZGVsZXRlVGV4dEZy b21Ob2RlKHRleHQsIDAsIG1fdXBzdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSk7 CiAgICAgICAgIH0KICAgICAgICAgCiAgICAgICAgIC8vIGhhbmRsZSBkZWxldGluZyBhbGwgbm9k ZXMgdGhhdCBhcmUgY29tcGxldGVseSBzZWxlY3RlZApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0 aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCmluZGV4IDljMzQyM2EuLjliNzc2MWMgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9X ZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2 LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00OCw2ICs0OSw5IEBAIHZvaWQgSW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsK ICAgICBtX25vZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYg KEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50 KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5y ZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fdGV4 dC5sZW5ndGgoKSk7CiB9CiAKIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFw cGx5KCkKQEAgLTU1LDYgKzU5LDEwIEBAIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fbm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAg ICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBh Y3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3Np YmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNo ZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1fdGV4dC5sZW5ndGgoKSk7CisKICAgICBFeGNl cHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV90ZXh0Lmxl bmd0aCgpLCBlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJl Zm9yZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5k LmNwcAppbmRleCAyY2U5ODQ2Li42ZjE2ZTA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcv SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRO b2RlQmVmb3JlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcu aCIKICNpbmNsdWRlICJJbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhP YmplY3RDYWNoZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKQEAgLTUxLDYgKzUyLDExIEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRv QXBwbHkoKQogCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBwYXJlbnQtPmluc2VydEJlZm9y ZShtX2luc2VydENoaWxkLmdldCgpLCBtX3JlZkNoaWxkLmdldCgpLCBlYyk7CisKKyAgICBpZiAo QVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkgeworICAgICAgICB1bnNpZ25l ZCBsZW4gPSBtX2luc2VydENoaWxkLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAgICAgZG9j dW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX2lu c2VydENoaWxkLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgMCwg bGVuKTsKKyAgICB9CiB9CiAKIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBs eSgpCkBAIC01OCw2ICs2NCwxMiBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb1Vu YXBwbHkoKQogICAgIGlmICghbV9pbnNlcnRDaGlsZC0+aXNDb250ZW50RWRpdGFibGUoKSkKICAg ICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9y ZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nl c3NpYmlsaXR5RW5hYmxlZCgpKSB7CisgICAgICAgIHVuc2lnbmVkIGxlbiA9IG1faW5zZXJ0Q2hp bGQtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpOworICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENh Y2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5zZXJ0Q2hpbGQtPnJlbmRlcmVy KCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIDAsIGxlbik7CisgICAgfQorCiAgICAg RXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX2luc2VydENoaWxkLT5yZW1vdmUoZWMpOwogfQotLSAK MS43LjAuNAoK 63712 2010-08-06 04:24:55 -0700 2010-09-02 07:18:43 -0700 Single patch for fixing this bug 0001-2010-08-06-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23671 mario RnJvbSAwOGEyMjUwY2NjYmUyYjBkYzY5OTkzNjQzMjA4MjQxMzg5MWY4MTY3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUdWUsIDMgQXVnIDIwMTAgMTI6MTc6NDMgKzAyMDAKU3ViamVjdDogW1BBVENI XSAyMDEwLTA4LTA2IE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+Cgog ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBvYmplY3Q6 dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFz c3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yNTg5OAoKICAgICAgICBJbXBsZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBl bWlzc2lvbiBmb3IgdGhlIEdUSyBwb3J0CgogICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2Rl KCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KICAgICAgICBEbyBpdCBl dmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBp bgogICAgICAgIG9yZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5v dGlmaWVkIGFib3V0IHRoZQogICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUgd2l0 aCB0aGF0IG5vZGUuCgogICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNw cDoKICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJh bERlbGV0ZSk6CgogICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRvIGNhbGwg d2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgogICAgICAgIEFkZGVkIG9uZSBuZXcgZnVuY3Rp b24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKICAgICAgICB0ZXh0 IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBzdWNoIGEK ICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljIGltcGxl bWVudGF0aW9uLAogICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rpb24g KHByb3ZpZGVkIGEgcHJvcGVyCiAgICAgICAgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBHVEsgcG9y dCBhbmQgYSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgoKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvQVhPYmplY3RDYWNoZS5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FY T2JqZWN0Q2FjaGUuaDoKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hh bmdlKTogTmV3IGVudW1lcmF0aW9uCiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAq IGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oOgogICAgICAgIChXZWJD b3JlOjp0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QpOgogICAgICAgICogYWNjZXNzaWJpbGl0 eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwOgogICAgICAgIChXZWJDb3JlOjpB WE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcDoKICAgICAgICAo V2ViQ29yZTo6Y2FsY3VsYXRlR2xvYmFsT2Zmc2V0KToKICAgICAgICAoV2ViQ29yZTo6ZW1pdFRl eHRDaGFuZ2VkKToKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFu Z2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMv QVhPYmplY3RDYWNoZU1hYy5tbToKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJp bGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKCiAgICAgICAg Tm90aWZ5IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdlcyBpbiBhIHRleHQgbm9k ZS4KICAgICAgICBDYWxsIHRvIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0 aW9uKCkgdG8gbm90aWZ5IHdoZW4KICAgICAgICB0ZXh0IHdhcyBpbnNlcnRlZC9kZWxldGVkIHdo ZW4gYXBwbHlpbmcvdW5hcHBseWluZyBhIHRleHQgZWRpdGlvbgogICAgICAgIGNvbW1hbmQsIGFs b25nIHdpdGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKICAgICAg ICBjaGFuZ2UgdG9vayBwbGFjZSBhbmQgdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzIHRoYXQgZ290 IGFmZmVjdGVkLgoKICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgogICAg ICAgIChXZWJDb3JlOjpzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyk6CiAgICAg ICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29y ZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHRO b2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZC5jcHA6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1h bmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgICogZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5KToK ICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAg ICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxl dGUpOgotLS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICA2NCArKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY T2JqZWN0Q2FjaGUuY3BwICAgICAgICAgICAgfCAgIDExICsrKysKIFdlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWE9iamVjdENhY2hlLmggICAgICAgICAgICAgIHwgICAxMiArKysrLQogV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCAgfCAgIDE3ICsrKysrLQog Li4uL2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAgICAgICAgICAgICAgfCAgICA0 ICsKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAgICAgIHwg ICA0NyArKysrKysrKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENh Y2hlTWFjLm1tICAgICAgfCAgICA0ICsKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmpl Y3RDYWNoZVdpbi5jcHAgICAgIHwgICAgNCArCiBXZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNv bW1hbmQuY3BwICAgICAgICAgICAgICB8ICAgMTcgKysrKysKIFdlYkNvcmUvZWRpdGluZy9EZWxl dGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCAgICAgIHwgICAgOCArKysKIFdlYkNvcmUvZWRpdGlu Zy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcCAgICAgICAgIHwgICAxMyArKystLQogV2ViQ29y ZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwICAgICAgfCAgICA4ICsrKwog V2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcCAgICAgICAgfCAgIDEy ICsrKysKIDEzIGZpbGVzIGNoYW5nZWQsIDIxNCBpbnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5k ZXggM2I2YWNiYS4uMmIwZWFlNiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv V2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2NyBAQAorMjAxMC0wOC0wNiBNYXJpbyBTYW5j aGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNoYW5nZWQgZXZlbnRz IHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0ZXh0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5OAorCisgICAgICAg IEltcGxlbWVudCBwcm9wZXIgJ3RleHQtY2hhbmdlZCcgc2lnbmFsIGVtaXNzaW9uIGZvciB0aGUg R1RLIHBvcnQKKworICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9kZSgpIHdoZW4gbmVlZGVk IHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCisgICAgICAgIERvIGl0IGV2ZW4gd2hlbiByZW1v dmVOb2RlKCkgaXMgZ29pbmcgdG8gYmUgY2FsbGVkIGFmdGVyd2FyZHMsIGluCisgICAgICAgIG9y ZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5vdGlmaWVkIGFib3V0 IHRoZQorICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdpdGggdGhhdCBub2Rl LgorCisgICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUp OgorCisgICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRvIGNhbGwgd2hlbiB0 ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgorICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0aW9uIHRv IGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCisgICAgICAgIHRleHQgbm9k ZSB0aHJvdWdoIHRoZSBhc3NvY2lhdGVkIFJlbmRlck9iamVjdCwgbWFraW5nIHN1Y2ggYQorICAg ICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljIGltcGxlbWVu dGF0aW9uLAorICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9uIChw cm92aWRlZCBhIHByb3BlcgorICAgICAgICBpbXBsZW1lbnRhdGlvbiBmb3IgdGhlIEdUSyBwb3J0 IGFuZCBhIGR1bW15IG9uZSBmb3IgdGhlIG90aGVycykuCisKKyAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6 bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuaDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4 dENoYW5nZSk6IE5ldyBlbnVtZXJhdGlvbgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNo ZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKKyAgICAg ICAgKFdlYkNvcmU6OnRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCk6CisgICAgICAgICogYWNj ZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwOgorICAgICAgICAo V2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlv bik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6Y2FsY3VsYXRlR2xvYmFsT2Zmc2V0KToKKyAgICAgICAgKFdl YkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNj ZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbToKKyAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRp b24pOiBOZXcKKworICAgICAgICBOb3RpZnkgYWNjZXNzaWJpbGl0eSB3aGVuIHNvbWV0aGluZyBj aGFuZ2VzIGluIGEgdGV4dCBub2RlLgorICAgICAgICBDYWxsIHRvIEFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKCkgdG8gbm90aWZ5IHdoZW4KKyAgICAgICAgdGV4dCB3 YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRp b24KKyAgICAgICAgY29tbWFuZCwgYWxvbmcgd2l0aCB0aGUgb2Zmc2V0IGluIHRoZSBvcmlnaW5h bCB0ZXh0IHdoZXJlIHRoZQorICAgICAgICBjaGFuZ2UgdG9vayBwbGFjZSBhbmQgdGhlIG51bWJl ciBvZiBjaGFyYWN0ZXJzIHRoYXQgZ290IGFmZmVjdGVkLgorCisgICAgICAgICogZWRpdGluZy9B cHBlbmROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpzZW5kQVhUZXh0Q2hhbmdl ZElnbm9yaW5nTGluZUJyZWFrcyk6CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFu ZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFw cGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6Cisg ICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgor ICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAg KFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAg ICogZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJ bnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRl bGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUpOgorCiAyMDEwLTA4LTA1 ICBBbmRyZWkgUG9wZXNjdSAgPGFuZHJlaXBAZGhjcC0xNzItMTYtMTQtMTIubG9uLmNvcnAuZ29v Z2xlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBKZXJlbXkgT3Jsb3cuCmRpZmYgLS1naXQg YS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAgYi9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKaW5kZXggNzUwYzYxMS4uZTc0OGM1OSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCisrKyBiL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDUzLDYgKzQ1MywxNyBAQCB2 b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRlck9iamVjdCog cmVuZGVyZXIpCiAgICAgLy8gdG8gZmluZCB0aGUgY29udGFpbmVyIHdoaWNoIHNob3VsZCBzZW5k IG91dCB0aGUgbm90aWZpY2F0aW9uLgogICAgIHBvc3ROb3RpZmljYXRpb24ocmVuZGVyZXIsIEFY U2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQsIGZhbHNlKTsKIH0KKwordm9pZCBBWE9iamVjdENhY2hl Ojpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBBWFRl eHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkKK3sK KyAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBEZWxlZ2F0ZSBv biB0aGUgcmlnaHQgcGxhdGZvcm0KKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmogPSBnZXRP ckNyZWF0ZShyZW5kZXJlcik7CisgICAgaWYgKG9iai0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0KCkpCisgICAgICAgIG5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24odG9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0KG9iaiksIHRleHRDaGFuZ2UsIG9mZnNldCwgY291bnQpOwor fQogI2VuZGlmCiAKICNpZiBIQVZFKEFDQ0VTU0lCSUxJVFkpCmRpZmYgLS1naXQgYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FY T2JqZWN0Q2FjaGUuaAppbmRleCBmNGY3YjNkLi4zOWI0NjQzIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmgKQEAgLTI2LDcgKzI2LDcgQEAKICNpZm5kZWYgQVhPYmplY3RDYWNo ZV9oCiAjZGVmaW5lIEFYT2JqZWN0Q2FjaGVfaAogCi0jaW5jbHVkZSAiQWNjZXNzaWJpbGl0eU9i amVjdC5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCIKICNpbmNsdWRl ICJUaW1lci5oIgogI2luY2x1ZGUgPGxpbWl0cy5oPgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+ CkBAIC0xMjQsMTAgKzEyNCwxOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0Tm90aWZpY2F0aW9u KFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RU eXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3RpZmljYXRpb24oQWNj ZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRv RWxlbWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisgICAgZW51bSBBWFRl eHRDaGFuZ2UgeworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAgQVhUZXh0RGVsZXRl ZCwKKyAgICB9OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJP YmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOwor CiAgICAgYm9vbCBub2RlSGFzUm9sZShOb2RlKiwgY29uc3QgQXRvbWljU3RyaW5nJiByb2xlKTsK IAogcHJvdGVjdGVkOgogICAgIHZvaWQgcG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2li aWxpdHlPYmplY3QqLCBBWE5vdGlmaWNhdGlvbik7CisgICAgdm9pZCBub2RlVGV4dENoYW5nZVBs YXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFu Z2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOwogCiBwcml2YXRlOgogICAgIEhh c2hNYXA8QVhJRCwgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ID4gbV9vYmplY3RzOwpAQCAt MTU1LDYgKzE2Myw4IEBAIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRy ZW5DaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6 cG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0 VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0 Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCosIEFYTm90aWZpY2F0 aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0Kiwg QVhOb3RpZmljYXRpb24pIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRD aGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwg dW5zaWduZWQpIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hh bmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6 aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0 KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVTY3JvbGxlZFRvQW5jaG9y KGNvbnN0IE5vZGUqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmNvbnRlbnRDaGFu Z2VkKFJlbmRlck9iamVjdCopIHsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKaW5kZXggNTI2NjRhNS4uZjg2MjkyOSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAorKysg Yi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCkBAIC0z MTAsNyArMzEwLDIyIEBAIHByaXZhdGU6CiAgICAgCiAgICAgbXV0YWJsZSBBY2Nlc3NpYmlsaXR5 Um9sZSBtX3JvbGVGb3JNU0FBOwogfTsKLSAgICAKKworaW5saW5lIEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QqIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChBY2Nlc3NpYmlsaXR5T2JqZWN0 KiBvYmplY3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwgb2JqZWN0LT5pc0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QoKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QqPihvYmplY3QpOworfQorCitpbmxpbmUgY29uc3QgQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxp dHlPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3QtPmlzQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8Y29uc3Qg QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKKy8vIFRoaXMgd2lsbCBj YXRjaCBhbnlvbmUgZG9pbmcgYW4gdW5uZWNlc3NhcnkgY2FzdC4KK3ZvaWQgdG9BY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqKTsKKwogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RD YWNoZUNocm9taXVtLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVj dENhY2hlQ2hyb21pdW0uY3BwCmluZGV4IDQxMThjNjMuLjU3NmU1MjYgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCisr KyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0u Y3BwCkBAIC02Nyw2ICs2NywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5v dGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgICAgICBj bGllbnQtPmRpZENoYW5nZUFjY2Vzc2liaWxpdHlPYmplY3RTdGF0ZShvYmopOwogfQogCit2b2lk IEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQor eworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2Vk KFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcAppbmRleCBjMzBiMDA2Li5iZmY1ODNhIDEw MDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKQEAg LTIyLDYgKzIyLDggQEAKIAogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNs dWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtNTAsNiArNTIsNTEgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAg ICB9CiB9CiAKKy8vIENhbGN1bGF0ZSBnbG9iYWwgb2Zmc2V0IChpbiB0aGUgd2hvbGUgdGV4dCwg bm90IGp1c3QgaW4gdGhlIGN1cnJlbnQgbm9kZSkKK3N0YXRpYyB1bnNpZ25lZCBjYWxjdWxhdGVH bG9iYWxPZmZzZXQoQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCogb2JqZWN0LCB1bnNpZ25lZCBv ZmZzZXQpCit7CisgICAgTm9kZSogbm9kZSA9IG9iamVjdC0+bm9kZSgpOworICAgIHVuc2lnbmVk IGdsb2JhbE9mZnNldCA9IG9mZnNldDsKKyAgICBmb3IgKE5vZGUqIG4gPSBub2RlLT5wYXJlbnRO b2RlKCktPmZpcnN0Q2hpbGQoKTsgbiAmJiAobiAhPSBub2RlKTsgbiA9IG4tPm5leHRTaWJsaW5n KCkpIHsKKyAgICAgICAgaWYgKG4tPmlzVGV4dE5vZGUoKSkKKyAgICAgICAgICAgIGdsb2JhbE9m ZnNldCArPSBuLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICB9CisgICAgcmV0dXJuIGdsb2Jh bE9mZnNldDsKK30KKworc3RhdGljIHZvaWQgZW1pdFRleHRDaGFuZ2VkKEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QqIG9iamVjdCwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRDaGFu Z2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAgLy8gR2V0IHRoZSBh eE9iamVjdCBmb3IgdGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3QqIHdyYXBwZXIgPSBv YmplY3QtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7CisgICAgaWYgKCF3cmFw cGVyIHx8ICFBVEtfSVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8g U2VsZWN0IHRoZSByaWdodCBzaWduYWwgdG8gYmUgZW1pdHRlZAorICAgIEdPd25QdHI8Z2NoYXI+ IGRldGFpbDsKKyAgICBzd2l0Y2ggKHRleHRDaGFuZ2UpIHsKKyAgICBjYXNlIEFYT2JqZWN0Q2Fj aGU6OkFYVGV4dEluc2VydGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVwKCJ0ZXh0LWNo YW5nZWQ6Omluc2VydCIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBBWE9iamVjdENhY2hl OjpBWFRleHREZWxldGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVwKCJ0ZXh0LWNoYW5n ZWQ6OmRlbGV0ZSIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorCisgICAgZ2NoYXIqIGRldGFp bFN0ciA9IGRldGFpbC5nZXQoKTsKKyAgICBpZiAoZGV0YWlsU3RyKQorICAgICAgICBnX3NpZ25h bF9lbWl0X2J5X25hbWUod3JhcHBlciwgZGV0YWlsU3RyLCBvZmZzZXQsIGNvdW50KTsKK30KKwor dm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIG9iamVjdCwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2Us IHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAgLy8gU2FuaXR5IGNoZWNr CisgICAgaWYgKCFvYmplY3QgfHwgY291bnQgPCAxKQorICAgICAgICByZXR1cm47CisKKyAgICB1 bnNpZ25lZCBnbG9iYWxPZmZzZXQgPSBjYWxjdWxhdGVHbG9iYWxPZmZzZXQob2JqZWN0LCBvZmZz ZXQpOworICAgIGVtaXRUZXh0Q2hhbmdlZChvYmplY3QsIHRleHRDaGFuZ2UsIGdsb2JhbE9mZnNl dCwgY291bnQpOworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1l bnRDaGFuZ2VkKFJlbmRlck9iamVjdCogb2xkRm9jdXNlZFJlbmRlciwgUmVuZGVyT2JqZWN0KiBu ZXdGb2N1c2VkUmVuZGVyKQogewogICAgIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiBvbGRP YmplY3QgPSBnZXRPckNyZWF0ZShvbGRGb2N1c2VkUmVuZGVyKTsKZGlmZiAtLWdpdCBhL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbSBiL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQppbmRleCBhMDJiYzc1Li4zYzYwNDM4IDEw MDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0K KysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCkBAIC0x MTQsNiArMTE0LDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0 aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAgICAgW29iai0+d3JhcHBl cigpIGFjY2Vzc2liaWxpdHlQb3N0ZWROb3RpZmljYXRpb246bWFjTm90aWZpY2F0aW9uXTsKIH0K IAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNp Z25lZCkKK3sKK30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50 Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3QqKQogewogICAgIFtbV2ViQ29yZVZp ZXdGYWN0b3J5IHNoYXJlZEZhY3RvcnldIGFjY2Vzc2liaWxpdHlIYW5kbGVGb2N1c0NoYW5nZWRd OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2lu LmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKaW5k ZXggMjFlNjFkOS4uYTljN2IyNyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dp bi9BWE9iamVjdENhY2hlV2luLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FY T2JqZWN0Q2FjaGVXaW4uY3BwCkBAIC0xMDMsNiArMTAzLDEwIEBAIHZvaWQgQVhPYmplY3RDYWNo ZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhO b3RpZmljCiAgICAgTm90aWZ5V2luRXZlbnQobXNhYUV2ZW50LCBwYWdlLT5jaHJvbWUoKS0+cGxh dGZvcm1QYWdlQ2xpZW50KCksIE9CSklEX0NMSUVOVCwgLXN0YXRpY19jYXN0PExPTkc+KG9iai0+ YXhPYmplY3RJRCgpKSk7CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hh bmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIEFYSUQgQVhPYmplY3RDYWNoZTo6cGxh dGZvcm1HZW5lcmF0ZUFYSUQoKSBjb25zdAogewogICAgIHN0YXRpYyBBWElEIGxhc3RVc2VkSUQg PSAwOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcCBi L1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKaW5kZXggNjE3ODY0MS4uMDJj NDQzYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcAor KysgYi9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3 IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiQXBwZW5kTm9kZUNvbW1hbmQuaCIK IAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00Miw2ICs0MywxNSBAQCBBcHBlbmROb2RlQ29tbWFu ZDo6QXBwZW5kTm9kZUNvbW1hbmQoUGFzc1JlZlB0cjxFbGVtZW50PiBwYXJlbnQsIFBhc3NSZWZQ dHI8Tm9kZQogICAgIEFTU0VSVChtX3BhcmVudC0+aXNDb250ZW50RWRpdGFibGUoKSB8fCAhbV9w YXJlbnQtPmF0dGFjaGVkKCkpOwogfQogCitzdGF0aWMgdm9pZCBzZW5kQVhUZXh0Q2hhbmdlZEln bm9yaW5nTGluZUJyZWFrcyhOb2RlKiBub2RlLCBBWE9iamVjdENhY2hlOjpBWFRleHRDaGFuZ2Ug dGV4dENoYW5nZSkKK3sKKyAgICBTdHJpbmcgbm9kZVZhbHVlID0gbm9kZS0+bm9kZVZhbHVlKCk7 CisgICAgdW5zaWduZWQgbGVuID0gbm9kZVZhbHVlLmxlbmd0aCgpOworICAgIC8vIERvbid0IGNv bnNpZGVyIGxpbmVicmVha3MgaW4gdGhpcyBjb21tYW5kCisgICAgaWYgKG5vZGVWYWx1ZSAhPSAi XG4iKQorICAgICAgICBub2RlLT5kb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0 Q2hhbmdlTm90aWZpY2F0aW9uKG5vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4 dEluc2VydGVkLCAwLCBsZW4pOworfQorCiB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5 KCkKIHsKICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJsZSgpICYmIG1fcGFyZW50 LT5hdHRhY2hlZCgpKQpAQCAtNDksNiArNTksOSBAQCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpk b0FwcGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX3BhcmVudC0+ YXBwZW5kQ2hpbGQobV9ub2RlLmdldCgpLCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6 YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmlu Z0xpbmVCcmVha3MobV9ub2RlLmdldCgpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCk7 CiB9CiAKIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC01Niw2ICs2OSwx MCBAQCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9wYXJl bnQtPmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAg Ly8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQK KyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAg c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MobV9ub2RlLmdldCgpLCBBWE9iamVj dENhY2hlOjpBWFRleHREZWxldGVkKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9u b2RlLT5yZW1vdmUoZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9k ZUNvbW1hbmQuY3BwCmluZGV4IGYxZDc5YWYuLmZlNTcyZTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRp bmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNs dWRlICJjb25maWcuaCIKICNpbmNsdWRlICJEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmgiCiAK KyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CkBAIC01Myw2ICs1NCwxMCBAQCB2b2lkIERlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQ6OmRvQXBwbHkoKQogICAgIGlmIChlYykKICAgICAgICAgcmV0dXJuOwogICAgIAorICAg IC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0 CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAg IGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24o bV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkLCBtX29mZnNl dCwgbV9jb3VudCk7CisKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9vZmZzZXQsIG1fY291bnQs IGVjKTsKIH0KIApAQCAtNjUsNiArNzAsOSBAQCB2b2lkIERlbGV0ZUZyb21UZXh0Tm9kZUNvbW1h bmQ6OmRvVW5hcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9u b2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKworICAgIGlmIChBWE9iamVj dENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9i amVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIo KSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIG1fb2Zmc2V0LCBtX2NvdW50KTsKIH0K IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0Rl bGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlv bkNvbW1hbmQuY3BwCmluZGV4IGMzN2IwZmMuLmQzNDRkMDQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcv RGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKQEAgLTQ0MywxMSArNDQzLDcgQEAgdm9pZCBEZWxl dGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgcmV0dXJu OwogCiAgICAgaWYgKHN0YXJ0Tm9kZSA9PSBtX2Rvd25zdHJlYW1FbmQubm9kZSgpKSB7Ci0gICAg ICAgIC8vIFRoZSBzZWxlY3Rpb24gdG8gZGVsZXRlIGlzIGFsbCBpbiBvbmUgbm9kZS4KLSAgICAg ICAgaWYgKCFzdGFydE5vZGUtPnJlbmRlcmVyKCkgfHwgKHN0YXJ0T2Zmc2V0ID09IDAgJiYgbV9k b3duc3RyZWFtRW5kLmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUoKSkpIHsKLSAgICAgICAg ICAgIC8vIGp1c3QgZGVsZXRlCi0gICAgICAgICAgICByZW1vdmVOb2RlKHN0YXJ0Tm9kZSk7Ci0g ICAgICAgIH0gZWxzZSBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0 KCkgLSBzdGFydE9mZnNldCA+IDApIHsKKyAgICAgICAgaWYgKG1fZG93bnN0cmVhbUVuZC5kZXBy ZWNhdGVkRWRpdGluZ09mZnNldCgpIC0gc3RhcnRPZmZzZXQgPiAwKSB7CiAgICAgICAgICAgICBp ZiAoc3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKICAgICAgICAgICAgICAgICAvLyBpbiBhIHRl eHQgbm9kZSB0aGF0IG5lZWRzIHRvIGJlIHRyaW1tZWQKICAgICAgICAgICAgICAgICBUZXh0KiB0 ZXh0ID0gc3RhdGljX2Nhc3Q8VGV4dCo+KHN0YXJ0Tm9kZSk7CkBAIC00NTcsNiArNDUzLDEwIEBA IHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSgpCiAgICAg ICAgICAgICAgICAgbV9lbmRpbmdQb3NpdGlvbiA9IG1fdXBzdHJlYW1TdGFydDsKICAgICAgICAg ICAgIH0KICAgICAgICAgfQorCisgICAgICAgIC8vIFRoZSBzZWxlY3Rpb24gdG8gZGVsZXRlIGlz IGFsbCBpbiBvbmUgbm9kZS4KKyAgICAgICAgaWYgKCFzdGFydE5vZGUtPnJlbmRlcmVyKCkgfHwg KCFzdGFydE9mZnNldCAmJiBtX2Rvd25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bvc2l0aW9uRm9y Tm9kZSgpKSkKKyAgICAgICAgICAgIHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKICAgICB9CiAgICAg ZWxzZSB7CiAgICAgICAgIGJvb2wgc3RhcnROb2RlV2FzRGVzY2VuZGFudE9mRW5kTm9kZSA9IG1f dXBzdHJlYW1TdGFydC5ub2RlKCktPmlzRGVzY2VuZGFudE9mKG1fZG93bnN0cmVhbUVuZC5ub2Rl KCkpOwpAQCAtNDcyLDYgKzQ3Miw5IEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFu ZGxlR2VuZXJhbERlbGV0ZSgpCiAgICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAg IG5vZGUgPSBzdGFydE5vZGUtPmNoaWxkTm9kZShzdGFydE9mZnNldCk7CiAgICAgICAgICAgICB9 CisgICAgICAgIH0gZWxzZSBpZiAoc3RhcnROb2RlID09IG1fdXBzdHJlYW1FbmQubm9kZSgpICYm IHN0YXJ0Tm9kZS0+aXNUZXh0Tm9kZSgpKSB7CisgICAgICAgICAgICBUZXh0KiB0ZXh0ID0gc3Rh dGljX2Nhc3Q8VGV4dCo+KG1fdXBzdHJlYW1FbmQubm9kZSgpKTsKKyAgICAgICAgICAgIGRlbGV0 ZVRleHRGcm9tTm9kZSh0ZXh0LCAwLCBtX3Vwc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5nT2Zm c2V0KCkpOwogICAgICAgICB9CiAgICAgICAgIAogICAgICAgICAvLyBoYW5kbGUgZGVsZXRpbmcg YWxsIG5vZGVzIHRoYXQgYXJlIGNvbXBsZXRlbHkgc2VsZWN0ZWQKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGlu Zy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAppbmRleCA5YzM0MjNhLi45Yjc3NjFjIDEw MDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAK KysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC0y Niw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0SW50b1Rl eHROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUg IlRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNDgsNiArNDksOSBAQCB2b2lkIElu c2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgIAogICAgIEV4Y2VwdGlvbkNv ZGUgZWM7CiAgICAgbV9ub2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKwor ICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBk b2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1f bm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIG1fb2Zmc2V0 LCBtX3RleHQubGVuZ3RoKCkpOwogfQogCiB2b2lkIEluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6 OmRvVW5hcHBseSgpCkBAIC01NSw2ICs1OSwxMCBAQCB2b2lkIEluc2VydEludG9UZXh0Tm9kZUNv bW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX25vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkp CiAgICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhpcyBi ZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6 YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNo ZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2Jq ZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCkpOworCiAg ICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9vZmZzZXQsIG1f dGV4dC5sZW5ndGgoKSwgZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dE5vZGVCZWZvcmVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3Jl Q29tbWFuZC5jcHAKaW5kZXggMmNlOTg0Ni4uNmYxNmUwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcv SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAi Y29uZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuaCIKIAorI2luY2x1 ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CkBAIC01MSw2ICs1MiwxMSBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21t YW5kOjpkb0FwcGx5KCkKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgcGFyZW50LT5pbnNl cnRCZWZvcmUobV9pbnNlcnRDaGlsZC5nZXQoKSwgbV9yZWZDaGlsZC5nZXQoKSwgZWMpOworCisg ICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpIHsKKyAgICAgICAg dW5zaWduZWQgbGVuID0gbV9pbnNlcnRDaGlsZC0+bm9kZVZhbHVlKCkubGVuZ3RoKCk7CisgICAg ICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRp b24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0 ZWQsIDAsIGxlbik7CisgICAgfQogfQogCiB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpk b1VuYXBwbHkoKQpAQCAtNTgsNiArNjQsMTIgQEAgdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFu ZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1faW5zZXJ0Q2hpbGQtPmlzQ29udGVudEVkaXRhYmxl KCkpCiAgICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhp cyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNo ZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkgeworICAgICAgICB1bnNpZ25lZCBsZW4gPSBtX2lu c2VydENoaWxkLT5ub2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhP YmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX2luc2VydENoaWxkLT5y ZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkLCAwLCBsZW4pOworICAgIH0K KwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9pbnNlcnRDaGlsZC0+cmVtb3ZlKGVjKTsK IH0KLS0gCjEuNy4wLjQKCg== 66367 2010-09-02 07:18:43 -0700 2010-09-13 13:16:21 -0700 Single patch for fixing this bug 0001-2010-09-02-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23640 mario RnJvbSAxNjY0NTJmNWZmMjQzNDY4NjQwODFjMzNjMmY4ODdiMjVmNjFlYzQwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBUaHUsIDIgU2VwIDIwMTAgMTM6MTI6NTMgKzAyMDAKU3ViamVjdDogW1BBVENI XSAyMDEwLTA5LTAyIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+Cgog ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgoKICAgICAgICBbR3RrXSBvYmplY3Q6 dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFz c3dvcmQgdGV4dAogICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yNTg5OAoKICAgICAgICBJbXBsZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBl bWlzc2lvbiBmb3IgdGhlIEdUSyBwb3J0CgogICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2Rl KCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KICAgICAgICBEbyBpdCBl dmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBp bgogICAgICAgIG9yZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5v dGlmaWVkIGFib3V0IHRoZQogICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUgd2l0 aCB0aGF0IG5vZGUuCgogICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNw cDoKICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJh bERlbGV0ZSk6CgogICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRvIGNhbGwg d2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgogICAgICAgIEFkZGVkIG9uZSBuZXcgZnVuY3Rp b24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKICAgICAgICB0ZXh0 IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBzdWNoIGEK ICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNpZmljIGltcGxl bWVudGF0aW9uLAogICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0ZWQgZnVuY3Rpb24g KHByb3ZpZGVkIGEgcHJvcGVyCiAgICAgICAgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBHVEsgcG9y dCBhbmQgYSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgoKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvQVhPYmplY3RDYWNoZS5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FY T2JqZWN0Q2FjaGUuaDoKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hh bmdlKTogTmV3IGVudW1lcmF0aW9uCiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAq IGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oOgogICAgICAgIChXZWJD b3JlOjp0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QpOgogICAgICAgICogYWNjZXNzaWJpbGl0 eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwOgogICAgICAgIChXZWJDb3JlOjpB WE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcDoKICAgICAgICAo V2ViQ29yZTo6Y2FsY3VsYXRlR2xvYmFsT2Zmc2V0KToKICAgICAgICAoV2ViQ29yZTo6ZW1pdFRl eHRDaGFuZ2VkKToKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFu Z2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMv QVhPYmplY3RDYWNoZU1hYy5tbToKICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJp bGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHA6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKCiAgICAgICAg Tm90aWZ5IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdlcyBpbiBhIHRleHQgbm9k ZS4KICAgICAgICBDYWxsIHRvIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0 aW9uKCkgdG8gbm90aWZ5IHdoZW4KICAgICAgICB0ZXh0IHdhcyBpbnNlcnRlZC9kZWxldGVkIHdo ZW4gYXBwbHlpbmcvdW5hcHBseWluZyBhIHRleHQgZWRpdGlvbgogICAgICAgIGNvbW1hbmQsIGFs b25nIHdpdGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKICAgICAg ICBjaGFuZ2UgdG9vayBwbGFjZSBhbmQgdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzIHRoYXQgZ290 IGFmZmVjdGVkLgoKICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgogICAg ICAgIChXZWJDb3JlOjpzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyk6CiAgICAg ICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29y ZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHRO b2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZC5jcHA6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNvbW1h bmQ6OmRvQXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgICogZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5KToK ICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAg ICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxl dGUpOgoKQ29uZmxpY3RzOgoKCVdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgK LS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgNjQgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMSArKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTQgKysrKy0KIFdlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggIHwgICAxNyArKysrKy0KIC4uLi9j aHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwICAgICAgICAgICAgIHwgICAgNCArCiBX ZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwICAgICB8ICAgNDcg KysrKysrKysrKysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1h Yy5tbSAgICAgIHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2Fj aGVXaW4uY3BwICAgICB8ICAgIDQgKwogV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5k LmNwcCAgICAgICAgICAgICAgfCAgIDE3ICsrKysrCiBXZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJv bVRleHROb2RlQ29tbWFuZC5jcHAgICAgICB8ICAgIDggKysrCiBXZWJDb3JlL2VkaXRpbmcvRGVs ZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgICAgICAgICB8ICAgMTMgKysrLS0KIFdlYkNvcmUvZWRp dGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcCAgICAgIHwgICAgOCArKysKIFdlYkNv cmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAgICAgICAgIHwgICAxMiArKysr CiAxMyBmaWxlcyBjaGFuZ2VkLCAyMTYgaW5zZXJ0aW9ucygrKSwgNyBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDlj MGJiNjEuLjczMDRhMDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNv cmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjcgQEAKKzIwMTAtMDktMDIgTWFyaW8gU2FuY2hleiBQ cmFkYSA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91 bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKworICAgICAgICBJbXBs ZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBlbWlzc2lvbiBmb3IgdGhlIEdUSyBw b3J0CisKKyAgICAgICAgQ2FsbCBkZWxldGVUZXh0RnJvbU5vZGUoKSB3aGVuIG5lZWRlZCB3aGls ZSByZW1vdmluZyB0ZXh0IG5vZGVzLgorICAgICAgICBEbyBpdCBldmVuIHdoZW4gcmVtb3ZlTm9k ZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBpbgorICAgICAgICBvcmRlciB0 byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBub3RpZmllZCBhYm91dCB0aGUK KyAgICAgICAgdGV4dCBiZWluZyByZW1vdmVkIGFsb25nc2lkZSB3aXRoIHRoYXQgbm9kZS4KKwor ICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKToKKwor ICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxsIHdoZW4gdGV4dCBj aGFuZ2VzIGluIGEgbm9kZS4KKyAgICAgICAgQWRkZWQgb25lIG5ldyBmdW5jdGlvbiB0byBhbGxv dyBub3RpZnlpbmcgc29tZXRoaW5nIGNoYW5nZWQgaW4gYQorICAgICAgICB0ZXh0IG5vZGUgdGhy b3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2luZyBzdWNoIGEKKyAgICAgICAg ZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBsZW1lbnRhdGlv biwKKyAgICAgICAgcHJvdmlkZWQgdGhyb3VnaCBhIHByb3RlY3RlZCBmdW5jdGlvbiAocHJvdmlk ZWQgYSBwcm9wZXIKKyAgICAgICAgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBHVEsgcG9ydCBhbmQg YSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgorCisgICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVU ZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9BWE9i amVjdENhY2hlLmg6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpBWFRleHRDaGFu Z2UpOiBOZXcgZW51bWVyYXRpb24KKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAg ICogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmg6CisgICAgICAgIChX ZWJDb3JlOjp0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QpOgorICAgICAgICAqIGFjY2Vzc2li aWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBO ZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OmNhbGN1bGF0ZUdsb2JhbE9mZnNldCk6CisgICAgICAgIChXZWJDb3Jl OjplbWl0VGV4dENoYW5nZWQpOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2li aWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAg ICogYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHA6CisgICAgICAgIChXZWJD b3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTog TmV3CisKKyAgICAgICAgTm90aWZ5IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdl cyBpbiBhIHRleHQgbm9kZS4KKyAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCisgICAgICAgIHRleHQgd2FzIGlu c2VydGVkL2RlbGV0ZWQgd2hlbiBhcHBseWluZy91bmFwcGx5aW5nIGEgdGV4dCBlZGl0aW9uCisg ICAgICAgIGNvbW1hbmQsIGFsb25nIHdpdGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4 dCB3aGVyZSB0aGUKKyAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2Yg Y2hhcmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KKworICAgICAgICAqIGVkaXRpbmcvQXBwZW5k Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25v cmluZ0xpbmVCcmVha3MpOgorICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRv QXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6 CisgICAgICAgICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAg ICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAg ICAgKiBlZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJD b3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVk aXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5z ZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0 Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVT ZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKToKKwogMjAxMC0wOC0zMSAgS2Vu dCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRh bSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hl LmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAppbmRleCA5MDdi YjE1Li4zOGFiZjRjIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RD YWNoZS5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCkBA IC00NjUsNiArNDY1LDE3IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRDaGlsZHJlbkNo YW5nZWQoUmVuZGVyT2JqZWN0KiByZW5kZXJlcikKICAgICAvLyB0byBmaW5kIHRoZSBjb250YWlu ZXIgd2hpY2ggc2hvdWxkIHNlbmQgb3V0IHRoZSBub3RpZmljYXRpb24uCiAgICAgcG9zdE5vdGlm aWNhdGlvbihyZW5kZXJlciwgQVhTZWxlY3RlZENoaWxkcmVuQ2hhbmdlZCwgZmFsc2UpOwogfQor Cit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRlck9i amVjdCogcmVuZGVyZXIsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQs IHVuc2lnbmVkIGNvdW50KQoreworICAgIGlmICghcmVuZGVyZXIpCisgICAgICAgIHJldHVybjsK KworICAgIC8vIERlbGVnYXRlIG9uIHRoZSByaWdodCBwbGF0Zm9ybQorICAgIEFjY2Vzc2liaWxp dHlPYmplY3QqIG9iaiA9IGdldE9yQ3JlYXRlKHJlbmRlcmVyKTsKKyAgICBpZiAob2JqLT5pc0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgbm9kZVRleHRDaGFuZ2VQbGF0Zm9y bU5vdGlmaWNhdGlvbih0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qob2JqKSwgdGV4dENoYW5n ZSwgb2Zmc2V0LCBjb3VudCk7Cit9CiAjZW5kaWYKIAogI2lmIEhBVkUoQUNDRVNTSUJJTElUWSkK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmggYi9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCmluZGV4IDI4YTU5MTcuLjQ2YWZiZjEg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKysrIGIv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaApAQCAtMjYsNyArMjYsNyBAQAog I2lmbmRlZiBBWE9iamVjdENhY2hlX2gKICNkZWZpbmUgQVhPYmplY3RDYWNoZV9oCiAKLSNpbmNs dWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0LmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oIgogI2luY2x1ZGUgIlRpbWVyLmgiCiAjaW5jbHVkZSA8bGltaXRzLmg+CiAjaW5j bHVkZSA8d3RmL0ZvcndhcmQuaD4KQEAgLTEyNSw4ICsxMjUsMTggQEAgcHVibGljOgogICAgIHZv aWQgcG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBw b3N0VG9FbGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3luY2hyb25vdXNseSk7CiAgICAgdm9pZCBw b3N0Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCosIEFYTm90aWZp Y2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5 KTsKIAorICAgIGVudW0gQVhUZXh0Q2hhbmdlIHsKKyAgICAgICAgQVhUZXh0SW5zZXJ0ZWQsCisg ICAgICAgIEFYVGV4dERlbGV0ZWQsCisgICAgfTsKKworICAgIHZvaWQgbm9kZVRleHRDaGFuZ2VO b3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQs IHVuc2lnbmVkIGNvdW50KTsKKworICAgIGJvb2wgbm9kZUhhc1JvbGUoTm9kZSosIGNvbnN0IEF0 b21pY1N0cmluZyYgcm9sZSk7CisKIHByb3RlY3RlZDoKICAgICB2b2lkIHBvc3RQbGF0Zm9ybU5v dGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhOb3RpZmljYXRpb24pOworICAgIHZv aWQgbm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KTsK IAogcHJpdmF0ZToKICAgICBIYXNoTWFwPEFYSUQsIFJlZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0 PiA+IG1fb2JqZWN0czsKQEAgLTE1Niw2ICsxNjYsOCBAQCBpbmxpbmUgdm9pZCBBWE9iamVjdENh Y2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChSZW5kZXJPYmplY3QqKSB7IH0KIGlubGluZSB2 b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3ROb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhOb3Rp ZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQg QVhPYmplY3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgRG9j dW1lbnQqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9 CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNj ZXNzaWJpbGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKSB7IH0KK2lubGluZSB2b2lkIEFYT2Jq ZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYVGV4 dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKSB7IH0KK2lubGluZSB2b2lkIEFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKSB7IH0KIGlubGluZSB2 b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9i amVjdCosIFJlbmRlck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFu ZGxlU2Nyb2xsZWRUb0FuY2hvcihjb25zdCBOb2RlKikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVj dENhY2hlOjpjb250ZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqKSB7IH0KZGlmZiAtLWdpdCBhL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggYi9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCmluZGV4IGNlZmFhOTQu LmI3Yjg1ZmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmgKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QuaApAQCAtMzExLDcgKzMxMSwyMiBAQCBwcml2YXRlOgogICAgIAogICAgIG11 dGFibGUgQWNjZXNzaWJpbGl0eVJvbGUgbV9yb2xlRm9yTVNBQTsKIH07Ci0gICAgCisKK2lubGlu ZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiB0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qo QWNjZXNzaWJpbGl0eU9iamVjdCogb2JqZWN0KQoreworICAgIEFTU0VSVCghb2JqZWN0IHx8IG9i amVjdC0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkpOworICAgIHJldHVybiBzdGF0aWNf Y2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsKK30KKworaW5saW5lIGNv bnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QpCit7CisgICAgQVNTRVJUKCFvYmpl Y3QgfHwgb2JqZWN0LT5pc0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSk7CisgICAgcmV0dXJu IHN0YXRpY19jYXN0PGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqPihvYmplY3QpOwor fQorCisvLyBUaGlzIHdpbGwgY2F0Y2ggYW55b25lIGRvaW5nIGFuIHVubmVjZXNzYXJ5IGNhc3Qu Cit2b2lkIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChjb25zdCBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0Kik7CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3RfaApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcAppbmRleCBkOTA2YTkxLi4wZjMz NjliIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RD YWNoZUNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhP YmplY3RDYWNoZUNocm9taXVtLmNwcApAQCAtODYsNiArODYsMTAgQEAgdm9pZCBBWE9iamVjdENh Y2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqLCBB WE5vdGlmaWMKICAgICB9CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hh bmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFu ZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikK IHsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNo ZUF0ay5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CmluZGV4IGMzMGIwMDYuLmJmZjU4M2EgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0 ay9BWE9iamVjdENhY2hlQXRrLmNwcApAQCAtMjIsNiArMjIsOCBAQAogCiAjaW5jbHVkZSAiQWNj ZXNzaWJpbGl0eU9iamVjdC5oIgogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy QXRrLmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIgorI2luY2x1ZGUg IkdPd25QdHIuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01MCw2ICs1Miw1MSBAQCB2 b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5 T2JqZWN0KiBjb3JlT2JqZWN0LCBBWAogICAgIH0KIH0KIAorLy8gQ2FsY3VsYXRlIGdsb2JhbCBv ZmZzZXQgKGluIHRoZSB3aG9sZSB0ZXh0LCBub3QganVzdCBpbiB0aGUgY3VycmVudCBub2RlKQor c3RhdGljIHVuc2lnbmVkIGNhbGN1bGF0ZUdsb2JhbE9mZnNldChBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0KiBvYmplY3QsIHVuc2lnbmVkIG9mZnNldCkKK3sKKyAgICBOb2RlKiBub2RlID0gb2Jq ZWN0LT5ub2RlKCk7CisgICAgdW5zaWduZWQgZ2xvYmFsT2Zmc2V0ID0gb2Zmc2V0OworICAgIGZv ciAoTm9kZSogbiA9IG5vZGUtPnBhcmVudE5vZGUoKS0+Zmlyc3RDaGlsZCgpOyBuICYmIChuICE9 IG5vZGUpOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkgeworICAgICAgICBpZiAobi0+aXNUZXh0Tm9k ZSgpKQorICAgICAgICAgICAgZ2xvYmFsT2Zmc2V0ICs9IG4tPm5vZGVWYWx1ZSgpLmxlbmd0aCgp OworICAgIH0KKyAgICByZXR1cm4gZ2xvYmFsT2Zmc2V0OworfQorCitzdGF0aWMgdm9pZCBlbWl0 VGV4dENoYW5nZWQoQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCogb2JqZWN0LCBBWE9iamVjdENh Y2hlOjpBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBj b3VudCkKK3sKKyAgICAvLyBHZXQgdGhlIGF4T2JqZWN0IGZvciB0aGUgcGFyZW50IG9iamVjdAor ICAgIEF0a09iamVjdCogd3JhcHBlciA9IG9iamVjdC0+cGFyZW50T2JqZWN0VW5pZ25vcmVkKCkt PndyYXBwZXIoKTsKKyAgICBpZiAoIXdyYXBwZXIgfHwgIUFUS19JU19URVhUKHdyYXBwZXIpKQor ICAgICAgICByZXR1cm47CisKKyAgICAvLyBTZWxlY3QgdGhlIHJpZ2h0IHNpZ25hbCB0byBiZSBl bWl0dGVkCisgICAgR093blB0cjxnY2hhcj4gZGV0YWlsOworICAgIHN3aXRjaCAodGV4dENoYW5n ZSkgeworICAgIGNhc2UgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQ6CisgICAgICAgIGRl dGFpbC5zZXQoZ19zdHJkdXAoInRleHQtY2hhbmdlZDo6aW5zZXJ0IikpOworICAgICAgICBicmVh azsKKyAgICBjYXNlIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQ6CisgICAgICAgIGRldGFp bC5zZXQoZ19zdHJkdXAoInRleHQtY2hhbmdlZDo6ZGVsZXRlIikpOworICAgICAgICBicmVhazsK KyAgICB9CisKKyAgICBnY2hhciogZGV0YWlsU3RyID0gZGV0YWlsLmdldCgpOworICAgIGlmIChk ZXRhaWxTdHIpCisgICAgICAgIGdfc2lnbmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCBkZXRhaWxT dHIsIG9mZnNldCwgY291bnQpOworfQorCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hh bmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCogb2JqZWN0 LCBBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3Vu dCkKK3sKKyAgICAvLyBTYW5pdHkgY2hlY2sKKyAgICBpZiAoIW9iamVjdCB8fCBjb3VudCA8IDEp CisgICAgICAgIHJldHVybjsKKworICAgIHVuc2lnbmVkIGdsb2JhbE9mZnNldCA9IGNhbGN1bGF0 ZUdsb2JhbE9mZnNldChvYmplY3QsIG9mZnNldCk7CisgICAgZW1pdFRleHRDaGFuZ2VkKG9iamVj dCwgdGV4dENoYW5nZSwgZ2xvYmFsT2Zmc2V0LCBjb3VudCk7Cit9CisKIHZvaWQgQVhPYmplY3RD YWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiBvbGRGb2N1 c2VkUmVuZGVyLCBSZW5kZXJPYmplY3QqIG5ld0ZvY3VzZWRSZW5kZXIpCiB7CiAgICAgUmVmUHRy PEFjY2Vzc2liaWxpdHlPYmplY3Q+IG9sZE9iamVjdCA9IGdldE9yQ3JlYXRlKG9sZEZvY3VzZWRS ZW5kZXIpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENh Y2hlTWFjLm1tIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1t CmluZGV4IGEwMmJjNzUuLjNjNjA0MzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFj L0FYT2JqZWN0Q2FjaGVNYWMubW0KQEAgLTExNCw2ICsxMTQsMTAgQEAgdm9pZCBBWE9iamVjdENh Y2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqLCBB WE5vdGlmaWMKICAgICBbb2JqLT53cmFwcGVyKCkgYWNjZXNzaWJpbGl0eVBvc3RlZE5vdGlmaWNh dGlvbjptYWNOb3RpZmljYXRpb25dOwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0 Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFY VGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQoreworfQorCiB2b2lkIEFYT2JqZWN0Q2Fj aGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRlck9i amVjdCopCiB7CiAgICAgW1tXZWJDb3JlVmlld0ZhY3Rvcnkgc2hhcmVkRmFjdG9yeV0gYWNjZXNz aWJpbGl0eUhhbmRsZUZvY3VzQ2hhbmdlZF07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dp bi9BWE9iamVjdENhY2hlV2luLmNwcAppbmRleCAyMWU2MWQ5Li5hOWM3YjI3IDEwMDY0NAotLS0g YS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCisrKyBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKQEAgLTEwMyw2ICsx MDMsMTAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNj ZXNzaWJpbGl0eU9iamVjdCogb2JqLCBBWE5vdGlmaWMKICAgICBOb3RpZnlXaW5FdmVudChtc2Fh RXZlbnQsIHBhZ2UtPmNocm9tZSgpLT5wbGF0Zm9ybVBhZ2VDbGllbnQoKSwgT0JKSURfQ0xJRU5U LCAtc3RhdGljX2Nhc3Q8TE9ORz4ob2JqLT5heE9iamVjdElEKCkpKTsKIH0KIAordm9pZCBBWE9i amVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkKK3sKK30K KwogQVhJRCBBWE9iamVjdENhY2hlOjpwbGF0Zm9ybUdlbmVyYXRlQVhJRCgpIGNvbnN0CiB7CiAg ICAgc3RhdGljIEFYSUQgbGFzdFVzZWRJRCA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRp bmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21t YW5kLmNwcAppbmRleCA2MTc4NjQxLi4wMmM0NDNhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2Rl Q29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNs dWRlICJBcHBlbmROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgog I2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQyLDYg KzQzLDE1IEBAIEFwcGVuZE5vZGVDb21tYW5kOjpBcHBlbmROb2RlQ29tbWFuZChQYXNzUmVmUHRy PEVsZW1lbnQ+IHBhcmVudCwgUGFzc1JlZlB0cjxOb2RlCiAgICAgQVNTRVJUKG1fcGFyZW50LT5p c0NvbnRlbnRFZGl0YWJsZSgpIHx8ICFtX3BhcmVudC0+YXR0YWNoZWQoKSk7CiB9CiAKK3N0YXRp YyB2b2lkIHNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJlYWtzKE5vZGUqIG5vZGUsIEFY T2JqZWN0Q2FjaGU6OkFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlKQoreworICAgIFN0cmluZyBub2Rl VmFsdWUgPSBub2RlLT5ub2RlVmFsdWUoKTsKKyAgICB1bnNpZ25lZCBsZW4gPSBub2RlVmFsdWUu bGVuZ3RoKCk7CisgICAgLy8gRG9uJ3QgY29uc2lkZXIgbGluZWJyZWFrcyBpbiB0aGlzIGNvbW1h bmQKKyAgICBpZiAobm9kZVZhbHVlICE9ICJcbiIpCisgICAgICAgIG5vZGUtPmRvY3VtZW50KCkt PmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obm9kZS0+cmVuZGVy ZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAsIGxlbik7Cit9CisKIHZvaWQg QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogewogICAgIGlmICghbV9wYXJlbnQtPmlzQ29u dGVudEVkaXRhYmxlKCkgJiYgbV9wYXJlbnQtPmF0dGFjaGVkKCkpCkBAIC00OSw2ICs1OSw5IEBA IHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgICAgICAKICAgICBFeGNlcHRp b25Db2RlIGVjOwogICAgIG1fcGFyZW50LT5hcHBlbmRDaGlsZChtX25vZGUuZ2V0KCksIGVjKTsK KworICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAg ICBzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyhtX25vZGUuZ2V0KCksIEFYT2Jq ZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkKTsKIH0KIAogdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KCkKQEAgLTU2LDYgKzY5LDEwIEBAIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRv VW5hcHBseSgpCiAgICAgaWYgKCFtX3BhcmVudC0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAg ICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBh Y3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3Np YmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJy ZWFrcyhtX25vZGUuZ2V0KCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQpOworCiAgICAg RXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPnJlbW92ZShlYyk7CiB9CmRpZmYgLS1naXQg YS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKaW5kZXggZjFkNzlhZi4uZmU1 NzJlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1h bmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNw cApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkRlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNp bmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTUzLDYgKzU0LDEwIEBA IHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgaWYgKGVjKQog ICAgICAgICByZXR1cm47CiAgICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUg YWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNz aWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5u b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2Fj aGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0LCBtX2NvdW50KTsKKwogICAgIG1fbm9kZS0+ZGVs ZXRlRGF0YShtX29mZnNldCwgbV9jb3VudCwgZWMpOwogfQogCkBAIC02NSw2ICs3MCw5IEBAIHZv aWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICAgICAgCiAgICAg RXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4 dCwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkp CisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3Rp ZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRl ZCwgbV9vZmZzZXQsIG1fY291bnQpOwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYg LS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9XZWJD b3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKaW5kZXggZTU3ODk1Yy4uNzE1 OTVmMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQu Y3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcApAQCAt NDQzLDExICs0NDMsNyBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUoKQogICAgICAgICByZXR1cm47CiAKICAgICBpZiAoc3RhcnROb2RlID09IG1fZG93 bnN0cmVhbUVuZC5ub2RlKCkpIHsKLSAgICAgICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxldGUg aXMgYWxsIGluIG9uZSBub2RlLgotICAgICAgICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8 fCAoc3RhcnRPZmZzZXQgPT0gMCAmJiBtX2Rvd25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bvc2l0 aW9uRm9yTm9kZSgpKSkgewotICAgICAgICAgICAgLy8ganVzdCBkZWxldGUKLSAgICAgICAgICAg IHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKLSAgICAgICAgfSBlbHNlIGlmIChtX2Rvd25zdHJlYW1F bmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSAtIHN0YXJ0T2Zmc2V0ID4gMCkgeworICAgICAg ICBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCkgLSBzdGFydE9m ZnNldCA+IDApIHsKICAgICAgICAgICAgIGlmIChzdGFydE5vZGUtPmlzVGV4dE5vZGUoKSkgewog ICAgICAgICAgICAgICAgIC8vIGluIGEgdGV4dCBub2RlIHRoYXQgbmVlZHMgdG8gYmUgdHJpbW1l ZAogICAgICAgICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0aWNfY2FzdDxUZXh0Kj4oc3RhcnRO b2RlKTsKQEAgLTQ1Nyw2ICs0NTMsMTAgQEAgdm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgICAgICAgICBtX2VuZGluZ1Bvc2l0aW9uID0g bV91cHN0cmVhbVN0YXJ0OwogICAgICAgICAgICAgfQogICAgICAgICB9CisKKyAgICAgICAgLy8g VGhlIHNlbGVjdGlvbiB0byBkZWxldGUgaXMgYWxsIGluIG9uZSBub2RlLgorICAgICAgICBpZiAo IXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8fCAoIXN0YXJ0T2Zmc2V0ICYmIG1fZG93bnN0cmVhbUVu ZC5hdExhc3RFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKCkpKQorICAgICAgICAgICAgcmVtb3ZlTm9k ZShzdGFydE5vZGUpOwogICAgIH0KICAgICBlbHNlIHsKICAgICAgICAgYm9vbCBzdGFydE5vZGVX YXNEZXNjZW5kYW50T2ZFbmROb2RlID0gbV91cHN0cmVhbVN0YXJ0Lm5vZGUoKS0+aXNEZXNjZW5k YW50T2YobV9kb3duc3RyZWFtRW5kLm5vZGUoKSk7CkBAIC00NzIsNiArNDcyLDkgQEAgdm9pZCBE ZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgICAg IH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgbm9kZSA9IHN0YXJ0Tm9kZS0+Y2hpbGROb2RlKHN0 YXJ0T2Zmc2V0KTsKICAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIGlmIChzdGFydE5vZGUg PT0gbV91cHN0cmVhbUVuZC5ub2RlKCkgJiYgc3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKKyAg ICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0aWNfY2FzdDxUZXh0Kj4obV91cHN0cmVhbUVuZC5u b2RlKCkpOworICAgICAgICAgICAgZGVsZXRlVGV4dEZyb21Ob2RlKHRleHQsIDAsIG1fdXBzdHJl YW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSk7CiAgICAgICAgIH0KICAgICAgICAgCiAg ICAgICAgIC8vIGhhbmRsZSBkZWxldGluZyBhbGwgbm9kZXMgdGhhdCBhcmUgY29tcGxldGVseSBz ZWxlY3RlZApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNv bW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3Bw CmluZGV4IDljMzQyM2EuLjliNzc2MWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNl cnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcu aCIKICNpbmNsdWRlICJJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJB WE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CkBAIC00OCw2ICs0OSw5IEBAIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBs eSgpCiAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPmluc2VydERhdGEo bV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2li aWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9k ZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hl OjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fdGV4dC5sZW5ndGgoKSk7CiB9CiAKIHZvaWQg SW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU1LDYgKzU5LDEwIEBA IHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1f bm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAg ICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4 dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAg ICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9u KG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZz ZXQsIG1fdGV4dC5sZW5ndGgoKSk7CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9k ZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpLCBlYyk7CiB9CmRpZmYgLS1n aXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwIGIvV2ViQ29y ZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcAppbmRleCAyY2U5ODQ2Li42ZjE2 ZTA4IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQu Y3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAKQEAg LTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJbnNlcnROb2Rl QmVmb3JlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUg Imh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTUxLDYgKzUyLDExIEBA IHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvQXBwbHkoKQogCiAgICAgRXhjZXB0aW9u Q29kZSBlYzsKICAgICBwYXJlbnQtPmluc2VydEJlZm9yZShtX2luc2VydENoaWxkLmdldCgpLCBt X3JlZkNoaWxkLmdldCgpLCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJp bGl0eUVuYWJsZWQoKSkgeworICAgICAgICB1bnNpZ25lZCBsZW4gPSBtX2luc2VydENoaWxkLT5u b2RlVmFsdWUoKS5sZW5ndGgoKTsKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgp LT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX2luc2VydENoaWxkLT5yZW5kZXJlcigpLCBB WE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgMCwgbGVuKTsKKyAgICB9CiB9CiAKIHZvaWQg SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC01OCw2ICs2NCwxMiBAQCB2 b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9pbnNl cnRDaGlsZC0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAK KyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUg dGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7Cisg ICAgICAgIHVuc2lnbmVkIGxlbiA9IG1faW5zZXJ0Q2hpbGQtPm5vZGVWYWx1ZSgpLmxlbmd0aCgp OworICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90 aWZpY2F0aW9uKG1faW5zZXJ0Q2hpbGQtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4 dERlbGV0ZWQsIDAsIGxlbik7CisgICAgfQorCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBt X2luc2VydENoaWxkLT5yZW1vdmUoZWMpOwogfQotLSAKMS43LjAuNAoK 67463 2010-09-13 13:16:21 -0700 2010-09-20 10:16:19 -0700 Single patch for fixing this bug 0001-2010-09-13-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23133 mario RnJvbSBlNGQ1Yzc1ODQzOTVhYjVjNDhiY2U5YjI3ZjdiODJlZjQzYWQ1YTUxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDEzIFNlcCAyMDEwIDIyOjA1OjEwICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0xMyBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMSArKysrCiBX ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTQg KysrKy0KIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmgg IHwgICAxNyArKysrKy0KIC4uLi9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwICAg ICAgICAgICAgIHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2Fj aGVBdGsuY3BwICAgICB8ICAgMzggKysrKysrKysrKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkv bWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gICAgICB8ICAgIDQgKwogV2ViQ29yZS9hY2Nlc3NpYmls aXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCAgICAgfCAgICA0ICsKIFdlYkNvcmUvZWRpdGlu Zy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICAgICAgIHwgICAxNyArKysrKwogV2ViQ29y ZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwICAgICAgfCAgICA4ICsrKwog V2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwICAgICAgICAgfCAgIDEz ICsrKy0tCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAgICAg ICB8ICAgIDggKysrCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3Bw ICAgICAgICB8ICAgIDggKysrCiAxMyBmaWxlcyBjaGFuZ2VkLCAyMDIgaW5zZXJ0aW9ucygrKSwg NyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDdhZDU4N2YuLjM0MjY1NTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMTAtMDkt MTMgTWFyaW8gU2FuY2hleiBQcmFkYSA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1j aGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQg dGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4 OTgKKworICAgICAgICBJbXBsZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBlbWlz c2lvbiBmb3IgdGhlIEdUSyBwb3J0CisKKyAgICAgICAgQ2FsbCBkZWxldGVUZXh0RnJvbU5vZGUo KSB3aGVuIG5lZWRlZCB3aGlsZSByZW1vdmluZyB0ZXh0IG5vZGVzLgorICAgICAgICBEbyBpdCBl dmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBp bgorICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKKyAgICAgICAgdGV4dCBiZWluZyByZW1vdmVkIGFsb25nc2lkZSB3 aXRoIHRoYXQgbm9kZS4KKworICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFu ZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVH ZW5lcmFsRGVsZXRlKToKKworICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0 byBjYWxsIHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KKyAgICAgICAgQWRkZWQgb25lIG5l dyBmdW5jdGlvbiB0byBhbGxvdyBub3RpZnlpbmcgc29tZXRoaW5nIGNoYW5nZWQgaW4gYQorICAg ICAgICB0ZXh0IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2lu ZyBzdWNoIGEKKyAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVj aWZpYyBpbXBsZW1lbnRhdGlvbiwKKyAgICAgICAgcHJvdmlkZWQgdGhyb3VnaCBhIHByb3RlY3Rl ZCBmdW5jdGlvbiAocHJvdmlkZWQgYSBwcm9wZXIKKyAgICAgICAgaW1wbGVtZW50YXRpb24gZm9y IHRoZSBHVEsgcG9ydCBhbmQgYSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgorCisgICAgICAg ICogYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICog YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmg6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpBWFRleHRDaGFuZ2UpOiBOZXcgZW51bWVyYXRpb24KKyAgICAgICAgKFdlYkNvcmU6 OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAg IChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0 aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0Lmg6CisgICAgICAgIChXZWJDb3JlOjp0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QpOgor ICAgICAgICAqIGFjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZv cm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVj dENhY2hlQXRrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CisgICAg ICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZp Y2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1h Yy5tbToKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L3dpbi9BWE9i amVjdENhY2hlV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVU ZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKworICAgICAgICBOb3RpZnkgYWNj ZXNzaWJpbGl0eSB3aGVuIHNvbWV0aGluZyBjaGFuZ2VzIGluIGEgdGV4dCBub2RlLgorICAgICAg ICBDYWxsIHRvIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKCkgdG8g bm90aWZ5IHdoZW4KKyAgICAgICAgdGV4dCB3YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5 aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KKyAgICAgICAgY29tbWFuZCwgYWxvbmcgd2l0 aCB0aGUgb2Zmc2V0IGluIHRoZSBvcmlnaW5hbCB0ZXh0IHdoZXJlIHRoZQorICAgICAgICBjaGFu Z2UgdG9vayBwbGFjZSBhbmQgdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzIHRoYXQgZ290IGFmZmVj dGVkLgorCisgICAgICAgICogZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyk6CisgICAgICAg IChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3Jl OjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0SW50b1Rl eHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNv bW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29t bWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9B cHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFw cGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdl bmVyYWxEZWxldGUpOgorCiAyMDEwLTA5LTEzICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hy b21pdW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFBhdmVsIEZlbGRtYW4uCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAgYi9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKaW5kZXggOTA3YmIxNS4uMzhhYmY0YyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCisrKyBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDY1LDYgKzQ2NSwxNyBA QCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRlck9iamVj dCogcmVuZGVyZXIpCiAgICAgLy8gdG8gZmluZCB0aGUgY29udGFpbmVyIHdoaWNoIHNob3VsZCBz ZW5kIG91dCB0aGUgbm90aWZpY2F0aW9uLgogICAgIHBvc3ROb3RpZmljYXRpb24ocmVuZGVyZXIs IEFYU2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQsIGZhbHNlKTsKIH0KKwordm9pZCBBWE9iamVjdENh Y2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBB WFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkK K3sKKyAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBEZWxlZ2F0 ZSBvbiB0aGUgcmlnaHQgcGxhdGZvcm0KKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmogPSBn ZXRPckNyZWF0ZShyZW5kZXJlcik7CisgICAgaWYgKG9iai0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0KCkpCisgICAgICAgIG5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24odG9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KG9iaiksIHRleHRDaGFuZ2UsIG9mZnNldCwgY291bnQp OworfQogI2VuZGlmCiAKICNpZiBIQVZFKEFDQ0VTU0lCSUxJVFkpCmRpZmYgLS1naXQgYS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuaAppbmRleCAyOGE1OTE3Li40NmFmYmYxIDEwMDY0NAotLS0gYS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWE9iamVjdENhY2hlLmgKQEAgLTI2LDcgKzI2LDcgQEAKICNpZm5kZWYgQVhPYmplY3RD YWNoZV9oCiAjZGVmaW5lIEFYT2JqZWN0Q2FjaGVfaAogCi0jaW5jbHVkZSAiQWNjZXNzaWJpbGl0 eU9iamVjdC5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCIKICNpbmNs dWRlICJUaW1lci5oIgogI2luY2x1ZGUgPGxpbWl0cy5oPgogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJk Lmg+CkBAIC0xMjUsOCArMTI1LDE4IEBAIHB1YmxpYzoKICAgICB2b2lkIHBvc3ROb3RpZmljYXRp b24oUmVuZGVyT2JqZWN0KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9z dFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogICAgIHZvaWQgcG9zdE5vdGlmaWNhdGlvbihB Y2Nlc3NpYmlsaXR5T2JqZWN0KiwgRG9jdW1lbnQqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0 VG9FbGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3luY2hyb25vdXNseSk7CiAKKyAgICBlbnVtIEFY VGV4dENoYW5nZSB7CisgICAgICAgIEFYVGV4dEluc2VydGVkLAorICAgICAgICBBWFRleHREZWxl dGVkLAorICAgIH07CisKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRl ck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7 CisKKyAgICBib29sIG5vZGVIYXNSb2xlKE5vZGUqLCBjb25zdCBBdG9taWNTdHJpbmcmIHJvbGUp OworCiBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNz aWJpbGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKTsKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdl UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENo YW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CiAKIHByaXZhdGU6CiAgICAg SGFzaE1hcDxBWElELCBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gPiBtX29iamVjdHM7CkBA IC0xNTYsNiArMTY2LDggQEAgaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRDaGls ZHJlbkNoYW5nZWQoUmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hl Ojpwb3N0Tm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBv c3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBv c3ROb3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmlj YXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQgQVhP YmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3Qq LCBBWE5vdGlmaWNhdGlvbikgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVk LCB1bnNpZ25lZCkgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5n ZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqLCBBWFRleHRD aGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hl OjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmpl Y3QqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZVNjcm9sbGVkVG9BbmNo b3IoY29uc3QgTm9kZSopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6Y29udGVudENo YW5nZWQoUmVuZGVyT2JqZWN0KikgeyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAppbmRleCBjZWZhYTk0Li5iN2I4NWZlIDEwMDY0NAot LS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCisr KyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKQEAg LTMxMSw3ICszMTEsMjIgQEAgcHJpdmF0ZToKICAgICAKICAgICBtdXRhYmxlIEFjY2Vzc2liaWxp dHlSb2xlIG1fcm9sZUZvck1TQUE7CiB9OwotICAgIAorCitpbmxpbmUgQWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KEFjY2Vzc2liaWxpdHlPYmpl Y3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3QtPmlzQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKK2lubGluZSBjb25zdCBBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0KiB0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoY29uc3QgQWNjZXNzaWJp bGl0eU9iamVjdCogb2JqZWN0KQoreworICAgIEFTU0VSVCghb2JqZWN0IHx8IG9iamVjdC0+aXNB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxjb25z dCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsKK30KKworLy8gVGhpcyB3aWxs IGNhdGNoIGFueW9uZSBkb2luZyBhbiB1bm5lY2Vzc2FyeSBjYXN0Lgordm9pZCB0b0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QoY29uc3QgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCopOworCiB9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0X2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVj dENhY2hlQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2Jq ZWN0Q2FjaGVDaHJvbWl1bS5jcHAKaW5kZXggZDkwNmE5MS4uMGYzMzY5YiAxMDA2NDQKLS0tIGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAK KysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1 bS5jcHAKQEAgLTg2LDYgKzg2LDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3Jt Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAgICAgfQog fQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRp b24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVu c2lnbmVkKQoreworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1l bnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiB9CmRpZmYgLS1naXQg YS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIGIvV2ViQ29y ZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcAppbmRleCBjMzBiMDA2Li4z YzA0ZGVhIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2Fj aGVBdGsuY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0 ay5jcHAKQEAgLTIyLDYgKzIyLDEwIEBACiAKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0 LmgiCiAjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuaCIKKyNpbmNsdWRl ICJBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgiCisjaW5jbHVkZSAiR093blB0ci5oIgorI2lu Y2x1ZGUgIlJhbmdlLmgiCisjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtNTAsNiArNTQsNDAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxh dGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAg ICB9CiB9CiAKK3N0YXRpYyB2b2lkIGVtaXRUZXh0Q2hhbmdlZChBY2Nlc3NpYmlsaXR5UmVuZGVy T2JqZWN0KiBvYmplY3QsIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1 bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIEdldCB0aGUgYXhPYmpl Y3QgZm9yIHRoZSBwYXJlbnQgb2JqZWN0CisgICAgQXRrT2JqZWN0KiB3cmFwcGVyID0gb2JqZWN0 LT5wYXJlbnRPYmplY3RVbmlnbm9yZWQoKS0+d3JhcHBlcigpOworICAgIGlmICghd3JhcHBlciB8 fCAhQVRLX0lTX1RFWFQod3JhcHBlcikpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIFNlbGVj dCB0aGUgcmlnaHQgc2lnbmFsIHRvIGJlIGVtaXR0ZWQKKyAgICBHT3duUHRyPGdjaGFyPiBkZXRh aWw7CisgICAgc3dpdGNoICh0ZXh0Q2hhbmdlKSB7CisgICAgY2FzZSBBWE9iamVjdENhY2hlOjpB WFRleHRJbnNlcnRlZDoKKyAgICAgICAgZGV0YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2Vk OjppbnNlcnQiKSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgQVhPYmplY3RDYWNoZTo6QVhU ZXh0RGVsZXRlZDoKKyAgICAgICAgZGV0YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2VkOjpk ZWxldGUiKSk7CisgICAgICAgIGJyZWFrOworICAgIH0KKworICAgIGdjaGFyKiBkZXRhaWxTdHIg PSBkZXRhaWwuZ2V0KCk7CisgICAgaWYgKGRldGFpbFN0cikKKyAgICAgICAgZ19zaWduYWxfZW1p dF9ieV9uYW1lKHdyYXBwZXIsIGRldGFpbFN0ciwgb2Zmc2V0LCBjb3VudCk7Cit9CisKK3ZvaWQg QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0KiBvYmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNp Z25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVjaworICAg IGlmICghb2JqZWN0IHx8IGNvdW50IDwgMSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTm9kZSog bm9kZSA9IG9iamVjdC0+bm9kZSgpOworICAgIFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBSYW5nZTo6 Y3JlYXRlKG5vZGUtPmRvY3VtZW50KCksICBQb3NpdGlvbihub2RlLT5wYXJlbnROb2RlKCksIDAp LCBQb3NpdGlvbihub2RlLCAwKSk7CisgICAgZW1pdFRleHRDaGFuZ2VkKG9iamVjdCwgdGV4dENo YW5nZSwgb2Zmc2V0ICsgVGV4dEl0ZXJhdG9yOjpyYW5nZUxlbmd0aChyYW5nZS5nZXQoKSksIGNv dW50KTsKK30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hh bmdlZChSZW5kZXJPYmplY3QqIG9sZEZvY3VzZWRSZW5kZXIsIFJlbmRlck9iamVjdCogbmV3Rm9j dXNlZFJlbmRlcikKIHsKICAgICBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gb2xkT2JqZWN0 ID0gZ2V0T3JDcmVhdGUob2xkRm9jdXNlZFJlbmRlcik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gYi9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KaW5kZXggYTAyYmM3NS4uM2M2MDQzOCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCisrKyBi L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQpAQCAtMTE0LDYg KzExNCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihB Y2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgIFtvYmotPndyYXBwZXIoKSBh Y2Nlc3NpYmlsaXR5UG9zdGVkTm90aWZpY2F0aW9uOm1hY05vdGlmaWNhdGlvbl07CiB9CiAKK3Zv aWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQp Cit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5n ZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikKIHsKICAgICBbW1dlYkNvcmVWaWV3RmFj dG9yeSBzaGFyZWRGYWN0b3J5XSBhY2Nlc3NpYmlsaXR5SGFuZGxlRm9jdXNDaGFuZ2VkXTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAg Yi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCmluZGV4IDIx ZTYxZDkuLmE5YzdiMjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhP YmplY3RDYWNoZVdpbi5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVj dENhY2hlV2luLmNwcApAQCAtMTAzLDYgKzEwMywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBv c3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZp YwogICAgIE5vdGlmeVdpbkV2ZW50KG1zYWFFdmVudCwgcGFnZS0+Y2hyb21lKCktPnBsYXRmb3Jt UGFnZUNsaWVudCgpLCBPQkpJRF9DTElFTlQsIC1zdGF0aWNfY2FzdDxMT05HPihvYmotPmF4T2Jq ZWN0SUQoKSkpOwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZv cm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwg dW5zaWduZWQsIHVuc2lnbmVkKQoreworfQorCiBBWElEIEFYT2JqZWN0Q2FjaGU6OnBsYXRmb3Jt R2VuZXJhdGVBWElEKCkgY29uc3QKIHsKICAgICBzdGF0aWMgQVhJRCBsYXN0VXNlZElEID0gMDsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJD b3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLjAyYzQ0M2Eg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIv V2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAog I2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkFwcGVuZE5vZGVDb21tYW5kLmgiCiAKKyNp bmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFt ZXNwYWNlIFdlYkNvcmUgewpAQCAtNDIsNiArNDMsMTUgQEAgQXBwZW5kTm9kZUNvbW1hbmQ6OkFw cGVuZE5vZGVDb21tYW5kKFBhc3NSZWZQdHI8RWxlbWVudD4gcGFyZW50LCBQYXNzUmVmUHRyPE5v ZGUKICAgICBBU1NFUlQobV9wYXJlbnQtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgIW1fcGFyZW50 LT5hdHRhY2hlZCgpKTsKIH0KIAorc3RhdGljIHZvaWQgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmlu Z0xpbmVCcmVha3MoTm9kZSogbm9kZSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRD aGFuZ2UpCit7CisgICAgU3RyaW5nIG5vZGVWYWx1ZSA9IG5vZGUtPm5vZGVWYWx1ZSgpOworICAg IHVuc2lnbmVkIGxlbiA9IG5vZGVWYWx1ZS5sZW5ndGgoKTsKKyAgICAvLyBEb24ndCBjb25zaWRl ciBsaW5lYnJlYWtzIGluIHRoaXMgY29tbWFuZAorICAgIGlmIChub2RlVmFsdWUgIT0gIlxuIikK KyAgICAgICAgbm9kZS0+ZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5n ZU5vdGlmaWNhdGlvbihub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNl cnRlZCwgMCwgbGVuKTsKK30KKwogdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiB7 CiAgICAgaWYgKCFtX3BhcmVudC0+aXNDb250ZW50RWRpdGFibGUoKSAmJiBtX3BhcmVudC0+YXR0 YWNoZWQoKSkKQEAgLTQ5LDYgKzU5LDkgQEAgdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBs eSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9wYXJlbnQtPmFwcGVu ZENoaWxkKG1fbm9kZS5nZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vz c2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIHNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5l QnJlYWtzKG1fbm9kZS5nZXQoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQpOwogfQog CiB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTYsNiArNjksMTAgQEAg dm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fcGFyZW50LT5p c0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5l ZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAg aWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIHNlbmRB WFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJlYWtzKG1fbm9kZS5nZXQoKSwgQVhPYmplY3RDYWNo ZTo6QVhUZXh0RGVsZXRlZCk7CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ cmVtb3ZlKGVjKTsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21t YW5kLmNwcAppbmRleCBmMWQ3OWFmLi5mZTU3MmUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0Rl bGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAi Y29uZmlnLmgiCiAjaW5jbHVkZSAiRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oIgogCisjaW5j bHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgIlRleHQuaCIKIAogbmFtZXNwYWNlIFdl YkNvcmUgewpAQCAtNTMsNiArNTQsMTAgQEAgdm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5k Ojpkb0FwcGx5KCkKICAgICBpZiAoZWMpCiAgICAgICAgIHJldHVybjsKICAgICAKKyAgICAvLyBO ZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAg IGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1 bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9k ZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1f Y291bnQpOworCiAgICAgbV9ub2RlLT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX2NvdW50LCBlYyk7 CiB9CiAKQEAgLTY1LDYgKzcwLDkgQEAgdm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpk b1VuYXBwbHkoKQogICAgICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ aW5zZXJ0RGF0YShtX29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNo ZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RD YWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFY T2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCBtX29mZnNldCwgbV9jb3VudCk7CiB9CiAKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVT ZWxlY3Rpb25Db21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21t YW5kLmNwcAppbmRleCA0YWE1YzNjLi40YWNhNTdlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCkBAIC00NDMsMTEgKzQ0Myw3IEBAIHZvaWQgRGVsZXRlU2Vs ZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSgpCiAgICAgICAgIHJldHVybjsKIAog ICAgIGlmIChzdGFydE5vZGUgPT0gbV9kb3duc3RyZWFtRW5kLm5vZGUoKSkgewotICAgICAgICAv LyBUaGUgc2VsZWN0aW9uIHRvIGRlbGV0ZSBpcyBhbGwgaW4gb25lIG5vZGUuCi0gICAgICAgIGlm ICghc3RhcnROb2RlLT5yZW5kZXJlcigpIHx8IChzdGFydE9mZnNldCA9PSAwICYmIG1fZG93bnN0 cmVhbUVuZC5hdExhc3RFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKCkpKSB7Ci0gICAgICAgICAgICAv LyBqdXN0IGRlbGV0ZQotICAgICAgICAgICAgcmVtb3ZlTm9kZShzdGFydE5vZGUpOwotICAgICAg ICB9IGVsc2UgaWYgKG1fZG93bnN0cmVhbUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpIC0g c3RhcnRPZmZzZXQgPiAwKSB7CisgICAgICAgIGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRl ZEVkaXRpbmdPZmZzZXQoKSAtIHN0YXJ0T2Zmc2V0ID4gMCkgewogICAgICAgICAgICAgaWYgKHN0 YXJ0Tm9kZS0+aXNUZXh0Tm9kZSgpKSB7CiAgICAgICAgICAgICAgICAgLy8gaW4gYSB0ZXh0IG5v ZGUgdGhhdCBuZWVkcyB0byBiZSB0cmltbWVkCiAgICAgICAgICAgICAgICAgVGV4dCogdGV4dCA9 IHN0YXRpY19jYXN0PFRleHQqPihzdGFydE5vZGUpOwpAQCAtNDU3LDYgKzQ1MywxMCBAQCB2b2lk IERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICAg ICAgICAgIG1fZW5kaW5nUG9zaXRpb24gPSBtX3Vwc3RyZWFtU3RhcnQ7CiAgICAgICAgICAgICB9 CiAgICAgICAgIH0KKworICAgICAgICAvLyBUaGUgc2VsZWN0aW9uIHRvIGRlbGV0ZSBpcyBhbGwg aW4gb25lIG5vZGUuCisgICAgICAgIGlmICghc3RhcnROb2RlLT5yZW5kZXJlcigpIHx8ICghc3Rh cnRPZmZzZXQgJiYgbV9kb3duc3RyZWFtRW5kLmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUo KSkpCisgICAgICAgICAgICByZW1vdmVOb2RlKHN0YXJ0Tm9kZSk7CiAgICAgfQogICAgIGVsc2Ug ewogICAgICAgICBib29sIHN0YXJ0Tm9kZVdhc0Rlc2NlbmRhbnRPZkVuZE5vZGUgPSBtX3Vwc3Ry ZWFtU3RhcnQubm9kZSgpLT5pc0Rlc2NlbmRhbnRPZihtX2Rvd25zdHJlYW1FbmQubm9kZSgpKTsK QEAgLTQ3Miw2ICs0NzIsOSBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdl bmVyYWxEZWxldGUoKQogICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICBub2Rl ID0gc3RhcnROb2RlLT5jaGlsZE5vZGUoc3RhcnRPZmZzZXQpOwogICAgICAgICAgICAgfQorICAg ICAgICB9IGVsc2UgaWYgKHN0YXJ0Tm9kZSA9PSBtX3Vwc3RyZWFtRW5kLm5vZGUoKSAmJiBzdGFy dE5vZGUtPmlzVGV4dE5vZGUoKSkgeworICAgICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19j YXN0PFRleHQqPihtX3Vwc3RyZWFtRW5kLm5vZGUoKSk7CisgICAgICAgICAgICBkZWxldGVUZXh0 RnJvbU5vZGUodGV4dCwgMCwgbV91cHN0cmVhbUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgp KTsKICAgICAgICAgfQogICAgICAgICAKICAgICAgICAgLy8gaGFuZGxlIGRlbGV0aW5nIGFsbCBu b2RlcyB0aGF0IGFyZSBjb21wbGV0ZWx5IHNlbGVjdGVkCmRpZmYgLS1naXQgYS9XZWJDb3JlL2Vk aXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKaW5kZXggOWMzNDIzYS4uOWI3NzYxYyAxMDA2NDQK LS0tIGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBi L1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiAr MjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkluc2VydEludG9UZXh0Tm9k ZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0 LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQ4LDYgKzQ5LDkgQEAgdm9pZCBJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVj OwogICAgIG1fbm9kZS0+aW5zZXJ0RGF0YShtX29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBp ZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1l bnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUt PnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCBtX29mZnNldCwgbV90 ZXh0Lmxlbmd0aCgpKTsKIH0KIAogdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1Vu YXBwbHkoKQpAQCAtNTUsNiArNTksMTAgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5k Ojpkb1VuYXBwbHkoKQogICAgIGlmICghbV9ub2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAg ICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3Jl IGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vz c2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+ bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENh Y2hlOjpBWFRleHREZWxldGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpKTsKKwogICAgIEV4 Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9ub2RlLT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX3RleHQu bGVuZ3RoKCksIGVjKTsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2Rl QmVmb3JlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1h bmQuY3BwCmluZGV4IDJjZTk4NDYuLmZiNzIzMTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGlu Zy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dE5vZGVCZWZvcmVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZp Zy5oIgogI2luY2x1ZGUgIkluc2VydE5vZGVCZWZvcmVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJB WE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdl YkNvcmUgewpAQCAtNTEsNiArNTIsOSBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpk b0FwcGx5KCkKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgcGFyZW50LT5pbnNlcnRCZWZv cmUobV9pbnNlcnRDaGlsZC5nZXQoKSwgbV9yZWZDaGlsZC5nZXQoKSwgZWMpOworCisgICAgaWYg KEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50 KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRD aGlsZC0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAsIG1faW5z ZXJ0Q2hpbGQtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpKTsKIH0KIAogdm9pZCBJbnNlcnROb2RlQmVm b3JlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU4LDYgKzYyLDEwIEBAIHZvaWQgSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX2luc2VydENoaWxkLT5pc0Nv bnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQg dG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYg KEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50 KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRD aGlsZC0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgMCwgbV9pbnNl cnRDaGlsZC0+bm9kZVZhbHVlKCkubGVuZ3RoKCkpOworCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsK ICAgICBtX2luc2VydENoaWxkLT5yZW1vdmUoZWMpOwogfQotLSAKMS43LjAuNAoK 68105 2010-09-20 10:16:19 -0700 2010-09-22 07:10:32 -0700 Single patch for fixing this bug 0001-2010-09-20-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23182 mario RnJvbSBjYjZjOTVlYjEzYzY0ZGExZjVlNDZhN2M1ODVmMTgyNTVkYjI3NjZmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDIwIFNlcCAyMDEwIDE5OjExOjU2ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0yMCBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMSArKysrCiBX ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTQg KysrKy0KIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmgg IHwgICAxNyArKysrKy0KIC4uLi9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwICAg ICAgICAgICAgIHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2Fj aGVBdGsuY3BwICAgICB8ICAgMzcgKysrKysrKysrKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkv bWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gICAgICB8ICAgIDQgKwogV2ViQ29yZS9hY2Nlc3NpYmls aXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCAgICAgfCAgICA0ICsKIFdlYkNvcmUvZWRpdGlu Zy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICAgICAgIHwgICAxOSArKysrKysKIFdlYkNv cmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCAgICAgIHwgICAgOCArKysK IFdlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcCAgICAgICAgIHwgICAx MyArKystLQogV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwICAg ICAgfCAgICA4ICsrKwogV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNw cCAgICAgICAgfCAgICA4ICsrKwogMTMgZmlsZXMgY2hhbmdlZCwgMjAzIGluc2VydGlvbnMoKyks IDcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCBhY2ZmNjc1Li4xOTA2ZjU4IDEwMDY0NAotLS0gYS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY2IEBACisyMDEwLTA5 LTIwIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0d0a10gb2JqZWN0OnRleHQt Y2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBhc3N3b3Jk IHRleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1 ODk4CisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwgZW1p c3Npb24gZm9yIHRoZSBHVEsgcG9ydAorCisgICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2Rl KCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KKyAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KKyAgICAgICAgb3JkZXIgdG8gYWxsb3cgYWNjZXNzaWJpbGl0eSB0byBnZXQgcHJvcGVybHkg bm90aWZpZWQgYWJvdXQgdGhlCisgICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUg d2l0aCB0aGF0IG5vZGUuCisKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1h bmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxl R2VuZXJhbERlbGV0ZSk6CisKKyAgICAgICAgTmV3IGZ1bmN0aW9uIGluIEFYT2JqZWN0Q2FjaGUg dG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUuCisgICAgICAgIEFkZGVkIG9uZSBu ZXcgZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKKyAg ICAgICAgdGV4dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtp bmcgc3VjaCBhCisgICAgICAgIGZ1bmN0aW9uIGRlcGVuZGFudCBvbiB0aGUgcGxhdGZvcm0tc3Bl Y2lmaWMgaW1wbGVtZW50YXRpb24sCisgICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0 ZWQgZnVuY3Rpb24gKHByb3ZpZGVkIGEgcHJvcGVyCisgICAgICAgIGltcGxlbWVudGF0aW9uIGZv ciB0aGUgR1RLIHBvcnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KKworICAgICAg ICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpB WE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAq IGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmpl Y3RDYWNoZTo6QVhUZXh0Q2hhbmdlKTogTmV3IGVudW1lcmF0aW9uCisgICAgICAgIChXZWJDb3Jl OjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAg ICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNh dGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToK KyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRm b3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmpl Y3RDYWNoZUF0ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjplbWl0VGV4dENoYW5nZWQpOgorICAg ICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlm aWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVN YWMubW06CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBs YXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS93aW4vQVhP YmplY3RDYWNoZVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2Rl VGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisKKyAgICAgICAgTm90aWZ5IGFj Y2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdlcyBpbiBhIHRleHQgbm9kZS4KKyAgICAg ICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRv IG5vdGlmeSB3aGVuCisgICAgICAgIHRleHQgd2FzIGluc2VydGVkL2RlbGV0ZWQgd2hlbiBhcHBs eWluZy91bmFwcGx5aW5nIGEgdGV4dCBlZGl0aW9uCisgICAgICAgIGNvbW1hbmQsIGFsb25nIHdp dGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKKyAgICAgICAgY2hh bmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZl Y3RlZC4KKworICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MpOgorICAgICAg ICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29y ZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9EZWxl dGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21U ZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydEludG9U ZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2Rl Q29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRv QXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5h cHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVH ZW5lcmFsRGVsZXRlKToKKwogMjAxMC0wOS0xOSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3 LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3NzQ5 LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwIGIv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4IDkwN2JiMTUuLjM4 YWJmNGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNw cAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKQEAgLTQ2NSw2 ICs0NjUsMTcgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChS ZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIC8vIHRvIGZpbmQgdGhlIGNvbnRhaW5lciB3aGlj aCBzaG91bGQgc2VuZCBvdXQgdGhlIG5vdGlmaWNhdGlvbi4KICAgICBwb3N0Tm90aWZpY2F0aW9u KHJlbmRlcmVyLCBBWFNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkLCBmYWxzZSk7CiB9CisKK3ZvaWQg QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiBy ZW5kZXJlciwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWdu ZWQgY291bnQpCit7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOworCisgICAg Ly8gRGVsZWdhdGUgb24gdGhlIHJpZ2h0IHBsYXRmb3JtCisgICAgQWNjZXNzaWJpbGl0eU9iamVj dCogb2JqID0gZ2V0T3JDcmVhdGUocmVuZGVyZXIpOworICAgIGlmIChvYmotPmlzQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdCgpKQorICAgICAgICBub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZp Y2F0aW9uKHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChvYmopLCB0ZXh0Q2hhbmdlLCBvZmZz ZXQsIGNvdW50KTsKK30KICNlbmRpZgogCiAjaWYgSEFWRShBQ0NFU1NJQklMSVRZKQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCBiL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKaW5kZXggMjhhNTkxNy4uNDZhZmJmMSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAorKysgYi9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCkBAIC0yNiw3ICsyNiw3IEBACiAjaWZuZGVm IEFYT2JqZWN0Q2FjaGVfaAogI2RlZmluZSBBWE9iamVjdENhY2hlX2gKIAotI2luY2x1ZGUgIkFj Y2Vzc2liaWxpdHlPYmplY3QuaCIKKyNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmgiCiAjaW5jbHVkZSAiVGltZXIuaCIKICNpbmNsdWRlIDxsaW1pdHMuaD4KICNpbmNsdWRlIDx3 dGYvRm9yd2FyZC5oPgpAQCAtMTI1LDggKzEyNSwxOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0 Tm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0Vs ZW1lbnQsIFBvc3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3Rp ZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24s IGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisg ICAgZW51bSBBWFRleHRDaGFuZ2UgeworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAg QVhUZXh0RGVsZXRlZCwKKyAgICB9OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNh dGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWdu ZWQgY291bnQpOworCisgICAgYm9vbCBub2RlSGFzUm9sZShOb2RlKiwgY29uc3QgQXRvbWljU3Ry aW5nJiByb2xlKTsKKwogcHJvdGVjdGVkOgogICAgIHZvaWQgcG9zdFBsYXRmb3JtTm90aWZpY2F0 aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWE5vdGlmaWNhdGlvbik7CisgICAgdm9pZCBub2Rl VGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qq LCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOwogCiBwcml2 YXRlOgogICAgIEhhc2hNYXA8QVhJRCwgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ID4gbV9v YmplY3RzOwpAQCAtMTU2LDYgKzE2Niw4IEBAIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNl bGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhP YmplY3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlv biwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVj dENhY2hlOjpwb3N0Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCos IEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGlu ZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmls aXR5T2JqZWN0KiwgQVhOb3RpZmljYXRpb24pIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNo ZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdl LCB1bnNpZ25lZCwgdW5zaWduZWQpIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpIHsgfQogaW5saW5lIHZvaWQgQVhP YmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0Kiwg UmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVTY3Jv bGxlZFRvQW5jaG9yKGNvbnN0IE5vZGUqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6 OmNvbnRlbnRDaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKaW5kZXggY2VmYWE5NC4uYjdiODVm ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oCkBAIC0zMTEsNyArMzExLDIyIEBAIHByaXZhdGU6CiAgICAgCiAgICAgbXV0YWJsZSBB Y2Nlc3NpYmlsaXR5Um9sZSBtX3JvbGVGb3JNU0FBOwogfTsKLSAgICAKKworaW5saW5lIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QqIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChBY2Nlc3Np YmlsaXR5T2JqZWN0KiBvYmplY3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwgb2JqZWN0LT5p c0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqPihvYmplY3QpOworfQorCitpbmxpbmUgY29uc3QgQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0 IEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBv YmplY3QtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGlj X2Nhc3Q8Y29uc3QgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKKy8v IFRoaXMgd2lsbCBjYXRjaCBhbnlvbmUgZG9pbmcgYW4gdW5uZWNlc3NhcnkgY2FzdC4KK3ZvaWQg dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21p dW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJv bWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCmluZGV4IDNmZjA4MzcuLmJlMWE5ZDcgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hy b21pdW0uY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENh Y2hlQ2hyb21pdW0uY3BwCkBAIC05MCw2ICs5MCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBv c3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZp YwogICAgIGNsaWVudC0+cG9zdEFjY2Vzc2liaWxpdHlOb3RpZmljYXRpb24ob2JqLCBub3RpZmlj YXRpb24pOyAgICAgICAgCiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hh bmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFu ZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikK IHsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNo ZUF0ay5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CmluZGV4IGMzMGIwMDYuLjIxOGU2NTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0 ay9BWE9iamVjdENhY2hlQXRrLmNwcApAQCAtMjIsNiArMjIsMTAgQEAKIAogI2luY2x1ZGUgIkFj Y2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBl ckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCIKKyNpbmNsdWRl ICJHT3duUHRyLmgiCisjaW5jbHVkZSAiUmFuZ2UuaCIKKyNpbmNsdWRlICJUZXh0SXRlcmF0b3Iu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01MCw2ICs1NCwzOSBAQCB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBj b3JlT2JqZWN0LCBBWAogICAgIH0KIH0KIAorc3RhdGljIHZvaWQgZW1pdFRleHRDaGFuZ2VkKEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIG9iamVjdCwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hh bmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAg Ly8gR2V0IHRoZSBheE9iamVjdCBmb3IgdGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3Qq IHdyYXBwZXIgPSBvYmplY3QtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7Cisg ICAgaWYgKCF3cmFwcGVyIHx8ICFBVEtfSVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgLy8gU2VsZWN0IHRoZSByaWdodCBzaWduYWwgdG8gYmUgZW1pdHRlZAorICAgIEdP d25QdHI8Z2NoYXI+IGRldGFpbDsKKyAgICBzd2l0Y2ggKHRleHRDaGFuZ2UpIHsKKyAgICBjYXNl IEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3Ry ZHVwKCJ0ZXh0LWNoYW5nZWQ6Omluc2VydCIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBB WE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVw KCJ0ZXh0LWNoYW5nZWQ6OmRlbGV0ZSIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorCisgICAg aWYgKGRldGFpbCkKKyAgICAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdyYXBwZXIsIGRldGFp bC5nZXQoKSwgb2Zmc2V0LCBjb3VudCk7Cit9CisKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiBv YmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVk IGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVjaworICAgIGlmICghb2JqZWN0IHx8IGNvdW50 IDwgMSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTm9kZSogbm9kZSA9IG9iamVjdC0+bm9kZSgp OworICAgIFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBSYW5nZTo6Y3JlYXRlKG5vZGUtPmRvY3VtZW50 KCksICBQb3NpdGlvbihub2RlLT5wYXJlbnROb2RlKCksIDApLCBQb3NpdGlvbihub2RlLCAwKSk7 CisgICAgZW1pdFRleHRDaGFuZ2VkKG9iamVjdCwgdGV4dENoYW5nZSwgb2Zmc2V0ICsgVGV4dEl0 ZXJhdG9yOjpyYW5nZUxlbmd0aChyYW5nZS5nZXQoKSksIGNvdW50KTsKK30KKwogdm9pZCBBWE9i amVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqIG9s ZEZvY3VzZWRSZW5kZXIsIFJlbmRlck9iamVjdCogbmV3Rm9jdXNlZFJlbmRlcikKIHsKICAgICBS ZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gb2xkT2JqZWN0ID0gZ2V0T3JDcmVhdGUob2xkRm9j dXNlZFJlbmRlcik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2Jq ZWN0Q2FjaGVNYWMubW0gYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVN YWMubW0KaW5kZXggYTAyYmM3NS4uM2M2MDQzOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQpAQCAtMTE0LDYgKzExNCwxMCBAQCB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBv YmosIEFYTm90aWZpYwogICAgIFtvYmotPndyYXBwZXIoKSBhY2Nlc3NpYmlsaXR5UG9zdGVkTm90 aWZpY2F0aW9uOm1hY05vdGlmaWNhdGlvbl07CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmpl Y3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVu ZGVyT2JqZWN0KikKIHsKICAgICBbW1dlYkNvcmVWaWV3RmFjdG9yeSBzaGFyZWRGYWN0b3J5XSBh Y2Nlc3NpYmlsaXR5SGFuZGxlRm9jdXNDaGFuZ2VkXTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCmluZGV4IDIxZTYxZDkuLmE5YzdiMjcgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKKysr IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcApAQCAtMTAz LDYgKzEwMywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlv bihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgIE5vdGlmeVdpbkV2ZW50 KG1zYWFFdmVudCwgcGFnZS0+Y2hyb21lKCktPnBsYXRmb3JtUGFnZUNsaWVudCgpLCBPQkpJRF9D TElFTlQsIC1zdGF0aWNfY2FzdDxMT05HPihvYmotPmF4T2JqZWN0SUQoKSkpOwogfQogCit2b2lk IEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQor eworfQorCiBBWElEIEFYT2JqZWN0Q2FjaGU6OnBsYXRmb3JtR2VuZXJhdGVBWElEKCkgY29uc3QK IHsKICAgICBzdGF0aWMgQVhJRCBsYXN0VXNlZElEID0gMDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9k ZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLjY3N2MzNTMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVu ZE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgog I2luY2x1ZGUgIkFwcGVuZE5vZGVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hl LmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAt NDIsNiArNDMsMTcgQEAgQXBwZW5kTm9kZUNvbW1hbmQ6OkFwcGVuZE5vZGVDb21tYW5kKFBhc3NS ZWZQdHI8RWxlbWVudD4gcGFyZW50LCBQYXNzUmVmUHRyPE5vZGUKICAgICBBU1NFUlQobV9wYXJl bnQtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgIW1fcGFyZW50LT5hdHRhY2hlZCgpKTsKIH0KIAor c3RhdGljIHZvaWQgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MoTm9kZSogbm9k ZSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UpCit7CisgICAgU3RyaW5n IG5vZGVWYWx1ZSA9IG5vZGUtPm5vZGVWYWx1ZSgpOworICAgIHVuc2lnbmVkIGxlbiA9IG5vZGVW YWx1ZS5sZW5ndGgoKTsKKyAgICAvLyBEb24ndCBjb25zaWRlciBsaW5lYnJlYWtzIGluIHRoaXMg Y29tbWFuZAorICAgIGlmIChub2RlVmFsdWUgPT0gIlxuIikKKyAgICAgIHJldHVybjsKKworICAg IG5vZGUtPmRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmlj YXRpb24obm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAs IGxlbik7Cit9CisKIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogewogICAgIGlm ICghbV9wYXJlbnQtPmlzQ29udGVudEVkaXRhYmxlKCkgJiYgbV9wYXJlbnQtPmF0dGFjaGVkKCkp CkBAIC00OSw2ICs2MSw5IEBAIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAg ICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fcGFyZW50LT5hcHBlbmRDaGlsZCht X25vZGUuZ2V0KCksIGVjKTsKKworICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5 RW5hYmxlZCgpKQorICAgICAgICBzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyht X25vZGUuZ2V0KCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkKTsKIH0KIAogdm9pZCBB cHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU2LDYgKzcxLDEwIEBAIHZvaWQgQXBw ZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX3BhcmVudC0+aXNDb250ZW50 RWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5v dGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9i amVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBzZW5kQVhUZXh0Q2hh bmdlZElnbm9yaW5nTGluZUJyZWFrcyhtX25vZGUuZ2V0KCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4 dERlbGV0ZWQpOworCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPnJlbW92ZShl Yyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29t bWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAK aW5kZXggZjFkNzlhZi4uZmU1NzJlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9t VGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5o IgogI2luY2x1ZGUgIkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFY T2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTUzLDYgKzU0LDEwIEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBs eSgpCiAgICAgaWYgKGVjKQogICAgICAgICByZXR1cm47CiAgICAgCisgICAgLy8gTmVlZCB0byBu b3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhP YmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+ YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRl cmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0LCBtX2NvdW50KTsK KwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV9jb3VudCwgZWMpOwogfQogCkBA IC02NSw2ICs3MCw5IEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5 KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPmluc2VydERh dGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vz c2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+ bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENh Y2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fY291bnQpOwogfQogCiB9IC8vIG5hbWVz cGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9u Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAK aW5kZXggNGFhNWMzYy4uNGFjYTU3ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rp b25Db21tYW5kLmNwcApAQCAtNDQzLDExICs0NDMsNyBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNv bW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICByZXR1cm47CiAKICAgICBpZiAo c3RhcnROb2RlID09IG1fZG93bnN0cmVhbUVuZC5ub2RlKCkpIHsKLSAgICAgICAgLy8gVGhlIHNl bGVjdGlvbiB0byBkZWxldGUgaXMgYWxsIGluIG9uZSBub2RlLgotICAgICAgICBpZiAoIXN0YXJ0 Tm9kZS0+cmVuZGVyZXIoKSB8fCAoc3RhcnRPZmZzZXQgPT0gMCAmJiBtX2Rvd25zdHJlYW1FbmQu YXRMYXN0RWRpdGluZ1Bvc2l0aW9uRm9yTm9kZSgpKSkgewotICAgICAgICAgICAgLy8ganVzdCBk ZWxldGUKLSAgICAgICAgICAgIHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKLSAgICAgICAgfSBlbHNl IGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSAtIHN0YXJ0T2Zm c2V0ID4gMCkgeworICAgICAgICBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5n T2Zmc2V0KCkgLSBzdGFydE9mZnNldCA+IDApIHsKICAgICAgICAgICAgIGlmIChzdGFydE5vZGUt PmlzVGV4dE5vZGUoKSkgewogICAgICAgICAgICAgICAgIC8vIGluIGEgdGV4dCBub2RlIHRoYXQg bmVlZHMgdG8gYmUgdHJpbW1lZAogICAgICAgICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0aWNf Y2FzdDxUZXh0Kj4oc3RhcnROb2RlKTsKQEAgLTQ1Nyw2ICs0NTMsMTAgQEAgdm9pZCBEZWxldGVT ZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgICAgICAgICBt X2VuZGluZ1Bvc2l0aW9uID0gbV91cHN0cmVhbVN0YXJ0OwogICAgICAgICAgICAgfQogICAgICAg ICB9CisKKyAgICAgICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxldGUgaXMgYWxsIGluIG9uZSBu b2RlLgorICAgICAgICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8fCAoIXN0YXJ0T2Zmc2V0 ICYmIG1fZG93bnN0cmVhbUVuZC5hdExhc3RFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKCkpKQorICAg ICAgICAgICAgcmVtb3ZlTm9kZShzdGFydE5vZGUpOwogICAgIH0KICAgICBlbHNlIHsKICAgICAg ICAgYm9vbCBzdGFydE5vZGVXYXNEZXNjZW5kYW50T2ZFbmROb2RlID0gbV91cHN0cmVhbVN0YXJ0 Lm5vZGUoKS0+aXNEZXNjZW5kYW50T2YobV9kb3duc3RyZWFtRW5kLm5vZGUoKSk7CkBAIC00NzIs NiArNDcyLDkgQEAgdm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVs ZXRlKCkKICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgbm9kZSA9IHN0YXJ0 Tm9kZS0+Y2hpbGROb2RlKHN0YXJ0T2Zmc2V0KTsKICAgICAgICAgICAgIH0KKyAgICAgICAgfSBl bHNlIGlmIChzdGFydE5vZGUgPT0gbV91cHN0cmVhbUVuZC5ub2RlKCkgJiYgc3RhcnROb2RlLT5p c1RleHROb2RlKCkpIHsKKyAgICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0aWNfY2FzdDxUZXh0 Kj4obV91cHN0cmVhbUVuZC5ub2RlKCkpOworICAgICAgICAgICAgZGVsZXRlVGV4dEZyb21Ob2Rl KHRleHQsIDAsIG1fdXBzdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSk7CiAgICAg ICAgIH0KICAgICAgICAgCiAgICAgICAgIC8vIGhhbmRsZSBkZWxldGluZyBhbGwgbm9kZXMgdGhh dCBhcmUgY29tcGxldGVseSBzZWxlY3RlZApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0lu c2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9U ZXh0Tm9kZUNvbW1hbmQuY3BwCmluZGV4IDljMzQyM2EuLjliNzc2MWMgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJDb3Jl L2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAK ICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5k LmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00OCw2ICs0OSw5IEBAIHZvaWQgSW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBt X25vZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYgKEFYT2Jq ZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4 T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJl cigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fdGV4dC5sZW5n dGgoKSk7CiB9CiAKIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkK QEAgLTU1LDYgKzU5LDEwIEBAIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFw cGx5KCkKICAgICBpZiAoIW1fbm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAgICAgcmV0 dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxs eSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5 RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0 Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhU ZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1fdGV4dC5sZW5ndGgoKSk7CisKICAgICBFeGNlcHRpb25D b2RlIGVjOwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgp LCBlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNv bW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcApp bmRleCAyY2U5ODQ2Li5mYjcyMzEyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVm b3JlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNp bmNsdWRlICJJbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RD YWNoZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTUxLDYgKzUyLDkgQEAgdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9BcHBseSgp CiAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIHBhcmVudC0+aW5zZXJ0QmVmb3JlKG1faW5z ZXJ0Q2hpbGQuZ2V0KCksIG1fcmVmQ2hpbGQuZ2V0KCksIGVjKTsKKworICAgIGlmIChBWE9iamVj dENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9i amVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5zZXJ0Q2hpbGQtPnJl bmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCAwLCBtX2luc2VydENoaWxk LT5ub2RlVmFsdWUoKS5sZW5ndGgoKSk7CiB9CiAKIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1h bmQ6OmRvVW5hcHBseSgpCkBAIC01OCw2ICs2MiwxMCBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVD b21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9pbnNlcnRDaGlsZC0+aXNDb250ZW50RWRp dGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlm eSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVj dENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9i amVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5zZXJ0Q2hpbGQtPnJl bmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIDAsIG1faW5zZXJ0Q2hpbGQt Pm5vZGVWYWx1ZSgpLmxlbmd0aCgpKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9p bnNlcnRDaGlsZC0+cmVtb3ZlKGVjKTsKIH0KLS0gCjEuNy4wLjQKCg== 68201 2010-09-21 01:52:17 -0700 2010-09-22 07:10:51 -0700 Single patch for fixing this bug 0001-2010-09-20-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23163 mario RnJvbSA2YmIwODAyMmE5NDNhNmJhODVkNjFlZmEyM2ZlYmQyODhiNmE5MGE0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDIwIFNlcCAyMDEwIDE5OjExOjU2ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0yMCBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMSArKysrCiBX ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTQg KysrKy0KIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmgg IHwgICAxNyArKysrKy0KIC4uLi9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwICAg ICAgICAgICAgIHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2Fj aGVBdGsuY3BwICAgICB8ICAgMzcgKysrKysrKysrKysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkv bWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gICAgICB8ICAgIDQgKwogV2ViQ29yZS9hY2Nlc3NpYmls aXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcCAgICAgfCAgICA0ICsKIFdlYkNvcmUvZWRpdGlu Zy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgICAgICAgICAgICAgIHwgICAxOSArKysrKysKIFdlYkNv cmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCAgICAgIHwgICAgOCArKysK IFdlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcCAgICAgICAgIHwgICAx MyArKystLQogV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwICAg ICAgfCAgICA4ICsrKwogV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNw cCAgICAgICAgfCAgICA4ICsrKwogMTMgZmlsZXMgY2hhbmdlZCwgMjAzIGluc2VydGlvbnMoKyks IDcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3Jl L0NoYW5nZUxvZwppbmRleCBhY2ZmNjc1Li4xOTA2ZjU4IDEwMDY0NAotLS0gYS9XZWJDb3JlL0No YW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY2IEBACisyMDEwLTA5 LTIwIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0d0a10gb2JqZWN0OnRleHQt Y2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBhc3N3b3Jk IHRleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1 ODk4CisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwgZW1p c3Npb24gZm9yIHRoZSBHVEsgcG9ydAorCisgICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21Ob2Rl KCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KKyAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KKyAgICAgICAgb3JkZXIgdG8gYWxsb3cgYWNjZXNzaWJpbGl0eSB0byBnZXQgcHJvcGVybHkg bm90aWZpZWQgYWJvdXQgdGhlCisgICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3NpZGUg d2l0aCB0aGF0IG5vZGUuCisKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1h bmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxl R2VuZXJhbERlbGV0ZSk6CisKKyAgICAgICAgTmV3IGZ1bmN0aW9uIGluIEFYT2JqZWN0Q2FjaGUg dG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUuCisgICAgICAgIEFkZGVkIG9uZSBu ZXcgZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEKKyAg ICAgICAgdGV4dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtp bmcgc3VjaCBhCisgICAgICAgIGZ1bmN0aW9uIGRlcGVuZGFudCBvbiB0aGUgcGxhdGZvcm0tc3Bl Y2lmaWMgaW1wbGVtZW50YXRpb24sCisgICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90ZWN0 ZWQgZnVuY3Rpb24gKHByb3ZpZGVkIGEgcHJvcGVyCisgICAgICAgIGltcGxlbWVudGF0aW9uIGZv ciB0aGUgR1RLIHBvcnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KKworICAgICAg ICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpB WE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAq IGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmpl Y3RDYWNoZTo6QVhUZXh0Q2hhbmdlKTogTmV3IGVudW1lcmF0aW9uCisgICAgICAgIChXZWJDb3Jl OjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAg ICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNh dGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToK KyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRm b3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmpl Y3RDYWNoZUF0ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjplbWl0VGV4dENoYW5nZWQpOgorICAg ICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlm aWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVN YWMubW06CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBs YXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS93aW4vQVhP YmplY3RDYWNoZVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2Rl VGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisKKyAgICAgICAgTm90aWZ5IGFj Y2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdlcyBpbiBhIHRleHQgbm9kZS4KKyAgICAg ICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigpIHRv IG5vdGlmeSB3aGVuCisgICAgICAgIHRleHQgd2FzIGluc2VydGVkL2RlbGV0ZWQgd2hlbiBhcHBs eWluZy91bmFwcGx5aW5nIGEgdGV4dCBlZGl0aW9uCisgICAgICAgIGNvbW1hbmQsIGFsb25nIHdp dGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKKyAgICAgICAgY2hh bmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBhZmZl Y3RlZC4KKworICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MpOgorICAgICAg ICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29y ZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9EZWxl dGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21U ZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydEludG9U ZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2Rl Q29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRv QXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5h cHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVH ZW5lcmFsRGVsZXRlKToKKwogMjAxMC0wOS0xOSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3 LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3NzQ5 LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwIGIv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4IDkwN2JiMTUuLjM4 YWJmNGMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNw cAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKQEAgLTQ2NSw2 ICs0NjUsMTcgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChS ZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIC8vIHRvIGZpbmQgdGhlIGNvbnRhaW5lciB3aGlj aCBzaG91bGQgc2VuZCBvdXQgdGhlIG5vdGlmaWNhdGlvbi4KICAgICBwb3N0Tm90aWZpY2F0aW9u KHJlbmRlcmVyLCBBWFNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkLCBmYWxzZSk7CiB9CisKK3ZvaWQg QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiBy ZW5kZXJlciwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWdu ZWQgY291bnQpCit7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOworCisgICAg Ly8gRGVsZWdhdGUgb24gdGhlIHJpZ2h0IHBsYXRmb3JtCisgICAgQWNjZXNzaWJpbGl0eU9iamVj dCogb2JqID0gZ2V0T3JDcmVhdGUocmVuZGVyZXIpOworICAgIGlmIChvYmotPmlzQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdCgpKQorICAgICAgICBub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZp Y2F0aW9uKHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChvYmopLCB0ZXh0Q2hhbmdlLCBvZmZz ZXQsIGNvdW50KTsKK30KICNlbmRpZgogCiAjaWYgSEFWRShBQ0NFU1NJQklMSVRZKQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCBiL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKaW5kZXggMjhhNTkxNy4uNDZhZmJmMSAxMDA2NDQK LS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAorKysgYi9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCkBAIC0yNiw3ICsyNiw3IEBACiAjaWZuZGVm IEFYT2JqZWN0Q2FjaGVfaAogI2RlZmluZSBBWE9iamVjdENhY2hlX2gKIAotI2luY2x1ZGUgIkFj Y2Vzc2liaWxpdHlPYmplY3QuaCIKKyNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 LmgiCiAjaW5jbHVkZSAiVGltZXIuaCIKICNpbmNsdWRlIDxsaW1pdHMuaD4KICNpbmNsdWRlIDx3 dGYvRm9yd2FyZC5oPgpAQCAtMTI1LDggKzEyNSwxOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0 Tm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0Vs ZW1lbnQsIFBvc3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3Rp ZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24s IGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisg ICAgZW51bSBBWFRleHRDaGFuZ2UgeworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAg QVhUZXh0RGVsZXRlZCwKKyAgICB9OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNh dGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWdu ZWQgY291bnQpOworCisgICAgYm9vbCBub2RlSGFzUm9sZShOb2RlKiwgY29uc3QgQXRvbWljU3Ry aW5nJiByb2xlKTsKKwogcHJvdGVjdGVkOgogICAgIHZvaWQgcG9zdFBsYXRmb3JtTm90aWZpY2F0 aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWE5vdGlmaWNhdGlvbik7CisgICAgdm9pZCBub2Rl VGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qq LCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOwogCiBwcml2 YXRlOgogICAgIEhhc2hNYXA8QVhJRCwgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ID4gbV9v YmplY3RzOwpAQCAtMTU2LDYgKzE2Niw4IEBAIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNl bGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhP YmplY3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlv biwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVj dENhY2hlOjpwb3N0Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCos IEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGlu ZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmls aXR5T2JqZWN0KiwgQVhOb3RpZmljYXRpb24pIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNo ZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdl LCB1bnNpZ25lZCwgdW5zaWduZWQpIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpIHsgfQogaW5saW5lIHZvaWQgQVhP YmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0Kiwg UmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVTY3Jv bGxlZFRvQW5jaG9yKGNvbnN0IE5vZGUqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6 OmNvbnRlbnRDaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKaW5kZXggY2VmYWE5NC4uYjdiODVm ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuaAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oCkBAIC0zMTEsNyArMzExLDIyIEBAIHByaXZhdGU6CiAgICAgCiAgICAgbXV0YWJsZSBB Y2Nlc3NpYmlsaXR5Um9sZSBtX3JvbGVGb3JNU0FBOwogfTsKLSAgICAKKworaW5saW5lIEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QqIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChBY2Nlc3Np YmlsaXR5T2JqZWN0KiBvYmplY3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwgb2JqZWN0LT5p c0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqPihvYmplY3QpOworfQorCitpbmxpbmUgY29uc3QgQWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0 IEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBv YmplY3QtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGlj X2Nhc3Q8Y29uc3QgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKKy8v IFRoaXMgd2lsbCBjYXRjaCBhbnlvbmUgZG9pbmcgYW4gdW5uZWNlc3NhcnkgY2FzdC4KK3ZvaWQg dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QqKTsKKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdF9oCmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21p dW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJv bWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCmluZGV4IDNmZjA4MzcuLmJlMWE5ZDcgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hy b21pdW0uY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENh Y2hlQ2hyb21pdW0uY3BwCkBAIC05MCw2ICs5MCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBv c3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZp YwogICAgIGNsaWVudC0+cG9zdEFjY2Vzc2liaWxpdHlOb3RpZmljYXRpb24ob2JqLCBub3RpZmlj YXRpb24pOyAgICAgICAgCiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hh bmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFu ZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikK IHsKIH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNo ZUF0ay5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CmluZGV4IGMzMGIwMDYuLjIxOGU2NTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0 ay9BWE9iamVjdENhY2hlQXRrLmNwcApAQCAtMjIsNiArMjIsMTAgQEAKIAogI2luY2x1ZGUgIkFj Y2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBl ckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCIKKyNpbmNsdWRl ICJHT3duUHRyLmgiCisjaW5jbHVkZSAiUmFuZ2UuaCIKKyNpbmNsdWRlICJUZXh0SXRlcmF0b3Iu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC01MCw2ICs1NCwzOSBAQCB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBj b3JlT2JqZWN0LCBBWAogICAgIH0KIH0KIAorc3RhdGljIHZvaWQgZW1pdFRleHRDaGFuZ2VkKEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIG9iamVjdCwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hh bmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAg Ly8gR2V0IHRoZSBheE9iamVjdCBmb3IgdGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3Qq IHdyYXBwZXIgPSBvYmplY3QtPnBhcmVudE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7Cisg ICAgaWYgKCF3cmFwcGVyIHx8ICFBVEtfSVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgLy8gU2VsZWN0IHRoZSByaWdodCBzaWduYWwgdG8gYmUgZW1pdHRlZAorICAgIEdP d25QdHI8Z2NoYXI+IGRldGFpbDsKKyAgICBzd2l0Y2ggKHRleHRDaGFuZ2UpIHsKKyAgICBjYXNl IEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3Ry ZHVwKCJ0ZXh0LWNoYW5nZWQ6Omluc2VydCIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBB WE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVw KCJ0ZXh0LWNoYW5nZWQ6OmRlbGV0ZSIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorCisgICAg aWYgKGRldGFpbCkKKyAgICAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1lKHdyYXBwZXIsIGRldGFp bC5nZXQoKSwgb2Zmc2V0LCBjb3VudCk7Cit9CisKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiBv YmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVk IGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVjaworICAgIGlmICghb2JqZWN0IHx8IGNvdW50 IDwgMSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTm9kZSogbm9kZSA9IG9iamVjdC0+bm9kZSgp OworICAgIFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBSYW5nZTo6Y3JlYXRlKG5vZGUtPmRvY3VtZW50 KCksICBQb3NpdGlvbihub2RlLT5wYXJlbnROb2RlKCksIDApLCBQb3NpdGlvbihub2RlLCAwKSk7 CisgICAgZW1pdFRleHRDaGFuZ2VkKG9iamVjdCwgdGV4dENoYW5nZSwgb2Zmc2V0ICsgVGV4dEl0 ZXJhdG9yOjpyYW5nZUxlbmd0aChyYW5nZS5nZXQoKSksIGNvdW50KTsKK30KKwogdm9pZCBBWE9i amVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqIG9s ZEZvY3VzZWRSZW5kZXIsIFJlbmRlck9iamVjdCogbmV3Rm9jdXNlZFJlbmRlcikKIHsKICAgICBS ZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gb2xkT2JqZWN0ID0gZ2V0T3JDcmVhdGUob2xkRm9j dXNlZFJlbmRlcik7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2Jq ZWN0Q2FjaGVNYWMubW0gYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVN YWMubW0KaW5kZXggYTAyYmM3NS4uM2M2MDQzOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQpAQCAtMTE0LDYgKzExNCwxMCBAQCB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBv YmosIEFYTm90aWZpYwogICAgIFtvYmotPndyYXBwZXIoKSBhY2Nlc3NpYmlsaXR5UG9zdGVkTm90 aWZpY2F0aW9uOm1hY05vdGlmaWNhdGlvbl07CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9k ZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIHZvaWQgQVhPYmpl Y3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVu ZGVyT2JqZWN0KikKIHsKICAgICBbW1dlYkNvcmVWaWV3RmFjdG9yeSBzaGFyZWRGYWN0b3J5XSBh Y2Nlc3NpYmlsaXR5SGFuZGxlRm9jdXNDaGFuZ2VkXTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCmluZGV4IDIxZTYxZDkuLmE5YzdiMjcgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKKysr IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcApAQCAtMTAz LDYgKzEwMywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlv bihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgIE5vdGlmeVdpbkV2ZW50 KG1zYWFFdmVudCwgcGFnZS0+Y2hyb21lKCktPnBsYXRmb3JtUGFnZUNsaWVudCgpLCBPQkpJRF9D TElFTlQsIC1zdGF0aWNfY2FzdDxMT05HPihvYmotPmF4T2JqZWN0SUQoKSkpOwogfQogCit2b2lk IEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQor eworfQorCiBBWElEIEFYT2JqZWN0Q2FjaGU6OnBsYXRmb3JtR2VuZXJhdGVBWElEKCkgY29uc3QK IHsKICAgICBzdGF0aWMgQVhJRCBsYXN0VXNlZElEID0gMDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9k ZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLmVlZWNkZDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVu ZE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgog I2luY2x1ZGUgIkFwcGVuZE5vZGVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hl LmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAt NDIsNiArNDMsMTcgQEAgQXBwZW5kTm9kZUNvbW1hbmQ6OkFwcGVuZE5vZGVDb21tYW5kKFBhc3NS ZWZQdHI8RWxlbWVudD4gcGFyZW50LCBQYXNzUmVmUHRyPE5vZGUKICAgICBBU1NFUlQobV9wYXJl bnQtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgIW1fcGFyZW50LT5hdHRhY2hlZCgpKTsKIH0KIAor c3RhdGljIHZvaWQgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MoTm9kZSogbm9k ZSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UpCit7CisgICAgU3RyaW5n IG5vZGVWYWx1ZSA9IG5vZGUtPm5vZGVWYWx1ZSgpOworICAgIHVuc2lnbmVkIGxlbiA9IG5vZGVW YWx1ZS5sZW5ndGgoKTsKKyAgICAvLyBEb24ndCBjb25zaWRlciBsaW5lYnJlYWtzIGluIHRoaXMg Y29tbWFuZAorICAgIGlmIChub2RlVmFsdWUgPT0gIlxuIikKKyAgICAgIHJldHVybjsKKworICAg IG5vZGUtPmRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmlj YXRpb24obm9kZS0+cmVuZGVyZXIoKSwgdGV4dENoYW5nZSwgMCwgbGVuKTsKK30KKwogdm9pZCBB cHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiB7CiAgICAgaWYgKCFtX3BhcmVudC0+aXNDb250 ZW50RWRpdGFibGUoKSAmJiBtX3BhcmVudC0+YXR0YWNoZWQoKSkKQEAgLTQ5LDYgKzYxLDkgQEAg dm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlv bkNvZGUgZWM7CiAgICAgbV9wYXJlbnQtPmFwcGVuZENoaWxkKG1fbm9kZS5nZXQoKSwgZWMpOwor CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAg IHNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJlYWtzKG1fbm9kZS5nZXQoKSwgQVhPYmpl Y3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQpOwogfQogCiB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpk b1VuYXBwbHkoKQpAQCAtNTYsNiArNzEsMTAgQEAgdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9V bmFwcGx5KCkKICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAg ICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFj dHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2li aWxpdHlFbmFibGVkKCkpCisgICAgICAgIHNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJl YWtzKG1fbm9kZS5nZXQoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCk7CisKICAgICBF eGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+cmVtb3ZlKGVjKTsKIH0KZGlmZiAtLWdpdCBh L1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUv ZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcAppbmRleCBmMWQ3OWFmLi5mZTU3 MmUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFu ZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3Bw CkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2lu Y2x1ZGUgIlRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNTMsNiArNTQsMTAgQEAg dm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKICAgICBpZiAoZWMpCiAg ICAgICAgIHJldHVybjsKICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBh Y3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3Np YmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5v ZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNo ZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1fY291bnQpOworCiAgICAgbV9ub2RlLT5kZWxl dGVEYXRhKG1fb2Zmc2V0LCBtX2NvdW50LCBlYyk7CiB9CiAKQEAgLTY1LDYgKzcwLDkgQEAgdm9p ZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgICAgICAKICAgICBF eGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+aW5zZXJ0RGF0YShtX29mZnNldCwgbV90ZXh0 LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkK KyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlm aWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVk LCBtX29mZnNldCwgbV9jb3VudCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAt LWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcCBiL1dlYkNv cmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAppbmRleCA0YWE1YzNjLi40YWNh NTdlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCkBAIC00 NDMsMTEgKzQ0Myw3IEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJh bERlbGV0ZSgpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChzdGFydE5vZGUgPT0gbV9kb3du c3RyZWFtRW5kLm5vZGUoKSkgewotICAgICAgICAvLyBUaGUgc2VsZWN0aW9uIHRvIGRlbGV0ZSBp cyBhbGwgaW4gb25lIG5vZGUuCi0gICAgICAgIGlmICghc3RhcnROb2RlLT5yZW5kZXJlcigpIHx8 IChzdGFydE9mZnNldCA9PSAwICYmIG1fZG93bnN0cmVhbUVuZC5hdExhc3RFZGl0aW5nUG9zaXRp b25Gb3JOb2RlKCkpKSB7Ci0gICAgICAgICAgICAvLyBqdXN0IGRlbGV0ZQotICAgICAgICAgICAg cmVtb3ZlTm9kZShzdGFydE5vZGUpOwotICAgICAgICB9IGVsc2UgaWYgKG1fZG93bnN0cmVhbUVu ZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpIC0gc3RhcnRPZmZzZXQgPiAwKSB7CisgICAgICAg IGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQoKSAtIHN0YXJ0T2Zm c2V0ID4gMCkgewogICAgICAgICAgICAgaWYgKHN0YXJ0Tm9kZS0+aXNUZXh0Tm9kZSgpKSB7CiAg ICAgICAgICAgICAgICAgLy8gaW4gYSB0ZXh0IG5vZGUgdGhhdCBuZWVkcyB0byBiZSB0cmltbWVk CiAgICAgICAgICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19jYXN0PFRleHQqPihzdGFydE5v ZGUpOwpAQCAtNDU3LDYgKzQ1MywxMCBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6Omhh bmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICAgICAgICAgIG1fZW5kaW5nUG9zaXRpb24gPSBt X3Vwc3RyZWFtU3RhcnQ7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KKworICAgICAgICAvLyBU aGUgc2VsZWN0aW9uIHRvIGRlbGV0ZSBpcyBhbGwgaW4gb25lIG5vZGUuCisgICAgICAgIGlmICgh c3RhcnROb2RlLT5yZW5kZXJlcigpIHx8ICghc3RhcnRPZmZzZXQgJiYgbV9kb3duc3RyZWFtRW5k LmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUoKSkpCisgICAgICAgICAgICByZW1vdmVOb2Rl KHN0YXJ0Tm9kZSk7CiAgICAgfQogICAgIGVsc2UgewogICAgICAgICBib29sIHN0YXJ0Tm9kZVdh c0Rlc2NlbmRhbnRPZkVuZE5vZGUgPSBtX3Vwc3RyZWFtU3RhcnQubm9kZSgpLT5pc0Rlc2NlbmRh bnRPZihtX2Rvd25zdHJlYW1FbmQubm9kZSgpKTsKQEAgLTQ3Miw2ICs0NzIsOSBAQCB2b2lkIERl bGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICAgICAg fSBlbHNlIHsKICAgICAgICAgICAgICAgICBub2RlID0gc3RhcnROb2RlLT5jaGlsZE5vZGUoc3Rh cnRPZmZzZXQpOwogICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKHN0YXJ0Tm9kZSA9 PSBtX3Vwc3RyZWFtRW5kLm5vZGUoKSAmJiBzdGFydE5vZGUtPmlzVGV4dE5vZGUoKSkgeworICAg ICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19jYXN0PFRleHQqPihtX3Vwc3RyZWFtRW5kLm5v ZGUoKSk7CisgICAgICAgICAgICBkZWxldGVUZXh0RnJvbU5vZGUodGV4dCwgMCwgbV91cHN0cmVh bUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpKTsKICAgICAgICAgfQogICAgICAgICAKICAg ICAgICAgLy8gaGFuZGxlIGRlbGV0aW5nIGFsbCBub2RlcyB0aGF0IGFyZSBjb21wbGV0ZWx5IHNl bGVjdGVkCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29t bWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAK aW5kZXggOWMzNDIzYS4uOWI3NzYxYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRv VGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5o IgogI2luY2x1ZGUgIkluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUgIkFY T2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTQ4LDYgKzQ5LDkgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5 KCkKICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+aW5zZXJ0RGF0YSht X29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJp bGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2Rl VGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6 OkFYVGV4dEluc2VydGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpKTsKIH0KIAogdm9pZCBJ bnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTUsNiArNTksMTAgQEAg dm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9u b2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAg IC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0 CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAg IGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24o bV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkLCBtX29mZnNl dCwgbV90ZXh0Lmxlbmd0aCgpKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9ub2Rl LT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCksIGVjKTsKIH0KZGlmZiAtLWdp dCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCmluZGV4IDJjZTk4NDYuLmZiNzIz MTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5j cHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcApAQCAt MjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkluc2VydE5vZGVC ZWZvcmVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAi aHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNTEsNiArNTIsOSBAQCB2 b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5KCkKIAogICAgIEV4Y2VwdGlvbkNv ZGUgZWM7CiAgICAgcGFyZW50LT5pbnNlcnRCZWZvcmUobV9pbnNlcnRDaGlsZC5nZXQoKSwgbV9y ZWZDaGlsZC5nZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxp dHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRl eHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIoKSwgQVhPYmplY3RD YWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAsIG1faW5zZXJ0Q2hpbGQtPm5vZGVWYWx1ZSgpLmxlbmd0 aCgpKTsKIH0KIAogdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAg LTU4LDYgKzYyLDEwIEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSgp CiAgICAgaWYgKCFtX2luc2VydENoaWxkLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICBy ZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVh bGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxp dHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRl eHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIoKSwgQVhPYmplY3RD YWNoZTo6QVhUZXh0RGVsZXRlZCwgMCwgbV9pbnNlcnRDaGlsZC0+bm9kZVZhbHVlKCkubGVuZ3Ro KCkpOworCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX2luc2VydENoaWxkLT5yZW1vdmUo ZWMpOwogfQotLSAKMS43LjAuNAoK 68263 2010-09-21 11:05:56 -0700 2010-09-22 07:11:07 -0700 Single patch for fixing this bug 0001-2010-09-20-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 23137 mario RnJvbSA3OGJkMWExNDRjYmZkMjIyMDFkYmY5ZGQ0MGRiYzRlNzk5NWViZGVhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDIwIFNlcCAyMDEwIDE5OjExOjU2ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0yMCBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMSArKysrCiBX ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oICAgICAgICAgICAgICB8ICAgMTMg KysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaCAg fCAgIDE3ICsrKysrLQogLi4uL2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAgICAg ICAgICAgICAgfCAgICA0ICsKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNo ZUF0ay5jcHAgICAgIHwgICAzNyArKysrKysrKysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9t YWMvQVhPYmplY3RDYWNoZU1hYy5tbSAgICAgIHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwICAgICB8ICAgIDQgKwogV2ViQ29yZS9lZGl0aW5n L0FwcGVuZE5vZGVDb21tYW5kLmNwcCAgICAgICAgICAgICAgfCAgIDE5ICsrKysrKwogV2ViQ29y ZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwICAgICAgfCAgICA4ICsrKwog V2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwICAgICAgICAgfCAgIDEz ICsrKy0tCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAgICAg ICB8ICAgIDggKysrCiBXZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3Bw ICAgICAgICB8ICAgIDggKysrCiAxMyBmaWxlcyBjaGFuZ2VkLCAyMDMgaW5zZXJ0aW9ucygrKSwg NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IGFjZmY2NzUuLjE5MDZmNTggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjYgQEAKKzIwMTAtMDkt MjAgTWFyaW8gU2FuY2hleiBQcmFkYSA8bXNhbmNoZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR3RrXSBvYmplY3Q6dGV4dC1j aGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50cmllcyBhbmQgcGFzc3dvcmQg dGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4 OTgKKworICAgICAgICBJbXBsZW1lbnQgcHJvcGVyICd0ZXh0LWNoYW5nZWQnIHNpZ25hbCBlbWlz c2lvbiBmb3IgdGhlIEdUSyBwb3J0CisKKyAgICAgICAgQ2FsbCBkZWxldGVUZXh0RnJvbU5vZGUo KSB3aGVuIG5lZWRlZCB3aGlsZSByZW1vdmluZyB0ZXh0IG5vZGVzLgorICAgICAgICBEbyBpdCBl dmVuIHdoZW4gcmVtb3ZlTm9kZSgpIGlzIGdvaW5nIHRvIGJlIGNhbGxlZCBhZnRlcndhcmRzLCBp bgorICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKKyAgICAgICAgdGV4dCBiZWluZyByZW1vdmVkIGFsb25nc2lkZSB3 aXRoIHRoYXQgbm9kZS4KKworICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFu ZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVH ZW5lcmFsRGVsZXRlKToKKworICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0 byBjYWxsIHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KKyAgICAgICAgQWRkZWQgb25lIG5l dyBmdW5jdGlvbiB0byBhbGxvdyBub3RpZnlpbmcgc29tZXRoaW5nIGNoYW5nZWQgaW4gYQorICAg ICAgICB0ZXh0IG5vZGUgdGhyb3VnaCB0aGUgYXNzb2NpYXRlZCBSZW5kZXJPYmplY3QsIG1ha2lu ZyBzdWNoIGEKKyAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVj aWZpYyBpbXBsZW1lbnRhdGlvbiwKKyAgICAgICAgcHJvdmlkZWQgdGhyb3VnaCBhIHByb3RlY3Rl ZCBmdW5jdGlvbiAocHJvdmlkZWQgYSBwcm9wZXIKKyAgICAgICAgaW1wbGVtZW50YXRpb24gZm9y IHRoZSBHVEsgcG9ydCBhbmQgYSBkdW1teSBvbmUgZm9yIHRoZSBvdGhlcnMpLgorCisgICAgICAg ICogYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICog YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmg6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpBWFRleHRDaGFuZ2UpOiBOZXcgZW51bWVyYXRpb24KKyAgICAgICAgKFdlYkNvcmU6 OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAg IChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0 aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0Lmg6CisgICAgICAgIChXZWJDb3JlOjp0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QpOgor ICAgICAgICAqIGFjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZv cm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVj dENhY2hlQXRrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CisgICAg ICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZp Y2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1h Yy5tbToKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L3dpbi9BWE9i amVjdENhY2hlV2luLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVU ZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKKworICAgICAgICBOb3RpZnkgYWNj ZXNzaWJpbGl0eSB3aGVuIHNvbWV0aGluZyBjaGFuZ2VzIGluIGEgdGV4dCBub2RlLgorICAgICAg ICBDYWxsIHRvIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKCkgdG8g bm90aWZ5IHdoZW4KKyAgICAgICAgdGV4dCB3YXMgaW5zZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5 aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KKyAgICAgICAgY29tbWFuZCwgYWxvbmcgd2l0 aCB0aGUgb2Zmc2V0IGluIHRoZSBvcmlnaW5hbCB0ZXh0IHdoZXJlIHRoZQorICAgICAgICBjaGFu Z2UgdG9vayBwbGFjZSBhbmQgdGhlIG51bWJlciBvZiBjaGFyYWN0ZXJzIHRoYXQgZ290IGFmZmVj dGVkLgorCisgICAgICAgICogZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyk6CisgICAgICAg IChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3Jl OjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0 ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0SW50b1Rl eHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5vZGVD b21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNv bW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29t bWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9B cHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFw cGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdl bmVyYWxEZWxldGUpOgorCiAyMDEwLTA5LTE5ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcu Ym90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByNjc3NDku CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAgYi9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKaW5kZXggOTA3YmIxNS4uMzhh YmY0YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3Bw CisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDY1LDYg KzQ2NSwxNyBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkKFJl bmRlck9iamVjdCogcmVuZGVyZXIpCiAgICAgLy8gdG8gZmluZCB0aGUgY29udGFpbmVyIHdoaWNo IHNob3VsZCBzZW5kIG91dCB0aGUgbm90aWZpY2F0aW9uLgogICAgIHBvc3ROb3RpZmljYXRpb24o cmVuZGVyZXIsIEFYU2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQsIGZhbHNlKTsKIH0KKwordm9pZCBB WE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqIHJl bmRlcmVyLCBBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25l ZCBjb3VudCkKK3sKKyAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICByZXR1cm47CisKKyAgICAv LyBEZWxlZ2F0ZSBvbiB0aGUgcmlnaHQgcGxhdGZvcm0KKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0 KiBvYmogPSBnZXRPckNyZWF0ZShyZW5kZXJlcik7CisgICAgaWYgKG9iai0+aXNBY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0KCkpCisgICAgICAgIG5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24odG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KG9iaiksIHRleHRDaGFuZ2UsIG9mZnNl dCwgY291bnQpOworfQogI2VuZGlmCiAKICNpZiBIQVZFKEFDQ0VTU0lCSUxJVFkpCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oIGIvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAppbmRleCAyOGE1OTE3Li5iYzA5YzQyIDEwMDY0NAot LS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oCisrKyBiL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKQEAgLTI3LDYgKzI3LDcgQEAKICNkZWZpbmUg QVhPYmplY3RDYWNoZV9oCiAKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0LmgiCisjaW5j bHVkZSAiQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIgogI2luY2x1ZGUgIlRpbWVyLmgiCiAj aW5jbHVkZSA8bGltaXRzLmg+CiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KQEAgLTEyNSw4ICsx MjYsMTggQEAgcHVibGljOgogICAgIHZvaWQgcG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3Qq LCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3lu Y2hyb25vdXNseSk7CiAgICAgdm9pZCBwb3N0Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmpl Y3QqLCBEb2N1bWVudCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RU eXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKIAorICAgIGVudW0gQVhUZXh0Q2hhbmdlIHsKKyAg ICAgICAgQVhUZXh0SW5zZXJ0ZWQsCisgICAgICAgIEFYVGV4dERlbGV0ZWQsCisgICAgfTsKKwor ICAgIHZvaWQgbm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0 Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KTsKKworICAgIGJvb2wgbm9k ZUhhc1JvbGUoTm9kZSosIGNvbnN0IEF0b21pY1N0cmluZyYgcm9sZSk7CisKIHByb3RlY3RlZDoK ICAgICB2b2lkIHBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0Kiwg QVhOb3RpZmljYXRpb24pOworICAgIHZvaWQgbm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNh dGlvbihBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCBv ZmZzZXQsIHVuc2lnbmVkIGNvdW50KTsKIAogcHJpdmF0ZToKICAgICBIYXNoTWFwPEFYSUQsIFJl ZlB0cjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiA+IG1fb2JqZWN0czsKQEAgLTE1Niw2ICsxNjcsOCBA QCBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdlZChSZW5k ZXJPYmplY3QqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3ROb3RpZmljYXRp b24oUmVuZGVyT2JqZWN0KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9z dFR5cGUpIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdE5vdGlmaWNhdGlvbihB Y2Nlc3NpYmlsaXR5T2JqZWN0KiwgRG9jdW1lbnQqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0 VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0 UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9u KSB7IH0KK2lubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0 aW9uKFJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKSB7IH0K K2lubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQs IHVuc2lnbmVkKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRV SUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopIHsgfQogaW5saW5l IHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlU2Nyb2xsZWRUb0FuY2hvcihjb25zdCBOb2RlKikg eyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpjb250ZW50Q2hhbmdlZChSZW5kZXJPYmpl Y3QqKSB7IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0LmggYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oCmluZGV4IGNlZmFhOTQuLmI3Yjg1ZmUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKKysrIGIvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaApAQCAtMzExLDcgKzMxMSwyMiBA QCBwcml2YXRlOgogICAgIAogICAgIG11dGFibGUgQWNjZXNzaWJpbGl0eVJvbGUgbV9yb2xlRm9y TVNBQTsKIH07Ci0gICAgCisKK2lubGluZSBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiB0b0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqZWN0KQorewor ICAgIEFTU0VSVCghb2JqZWN0IHx8IG9iamVjdC0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KCkpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4o b2JqZWN0KTsKK30KKworaW5saW5lIGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIHRv QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChjb25zdCBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmpl Y3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwgb2JqZWN0LT5pc0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QoKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PGNvbnN0IEFjY2Vzc2liaWxpdHlS ZW5kZXJPYmplY3QqPihvYmplY3QpOworfQorCisvLyBUaGlzIHdpbGwgY2F0Y2ggYW55b25lIGRv aW5nIGFuIHVubmVjZXNzYXJ5IGNhc3QuCit2b2lkIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dChjb25zdCBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kik7CisKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKIAogI2VuZGlmIC8vIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3RfaApkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5j cHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVt LmNwcAppbmRleCAzZmYwODM3Li5iZTFhOWQ3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcAorKysgYi9XZWJDb3JlL2Fj Y2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcApAQCAtOTAsNiAr OTAsMTAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNj ZXNzaWJpbGl0eU9iamVjdCogb2JqLCBBWE5vdGlmaWMKICAgICBjbGllbnQtPnBvc3RBY2Nlc3Np YmlsaXR5Tm90aWZpY2F0aW9uKG9iaiwgbm90aWZpY2F0aW9uKTsgICAgICAgIAogfQogCit2b2lk IEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQsIHVuc2lnbmVkKQor eworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2Vk KFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcAppbmRleCBjMzBiMDA2Li4yMThlNjU5IDEw MDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3Bw CisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKQEAg LTIyLDYgKzIyLDEwIEBACiAKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0LmgiCiAjaW5j bHVkZSAiQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuaCIKKyNpbmNsdWRlICJBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmgiCisjaW5jbHVkZSAiR093blB0ci5oIgorI2luY2x1ZGUgIlJh bmdlLmgiCisjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IApAQCAtNTAsNiArNTQsMzkgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3Rp ZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQVgKICAgICB9CiB9CiAK K3N0YXRpYyB2b2lkIGVtaXRUZXh0Q2hhbmdlZChBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KiBv YmplY3QsIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBv ZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIEdldCB0aGUgYXhPYmplY3QgZm9yIHRo ZSBwYXJlbnQgb2JqZWN0CisgICAgQXRrT2JqZWN0KiB3cmFwcGVyID0gb2JqZWN0LT5wYXJlbnRP YmplY3RVbmlnbm9yZWQoKS0+d3JhcHBlcigpOworICAgIGlmICghd3JhcHBlciB8fCAhQVRLX0lT X1RFWFQod3JhcHBlcikpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIFNlbGVjdCB0aGUgcmln aHQgc2lnbmFsIHRvIGJlIGVtaXR0ZWQKKyAgICBHT3duUHRyPGdjaGFyPiBkZXRhaWw7CisgICAg c3dpdGNoICh0ZXh0Q2hhbmdlKSB7CisgICAgY2FzZSBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNl cnRlZDoKKyAgICAgICAgZGV0YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2VkOjppbnNlcnQi KSk7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRl ZDoKKyAgICAgICAgZGV0YWlsLnNldChnX3N0cmR1cCgidGV4dC1jaGFuZ2VkOjpkZWxldGUiKSk7 CisgICAgICAgIGJyZWFrOworICAgIH0KKworICAgIGlmIChkZXRhaWwpCisgICAgICAgIGdfc2ln bmFsX2VtaXRfYnlfbmFtZSh3cmFwcGVyLCBkZXRhaWwuZ2V0KCksIG9mZnNldCwgY291bnQpOwor fQorCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRp b24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCogb2JqZWN0LCBBWFRleHRDaGFuZ2UgdGV4dENo YW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkKK3sKKyAgICAvLyBTYW5pdHkg Y2hlY2sKKyAgICBpZiAoIW9iamVjdCB8fCBjb3VudCA8IDEpCisgICAgICAgIHJldHVybjsKKwor ICAgIE5vZGUqIG5vZGUgPSBvYmplY3QtPm5vZGUoKTsKKyAgICBSZWZQdHI8UmFuZ2U+IHJhbmdl ID0gUmFuZ2U6OmNyZWF0ZShub2RlLT5kb2N1bWVudCgpLCAgUG9zaXRpb24obm9kZS0+cGFyZW50 Tm9kZSgpLCAwKSwgUG9zaXRpb24obm9kZSwgMCkpOworICAgIGVtaXRUZXh0Q2hhbmdlZChvYmpl Y3QsIHRleHRDaGFuZ2UsIG9mZnNldCArIFRleHRJdGVyYXRvcjo6cmFuZ2VMZW5ndGgocmFuZ2Uu Z2V0KCkpLCBjb3VudCk7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJ RWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiBvbGRGb2N1c2VkUmVuZGVyLCBSZW5kZXJPYmpl Y3QqIG5ld0ZvY3VzZWRSZW5kZXIpCiB7CiAgICAgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ IG9sZE9iamVjdCA9IGdldE9yQ3JlYXRlKG9sZEZvY3VzZWRSZW5kZXIpOwpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tIGIvV2ViQ29yZS9h Y2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCmluZGV4IGEwMmJjNzUuLjNjNjA0 MzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1h Yy5tbQorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0K QEAgLTExNCw2ICsxMTQsMTAgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0UGxhdGZvcm1Ob3Rp ZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2JqLCBBWE5vdGlmaWMKICAgICBbb2JqLT53 cmFwcGVyKCkgYWNjZXNzaWJpbGl0eVBvc3RlZE5vdGlmaWNhdGlvbjptYWNOb3RpZmljYXRpb25d OwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24oQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQs IHVuc2lnbmVkKQoreworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZUZvY3VzZWRVSUVs ZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCosIFJlbmRlck9iamVjdCopCiB7CiAgICAgW1tXZWJD b3JlVmlld0ZhY3Rvcnkgc2hhcmVkRmFjdG9yeV0gYWNjZXNzaWJpbGl0eUhhbmRsZUZvY3VzQ2hh bmdlZF07CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2Fj aGVXaW4uY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNw cAppbmRleCAyMWU2MWQ5Li5hOWM3YjI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93 aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAKQEAgLTEwMyw2ICsxMDMsMTAgQEAgdm9pZCBBWE9iamVj dENhY2hlOjpwb3N0UGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCogb2Jq LCBBWE5vdGlmaWMKICAgICBOb3RpZnlXaW5FdmVudChtc2FhRXZlbnQsIHBhZ2UtPmNocm9tZSgp LT5wbGF0Zm9ybVBhZ2VDbGllbnQoKSwgT0JKSURfQ0xJRU5ULCAtc3RhdGljX2Nhc3Q8TE9ORz4o b2JqLT5heE9iamVjdElEKCkpKTsKIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENo YW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqLCBBWFRl eHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkKK3sKK30KKwogQVhJRCBBWE9iamVjdENhY2hl OjpwbGF0Zm9ybUdlbmVyYXRlQVhJRCgpIGNvbnN0CiB7CiAgICAgc3RhdGljIEFYSUQgbGFzdFVz ZWRJRCA9IDA7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQu Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcAppbmRleCA2MTc4NjQx Li5lZWVjZGQyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQu Y3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYg KzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJBcHBlbmROb2RlQ29tbWFu ZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5n LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTQyLDYgKzQzLDE3IEBAIEFwcGVuZE5vZGVD b21tYW5kOjpBcHBlbmROb2RlQ29tbWFuZChQYXNzUmVmUHRyPEVsZW1lbnQ+IHBhcmVudCwgUGFz c1JlZlB0cjxOb2RlCiAgICAgQVNTRVJUKG1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJsZSgpIHx8 ICFtX3BhcmVudC0+YXR0YWNoZWQoKSk7CiB9CiAKK3N0YXRpYyB2b2lkIHNlbmRBWFRleHRDaGFu Z2VkSWdub3JpbmdMaW5lQnJlYWtzKE5vZGUqIG5vZGUsIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSB0ZXh0Q2hhbmdlKQoreworICAgIFN0cmluZyBub2RlVmFsdWUgPSBub2RlLT5ub2RlVmFs dWUoKTsKKyAgICB1bnNpZ25lZCBsZW4gPSBub2RlVmFsdWUubGVuZ3RoKCk7CisgICAgLy8gRG9u J3QgY29uc2lkZXIgbGluZWJyZWFrcyBpbiB0aGlzIGNvbW1hbmQKKyAgICBpZiAobm9kZVZhbHVl ID09ICJcbiIpCisgICAgICByZXR1cm47CisKKyAgICBub2RlLT5kb2N1bWVudCgpLT5heE9iamVj dENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG5vZGUtPnJlbmRlcmVyKCksIHRl eHRDaGFuZ2UsIDAsIGxlbik7Cit9CisKIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHko KQogewogICAgIGlmICghbV9wYXJlbnQtPmlzQ29udGVudEVkaXRhYmxlKCkgJiYgbV9wYXJlbnQt PmF0dGFjaGVkKCkpCkBAIC00OSw2ICs2MSw5IEBAIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRv QXBwbHkoKQogICAgICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fcGFyZW50LT5h cHBlbmRDaGlsZChtX25vZGUuZ2V0KCksIGVjKTsKKworICAgIGlmIChBWE9iamVjdENhY2hlOjph Y2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBzZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5n TGluZUJyZWFrcyhtX25vZGUuZ2V0KCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkKTsK IH0KIAogdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKQEAgLTU2LDYgKzcxLDEw IEBAIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX3BhcmVu dC0+aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAv LyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAor ICAgIGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBz ZW5kQVhUZXh0Q2hhbmdlZElnbm9yaW5nTGluZUJyZWFrcyhtX25vZGUuZ2V0KCksIEFYT2JqZWN0 Q2FjaGU6OkFYVGV4dERlbGV0ZWQpOworCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25v ZGUtPnJlbW92ZShlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJv bVRleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2Rl Q29tbWFuZC5jcHAKaW5kZXggZjFkNzlhZi4uZmU1NzJlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGlu Zy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1 ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQuaCIKIAor I2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKQEAgLTUzLDYgKzU0LDEwIEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29t bWFuZDo6ZG9BcHBseSgpCiAgICAgaWYgKGVjKQogICAgICAgICByZXR1cm47CiAgICAgCisgICAg Ly8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQK KyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAg ZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbiht X25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0 LCBtX2NvdW50KTsKKwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV9jb3VudCwg ZWMpOwogfQogCkBAIC02NSw2ICs3MCw5IEBAIHZvaWQgRGVsZXRlRnJvbVRleHROb2RlQ29tbWFu ZDo6ZG9VbmFwcGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25v ZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0 Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2Jq ZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigp LCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQsIG1fY291bnQpOwogfQog CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRGVs ZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9u Q29tbWFuZC5jcHAKaW5kZXggNGFhNWMzYy4uNGFjYTU3ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9E ZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcApAQCAtNDQzLDExICs0NDMsNyBAQCB2b2lkIERlbGV0 ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICByZXR1cm47 CiAKICAgICBpZiAoc3RhcnROb2RlID09IG1fZG93bnN0cmVhbUVuZC5ub2RlKCkpIHsKLSAgICAg ICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxldGUgaXMgYWxsIGluIG9uZSBub2RlLgotICAgICAg ICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8fCAoc3RhcnRPZmZzZXQgPT0gMCAmJiBtX2Rv d25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bvc2l0aW9uRm9yTm9kZSgpKSkgewotICAgICAgICAg ICAgLy8ganVzdCBkZWxldGUKLSAgICAgICAgICAgIHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKLSAg ICAgICAgfSBlbHNlIGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQo KSAtIHN0YXJ0T2Zmc2V0ID4gMCkgeworICAgICAgICBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJl Y2F0ZWRFZGl0aW5nT2Zmc2V0KCkgLSBzdGFydE9mZnNldCA+IDApIHsKICAgICAgICAgICAgIGlm IChzdGFydE5vZGUtPmlzVGV4dE5vZGUoKSkgewogICAgICAgICAgICAgICAgIC8vIGluIGEgdGV4 dCBub2RlIHRoYXQgbmVlZHMgdG8gYmUgdHJpbW1lZAogICAgICAgICAgICAgICAgIFRleHQqIHRl eHQgPSBzdGF0aWNfY2FzdDxUZXh0Kj4oc3RhcnROb2RlKTsKQEAgLTQ1Nyw2ICs0NTMsMTAgQEAg dm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAg ICAgICAgICAgICBtX2VuZGluZ1Bvc2l0aW9uID0gbV91cHN0cmVhbVN0YXJ0OwogICAgICAgICAg ICAgfQogICAgICAgICB9CisKKyAgICAgICAgLy8gVGhlIHNlbGVjdGlvbiB0byBkZWxldGUgaXMg YWxsIGluIG9uZSBub2RlLgorICAgICAgICBpZiAoIXN0YXJ0Tm9kZS0+cmVuZGVyZXIoKSB8fCAo IXN0YXJ0T2Zmc2V0ICYmIG1fZG93bnN0cmVhbUVuZC5hdExhc3RFZGl0aW5nUG9zaXRpb25Gb3JO b2RlKCkpKQorICAgICAgICAgICAgcmVtb3ZlTm9kZShzdGFydE5vZGUpOwogICAgIH0KICAgICBl bHNlIHsKICAgICAgICAgYm9vbCBzdGFydE5vZGVXYXNEZXNjZW5kYW50T2ZFbmROb2RlID0gbV91 cHN0cmVhbVN0YXJ0Lm5vZGUoKS0+aXNEZXNjZW5kYW50T2YobV9kb3duc3RyZWFtRW5kLm5vZGUo KSk7CkBAIC00NzIsNiArNDcyLDkgQEAgdm9pZCBEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5k bGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAg bm9kZSA9IHN0YXJ0Tm9kZS0+Y2hpbGROb2RlKHN0YXJ0T2Zmc2V0KTsKICAgICAgICAgICAgIH0K KyAgICAgICAgfSBlbHNlIGlmIChzdGFydE5vZGUgPT0gbV91cHN0cmVhbUVuZC5ub2RlKCkgJiYg c3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKKyAgICAgICAgICAgIFRleHQqIHRleHQgPSBzdGF0 aWNfY2FzdDxUZXh0Kj4obV91cHN0cmVhbUVuZC5ub2RlKCkpOworICAgICAgICAgICAgZGVsZXRl VGV4dEZyb21Ob2RlKHRleHQsIDAsIG1fdXBzdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZz ZXQoKSk7CiAgICAgICAgIH0KICAgICAgICAgCiAgICAgICAgIC8vIGhhbmRsZSBkZWxldGluZyBh bGwgbm9kZXMgdGhhdCBhcmUgY29tcGxldGVseSBzZWxlY3RlZApkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCmluZGV4IDljMzQyM2EuLjliNzc2MWMgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAor KysgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2 LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJbnNlcnRJbnRvVGV4 dE5vZGVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAi VGV4dC5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00OCw2ICs0OSw5IEBAIHZvaWQgSW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgCiAgICAgRXhjZXB0aW9uQ29k ZSBlYzsKICAgICBtX25vZGUtPmluc2VydERhdGEobV9vZmZzZXQsIG1fdGV4dCwgZWMpOworCisg ICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRv Y3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9u b2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgbV9vZmZzZXQs IG1fdGV4dC5sZW5ndGgoKSk7CiB9CiAKIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZDo6 ZG9VbmFwcGx5KCkKQEAgLTU1LDYgKzU5LDEwIEBAIHZvaWQgSW5zZXJ0SW50b1RleHROb2RlQ29t bWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fbm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkK ICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0aGlzIGJl Zm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENhY2hlOjph Y2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hl KCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwgQVhPYmpl Y3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1fdGV4dC5sZW5ndGgoKSk7CisKICAg ICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ZGVsZXRlRGF0YShtX29mZnNldCwgbV90 ZXh0Lmxlbmd0aCgpLCBlYyk7CiB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 Tm9kZUJlZm9yZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVD b21tYW5kLmNwcAppbmRleCAyY2U5ODQ2Li5mYjcyMzEyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2Vk aXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9J bnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJj b25maWcuaCIKICNpbmNsdWRlICJJbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5oIgogCisjaW5jbHVk ZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKQEAgLTUxLDYgKzUyLDkgQEAgdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFu ZDo6ZG9BcHBseSgpCiAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIHBhcmVudC0+aW5zZXJ0 QmVmb3JlKG1faW5zZXJ0Q2hpbGQuZ2V0KCksIG1fcmVmQ2hpbGQuZ2V0KCksIGVjKTsKKworICAg IGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1 bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5z ZXJ0Q2hpbGQtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCAwLCBt X2luc2VydENoaWxkLT5ub2RlVmFsdWUoKS5sZW5ndGgoKSk7CiB9CiAKIHZvaWQgSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC01OCw2ICs2MiwxMCBAQCB2b2lkIEluc2Vy dE5vZGVCZWZvcmVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9pbnNlcnRDaGlsZC0+ aXNDb250ZW50RWRpdGFibGUoKSkKICAgICAgICAgcmV0dXJuOwogICAgICAgICAKKyAgICAvLyBO ZWVkIHRvIG5vdGlmeSB0aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAg IGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1 bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1faW5z ZXJ0Q2hpbGQtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIDAsIG1f aW5zZXJ0Q2hpbGQtPm5vZGVWYWx1ZSgpLmxlbmd0aCgpKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUg ZWM7CiAgICAgbV9pbnNlcnRDaGlsZC0+cmVtb3ZlKGVjKTsKIH0KLS0gCjEuNy4wLjQKCg== 68346 2010-09-22 01:05:09 -0700 2010-09-22 13:18:57 -0700 Single patch for fixing this bug 0001-2010-09-22-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 22907 mario RnJvbSAyYTYxMmQxYTNiMWU5NGU1ZDQxYzRmNDQ3ZTI1OTRiMDczYjNkZDRjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDIwIFNlcCAyMDEwIDE5OjExOjU2ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0yMiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNjMgKysrKysrKysrKysrKysrKysrKysKIFdlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgICAgICAgICAgIHwgICAxMCArKysKIFdl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmggICAgICAgICAgICAgIHwgICAxMiAr KysrCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oICB8 ICAgMTcgKysrKystCiAuLi4vY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcCAgICAg ICAgICAgICB8ICAgIDQgKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hl QXRrLmNwcCAgICAgfCAgIDM3ICsrKysrKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21h Yy9BWE9iamVjdENhY2hlTWFjLm1tICAgICAgfCAgICA0ICsKIFdlYkNvcmUvYWNjZXNzaWJpbGl0 eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAgICAgIHwgICAgNCArCiBXZWJDb3JlL2VkaXRpbmcv QXBwZW5kTm9kZUNvbW1hbmQuY3BwICAgICAgICAgICAgICB8ICAgMTkgKysrKysrCiBXZWJDb3Jl L2VkaXRpbmcvRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAgICAgICB8ICAgIDggKysrCiBX ZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgICAgICAgICB8ICAgMTMg KysrLS0KIFdlYkNvcmUvZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcCAgICAg IHwgICAgOCArKysKIFdlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5jcHAg ICAgICAgIHwgICAgOCArKysKIDEzIGZpbGVzIGNoYW5nZWQsIDIwMSBpbnNlcnRpb25zKCspLCA2 IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9D aGFuZ2VMb2cKaW5kZXggYWNmZjY3NS4uZjI5ZjM5MiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2NiBAQAorMjAxMC0wOS0y MiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFtHdGtdIG9iamVjdDp0ZXh0LWNo YW5nZWQgZXZlbnRzIHNob3VsZCBiZSBlbWl0dGVkIGZvciBlbnRyaWVzIGFuZCBwYXNzd29yZCB0 ZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTg5 OAorCisgICAgICAgIEltcGxlbWVudCBwcm9wZXIgJ3RleHQtY2hhbmdlZCcgc2lnbmFsIGVtaXNz aW9uIGZvciB0aGUgR1RLIHBvcnQKKworICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9kZSgp IHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCisgICAgICAgIERvIGl0IGV2 ZW4gd2hlbiByZW1vdmVOb2RlKCkgaXMgZ29pbmcgdG8gYmUgY2FsbGVkIGFmdGVyd2FyZHMsIGlu CisgICAgICAgIG9yZGVyIHRvIGFsbG93IGFjY2Vzc2liaWxpdHkgdG8gZ2V0IHByb3Blcmx5IG5v dGlmaWVkIGFib3V0IHRoZQorICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgorCisgICAgICAgICogZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5k LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdl bmVyYWxEZWxldGUpOgorCisgICAgICAgIE5ldyBmdW5jdGlvbiBpbiBBWE9iamVjdENhY2hlIHRv IGNhbGwgd2hlbiB0ZXh0IGNoYW5nZXMgaW4gYSBub2RlLgorICAgICAgICBBZGRlZCBvbmUgbmV3 IGZ1bmN0aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCisgICAg ICAgIHRleHQgbm9kZSB0aHJvdWdoIHRoZSBhc3NvY2lhdGVkIFJlbmRlck9iamVjdCwgbWFraW5n IHN1Y2ggYQorICAgICAgICBmdW5jdGlvbiBkZXBlbmRhbnQgb24gdGhlIHBsYXRmb3JtLXNwZWNp ZmljIGltcGxlbWVudGF0aW9uLAorICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVk IGZ1bmN0aW9uIChwcm92aWRlZCBhIHByb3BlcgorICAgICAgICBpbXBsZW1lbnRhdGlvbiBmb3Ig dGhlIEdUSyBwb3J0IGFuZCBhIGR1bW15IG9uZSBmb3IgdGhlIG90aGVycykuCisKKyAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QVhP YmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAgKiBh Y2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaDoKKyAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0 Q2FjaGU6OkFYVGV4dENoYW5nZSk6IE5ldyBlbnVtZXJhdGlvbgorICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24pOiBOZXcKKyAgICAgICAg KFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRp b24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuaDoKKyAgICAgICAgKFdlYkNvcmU6OnRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCk6Cisg ICAgICAgICogYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3Bw OgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9y bU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0 Q2FjaGVBdGsuY3BwOgorICAgICAgICAoV2ViQ29yZTo6ZW1pdFRleHRDaGFuZ2VkKToKKyAgICAg ICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmlj YXRpb24pOiBOZXcKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFj Lm1tOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0 Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2Jq ZWN0Q2FjaGVXaW4uY3BwOgorICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldworCisgICAgICAgIE5vdGlmeSBhY2Nl c3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5nZXMgaW4gYSB0ZXh0IG5vZGUuCisgICAgICAg IENhbGwgdG8gQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oKSB0byBu b3RpZnkgd2hlbgorICAgICAgICB0ZXh0IHdhcyBpbnNlcnRlZC9kZWxldGVkIHdoZW4gYXBwbHlp bmcvdW5hcHBseWluZyBhIHRleHQgZWRpdGlvbgorICAgICAgICBjb21tYW5kLCBhbG9uZyB3aXRo IHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQgd2hlcmUgdGhlCisgICAgICAgIGNoYW5n ZSB0b29rIHBsYWNlIGFuZCB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMgdGhhdCBnb3QgYWZmZWN0 ZWQuCisKKyAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OnNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJlYWtzKToKKyAgICAgICAg KFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6 OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvRGVsZXRl RnJvbVRleHROb2RlQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVGcm9tVGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZyb21UZXh0 Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRJbnRvVGV4 dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydEludG9UZXh0Tm9kZUNv bW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHROb2RlQ29t bWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21t YW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0Fw cGx5KToKKyAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb1VuYXBw bHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2Vu ZXJhbERlbGV0ZSk6CisKIDIwMTAtMDktMTkgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5i b3RAZ21haWwuY29tPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI2Nzc0OS4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAppbmRleCA5MDdiYjE1Li5hNThi MzI0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAK KysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCkBAIC00NjUsNiAr NDY1LDE2IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRDaGlsZHJlbkNoYW5nZWQoUmVu ZGVyT2JqZWN0KiByZW5kZXJlcikKICAgICAvLyB0byBmaW5kIHRoZSBjb250YWluZXIgd2hpY2gg c2hvdWxkIHNlbmQgb3V0IHRoZSBub3RpZmljYXRpb24uCiAgICAgcG9zdE5vdGlmaWNhdGlvbihy ZW5kZXJlciwgQVhTZWxlY3RlZENoaWxkcmVuQ2hhbmdlZCwgZmFsc2UpOwogfQorCit2b2lkIEFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCogcmVu ZGVyZXIsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVk IGNvdW50KQoreworICAgIGlmICghcmVuZGVyZXIpCisgICAgICAgIHJldHVybjsKKworICAgIC8v IERlbGVnYXRlIG9uIHRoZSByaWdodCBwbGF0Zm9ybQorICAgIEFjY2Vzc2liaWxpdHlPYmplY3Qq IG9iaiA9IGdldE9yQ3JlYXRlKHJlbmRlcmVyKTsKKyAgICBub2RlVGV4dENoYW5nZVBsYXRmb3Jt Tm90aWZpY2F0aW9uKG9iaiwgdGV4dENoYW5nZSwgb2Zmc2V0LCBjb3VudCk7Cit9CiAjZW5kaWYK IAogI2lmIEhBVkUoQUNDRVNTSUJJTElUWSkKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWE9iamVjdENhY2hlLmggYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNo ZS5oCmluZGV4IDI4YTU5MTcuLjcxODlhMzUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9BWE9iamVjdENhY2hlLmgKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0 Q2FjaGUuaApAQCAtMTI1LDggKzEyNSwxOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBwb3N0Tm90aWZp Y2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29sIHBvc3RUb0VsZW1lbnQs IFBvc3RUeXBlID0gUG9zdEFzeW5jaHJvbm91c2x5KTsKICAgICB2b2lkIHBvc3ROb3RpZmljYXRp b24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3RpZmljYXRpb24sIGJvb2wg cG9zdFRvRWxlbWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogCisgICAgZW51 bSBBWFRleHRDaGFuZ2UgeworICAgICAgICBBWFRleHRJbnNlcnRlZCwKKyAgICAgICAgQVhUZXh0 RGVsZXRlZCwKKyAgICB9OworCisgICAgdm9pZCBub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihS ZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291 bnQpOworCisgICAgYm9vbCBub2RlSGFzUm9sZShOb2RlKiwgY29uc3QgQXRvbWljU3RyaW5nJiBy b2xlKTsKKwogcHJvdGVjdGVkOgogICAgIHZvaWQgcG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFj Y2Vzc2liaWxpdHlPYmplY3QqLCBBWE5vdGlmaWNhdGlvbik7CisgICAgdm9pZCBub2RlVGV4dENo YW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFu Z2UsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgY291bnQpOwogCiBwcml2YXRlOgogICAgIEhh c2hNYXA8QVhJRCwgUmVmUHRyPEFjY2Vzc2liaWxpdHlPYmplY3Q+ID4gbV9vYmplY3RzOwpAQCAt MTU2LDYgKzE2Niw4IEBAIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OnNlbGVjdGVkQ2hpbGRy ZW5DaGFuZ2VkKFJlbmRlck9iamVjdCopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6 cG9zdE5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWE5vdGlmaWNhdGlvbiwgYm9vbCBwb3N0 VG9FbGVtZW50LCBQb3N0VHlwZSkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpwb3N0 Tm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBEb2N1bWVudCosIEFYTm90aWZpY2F0 aW9uLCBib29sIHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2Jq ZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0Kiwg QVhOb3RpZmljYXRpb24pIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRD aGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwg dW5zaWduZWQpIHsgfQoraW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1 bnNpZ25lZCwgdW5zaWduZWQpIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxl Rm9jdXNlZFVJRWxlbWVudENoYW5nZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikgeyB9 CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVTY3JvbGxlZFRvQW5jaG9yKGNvbnN0 IE5vZGUqKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmNvbnRlbnRDaGFuZ2VkKFJl bmRlck9iamVjdCopIHsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmls aXR5UmVuZGVyT2JqZWN0LmgKaW5kZXggY2VmYWE5NC4uYjdiODVmZSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaAorKysgYi9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCkBAIC0zMTEsNyAr MzExLDIyIEBAIHByaXZhdGU6CiAgICAgCiAgICAgbXV0YWJsZSBBY2Nlc3NpYmlsaXR5Um9sZSBt X3JvbGVGb3JNU0FBOwogfTsKLSAgICAKKworaW5saW5lIEFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QqIHRvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdChBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmpl Y3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwgb2JqZWN0LT5pc0FjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QoKSk7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QqPihvYmplY3QpOworfQorCitpbmxpbmUgY29uc3QgQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxpdHlPYmpl Y3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3QtPmlzQWNjZXNzaWJp bGl0eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8Y29uc3QgQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKKy8vIFRoaXMgd2lsbCBjYXRjaCBh bnlvbmUgZG9pbmcgYW4gdW5uZWNlc3NhcnkgY2FzdC4KK3ZvaWQgdG9BY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0KGNvbnN0IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqKTsKKwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdF9oCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNo cm9taXVtLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hl Q2hyb21pdW0uY3BwCmluZGV4IDNmZjA4MzcuLmZhMDliYWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCisrKyBiL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwCkBA IC05MCw2ICs5MCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNh dGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgIGNsaWVudC0+cG9z dEFjY2Vzc2liaWxpdHlOb3RpZmljYXRpb24ob2JqLCBub3RpZmljYXRpb24pOyAgICAgICAgCiB9 CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlv bihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQp Cit7Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5n ZWQoUmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikKIHsKIH0KZGlmZiAtLWdpdCBhL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAgYi9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwCmluZGV4IGMzMGIwMDYuLjFhZjQzM2Ig MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5j cHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcApA QCAtMjIsNiArMjIsMTAgQEAKIAogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3QuaCIKICNp bmNsdWRlICJBY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5oIgorI2luY2x1ZGUgIkFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaCIKKyNpbmNsdWRlICJHT3duUHRyLmgiCisjaW5jbHVkZSAi UmFuZ2UuaCIKKyNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUg ewogCkBAIC01MCw2ICs1NCwzOSBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5v dGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBjb3JlT2JqZWN0LCBBWAogICAgIH0KIH0K IAorc3RhdGljIHZvaWQgZW1pdFRleHRDaGFuZ2VkKEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qq IG9iamVjdCwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVk IG9mZnNldCwgdW5zaWduZWQgY291bnQpCit7CisgICAgLy8gR2V0IHRoZSBheE9iamVjdCBmb3Ig dGhlIHBhcmVudCBvYmplY3QKKyAgICBBdGtPYmplY3QqIHdyYXBwZXIgPSBvYmplY3QtPnBhcmVu dE9iamVjdFVuaWdub3JlZCgpLT53cmFwcGVyKCk7CisgICAgaWYgKCF3cmFwcGVyIHx8ICFBVEtf SVNfVEVYVCh3cmFwcGVyKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gU2VsZWN0IHRoZSBy aWdodCBzaWduYWwgdG8gYmUgZW1pdHRlZAorICAgIEdPd25QdHI8Z2NoYXI+IGRldGFpbDsKKyAg ICBzd2l0Y2ggKHRleHRDaGFuZ2UpIHsKKyAgICBjYXNlIEFYT2JqZWN0Q2FjaGU6OkFYVGV4dElu c2VydGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVwKCJ0ZXh0LWNoYW5nZWQ6Omluc2Vy dCIpKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBBWE9iamVjdENhY2hlOjpBWFRleHREZWxl dGVkOgorICAgICAgICBkZXRhaWwuc2V0KGdfc3RyZHVwKCJ0ZXh0LWNoYW5nZWQ6OmRlbGV0ZSIp KTsKKyAgICAgICAgYnJlYWs7CisgICAgfQorCisgICAgaWYgKGRldGFpbCkKKyAgICAgICAgZ19z aWduYWxfZW1pdF9ieV9uYW1lKHdyYXBwZXIsIGRldGFpbC5nZXQoKSwgb2Zmc2V0LCBjb3VudCk7 Cit9CisKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNh dGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QsIEFYVGV4dENoYW5nZSB0ZXh0Q2hhbmdl LCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIGNvdW50KQoreworICAgIC8vIFNhbml0eSBjaGVj aworICAgIGlmIChjb3VudCA8IDEgfHwgIW9iamVjdCB8fCAhb2JqZWN0LT5pc0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgTm9kZSogbm9kZSA9IG9i amVjdC0+bm9kZSgpOworICAgIFJlZlB0cjxSYW5nZT4gcmFuZ2UgPSBSYW5nZTo6Y3JlYXRlKG5v ZGUtPmRvY3VtZW50KCksICBQb3NpdGlvbihub2RlLT5wYXJlbnROb2RlKCksIDApLCBQb3NpdGlv bihub2RlLCAwKSk7CisgICAgZW1pdFRleHRDaGFuZ2VkKHRvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdChvYmplY3QpLCB0ZXh0Q2hhbmdlLCBvZmZzZXQgKyBUZXh0SXRlcmF0b3I6OnJhbmdlTGVu Z3RoKHJhbmdlLmdldCgpKSwgY291bnQpOworfQorCiB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRs ZUZvY3VzZWRVSUVsZW1lbnRDaGFuZ2VkKFJlbmRlck9iamVjdCogb2xkRm9jdXNlZFJlbmRlciwg UmVuZGVyT2JqZWN0KiBuZXdGb2N1c2VkUmVuZGVyKQogewogICAgIFJlZlB0cjxBY2Nlc3NpYmls aXR5T2JqZWN0PiBvbGRPYmplY3QgPSBnZXRPckNyZWF0ZShvbGRGb2N1c2VkUmVuZGVyKTsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbSBi L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQppbmRleCBhMDJi Yzc1Li5lNjUxYTc1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvbWFjL0FYT2Jq ZWN0Q2FjaGVNYWMubW0KKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENh Y2hlTWFjLm1tCkBAIC0xMTQsNiArMTE0LDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBs YXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAg ICAgW29iai0+d3JhcHBlcigpIGFjY2Vzc2liaWxpdHlQb3N0ZWROb3RpZmljYXRpb246bWFjTm90 aWZpY2F0aW9uXTsKIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRm b3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2ln bmVkLCB1bnNpZ25lZCkKK3sKK30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2Vk VUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3QqKQogewogICAgIFtb V2ViQ29yZVZpZXdGYWN0b3J5IHNoYXJlZEZhY3RvcnldIGFjY2Vzc2liaWxpdHlIYW5kbGVGb2N1 c0NoYW5nZWRdOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVj dENhY2hlV2luLmNwcCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdp bi5jcHAKaW5kZXggMjFlNjFkOS4uYjIwYjUxYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L3dpbi9BWE9iamVjdENhY2hlV2luLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCkBAIC0xMDMsNiArMTAzLDEwIEBAIHZvaWQgQVhP YmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3Qq IG9iaiwgQVhOb3RpZmljCiAgICAgTm90aWZ5V2luRXZlbnQobXNhYUV2ZW50LCBwYWdlLT5jaHJv bWUoKS0+cGxhdGZvcm1QYWdlQ2xpZW50KCksIE9CSklEX0NMSUVOVCwgLXN0YXRpY19jYXN0PExP Tkc+KG9iai0+YXhPYmplY3RJRCgpKSk7CiB9CiAKK3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRl eHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0 Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7Cit9CisKIEFYSUQgQVhPYmplY3RDYWNoZTo6 cGxhdGZvcm1HZW5lcmF0ZUFYSUQoKSBjb25zdAogewogICAgIHN0YXRpYyBBWElEIGxhc3RVc2Vk SUQgPSAwOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNw cCBiL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKaW5kZXggNjE3ODY0MS4u ZWVlY2RkMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNw cAorKysgYi9XZWJDb3JlL2VkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsy Niw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiQXBwZW5kTm9kZUNvbW1hbmQu aCIKIAorI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC00Miw2ICs0MywxNyBAQCBBcHBlbmROb2RlQ29t bWFuZDo6QXBwZW5kTm9kZUNvbW1hbmQoUGFzc1JlZlB0cjxFbGVtZW50PiBwYXJlbnQsIFBhc3NS ZWZQdHI8Tm9kZQogICAgIEFTU0VSVChtX3BhcmVudC0+aXNDb250ZW50RWRpdGFibGUoKSB8fCAh bV9wYXJlbnQtPmF0dGFjaGVkKCkpOwogfQogCitzdGF0aWMgdm9pZCBzZW5kQVhUZXh0Q2hhbmdl ZElnbm9yaW5nTGluZUJyZWFrcyhOb2RlKiBub2RlLCBBWE9iamVjdENhY2hlOjpBWFRleHRDaGFu Z2UgdGV4dENoYW5nZSkKK3sKKyAgICBTdHJpbmcgbm9kZVZhbHVlID0gbm9kZS0+bm9kZVZhbHVl KCk7CisgICAgdW5zaWduZWQgbGVuID0gbm9kZVZhbHVlLmxlbmd0aCgpOworICAgIC8vIERvbid0 IGNvbnNpZGVyIGxpbmVicmVha3MgaW4gdGhpcyBjb21tYW5kCisgICAgaWYgKG5vZGVWYWx1ZSA9 PSAiXG4iKQorICAgICAgcmV0dXJuOworCisgICAgbm9kZS0+ZG9jdW1lbnQoKS0+YXhPYmplY3RD YWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihub2RlLT5yZW5kZXJlcigpLCB0ZXh0 Q2hhbmdlLCAwLCBsZW4pOworfQorCiB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb0FwcGx5KCkK IHsKICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJsZSgpICYmIG1fcGFyZW50LT5h dHRhY2hlZCgpKQpAQCAtNDksNiArNjEsOSBAQCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb0Fw cGx5KCkKICAgICAgICAgCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX3BhcmVudC0+YXBw ZW5kQ2hpbGQobV9ub2RlLmdldCgpLCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNj ZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MobV9ub2RlLmdldCgpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCk7CiB9 CiAKIHZvaWQgQXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC01Niw2ICs3MSwxMCBA QCB2b2lkIEFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAgIGlmICghbV9wYXJlbnQt PmlzQ29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8g TmVlZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAg ICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgc2Vu ZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MobV9ub2RlLmdldCgpLCBBWE9iamVjdENh Y2hlOjpBWFRleHREZWxldGVkKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9ub2Rl LT5yZW1vdmUoZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21U ZXh0Tm9kZUNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9kZUNv bW1hbmQuY3BwCmluZGV4IGYxZDc5YWYuLmZlNTcyZTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRp dGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcv RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5jcHAKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRl ICJjb25maWcuaCIKICNpbmNsdWRlICJEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmgiCiAKKyNp bmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CkBAIC01Myw2ICs1NCwxMCBAQCB2b2lkIERlbGV0ZUZyb21UZXh0Tm9kZUNvbW1h bmQ6OmRvQXBwbHkoKQogICAgIGlmIChlYykKICAgICAgICAgcmV0dXJuOwogICAgIAorICAgIC8v IE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0Cisg ICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRv Y3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9u b2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkLCBtX29mZnNldCwg bV9jb3VudCk7CisKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9vZmZzZXQsIG1fY291bnQsIGVj KTsKIH0KIApAQCAtNjUsNiArNzAsOSBAQCB2b2lkIERlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6 OmRvVW5hcHBseSgpCiAgICAgICAgIAogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9ub2Rl LT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKworICAgIGlmIChBWE9iamVjdENh Y2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVj dENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwg QVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIG1fb2Zmc2V0LCBtX2NvdW50KTsKIH0KIAog fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0RlbGV0 ZVNlbGVjdGlvbkNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNv bW1hbmQuY3BwCmluZGV4IDRhYTVjM2MuLjRhY2E1N2UgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRp dGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRGVs ZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKQEAgLTQ0MywxMSArNDQzLDcgQEAgdm9pZCBEZWxldGVT ZWxlY3Rpb25Db21tYW5kOjpoYW5kbGVHZW5lcmFsRGVsZXRlKCkKICAgICAgICAgcmV0dXJuOwog CiAgICAgaWYgKHN0YXJ0Tm9kZSA9PSBtX2Rvd25zdHJlYW1FbmQubm9kZSgpKSB7Ci0gICAgICAg IC8vIFRoZSBzZWxlY3Rpb24gdG8gZGVsZXRlIGlzIGFsbCBpbiBvbmUgbm9kZS4KLSAgICAgICAg aWYgKCFzdGFydE5vZGUtPnJlbmRlcmVyKCkgfHwgKHN0YXJ0T2Zmc2V0ID09IDAgJiYgbV9kb3du c3RyZWFtRW5kLmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUoKSkpIHsKLSAgICAgICAgICAg IC8vIGp1c3QgZGVsZXRlCi0gICAgICAgICAgICByZW1vdmVOb2RlKHN0YXJ0Tm9kZSk7Ci0gICAg ICAgIH0gZWxzZSBpZiAobV9kb3duc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCkg LSBzdGFydE9mZnNldCA+IDApIHsKKyAgICAgICAgaWYgKG1fZG93bnN0cmVhbUVuZC5kZXByZWNh dGVkRWRpdGluZ09mZnNldCgpIC0gc3RhcnRPZmZzZXQgPiAwKSB7CiAgICAgICAgICAgICBpZiAo c3RhcnROb2RlLT5pc1RleHROb2RlKCkpIHsKICAgICAgICAgICAgICAgICAvLyBpbiBhIHRleHQg bm9kZSB0aGF0IG5lZWRzIHRvIGJlIHRyaW1tZWQKICAgICAgICAgICAgICAgICBUZXh0KiB0ZXh0 ID0gc3RhdGljX2Nhc3Q8VGV4dCo+KHN0YXJ0Tm9kZSk7CkBAIC00NTcsNiArNDUzLDEwIEBAIHZv aWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSgpCiAgICAgICAg ICAgICAgICAgbV9lbmRpbmdQb3NpdGlvbiA9IG1fdXBzdHJlYW1TdGFydDsKICAgICAgICAgICAg IH0KICAgICAgICAgfQorCisgICAgICAgIC8vIFRoZSBzZWxlY3Rpb24gdG8gZGVsZXRlIGlzIGFs bCBpbiBvbmUgbm9kZS4KKyAgICAgICAgaWYgKCFzdGFydE5vZGUtPnJlbmRlcmVyKCkgfHwgKCFz dGFydE9mZnNldCAmJiBtX2Rvd25zdHJlYW1FbmQuYXRMYXN0RWRpdGluZ1Bvc2l0aW9uRm9yTm9k ZSgpKSkKKyAgICAgICAgICAgIHJlbW92ZU5vZGUoc3RhcnROb2RlKTsKICAgICB9CiAgICAgZWxz ZSB7CiAgICAgICAgIGJvb2wgc3RhcnROb2RlV2FzRGVzY2VuZGFudE9mRW5kTm9kZSA9IG1fdXBz dHJlYW1TdGFydC5ub2RlKCktPmlzRGVzY2VuZGFudE9mKG1fZG93bnN0cmVhbUVuZC5ub2RlKCkp OwpAQCAtNDcyLDYgKzQ3Miw5IEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxl R2VuZXJhbERlbGV0ZSgpCiAgICAgICAgICAgICB9IGVsc2UgewogICAgICAgICAgICAgICAgIG5v ZGUgPSBzdGFydE5vZGUtPmNoaWxkTm9kZShzdGFydE9mZnNldCk7CiAgICAgICAgICAgICB9Cisg ICAgICAgIH0gZWxzZSBpZiAoc3RhcnROb2RlID09IG1fdXBzdHJlYW1FbmQubm9kZSgpICYmIHN0 YXJ0Tm9kZS0+aXNUZXh0Tm9kZSgpKSB7CisgICAgICAgICAgICBUZXh0KiB0ZXh0ID0gc3RhdGlj X2Nhc3Q8VGV4dCo+KG1fdXBzdHJlYW1FbmQubm9kZSgpKTsKKyAgICAgICAgICAgIGRlbGV0ZVRl eHRGcm9tTm9kZSh0ZXh0LCAwLCBtX3Vwc3RyZWFtRW5kLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0 KCkpOwogICAgICAgICB9CiAgICAgICAgIAogICAgICAgICAvLyBoYW5kbGUgZGVsZXRpbmcgYWxs IG5vZGVzIHRoYXQgYXJlIGNvbXBsZXRlbHkgc2VsZWN0ZWQKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9J bnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcAppbmRleCA5YzM0MjNhLi45Yjc3NjFjIDEwMDY0 NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAKKysr IGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCkBAIC0yNiw2 ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgIlRl eHQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNDgsNiArNDksOSBAQCB2b2lkIEluc2Vy dEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgIAogICAgIEV4Y2VwdGlvbkNvZGUg ZWM7CiAgICAgbV9ub2RlLT5pbnNlcnREYXRhKG1fb2Zmc2V0LCBtX3RleHQsIGVjKTsKKworICAg IGlmIChBWE9iamVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1 bWVudCgpLT5heE9iamVjdENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9k ZS0+cmVuZGVyZXIoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIG1fb2Zmc2V0LCBt X3RleHQubGVuZ3RoKCkpOwogfQogCiB2b2lkIEluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQ6OmRv VW5hcHBseSgpCkBAIC01NSw2ICs1OSwxMCBAQCB2b2lkIEluc2VydEludG9UZXh0Tm9kZUNvbW1h bmQ6OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX25vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkpCiAg ICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8gTmVlZCB0byBub3RpZnkgdGhpcyBiZWZv cmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNj ZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgp LT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0 Q2FjaGU6OkFYVGV4dERlbGV0ZWQsIG1fb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCkpOworCiAgICAg RXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX25vZGUtPmRlbGV0ZURhdGEobV9vZmZzZXQsIG1fdGV4 dC5sZW5ndGgoKSwgZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5v ZGVCZWZvcmVDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29t bWFuZC5jcHAKaW5kZXggMmNlOTg0Ni4uZmI3MjMxMiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0 aW5nL0luc2VydE5vZGVCZWZvcmVDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29u ZmlnLmgiCiAjaW5jbHVkZSAiSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuaCIKIAorI2luY2x1ZGUg IkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CkBAIC01MSw2ICs1Miw5IEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6 OmRvQXBwbHkoKQogCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBwYXJlbnQtPmluc2VydEJl Zm9yZShtX2luc2VydENoaWxkLmdldCgpLCBtX3JlZkNoaWxkLmdldCgpLCBlYyk7CisKKyAgICBp ZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1l bnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX2luc2Vy dENoaWxkLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNlcnRlZCwgMCwgbV9p bnNlcnRDaGlsZC0+bm9kZVZhbHVlKCkubGVuZ3RoKCkpOwogfQogCiB2b2lkIEluc2VydE5vZGVC ZWZvcmVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTgsNiArNjIsMTAgQEAgdm9pZCBJbnNlcnRO b2RlQmVmb3JlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1faW5zZXJ0Q2hpbGQtPmlz Q29udGVudEVkaXRhYmxlKCkpCiAgICAgICAgIHJldHVybjsKICAgICAgICAgCisgICAgLy8gTmVl ZCB0byBub3RpZnkgdGhpcyBiZWZvcmUgYWN0dWFsbHkgZGVsZXRpbmcgdGhlIHRleHQKKyAgICBp ZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1l bnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX2luc2Vy dENoaWxkLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkLCAwLCBtX2lu c2VydENoaWxkLT5ub2RlVmFsdWUoKS5sZW5ndGgoKSk7CisKICAgICBFeGNlcHRpb25Db2RlIGVj OwogICAgIG1faW5zZXJ0Q2hpbGQtPnJlbW92ZShlYyk7CiB9Ci0tIAoxLjcuMC40Cgo= 68427 2010-09-22 13:18:57 -0700 2010-09-22 13:43:41 -0700 Single patch for fixing this bug + Unit test 0001-2010-09-22-Mario-Sanchez-Prada-msanchez-igalia.com.patch text/plain 28566 mario RnJvbSA5Yzg0MTVjZDA5NzExOTE5ZjU2N2I5MzY5ZjVjMDljNGU0OGMyMDAyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEu Y29tPgpEYXRlOiBNb24sIDIwIFNlcCAyMDEwIDE5OjExOjU2ICswMjAwClN1YmplY3Q6IFtQQVRD SF0gMjAxMC0wOS0yMiBNYXJpbyBTYW5jaGV6IFByYWRhIDxtc2FuY2hlekBpZ2FsaWEuY29tPgoK ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCiAgICAgICAgW0d0a10gb2JqZWN0 OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBh c3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjU4OTgKCiAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAoKICAgICAgICBDYWxsIGRlbGV0ZVRleHRGcm9tTm9k ZSgpIHdoZW4gbmVlZGVkIHdoaWxlIHJlbW92aW5nIHRleHQgbm9kZXMuCiAgICAgICAgRG8gaXQg ZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJkcywg aW4KICAgICAgICBvcmRlciB0byBhbGxvdyBhY2Nlc3NpYmlsaXR5IHRvIGdldCBwcm9wZXJseSBu b3RpZmllZCBhYm91dCB0aGUKICAgICAgICB0ZXh0IGJlaW5nIHJlbW92ZWQgYWxvbmdzaWRlIHdp dGggdGhhdCBub2RlLgoKICAgICAgICAqIGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5j cHA6CiAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVy YWxEZWxldGUpOgoKICAgICAgICBOZXcgZnVuY3Rpb24gaW4gQVhPYmplY3RDYWNoZSB0byBjYWxs IHdoZW4gdGV4dCBjaGFuZ2VzIGluIGEgbm9kZS4KICAgICAgICBBZGRlZCBvbmUgbmV3IGZ1bmN0 aW9uIHRvIGFsbG93IG5vdGlmeWluZyBzb21ldGhpbmcgY2hhbmdlZCBpbiBhCiAgICAgICAgdGV4 dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBtYWtpbmcgc3VjaCBh CiAgICAgICAgZnVuY3Rpb24gZGVwZW5kYW50IG9uIHRoZSBwbGF0Zm9ybS1zcGVjaWZpYyBpbXBs ZW1lbnRhdGlvbiwKICAgICAgICBwcm92aWRlZCB0aHJvdWdoIGEgcHJvdGVjdGVkIGZ1bmN0aW9u IChwcm92aWRlZCBhIHByb3BlcgogICAgICAgIGltcGxlbWVudGF0aW9uIGZvciB0aGUgR1RLIHBv cnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KCiAgICAgICAgKiBhY2Nlc3NpYmls aXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgICogYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmg6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6OkFYVGV4dENo YW5nZSk6IE5ldyBlbnVtZXJhdGlvbgogICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldwogICAgICAgIChXZWJDb3JlOjpBWE9iamVj dENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CiAgICAgICAg KiBhY2Nlc3NpYmlsaXR5L0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QuaDoKICAgICAgICAoV2Vi Q29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KToKICAgICAgICAqIGFjY2Vzc2liaWxp dHkvY2hyb21pdW0vQVhPYmplY3RDYWNoZUNocm9taXVtLmNwcDoKICAgICAgICAoV2ViQ29yZTo6 QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbik6IE5ldwog ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHA6CiAgICAgICAg KFdlYkNvcmU6OmVtaXRUZXh0Q2hhbmdlZCk6CiAgICAgICAgKFdlYkNvcmU6OkFYT2JqZWN0Q2Fj aGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAgICAgICAqIGFj Y2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW06CiAgICAgICAgKFdlYkNvcmU6OkFY T2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24pOiBOZXcKICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwOgogICAgICAgIChX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9u KTogTmV3CgogICAgICAgIE5vdGlmeSBhY2Nlc3NpYmlsaXR5IHdoZW4gc29tZXRoaW5nIGNoYW5n ZXMgaW4gYSB0ZXh0IG5vZGUuCiAgICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbigpIHRvIG5vdGlmeSB3aGVuCiAgICAgICAgdGV4dCB3YXMgaW5z ZXJ0ZWQvZGVsZXRlZCB3aGVuIGFwcGx5aW5nL3VuYXBwbHlpbmcgYSB0ZXh0IGVkaXRpb24KICAg ICAgICBjb21tYW5kLCBhbG9uZyB3aXRoIHRoZSBvZmZzZXQgaW4gdGhlIG9yaWdpbmFsIHRleHQg d2hlcmUgdGhlCiAgICAgICAgY2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hh cmFjdGVycyB0aGF0IGdvdCBhZmZlY3RlZC4KCiAgICAgICAgKiBlZGl0aW5nL0FwcGVuZE5vZGVD b21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xp bmVCcmVha3MpOgogICAgICAgIChXZWJDb3JlOjpBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSk6 CiAgICAgICAgKFdlYkNvcmU6OkFwcGVuZE5vZGVDb21tYW5kOjpkb1VuYXBwbHkpOgogICAgICAg ICogZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKICAgICAgICAoV2ViQ29y ZTo6RGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6 OkRlbGV0ZUZyb21UZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CiAgICAgICAgKiBlZGl0aW5n L0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnRJ bnRvVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KToKICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9k ZUJlZm9yZUNvbW1hbmQuY3BwOgogICAgICAgIChXZWJDb3JlOjpJbnNlcnROb2RlQmVmb3JlQ29t bWFuZDo6ZG9BcHBseSk6CiAgICAgICAgKFdlYkNvcmU6Okluc2VydE5vZGVCZWZvcmVDb21tYW5k Ojpkb1VuYXBwbHkpOgogICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpo YW5kbGVHZW5lcmFsRGVsZXRlKToKCjIwMTAtMDktMjIgIE1hcmlvIFNhbmNoZXogUHJhZGEgIDxt c2FuY2hlekBpZ2FsaWEuY29tPgoKICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K CiAgICAgICAgW0d0a10gb2JqZWN0OnRleHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0 ZWQgZm9yIGVudHJpZXMgYW5kIHBhc3N3b3JkIHRleHQKICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU4OTgKCiAgICAgICAgTmV3IHVuaXQgdGVzdCB0byBt YWtlIHN1cmUgdGV4dC1jaGFuZ2VkIHNpZ25hbHMgYXJlIGVtaXR0ZWQKCiAgICAgICAgKiB0ZXN0 cy90ZXN0YXRrLmM6CiAgICAgICAgKHRleHRDaGFuZ2VkQ2IpOiBOZXcuIFNpZ25hbCBoYW5kbGVy IGZvciB0aGUKICAgICAgICB0ZXh0LWNoYW5nZWQ6Omluc2VydCBhbmQgdGV4dC1jaGFuZ2VkOjpk ZWxldGUgc2lnbmFscy4KICAgICAgICAoY2hlY2tUZXh0Q2hhbmdlc0FuZEJhaWxPdXQpOiBOZXcu IFNvdXJjZSBmdW5jdGlvbiB0byBjaGVjawogICAgICAgIHRoZSBnbG9iYWwgcmVzdWx0IG9mIHRo ZSB0ZXN0IGFuZCBxdWl0IGZyb20gdGhlIG1haW4gbG9vcC4KICAgICAgICAodGVzdFdlYmtpdEF0 a1RleHRDaGFuZ2VkTm90aWZpY2F0aW9ucyk6IE5ldyB0ZXN0LgogICAgICAgIChtYWluKToKLS0t CiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg NjMgKysrKysrKysrKysrKysrKysrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2Fj aGUuY3BwICAgICAgICAgICAgfCAgIDEwICsrKwogV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2Jq ZWN0Q2FjaGUuaCAgICAgICAgICAgICAgfCAgIDEyICsrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmggIHwgICAxNyArKysrKy0KIC4uLi9jaHJvbWl1 bS9BWE9iamVjdENhY2hlQ2hyb21pdW0uY3BwICAgICAgICAgICAgIHwgICAgNCArCiBXZWJDb3Jl L2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsuY3BwICAgICB8ICAgMzcgKysrKysr KysrKysKIFdlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbSAgICAg IHwgICAgNCArCiBXZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3Bw ICAgICB8ICAgIDQgKwogV2ViQ29yZS9lZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcCAgICAg ICAgICAgICAgfCAgIDE5ICsrKysrKwogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9k ZUNvbW1hbmQuY3BwICAgICAgfCAgICA4ICsrKwogV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVj dGlvbkNvbW1hbmQuY3BwICAgICAgICAgfCAgIDEzICsrKy0tCiBXZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0SW50b1RleHROb2RlQ29tbWFuZC5jcHAgICAgICB8ICAgIDggKysrCiBXZWJDb3JlL2VkaXRp bmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwICAgICAgICB8ICAgIDggKysrCiBXZWJLaXQv Z3RrL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTcgKysrKysK IFdlYktpdC9ndGsvdGVzdHMvdGVzdGF0ay5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2 NSArKysrKysrKysrKysrKysrKysrKwogMTUgZmlsZXMgY2hhbmdlZCwgMjgzIGluc2VydGlvbnMo KyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJD b3JlL0NoYW5nZUxvZwppbmRleCBhY2ZmNjc1Li5mMjlmMzkyIDEwMDY0NAotLS0gYS9XZWJDb3Jl L0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY2IEBACisyMDEw LTA5LTIyIE1hcmlvIFNhbmNoZXogUHJhZGEgPG1zYW5jaGV6QGlnYWxpYS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW0d0a10gb2JqZWN0OnRl eHQtY2hhbmdlZCBldmVudHMgc2hvdWxkIGJlIGVtaXR0ZWQgZm9yIGVudHJpZXMgYW5kIHBhc3N3 b3JkIHRleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI1ODk4CisKKyAgICAgICAgSW1wbGVtZW50IHByb3BlciAndGV4dC1jaGFuZ2VkJyBzaWduYWwg ZW1pc3Npb24gZm9yIHRoZSBHVEsgcG9ydAorCisgICAgICAgIENhbGwgZGVsZXRlVGV4dEZyb21O b2RlKCkgd2hlbiBuZWVkZWQgd2hpbGUgcmVtb3ZpbmcgdGV4dCBub2Rlcy4KKyAgICAgICAgRG8g aXQgZXZlbiB3aGVuIHJlbW92ZU5vZGUoKSBpcyBnb2luZyB0byBiZSBjYWxsZWQgYWZ0ZXJ3YXJk cywgaW4KKyAgICAgICAgb3JkZXIgdG8gYWxsb3cgYWNjZXNzaWJpbGl0eSB0byBnZXQgcHJvcGVy bHkgbm90aWZpZWQgYWJvdXQgdGhlCisgICAgICAgIHRleHQgYmVpbmcgcmVtb3ZlZCBhbG9uZ3Np ZGUgd2l0aCB0aGF0IG5vZGUuCisKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFu ZGxlR2VuZXJhbERlbGV0ZSk6CisKKyAgICAgICAgTmV3IGZ1bmN0aW9uIGluIEFYT2JqZWN0Q2Fj aGUgdG8gY2FsbCB3aGVuIHRleHQgY2hhbmdlcyBpbiBhIG5vZGUuCisgICAgICAgIEFkZGVkIG9u ZSBuZXcgZnVuY3Rpb24gdG8gYWxsb3cgbm90aWZ5aW5nIHNvbWV0aGluZyBjaGFuZ2VkIGluIGEK KyAgICAgICAgdGV4dCBub2RlIHRocm91Z2ggdGhlIGFzc29jaWF0ZWQgUmVuZGVyT2JqZWN0LCBt YWtpbmcgc3VjaCBhCisgICAgICAgIGZ1bmN0aW9uIGRlcGVuZGFudCBvbiB0aGUgcGxhdGZvcm0t c3BlY2lmaWMgaW1wbGVtZW50YXRpb24sCisgICAgICAgIHByb3ZpZGVkIHRocm91Z2ggYSBwcm90 ZWN0ZWQgZnVuY3Rpb24gKHByb3ZpZGVkIGEgcHJvcGVyCisgICAgICAgIGltcGxlbWVudGF0aW9u IGZvciB0aGUgR1RLIHBvcnQgYW5kIGEgZHVtbXkgb25lIGZvciB0aGUgb3RoZXJzKS4KKworICAg ICAgICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAgICAg ICAqIGFjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oOgorICAgICAgICAoV2ViQ29yZTo6QVhP YmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlKTogTmV3IGVudW1lcmF0aW9uCisgICAgICAgIChXZWJD b3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbik6IE5ldworICAg ICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlm aWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdC5oOgorICAgICAgICAoV2ViQ29yZTo6dG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KToKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1 bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBs YXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQVhP YmplY3RDYWNoZUF0ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjplbWl0VGV4dENoYW5nZWQpOgor ICAgICAgICAoV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5v dGlmaWNhdGlvbik6IE5ldworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2Fj aGVNYWMubW06CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5n ZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisgICAgICAgICogYWNjZXNzaWJpbGl0eS93aW4v QVhPYmplY3RDYWNoZVdpbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBWE9iamVjdENhY2hlOjpu b2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKTogTmV3CisKKyAgICAgICAgTm90aWZ5 IGFjY2Vzc2liaWxpdHkgd2hlbiBzb21ldGhpbmcgY2hhbmdlcyBpbiBhIHRleHQgbm9kZS4KKyAg ICAgICAgQ2FsbCB0byBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbigp IHRvIG5vdGlmeSB3aGVuCisgICAgICAgIHRleHQgd2FzIGluc2VydGVkL2RlbGV0ZWQgd2hlbiBh cHBseWluZy91bmFwcGx5aW5nIGEgdGV4dCBlZGl0aW9uCisgICAgICAgIGNvbW1hbmQsIGFsb25n IHdpdGggdGhlIG9mZnNldCBpbiB0aGUgb3JpZ2luYWwgdGV4dCB3aGVyZSB0aGUKKyAgICAgICAg Y2hhbmdlIHRvb2sgcGxhY2UgYW5kIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyB0aGF0IGdvdCBh ZmZlY3RlZC4KKworICAgICAgICAqIGVkaXRpbmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6c2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVha3MpOgorICAg ICAgICAoV2ViQ29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2Vi Q29yZTo6QXBwZW5kTm9kZUNvbW1hbmQ6OmRvVW5hcHBseSk6CisgICAgICAgICogZWRpdGluZy9E ZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkRlbGV0ZUZy b21UZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlRnJv bVRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KToKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydElu dG9UZXh0Tm9kZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0SW50b1RleHRO b2RlQ29tbWFuZDo6ZG9BcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpJbnNlcnRJbnRvVGV4dE5v ZGVDb21tYW5kOjpkb1VuYXBwbHkpOgorICAgICAgICAqIGVkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9y ZUNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6 OmRvQXBwbHkpOgorICAgICAgICAoV2ViQ29yZTo6SW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6OmRv VW5hcHBseSk6CisgICAgICAgIChXZWJDb3JlOjpEZWxldGVTZWxlY3Rpb25Db21tYW5kOjpoYW5k bGVHZW5lcmFsRGVsZXRlKToKKwogMjAxMC0wOS0xOSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2 aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjY3 NzQ5LgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3Bw IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4IDkwN2JiMTUu LmE1OGIzMjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hl LmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKQEAgLTQ2 NSw2ICs0NjUsMTYgQEAgdm9pZCBBWE9iamVjdENhY2hlOjpzZWxlY3RlZENoaWxkcmVuQ2hhbmdl ZChSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIC8vIHRvIGZpbmQgdGhlIGNvbnRhaW5lciB3 aGljaCBzaG91bGQgc2VuZCBvdXQgdGhlIG5vdGlmaWNhdGlvbi4KICAgICBwb3N0Tm90aWZpY2F0 aW9uKHJlbmRlcmVyLCBBWFNlbGVjdGVkQ2hpbGRyZW5DaGFuZ2VkLCBmYWxzZSk7CiB9CisKK3Zv aWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24oUmVuZGVyT2JqZWN0 KiByZW5kZXJlciwgQVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UsIHVuc2lnbmVkIG9mZnNldCwgdW5z aWduZWQgY291bnQpCit7CisgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgcmV0dXJuOworCisg ICAgLy8gRGVsZWdhdGUgb24gdGhlIHJpZ2h0IHBsYXRmb3JtCisgICAgQWNjZXNzaWJpbGl0eU9i amVjdCogb2JqID0gZ2V0T3JDcmVhdGUocmVuZGVyZXIpOworICAgIG5vZGVUZXh0Q2hhbmdlUGxh dGZvcm1Ob3RpZmljYXRpb24ob2JqLCB0ZXh0Q2hhbmdlLCBvZmZzZXQsIGNvdW50KTsKK30KICNl bmRpZgogCiAjaWYgSEFWRShBQ0NFU1NJQklMSVRZKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmgKaW5kZXggMjhhNTkxNy4uNzE4OWEzNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhP YmplY3RDYWNoZS5oCkBAIC0xMjUsOCArMTI1LDE4IEBAIHB1YmxpYzoKICAgICB2b2lkIHBvc3RO b3RpZmljYXRpb24oUmVuZGVyT2JqZWN0KiwgQVhOb3RpZmljYXRpb24sIGJvb2wgcG9zdFRvRWxl bWVudCwgUG9zdFR5cGUgPSBQb3N0QXN5bmNocm9ub3VzbHkpOwogICAgIHZvaWQgcG9zdE5vdGlm aWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiwgRG9jdW1lbnQqLCBBWE5vdGlmaWNhdGlvbiwg Ym9vbCBwb3N0VG9FbGVtZW50LCBQb3N0VHlwZSA9IFBvc3RBc3luY2hyb25vdXNseSk7CiAKKyAg ICBlbnVtIEFYVGV4dENoYW5nZSB7CisgICAgICAgIEFYVGV4dEluc2VydGVkLAorICAgICAgICBB WFRleHREZWxldGVkLAorICAgIH07CisKKyAgICB2b2lkIG5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0 aW9uKFJlbmRlck9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25l ZCBjb3VudCk7CisKKyAgICBib29sIG5vZGVIYXNSb2xlKE5vZGUqLCBjb25zdCBBdG9taWNTdHJp bmcmIHJvbGUpOworCiBwcm90ZWN0ZWQ6CiAgICAgdm9pZCBwb3N0UGxhdGZvcm1Ob3RpZmljYXRp b24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYTm90aWZpY2F0aW9uKTsKKyAgICB2b2lkIG5vZGVU ZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4 dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCk7CiAKIHByaXZhdGU6CiAg ICAgSGFzaE1hcDxBWElELCBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gPiBtX29iamVjdHM7 CkBAIC0xNTYsNiArMTY2LDggQEAgaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6c2VsZWN0ZWRD aGlsZHJlbkNoYW5nZWQoUmVuZGVyT2JqZWN0KikgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENh Y2hlOjpwb3N0Tm90aWZpY2F0aW9uKFJlbmRlck9iamVjdCosIEFYTm90aWZpY2F0aW9uLCBib29s IHBvc3RUb0VsZW1lbnQsIFBvc3RUeXBlKSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6 OnBvc3ROb3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIERvY3VtZW50KiwgQVhOb3Rp ZmljYXRpb24sIGJvb2wgcG9zdFRvRWxlbWVudCwgUG9zdFR5cGUpIHsgfQogaW5saW5lIHZvaWQg QVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmpl Y3QqLCBBWE5vdGlmaWNhdGlvbikgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2Rl VGV4dENoYW5nZU5vdGlmaWNhdGlvbihSZW5kZXJPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2ln bmVkLCB1bnNpZ25lZCkgeyB9CitpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENo YW5nZVBsYXRmb3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFu Z2UsIHVuc2lnbmVkLCB1bnNpZ25lZCkgeyB9CiBpbmxpbmUgdm9pZCBBWE9iamVjdENhY2hlOjpo YW5kbGVGb2N1c2VkVUlFbGVtZW50Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3Qq KSB7IH0KIGlubGluZSB2b2lkIEFYT2JqZWN0Q2FjaGU6OmhhbmRsZVNjcm9sbGVkVG9BbmNob3Io Y29uc3QgTm9kZSopIHsgfQogaW5saW5lIHZvaWQgQVhPYmplY3RDYWNoZTo6Y29udGVudENoYW5n ZWQoUmVuZGVyT2JqZWN0KikgeyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QuaAppbmRleCBjZWZhYTk0Li5iN2I4NWZlIDEwMDY0NAotLS0g YS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oCisrKyBi L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKQEAgLTMx MSw3ICszMTEsMjIgQEAgcHJpdmF0ZToKICAgICAKICAgICBtdXRhYmxlIEFjY2Vzc2liaWxpdHlS b2xlIG1fcm9sZUZvck1TQUE7CiB9OwotICAgIAorCitpbmxpbmUgQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdCogdG9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KEFjY2Vzc2liaWxpdHlPYmplY3Qq IG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3QtPmlzQWNjZXNzaWJpbGl0 eVJlbmRlck9iamVjdCgpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVJl bmRlck9iamVjdCo+KG9iamVjdCk7Cit9CisKK2lubGluZSBjb25zdCBBY2Nlc3NpYmlsaXR5UmVu ZGVyT2JqZWN0KiB0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoY29uc3QgQWNjZXNzaWJpbGl0 eU9iamVjdCogb2JqZWN0KQoreworICAgIEFTU0VSVCghb2JqZWN0IHx8IG9iamVjdC0+aXNBY2Nl c3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxjb25zdCBB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4ob2JqZWN0KTsKK30KKworLy8gVGhpcyB3aWxsIGNh dGNoIGFueW9uZSBkb2luZyBhbiB1bm5lY2Vzc2FyeSBjYXN0Lgordm9pZCB0b0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QoY29uc3QgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCopOworCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 X2gKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9jaHJvbWl1bS9BWE9iamVjdENh Y2hlQ2hyb21pdW0uY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0 Q2FjaGVDaHJvbWl1bS5jcHAKaW5kZXggM2ZmMDgzNy4uZmEwOWJhYyAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5jcHAKKysr IGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2Nocm9taXVtL0FYT2JqZWN0Q2FjaGVDaHJvbWl1bS5j cHAKQEAgLTkwLDYgKzkwLDEwIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRmb3JtTm90 aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIG9iaiwgQVhOb3RpZmljCiAgICAgY2xpZW50 LT5wb3N0QWNjZXNzaWJpbGl0eU5vdGlmaWNhdGlvbihvYmosIG5vdGlmaWNhdGlvbik7ICAgICAg ICAKIH0KIAordm9pZCBBWE9iamVjdENhY2hlOjpub2RlVGV4dENoYW5nZVBsYXRmb3JtTm90aWZp Y2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqLCBBWFRleHRDaGFuZ2UsIHVuc2lnbmVkLCB1bnNp Z25lZCkKK3sKK30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50 Q2hhbmdlZChSZW5kZXJPYmplY3QqLCBSZW5kZXJPYmplY3QqKQogewogfQpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hlQXRrLmNwcCBiL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9ndGsvQVhPYmplY3RDYWNoZUF0ay5jcHAKaW5kZXggYzMwYjAwNi4uYTRl YTg3YyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BWE9iamVjdENhY2hl QXRrLmNwcAorKysgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FYT2JqZWN0Q2FjaGVBdGsu Y3BwCkBAIC0yMiw2ICsyMiwxMCBAQAogCiAjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eU9iamVjdC5o IgogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmgiCisjaW5jbHVkZSAi QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIgorI2luY2x1ZGUgIkdPd25QdHIuaCIKKyNpbmNs dWRlICJSYW5nZS5oIgorI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKQEAgLTUwLDYgKzU0LDM5IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cG9zdFBsYXRm b3JtTm90aWZpY2F0aW9uKEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmVPYmplY3QsIEFYCiAgICAg fQogfQogCitzdGF0aWMgdm9pZCBlbWl0VGV4dENoYW5nZWQoQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdCogb2JqZWN0LCBBWE9iamVjdENhY2hlOjpBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5z aWduZWQgb2Zmc2V0LCB1bnNpZ25lZCBjb3VudCkKK3sKKyAgICAvLyBHZXQgdGhlIGF4T2JqZWN0 IGZvciB0aGUgcGFyZW50IG9iamVjdAorICAgIEF0a09iamVjdCogd3JhcHBlciA9IG9iamVjdC0+ cGFyZW50T2JqZWN0VW5pZ25vcmVkKCktPndyYXBwZXIoKTsKKyAgICBpZiAoIXdyYXBwZXIgfHwg IUFUS19JU19URVhUKHdyYXBwZXIpKQorICAgICAgICByZXR1cm47CisKKyAgICAvLyBTZWxlY3Qg dGhlIHJpZ2h0IHNpZ25hbCB0byBiZSBlbWl0dGVkCisgICAgQ1N0cmluZyBkZXRhaWw7CisgICAg c3dpdGNoICh0ZXh0Q2hhbmdlKSB7CisgICAgY2FzZSBBWE9iamVjdENhY2hlOjpBWFRleHRJbnNl cnRlZDoKKyAgICAgICAgZGV0YWlsID0gInRleHQtY2hhbmdlZDo6aW5zZXJ0IjsKKyAgICAgICAg YnJlYWs7CisgICAgY2FzZSBBWE9iamVjdENhY2hlOjpBWFRleHREZWxldGVkOgorICAgICAgICBk ZXRhaWwgPSAidGV4dC1jaGFuZ2VkOjpkZWxldGUiOworICAgICAgICBicmVhazsKKyAgICB9CisK KyAgICBpZiAoIWRldGFpbC5pc051bGwoKSkKKyAgICAgICAgZ19zaWduYWxfZW1pdF9ieV9uYW1l KHdyYXBwZXIsIGRldGFpbC5kYXRhKCksIG9mZnNldCwgY291bnQpOworfQorCit2b2lkIEFYT2Jq ZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1Ob3RpZmljYXRpb24oQWNjZXNzaWJpbGl0 eU9iamVjdCogb2JqZWN0LCBBWFRleHRDaGFuZ2UgdGV4dENoYW5nZSwgdW5zaWduZWQgb2Zmc2V0 LCB1bnNpZ25lZCBjb3VudCkKK3sKKyAgICAvLyBTYW5pdHkgY2hlY2sKKyAgICBpZiAoY291bnQg PCAxIHx8ICFvYmplY3QgfHwgIW9iamVjdC0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkp CisgICAgICAgIHJldHVybjsKKworICAgIE5vZGUqIG5vZGUgPSBvYmplY3QtPm5vZGUoKTsKKyAg ICBSZWZQdHI8UmFuZ2U+IHJhbmdlID0gUmFuZ2U6OmNyZWF0ZShub2RlLT5kb2N1bWVudCgpLCAg UG9zaXRpb24obm9kZS0+cGFyZW50Tm9kZSgpLCAwKSwgUG9zaXRpb24obm9kZSwgMCkpOworICAg IGVtaXRUZXh0Q2hhbmdlZCh0b0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3Qob2JqZWN0KSwgdGV4 dENoYW5nZSwgb2Zmc2V0ICsgVGV4dEl0ZXJhdG9yOjpyYW5nZUxlbmd0aChyYW5nZS5nZXQoKSks IGNvdW50KTsKK30KKwogdm9pZCBBWE9iamVjdENhY2hlOjpoYW5kbGVGb2N1c2VkVUlFbGVtZW50 Q2hhbmdlZChSZW5kZXJPYmplY3QqIG9sZEZvY3VzZWRSZW5kZXIsIFJlbmRlck9iamVjdCogbmV3 Rm9jdXNlZFJlbmRlcikKIHsKICAgICBSZWZQdHI8QWNjZXNzaWJpbGl0eU9iamVjdD4gb2xkT2Jq ZWN0ID0gZ2V0T3JDcmVhdGUob2xkRm9jdXNlZFJlbmRlcik7CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0gYi9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvbWFjL0FYT2JqZWN0Q2FjaGVNYWMubW0KaW5kZXggYTAyYmM3NS4uZTY1MWE3NSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L21hYy9BWE9iamVjdENhY2hlTWFjLm1tCisr KyBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9tYWMvQVhPYmplY3RDYWNoZU1hYy5tbQpAQCAtMTE0 LDYgKzExNCwxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQbGF0Zm9ybU5vdGlmaWNhdGlv bihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwogICAgIFtvYmotPndyYXBwZXIo KSBhY2Nlc3NpYmlsaXR5UG9zdGVkTm90aWZpY2F0aW9uOm1hY05vdGlmaWNhdGlvbl07CiB9CiAK K3ZvaWQgQVhPYmplY3RDYWNoZTo6bm9kZVRleHRDaGFuZ2VQbGF0Zm9ybU5vdGlmaWNhdGlvbihB Y2Nlc3NpYmlsaXR5T2JqZWN0KiwgQVhUZXh0Q2hhbmdlLCB1bnNpZ25lZCwgdW5zaWduZWQpCit7 Cit9CisKIHZvaWQgQVhPYmplY3RDYWNoZTo6aGFuZGxlRm9jdXNlZFVJRWxlbWVudENoYW5nZWQo UmVuZGVyT2JqZWN0KiwgUmVuZGVyT2JqZWN0KikKIHsKICAgICBbW1dlYkNvcmVWaWV3RmFjdG9y eSBzaGFyZWRGYWN0b3J5XSBhY2Nlc3NpYmlsaXR5SGFuZGxlRm9jdXNDaGFuZ2VkXTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmplY3RDYWNoZVdpbi5jcHAgYi9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvd2luL0FYT2JqZWN0Q2FjaGVXaW4uY3BwCmluZGV4IDIxZTYx ZDkuLmIyMGI1MWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS93aW4vQVhPYmpl Y3RDYWNoZVdpbi5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L3dpbi9BWE9iamVjdENh Y2hlV2luLmNwcApAQCAtMTAzLDYgKzEwMywxMCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OnBvc3RQ bGF0Zm9ybU5vdGlmaWNhdGlvbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmosIEFYTm90aWZpYwog ICAgIE5vdGlmeVdpbkV2ZW50KG1zYWFFdmVudCwgcGFnZS0+Y2hyb21lKCktPnBsYXRmb3JtUGFn ZUNsaWVudCgpLCBPQkpJRF9DTElFTlQsIC1zdGF0aWNfY2FzdDxMT05HPihvYmotPmF4T2JqZWN0 SUQoKSkpOwogfQogCit2b2lkIEFYT2JqZWN0Q2FjaGU6Om5vZGVUZXh0Q2hhbmdlUGxhdGZvcm1O b3RpZmljYXRpb24oQWNjZXNzaWJpbGl0eU9iamVjdCosIEFYVGV4dENoYW5nZSwgdW5zaWduZWQs IHVuc2lnbmVkKQoreworfQorCiBBWElEIEFYT2JqZWN0Q2FjaGU6OnBsYXRmb3JtR2VuZXJhdGVB WElEKCkgY29uc3QKIHsKICAgICBzdGF0aWMgQVhJRCBsYXN0VXNlZElEID0gMDsKZGlmZiAtLWdp dCBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRp bmcvQXBwZW5kTm9kZUNvbW1hbmQuY3BwCmluZGV4IDYxNzg2NDEuLmVlZWNkZDIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZWRpdGluZy9BcHBlbmROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9l ZGl0aW5nL0FwcGVuZE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUg ImNvbmZpZy5oIgogI2luY2x1ZGUgIkFwcGVuZE5vZGVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJB WE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdl YkNvcmUgewpAQCAtNDIsNiArNDMsMTcgQEAgQXBwZW5kTm9kZUNvbW1hbmQ6OkFwcGVuZE5vZGVD b21tYW5kKFBhc3NSZWZQdHI8RWxlbWVudD4gcGFyZW50LCBQYXNzUmVmUHRyPE5vZGUKICAgICBB U1NFUlQobV9wYXJlbnQtPmlzQ29udGVudEVkaXRhYmxlKCkgfHwgIW1fcGFyZW50LT5hdHRhY2hl ZCgpKTsKIH0KIAorc3RhdGljIHZvaWQgc2VuZEFYVGV4dENoYW5nZWRJZ25vcmluZ0xpbmVCcmVh a3MoTm9kZSogbm9kZSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0Q2hhbmdlIHRleHRDaGFuZ2UpCit7 CisgICAgU3RyaW5nIG5vZGVWYWx1ZSA9IG5vZGUtPm5vZGVWYWx1ZSgpOworICAgIHVuc2lnbmVk IGxlbiA9IG5vZGVWYWx1ZS5sZW5ndGgoKTsKKyAgICAvLyBEb24ndCBjb25zaWRlciBsaW5lYnJl YWtzIGluIHRoaXMgY29tbWFuZAorICAgIGlmIChub2RlVmFsdWUgPT0gIlxuIikKKyAgICAgIHJl dHVybjsKKworICAgIG5vZGUtPmRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRD aGFuZ2VOb3RpZmljYXRpb24obm9kZS0+cmVuZGVyZXIoKSwgdGV4dENoYW5nZSwgMCwgbGVuKTsK K30KKwogdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiB7CiAgICAgaWYgKCFtX3Bh cmVudC0+aXNDb250ZW50RWRpdGFibGUoKSAmJiBtX3BhcmVudC0+YXR0YWNoZWQoKSkKQEAgLTQ5 LDYgKzYxLDkgQEAgdm9pZCBBcHBlbmROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgICAgIAog ICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgbV9wYXJlbnQtPmFwcGVuZENoaWxkKG1fbm9kZS5n ZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVk KCkpCisgICAgICAgIHNlbmRBWFRleHRDaGFuZ2VkSWdub3JpbmdMaW5lQnJlYWtzKG1fbm9kZS5n ZXQoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQpOwogfQogCiB2b2lkIEFwcGVuZE5v ZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTYsNiArNzEsMTAgQEAgdm9pZCBBcHBlbmROb2Rl Q29tbWFuZDo6ZG9VbmFwcGx5KCkKICAgICBpZiAoIW1fcGFyZW50LT5pc0NvbnRlbnRFZGl0YWJs ZSgpKQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRo aXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2Fj aGU6OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIHNlbmRBWFRleHRDaGFuZ2VkSWdu b3JpbmdMaW5lQnJlYWtzKG1fbm9kZS5nZXQoKSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRl ZCk7CisKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+cmVtb3ZlKGVjKTsKIH0K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNw cCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kLmNwcAppbmRleCBm MWQ3OWFmLi5mZTU3MmUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlRnJvbVRl eHROb2RlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZUZyb21UZXh0Tm9k ZUNvbW1hbmQuY3BwCkBAIC0yNiw2ICsyNiw3IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5j bHVkZSAiRGVsZXRlRnJvbVRleHROb2RlQ29tbWFuZC5oIgogCisjaW5jbHVkZSAiQVhPYmplY3RD YWNoZS5oIgogI2luY2x1ZGUgIlRleHQuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNTMs NiArNTQsMTAgQEAgdm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKICAg ICBpZiAoZWMpCiAgICAgICAgIHJldHVybjsKICAgICAKKyAgICAvLyBOZWVkIHRvIG5vdGlmeSB0 aGlzIGJlZm9yZSBhY3R1YWxseSBkZWxldGluZyB0aGUgdGV4dAorICAgIGlmIChBWE9iamVjdENh Y2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKQorICAgICAgICBkb2N1bWVudCgpLT5heE9iamVj dENhY2hlKCktPm5vZGVUZXh0Q2hhbmdlTm90aWZpY2F0aW9uKG1fbm9kZS0+cmVuZGVyZXIoKSwg QVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgbV9vZmZzZXQsIG1fY291bnQpOworCiAgICAg bV9ub2RlLT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX2NvdW50LCBlYyk7CiB9CiAKQEAgLTY1LDYg KzcwLDkgQEAgdm9pZCBEZWxldGVGcm9tVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQogICAg ICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+aW5zZXJ0RGF0YShtX29m ZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNoZTo6YWNjZXNzaWJpbGl0 eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5ub2RlVGV4 dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFYT2JqZWN0Q2FjaGU6OkFY VGV4dEluc2VydGVkLCBtX29mZnNldCwgbV9jb3VudCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdl YkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5k LmNwcCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAppbmRleCA0 YWE1YzNjLi40YWNhNTdlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0 aW9uQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1h bmQuY3BwCkBAIC00NDMsMTEgKzQ0Myw3IEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6 aGFuZGxlR2VuZXJhbERlbGV0ZSgpCiAgICAgICAgIHJldHVybjsKIAogICAgIGlmIChzdGFydE5v ZGUgPT0gbV9kb3duc3RyZWFtRW5kLm5vZGUoKSkgewotICAgICAgICAvLyBUaGUgc2VsZWN0aW9u IHRvIGRlbGV0ZSBpcyBhbGwgaW4gb25lIG5vZGUuCi0gICAgICAgIGlmICghc3RhcnROb2RlLT5y ZW5kZXJlcigpIHx8IChzdGFydE9mZnNldCA9PSAwICYmIG1fZG93bnN0cmVhbUVuZC5hdExhc3RF ZGl0aW5nUG9zaXRpb25Gb3JOb2RlKCkpKSB7Ci0gICAgICAgICAgICAvLyBqdXN0IGRlbGV0ZQot ICAgICAgICAgICAgcmVtb3ZlTm9kZShzdGFydE5vZGUpOwotICAgICAgICB9IGVsc2UgaWYgKG1f ZG93bnN0cmVhbUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpIC0gc3RhcnRPZmZzZXQgPiAw KSB7CisgICAgICAgIGlmIChtX2Rvd25zdHJlYW1FbmQuZGVwcmVjYXRlZEVkaXRpbmdPZmZzZXQo KSAtIHN0YXJ0T2Zmc2V0ID4gMCkgewogICAgICAgICAgICAgaWYgKHN0YXJ0Tm9kZS0+aXNUZXh0 Tm9kZSgpKSB7CiAgICAgICAgICAgICAgICAgLy8gaW4gYSB0ZXh0IG5vZGUgdGhhdCBuZWVkcyB0 byBiZSB0cmltbWVkCiAgICAgICAgICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19jYXN0PFRl eHQqPihzdGFydE5vZGUpOwpAQCAtNDU3LDYgKzQ1MywxMCBAQCB2b2lkIERlbGV0ZVNlbGVjdGlv bkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQogICAgICAgICAgICAgICAgIG1fZW5kaW5n UG9zaXRpb24gPSBtX3Vwc3RyZWFtU3RhcnQ7CiAgICAgICAgICAgICB9CiAgICAgICAgIH0KKwor ICAgICAgICAvLyBUaGUgc2VsZWN0aW9uIHRvIGRlbGV0ZSBpcyBhbGwgaW4gb25lIG5vZGUuCisg ICAgICAgIGlmICghc3RhcnROb2RlLT5yZW5kZXJlcigpIHx8ICghc3RhcnRPZmZzZXQgJiYgbV9k b3duc3RyZWFtRW5kLmF0TGFzdEVkaXRpbmdQb3NpdGlvbkZvck5vZGUoKSkpCisgICAgICAgICAg ICByZW1vdmVOb2RlKHN0YXJ0Tm9kZSk7CiAgICAgfQogICAgIGVsc2UgewogICAgICAgICBib29s IHN0YXJ0Tm9kZVdhc0Rlc2NlbmRhbnRPZkVuZE5vZGUgPSBtX3Vwc3RyZWFtU3RhcnQubm9kZSgp LT5pc0Rlc2NlbmRhbnRPZihtX2Rvd25zdHJlYW1FbmQubm9kZSgpKTsKQEAgLTQ3Miw2ICs0NzIs OSBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmhhbmRsZUdlbmVyYWxEZWxldGUoKQog ICAgICAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgICAgICBub2RlID0gc3RhcnROb2RlLT5j aGlsZE5vZGUoc3RhcnRPZmZzZXQpOwogICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYg KHN0YXJ0Tm9kZSA9PSBtX3Vwc3RyZWFtRW5kLm5vZGUoKSAmJiBzdGFydE5vZGUtPmlzVGV4dE5v ZGUoKSkgeworICAgICAgICAgICAgVGV4dCogdGV4dCA9IHN0YXRpY19jYXN0PFRleHQqPihtX3Vw c3RyZWFtRW5kLm5vZGUoKSk7CisgICAgICAgICAgICBkZWxldGVUZXh0RnJvbU5vZGUodGV4dCwg MCwgbV91cHN0cmVhbUVuZC5kZXByZWNhdGVkRWRpdGluZ09mZnNldCgpKTsKICAgICAgICAgfQog ICAgICAgICAKICAgICAgICAgLy8gaGFuZGxlIGRlbGV0aW5nIGFsbCBub2RlcyB0aGF0IGFyZSBj b21wbGV0ZWx5IHNlbGVjdGVkCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50 b1RleHROb2RlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0SW50b1RleHROb2Rl Q29tbWFuZC5jcHAKaW5kZXggOWMzNDIzYS4uOWI3NzYxYyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL0luc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGlu Zy9JbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1 ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIkluc2VydEludG9UZXh0Tm9kZUNvbW1hbmQuaCIKIAor I2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJUZXh0LmgiCiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKQEAgLTQ4LDYgKzQ5LDkgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21t YW5kOjpkb0FwcGx5KCkKICAgICAKICAgICBFeGNlcHRpb25Db2RlIGVjOwogICAgIG1fbm9kZS0+ aW5zZXJ0RGF0YShtX29mZnNldCwgbV90ZXh0LCBlYyk7CisKKyAgICBpZiAoQVhPYmplY3RDYWNo ZTo6YWNjZXNzaWJpbGl0eUVuYWJsZWQoKSkKKyAgICAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RD YWNoZSgpLT5ub2RlVGV4dENoYW5nZU5vdGlmaWNhdGlvbihtX25vZGUtPnJlbmRlcmVyKCksIEFY T2JqZWN0Q2FjaGU6OkFYVGV4dEluc2VydGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpKTsK IH0KIAogdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNTUs NiArNTksMTAgQEAgdm9pZCBJbnNlcnRJbnRvVGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQog ICAgIGlmICghbV9ub2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47CiAg ICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMgYmVmb3JlIGFjdHVhbGx5IGRlbGV0 aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6OmFjY2Vzc2liaWxpdHlFbmFibGVk KCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+bm9kZVRleHRDaGFuZ2VO b3RpZmljYXRpb24obV9ub2RlLT5yZW5kZXJlcigpLCBBWE9iamVjdENhY2hlOjpBWFRleHREZWxl dGVkLCBtX29mZnNldCwgbV90ZXh0Lmxlbmd0aCgpKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7 CiAgICAgbV9ub2RlLT5kZWxldGVEYXRhKG1fb2Zmc2V0LCBtX3RleHQubGVuZ3RoKCksIGVjKTsK IH0KZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVmb3JlQ29tbWFuZC5j cHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQuY3BwCmluZGV4IDJj ZTk4NDYuLmZiNzIzMTIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnROb2RlQmVm b3JlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydE5vZGVCZWZvcmVDb21t YW5kLmNwcApAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUg Ikluc2VydE5vZGVCZWZvcmVDb21tYW5kLmgiCiAKKyNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgi CiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewpAQCAtNTEs NiArNTIsOSBAQCB2b2lkIEluc2VydE5vZGVCZWZvcmVDb21tYW5kOjpkb0FwcGx5KCkKIAogICAg IEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgcGFyZW50LT5pbnNlcnRCZWZvcmUobV9pbnNlcnRDaGls ZC5nZXQoKSwgbV9yZWZDaGlsZC5nZXQoKSwgZWMpOworCisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6 OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2Fj aGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIo KSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0SW5zZXJ0ZWQsIDAsIG1faW5zZXJ0Q2hpbGQtPm5vZGVW YWx1ZSgpLmxlbmd0aCgpKTsKIH0KIAogdm9pZCBJbnNlcnROb2RlQmVmb3JlQ29tbWFuZDo6ZG9V bmFwcGx5KCkKQEAgLTU4LDYgKzYyLDEwIEBAIHZvaWQgSW5zZXJ0Tm9kZUJlZm9yZUNvbW1hbmQ6 OmRvVW5hcHBseSgpCiAgICAgaWYgKCFtX2luc2VydENoaWxkLT5pc0NvbnRlbnRFZGl0YWJsZSgp KQogICAgICAgICByZXR1cm47CiAgICAgICAgIAorICAgIC8vIE5lZWQgdG8gbm90aWZ5IHRoaXMg YmVmb3JlIGFjdHVhbGx5IGRlbGV0aW5nIHRoZSB0ZXh0CisgICAgaWYgKEFYT2JqZWN0Q2FjaGU6 OmFjY2Vzc2liaWxpdHlFbmFibGVkKCkpCisgICAgICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2Fj aGUoKS0+bm9kZVRleHRDaGFuZ2VOb3RpZmljYXRpb24obV9pbnNlcnRDaGlsZC0+cmVuZGVyZXIo KSwgQVhPYmplY3RDYWNoZTo6QVhUZXh0RGVsZXRlZCwgMCwgbV9pbnNlcnRDaGlsZC0+bm9kZVZh bHVlKCkubGVuZ3RoKCkpOworCiAgICAgRXhjZXB0aW9uQ29kZSBlYzsKICAgICBtX2luc2VydENo aWxkLT5yZW1vdmUoZWMpOwogfQpkaWZmIC0tZ2l0IGEvV2ViS2l0L2d0ay9DaGFuZ2VMb2cgYi9X ZWJLaXQvZ3RrL0NoYW5nZUxvZwppbmRleCAxNmY0MDYzLi40MTFmYTlmIDEwMDY0NAotLS0gYS9X ZWJLaXQvZ3RrL0NoYW5nZUxvZworKysgYi9XZWJLaXQvZ3RrL0NoYW5nZUxvZwpAQCAtMSwzICsx LDIwIEBACisyMDEwLTA5LTIyICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bXNhbmNoZXpAaWdhbGlh LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBb R3RrXSBvYmplY3Q6dGV4dC1jaGFuZ2VkIGV2ZW50cyBzaG91bGQgYmUgZW1pdHRlZCBmb3IgZW50 cmllcyBhbmQgcGFzc3dvcmQgdGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjU4OTgKKworICAgICAgICBOZXcgdW5pdCB0ZXN0IHRvIG1ha2Ugc3Vy ZSB0ZXh0LWNoYW5nZWQgc2lnbmFscyBhcmUgZW1pdHRlZAorCisgICAgICAgICogdGVzdHMvdGVz dGF0ay5jOgorICAgICAgICAodGV4dENoYW5nZWRDYik6IE5ldy4gU2lnbmFsIGhhbmRsZXIgZm9y IHRoZQorICAgICAgICB0ZXh0LWNoYW5nZWQ6Omluc2VydCBhbmQgdGV4dC1jaGFuZ2VkOjpkZWxl dGUgc2lnbmFscy4KKyAgICAgICAgKGNoZWNrVGV4dENoYW5nZXNBbmRCYWlsT3V0KTogTmV3LiBT b3VyY2UgZnVuY3Rpb24gdG8gY2hlY2sKKyAgICAgICAgdGhlIGdsb2JhbCByZXN1bHQgb2YgdGhl IHRlc3QgYW5kIHF1aXQgZnJvbSB0aGUgbWFpbiBsb29wLgorICAgICAgICAodGVzdFdlYmtpdEF0 a1RleHRDaGFuZ2VkTm90aWZpY2F0aW9ucyk6IE5ldyB0ZXN0LgorICAgICAgICAobWFpbik6CisK IDIwMTAtMDktMTcgIERhcmluIEFkbGVyICA8ZGFyaW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IFNhbSBXZWluaWcuCmRpZmYgLS1naXQgYS9XZWJLaXQvZ3RrL3Rlc3RzL3Rlc3Rh dGsuYyBiL1dlYktpdC9ndGsvdGVzdHMvdGVzdGF0ay5jCmluZGV4IDljYTdjMDUuLjllNzIzMzQg MTAwNjQ0Ci0tLSBhL1dlYktpdC9ndGsvdGVzdHMvdGVzdGF0ay5jCisrKyBiL1dlYktpdC9ndGsv dGVzdHMvdGVzdGF0ay5jCkBAIC00NCw2ICs0NCw4IEBAIHN0YXRpYyBjb25zdCBjaGFyKiBjb250 ZW50c0luVGFibGUgPSAiPGh0bWw+PGJvZHk+PHRhYmxlPjx0cj48dGQ+Zm9vPC90ZD48dGQ+YmFy CiAKIHN0YXRpYyBjb25zdCBjaGFyKiBjb250ZW50c0luVGFibGVXaXRoSGVhZGVycyA9ICI8aHRt bD48Ym9keT48dGFibGU+PHRyPjx0aD5mb288L3RoPjx0aD5iYXI8L3RoPjx0aCBjb2xzcGFuPScy Jz5iYXo8L3RoPjwvdHI+PHRyPjx0aD5xdXg8L3RoPjx0ZD4xPC90ZD48dGQ+MjwvdGQ+PHRkPjM8 L3RkPjwvdHI+PHRyPjx0aCByb3dzcGFuPScyJz5xdXV4PC90aD48dGQ+NDwvdGQ+PHRkPjU8L3Rk Pjx0ZD42PC90ZD48L3RyPjx0cj48dGQ+NjwvdGQ+PHRkPjc8L3RkPjx0ZD44PC90ZD48L3RyPjx0 cj48dGg+Y29yZ2U8L3RoPjx0ZD45PC90ZD48dGQ+MTA8L3RkPjx0ZD4xMTwvdGQ+PC90cj48L3Rh YmxlPjx0YWJsZT48dHI+PHRkPjE8L3RkPjx0ZD4yPC90ZD48L3RyPjx0cj48dGQ+MzwvdGQ+PHRk PjQ8L3RkPjwvdHI+PC90YWJsZT48L2JvZHk+PC9odG1sPiI7CiAKK3N0YXRpYyBjb25zdCBjaGFy KiBmb3JtV2l0aFRleHRJbnB1dHMgPSAiPGh0bWw+PGJvZHk+PGZvcm0+PGlucHV0IHR5cGU9J3Rl eHQnIG5hbWU9J2VudHJ5JyAvPjwvZm9ybT48L2JvZHk+PC9odG1sPiI7CisKIHN0YXRpYyBjb25z dCBjaGFyKiBsaXN0c09mSXRlbXMgPSAiPGh0bWw+PGJvZHk+PHVsPjxsaT50ZXh0IG9ubHk8L2xp PjxsaT48YSBocmVmPSdmb28nPmxpbmsgb25seTwvYT48L2xpPjxsaT50ZXh0IGFuZCBhIDxhIGhy ZWY9J2Jhcic+bGluazwvYT48L2xpPjwvdWw+PG9sPjxsaT50ZXh0IG9ubHk8L2xpPjxsaT48YSBo cmVmPSdmb28nPmxpbmsgb25seTwvYT48L2xpPjxsaT50ZXh0IGFuZCBhIDxhIGhyZWY9J2Jhcic+ bGluazwvYT48L2xpPjwvb2w+PC9ib2R5PjwvaHRtbD4iOwogCiBzdGF0aWMgY29uc3QgY2hhciog dGV4dEZvclNlbGVjdGlvbnMgPSAiPGh0bWw+PGJvZHk+PHA+QSBwYXJhZ3JhcGggd2l0aCBwbGFp biB0ZXh0PC9wPjxwPkEgcGFyYWdyYXBoIHdpdGggPGEgaHJlZj0naHR0cDovL3dlYmtpdC5vcmcn PmEgbGluazwvYT4gaW4gdGhlIG1pZGRsZTwvcD48L2JvZHk+PC9odG1sPiI7CkBAIC0xMDM3LDYg KzEwMzksNjggQEAgc3RhdGljIHZvaWQgdGVzdFdlYmtpdEF0a0xpc3RzT2ZJdGVtcyh2b2lkKQog ICAgIGdfb2JqZWN0X3VucmVmKHdlYlZpZXcpOwogfQogCitzdGF0aWMgZ2Jvb2xlYW4gdGV4dElu c2VydGVkID0gRkFMU0U7CitzdGF0aWMgZ2Jvb2xlYW4gdGV4dERlbGV0ZWQgPSBGQUxTRTsKKwor c3RhdGljIHZvaWQgdGV4dENoYW5nZWRDYihBdGtUZXh0KiB0ZXh0LCBnaW50IHBvcywgZ2ludCBs ZW4sIGNvbnN0IGdjaGFyKiBkZXRhaWwpCit7CisgICAgZ19hc3NlcnQodGV4dCAmJiBBVEtfSVNf T0JKRUNUKHRleHQpKTsKKworICAgIGlmICghZ19zdHJjbXAwKGRldGFpbCwgImluc2VydCIpKQor ICAgICAgICB0ZXh0SW5zZXJ0ZWQgPSBUUlVFOworICAgIGVsc2UgaWYgKCFnX3N0cmNtcDAoZGV0 YWlsLCAiZGVsZXRlIikpCisgICAgICAgIHRleHREZWxldGVkID0gVFJVRTsKK30KKworc3RhdGlj IGdib29sZWFuIGNoZWNrVGV4dENoYW5nZXMoZ3BvaW50ZXIgdW51c2VkKQoreworICAgIGdfYXNz ZXJ0X2NtcGludCh0ZXh0SW5zZXJ0ZWQsID09LCBUUlVFKTsKKyAgICBnX2Fzc2VydF9jbXBpbnQo dGV4dERlbGV0ZWQsID09LCBUUlVFKTsKKyAgICByZXR1cm4gRkFMU0U7Cit9CisKK3N0YXRpYyB2 b2lkIHRlc3RXZWJraXRBdGtUZXh0Q2hhbmdlZE5vdGlmaWNhdGlvbnModm9pZCkKK3sKKyAgICBX ZWJLaXRXZWJWaWV3KiB3ZWJWaWV3ID0gV0VCS0lUX1dFQl9WSUVXKHdlYmtpdF93ZWJfdmlld19u ZXcoKSk7CisgICAgZ19vYmplY3RfcmVmX3Npbmsod2ViVmlldyk7CisgICAgR3RrQWxsb2NhdGlv biBhbGxvYyA9IHsgMCwgMCwgODAwLCA2MDAgfTsKKyAgICBndGtfd2lkZ2V0X3NpemVfYWxsb2Nh dGUoR1RLX1dJREdFVCh3ZWJWaWV3KSwgJmFsbG9jKTsKKyAgICB3ZWJraXRfd2ViX3ZpZXdfbG9h ZF9zdHJpbmcod2ViVmlldywgZm9ybVdpdGhUZXh0SW5wdXRzLCAwLCAwLCAwKTsKKworICAgIC8v IE1hbnVhbGx5IHNwaW4gdGhlIG1haW4gY29udGV4dCB0byBnZXQgdGhlIGFjY2Vzc2libGUgb2Jq ZWN0cworICAgIHdoaWxlIChnX21haW5fY29udGV4dF9wZW5kaW5nKDApKQorICAgICAgICBnX21h aW5fY29udGV4dF9pdGVyYXRpb24oMCwgVFJVRSk7CisKKyAgICBBdGtPYmplY3QqIG9iaiA9IGd0 a193aWRnZXRfZ2V0X2FjY2Vzc2libGUoR1RLX1dJREdFVCh3ZWJWaWV3KSk7CisgICAgZ19hc3Nl cnQob2JqKTsKKworICAgIEF0a09iamVjdCogZm9ybSA9IGF0a19vYmplY3RfcmVmX2FjY2Vzc2li bGVfY2hpbGQob2JqLCAwKTsKKyAgICBnX2Fzc2VydChBVEtfSVNfT0JKRUNUKGZvcm0pKTsKKwor ICAgIEF0a09iamVjdCogdGV4dEVudHJ5ID0gYXRrX29iamVjdF9yZWZfYWNjZXNzaWJsZV9jaGls ZChmb3JtLCAwKTsKKyAgICBnX2Fzc2VydChBVEtfSVNfRURJVEFCTEVfVEVYVCh0ZXh0RW50cnkp KTsKKyAgICBnX2Fzc2VydChhdGtfb2JqZWN0X2dldF9yb2xlKEFUS19PQkpFQ1QodGV4dEVudHJ5 KSkgPT0gQVRLX1JPTEVfRU5UUlkpOworCisgICAgZ19zaWduYWxfY29ubmVjdCh0ZXh0RW50cnks ICJ0ZXh0LWNoYW5nZWQ6Omluc2VydCIsCisgICAgICAgICAgICAgICAgICAgICBHX0NBTExCQUNL KHRleHRDaGFuZ2VkQ2IpLAorICAgICAgICAgICAgICAgICAgICAgKGdwb2ludGVyKSJpbnNlcnQi KTsKKyAgICBnX3NpZ25hbF9jb25uZWN0KHRleHRFbnRyeSwgInRleHQtY2hhbmdlZDo6ZGVsZXRl IiwKKyAgICAgICAgICAgICAgICAgICAgIEdfQ0FMTEJBQ0sodGV4dENoYW5nZWRDYiksCisgICAg ICAgICAgICAgICAgICAgICAoZ3BvaW50ZXIpImRlbGV0ZSIpOworCisgICAgZ2ludCBwb3MgPSAw OworICAgIGF0a19lZGl0YWJsZV90ZXh0X2luc2VydF90ZXh0KEFUS19FRElUQUJMRV9URVhUKHRl eHRFbnRyeSksICJmb28gYmFyIGJheiIsIDExLCAmcG9zKTsKKyAgICBhdGtfZWRpdGFibGVfdGV4 dF9kZWxldGVfdGV4dChBVEtfRURJVEFCTEVfVEVYVCh0ZXh0RW50cnkpLCA0LCA3KTsKKyAgICB0 ZXh0SW5zZXJ0ZWQgPSBGQUxTRTsKKyAgICB0ZXh0RGVsZXRlZCA9IEZBTFNFOworCisgICAgZ19p ZGxlX2FkZCgoR1NvdXJjZUZ1bmMpY2hlY2tUZXh0Q2hhbmdlcywgMCk7CisKKyAgICBnX29iamVj dF91bnJlZihmb3JtKTsKKyAgICBnX29iamVjdF91bnJlZih0ZXh0RW50cnkpOworICAgIGdfb2Jq ZWN0X3VucmVmKHdlYlZpZXcpOworfQorCiBpbnQgbWFpbihpbnQgYXJnYywgY2hhcioqIGFyZ3Yp CiB7CiAgICAgZ190aHJlYWRfaW5pdChOVUxMKTsKQEAgLTEwNTYsNiArMTEyMCw3IEBAIGludCBt YWluKGludCBhcmdjLCBjaGFyKiogYXJndikKICAgICBnX3Rlc3RfYWRkX2Z1bmMoIi93ZWJraXQv YXRrL3RleHRTZWxlY3Rpb25zIiwgdGVzdFdla2l0QXRrVGV4dFNlbGVjdGlvbnMpOwogICAgIGdf dGVzdF9hZGRfZnVuYygiL3dlYmtpdC9hdGsvZ2V0X2V4dGVudHMiLCB0ZXN0X3dlYmtpdF9hdGtf Z2V0X2V4dGVudHMpOwogICAgIGdfdGVzdF9hZGRfZnVuYygiL3dlYmtpdC9hdGsvbGlzdHNPZkl0 ZW1zIiwgdGVzdFdlYmtpdEF0a0xpc3RzT2ZJdGVtcyk7CisgICAgZ190ZXN0X2FkZF9mdW5jKCIv d2Via2l0L2F0ay90ZXh0Q2hhbmdlZE5vdGlmaWNhdGlvbnMiLCB0ZXN0V2Via2l0QXRrVGV4dENo YW5nZWROb3RpZmljYXRpb25zKTsKICAgICByZXR1cm4gZ190ZXN0X3J1biAoKTsKIH0KIAotLSAK MS43LjAuNAoK