146574 2015-07-02 20:02:12 -0700 [GTK][Wayland] Implement clipboard support 2016-10-09 13:32:08 -0700 1 1 1 Unclassified WebKit WebKitGTK Other PC Linux RESOLVED FIXED https://bugzilla.redhat.com/show_bug.cgi?id=1278533 https://bugzilla.redhat.com/show_bug.cgi?id=1285078 https://bugzilla.gnome.org/show_bug.cgi?id=763738 https://bugzilla.gnome.org/show_bug.cgi?id=764920 https://bugzilla.gnome.org/show_bug.cgi?id=765546 https://bugzilla.gnome.org/show_bug.cgi?id=765672 https://bugzilla.redhat.com/show_bug.cgi?id=1380839 P1 Blocker --- 161907 81456 1 unixman mcatanzaro berend.de.schouwer bugs-noreply bugzilla carlosg cgarcia commit-queue csaavedra fosero jadahl jana jeremyhu joone lantw44 mcatanzaro mike nekohayo torben.andresen tpopela zan oldest_to_newest 1106602 0 unixman 2015-07-02 20:02:12 -0700 copy/paste address bar from/to another application works. copy/paste page contents from/to another application don't works. copy/paste on same tab works. copy/paste between tabs don't works. there is no log output. webkitgtk-2.8.3 gtk-3.16.4 wayland-1.8.1 weston-1.8.0 wayland has protokol level clipboard and drag&drop support. thanks. 1106603 1 unixman 2015-07-02 20:04:36 -0700 forgot : epiphany-3.16.2 1112231 2 mcatanzaro 2015-07-25 15:36:16 -0700 (In reply to comment #0) > copy/paste address bar from/to another application works. > > copy/paste page contents from/to another application don't works. Hm, webkitgtk-2.8.3 indicates the web process is running under XWayland, and gtk-3.16.4 indicates you probably have mutter 3.16.x, which I don't believe knew how to copy/paste between X and Wayland applications. We need to find out if this is still a problem with 2.9.4 compiled with ENABLE_WAYLAND_TARGET=ON (the new default setting) and running under the latest mutter 3.17.x. 1112421 3 unixman 2015-07-27 09:14:28 -0700 Great! i compiled webkitgtk-2.9.4 successfully into my libX11'less partition. i tested it only on weston(drm-backend) via MiniBrowser. So there aren't xwayland and mutter here. copy/paste between apps still doesn't work. copy/paste between page and address bar didn't work too. copy/paste in page scope works. 1112423 4 unixman 2015-07-27 09:28:20 -0700 just an additional info: i noticed that MiniBrowser and weston-terminal(a native weston app) maintains two different clipboard when they running. copy/paste between two weston-terminal instances works. But copy/paste between two MiniBrowser instances doesn't work. 1112712 5 unixman 2015-07-28 08:58:17 -0700 a webkitsetting exists in MiniBrowser's settings menu. it is named as "JavaScript can access clipboard" 1114297 6 unixman 2015-08-03 12:32:40 -0700 page context(so webkit) doesn't respect 'global clipboard object'; creates and maintains its own.But 'address bar'(so gtk) know and respect it. 1114311 7 mcatanzaro 2015-08-03 12:59:35 -0700 I'll look into this in 3-4 weeks, unless Zan beats me to it. I have to implement Wayland copy/paste for Chromium anyway. I'd prefer to do Chromium first, but I have no deadline there, while this bug is starting to look relatively urgent.... 1139196 8 mike 2015-11-03 17:01:22 -0800 *** Bug 150316 has been marked as a duplicate of this bug. *** 1139211 9 mcatanzaro 2015-11-03 17:47:43 -0800 (In reply to comment #7) > I'll look into this in 3-4 weeks, unless Zan beats me to it. I have to > implement Wayland copy/paste for Chromium anyway. I'd prefer to do Chromium > first, but I have no deadline there, while this bug is starting to look > relatively urgent.... FWIW at the time we were planning to ship Fedora 23 with Wayland instead of X11, but that transition got delayed until Fedora 24. 1139581 10 bugzilla 2015-11-05 04:35:36 -0800 This is a problem for me using epiphany under Wayland. 1153031 11 csaavedra 2016-01-06 05:58:08 -0800 I implemented this for the WPE backend. If someone is in a hurry, feel free to use the code in https://github.com/WebKitForWayland/webkit/pull/14 . Otherwise I might be able to look into this at some point, no promises though :) 1183044 12 mcatanzaro 2016-04-12 07:07:41 -0700 *** Bug 156497 has been marked as a duplicate of this bug. *** 1183045 13 mcatanzaro 2016-04-12 07:10:58 -0700 By the way, some background on this: with help from Carlos Garnacho, we determined it's impossible to access the clipboard from the web process in Wayland, because the web process doesn't have a mutter window. Instead we decided to implement a clipboard proxy to the UI process, like Apple already has for its ports, and like what Claudio recently did for WPE. We can probably reuse most of Claudio's code, except ours of course needs to properly support the same set of MIME types that we currently do. 1192693 14 torben.andresen 2016-05-13 01:12:06 -0700 Ist there any progress on this? It's really annoying that i have to use a second browser for C&P. 1192729 15 mcatanzaro 2016-05-13 05:59:04 -0700 (In reply to comment #14) > Ist there any progress on this? Nope. > It's really annoying that i have to use a > second browser for C&P. Yup. 1220825 16 mcatanzaro 2016-08-17 01:09:15 -0700 (In reply to comment #14) > Ist there any progress on this? I've been investigating and have some code written, but I need more time. No estimate as to when this might be finished. 1221859 17 mcatanzaro 2016-08-22 08:24:18 -0700 (In reply to comment #16) > I've been investigating and have some code written, but I need more time. No > estimate as to when this might be finished. In case anyone else wants to look into this, the information flow needs to be: Pasteboard (WebCore, web process) -> PasteboardStrategy/WebPlatformStrategies (WebCore/WebKit2, web process) -> WebPasteboardProxy (WebKit2 web process) -> PlatformPasteboard (WebCore UI process) Most of the code currently in the Pasteboard or PasteboardHelper classes needs to move to PlatformPasteboard (in the UI process). GtkClipboard must not be accessed anywhere except PlatformPasteboard. There is example code for a different WebKit port in comment #11. 1227601 18 288269 carlosg 2016-09-08 08:55:24 -0700 Created attachment 288269 Patch, implement clipboard as a PlatformPasteboard Initial patch to get things rolling. It implements PlatformPasteboard for GTK+, and adds the necessary plumbing so Pasteboard in the webprocess side forwards clipboard contents/requests to the UI process. It does so by reusing as much of the previous code as it was possible, more concretely DataObjectGtk is used on both sides to keep a local representation of the clibpoard contents, and PasteboardHelper usage has simply been shuffled from PasteboardGtk.cpp to PlatformPasteboardGtk.cpp. 1227662 19 288269 mcatanzaro 2016-09-08 11:40:34 -0700 Comment on attachment 288269 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288269&action=review Thanks very much. Since you're now our expert on this code, any thoughts on lightly-related bug #144547 would be appreciated. > Source/WebCore/ChangeLog:3 > + [GTK] Manage selections through PlatformPasteboard The first line should be the title of the bug. If you want to rename the bug, then make sure to mention that this implements clipboard support for Wayland somewhere in the changelog. > Source/WebCore/platform/Pasteboard.h:145 > + enum PasteboardType { None, Primary, Selection }; Hm, this seems like very confusing terminology. In GTK+ parlance the default clipboard is CLIPBOARD and the primary selection clipboard is PRIMARY. At first I thought your Primary was GTK+'s CLIPBOARD, and your Selection was GTK+'s PRIMARY, but I see you are using Primary as expected and Selection to mean CLIPBOARD. It's really confusing because primary is of course short for "primary selection," so when we talk about the selection clipboard we're normally talking about primary, right? I would stick to GTK+ terminology here and rename Selection to Clipboard. Yeah it's a bit confusing for Clipboard to be a PasteboardType, but I don't see any way around it. Also, use enum class rather than old style enums, so it gets scoped nicely. > Source/WebCore/platform/Pasteboard.h:229 > + String pasteboardName(void); This function should be const, so that it can be called from other const member functions (and to ensure it can't modify member variables). Also, unlike in C, in C++ functions with no parameters declared are always void by default, so we don't include that. So the declaration should be: String pasteboardName() const; > Source/WebCore/platform/Pasteboard.h:230 > + void writeToClipboard(bool includeSmartPaste = false); We don't like to use boolean parameters since it's harder to read; instead, you can do something like this: enum class ShouldIncludeSmartPaste { No, Yes }; void writeToClipboard(ShouldIncludeSmartPaste = ShouldIncludeSmartPaste::No); Then instead of calling writeToClipboard(true), you call writeToClipboard(ShouldIncludeSmartPaste::Yes), which is easier to read. Also consider whether having the default argument is really worth it; I'd probably just pass the tag everywhere to be explicit about it. > Source/WebCore/platform/Pasteboard.h:231 > + void readFromClipboard(void); void readFromClipboard(); > Source/WebCore/platform/PasteboardStrategy.h:77 > +#if PLATFORM(GTK) > + virtual void clearSelection(String selection); > + virtual void claimSelection(String selection); > + virtual Vector<String> getTypes(String selection); > + virtual void setString(String selection, String pasteboardType, String buffer); > + virtual String getString(String selection, String pasteboardType); > +#endif // PLATFORM(GTK) As discussed on IRC, these need to be pure virtual. I'm not sure how you were able to build it like this. I think using "selection" to refer to clipboard names is perhaps confusing. What do think about using "pasteboardName" instead of "selection"? Lastly, I think "buffer" is a confusing name for a String object, since actually the buffer is encapsulated by the String. What do you think about "pasteboardContents" instead of "buffer"? > Source/WebCore/platform/gtk/PasteboardGtk.cpp:43 > + return std::make_unique<Pasteboard>(Selection); (When you convert this to an enum class, you'll have to write PasteboardType::Selection and PasteboardType::Primary instead of Selection and Primary on their own.) > Source/WebCore/platform/gtk/PasteboardGtk.cpp:87 > ASSERT(m_dataObject); You can get rid of this assert. It's safe to assume a create function only fails if you pass an invalid parameter, and it doesn't take a parameter anymore. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:122 > +String Pasteboard::pasteboardName(void) String Pasteboard::pasteboardName() const > Source/WebCore/platform/gtk/PasteboardGtk.cpp:128 > + return emptyString(); Our Strings actually have a separate null state. I think we would normally return a default-constructed String here: return String {}; > Source/WebCore/platform/gtk/PasteboardGtk.cpp:136 > + String selection = pasteboardName(); > + > + ASSERT(!selection.isEmpty()); I would remove the blank line here, since the assert goes with the declaration above it. Perhaps "pasteboardName" would be a better name than "selection" for this variable. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:170 > + for (auto it : types) { Careful, you're copying into "it" here. You want auto& it > Source/WebCore/platform/gtk/PasteboardGtk.cpp:306 > bool Pasteboard::canSmartReplace() This function should be const. Since you're modifying it anyway, go ahead and fix it: bool Pasteboard::canSmartReplace() const > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:2 > + * Copyright (C) 2016 Red Hat. Don't you normally write Red Hat Inc? > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:39 > + static HashMap<String, std::unique_ptr<WebCore::PlatformPasteboard> > pasteboardMap; Since you have a "using namespace WebCore" statement up above, you don't need this extra scoping here. Also, you don't need the extra space between the > > anymore, that's been valid since C++11 and we're using C++14 now. Also, we want to avoid static objects being destroyed at exit time since that tends to cause bugs, so please leak it with NeverDestroyed (you'll need to #include <wtf/NeverDestroyed.h>. It will look like this: static NeverDestroyed<HashMap<String, std::unique_ptr<PlatformPasteboard>>> pasteboardMap; 1227671 20 mcatanzaro 2016-09-08 11:54:16 -0700 Hm, I now see these warnings when closing an Epiphany tab: pure virtual method called terminate called without an active exception That looks pretty bad; I've never seen errors like these before. I wonder if we're slicing off the derived class portion of an object somewhere. 1227678 21 288269 mcatanzaro 2016-09-08 12:02:23 -0700 Comment on attachment 288269 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288269&action=review > Source/WebCore/platform/gtk/PasteboardGtk.cpp:147 > + if (m_dataObject->hasText()) > + strategy.setString(selection, "Text", m_dataObject->text()); > + if (m_dataObject->hasMarkup()) > + strategy.setString(selection, "text/html", m_dataObject->markup()); > + if (m_dataObject->hasURL()) > + strategy.setString(selection, "URL", m_dataObject->url()); > + if (m_dataObject->hasURIList()) > + strategy.setString(selection, "Files", m_dataObject->uriList()); I agree with you that it'd be better to use enums rather than strings for the second parameter here. Carlos Garcia gave you a tip on IRC on how to do this, was it enough? > Source/WebCore/platform/gtk/PasteboardGtk.cpp:168 > + Vector<String> types; > + types = strategy.getTypes(selection); This should be done in one line. > Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp:39 > + : m_clipboard(gtk_clipboard_get(gdk_atom_intern(pasteboardName.utf8().data(), true))) Nit: we normally use gboolean TRUE when calling GObject functions. 1227689 22 288269 mcatanzaro 2016-09-08 12:11:51 -0700 Comment on attachment 288269 Patch, implement clipboard as a PlatformPasteboard (r- until we figure out what's causing "pure virtual method called") 1227697 23 mcatanzaro 2016-09-08 12:16:24 -0700 (In reply to comment #20) > Hm, I now see these warnings when closing an Epiphany tab: > > pure virtual method called > terminate called without an active exception > > That looks pretty bad; I've never seen errors like these before. I wonder if > we're slicing off the derived class portion of an object somewhere. I rebooted my computer and the errors are gone. Very strange.... 1227853 24 mcatanzaro 2016-09-08 14:59:10 -0700 (In reply to comment #23) > I rebooted my computer and the errors are gone. Very strange.... I'm not confident these were related to your patch. Let's assume otherwise. We can debug when they appear again. 1228073 25 288269 cgarcia 2016-09-09 01:15:57 -0700 Comment on attachment 288269 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288269&action=review What about WebEditorClient::updateGlobalSelection()? it's currently protected by X11 guards, could we remove those guards now? >> Source/WebCore/platform/Pasteboard.h:145 >> + enum PasteboardType { None, Primary, Selection }; > > Hm, this seems like very confusing terminology. In GTK+ parlance the default clipboard is CLIPBOARD and the primary selection clipboard is PRIMARY. At first I thought your Primary was GTK+'s CLIPBOARD, and your Selection was GTK+'s PRIMARY, but I see you are using Primary as expected and Selection to mean CLIPBOARD. It's really confusing because primary is of course short for "primary selection," so when we talk about the selection clipboard we're normally talking about primary, right? I would stick to GTK+ terminology here and rename Selection to Clipboard. Yeah it's a bit confusing for Clipboard to be a PasteboardType, but I don't see any way around it. > > Also, use enum class rather than old style enums, so it gets scoped nicely. Yes, also PasteboardType is redundant inside a PasteboardClass and even more if we use an emu class, so use just Type. >> Source/WebCore/platform/Pasteboard.h:229 >> + String pasteboardName(void); > > This function should be const, so that it can be called from other const member functions (and to ensure it can't modify member variables). Also, unlike in C, in C++ functions with no parameters declared are always void by default, so we don't include that. So the declaration should be: > > String pasteboardName() const; No, it should be: const String& name() const; again pasteboardName sounds redundant and it should return a const reference. >> Source/WebCore/platform/Pasteboard.h:230 >> + void writeToClipboard(bool includeSmartPaste = false); > > We don't like to use boolean parameters since it's harder to read; instead, you can do something like this: > > enum class ShouldIncludeSmartPaste { No, Yes }; > > void writeToClipboard(ShouldIncludeSmartPaste = ShouldIncludeSmartPaste::No); > > Then instead of calling writeToClipboard(true), you call writeToClipboard(ShouldIncludeSmartPaste::Yes), which is easier to read. Also consider whether having the default argument is really worth it; I'd probably just pass the tag everywhere to be explicit about it. We already have an enum SmartPasteInclusion in PasteboardHelper > Source/WebCore/platform/PasteboardStrategy.h:74 > + virtual Vector<String> getTypes(String selection); This should return the vector as an out parameter. Or leave it this way but rename it as types() >> Source/WebCore/platform/PasteboardStrategy.h:77 >> +#endif // PLATFORM(GTK) > > As discussed on IRC, these need to be pure virtual. I'm not sure how you were able to build it like this. > > I think using "selection" to refer to clipboard names is perhaps confusing. What do think about using "pasteboardName" instead of "selection"? > > Lastly, I think "buffer" is a confusing name for a String object, since actually the buffer is encapsulated by the String. What do you think about "pasteboardContents" instead of "buffer"? Yes, they should be pure virtual, and all string parameters should be const String&. The pasteboardType parameter is also confusing, we have PasteboardType enum referring to the clipboard name, but here it refers to the content types. I wonder if we could use DataObjectGtk directly, making it serializable. > Source/WebCore/platform/PlatformPasteboard.h:86 > + WEBCORE_EXPORT void clearSelection(); > + WEBCORE_EXPORT void claimSelection(); I'm not sure I understand these. Claim is what writes, and clear is donde before, why do we need the clear? >> Source/WebCore/platform/gtk/PasteboardGtk.cpp:122 >> +String Pasteboard::pasteboardName(void) > > String Pasteboard::pasteboardName() const const String& Pasteboard::name() const > Source/WebCore/platform/gtk/PasteboardGtk.cpp:127 > + if (m_pasteboardType == Primary) > + return "PRIMARY"; > + if (m_pasteboardType == Selection) > + return "CLIPBOARD"; To be able to return a const String& you could define PRIMARY and CLIPBOARD as: static NeverDestroyed<const String> primaryName(ASCIILiteral("PRIMARY")); static NeverDestroyed<const String> clipboardName(ASCIILiteral("CLIPBOARD")); Then use a switch instead of ifs to handle enum cases > Source/WebCore/platform/gtk/PasteboardGtk.cpp:134 > + String selection = pasteboardName(); and here you could use const String& selection = name(); > Source/WebCore/platform/gtk/PasteboardGtk.cpp:157 > + strategy.claimSelection(selection); So, to write something to the clipboard we need, one IPC message to clear the clipboard, one or more to set data contents, and one to claim the selection. If we serialize DataObjectGtk, this could be just one message: WriteToClipboard(WebCore::DataObjectGtk); no? >> Source/WebCore/platform/gtk/PasteboardGtk.cpp:170 >> + for (auto it : types) { > > Careful, you're copying into "it" here. You want auto& it Use a name for the iterator, since in this case it's not an iterator what you get, but the actual value. for (auto& type : types) for example > Source/WebCore/platform/gtk/PasteboardGtk.cpp:175 > + } Reading is even worse, because GetString and GetTypes messages are synchronous. So, again we could have s single message that returns a DataObjectGtk > Source/WebCore/platform/gtk/PasteboardGtk.cpp:205 > - if (m_gtkClipboard) > - PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, (smartReplaceOption == CanSmartReplace) ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste); > + if (m_pasteboardType != None) > + writeToClipboard(smartReplaceOption == CanSmartReplace); It's a good time to change this and do the check in writeToClipboard, returning early for None type. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:314 > + types = strategy.getTypes(pasteboardName()); Now that I see this again, the name() method is a private function, and the value is known at construction time. The type is only used to check whether it's none or not and to return the name, whcih is always the same for the same instance. So, what about having m_name only? Then we only need to check isEmpty() or isNull() instead of type == None, and use m_name everywhere instead of name(); > Source/WebCore/platform/gtk/PasteboardGtk.cpp:329 > - if (m_gtkClipboard) > - PasteboardHelper::singleton().getClipboardContents(m_gtkClipboard); > + if (m_pasteboardType != None) > + readFromClipboard(); Same her,e let's move the check to readFromClipboard() > Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp:53 > +void PlatformPasteboard::claimSelection() > +{ > + PasteboardHelper::singleton().writeClipboardContents(m_clipboard); > +} I think it's clearer if this method is called writeClipboardContents instead of claim. As I suggested before, if we receive a DataObjectGtk here, we could only need to set the DataObjectGtk of this clipboard from the given one. >> Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:39 >> + static HashMap<String, std::unique_ptr<WebCore::PlatformPasteboard> > pasteboardMap; > > Since you have a "using namespace WebCore" statement up above, you don't need this extra scoping here. Also, you don't need the extra space between the > > anymore, that's been valid since C++11 and we're using C++14 now. Also, we want to avoid static objects being destroyed at exit time since that tends to cause bugs, so please leak it with NeverDestroyed (you'll need to #include <wtf/NeverDestroyed.h>. It will look like this: > > static NeverDestroyed<HashMap<String, std::unique_ptr<PlatformPasteboard>>> pasteboardMap; Do we even want this? This is already done by GTK+. Here we heap allocate a PlatformPasteboard which only state is a GtkClipboard, obtained with gtk_clipboard_get(). That returns a permanent object owned by GTK+. So, we could just create a stack allocated PlatformPasteboard object to use the clipboard for the given name, since this table is already maintained by GTK+. > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:51 > + PlatformPasteboard* pasteboard = lookupPlatformPasteboard(selection); > + pasteboard->clearSelection(); Then this would be just: PlatformPasteboard(selection).clearSelection(); 1228074 26 cgarcia 2016-09-09 01:28:10 -0700 DataObjectGtk is already serializable, we send it over IPC as part of DragData. We just need to add ArgumentCoder<DataObjectGTK>::encode/decode methdos 1228091 27 mcatanzaro 2016-09-09 05:06:23 -0700 (In reply to comment #25) > > Source/WebCore/platform/PasteboardStrategy.h:74 > > + virtual Vector<String> getTypes(String selection); > > This should return the vector as an out parameter. Or leave it this way but > rename it as types() Leave it this way but rename to types(). Using an out parameter was a pre-C++1 workaround for the lack of language guarantee that the return value would be moved rather than copied. 1228191 28 mcatanzaro 2016-09-09 10:26:09 -0700 (In reply to comment #22) > Comment on attachment 288269 [details] > Patch, implement clipboard as a PlatformPasteboard > > (r- until we figure out what's causing "pure virtual method called") It's related to bug #161605, not your patch. 1228603 29 jana 2016-09-11 03:08:04 -0700 I'm getting complaints at link time that the virtual table of WebCore::PasteboardStrategy cannot be found. The five added method methods in Source/WebCore/platform/PasteboardStrategy.h should be declared with '= 0' to fix this since it's only an interface. 1228714 30 288563 carlosg 2016-09-12 03:03:00 -0700 Created attachment 288563 Patch, implement clipboard as a PlatformPasteboard This patch applies the suggestions from Michael Catanzaro, and the suggestions from Carlos García on IRC to allow serialization of DataObjectGtk, thus simplifying the IPC into two setSelection/getSelection requests, this makes the IPC parts much easier to follow. 1228717 31 288564 carlosg 2016-09-12 04:01:04 -0700 Created attachment 288564 Patch, implement clipboard as a PlatformPasteboard This patch applies most of the remaining suggestions (except the ones rendered obsolete by the switch to serializing DataObjectGtk) in comment #25, which I didn't notice. 1228720 32 carlosg 2016-09-12 04:07:12 -0700 (In reply to comment #25) > Comment on attachment 288269 [details] > Patch, implement clipboard as a PlatformPasteboard > > View in context: > https://bugs.webkit.org/attachment.cgi?id=288269&action=review > > What about WebEditorClient::updateGlobalSelection()? it's currently > protected by X11 guards, could we remove those guards now? I need to investigate that. Having an implementation of primary selection is dependent on the compositor, and I'm not sure how well gtk+ will fare with gtk_clipboard_wait_for_contents() on it if the compositor doesn't offer an implementation. An option might be teaching PasteboardHelper to do gtk_clipboard_request* so stalls are not possible. With gnome-shell/mutter it should just work though. > > We don't like to use boolean parameters since it's harder to read; instead, you can do something like this: > > > > enum class ShouldIncludeSmartPaste { No, Yes }; > > > > void writeToClipboard(ShouldIncludeSmartPaste = ShouldIncludeSmartPaste::No); > > > > Then instead of calling writeToClipboard(true), you call writeToClipboard(ShouldIncludeSmartPaste::Yes), which is easier to read. Also consider whether having the default argument is really worth it; I'd probably just pass the tag everywhere to be explicit about it. > > We already have an enum SmartPasteInclusion in PasteboardHelper I think this is the only unaddressed comment. IMHO it's PasteboardHelper's enum which should change to using the one defined here, since this one is exposed in shared layers. If you think this modification belongs to the patch at hand I'll do that. 1228735 33 288564 cgarcia 2016-09-12 06:25:16 -0700 Comment on attachment 288564 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288564&action=review This looks much better now, I still have a few comments, tough. > Source/WebCore/platform/Pasteboard.h:235 > + Type m_pasteboardType; > + const String m_name; I don't think we need to keep both type and name. If we keep the type, then we could simply use the name() method, instead of keeping this member. What I meant in my previous revision is that we can only keep m_name only, initialized on construction, because m_type is only used to get the name. > Source/WebCore/platform/PasteboardStrategy.h:42 > +#if PLATFORM(GTK) > +class DataObjectGtk; > +#endif Leave an empty line between non-platform specific declarations and this. > Source/WebCore/platform/PasteboardStrategy.h:76 > + virtual void setSelection(const String& pasteboardName, WebCore::DataObjectGtk*) = 0; > + virtual RefPtr<WebCore::DataObjectGtk> getSelection(const String& pasteboardName) = 0; I prefer to follow the pasteboard names, writeToClipboard/ReadFromClipboard. No need for WebCore::, since we already inside WebCore namespace. > Source/WebCore/platform/PlatformPasteboard.h:46 > +#if PLATFORM(GTK) > +class DataObjectGtk; > +#endif Move this below the declarations > Source/WebCore/platform/PlatformPasteboard.h:89 > + WEBCORE_EXPORT DataObjectGtk* getSelection(); This should never return nullptr either, so return a reference instead of a pointer. > Source/WebCore/platform/gtk/DataObjectGtk.cpp:164 > + auto addResult = objectMap.add(clipboard, nullptr); > + addResult.iterator->value = dataObject; Since we are going to replace the DataObjectGtk associated to the clipboard, I think we can stop doing this. We should probably pass a DataObjectGTK to the PasteboardHelper write method, and read method should return a new DataObjectGtk too. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:87 > + , m_pasteboardType(type) > + , m_name(name()) So, here we could initialize the name using a helper function that can be static instead of name() m_name(pateboardNameForType(type)) > Source/WebCore/platform/gtk/PasteboardGtk.cpp:123 > +const String& Pasteboard::name() const And then this wouldn't return a const String& anymore, so we could return directly ASCIILiteral("PRIMARY"), ASCIILiteral("CLIPBOARD") or String(). Now it's better to use a null string, so that it matches the constructor not taking a type. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:140 > + if (m_name.isEmpty()) here we would check isNull instead > Source/WebCore/platform/gtk/PasteboardGtk.cpp:143 > + DataObjectGtk* dataObject = m_dataObject.get(); We don't need a local variable for this, you can use m_dataObject-> directly > Source/WebCore/platform/gtk/PasteboardGtk.cpp:147 > + strategy.setSelection(m_name, dataObject); strategy is used only once here, so we don't need a local variable for that either: platformStrategies()->pasteboardStrategy()->setSelection(m_name, m_dataObject.get()); > Source/WebCore/platform/gtk/PasteboardGtk.cpp:152 > + if (m_name.isEmpty()) and here isNull() too. > Source/WebCore/platform/gtk/PasteboardGtk.cpp:156 > + RefPtr<DataObjectGtk> dataObject = strategy.getSelection(m_name); > + m_dataObject = dataObject.get(); m_dataObject = WTFMove(platformStrategies()->pasteboardStrategy()->getSelection(m_name)); > Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp:37 > +void PlatformPasteboard::setSelection(DataObjectGtk* dataObject) This should receive a reference instead of a pointer > Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp:40 > + DataObjectGtk::setForClipboard(m_clipboard, dataObject); > + PasteboardHelper::singleton().writeClipboardContents(m_clipboard); And I think we could simply pass the dataObject to PasteboardHelper::writeClipboardContents() so that we don't need the clipboard/dataobjects map. > Source/WebCore/platform/gtk/PlatformPasteboardGtk.cpp:46 > + PasteboardHelper::singleton().getClipboardContents(m_clipboard); > + return DataObjectGtk::forClipboard(m_clipboard); And PasteboardHelper::getClipboardContents(9), that should probably be renamed as readClipboardContents(), should return the newly created DataObjectGtk > Source/WebKit2/Shared/gtk/PasteboardContentGtk.cpp:20 > +#include "PasteboardContentGtk.h" PasteboardContentGtk sounds like if there was a PasteboardContent base class and this is the Gtk implementation. Since this is already inside a gtk dir and only used inide GTK ifdefs, we don't need to use Gtk in the name. > Source/WebKit2/Shared/gtk/PasteboardContentGtk.cpp:23 > +#include "DataObjectGtk.h" This should be included as <WebCore/DataObjectGtk.h> > Source/WebKit2/Shared/gtk/PasteboardContentGtk.cpp:32 > +PasteboardContentGtk::PasteboardContentGtk() > +{ > +} Use = default in the header. > Source/WebKit2/Shared/gtk/PasteboardContentGtk.cpp:43 > + encoder << static_cast<bool>(dataObject); > + if (dataObject) > + IPC::encode(encoder, dataObject.get()); We should never allow to encode a PasteboardContent without a dataObject. The default constructor is only required to the decode method, were we need to pass a ref to be filled. > Source/WebKit2/Shared/gtk/PasteboardContentGtk.cpp:53 > + bool hasPasteboardContent; > + if (!decoder.decode(hasPasteboardContent)) > + return false; > + > + if (!hasPasteboardContent) > + return true; So, this is not needed either. > Source/WebKit2/UIProcess/WebPasteboardProxy.h:45 > +#if PLATFORM(GTK) > +class PasteboardContentGtk; > +#endif Move this below. > Source/WebKit2/UIProcess/WebPasteboardProxy.h:90 > + void setSelection(const String& pasteboardName, const WebKit::PasteboardContentGtk&); > + void getSelection(const String& pasteboardName, WebKit::PasteboardContentGtk&); No need for WebKit:: inside WebKit namespace > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:29 > +#include <Shared/gtk/PasteboardContentGtk.h> This should be "PasteboardContentGtk.h" include the directory to the include dir list if needed in the makefile. > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:39 > +void WebPasteboardProxy::setSelection(const String& pasteboardName, const WebKit::PasteboardContentGtk& pasteboardContent) No need for WebKit:: > Source/WebKit2/UIProcess/gtk/WebPasteboardProxyGtk.cpp:44 > +void WebPasteboardProxy::getSelection(const String& pasteboardName, WebKit::PasteboardContentGtk& pasteboardContent) Ditto. > Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:349 > +void WebPlatformStrategies::setSelection(const String& pasteboardName, WebCore::DataObjectGtk* dataObject) This should receive a reference instead of a pointer. > Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:359 > + return WTFMove(pasteboardContent.dataObject); I'm don't think WTFMove() is needed in this case. 1228737 34 cgarcia 2016-09-12 06:37:26 -0700 (In reply to comment #32) > (In reply to comment #25) > > Comment on attachment 288269 [details] > > Patch, implement clipboard as a PlatformPasteboard > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=288269&action=review > > > > What about WebEditorClient::updateGlobalSelection()? it's currently > > protected by X11 guards, could we remove those guards now? > > I need to investigate that. Having an implementation of primary selection is > dependent on the compositor, and I'm not sure how well gtk+ will fare with > gtk_clipboard_wait_for_contents() on it if the compositor doesn't offer an > implementation. An option might be teaching PasteboardHelper to do > gtk_clipboard_request* so stalls are not possible. > > With gnome-shell/mutter it should just work though. My point is that there's nothing X11 specific in there, and guards are compile time, so when building X11 and wayland at the same time that code will be used in wayland anyway. > > > We don't like to use boolean parameters since it's harder to read; instead, you can do something like this: > > > > > > enum class ShouldIncludeSmartPaste { No, Yes }; > > > > > > void writeToClipboard(ShouldIncludeSmartPaste = ShouldIncludeSmartPaste::No); > > > > > > Then instead of calling writeToClipboard(true), you call writeToClipboard(ShouldIncludeSmartPaste::Yes), which is easier to read. Also consider whether having the default argument is really worth it; I'd probably just pass the tag everywhere to be explicit about it. > > > > We already have an enum SmartPasteInclusion in PasteboardHelper > > I think this is the only unaddressed comment. IMHO it's PasteboardHelper's > enum which should change to using the one defined here, since this one is > exposed in shared layers. If you think this modification belongs to the > patch at hand I'll do that. It's ok. 1228739 35 288564 cgarcia 2016-09-12 06:47:35 -0700 Comment on attachment 288564 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288564&action=review > Source/WebCore/platform/gtk/PasteboardGtk.cpp:219 > - if (m_gtkClipboard) > - PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, pasteboardContent.canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste, pasteboardContent.callback.get()); > + writeToClipboard(pasteboardContent.canSmartCopyOrDelete ? ShouldIncludeSmartPaste::Yes : ShouldIncludeSmartPaste::No); Wait, this one is breaking the callback used for global selection, since we are now ignoring pasteboardContent.callback. We need to rework all that, I don't remember why we needed to colapse the selection when cleared. 1229549 36 288814 carlosg 2016-09-14 08:11:27 -0700 Created attachment 288814 Patch, implement clipboard as a PlatformPasteboard 1229564 37 288814 cgarcia 2016-09-14 08:47:46 -0700 Comment on attachment 288814 Patch, implement clipboard as a PlatformPasteboard View in context: https://bugs.webkit.org/attachment.cgi?id=288814&action=review This looks really good now, I only have a few more comments > Source/WebCore/platform/gtk/DataObjectGtk.cpp:142 > + m_hasSmartPaste = false; This set when writing to the clipboard based on whether SmartReplaceOption passed is CanSmartReplace. So I think it's more accurate to call this canSmartPaste > Source/WebCore/platform/gtk/DataObjectGtk.h:79 > + bool m_hasSmartPaste; bool m_hasSmartPaste { false }; > Source/WebCore/platform/gtk/PasteboardGtk.cpp:197 > - if (m_gtkClipboard) > - PasteboardHelper::singleton().writeClipboardContents(m_gtkClipboard, *m_dataObject, pasteboardContent.canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste, pasteboardContent.callback.get()); > + writeToClipboard(); We should pass the smart paste in this case too depending on pasteboardContent.canSmartCopyOrDelete > Source/WebCore/platform/gtk/PasteboardGtk.cpp:260 > - return m_gtkClipboard && PasteboardHelper::singleton().clipboardContentSupportsSmartReplace(m_gtkClipboard); > + readFromClipboard(); > + return !m_dataObject->unknownTypeData("application/vnd.webkitgtk.smartpaste").isEmpty(); I don't think this is correct, we shouldn't mix canSmartPaste with unknown types. I guess we could make canSmartPaste bidirectional, and in case of reading, set it also using gtk_clipboard_wait_is_target_available as we did before. > Source/WebCore/platform/gtk/PasteboardHelper.cpp:292 > - GRefPtr<GtkTargetList> list = targetListForDataObject(dataObject, includeSmartPaste); > + GRefPtr<GtkTargetList> list = targetListForDataObject(dataObject, dataObject.hasSmartPaste() ? IncludeSmartPaste : DoNotIncludeSmartPaste); I think we should remove smart paste parameter from targetListForDataObject, since it already received the data object. > Source/WebKit2/Shared/gtk/PasteboardContent.h:33 > + explicit PasteboardContent(RefPtr<WebCore::DataObjectGtk>); I think this could receive a const reference too 1229578 38 288825 carlosg 2016-09-14 09:19:30 -0700 Created attachment 288825 Patch, implement clipboard as a PlatformPasteboard Thanks for the review! I applied all suggestions, and removed the "smart paste" checks from using unknownDataTypes, now canSmartReplace() is set both ways on the DataObjectGtk. 1229582 39 288825 cgarcia 2016-09-14 09:31:34 -0700 Comment on attachment 288825 Patch, implement clipboard as a PlatformPasteboard Excellent! 1229591 40 288825 commit-queue 2016-09-14 09:47:55 -0700 Comment on attachment 288825 Patch, implement clipboard as a PlatformPasteboard Clearing flags on attachment: 288825 Committed r205909: <http://trac.webkit.org/changeset/205909> 1229592 41 commit-queue 2016-09-14 09:48:02 -0700 All reviewed patches have been landed. Closing bug. 1231581 42 jeremyhu 2016-09-20 02:31:13 -0700 Build failure regression tracked in: https://bugs.webkit.org/show_bug.cgi?id=162261 1238106 43 mcatanzaro 2016-10-09 13:32:08 -0700 It broke layout test editing/pasteboard/image-in-iframe, see bug #163185. 288269 2016-09-08 08:55:24 -0700 2016-09-12 03:03:00 -0700 Patch, implement clipboard as a PlatformPasteboard webkit-platform-gtkclipboard.patch text/plain 29773 carlosg ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3MDRiNzUyLi5mYmY2YzY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTcg QEAKKzIwMTYtMDktMDggIENhcmxvcyBHYXJuYWNobyAgPGNhcmxvc2dAZ25vbWUub3JnPgorCisg ICAgICAgIFtHVEtdIE1hbmFnZSBzZWxlY3Rpb25zIHRocm91Z2ggUGxhdGZvcm1QYXN0ZWJvYXJk CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDY1NzQK KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbXBsZW1l bnQgUGxhdGZvcm1QYXN0ZWJvYXJkIGluIHRoZSBHVEsrIHBsYXRmb3JtLCBhbmQgbW92ZSBQYXN0 ZWJvYXJkCisgICAgICAgIHRvIHVzaW5nIFBhc3RlYm9hcmRTdHJhdGVneSBzbyBjbGlwYm9hcmQg bWFuYWdlbWVudCBpcyBsZWZ0IHRvIHRoZQorICAgICAgICBVSVByb2Nlc3MuCisKKyAgICAgICAg RGF0YU9iamVjdEd0ayBpcyBzdGlsbCB1c2VkIGluIHRoZSBQYXN0ZWJvYXJkIEdUSyBpbXBsZW1l bnRhdGlvbiwgaXQncworICAgICAgICBub3cganVzdCBuZXZlciBiYWNrZWQgYnkgYSBHdGtDbGlw Ym9hcmQsIHRoaXMgb2JqZWN0IGlzIGluc3RlYWQKKyAgICAgICAgc2VyaWFsaXplZCB0aHJvdWdo IFBhc3RlYm9hcmRTdHJhdGVneSwgc28gdGhlIFVJUHJvY2VzcyBzaWRlIGNhbiBtaXJyb3IKKyAg ICAgICAgdGhlIGNvbnRlbnQgaW4gYSBHdGtDbGlwYm9hcmQtYmFja2VkIERhdGFPYmplY3RHdGss IHdoaWNoIGlzIHRoZW4KKyAgICAgICAgZXhwb3NlZCB0byB0aGUgd2luZG93aW5nIHRocm91Z2gg UGxhdGZvcm1QYXN0ZWJvYXJkL1Bhc3RlYm9hcmRIZWxwZXIuCisKKyAgICAgICAgV2hlbiByZXF1 ZXN0aW5nIGNsaXBib2FyZCBjb250ZW50LCBpdCB3b3JrcyBzaW1pbGFybHksIHRoZSBVSVByb2Nl c3MKKyAgICAgICAgc2lkZSBmaXJzdCB1cGRhdGVzIGl0cyBEYXRhT2JqZWN0R3RrLCB3aGljaCBp cyB0aGVuIG1pcnJvcmVkIGJ5IHRoZQorICAgICAgICBXZWJQcm9jZXNzIHRocm91Z2ggdGhlIFBh c3RlYm9hcmRTdHJhdGVneSByZXF1ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtl OiBBZGRlZCBQbGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwCisgICAgICAgICogcGxhdGZvcm0vUGFz dGVib2FyZC5oOiBDbGVhbmVkIHVwIG9mIGRpcmVjdCBHVEsrIGRlcGVuZGVuY3kKKyAgICAgICAg KiBwbGF0Zm9ybS9QYXN0ZWJvYXJkU3RyYXRlZ3kuaDogQWRkZWQgcGx1bWJpbmcgdG93YXJkcyB0 aGUgcGFzdGVib2FyZAorICAgICAgICBwcm94eS4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUGFz dGVib2FyZEd0ay5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjcmVhdGVGb3JD b3B5QW5kUGFzdGUpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6Y3JlYXRlRm9yR2xv YmFsU2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OlBhc3RlYm9hcmQp OgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6cGFzdGVib2FyZE5hbWUpOgorICAgICAg ICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6d3JpdGVUb0NsaXBib2FyZCk6CisgICAgICAgIChXZWJD b3JlOjpQYXN0ZWJvYXJkOjpyZWFkRnJvbUNsaXBib2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQ YXN0ZWJvYXJkOjp3cml0ZVBsYWluVGV4dCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJk Ojp3cml0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVBhc3RlYm9hcmQp OgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6Y2xlYXIpOgorICAgICAgICAoV2ViQ29y ZTo6UGFzdGVib2FyZDo6Y2FuU21hcnRSZXBsYWNlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OnJlYWQpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6aGFzRGF0YSk6Cisg ICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp0eXBlcyk6CisgICAgICAgIChXZWJDb3JlOjpQ YXN0ZWJvYXJkOjpyZWFkU3RyaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnJl YWRGaWxlbmFtZXMpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6d3JpdGVTdHJpbmcp OiBNYWRlIHRvIHVzZSB0aGUKKyAgICAgICAgUGFzdGVib2FyZFN0cmF0ZWd5IGluc3RlYWQgb2Yg UGFzdGVib2FyZEhlbHBlci9HVEsrIEFQSS4KKyAgICAgICAgKiBwbGF0Zm9ybS9QbGF0Zm9ybVBh c3RlYm9hcmQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3Rr LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6OlBsYXRm b3JtUGFzdGVib2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6OmNs ZWFyU2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlBsYXRmb3JtUGFzdGVib2FyZDo6Y2xh aW1TZWxlY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1QYXN0ZWJvYXJkOjpnZXRU eXBlcyk6CisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6OnNldFN0cmluZ0Zv clR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1QYXN0ZWJvYXJkOjpyZWFkU3RyaW5n KTogSW1wbGVtZW50ZWQKKyAgICAgICAgUGxhdGZvcm1QYXN0ZWJvYXJkIHVzaW5nIFBhc3RlYm9h cmRIZWxwZXIvR1RLKyBBUEkuCisKIDIwMTYtMDktMDQgIEFudHRpIEtvaXZpc3RvICA8YW50dGlA YXBwbGUuY29tPgogCiAgICAgICAgIFJldmVyc2Ugb3duZXJzaGlwIHJlbGF0aW9uIG9mIFN0eWxl Q2FjaGVkSW1hZ2UgYW5kIENTU0ltYWdlVmFsdWUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5k ZXggZjIxZmMwNC4uNmMxMzk1YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTIyMSw2 ICsyMjEsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlUGxhdGZvcm1HVEtfU09VUkNFUwogICAgIHBs YXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmNwcAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9y bUtleWJvYXJkRXZlbnRHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1BsYXRmb3JtTW91c2VFdmVu dEd0ay5jcHAKKyAgICBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcAogICAg IHBsYXRmb3JtL2d0ay9QbGF0Zm9ybVNjcmVlbkd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvUGxh dGZvcm1XaGVlbEV2ZW50R3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9SZW5kZXJUaGVtZUdhZGdl dC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmQuaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmQuaAppbmRleCA0NzMzYjM1Li5iNWY0 YjE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZC5oCkBAIC0zMyw3ICszMyw2IEBA CiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKICNpZiBQTEFURk9STShHVEspCi10 eXBlZGVmIHN0cnVjdCBfR3RrQ2xpcGJvYXJkIEd0a0NsaXBib2FyZDsKICNpbmNsdWRlIDx3dGYv Z2xpYi9HUmVmUHRyLmg+CiAjZW5kaWYKIApAQCAtMTQzLDggKzE0Miw5IEBAIHB1YmxpYzoKICAg ICB+UGFzdGVib2FyZCgpOwogCiAjaWYgUExBVEZPUk0oR1RLKQorICAgIGVudW0gUGFzdGVib2Fy ZFR5cGUgeyBOb25lLCBQcmltYXJ5LCBTZWxlY3Rpb24gfTsKKyAgICBleHBsaWNpdCBQYXN0ZWJv YXJkKFBhc3RlYm9hcmRUeXBlKTsKICAgICBleHBsaWNpdCBQYXN0ZWJvYXJkKFJlZlB0cjxEYXRh T2JqZWN0R3RrPiYmKTsKLSAgICBleHBsaWNpdCBQYXN0ZWJvYXJkKEd0a0NsaXBib2FyZCopOwog I2VuZGlmCiAKICNpZiBQTEFURk9STShXSU4pCkBAIC0yMjYsOCArMjI2LDExIEBAIHByaXZhdGU6 CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNKEdUSykKKyAgICBTdHJpbmcgcGFzdGVib2FyZE5hbWUo dm9pZCk7CisgICAgdm9pZCB3cml0ZVRvQ2xpcGJvYXJkKGJvb2wgaW5jbHVkZVNtYXJ0UGFzdGUg PSBmYWxzZSk7CisgICAgdm9pZCByZWFkRnJvbUNsaXBib2FyZCh2b2lkKTsKICAgICBSZWZQdHI8 RGF0YU9iamVjdEd0az4gbV9kYXRhT2JqZWN0OwotICAgIEd0a0NsaXBib2FyZCogbV9ndGtDbGlw Ym9hcmQ7CisgICAgUGFzdGVib2FyZFR5cGUgbV9wYXN0ZWJvYXJkVHlwZTsKICNlbmRpZgogCiAj aWYgUExBVEZPUk0oSU9TKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFz dGVib2FyZFN0cmF0ZWd5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkU3Ry YXRlZ3kuaAppbmRleCA2MzAwODVlLi43MWNjZDBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkU3RyYXRlZ3kuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9QYXN0ZWJvYXJkU3RyYXRlZ3kuaApAQCAtNjgsNiArNjgsMTMgQEAgcHVibGljOgogICAg IHZpcnR1YWwgbG9uZyBzZXRQYXRobmFtZXNGb3JUeXBlKGNvbnN0IFZlY3RvcjxTdHJpbmc+Jiwg Y29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFt ZSkgPSAwOwogICAgIHZpcnR1YWwgbG9uZyBzZXRTdHJpbmdGb3JUeXBlKGNvbnN0IFN0cmluZyYs IGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5h bWUpID0gMDsKICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2aXJ0dWFsIHZvaWQgY2xl YXJTZWxlY3Rpb24oU3RyaW5nIHNlbGVjdGlvbik7CisgICAgdmlydHVhbCB2b2lkIGNsYWltU2Vs ZWN0aW9uKFN0cmluZyBzZWxlY3Rpb24pOworICAgIHZpcnR1YWwgVmVjdG9yPFN0cmluZz4gZ2V0 VHlwZXMoU3RyaW5nIHNlbGVjdGlvbik7CisgICAgdmlydHVhbCB2b2lkIHNldFN0cmluZyhTdHJp bmcgc2VsZWN0aW9uLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUsIFN0cmluZyBidWZmZXIpOworICAg IHZpcnR1YWwgU3RyaW5nIGdldFN0cmluZyhTdHJpbmcgc2VsZWN0aW9uLCBTdHJpbmcgcGFzdGVi b2FyZFR5cGUpOworI2VuZGlmIC8vIFBMQVRGT1JNKEdUSykKIHByb3RlY3RlZDoKICAgICB2aXJ0 dWFsIH5QYXN0ZWJvYXJkU3RyYXRlZ3koKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1BsYXRmb3JtUGFzdGVib2FyZC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKaW5kZXggMGJiNmUyZC4uYzBhZDkwZSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKQEAgLTgxLDYgKzgxLDEx IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCBVUkwgcmVhZFVSTChpbnQgaW5kZXgsIGNv bnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUpOwogICAgIFdFQkNPUkVfRVhQT1JUIGludCBjb3Vu dCgpOwogCisjaWYgUExBVEZPUk0oR1RLKQorICAgIFdFQkNPUkVfRVhQT1JUIHZvaWQgY2xlYXJT ZWxlY3Rpb24oKTsKKyAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsYWltU2VsZWN0aW9uKCk7Cisj ZW5kaWYKKwogcHJpdmF0ZToKICNpZiBQTEFURk9STShNQUMpCiAgICAgUmV0YWluUHRyPE5TUGFz dGVib2FyZD4gbV9wYXN0ZWJvYXJkOwpAQCAtODgsNiArOTMsOSBAQCBwcml2YXRlOgogI2lmIFBM QVRGT1JNKElPUykKICAgICBSZXRhaW5QdHI8VUlQYXN0ZWJvYXJkPiBtX3Bhc3RlYm9hcmQ7CiAj ZW5kaWYKKyNpZiBQTEFURk9STShHVEspCisgICAgR3RrQ2xpcGJvYXJkKiBtX2NsaXBib2FyZDsK KyNlbmRpZgogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1Bhc3RlYm9hcmRHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9h cmRHdGsuY3BwCmluZGV4IDEzYzBkZDAuLmI3YjVkNjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkR3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5jcHAKQEAgLTIzLDkgKzIzLDkgQEAKICNpbmNsdWRl ICJEYXRhT2JqZWN0R3RrLmgiCiAjaW5jbHVkZSAiRHJhZ0RhdGEuaCIKICNpbmNsdWRlICJJbWFn ZS5oIgorI2luY2x1ZGUgIlBhc3RlYm9hcmRTdHJhdGVneS5oIgorI2luY2x1ZGUgIlBsYXRmb3Jt U3RyYXRlZ2llcy5oIgogI2luY2x1ZGUgIlVSTC5oIgotI2luY2x1ZGUgIlBhc3RlYm9hcmRIZWxw ZXIuaCIKLSNpbmNsdWRlIDxndGsvZ3RrLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAt NDAsMTIgKzQwLDEyIEBAIGVudW0gQ2xpcGJvYXJkRGF0YVR5cGUgewogCiBzdGQ6OnVuaXF1ZV9w dHI8UGFzdGVib2FyZD4gUGFzdGVib2FyZDo6Y3JlYXRlRm9yQ29weUFuZFBhc3RlKCkKIHsKLSAg ICByZXR1cm4gc3RkOjptYWtlX3VuaXF1ZTxQYXN0ZWJvYXJkPihndGtfY2xpcGJvYXJkX2dldChH REtfU0VMRUNUSU9OX0NMSVBCT0FSRCkpOworICAgIHJldHVybiBzdGQ6Om1ha2VfdW5pcXVlPFBh c3RlYm9hcmQ+KFNlbGVjdGlvbik7CiB9CiAKIHN0ZDo6dW5pcXVlX3B0cjxQYXN0ZWJvYXJkPiBQ YXN0ZWJvYXJkOjpjcmVhdGVGb3JHbG9iYWxTZWxlY3Rpb24oKQogewotICAgIHJldHVybiBzdGQ6 Om1ha2VfdW5pcXVlPFBhc3RlYm9hcmQ+KGd0a19jbGlwYm9hcmRfZ2V0KEdES19TRUxFQ1RJT05f UFJJTUFSWSkpOworICAgIHJldHVybiBzdGQ6Om1ha2VfdW5pcXVlPFBhc3RlYm9hcmQ+KFByaW1h cnkpOwogfQogCiBzdGQ6OnVuaXF1ZV9wdHI8UGFzdGVib2FyZD4gUGFzdGVib2FyZDo6Y3JlYXRl UHJpdmF0ZSgpCkBAIC03NiwxNyArNzYsMTUgQEAgUGFzdGVib2FyZEltYWdlOjp+UGFzdGVib2Fy ZEltYWdlKCkKIAogUGFzdGVib2FyZDo6UGFzdGVib2FyZChSZWZQdHI8RGF0YU9iamVjdEd0az4m JiBkYXRhT2JqZWN0KQogICAgIDogbV9kYXRhT2JqZWN0KFdURk1vdmUoZGF0YU9iamVjdCkpCi0g ICAgLCBtX2d0a0NsaXBib2FyZChudWxscHRyKQogewogICAgIEFTU0VSVChtX2RhdGFPYmplY3Qp OwogfQogCi1QYXN0ZWJvYXJkOjpQYXN0ZWJvYXJkKEd0a0NsaXBib2FyZCogZ3RrQ2xpcGJvYXJk KQotICAgIDogbV9kYXRhT2JqZWN0KERhdGFPYmplY3RHdGs6OmZvckNsaXBib2FyZChndGtDbGlw Ym9hcmQpKQotICAgICwgbV9ndGtDbGlwYm9hcmQoZ3RrQ2xpcGJvYXJkKQorUGFzdGVib2FyZDo6 UGFzdGVib2FyZChQYXN0ZWJvYXJkVHlwZSB0eXBlKQorICAgIDogbV9kYXRhT2JqZWN0KERhdGFP YmplY3RHdGs6OmNyZWF0ZSgpKQorICAgICwgbV9wYXN0ZWJvYXJkVHlwZSh0eXBlKQogewogICAg IEFTU0VSVChtX2RhdGFPYmplY3QpOwotICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigp LnJlZ2lzdGVyQ2xpcGJvYXJkKGd0a0NsaXBib2FyZCk7CiB9CiAKIFBhc3RlYm9hcmQ6On5QYXN0 ZWJvYXJkKCkKQEAgLTEyMSw2ICsxMTksNjIgQEAgc3RhdGljIENsaXBib2FyZERhdGFUeXBlIGRh dGFPYmplY3RUeXBlRnJvbUhUTUxDbGlwYm9hcmRUeXBlKGNvbnN0IFN0cmluZyYgcmF3VHkKICAg ICByZXR1cm4gQ2xpcGJvYXJkRGF0YVR5cGVVbmtub3duOwogfQogCitTdHJpbmcgUGFzdGVib2Fy ZDo6cGFzdGVib2FyZE5hbWUodm9pZCkKK3sKKyAgICBpZiAobV9wYXN0ZWJvYXJkVHlwZSA9PSBQ cmltYXJ5KQorICAgICAgICByZXR1cm4gIlBSSU1BUlkiOworICAgIGlmIChtX3Bhc3RlYm9hcmRU eXBlID09IFNlbGVjdGlvbikKKyAgICAgICAgcmV0dXJuICJDTElQQk9BUkQiOworICAgIHJldHVy biBlbXB0eVN0cmluZygpOworfQorCit2b2lkIFBhc3RlYm9hcmQ6OndyaXRlVG9DbGlwYm9hcmQo Ym9vbCBpbmNsdWRlU21hcnRQYXN0ZSkKK3sKKyAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kmIHN0cmF0 ZWd5ID0gKnBsYXRmb3JtU3RyYXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKTsKKyAgICBT dHJpbmcgc2VsZWN0aW9uID0gcGFzdGVib2FyZE5hbWUoKTsKKworICAgIEFTU0VSVCghc2VsZWN0 aW9uLmlzRW1wdHkoKSk7CisKKyAgICBzdHJhdGVneS5jbGVhclNlbGVjdGlvbihzZWxlY3Rpb24p OworCisgICAgaWYgKG1fZGF0YU9iamVjdC0+aGFzVGV4dCgpKQorICAgICAgICBzdHJhdGVneS5z ZXRTdHJpbmcoc2VsZWN0aW9uLCAiVGV4dCIsIG1fZGF0YU9iamVjdC0+dGV4dCgpKTsKKyAgICBp ZiAobV9kYXRhT2JqZWN0LT5oYXNNYXJrdXAoKSkKKyAgICAgICAgc3RyYXRlZ3kuc2V0U3RyaW5n KHNlbGVjdGlvbiwgInRleHQvaHRtbCIsIG1fZGF0YU9iamVjdC0+bWFya3VwKCkpOworICAgIGlm IChtX2RhdGFPYmplY3QtPmhhc1VSTCgpKQorICAgICAgICBzdHJhdGVneS5zZXRTdHJpbmcoc2Vs ZWN0aW9uLCAiVVJMIiwgbV9kYXRhT2JqZWN0LT51cmwoKSk7CisgICAgaWYgKG1fZGF0YU9iamVj dC0+aGFzVVJJTGlzdCgpKQorICAgICAgICBzdHJhdGVneS5zZXRTdHJpbmcoc2VsZWN0aW9uLCAi RmlsZXMiLCBtX2RhdGFPYmplY3QtPnVyaUxpc3QoKSk7CisKKyAgICBpZiAobV9kYXRhT2JqZWN0 LT5oYXNVbmtub3duVHlwZURhdGEoKSkgeworICAgICAgICBmb3IgKGF1dG8mIGl0IDogbV9kYXRh T2JqZWN0LT51bmtub3duVHlwZXMoKSkgeworICAgICAgICAgICAgaWYgKGl0LmtleSA9PSAiYXBw bGljYXRpb24vdm5kLndlYmtpdGd0ay5zbWFydHBhc3RlIiAmJiAhaW5jbHVkZVNtYXJ0UGFzdGUp CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBzdHJhdGVneS5zZXRTdHJp bmcoc2VsZWN0aW9uLCBpdC5rZXksIGl0LnZhbHVlKTsKKyAgICAgICAgfQorICAgIH0KKworICAg IHN0cmF0ZWd5LmNsYWltU2VsZWN0aW9uKHNlbGVjdGlvbik7Cit9CisKK3ZvaWQgUGFzdGVib2Fy ZDo6cmVhZEZyb21DbGlwYm9hcmQodm9pZCkKK3sKKyAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kmIHN0 cmF0ZWd5ID0gKnBsYXRmb3JtU3RyYXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKTsKKyAg ICBTdHJpbmcgc2VsZWN0aW9uID0gcGFzdGVib2FyZE5hbWUoKTsKKworICAgIG1fZGF0YU9iamVj dC0+Y2xlYXJBbGwoKTsKKworICAgIFZlY3RvcjxTdHJpbmc+IHR5cGVzOworICAgIHR5cGVzID0g c3RyYXRlZ3kuZ2V0VHlwZXMoc2VsZWN0aW9uKTsKKworICAgIGZvciAoYXV0byBpdCA6IHR5cGVz KSB7CisgICAgICAgIGlmIChkYXRhT2JqZWN0VHlwZUZyb21IVE1MQ2xpcGJvYXJkVHlwZShpdCkg PT0gQ2xpcGJvYXJkRGF0YVR5cGVVbmtub3duKQorICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIFN0cmluZyBkYXRhID0gc3RyYXRlZ3kuZ2V0U3RyaW5nKHNlbGVjdGlvbiwgaXQpOworICAg ICAgICB3cml0ZVN0cmluZyhpdCwgZGF0YSk7CisgICAgfQorfQorCiB2b2lkIFBhc3RlYm9hcmQ6 OndyaXRlU3RyaW5nKGNvbnN0IFN0cmluZyYgdHlwZSwgY29uc3QgU3RyaW5nJiBkYXRhKQogewog ICAgIHN3aXRjaCAoZGF0YU9iamVjdFR5cGVGcm9tSFRNTENsaXBib2FyZFR5cGUodHlwZSkpIHsK QEAgLTE0Nyw4ICsyMDEsOCBAQCB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlUGxhaW5UZXh0KGNvbnN0 IFN0cmluZyYgdGV4dCwgU21hcnRSZXBsYWNlT3B0aW9uIHNtYXJ0UmVwbAogICAgIG1fZGF0YU9i amVjdC0+Y2xlYXJBbGwoKTsKICAgICBtX2RhdGFPYmplY3QtPnNldFRleHQodGV4dCk7CiAKLSAg ICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRv bigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsIChzbWFydFJlcGxhY2VP cHRpb24gPT0gQ2FuU21hcnRSZXBsYWNlKSA/IFBhc3RlYm9hcmRIZWxwZXI6OkluY2x1ZGVTbWFy dFBhc3RlIDogUGFzdGVib2FyZEhlbHBlcjo6RG9Ob3RJbmNsdWRlU21hcnRQYXN0ZSk7CisgICAg aWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gTm9uZSkKKyAgICAgICAgd3JpdGVUb0NsaXBib2FyZChz bWFydFJlcGxhY2VPcHRpb24gPT0gQ2FuU21hcnRSZXBsYWNlKTsKIH0KIAogdm9pZCBQYXN0ZWJv YXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkVVJMJiBwYXN0ZWJvYXJkVVJMKQpAQCAtMTU4LDgg KzIxMiw4IEBAIHZvaWQgUGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZFVSTCYgcGFz dGVib2FyZFVSTCkKICAgICBtX2RhdGFPYmplY3QtPmNsZWFyQWxsKCk7CiAgICAgbV9kYXRhT2Jq ZWN0LT5zZXRVUkwocGFzdGVib2FyZFVSTC51cmwsIHBhc3RlYm9hcmRVUkwudGl0bGUpOwogCi0g ICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0 b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICBpZiAobV9w YXN0ZWJvYXJkVHlwZSAhPSBOb25lKQorICAgICAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9CiAK IHZvaWQgUGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZEltYWdlJiBwYXN0ZWJvYXJk SW1hZ2UpCkBAIC0xNzQsOCArMjI4LDggQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQ YXN0ZWJvYXJkSW1hZ2UmIHBhc3RlYm9hcmRJbWFnZSkKICAgICBpZiAocGl4YnVmKQogICAgICAg ICBtX2RhdGFPYmplY3QtPnNldEltYWdlKHBpeGJ1Zi5nZXQoKSk7CiAKLSAgICBpZiAobV9ndGtD bGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xp cGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBl ICE9IE5vbmUpCisgICAgICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0KIAogdm9pZCBQYXN0ZWJv YXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkV2ViQ29udGVudCYgcGFzdGVib2FyZENvbnRlbnQp CkBAIC0xODQsOCArMjM4LDggQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJv YXJkV2ViQ29udGVudCYgcGFzdGVib2FyZENvbnRlbnQpCiAgICAgbV9kYXRhT2JqZWN0LT5zZXRU ZXh0KHBhc3RlYm9hcmRDb250ZW50LnRleHQpOwogICAgIG1fZGF0YU9iamVjdC0+c2V0TWFya3Vw KHBhc3RlYm9hcmRDb250ZW50Lm1hcmt1cCk7CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0g ICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVu dHMobV9ndGtDbGlwYm9hcmQsIHBhc3RlYm9hcmRDb250ZW50LmNhblNtYXJ0Q29weU9yRGVsZXRl ID8gUGFzdGVib2FyZEhlbHBlcjo6SW5jbHVkZVNtYXJ0UGFzdGUgOiBQYXN0ZWJvYXJkSGVscGVy OjpEb05vdEluY2x1ZGVTbWFydFBhc3RlLCBwYXN0ZWJvYXJkQ29udGVudC5jYWxsYmFjay5nZXQo KSk7CisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gTm9uZSkKKyAgICAgICAgd3JpdGVUb0Ns aXBib2FyZChwYXN0ZWJvYXJkQ29udGVudC5jYW5TbWFydENvcHlPckRlbGV0ZSk7CiB9CiAKIHZv aWQgUGFzdGVib2FyZDo6d3JpdGVQYXN0ZWJvYXJkKGNvbnN0IFBhc3RlYm9hcmQmIHNvdXJjZVBh c3RlYm9hcmQpCkBAIC0yMDgsOCArMjYyLDggQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZVBhc3Rl Ym9hcmQoY29uc3QgUGFzdGVib2FyZCYgc291cmNlUGFzdGVib2FyZCkKICAgICAgICAgICAgIG1f ZGF0YU9iamVjdC0+c2V0VW5rbm93blR5cGVEYXRhKGl0LmtleSwgaXQudmFsdWUpOwogICAgIH0K IAotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2lu Z2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYg KG1fcGFzdGVib2FyZFR5cGUgIT0gTm9uZSkKKyAgICAgICAgd3JpdGVUb0NsaXBib2FyZCgpOwog fQogCiB2b2lkIFBhc3RlYm9hcmQ6OmNsZWFyKCkKQEAgLTIyMCw4ICsyNzQsOCBAQCB2b2lkIFBh c3RlYm9hcmQ6OmNsZWFyKCkKICAgICAvLyBzdGlsbCBjb250YWluIHRoZSAiRmlsZXMiIHN0cmlu ZyBpZiBhbnkgZmlsZXMgd2VyZSBpbmNsdWRlZCBpbiB0aGUgZHJhZykuIgogICAgIG1fZGF0YU9i amVjdC0+Y2xlYXJBbGxFeGNlcHRGaWxlbmFtZXMoKTsKIAotICAgIGlmIChtX2d0a0NsaXBib2Fy ZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRD b250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gTm9u ZSkKKyAgICAgICAgd3JpdGVUb0NsaXBib2FyZCgpOwogfQogCiB2b2lkIFBhc3RlYm9hcmQ6OmNs ZWFyKGNvbnN0IFN0cmluZyYgdHlwZSkKQEAgLTI0NSwxMyArMjk5LDIyIEBAIHZvaWQgUGFzdGVi b2FyZDo6Y2xlYXIoY29uc3QgU3RyaW5nJiB0eXBlKQogICAgICAgICBicmVhazsKICAgICB9CiAK LSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmds ZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIGlmICht X3Bhc3RlYm9hcmRUeXBlICE9IE5vbmUpCisgICAgICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0K IAogYm9vbCBQYXN0ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UoKQogewotICAgIHJldHVybiBtX2d0 a0NsaXBib2FyZCAmJiBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5jbGlwYm9hcmRDb250 ZW50U3VwcG9ydHNTbWFydFJlcGxhY2UobV9ndGtDbGlwYm9hcmQpOworICAgIFBhc3RlYm9hcmRT dHJhdGVneSYgc3RyYXRlZ3kgPSAqcGxhdGZvcm1TdHJhdGVnaWVzKCktPnBhc3RlYm9hcmRTdHJh dGVneSgpOworCisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgPT0gTm9uZSkKKyAgICAgICAgcmV0 dXJuIGZhbHNlOworCisgICAgVmVjdG9yPFN0cmluZz4gdHlwZXM7CisgICAgdHlwZXMgPSBzdHJh dGVneS5nZXRUeXBlcyhwYXN0ZWJvYXJkTmFtZSgpKTsKKyAgICByZXR1cm4gdHlwZXMuY29udGFp bnMoImFwcGxpY2F0aW9uL3ZuZC53ZWJraXRndGsuc21hcnRwYXN0ZSIpOworCisgICAgcmV0dXJu IGZhbHNlOwogfQogCiAjaWYgRU5BQkxFKERSQUdfU1VQUE9SVCkKQEAgLTI2MiwyMyArMzI1LDI0 IEBAIHZvaWQgUGFzdGVib2FyZDo6c2V0RHJhZ0ltYWdlKERyYWdJbWFnZVJlZiwgY29uc3QgSW50 UG9pbnQmKQogCiB2b2lkIFBhc3RlYm9hcmQ6OnJlYWQoUGFzdGVib2FyZFBsYWluVGV4dCYgdGV4 dCkKIHsKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6 OnNpbmdsZXRvbigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICBp ZiAobV9wYXN0ZWJvYXJkVHlwZSAhPSBOb25lKQorICAgICAgICByZWFkRnJvbUNsaXBib2FyZCgp OworCiAgICAgdGV4dC50ZXh0ID0gbV9kYXRhT2JqZWN0LT50ZXh0KCk7CiB9CiAKIGJvb2wgUGFz dGVib2FyZDo6aGFzRGF0YSgpCiB7Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQ YXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0Ns aXBib2FyZCk7CisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gTm9uZSkKKyAgICAgICAgcmVh ZEZyb21DbGlwYm9hcmQoKTsKIAogICAgIHJldHVybiBtX2RhdGFPYmplY3QtPmhhc1RleHQoKSB8 fCBtX2RhdGFPYmplY3QtPmhhc01hcmt1cCgpIHx8IG1fZGF0YU9iamVjdC0+aGFzVVJJTGlzdCgp IHx8IG1fZGF0YU9iamVjdC0+aGFzSW1hZ2UoKSB8fCBtX2RhdGFPYmplY3QtPmhhc1Vua25vd25U eXBlRGF0YSgpOwogfQogCiBWZWN0b3I8U3RyaW5nPiBQYXN0ZWJvYXJkOjp0eXBlcygpCiB7Ci0g ICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0 b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYgKG1fcGFz dGVib2FyZFR5cGUgIT0gTm9uZSkKKyAgICAgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKIAogICAg IFZlY3RvcjxTdHJpbmc+IHR5cGVzOwogICAgIGlmIChtX2RhdGFPYmplY3QtPmhhc1RleHQoKSkg ewpAQCAtMzA2LDggKzM3MCw4IEBAIFZlY3RvcjxTdHJpbmc+IFBhc3RlYm9hcmQ6OnR5cGVzKCkK IAogU3RyaW5nIFBhc3RlYm9hcmQ6OnJlYWRTdHJpbmcoY29uc3QgU3RyaW5nJiB0eXBlKQogewot ICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xl dG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIGlmIChtX3Bh c3RlYm9hcmRUeXBlICE9IE5vbmUpCisgICAgICAgIHJlYWRGcm9tQ2xpcGJvYXJkKCk7CiAKICAg ICBzd2l0Y2ggKGRhdGFPYmplY3RUeXBlRnJvbUhUTUxDbGlwYm9hcmRUeXBlKHR5cGUpKSB7CiAg ICAgY2FzZSBDbGlwYm9hcmREYXRhVHlwZVVSSUxpc3Q6CkBAIC0zMjksOCArMzkzLDggQEAgU3Ry aW5nIFBhc3RlYm9hcmQ6OnJlYWRTdHJpbmcoY29uc3QgU3RyaW5nJiB0eXBlKQogCiBWZWN0b3I8 U3RyaW5nPiBQYXN0ZWJvYXJkOjpyZWFkRmlsZW5hbWVzKCkKIHsKLSAgICBpZiAobV9ndGtDbGlw Ym9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLmdldENsaXBib2Fy ZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICBpZiAobV9wYXN0ZWJvYXJkVHlwZSAhPSBO b25lKQorICAgICAgICByZWFkRnJvbUNsaXBib2FyZCgpOwogCiAgICAgcmV0dXJuIG1fZGF0YU9i amVjdC0+ZmlsZW5hbWVzKCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9QbGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAuLjlhZjNkZjQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcApAQCAtMCwwICsxLDExMSBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0CisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQbGF0Zm9y bVBhc3RlYm9hcmQuaCIKKworI2luY2x1ZGUgIkNvbG9yLmgiCisjaW5jbHVkZSAiRGF0YU9iamVj dEd0ay5oIgorI2luY2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKKyNpbmNsdWRlICJTaGFyZWRC dWZmZXIuaCIKKyNpbmNsdWRlICJVUkwuaCIKKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworUGxhdGZvcm1QYXN0ZWJvYXJkOjpQbGF0Zm9ybVBhc3RlYm9hcmQo Y29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkKKyAgICA6IG1fY2xpcGJvYXJkKGd0a19jbGlw Ym9hcmRfZ2V0KGdka19hdG9tX2ludGVybihwYXN0ZWJvYXJkTmFtZS51dGY4KCkuZGF0YSgpLCB0 cnVlKSkpCit7CisgICAgQVNTRVJUKG1fZ3RrQ2xpcGJvYXJkKTsKK30KKwordm9pZCBQbGF0Zm9y bVBhc3RlYm9hcmQ6OmNsZWFyU2VsZWN0aW9uKCkKK3sKKyAgICBEYXRhT2JqZWN0R3RrKiBkYXRh ID0gRGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkKG1fY2xpcGJvYXJkKTsKKyAgICBkYXRhLT5j bGVhckFsbCgpOworfQorCit2b2lkIFBsYXRmb3JtUGFzdGVib2FyZDo6Y2xhaW1TZWxlY3Rpb24o KQoreworICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29u dGVudHMobV9jbGlwYm9hcmQpOworfQorCit2b2lkIFBsYXRmb3JtUGFzdGVib2FyZDo6Z2V0VHlw ZXMoVmVjdG9yPFN0cmluZz4mIHBhc3RlYm9hcmRUeXBlcykKK3sKKyAgICBQYXN0ZWJvYXJkSGVs cGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2NsaXBib2FyZCk7CisgICAg RGF0YU9iamVjdEd0ayogZGF0YSA9IERhdGFPYmplY3RHdGs6OmZvckNsaXBib2FyZChtX2NsaXBi b2FyZCk7CisKKyAgICBpZiAoZGF0YS0+aGFzVGV4dCgpKSB7CisgICAgICAgIHBhc3RlYm9hcmRU eXBlcy5hcHBlbmQoQVNDSUlMaXRlcmFsKCJ0ZXh0L3BsYWluIikpOworICAgICAgICBwYXN0ZWJv YXJkVHlwZXMuYXBwZW5kKEFTQ0lJTGl0ZXJhbCgiVGV4dCIpKTsKKyAgICAgICAgcGFzdGVib2Fy ZFR5cGVzLmFwcGVuZChBU0NJSUxpdGVyYWwoInRleHQiKSk7CisgICAgfQorCisgICAgaWYgKGRh dGEtPmhhc01hcmt1cCgpKQorICAgICAgICBwYXN0ZWJvYXJkVHlwZXMuYXBwZW5kKEFTQ0lJTGl0 ZXJhbCgidGV4dC9odG1sIikpOworCisgICAgaWYgKGRhdGEtPmhhc1VSSUxpc3QoKSkgeworICAg ICAgICBwYXN0ZWJvYXJkVHlwZXMuYXBwZW5kKEFTQ0lJTGl0ZXJhbCgidGV4dC91cmktbGlzdCIp KTsKKyAgICAgICAgcGFzdGVib2FyZFR5cGVzLmFwcGVuZChBU0NJSUxpdGVyYWwoIlVSTCIpKTsK KyAgICB9CisKKyAgICBpZiAoZGF0YS0+aGFzRmlsZW5hbWVzKCkpCisgICAgICAgIHBhc3RlYm9h cmRUeXBlcy5hcHBlbmQoQVNDSUlMaXRlcmFsKCJGaWxlcyIpKTsKKworICAgIGZvciAoYXV0byYg a2V5IDogZGF0YS0+dW5rbm93blR5cGVzKCkua2V5cygpKQorICAgICAgICBwYXN0ZWJvYXJkVHlw ZXMuYXBwZW5kKGtleSk7Cit9CisKK2xvbmcgUGxhdGZvcm1QYXN0ZWJvYXJkOjpzZXRTdHJpbmdG b3JUeXBlKGNvbnN0IFN0cmluZyYgdmFsdWUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUp Cit7CisgICAgRGF0YU9iamVjdEd0ayogZGF0YSA9IERhdGFPYmplY3RHdGs6OmZvckNsaXBib2Fy ZChtX2NsaXBib2FyZCk7CisKKyAgICBpZiAocGFzdGVib2FyZFR5cGUgPT0gIlRleHQiIHx8IHBh c3RlYm9hcmRUeXBlID09ICJ0ZXh0IiB8fCBwYXN0ZWJvYXJkVHlwZSA9PSAidGV4dC9wbGFpbiIg fHwgcGFzdGVib2FyZFR5cGUuc3RhcnRzV2l0aCgidGV4dC9wbGFpbjsiKSkKKyAgICAgICAgZGF0 YS0+c2V0VGV4dCh2YWx1ZSk7CisgICAgaWYgKHBhc3RlYm9hcmRUeXBlID09ICJ0ZXh0L2h0bWwi IHx8IHBhc3RlYm9hcmRUeXBlLnN0YXJ0c1dpdGgoInRleHQvaHRtbDsiKSkKKyAgICAgICAgZGF0 YS0+c2V0TWFya3VwKHZhbHVlKTsKKyAgICBpZiAocGFzdGVib2FyZFR5cGUgPT0gIlVSTCIgfHwg cGFzdGVib2FyZFR5cGUgPT0gIkZpbGVzIiB8fCBwYXN0ZWJvYXJkVHlwZSA9PSAidGV4dC91cmkt bGlzdCIgfHwgcGFzdGVib2FyZFR5cGUuc3RhcnRzV2l0aCgidGV4dC91cmktbGlzdDsiKSkKKyAg ICAgICAgZGF0YS0+c2V0VVJJTGlzdCh2YWx1ZSk7CisKKyAgICByZXR1cm4gMDsKK30KKworU3Ry aW5nIFBsYXRmb3JtUGFzdGVib2FyZDo6cmVhZFN0cmluZyhpbnQsIGNvbnN0IFN0cmluZyYgcGFz dGVib2FyZFR5cGUpCit7CisgICAgRGF0YU9iamVjdEd0ayogZGF0YSA9IERhdGFPYmplY3RHdGs6 OmZvckNsaXBib2FyZChtX2NsaXBib2FyZCk7CisKKyAgICBpZiAocGFzdGVib2FyZFR5cGUgPT0g IlRleHQiIHx8IHBhc3RlYm9hcmRUeXBlID09ICJ0ZXh0IiB8fCBwYXN0ZWJvYXJkVHlwZSA9PSAi dGV4dC9wbGFpbiIgfHwgcGFzdGVib2FyZFR5cGUuc3RhcnRzV2l0aCgidGV4dC9wbGFpbjsiKSkK KyAgICAgICAgcmV0dXJuIGRhdGEtPnRleHQoKTsKKyAgICBpZiAocGFzdGVib2FyZFR5cGUgPT0g IlVSTCIpCisgICAgICAgIHJldHVybiBkYXRhLT51cmwoKTsKKyAgICBpZiAocGFzdGVib2FyZFR5 cGUgPT0gInRleHQvaHRtbCIgfHwgcGFzdGVib2FyZFR5cGUuc3RhcnRzV2l0aCgidGV4dC9odG1s OyIpKQorICAgICAgICByZXR1cm4gZGF0YS0+bWFya3VwKCk7CisgICAgaWYgKHBhc3RlYm9hcmRU eXBlID09ICJGaWxlcyIgfHwgcGFzdGVib2FyZFR5cGUgPT0gInRleHQvdXJpLWxpc3QiIHx8IHBh c3RlYm9hcmRUeXBlLnN0YXJ0c1dpdGgoInRleHQvdXJpLWxpc3Q7IikpCisgICAgICAgIHJldHVy biBkYXRhLT51cmlMaXN0KCk7CisKKyAgICByZXR1cm4gZW1wdHlTdHJpbmcoKTsKK30KKworfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hh bmdlTG9nCmluZGV4IDY3ZmI2OGMuLmEzNzFhYTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNiBA QAorMjAxNi0wOS0wOCAgQ2FybG9zIEdhcm5hY2hvICA8Y2FybG9zZ0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgW0dUS10gTWFuYWdlIHNlbGVjdGlvbnMgdGhyb3VnaCBQbGF0Zm9ybVBhc3RlYm9hcmQK KworICAgICAgICBBZGQgdGhlIG5lY2Vzc2FyeSBwbHVtYmluZyBmb3IgdGhlIEdUSysgYmFja2Vu ZCB0byB1c2UgdGhlCisgICAgICAgIFBsYXRmb3JtUGFzdGVib2FyZCBpbiBXZWJDb3JlLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ2NTc0CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBQbGF0Zm9ybUdU Sy5jbWFrZTogQWRkIFdlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKKyAgICAgICAgKiBVSVByb2Nl c3MvV2ViUGFzdGVib2FyZFByb3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhc3RlYm9h cmRQcm94eS5tZXNzYWdlcy5pbjogQWRkZWQgcGx1bWJpbmcgZm9yIHRoZQorICAgICAgICBHVEsr IHBhc3RlYm9hcmQgcHJveHkgZnVuY3Rpb25zLgorICAgICAgICAqIFVJUHJvY2Vzcy9ndGsvV2Vi UGFzdGVib2FyZFByb3h5R3RrLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6Omxvb2t1cFBs YXRmb3JtUGFzdGVib2FyZCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhc3RlYm9hcmRQcm94eTo6 Y2xlYXJTZWxlY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OmNs YWltU2VsZWN0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFzdGVib2FyZFByb3h5OjpnZXRU eXBlcyk6CisgICAgICAgIChXZWJLaXQ6OldlYlBhc3RlYm9hcmRQcm94eTo6c2V0U3RyaW5nKToK KyAgICAgICAgKFdlYktpdDo6V2ViUGFzdGVib2FyZFByb3h5OjpnZXRTdHJpbmcpOiBJbXBsZW1l bnRlZCBmdW5jdGlvbnMgaG9va2luZworICAgICAgICBpbnRvIHRoZSBQbGF0Zm9ybVBhc3RlYm9h cmQuIFBlci1zZWxlY3Rpb24gKGllLiBwcmltYXJ5L2NsaXBib2FyZCkKKyAgICAgICAgUGxhdGZv cm1QYXN0ZWJvYXJkcyBhcmUga2VwdCBhdCB0aGlzIGxldmVsLCBzbyB0aG9zZSBhcmUgaW5kZXBl bmRlbnRseQorICAgICAgICBzZXQgYW5kIGRlYWx0IHdpdGguCisgICAgICAgICogV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwOgorICAgICAgICAoV2Vi S2l0OjpXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OmNsZWFyU2VsZWN0aW9uKToKKyAgICAgICAgKFdl YktpdDo6V2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpjbGFpbVNlbGVjdGlvbik6CisgICAgICAgIChX ZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6Z2V0VHlwZXMpOgorICAgICAgICAoV2ViS2l0 OjpXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OnNldFN0cmluZyk6CisgICAgICAgIChXZWJLaXQ6Oldl YlBsYXRmb3JtU3RyYXRlZ2llczo6Z2V0U3RyaW5nKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oOiBBZGRlZCBtZXRob2RzIHRvCisg ICAgICAgIHNlbmQgdGhlIFdlYlByb2Nlc3MtPlVJUHJvY2VzcyBtZXNzYWdlcy4KKwogMjAxNi0w OS0wNCAgQ29tbWl0IFF1ZXVlICA8Y29tbWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAg VW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjIwNTQxNS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UK aW5kZXggZTY0MDYwMy4uOTFlMGNjMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZv cm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UKQEAgLTMx Myw2ICszMTMsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nlc3Mv Z3RrL1dlYkluc3BlY3RvckNsaWVudEd0ay5jcHAKICAgICBVSVByb2Nlc3MvZ3RrL1dlYkluc3Bl Y3RvclByb3h5R3RrLmNwcAogICAgIFVJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcAor ICAgIFVJUHJvY2Vzcy9ndGsvV2ViUGFzdGVib2FyZFByb3h5R3RrLmNwcAogICAgIFVJUHJvY2Vz cy9ndGsvV2ViUG9wdXBNZW51UHJveHlHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJQcmVm ZXJlbmNlc0d0ay5jcHAKICAgICBVSVByb2Nlc3MvZ3RrL1dlYlByb2Nlc3NQb29sR3RrLmNwcApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5o IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5oCmluZGV4IDVl MmE1YjEuLmJmNjIyNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ YXN0ZWJvYXJkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFzdGVi b2FyZFByb3h5LmgKQEAgLTgxLDYgKzgxLDEzIEBAIHByaXZhdGU6CiAgICAgdm9pZCBzZXRQYXN0 ZWJvYXJkU3RyaW5nRm9yVHlwZShjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBT dHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJpbmcmLCB1aW50NjRfdCYgbmV3Q2hhbmdl Q291bnQpOwogICAgIHZvaWQgc2V0UGFzdGVib2FyZEJ1ZmZlckZvclR5cGUoY29uc3QgU3RyaW5n JiBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU2hh cmVkTWVtb3J5OjpIYW5kbGUmLCB1aW50NjRfdCBzaXplLCB1aW50NjRfdCYgbmV3Q2hhbmdlQ291 bnQpOwogI2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHZvaWQgY2xlYXJTZWxlY3Rpb24o U3RyaW5nIHNlbGVjdGlvbik7CisgICAgdm9pZCBjbGFpbVNlbGVjdGlvbihTdHJpbmcgc2VsZWN0 aW9uKTsKKyAgICB2b2lkIGdldFR5cGVzKFN0cmluZyBzZWxlY3Rpb24sIFZlY3RvcjxTdHJpbmc+ JiB0eXBlcyk7CisgICAgdm9pZCBzZXRTdHJpbmcoU3RyaW5nIHNlbGVjdGlvbiwgU3RyaW5nIHBh c3RlYm9hcmRUeXBlLCBTdHJpbmcgYnVmZmVyKTsKKyAgICB2b2lkIGdldFN0cmluZyhTdHJpbmcg c2VsZWN0aW9uLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUsIFN0cmluZyYgdmFsdWUpOworI2VuZGlm IC8vIFBMQVRGT1JNKEdUSykKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5p biBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMu aW4KaW5kZXggZDBkOWZhMS4uMDM2OTk2NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5Lm1lc3NhZ2VzLmluCkBAIC00OCw0ICs0OCwx MiBAQCBtZXNzYWdlcyAtPiBXZWJQYXN0ZWJvYXJkUHJveHkgewogICAgIFNldFBhc3RlYm9hcmRT dHJpbmdGb3JUeXBlKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSwgU3RyaW5nIHBhc3RlYm9hcmRUeXBl LCBTdHJpbmcgc3RyaW5nKSAtPiAodWludDY0X3QgY2hhbmdlQ291bnQpCiAgICAgU2V0UGFzdGVi b2FyZEJ1ZmZlckZvclR5cGUoU3RyaW5nIHBhc3RlYm9hcmROYW1lLCBTdHJpbmcgcGFzdGVib2Fy ZFR5cGUsIFdlYktpdDo6U2hhcmVkTWVtb3J5OjpIYW5kbGUgaGFuZGxlLCB1aW50NjRfdCBzaXpl KSAtPiAodWludDY0X3QgY2hhbmdlQ291bnQpCiAjZW5kaWYKKworI2lmIFBMQVRGT1JNKEdUSykK KyAgICBDbGVhclNlbGVjdGlvbihTdHJpbmcgc2VsZWN0aW9uKQorICAgIENsYWltU2VsZWN0aW9u KFN0cmluZyBzZWxlY3Rpb24pCisgICAgR2V0VHlwZXMoU3RyaW5nIHNlbGVjdGlvbikgLT4gKFZl Y3RvcjxTdHJpbmc+IHR5cGVzKQorICAgIFNldFN0cmluZyhTdHJpbmcgc2VsZWN0aW9uLCBTdHJp bmcgcGFzdGVib2FyZFR5cGUsIFN0cmluZyBidWZmZXIpCisgICAgR2V0U3RyaW5nKFN0cmluZyBz ZWxlY3Rpb24sIFN0cmluZyBwYXN0ZWJvYXJkVHlwZSkgLT4gKFN0cmluZyBzdHJpbmcpCisjZW5k aWYKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFzdGVi b2FyZFByb3h5R3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFzdGVi b2FyZFByb3h5R3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMWI2 YmNiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQ YXN0ZWJvYXJkUHJveHlHdGsuY3BwCkBAIC0wLDAgKzEsNzggQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTYgUmVkIEhhdC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIldlYlBhc3RlYm9hcmRQcm94eS5oIgorCisjaW5jbHVkZSA8V2ViQ29yZS9QbGF0Zm9ybVBh c3RlYm9hcmQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0 L1N0cmluZ0hhc2guaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBX ZWJLaXQgeworCitzdGF0aWMgV2ViQ29yZTo6UGxhdGZvcm1QYXN0ZWJvYXJkKiBsb29rdXBQbGF0 Zm9ybVBhc3RlYm9hcmQoY29uc3QgU3RyaW5nJiBzZWxlY3Rpb24pCit7CisgICAgc3RhdGljIEhh c2hNYXA8U3RyaW5nLCBzdGQ6OnVuaXF1ZV9wdHI8V2ViQ29yZTo6UGxhdGZvcm1QYXN0ZWJvYXJk PiA+IHBhc3RlYm9hcmRNYXA7CisKKyAgICBhdXRvIGFkZFJlc3VsdCA9IHBhc3RlYm9hcmRNYXAu YWRkKHNlbGVjdGlvbiwgbnVsbHB0cik7CisgICAgaWYgKGFkZFJlc3VsdC5pc05ld0VudHJ5KQor ICAgICAgICBhZGRSZXN1bHQuaXRlcmF0b3ItPnZhbHVlID0gc3RkOjptYWtlX3VuaXF1ZTxQbGF0 Zm9ybVBhc3RlYm9hcmQ+KHNlbGVjdGlvbik7CisKKyAgICByZXR1cm4gYWRkUmVzdWx0Lml0ZXJh dG9yLT52YWx1ZS5nZXQoKTsKK30KKwordm9pZCBXZWJQYXN0ZWJvYXJkUHJveHk6OmNsZWFyU2Vs ZWN0aW9uKFN0cmluZyBzZWxlY3Rpb24pCit7CisgICAgUGxhdGZvcm1QYXN0ZWJvYXJkKiBwYXN0 ZWJvYXJkID0gbG9va3VwUGxhdGZvcm1QYXN0ZWJvYXJkKHNlbGVjdGlvbik7CisgICAgcGFzdGVi b2FyZC0+Y2xlYXJTZWxlY3Rpb24oKTsKK30KKwordm9pZCBXZWJQYXN0ZWJvYXJkUHJveHk6OmNs YWltU2VsZWN0aW9uKFN0cmluZyBzZWxlY3Rpb24pCit7CisgICAgUGxhdGZvcm1QYXN0ZWJvYXJk KiBwYXN0ZWJvYXJkID0gbG9va3VwUGxhdGZvcm1QYXN0ZWJvYXJkKHNlbGVjdGlvbik7CisgICAg cGFzdGVib2FyZC0+Y2xhaW1TZWxlY3Rpb24oKTsKK30KKwordm9pZCBXZWJQYXN0ZWJvYXJkUHJv eHk6OmdldFR5cGVzKFN0cmluZyBzZWxlY3Rpb24sIFZlY3RvcjxTdHJpbmc+JiB0eXBlcykKK3sK KyAgICBQbGF0Zm9ybVBhc3RlYm9hcmQqIHBhc3RlYm9hcmQgPSBsb29rdXBQbGF0Zm9ybVBhc3Rl Ym9hcmQoc2VsZWN0aW9uKTsKKyAgICBwYXN0ZWJvYXJkLT5nZXRUeXBlcyh0eXBlcyk7Cit9CisK K3ZvaWQgV2ViUGFzdGVib2FyZFByb3h5OjpzZXRTdHJpbmcoU3RyaW5nIHNlbGVjdGlvbiwgU3Ry aW5nIHBhc3RlYm9hcmRUeXBlLCBTdHJpbmcgYnVmZmVyKQoreworICAgIFBsYXRmb3JtUGFzdGVi b2FyZCogcGFzdGVib2FyZCA9IGxvb2t1cFBsYXRmb3JtUGFzdGVib2FyZChzZWxlY3Rpb24pOwor ICAgIHBhc3RlYm9hcmQtPnNldFN0cmluZ0ZvclR5cGUoYnVmZmVyLCBwYXN0ZWJvYXJkVHlwZSk7 Cit9CisKK3ZvaWQgV2ViUGFzdGVib2FyZFByb3h5OjpnZXRTdHJpbmcoU3RyaW5nIHNlbGVjdGlv biwgU3RyaW5nIHBhc3RlYm9hcmRUeXBlLCBTdHJpbmcmIHZhbHVlKQoreworICAgIFBsYXRmb3Jt UGFzdGVib2FyZCogcGFzdGVib2FyZCA9IGxvb2t1cFBsYXRmb3JtUGFzdGVib2FyZChzZWxlY3Rp b24pOworICAgIHZhbHVlID0gcGFzdGVib2FyZC0+cmVhZFN0cmluZygwLCBwYXN0ZWJvYXJkVHlw ZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwIGIv U291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0 ZWdpZXMuY3BwCmluZGV4IDAxOWMxMzMuLmNhYzQyZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3Jt U3RyYXRlZ2llcy5jcHAKQEAgLTMzOSw0ICszMzksMzggQEAgbG9uZyBXZWJQbGF0Zm9ybVN0cmF0 ZWdpZXM6OmNoYW5nZUNvdW50KCkKIAogI2VuZGlmIC8vIFBMQVRGT1JNKENPQ09BKQogCisjaWYg UExBVEZPUk0oR1RLKQorLy8gUGFzdGVib2FyZFN0cmF0ZWd5CisKK3ZvaWQgV2ViUGxhdGZvcm1T dHJhdGVnaWVzOjpjbGVhclNlbGVjdGlvbihTdHJpbmcgc2VsZWN0aW9uKQoreworICAgIFdlYlBy b2Nlc3M6OnNpbmdsZXRvbigpLnBhcmVudFByb2Nlc3NDb25uZWN0aW9uKCktPnNlbmQoTWVzc2Fn ZXM6OldlYlBhc3RlYm9hcmRQcm94eTo6Q2xlYXJTZWxlY3Rpb24oc2VsZWN0aW9uKSwgMCk7Cit9 CisKK3ZvaWQgV2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpjbGFpbVNlbGVjdGlvbihTdHJpbmcgc2Vs ZWN0aW9uKQoreworICAgIFdlYlByb2Nlc3M6OnNpbmdsZXRvbigpLnBhcmVudFByb2Nlc3NDb25u ZWN0aW9uKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhc3RlYm9hcmRQcm94eTo6Q2xhaW1TZWxlY3Rp b24oc2VsZWN0aW9uKSwgMCk7Cit9CisKK1ZlY3RvcjxTdHJpbmc+IFdlYlBsYXRmb3JtU3RyYXRl Z2llczo6Z2V0VHlwZXMoU3RyaW5nIHNlbGVjdGlvbikKK3sKKyAgICBWZWN0b3I8U3RyaW5nPiB0 eXBlczsKKyAgICBXZWJQcm9jZXNzOjpzaW5nbGV0b24oKS5wYXJlbnRQcm9jZXNzQ29ubmVjdGlv bigpLT5zZW5kU3luYyhNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5OjpHZXRUeXBlcyhzZWxl Y3Rpb24pLCBNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5OjpHZXRUeXBlczo6UmVwbHkodHlw ZXMpLCAwKTsKKyAgICByZXR1cm4gdHlwZXM7Cit9CisKK3ZvaWQgV2ViUGxhdGZvcm1TdHJhdGVn aWVzOjpzZXRTdHJpbmcoU3RyaW5nIHNlbGVjdGlvbiwgU3RyaW5nIHBhc3RlYm9hcmRUeXBlLCBT dHJpbmcgYnVmZmVyKQoreworICAgIFdlYlByb2Nlc3M6OnNpbmdsZXRvbigpLnBhcmVudFByb2Nl c3NDb25uZWN0aW9uKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhc3RlYm9hcmRQcm94eTo6U2V0U3Ry aW5nKHNlbGVjdGlvbiwgcGFzdGVib2FyZFR5cGUsIGJ1ZmZlciksIDApOworfQorCitTdHJpbmcg V2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpnZXRTdHJpbmcoU3RyaW5nIHNlbGVjdGlvbiwgU3RyaW5n IHBhc3RlYm9hcmRUeXBlKQoreworICAgIFN0cmluZyB2YWx1ZTsKKyAgICBXZWJQcm9jZXNzOjpz aW5nbGV0b24oKS5wYXJlbnRQcm9jZXNzQ29ubmVjdGlvbigpLT5zZW5kU3luYyhNZXNzYWdlczo6 V2ViUGFzdGVib2FyZFByb3h5OjpHZXRTdHJpbmcoc2VsZWN0aW9uLCBwYXN0ZWJvYXJkVHlwZSks IE1lc3NhZ2VzOjpXZWJQYXN0ZWJvYXJkUHJveHk6OkdldFN0cmluZzo6UmVwbHkodmFsdWUpLCAw KTsKKyAgICByZXR1cm4gdmFsdWU7Cit9CisKKyNlbmRpZiAvLyBQTEFURk9STShHVEspCisKIH0g Ly8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaCBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmgKaW5kZXgg Nzk4ZWQyYy4uNzFiYjJiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCkBAIC04 Niw3ICs4NiwxMyBAQCBwcml2YXRlOgogICAgIGxvbmcgc2V0UGF0aG5hbWVzRm9yVHlwZShjb25z dCBWZWN0b3I8U3RyaW5nPiYsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0 cmluZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJyaWRlOwogICAgIGxvbmcgc2V0U3RyaW5nRm9yVHlw ZShjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJp bmcmIHBhc3RlYm9hcmROYW1lKSBvdmVycmlkZTsKICNlbmRpZgotCisjaWYgUExBVEZPUk0oR1RL KQorICAgIHZvaWQgY2xlYXJTZWxlY3Rpb24oU3RyaW5nIHNlbGVjdGlvbikgb3ZlcnJpZGU7Cisg ICAgdm9pZCBjbGFpbVNlbGVjdGlvbihTdHJpbmcgc2VsZWN0aW9uKSBvdmVycmlkZTsKKyAgICBW ZWN0b3I8U3RyaW5nPiBnZXRUeXBlcyhTdHJpbmcgc2VsZWN0aW9uKSBvdmVycmlkZTsKKyAgICB2 b2lkIHNldFN0cmluZyhTdHJpbmcgc2VsZWN0aW9uLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUsIFN0 cmluZyBidWZmZXIpIG92ZXJyaWRlOworICAgIFN0cmluZyBnZXRTdHJpbmcoU3RyaW5nIHNlbGVj dGlvbiwgU3RyaW5nIHBhc3RlYm9hcmRUeXBlKSBvdmVycmlkZTsKKyNlbmRpZgogfTsKIAogfSAv LyBuYW1lc3BhY2UgV2ViS2l0Cg== 288563 2016-09-12 03:03:00 -0700 2016-09-12 04:01:04 -0700 Patch, implement clipboard as a PlatformPasteboard webkit-platform-gtkclipboard.patch text/plain 34423 carlosg ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3MDRiNzUyLi5jYWU4ZmIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTkg QEAKKzIwMTYtMDktMTIgIENhcmxvcyBHYXJuYWNobyAgPGNhcmxvc2dAZ25vbWUub3JnPgorCisg ICAgICAgIFtHVEtdW1dheWxhbmRdIEltcGxlbWVudCBjbGlwYm9hcmQgc3VwcG9ydAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ2NTc0CisKKyAgICAg ICAgSW1wbGVtZW50IFBsYXRmb3JtUGFzdGVib2FyZCBpbiB0aGUgR1RLKyBwbGF0Zm9ybSwgYW5k IG1vdmUgUGFzdGVib2FyZAorICAgICAgICB0byB1c2luZyBQYXN0ZWJvYXJkU3RyYXRlZ3kgc28g Y2xpcGJvYXJkIG1hbmFnZW1lbnQgaXMgbGVmdCB0byB0aGUKKyAgICAgICAgVUlQcm9jZXNzLgor CisgICAgICAgIERhdGFPYmplY3RHdGsgaXMgc3RpbGwgdXNlZCBpbiB0aGUgUGFzdGVib2FyZCBH VEsgaW1wbGVtZW50YXRpb24sIGl0J3MKKyAgICAgICAgbm93IGp1c3QgbmV2ZXIgYmFja2VkIGJ5 IGEgR3RrQ2xpcGJvYXJkLCB0aGlzIG9iamVjdCBpcyBpbnN0ZWFkCisgICAgICAgIHNlcmlhbGl6 ZWQgdGhyb3VnaCBQYXN0ZWJvYXJkU3RyYXRlZ3ksIHNvIHRoZSBVSVByb2Nlc3Mgc2lkZSBjYW4g bWlycm9yCisgICAgICAgIHRoZSBjb250ZW50IGluIGEgR3RrQ2xpcGJvYXJkLWJhY2tlZCBEYXRh T2JqZWN0R3RrLCB3aGljaCBpcyB0aGVuCisgICAgICAgIGV4cG9zZWQgdG8gdGhlIHdpbmRvd2lu ZyB0aHJvdWdoIFBsYXRmb3JtUGFzdGVib2FyZC9QYXN0ZWJvYXJkSGVscGVyLgorCisgICAgICAg IFdoZW4gcmVxdWVzdGluZyBjbGlwYm9hcmQgY29udGVudCwgaXQgd29ya3Mgc2ltaWxhcmx5LCB0 aGUgVUlQcm9jZXNzCisgICAgICAgIHNpZGUgZmlyc3QgdXBkYXRlcyBpdHMgRGF0YU9iamVjdEd0 aywgd2hpY2ggaXMgdGhlbiBtaXJyb3JlZCBieSB0aGUKKyAgICAgICAgV2ViUHJvY2VzcyB0aHJv dWdoIHRoZSBQYXN0ZWJvYXJkU3RyYXRlZ3kgcmVxdWVzdHMuCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZTogQWRkZWQg UGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcAorICAgICAgICAqIHBsYXRmb3JtL1Bhc3RlYm9hcmQu aDogQ2xlYW5lZCB1cCBvZiBkaXJlY3QgR1RLKyBkZXBlbmRlbmN5CisgICAgICAgICogcGxhdGZv cm0vUGFzdGVib2FyZFN0cmF0ZWd5Lmg6IEFkZGVkIHBsdW1iaW5nIHRvd2FyZHMgdGhlIHBhc3Rl Ym9hcmQKKyAgICAgICAgcHJveHkuCisgICAgICAgICogcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJv YXJkLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFPYmplY3RHdGs6OnNldEZvckNsaXBib2FyZCk6IEFkZGVkIHNldHRlcgorICAgICAg ICBmdW5jdGlvbiB0byByZXBsYWNlIGEgY2xpcGJvYXJkJ3MgRGF0YU9iamVjdEd0ay4KKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9QYXN0ZWJvYXJkR3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OmNyZWF0 ZUZvckNvcHlBbmRQYXN0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjcmVhdGVG b3JHbG9iYWxTZWxlY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6UGFzdGVi b2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpwYXN0ZWJvYXJkTmFtZSk6Cisg ICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVRvQ2xpcGJvYXJkKToKKyAgICAgICAg KFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnJlYWRGcm9tQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNv cmU6OlBhc3RlYm9hcmQ6OndyaXRlUGxhaW5UZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OndyaXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OndyaXRlUGFzdGVi b2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjbGVhcik6CisgICAgICAgIChX ZWJDb3JlOjpQYXN0ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UpOgorICAgICAgICAoV2ViQ29yZTo6 UGFzdGVib2FyZDo6cmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpoYXNEYXRh KToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnR5cGVzKToKKyAgICAgICAgKFdlYkNv cmU6OlBhc3RlYm9hcmQ6OnJlYWRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2Fy ZDo6cmVhZEZpbGVuYW1lcyk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVN0 cmluZyk6IE1hZGUgdG8gdXNlIHRoZQorICAgICAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kgaW5zdGVh ZCBvZiBQYXN0ZWJvYXJkSGVscGVyL0dUSysgQVBJLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Q bGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBsYXRm b3JtUGFzdGVib2FyZDo6UGxhdGZvcm1QYXN0ZWJvYXJkKToKKyAgICAgICAgKFdlYkNvcmU6OlBs YXRmb3JtUGFzdGVib2FyZDo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlBsYXRm b3JtUGFzdGVib2FyZDo6Z2V0U2VsZWN0aW9uKTogSW1wbGVtZW50ZWQKKyAgICAgICAgUGxhdGZv cm1QYXN0ZWJvYXJkIHVzaW5nIFBhc3RlYm9hcmRIZWxwZXIvR1RLKyBBUEkuCisKIDIwMTYtMDkt MDQgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmVyc2Ug b3duZXJzaGlwIHJlbGF0aW9uIG9mIFN0eWxlQ2FjaGVkSW1hZ2UgYW5kIENTU0ltYWdlVmFsdWUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dl YkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggZjIxZmMwNC4uNmMxMzk1YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUv UGxhdGZvcm1HVEsuY21ha2UKQEAgLTIyMSw2ICsyMjEsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3Jl UGxhdGZvcm1HVEtfU09VUkNFUwogICAgIHBsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmNw cAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybUtleWJvYXJkRXZlbnRHdGsuY3BwCiAgICAgcGxh dGZvcm0vZ3RrL1BsYXRmb3JtTW91c2VFdmVudEd0ay5jcHAKKyAgICBwbGF0Zm9ybS9ndGsvUGxh dGZvcm1QYXN0ZWJvYXJkR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybVNjcmVlbkd0 ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1XaGVlbEV2ZW50R3RrLmNwcAogICAgIHBs YXRmb3JtL2d0ay9SZW5kZXJUaGVtZUdhZGdldC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3Rl Ym9hcmQuaAppbmRleCA0NzMzYjM1Li5kOTFjNTZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFz dGVib2FyZC5oCkBAIC0zMyw3ICszMyw2IEBACiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5n Lmg+CiAKICNpZiBQTEFURk9STShHVEspCi10eXBlZGVmIHN0cnVjdCBfR3RrQ2xpcGJvYXJkIEd0 a0NsaXBib2FyZDsKICNpbmNsdWRlIDx3dGYvZ2xpYi9HUmVmUHRyLmg+CiAjZW5kaWYKIApAQCAt MTQzLDggKzE0Miw5IEBAIHB1YmxpYzoKICAgICB+UGFzdGVib2FyZCgpOwogCiAjaWYgUExBVEZP Uk0oR1RLKQorICAgIGVudW0gY2xhc3MgUGFzdGVib2FyZFR5cGUgeyBOb25lLCBQcmltYXJ5LCBD bGlwYm9hcmQgfTsKKyAgICBleHBsaWNpdCBQYXN0ZWJvYXJkKFBhc3RlYm9hcmRUeXBlKTsKICAg ICBleHBsaWNpdCBQYXN0ZWJvYXJkKFJlZlB0cjxEYXRhT2JqZWN0R3RrPiYmKTsKLSAgICBleHBs aWNpdCBQYXN0ZWJvYXJkKEd0a0NsaXBib2FyZCopOwogI2VuZGlmCiAKICNpZiBQTEFURk9STShX SU4pCkBAIC0yMjYsOCArMjI2LDEyIEBAIHByaXZhdGU6CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JN KEdUSykKKyAgICBTdHJpbmcgcGFzdGVib2FyZE5hbWUoKSBjb25zdDsKKyAgICBlbnVtIGNsYXNz IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlIHsgTm8sIFllcyB9OworICAgIHZvaWQgd3JpdGVUb0Ns aXBib2FyZChTaG91bGRJbmNsdWRlU21hcnRQYXN0ZSA9IFNob3VsZEluY2x1ZGVTbWFydFBhc3Rl OjpObyk7CisgICAgdm9pZCByZWFkRnJvbUNsaXBib2FyZCgpOwogICAgIFJlZlB0cjxEYXRhT2Jq ZWN0R3RrPiBtX2RhdGFPYmplY3Q7Ci0gICAgR3RrQ2xpcGJvYXJkKiBtX2d0a0NsaXBib2FyZDsK KyAgICBQYXN0ZWJvYXJkVHlwZSBtX3Bhc3RlYm9hcmRUeXBlOwogI2VuZGlmCiAKICNpZiBQTEFU Rk9STShJT1MpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJk U3RyYXRlZ3kuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmRTdHJhdGVneS5o CmluZGV4IDYzMDA4NWUuLjI4OTI3M2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Bhc3RlYm9hcmRTdHJhdGVneS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bh c3RlYm9hcmRTdHJhdGVneS5oCkBAIC0zNyw2ICszNyw5IEBAIGNsYXNzIFNoYXJlZEJ1ZmZlcjsK IGNsYXNzIFVSTDsKIHN0cnVjdCBQYXN0ZWJvYXJkSW1hZ2U7CiBzdHJ1Y3QgUGFzdGVib2FyZFdl YkNvbnRlbnQ7CisjaWYgUExBVEZPUk0oR1RLKQorY2xhc3MgRGF0YU9iamVjdEd0azsKKyNlbmRp ZgogCiBjbGFzcyBQYXN0ZWJvYXJkU3RyYXRlZ3kgewogcHVibGljOgpAQCAtNjgsNiArNzEsMTAg QEAgcHVibGljOgogICAgIHZpcnR1YWwgbG9uZyBzZXRQYXRobmFtZXNGb3JUeXBlKGNvbnN0IFZl Y3RvcjxTdHJpbmc+JiwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5n JiBwYXN0ZWJvYXJkTmFtZSkgPSAwOwogICAgIHZpcnR1YWwgbG9uZyBzZXRTdHJpbmdGb3JUeXBl KGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0cmlu ZyYgcGFzdGVib2FyZE5hbWUpID0gMDsKICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0U2VsZWN0aW9uKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSwgV2ViQ29yZTo6 RGF0YU9iamVjdEd0ayopID0gMDsKKyAgICB2aXJ0dWFsIFJlZlB0cjxXZWJDb3JlOjpEYXRhT2Jq ZWN0R3RrPiBnZXRTZWxlY3Rpb24oU3RyaW5nIHBhc3RlYm9hcmROYW1lKSA9IDA7CisjZW5kaWYg Ly8gUExBVEZPUk0oR1RLKQogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgflBhc3RlYm9hcmRTdHJh dGVneSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZv cm1QYXN0ZWJvYXJkLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybVBhc3RlYm9h cmQuaAppbmRleCAwYmI2ZTJkLi5hZjA5NTk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9QbGF0Zm9ybVBhc3RlYm9hcmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9QbGF0Zm9ybVBhc3RlYm9hcmQuaApAQCAtNDEsNiArNDEsOSBAQCBPQkpDX0NMQVNTIFVJUGFz dGVib2FyZDsKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCisjaWYgUExBVEZPUk0oR1RLKQorY2xh c3MgRGF0YU9iamVjdEd0azsKKyNlbmRpZgogY2xhc3MgQ29sb3I7CiBjbGFzcyBTaGFyZWRCdWZm ZXI7CiBjbGFzcyBVUkw7CkBAIC04MSw2ICs4NCwxMSBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9F WFBPUlQgVVJMIHJlYWRVUkwoaW50IGluZGV4LCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBl KTsKICAgICBXRUJDT1JFX0VYUE9SVCBpbnQgY291bnQoKTsKIAorI2lmIFBMQVRGT1JNKEdUSykK KyAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIHNldFNlbGVjdGlvbihEYXRhT2JqZWN0R3RrKik7Cisg ICAgV0VCQ09SRV9FWFBPUlQgRGF0YU9iamVjdEd0ayogZ2V0U2VsZWN0aW9uKCk7CisjZW5kaWYK KwogcHJpdmF0ZToKICNpZiBQTEFURk9STShNQUMpCiAgICAgUmV0YWluUHRyPE5TUGFzdGVib2Fy ZD4gbV9wYXN0ZWJvYXJkOwpAQCAtODgsNiArOTYsOSBAQCBwcml2YXRlOgogI2lmIFBMQVRGT1JN KElPUykKICAgICBSZXRhaW5QdHI8VUlQYXN0ZWJvYXJkPiBtX3Bhc3RlYm9hcmQ7CiAjZW5kaWYK KyNpZiBQTEFURk9STShHVEspCisgICAgR3RrQ2xpcGJvYXJkKiBtX2NsaXBib2FyZDsKKyNlbmRp ZgogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0RhdGFP YmplY3RHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsu Y3BwCmluZGV4IDg3MDkyMzUuLjA1NmQzYWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9EYXRhT2JqZWN0R3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvRGF0YU9iamVjdEd0ay5jcHAKQEAgLTE0NywxMCArMTQ3LDEwIEBAIHZvaWQgRGF0YU9i amVjdEd0azo6Y2xlYXJBbGwoKQogICAgIG1fZmlsZW5hbWVzLmNsZWFyKCk7CiB9CiAKK3N0YXRp YyBIYXNoTWFwPEd0a0NsaXBib2FyZCosIFJlZlB0cjxEYXRhT2JqZWN0R3RrPj4gb2JqZWN0TWFw OworCiBEYXRhT2JqZWN0R3RrKiBEYXRhT2JqZWN0R3RrOjpmb3JDbGlwYm9hcmQoR3RrQ2xpcGJv YXJkKiBjbGlwYm9hcmQpCiB7Ci0gICAgc3RhdGljIEhhc2hNYXA8R3RrQ2xpcGJvYXJkKiwgUmVm UHRyPERhdGFPYmplY3RHdGs+ID4gb2JqZWN0TWFwOwotCiAgICAgYXV0byBhZGRSZXN1bHQgPSBv YmplY3RNYXAuYWRkKGNsaXBib2FyZCwgbnVsbHB0cik7CiAgICAgaWYgKGFkZFJlc3VsdC5pc05l d0VudHJ5KQogICAgICAgICBhZGRSZXN1bHQuaXRlcmF0b3ItPnZhbHVlID0gRGF0YU9iamVjdEd0 azo6Y3JlYXRlKCk7CkBAIC0xNTgsNCArMTU4LDEwIEBAIERhdGFPYmplY3RHdGsqIERhdGFPYmpl Y3RHdGs6OmZvckNsaXBib2FyZChHdGtDbGlwYm9hcmQqIGNsaXBib2FyZCkKICAgICByZXR1cm4g YWRkUmVzdWx0Lml0ZXJhdG9yLT52YWx1ZS5nZXQoKTsKIH0KIAordm9pZCBEYXRhT2JqZWN0R3Rr OjpzZXRGb3JDbGlwYm9hcmQoR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQsIERhdGFPYmplY3RHdGsq IGRhdGFPYmplY3QpCit7CisgICAgYXV0byBhZGRSZXN1bHQgPSBvYmplY3RNYXAuYWRkKGNsaXBi b2FyZCwgbnVsbHB0cik7CisgICAgYWRkUmVzdWx0Lml0ZXJhdG9yLT52YWx1ZSA9IGRhdGFPYmpl Y3Q7Cit9CisKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9EYXRh T2JqZWN0R3RrLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5o CmluZGV4IDNhYmIxZjguLmE5NDhmMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9EYXRhT2JqZWN0R3RrLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L0RhdGFPYmplY3RHdGsuaApAQCAtNjcsNiArNjcsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCBjbGVh ck1hcmt1cCgpOwogCiAgICAgc3RhdGljIERhdGFPYmplY3RHdGsqIGZvckNsaXBib2FyZChHdGtD bGlwYm9hcmQqKTsKKyAgICBzdGF0aWMgdm9pZCBzZXRGb3JDbGlwYm9hcmQoR3RrQ2xpcGJvYXJk KiwgRGF0YU9iamVjdEd0ayopOwogCiBwcml2YXRlOgogICAgIFN0cmluZyBtX3RleHQ7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5jcHAKaW5kZXggMTNjMGRk MC4uMjRlY2ZmNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3Rl Ym9hcmRHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJk R3RrLmNwcApAQCAtMjMsOSArMjMsOSBAQAogI2luY2x1ZGUgIkRhdGFPYmplY3RHdGsuaCIKICNp bmNsdWRlICJEcmFnRGF0YS5oIgogI2luY2x1ZGUgIkltYWdlLmgiCisjaW5jbHVkZSAiUGFzdGVi b2FyZFN0cmF0ZWd5LmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJhdGVnaWVzLmgiCiAjaW5jbHVk ZSAiVVJMLmgiCi0jaW5jbHVkZSAiUGFzdGVib2FyZEhlbHBlci5oIgotI2luY2x1ZGUgPGd0ay9n dGsuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC00MCwxMiArNDAsMTIgQEAgZW51bSBD bGlwYm9hcmREYXRhVHlwZSB7CiAKIHN0ZDo6dW5pcXVlX3B0cjxQYXN0ZWJvYXJkPiBQYXN0ZWJv YXJkOjpjcmVhdGVGb3JDb3B5QW5kUGFzdGUoKQogewotICAgIHJldHVybiBzdGQ6Om1ha2VfdW5p cXVlPFBhc3RlYm9hcmQ+KGd0a19jbGlwYm9hcmRfZ2V0KEdES19TRUxFQ1RJT05fQ0xJUEJPQVJE KSk7CisgICAgcmV0dXJuIHN0ZDo6bWFrZV91bmlxdWU8UGFzdGVib2FyZD4oUGFzdGVib2FyZFR5 cGU6OkNsaXBib2FyZCk7CiB9CiAKIHN0ZDo6dW5pcXVlX3B0cjxQYXN0ZWJvYXJkPiBQYXN0ZWJv YXJkOjpjcmVhdGVGb3JHbG9iYWxTZWxlY3Rpb24oKQogewotICAgIHJldHVybiBzdGQ6Om1ha2Vf dW5pcXVlPFBhc3RlYm9hcmQ+KGd0a19jbGlwYm9hcmRfZ2V0KEdES19TRUxFQ1RJT05fUFJJTUFS WSkpOworICAgIHJldHVybiBzdGQ6Om1ha2VfdW5pcXVlPFBhc3RlYm9hcmQ+KFBhc3RlYm9hcmRU eXBlOjpQcmltYXJ5KTsKIH0KIAogc3RkOjp1bmlxdWVfcHRyPFBhc3RlYm9hcmQ+IFBhc3RlYm9h cmQ6OmNyZWF0ZVByaXZhdGUoKQpAQCAtNzYsMTcgKzc2LDE0IEBAIFBhc3RlYm9hcmRJbWFnZTo6 flBhc3RlYm9hcmRJbWFnZSgpCiAKIFBhc3RlYm9hcmQ6OlBhc3RlYm9hcmQoUmVmUHRyPERhdGFP YmplY3RHdGs+JiYgZGF0YU9iamVjdCkKICAgICA6IG1fZGF0YU9iamVjdChXVEZNb3ZlKGRhdGFP YmplY3QpKQotICAgICwgbV9ndGtDbGlwYm9hcmQobnVsbHB0cikKIHsKICAgICBBU1NFUlQobV9k YXRhT2JqZWN0KTsKIH0KIAotUGFzdGVib2FyZDo6UGFzdGVib2FyZChHdGtDbGlwYm9hcmQqIGd0 a0NsaXBib2FyZCkKLSAgICA6IG1fZGF0YU9iamVjdChEYXRhT2JqZWN0R3RrOjpmb3JDbGlwYm9h cmQoZ3RrQ2xpcGJvYXJkKSkKLSAgICAsIG1fZ3RrQ2xpcGJvYXJkKGd0a0NsaXBib2FyZCkKK1Bh c3RlYm9hcmQ6OlBhc3RlYm9hcmQoUGFzdGVib2FyZFR5cGUgdHlwZSkKKyAgICA6IG1fZGF0YU9i amVjdChEYXRhT2JqZWN0R3RrOjpjcmVhdGUoKSkKKyAgICAsIG1fcGFzdGVib2FyZFR5cGUodHlw ZSkKIHsKLSAgICBBU1NFUlQobV9kYXRhT2JqZWN0KTsKLSAgICBQYXN0ZWJvYXJkSGVscGVyOjpz aW5nbGV0b24oKS5yZWdpc3RlckNsaXBib2FyZChndGtDbGlwYm9hcmQpOwogfQogCiBQYXN0ZWJv YXJkOjp+UGFzdGVib2FyZCgpCkBAIC0xMjEsNiArMTE4LDM0IEBAIHN0YXRpYyBDbGlwYm9hcmRE YXRhVHlwZSBkYXRhT2JqZWN0VHlwZUZyb21IVE1MQ2xpcGJvYXJkVHlwZShjb25zdCBTdHJpbmcm IHJhd1R5CiAgICAgcmV0dXJuIENsaXBib2FyZERhdGFUeXBlVW5rbm93bjsKIH0KIAorU3RyaW5n IFBhc3RlYm9hcmQ6OnBhc3RlYm9hcmROYW1lKCkgY29uc3QKK3sKKyAgICBpZiAobV9wYXN0ZWJv YXJkVHlwZSA9PSBQYXN0ZWJvYXJkVHlwZTo6UHJpbWFyeSkKKyAgICAgICAgcmV0dXJuICJQUklN QVJZIjsKKyAgICBpZiAobV9wYXN0ZWJvYXJkVHlwZSA9PSBQYXN0ZWJvYXJkVHlwZTo6Q2xpcGJv YXJkKQorICAgICAgICByZXR1cm4gIkNMSVBCT0FSRCI7CisgICAgcmV0dXJuIFN0cmluZyB7IH07 Cit9CisKK3ZvaWQgUGFzdGVib2FyZDo6d3JpdGVUb0NsaXBib2FyZChTaG91bGRJbmNsdWRlU21h cnRQYXN0ZSBzaG91bGRJbmNsdWRlU21hcnRQYXN0ZSkKK3sKKyAgICBBU1NFUlQoIXBhc3RlYm9h cmROYW1lKCkuaXNFbXB0eSgpKTsKKyAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kmIHN0cmF0ZWd5ID0g KnBsYXRmb3JtU3RyYXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKTsKKyAgICBEYXRhT2Jq ZWN0R3RrKiBkYXRhT2JqZWN0ID0gbV9kYXRhT2JqZWN0LmdldCgpOworCisgICAgaWYgKHNob3Vs ZEluY2x1ZGVTbWFydFBhc3RlID09IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlOjpObykKKyAgICAg ICAgZGF0YU9iamVjdC0+c2V0VW5rbm93blR5cGVEYXRhKCJhcHBsaWNhdGlvbi92bmQud2Via2l0 Z3RrLnNtYXJ0cGFzdGUiLCBlbXB0eVN0cmluZygpKTsKKyAgICBzdHJhdGVneS5zZXRTZWxlY3Rp b24ocGFzdGVib2FyZE5hbWUoKSwgZGF0YU9iamVjdCk7Cit9CisKK3ZvaWQgUGFzdGVib2FyZDo6 cmVhZEZyb21DbGlwYm9hcmQodm9pZCkKK3sKKyAgICBBU1NFUlQoIXBhc3RlYm9hcmROYW1lKCku aXNFbXB0eSgpKTsKKyAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kmIHN0cmF0ZWd5ID0gKnBsYXRmb3Jt U3RyYXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKTsKKyAgICBSZWZQdHI8RGF0YU9iamVj dEd0az4gZGF0YU9iamVjdCA9IHN0cmF0ZWd5LmdldFNlbGVjdGlvbihwYXN0ZWJvYXJkTmFtZSgp KTsKKyAgICBtX2RhdGFPYmplY3QgPSBkYXRhT2JqZWN0LmdldCgpOworfQorCiB2b2lkIFBhc3Rl Ym9hcmQ6OndyaXRlU3RyaW5nKGNvbnN0IFN0cmluZyYgdHlwZSwgY29uc3QgU3RyaW5nJiBkYXRh KQogewogICAgIHN3aXRjaCAoZGF0YU9iamVjdFR5cGVGcm9tSFRNTENsaXBib2FyZFR5cGUodHlw ZSkpIHsKQEAgLTE0Nyw4ICsxNzIsOCBAQCB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlUGxhaW5UZXh0 KGNvbnN0IFN0cmluZyYgdGV4dCwgU21hcnRSZXBsYWNlT3B0aW9uIHNtYXJ0UmVwbAogICAgIG1f ZGF0YU9iamVjdC0+Y2xlYXJBbGwoKTsKICAgICBtX2RhdGFPYmplY3QtPnNldFRleHQodGV4dCk7 CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNp bmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsIChzbWFydFJl cGxhY2VPcHRpb24gPT0gQ2FuU21hcnRSZXBsYWNlKSA/IFBhc3RlYm9hcmRIZWxwZXI6OkluY2x1 ZGVTbWFydFBhc3RlIDogUGFzdGVib2FyZEhlbHBlcjo6RG9Ob3RJbmNsdWRlU21hcnRQYXN0ZSk7 CisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gUGFzdGVib2FyZFR5cGU6Ok5vbmUpCisgICAg ICAgIHdyaXRlVG9DbGlwYm9hcmQoc21hcnRSZXBsYWNlT3B0aW9uID09IENhblNtYXJ0UmVwbGFj ZSA/IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlOjpZZXMgOiBTaG91bGRJbmNsdWRlU21hcnRQYXN0 ZTo6Tm8pOwogfQogCiB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlKGNvbnN0IFBhc3RlYm9hcmRVUkwm IHBhc3RlYm9hcmRVUkwpCkBAIC0xNTgsOCArMTgzLDggQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0 ZShjb25zdCBQYXN0ZWJvYXJkVVJMJiBwYXN0ZWJvYXJkVVJMKQogICAgIG1fZGF0YU9iamVjdC0+ Y2xlYXJBbGwoKTsKICAgICBtX2RhdGFPYmplY3QtPnNldFVSTChwYXN0ZWJvYXJkVVJMLnVybCwg cGFzdGVib2FyZFVSTC50aXRsZSk7CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAg IFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9n dGtDbGlwYm9hcmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9IFBhc3RlYm9hcmRUeXBl OjpOb25lKQorICAgICAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9CiAKIHZvaWQgUGFzdGVib2Fy ZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZEltYWdlJiBwYXN0ZWJvYXJkSW1hZ2UpCkBAIC0xNzQs OCArMTk5LDggQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkSW1hZ2Um IHBhc3RlYm9hcmRJbWFnZSkKICAgICBpZiAocGl4YnVmKQogICAgICAgICBtX2RhdGFPYmplY3Qt PnNldEltYWdlKHBpeGJ1Zi5nZXQoKSk7CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAg ICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMo bV9ndGtDbGlwYm9hcmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9IFBhc3RlYm9hcmRU eXBlOjpOb25lKQorICAgICAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9CiAKIHZvaWQgUGFzdGVi b2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZFdlYkNvbnRlbnQmIHBhc3RlYm9hcmRDb250ZW50 KQpAQCAtMTg0LDggKzIwOSw4IEBAIHZvaWQgUGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVi b2FyZFdlYkNvbnRlbnQmIHBhc3RlYm9hcmRDb250ZW50KQogICAgIG1fZGF0YU9iamVjdC0+c2V0 VGV4dChwYXN0ZWJvYXJkQ29udGVudC50ZXh0KTsKICAgICBtX2RhdGFPYmplY3QtPnNldE1hcmt1 cChwYXN0ZWJvYXJkQ29udGVudC5tYXJrdXApOwogCi0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQot ICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRl bnRzKG1fZ3RrQ2xpcGJvYXJkLCBwYXN0ZWJvYXJkQ29udGVudC5jYW5TbWFydENvcHlPckRlbGV0 ZSA/IFBhc3RlYm9hcmRIZWxwZXI6OkluY2x1ZGVTbWFydFBhc3RlIDogUGFzdGVib2FyZEhlbHBl cjo6RG9Ob3RJbmNsdWRlU21hcnRQYXN0ZSwgcGFzdGVib2FyZENvbnRlbnQuY2FsbGJhY2suZ2V0 KCkpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9IFBhc3RlYm9hcmRUeXBlOjpOb25lKQor ICAgICAgICB3cml0ZVRvQ2xpcGJvYXJkKHBhc3RlYm9hcmRDb250ZW50LmNhblNtYXJ0Q29weU9y RGVsZXRlID8gU2hvdWxkSW5jbHVkZVNtYXJ0UGFzdGU6OlllcyA6IFNob3VsZEluY2x1ZGVTbWFy dFBhc3RlOjpObyk7CiB9CiAKIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVQYXN0ZWJvYXJkKGNvbnN0 IFBhc3RlYm9hcmQmIHNvdXJjZVBhc3RlYm9hcmQpCkBAIC0yMDgsOCArMjMzLDggQEAgdm9pZCBQ YXN0ZWJvYXJkOjp3cml0ZVBhc3RlYm9hcmQoY29uc3QgUGFzdGVib2FyZCYgc291cmNlUGFzdGVi b2FyZCkKICAgICAgICAgICAgIG1fZGF0YU9iamVjdC0+c2V0VW5rbm93blR5cGVEYXRhKGl0Lmtl eSwgaXQudmFsdWUpOwogICAgIH0KIAotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAg UGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0 a0NsaXBib2FyZCk7CisgICAgaWYgKG1fcGFzdGVib2FyZFR5cGUgIT0gUGFzdGVib2FyZFR5cGU6 Ok5vbmUpCisgICAgICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJk OjpjbGVhcigpCkBAIC0yMjAsOCArMjQ1LDggQEAgdm9pZCBQYXN0ZWJvYXJkOjpjbGVhcigpCiAg ICAgLy8gc3RpbGwgY29udGFpbiB0aGUgIkZpbGVzIiBzdHJpbmcgaWYgYW55IGZpbGVzIHdlcmUg aW5jbHVkZWQgaW4gdGhlIGRyYWcpLiIKICAgICBtX2RhdGFPYmplY3QtPmNsZWFyQWxsRXhjZXB0 RmlsZW5hbWVzKCk7CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9h cmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9h cmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9IFBhc3RlYm9hcmRUeXBlOjpOb25lKQor ICAgICAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9CiAKIHZvaWQgUGFzdGVib2FyZDo6Y2xlYXIo Y29uc3QgU3RyaW5nJiB0eXBlKQpAQCAtMjQ1LDEzICsyNzAsMTYgQEAgdm9pZCBQYXN0ZWJvYXJk OjpjbGVhcihjb25zdCBTdHJpbmcmIHR5cGUpCiAgICAgICAgIGJyZWFrOwogICAgIH0KIAotICAg IGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9u KCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYgKG1fcGFz dGVib2FyZFR5cGUgIT0gUGFzdGVib2FyZFR5cGU6Ok5vbmUpCisgICAgICAgIHdyaXRlVG9DbGlw Ym9hcmQoKTsKIH0KIAogYm9vbCBQYXN0ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UoKQogewotICAg IHJldHVybiBtX2d0a0NsaXBib2FyZCAmJiBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5j bGlwYm9hcmRDb250ZW50U3VwcG9ydHNTbWFydFJlcGxhY2UobV9ndGtDbGlwYm9hcmQpOworICAg IGlmIChtX3Bhc3RlYm9hcmRUeXBlID09IFBhc3RlYm9hcmRUeXBlOjpOb25lKQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKKyAgICByZXR1cm4gIW1fZGF0 YU9iamVjdC0+dW5rbm93blR5cGVEYXRhKCJhcHBsaWNhdGlvbi92bmQud2Via2l0Z3RrLnNtYXJ0 cGFzdGUiKS5pc0VtcHR5KCk7CiB9CiAKICNpZiBFTkFCTEUoRFJBR19TVVBQT1JUKQpAQCAtMjYy LDIzICsyOTAsMjQgQEAgdm9pZCBQYXN0ZWJvYXJkOjpzZXREcmFnSW1hZ2UoRHJhZ0ltYWdlUmVm LCBjb25zdCBJbnRQb2ludCYpCiAKIHZvaWQgUGFzdGVib2FyZDo6cmVhZChQYXN0ZWJvYXJkUGxh aW5UZXh0JiB0ZXh0KQogewotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVi b2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9h cmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9IFBhc3RlYm9hcmRUeXBlOjpOb25lKQor ICAgICAgICByZWFkRnJvbUNsaXBib2FyZCgpOworCiAgICAgdGV4dC50ZXh0ID0gbV9kYXRhT2Jq ZWN0LT50ZXh0KCk7CiB9CiAKIGJvb2wgUGFzdGVib2FyZDo6aGFzRGF0YSgpCiB7Ci0gICAgaWYg KG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5n ZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYgKG1fcGFzdGVib2Fy ZFR5cGUgIT0gUGFzdGVib2FyZFR5cGU6Ok5vbmUpCisgICAgICAgIHJlYWRGcm9tQ2xpcGJvYXJk KCk7CiAKICAgICByZXR1cm4gbV9kYXRhT2JqZWN0LT5oYXNUZXh0KCkgfHwgbV9kYXRhT2JqZWN0 LT5oYXNNYXJrdXAoKSB8fCBtX2RhdGFPYmplY3QtPmhhc1VSSUxpc3QoKSB8fCBtX2RhdGFPYmpl Y3QtPmhhc0ltYWdlKCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNVbmtub3duVHlwZURhdGEoKTsKIH0K IAogVmVjdG9yPFN0cmluZz4gUGFzdGVib2FyZDo6dHlwZXMoKQogewotICAgIGlmIChtX2d0a0Ns aXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJv YXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIGlmIChtX3Bhc3RlYm9hcmRUeXBlICE9 IFBhc3RlYm9hcmRUeXBlOjpOb25lKQorICAgICAgICByZWFkRnJvbUNsaXBib2FyZCgpOwogCiAg ICAgVmVjdG9yPFN0cmluZz4gdHlwZXM7CiAgICAgaWYgKG1fZGF0YU9iamVjdC0+aGFzVGV4dCgp KSB7CkBAIC0zMDYsOCArMzM1LDggQEAgVmVjdG9yPFN0cmluZz4gUGFzdGVib2FyZDo6dHlwZXMo KQogCiBTdHJpbmcgUGFzdGVib2FyZDo6cmVhZFN0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUpCiB7 Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5n bGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCk7CisgICAgaWYgKG1f cGFzdGVib2FyZFR5cGUgIT0gUGFzdGVib2FyZFR5cGU6Ok5vbmUpCisgICAgICAgIHJlYWRGcm9t Q2xpcGJvYXJkKCk7CiAKICAgICBzd2l0Y2ggKGRhdGFPYmplY3RUeXBlRnJvbUhUTUxDbGlwYm9h cmRUeXBlKHR5cGUpKSB7CiAgICAgY2FzZSBDbGlwYm9hcmREYXRhVHlwZVVSSUxpc3Q6CkBAIC0z MjksOCArMzU4LDggQEAgU3RyaW5nIFBhc3RlYm9hcmQ6OnJlYWRTdHJpbmcoY29uc3QgU3RyaW5n JiB0eXBlKQogCiBWZWN0b3I8U3RyaW5nPiBQYXN0ZWJvYXJkOjpyZWFkRmlsZW5hbWVzKCkKIHsK LSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmds ZXRvbigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICBpZiAobV9w YXN0ZWJvYXJkVHlwZSAhPSBQYXN0ZWJvYXJkVHlwZTo6Tm9uZSkKKyAgICAgICAgcmVhZEZyb21D bGlwYm9hcmQoKTsKIAogICAgIHJldHVybiBtX2RhdGFPYmplY3QtPmZpbGVuYW1lcygpOwogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BsYXRmb3JtUGFzdGVib2Fy ZEd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJk R3RrLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45MzRjOGFlCi0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BsYXRmb3JtUGFzdGVi b2FyZEd0ay5jcHAKQEAgLTAsMCArMSw0OSBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTYg UmVkIEhhdCBJbmMuCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1z IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgor ICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBo YXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog IExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZy ZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZp ZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1QYXN0ZWJvYXJkLmgiCisKKyNpbmNsdWRlICJD b2xvci5oIgorI2luY2x1ZGUgIkRhdGFPYmplY3RHdGsuaCIKKyNpbmNsdWRlICJQYXN0ZWJvYXJk SGVscGVyLmgiCisjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAiVVJMLmgiCisj aW5jbHVkZSA8Z3RrL2d0ay5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1BsYXRmb3JtUGFz dGVib2FyZDo6UGxhdGZvcm1QYXN0ZWJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUp CisgICAgOiBtX2NsaXBib2FyZChndGtfY2xpcGJvYXJkX2dldChnZGtfYXRvbV9pbnRlcm4ocGFz dGVib2FyZE5hbWUudXRmOCgpLmRhdGEoKSwgVFJVRSkpKQoreworICAgIEFTU0VSVChtX2NsaXBi b2FyZCk7Cit9CisKK3ZvaWQgUGxhdGZvcm1QYXN0ZWJvYXJkOjpzZXRTZWxlY3Rpb24oRGF0YU9i amVjdEd0ayogZGF0YU9iamVjdCkKK3sKKyAgICBEYXRhT2JqZWN0R3RrOjpzZXRGb3JDbGlwYm9h cmQobV9jbGlwYm9hcmQsIGRhdGFPYmplY3QpOworICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmds ZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9jbGlwYm9hcmQpOworfQorCitEYXRhT2Jq ZWN0R3RrKiBQbGF0Zm9ybVBhc3RlYm9hcmQ6OmdldFNlbGVjdGlvbigpCit7CisgICAgUGFzdGVi b2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVudHMobV9jbGlwYm9hcmQp OworICAgIHJldHVybiBEYXRhT2JqZWN0R3RrOjpmb3JDbGlwYm9hcmQobV9jbGlwYm9hcmQpOwor fQorCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKaW5kZXggNjdmYjY4Yy4uOTgzODAyZiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDQ3IEBACisyMDE2LTA5LTEyICBDYXJsb3MgR2FybmFjaG8gIDxjYXJsb3NnQGdub21lLm9y Zz4KKworICAgICAgICBbR1RLXVtXYXlsYW5kXSBJbXBsZW1lbnQgY2xpcGJvYXJkIHN1cHBvcnQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NjU3NAor CisgICAgICAgIEFkZCB0aGUgbmVjZXNzYXJ5IHBsdW1iaW5nIGZvciB0aGUgR1RLKyBiYWNrZW5k IHRvIHVzZSB0aGUKKyAgICAgICAgUGxhdGZvcm1QYXN0ZWJvYXJkIGluIFdlYkNvcmUuIEFsbCBz ZWxlY3Rpb24gZGF0YSBpcyB0cmFuc21pdHRlZAorICAgICAgICBhdCBvbmNlIHRocm91Z2ggdGhl IHNlcmlhbGl6YXRpb24gb2YgUGFzdGVib2FyZENvbnRlbnRHdGsvRGF0YU9iamVjdEd0ay4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFBsYXRmb3Jt R1RLLmNtYWtlOiBBZGQgUGFzdGVib2FyZENvbnRlbnRHdGsuY3BwIGFuZAorICAgICAgICBXZWJQ YXN0ZWJvYXJkUHJveHlHdGsuY3BwCisgICAgICAgICogU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVy c0d0ay5jcHA6CisgICAgICAgIChJUEM6OmVuY29kZSk6CisgICAgICAgIChJUEM6OmRlY29kZSk6 IFJlbmFtZWQgZnJvbSBlbmNvZGVEYXRhT2JqZWN0L2RlY29kZURhdGFPYmplY3QKKyAgICAgICAg YW5kIG1hZGUgcHVibGljLgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVyPERyYWdEYXRhPjo6 ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxEcmFnRGF0YT46OmRlY29kZSk6 IFVwZGF0ZSBEYXRhT2JqZWN0R3RrCisgICAgICAgIGVuY29kZS9kZWNvZGUgY2FsbGVycy4KKyAg ICAgICAgKiBTaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmg6IEV4cG9zZSBlbmNvZGUvZGVj b2RlIG1ldGhvZHMgZm9yCisgICAgICAgIERhdGFPYmplY3RHdGsuCisgICAgICAgICogU2hhcmVk L2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5jcHA6IEFkZGVkLiBXcmFwcyBhIERhdGFPYmplY3RH dGsKKyAgICAgICAgc28gaXQgY2FuIGJlIHNlcmlhbGl6ZWQgb24gV2ViUHJvY2Vzcy9VSVByb2Nl c3MgbWVzc2FnaW5nLgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0azo6UGFz dGVib2FyZENvbnRlbnRHdGspOgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0 azo6ZW5jb2RlKToKKyAgICAgICAgKFdlYktpdDo6UGFzdGVib2FyZENvbnRlbnRHdGs6OmRlY29k ZSk6CisgICAgICAgICogU2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5oOiBBZGRlZC4K KyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5Lmg6CisgICAgICAgICogVUlQ cm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbjogQWRkZWQgcGx1bWJpbmcgZm9y IHRoZQorICAgICAgICBHVEsrIHBhc3RlYm9hcmQgcHJveHkgZnVuY3Rpb25zLgorICAgICAgICAq IFVJUHJvY2Vzcy9ndGsvV2ViUGFzdGVib2FyZFByb3h5R3RrLmNwcDogQWRkZWQKKyAgICAgICAg KFdlYktpdDo6bG9va3VwUGxhdGZvcm1QYXN0ZWJvYXJkKToKKyAgICAgICAgKFdlYktpdDo6V2Vi UGFzdGVib2FyZFByb3h5OjpzZXRTZWxlY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0 ZWJvYXJkUHJveHk6OmdldFNlbGVjdGlvbik6SW1wbGVtZW50ZWQgZnVuY3Rpb25zIGhvb2tpbmcK KyAgICAgICAgaW50byB0aGUgUGxhdGZvcm1QYXN0ZWJvYXJkLiBQZXItc2VsZWN0aW9uIChpZS4g cHJpbWFyeS9jbGlwYm9hcmQpCisgICAgICAgIFBsYXRmb3JtUGFzdGVib2FyZHMgYXJlIGtlcHQg YXQgdGhpcyBsZXZlbCwgc28gdGhvc2UgYXJlIGluZGVwZW5kZW50bHkKKyAgICAgICAgc2V0IGFu ZCBkZWFsdCB3aXRoLgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxh dGZvcm1TdHJhdGVnaWVzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGxhdGZvcm1TdHJhdGVn aWVzOjpzZXRTZWxlY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJQbGF0Zm9ybVN0cmF0ZWdp ZXM6OmdldFNlbGVjdGlvbik6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9X ZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaDogQWRkZWQgbWV0aG9kcyB0bworICAgICAgICBzZW5kIHRo ZSBXZWJQcm9jZXNzLT5VSVByb2Nlc3MgbWVzc2FnZXMuCisKIDIwMTYtMDktMDQgIENvbW1pdCBR dWV1ZSAgPGNvbW1pdC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJv bGxpbmcgb3V0IHIyMDU0MTUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdU Sy5jbWFrZSBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlCmluZGV4IGU2NDA2MDMu LjJlNTJkMzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlCisr KyBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlCkBAIC03MSw2ICs3MSw3IEBAIGxp c3QoQVBQRU5EIFdlYktpdDJfU09VUkNFUwogICAgIFNoYXJlZC9ndGsvTmF0aXZlV2ViTW91c2VF dmVudEd0ay5jcHAKICAgICBTaGFyZWQvZ3RrL05hdGl2ZVdlYlRvdWNoRXZlbnRHdGsuY3BwCiAg ICAgU2hhcmVkL2d0ay9OYXRpdmVXZWJXaGVlbEV2ZW50R3RrLmNwcAorICAgIFNoYXJlZC9ndGsv UGFzdGVib2FyZENvbnRlbnRHdGsuY3BwCiAgICAgU2hhcmVkL2d0ay9QcmludEluZm9HdGsuY3Bw CiAgICAgU2hhcmVkL2d0ay9Qcm9jZXNzRXhlY3V0YWJsZVBhdGhHdGsuY3BwCiAgICAgU2hhcmVk L2d0ay9XZWJDb250ZXh0TWVudUl0ZW1HdGsuY3BwCkBAIC0zMTMsNiArMzE0LDcgQEAgbGlzdChB UFBFTkQgV2ViS2l0Ml9TT1VSQ0VTCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJJbnNwZWN0b3JDbGll bnRHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJJbnNwZWN0b3JQcm94eUd0ay5jcHAKICAg ICBVSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHAKKyAgICBVSVByb2Nlc3MvZ3RrL1dl YlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKICAgICBVSVByb2Nlc3MvZ3RrL1dlYlBvcHVwTWVudVBy b3h5R3RrLmNwcAogICAgIFVJUHJvY2Vzcy9ndGsvV2ViUHJlZmVyZW5jZXNHdGsuY3BwCiAgICAg VUlQcm9jZXNzL2d0ay9XZWJQcm9jZXNzUG9vbEd0ay5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuY3BwIGIvU291cmNlL1dlYktpdDIv U2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5jcHAKaW5kZXggZmQ5NDVhMDYuLjBjOTFiN2Qg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuY3Bw CkBAIC04Miw3ICs4Miw3IEBAIHN0YXRpYyBib29sIGRlY29kZUltYWdlKERlY29kZXImIGRlY29k ZXIsIEdSZWZQdHI8R2RrUGl4YnVmPiYgcGl4YnVmKQogICAgIHJldHVybiB0cnVlOwogfQogCi1z dGF0aWMgdm9pZCBlbmNvZGVEYXRhT2JqZWN0KEVuY29kZXImIGVuY29kZXIsIGNvbnN0IERhdGFP YmplY3RHdGsqIGRhdGFPYmplY3QpCit2b2lkIGVuY29kZShFbmNvZGVyJiBlbmNvZGVyLCBjb25z dCBEYXRhT2JqZWN0R3RrKiBkYXRhT2JqZWN0KQogewogICAgIGJvb2wgaGFzVGV4dCA9IGRhdGFP YmplY3QtPmhhc1RleHQoKTsKICAgICBlbmNvZGVyIDw8IGhhc1RleHQ7CkBAIC0xMTUsNyArMTE1 LDcgQEAgc3RhdGljIHZvaWQgZW5jb2RlRGF0YU9iamVjdChFbmNvZGVyJiBlbmNvZGVyLCBjb25z dCBEYXRhT2JqZWN0R3RrKiBkYXRhT2JqZWN0KQogICAgICAgICBlbmNvZGVyIDw8IGRhdGFPYmpl Y3QtPnVua25vd25UeXBlcygpOwogfQogCi1zdGF0aWMgYm9vbCBkZWNvZGVEYXRhT2JqZWN0KERl Y29kZXImIGRlY29kZXIsIFJlZlB0cjxEYXRhT2JqZWN0R3RrPiYgZGF0YU9iamVjdCkKK2Jvb2wg ZGVjb2RlKERlY29kZXImIGRlY29kZXIsIFJlZlB0cjxEYXRhT2JqZWN0R3RrPiYgZGF0YU9iamVj dCkKIHsKICAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gZGF0YSA9IERhdGFPYmplY3RHdGs6OmNy ZWF0ZSgpOwogCkBAIC0xOTgsNyArMTk4LDcgQEAgdm9pZCBBcmd1bWVudENvZGVyPERyYWdEYXRh Pjo6ZW5jb2RlKEVuY29kZXImIGVuY29kZXIsIGNvbnN0IERyYWdEYXRhJiBkcmFnRGF0YSkKICAg ICBEYXRhT2JqZWN0R3RrKiBwbGF0Zm9ybURhdGEgPSBkcmFnRGF0YS5wbGF0Zm9ybURhdGEoKTsK ICAgICBlbmNvZGVyIDw8IHN0YXRpY19jYXN0PGJvb2w+KHBsYXRmb3JtRGF0YSk7CiAgICAgaWYg KHBsYXRmb3JtRGF0YSkKLSAgICAgICAgZW5jb2RlRGF0YU9iamVjdChlbmNvZGVyLCBwbGF0Zm9y bURhdGEpOworICAgICAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBwbGF0Zm9ybURhdGEpOwogfQog CiBib29sIEFyZ3VtZW50Q29kZXI8RHJhZ0RhdGE+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2Rlciwg RHJhZ0RhdGEmIGRyYWdEYXRhKQpAQCAtMjI1LDcgKzIyNSw3IEBAIGJvb2wgQXJndW1lbnRDb2Rl cjxEcmFnRGF0YT46OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyLCBEcmFnRGF0YSYgZHJhZ0RhdGEp CiAKICAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gcGxhdGZvcm1EYXRhOwogICAgIGlmIChoYXNQ bGF0Zm9ybURhdGEpIHsKLSAgICAgICAgaWYgKCFkZWNvZGVEYXRhT2JqZWN0KGRlY29kZXIsIHBs YXRmb3JtRGF0YSkpCisgICAgICAgIGlmICghSVBDOjpkZWNvZGUoZGVjb2RlciwgcGxhdGZvcm1E YXRhKSkKICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuaCBiL1NvdXJjZS9XZWJL aXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuaAppbmRleCAwMWFjNGNmLi4xNjljNjY5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3Rr LmgKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5oCkBA IC01Miw2ICs1Miw5IEBAIGJvb2wgZGVjb2RlKERlY29kZXImLCBHUmVmUHRyPEd0a1ByaW50U2V0 dGluZ3M+Jik7CiB2b2lkIGVuY29kZShFbmNvZGVyJiwgR3RrUGFnZVNldHVwKik7CiBib29sIGRl Y29kZShEZWNvZGVyJiwgR1JlZlB0cjxHdGtQYWdlU2V0dXA+Jik7CiAKK3ZvaWQgZW5jb2RlKEVu Y29kZXImLCBjb25zdCBXZWJDb3JlOjpEYXRhT2JqZWN0R3RrKik7Citib29sIGRlY29kZShEZWNv ZGVyJiwgUmVmUHRyPFdlYkNvcmU6OkRhdGFPYmplY3RHdGs+Jik7CisKIH0gLy8gbmFtZXNwYWNl IElQQwogCiAjZW5kaWYgLy8gQXJndW1lbnRDb2RlcnNHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvU2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50R3RrLmNwcApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4xYmU2YTEyCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dl YktpdDIvU2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5jcHAKQEAgLTAsMCArMSw2MSBA QAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTYgUmVkIEhhdCBJbmMuCisgKgorICogIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwg UHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4g IFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxp YnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyAqICBGb3VuZGF0aW9u LCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjEx MC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUGFzdGVi b2FyZENvbnRlbnRHdGsuaCIKKworI2luY2x1ZGUgIkFyZ3VtZW50Q29kZXJzR3RrLmgiCisjaW5j bHVkZSAiRGF0YU9iamVjdEd0ay5oIgorI2luY2x1ZGUgIkRlY29kZXIuaCIKKyNpbmNsdWRlICJF bmNvZGVyLmgiCisjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5oPgorCituYW1lc3BhY2UgV2ViS2l0 IHsKKworUGFzdGVib2FyZENvbnRlbnRHdGs6OlBhc3RlYm9hcmRDb250ZW50R3RrKCkKK3sKK30K KworUGFzdGVib2FyZENvbnRlbnRHdGs6OlBhc3RlYm9hcmRDb250ZW50R3RrKFdlYkNvcmU6OkRh dGFPYmplY3RHdGsqIGRhdGEpCisgICAgOiBkYXRhT2JqZWN0KGRhdGEpCit7Cit9CisKK3ZvaWQg UGFzdGVib2FyZENvbnRlbnRHdGs6OmVuY29kZShJUEM6OkVuY29kZXImIGVuY29kZXIpIGNvbnN0 Cit7CisgICAgZW5jb2RlciA8PCBzdGF0aWNfY2FzdDxib29sPihkYXRhT2JqZWN0KTsKKyAgICBp ZiAoZGF0YU9iamVjdCkKKyAgICAgICAgSVBDOjplbmNvZGUoZW5jb2RlciwgZGF0YU9iamVjdC5n ZXQoKSk7Cit9CisKK2Jvb2wgUGFzdGVib2FyZENvbnRlbnRHdGs6OmRlY29kZShJUEM6OkRlY29k ZXImIGRlY29kZXIsIFBhc3RlYm9hcmRDb250ZW50R3RrJiBwYXN0ZWJvYXJkQ29udGVudCkKK3sK KyAgICBib29sIGhhc1Bhc3RlYm9hcmRDb250ZW50OworICAgIGlmICghZGVjb2Rlci5kZWNvZGUo aGFzUGFzdGVib2FyZENvbnRlbnQpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBpZiAo IWhhc1Bhc3RlYm9hcmRDb250ZW50KQorICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIGlmICgh SVBDOjpkZWNvZGUoZGVjb2RlciwgcGFzdGVib2FyZENvbnRlbnQuZGF0YU9iamVjdCkpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiB0cnVlOworfQorCit9IC8vIG5hbWVzcGFj ZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFzdGVib2Fy ZENvbnRlbnRHdGsuaCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFzdGVib2FyZENvbnRl bnRHdGsuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hODgwMjU4Ci0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVu dEd0ay5oCkBAIC0wLDAgKzEsNDMgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChDKSAyMDE2IFJlZCBI YXQgSW5jLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogIExlc3NlciBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNl bnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNv ZnR3YXJlCisgKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBG bG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKi8KKworI2lmbmRlZiBQYXN0ZWJv YXJkQ29udGVudEd0a19oCisjZGVmaW5lIFBhc3RlYm9hcmRDb250ZW50R3RrX2gKKworI2luY2x1 ZGUgIkRhdGFPYmplY3RHdGsuaCIKKworbmFtZXNwYWNlIElQQyB7CitjbGFzcyBEZWNvZGVyOwor Y2xhc3MgRW5jb2RlcjsKK30KKworbmFtZXNwYWNlIFdlYktpdCB7CisKK3N0cnVjdCBQYXN0ZWJv YXJkQ29udGVudEd0ayB7CisgICAgUGFzdGVib2FyZENvbnRlbnRHdGsoKTsKKyAgICBleHBsaWNp dCBQYXN0ZWJvYXJkQ29udGVudEd0ayhXZWJDb3JlOjpEYXRhT2JqZWN0R3RrKik7CisKKyAgICBS ZWZQdHI8V2ViQ29yZTo6RGF0YU9iamVjdEd0az4gZGF0YU9iamVjdDsKKworICAgIHZvaWQgZW5j b2RlKElQQzo6RW5jb2RlciYpIGNvbnN0OworICAgIHN0YXRpYyBib29sIGRlY29kZShJUEM6OkRl Y29kZXImLCBQYXN0ZWJvYXJkQ29udGVudEd0ayYpOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2Vi S2l0CisKKyNlbmRpZiAvLyBQYXN0ZWJvYXJkQ29udGVudEd0a19oCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmggYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmgKaW5kZXggNWUyYTViMS4uNDJkODIwMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5o CisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkuaApAQCAt NDAsNiArNDAsMTAgQEAgc3RydWN0IFBhc3RlYm9hcmRXZWJDb250ZW50OwogCiBuYW1lc3BhY2Ug V2ViS2l0IHsKIAorI2lmIFBMQVRGT1JNKEdUSykKK2NsYXNzIFBhc3RlYm9hcmRDb250ZW50R3Rr OworI2VuZGlmCisKIGNsYXNzIFdlYlByb2Nlc3NQcm94eTsKIAogY2xhc3MgV2ViUGFzdGVib2Fy ZFByb3h5IDogcHVibGljIElQQzo6TWVzc2FnZVJlY2VpdmVyIHsKQEAgLTgxLDYgKzg1LDEwIEBA IHByaXZhdGU6CiAgICAgdm9pZCBzZXRQYXN0ZWJvYXJkU3RyaW5nRm9yVHlwZShjb25zdCBTdHJp bmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBT dHJpbmcmLCB1aW50NjRfdCYgbmV3Q2hhbmdlQ291bnQpOwogICAgIHZvaWQgc2V0UGFzdGVib2Fy ZEJ1ZmZlckZvclR5cGUoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgU3RyaW5n JiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU2hhcmVkTWVtb3J5OjpIYW5kbGUmLCB1aW50NjRfdCBz aXplLCB1aW50NjRfdCYgbmV3Q2hhbmdlQ291bnQpOwogI2VuZGlmCisjaWYgUExBVEZPUk0oR1RL KQorICAgIHZvaWQgc2V0U2VsZWN0aW9uKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgV2Vi S2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0ayYpOworICAgIHZvaWQgZ2V0U2VsZWN0aW9uKFN0cmlu ZyBwYXN0ZWJvYXJkTmFtZSwgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0ayYpOworI2VuZGlm IC8vIFBMQVRGT1JNKEdUSykKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5p biBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMu aW4KaW5kZXggZDBkOWZhMS4uMDgyN2EyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5Lm1lc3NhZ2VzLmluCkBAIC00OCw0ICs0OCw5 IEBAIG1lc3NhZ2VzIC0+IFdlYlBhc3RlYm9hcmRQcm94eSB7CiAgICAgU2V0UGFzdGVib2FyZFN0 cmluZ0ZvclR5cGUoU3RyaW5nIHBhc3RlYm9hcmROYW1lLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUs IFN0cmluZyBzdHJpbmcpIC0+ICh1aW50NjRfdCBjaGFuZ2VDb3VudCkKICAgICBTZXRQYXN0ZWJv YXJkQnVmZmVyRm9yVHlwZShTdHJpbmcgcGFzdGVib2FyZE5hbWUsIFN0cmluZyBwYXN0ZWJvYXJk VHlwZSwgV2ViS2l0OjpTaGFyZWRNZW1vcnk6OkhhbmRsZSBoYW5kbGUsIHVpbnQ2NF90IHNpemUp IC0+ICh1aW50NjRfdCBjaGFuZ2VDb3VudCkKICNlbmRpZgorCisjaWYgUExBVEZPUk0oR1RLKQor ICAgIFNldFNlbGVjdGlvbihTdHJpbmcgcGFzdGVib2FyZE5hbWUsIHN0cnVjdCBXZWJLaXQ6OlBh c3RlYm9hcmRDb250ZW50R3RrIHBhc3RlYm9hcmRDb250ZW50KQorICAgIEdldFNlbGVjdGlvbihT dHJpbmcgcGFzdGVib2FyZE5hbWUpIC0+IChzdHJ1Y3QgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVu dEd0ayBwYXN0ZWJvYXJkQ29udGVudCkKKyNlbmRpZgogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE4NDAwMzgKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKQEAgLTAs MCArMSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElU UyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElO Qy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YK KyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up CisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldlYlBhc3RlYm9hcmRQcm94eS5o IgorCisjaW5jbHVkZSA8U2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5oPgorI2luY2x1 ZGUgPFdlYkNvcmUvUGxhdGZvcm1QYXN0ZWJvYXJkLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAu aD4KKyNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9T dHJpbmdIYXNoLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgV2Vi S2l0IHsKKworc3RhdGljIFdlYkNvcmU6OlBsYXRmb3JtUGFzdGVib2FyZCogbG9va3VwUGxhdGZv cm1QYXN0ZWJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpCit7CisgICAgc3RhdGlj IE5ldmVyRGVzdHJveWVkPEhhc2hNYXA8U3RyaW5nLCBzdGQ6OnVuaXF1ZV9wdHI8UGxhdGZvcm1Q YXN0ZWJvYXJkPj4+IHBhc3RlYm9hcmRNYXA7CisKKyAgICBhdXRvIGFkZFJlc3VsdCA9IHBhc3Rl Ym9hcmRNYXAuZ2V0KCkuYWRkKHBhc3RlYm9hcmROYW1lLCBudWxscHRyKTsKKyAgICBpZiAoYWRk UmVzdWx0LmlzTmV3RW50cnkpCisgICAgICAgIGFkZFJlc3VsdC5pdGVyYXRvci0+dmFsdWUgPSBz dGQ6Om1ha2VfdW5pcXVlPFBsYXRmb3JtUGFzdGVib2FyZD4ocGFzdGVib2FyZE5hbWUpOworCisg ICAgcmV0dXJuIGFkZFJlc3VsdC5pdGVyYXRvci0+dmFsdWUuZ2V0KCk7Cit9CisKK3ZvaWQgV2Vi UGFzdGVib2FyZFByb3h5OjpzZXRTZWxlY3Rpb24oU3RyaW5nIHBhc3RlYm9hcmROYW1lLCBjb25z dCBXZWJLaXQ6OlBhc3RlYm9hcmRDb250ZW50R3RrJiBwYXN0ZWJvYXJkQ29udGVudCkKK3sKKyAg ICBQbGF0Zm9ybVBhc3RlYm9hcmQqIHBhc3RlYm9hcmQgPSBsb29rdXBQbGF0Zm9ybVBhc3RlYm9h cmQocGFzdGVib2FyZE5hbWUpOworICAgIHBhc3RlYm9hcmQtPnNldFNlbGVjdGlvbihwYXN0ZWJv YXJkQ29udGVudC5kYXRhT2JqZWN0LmdldCgpKTsKK30KKwordm9pZCBXZWJQYXN0ZWJvYXJkUHJv eHk6OmdldFNlbGVjdGlvbihTdHJpbmcgcGFzdGVib2FyZE5hbWUsIFdlYktpdDo6UGFzdGVib2Fy ZENvbnRlbnRHdGsmIHBhc3RlYm9hcmRDb250ZW50KQoreworICAgIFBsYXRmb3JtUGFzdGVib2Fy ZCogcGFzdGVib2FyZCA9IGxvb2t1cFBsYXRmb3JtUGFzdGVib2FyZChwYXN0ZWJvYXJkTmFtZSk7 CisgICAgcGFzdGVib2FyZENvbnRlbnQgPSBXZWJLaXQ6OlBhc3RlYm9hcmRDb250ZW50R3RrKHBh c3RlYm9hcmQtPmdldFNlbGVjdGlvbigpKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBs YXRmb3JtU3RyYXRlZ2llcy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVT dXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAKaW5kZXggMDE5YzEzMy4uMmU3YzJiOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQ bGF0Zm9ybVN0cmF0ZWdpZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2Vi Q29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcApAQCAtNjksNiArNjksMTAgQEAK ICNpbmNsdWRlICJTdHJpbmdVdGlsaXRpZXMuaCIKICNlbmRpZgogCisjaWYgUExBVEZPUk0oR1RL KQorI2luY2x1ZGUgIlBhc3RlYm9hcmRDb250ZW50R3RrLmgiCisjZW5kaWYKKwogdXNpbmcgbmFt ZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtMzM5LDQgKzM0MywyMiBA QCBsb25nIFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6Y2hhbmdlQ291bnQoKQogCiAjZW5kaWYgLy8g UExBVEZPUk0oQ09DT0EpCiAKKyNpZiBQTEFURk9STShHVEspCisvLyBQYXN0ZWJvYXJkU3RyYXRl Z3kKKwordm9pZCBXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OnNldFNlbGVjdGlvbihTdHJpbmcgcGFz dGVib2FyZE5hbWUsIFdlYkNvcmU6OkRhdGFPYmplY3RHdGsqIGRhdGFPYmplY3QpCit7CisgICAg UGFzdGVib2FyZENvbnRlbnRHdGsgcGFzdGVib2FyZENvbnRlbnQgPSBQYXN0ZWJvYXJkQ29udGVu dEd0ayhkYXRhT2JqZWN0KTsKKyAgICBXZWJQcm9jZXNzOjpzaW5nbGV0b24oKS5wYXJlbnRQcm9j ZXNzQ29ubmVjdGlvbigpLT5zZW5kKE1lc3NhZ2VzOjpXZWJQYXN0ZWJvYXJkUHJveHk6OlNldFNl bGVjdGlvbihwYXN0ZWJvYXJkTmFtZSwgcGFzdGVib2FyZENvbnRlbnQpLCAwKTsKK30KKworUmVm UHRyPFdlYkNvcmU6OkRhdGFPYmplY3RHdGs+IFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6Z2V0U2Vs ZWN0aW9uKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSkKK3sKKyAgICBQYXN0ZWJvYXJkQ29udGVudEd0 ayBwYXN0ZWJvYXJkQ29udGVudDsKKyAgICBXZWJQcm9jZXNzOjpzaW5nbGV0b24oKS5wYXJlbnRQ cm9jZXNzQ29ubmVjdGlvbigpLT5zZW5kU3luYyhNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5 OjpHZXRTZWxlY3Rpb24ocGFzdGVib2FyZE5hbWUpLCBNZXNzYWdlczo6V2ViUGFzdGVib2FyZFBy b3h5OjpHZXRTZWxlY3Rpb246OlJlcGx5KHBhc3RlYm9hcmRDb250ZW50KSwgMCk7CisgICAgcmV0 dXJuIFdURk1vdmUocGFzdGVib2FyZENvbnRlbnQuZGF0YU9iamVjdCk7Cit9CisKKyNlbmRpZiAv LyBQTEFURk9STShHVEspCisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdp ZXMuaCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZv cm1TdHJhdGVnaWVzLmgKaW5kZXggNzk4ZWQyYy4uN2M5ZDM2MSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRm b3JtU3RyYXRlZ2llcy5oCkBAIC04Niw3ICs4NiwxMCBAQCBwcml2YXRlOgogICAgIGxvbmcgc2V0 UGF0aG5hbWVzRm9yVHlwZShjb25zdCBWZWN0b3I8U3RyaW5nPiYsIGNvbnN0IFN0cmluZyYgcGFz dGVib2FyZFR5cGUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJyaWRlOwogICAg IGxvbmcgc2V0U3RyaW5nRm9yVHlwZShjb25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIHBhc3Rl Ym9hcmRUeXBlLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lKSBvdmVycmlkZTsKICNlbmRp ZgotCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHZvaWQgc2V0U2VsZWN0aW9uKFN0cmluZyBwYXN0 ZWJvYXJkTmFtZSwgV2ViQ29yZTo6RGF0YU9iamVjdEd0ayopIG92ZXJyaWRlOworICAgIFJlZlB0 cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPiBnZXRTZWxlY3Rpb24oU3RyaW5nIHBhc3RlYm9hcmRO YW1lKSBvdmVycmlkZTsKKyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0Cg== 288564 2016-09-12 04:01:04 -0700 2016-09-14 08:11:27 -0700 Patch, implement clipboard as a PlatformPasteboard webkit-platform-gtkclipboard.patch text/plain 33330 carlosg ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3MDRiNzUyLi5jYWU4ZmIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTkg QEAKKzIwMTYtMDktMTIgIENhcmxvcyBHYXJuYWNobyAgPGNhcmxvc2dAZ25vbWUub3JnPgorCisg ICAgICAgIFtHVEtdW1dheWxhbmRdIEltcGxlbWVudCBjbGlwYm9hcmQgc3VwcG9ydAorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ2NTc0CisKKyAgICAg ICAgSW1wbGVtZW50IFBsYXRmb3JtUGFzdGVib2FyZCBpbiB0aGUgR1RLKyBwbGF0Zm9ybSwgYW5k IG1vdmUgUGFzdGVib2FyZAorICAgICAgICB0byB1c2luZyBQYXN0ZWJvYXJkU3RyYXRlZ3kgc28g Y2xpcGJvYXJkIG1hbmFnZW1lbnQgaXMgbGVmdCB0byB0aGUKKyAgICAgICAgVUlQcm9jZXNzLgor CisgICAgICAgIERhdGFPYmplY3RHdGsgaXMgc3RpbGwgdXNlZCBpbiB0aGUgUGFzdGVib2FyZCBH VEsgaW1wbGVtZW50YXRpb24sIGl0J3MKKyAgICAgICAgbm93IGp1c3QgbmV2ZXIgYmFja2VkIGJ5 IGEgR3RrQ2xpcGJvYXJkLCB0aGlzIG9iamVjdCBpcyBpbnN0ZWFkCisgICAgICAgIHNlcmlhbGl6 ZWQgdGhyb3VnaCBQYXN0ZWJvYXJkU3RyYXRlZ3ksIHNvIHRoZSBVSVByb2Nlc3Mgc2lkZSBjYW4g bWlycm9yCisgICAgICAgIHRoZSBjb250ZW50IGluIGEgR3RrQ2xpcGJvYXJkLWJhY2tlZCBEYXRh T2JqZWN0R3RrLCB3aGljaCBpcyB0aGVuCisgICAgICAgIGV4cG9zZWQgdG8gdGhlIHdpbmRvd2lu ZyB0aHJvdWdoIFBsYXRmb3JtUGFzdGVib2FyZC9QYXN0ZWJvYXJkSGVscGVyLgorCisgICAgICAg IFdoZW4gcmVxdWVzdGluZyBjbGlwYm9hcmQgY29udGVudCwgaXQgd29ya3Mgc2ltaWxhcmx5LCB0 aGUgVUlQcm9jZXNzCisgICAgICAgIHNpZGUgZmlyc3QgdXBkYXRlcyBpdHMgRGF0YU9iamVjdEd0 aywgd2hpY2ggaXMgdGhlbiBtaXJyb3JlZCBieSB0aGUKKyAgICAgICAgV2ViUHJvY2VzcyB0aHJv dWdoIHRoZSBQYXN0ZWJvYXJkU3RyYXRlZ3kgcmVxdWVzdHMuCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZTogQWRkZWQg UGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcAorICAgICAgICAqIHBsYXRmb3JtL1Bhc3RlYm9hcmQu aDogQ2xlYW5lZCB1cCBvZiBkaXJlY3QgR1RLKyBkZXBlbmRlbmN5CisgICAgICAgICogcGxhdGZv cm0vUGFzdGVib2FyZFN0cmF0ZWd5Lmg6IEFkZGVkIHBsdW1iaW5nIHRvd2FyZHMgdGhlIHBhc3Rl Ym9hcmQKKyAgICAgICAgcHJveHkuCisgICAgICAgICogcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJv YXJkLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6RGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNv cmU6OkRhdGFPYmplY3RHdGs6OnNldEZvckNsaXBib2FyZCk6IEFkZGVkIHNldHRlcgorICAgICAg ICBmdW5jdGlvbiB0byByZXBsYWNlIGEgY2xpcGJvYXJkJ3MgRGF0YU9iamVjdEd0ay4KKyAgICAg ICAgKiBwbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9QYXN0ZWJvYXJkR3RrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OmNyZWF0 ZUZvckNvcHlBbmRQYXN0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjcmVhdGVG b3JHbG9iYWxTZWxlY3Rpb24pOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6UGFzdGVi b2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpwYXN0ZWJvYXJkTmFtZSk6Cisg ICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVRvQ2xpcGJvYXJkKToKKyAgICAgICAg KFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnJlYWRGcm9tQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNv cmU6OlBhc3RlYm9hcmQ6OndyaXRlUGxhaW5UZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OndyaXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OndyaXRlUGFzdGVi b2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjbGVhcik6CisgICAgICAgIChX ZWJDb3JlOjpQYXN0ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UpOgorICAgICAgICAoV2ViQ29yZTo6 UGFzdGVib2FyZDo6cmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpoYXNEYXRh KToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnR5cGVzKToKKyAgICAgICAgKFdlYkNv cmU6OlBhc3RlYm9hcmQ6OnJlYWRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2Fy ZDo6cmVhZEZpbGVuYW1lcyk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVN0 cmluZyk6IE1hZGUgdG8gdXNlIHRoZQorICAgICAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kgaW5zdGVh ZCBvZiBQYXN0ZWJvYXJkSGVscGVyL0dUSysgQVBJLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9Q bGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBsYXRm b3JtUGFzdGVib2FyZDo6UGxhdGZvcm1QYXN0ZWJvYXJkKToKKyAgICAgICAgKFdlYkNvcmU6OlBs YXRmb3JtUGFzdGVib2FyZDo6c2V0U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OlBsYXRm b3JtUGFzdGVib2FyZDo6Z2V0U2VsZWN0aW9uKTogSW1wbGVtZW50ZWQKKyAgICAgICAgUGxhdGZv cm1QYXN0ZWJvYXJkIHVzaW5nIFBhc3RlYm9hcmRIZWxwZXIvR1RLKyBBUEkuCisKIDIwMTYtMDkt MDQgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmVyc2Ug b3duZXJzaGlwIHJlbGF0aW9uIG9mIFN0eWxlQ2FjaGVkSW1hZ2UgYW5kIENTU0ltYWdlVmFsdWUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dl YkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKaW5kZXggZjIxZmMwNC4uNmMxMzk1YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUv UGxhdGZvcm1HVEsuY21ha2UKQEAgLTIyMSw2ICsyMjEsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3Jl UGxhdGZvcm1HVEtfU09VUkNFUwogICAgIHBsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmNw cAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybUtleWJvYXJkRXZlbnRHdGsuY3BwCiAgICAgcGxh dGZvcm0vZ3RrL1BsYXRmb3JtTW91c2VFdmVudEd0ay5jcHAKKyAgICBwbGF0Zm9ybS9ndGsvUGxh dGZvcm1QYXN0ZWJvYXJkR3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybVNjcmVlbkd0 ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1XaGVlbEV2ZW50R3RrLmNwcAogICAgIHBs YXRmb3JtL2d0ay9SZW5kZXJUaGVtZUdhZGdldC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3Rl Ym9hcmQuaAppbmRleCA0NzMzYjM1Li40ZGJmZWZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFz dGVib2FyZC5oCkBAIC0zMyw3ICszMyw2IEBACiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5n Lmg+CiAKICNpZiBQTEFURk9STShHVEspCi10eXBlZGVmIHN0cnVjdCBfR3RrQ2xpcGJvYXJkIEd0 a0NsaXBib2FyZDsKICNpbmNsdWRlIDx3dGYvZ2xpYi9HUmVmUHRyLmg+CiAjZW5kaWYKIApAQCAt MTQzLDggKzE0Miw5IEBAIHB1YmxpYzoKICAgICB+UGFzdGVib2FyZCgpOwogCiAjaWYgUExBVEZP Uk0oR1RLKQorICAgIGVudW0gY2xhc3MgVHlwZSB7IE5vbmUsIFByaW1hcnksIENsaXBib2FyZCB9 OworICAgIGV4cGxpY2l0IFBhc3RlYm9hcmQoVHlwZSk7CiAgICAgZXhwbGljaXQgUGFzdGVib2Fy ZChSZWZQdHI8RGF0YU9iamVjdEd0az4mJik7Ci0gICAgZXhwbGljaXQgUGFzdGVib2FyZChHdGtD bGlwYm9hcmQqKTsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oV0lOKQpAQCAtMjI2LDggKzIyNiwx MyBAQCBwcml2YXRlOgogI2VuZGlmCiAKICNpZiBQTEFURk9STShHVEspCisgICAgY29uc3QgU3Ry aW5nJiBuYW1lKCkgY29uc3Q7CisgICAgZW51bSBjbGFzcyBTaG91bGRJbmNsdWRlU21hcnRQYXN0 ZSB7IE5vLCBZZXMgfTsKKyAgICB2b2lkIHdyaXRlVG9DbGlwYm9hcmQoU2hvdWxkSW5jbHVkZVNt YXJ0UGFzdGUgPSBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6Tm8pOworICAgIHZvaWQgcmVhZEZy b21DbGlwYm9hcmQoKTsKICAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gbV9kYXRhT2JqZWN0Owot ICAgIEd0a0NsaXBib2FyZCogbV9ndGtDbGlwYm9hcmQ7CisgICAgVHlwZSBtX3Bhc3RlYm9hcmRU eXBlOworICAgIGNvbnN0IFN0cmluZyBtX25hbWU7CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNKElP UykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmRTdHJhdGVn eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZFN0cmF0ZWd5LmgKaW5kZXgg NjMwMDg1ZS4uYWE4OGViNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFz dGVib2FyZFN0cmF0ZWd5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2Fy ZFN0cmF0ZWd5LmgKQEAgLTM3LDYgKzM3LDkgQEAgY2xhc3MgU2hhcmVkQnVmZmVyOwogY2xhc3Mg VVJMOwogc3RydWN0IFBhc3RlYm9hcmRJbWFnZTsKIHN0cnVjdCBQYXN0ZWJvYXJkV2ViQ29udGVu dDsKKyNpZiBQTEFURk9STShHVEspCitjbGFzcyBEYXRhT2JqZWN0R3RrOworI2VuZGlmCiAKIGNs YXNzIFBhc3RlYm9hcmRTdHJhdGVneSB7CiBwdWJsaWM6CkBAIC02OCw2ICs3MSwxMCBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCBsb25nIHNldFBhdGhuYW1lc0ZvclR5cGUoY29uc3QgVmVjdG9yPFN0 cmluZz4mLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJpbmcmIHBhc3Rl Ym9hcmROYW1lKSA9IDA7CiAgICAgdmlydHVhbCBsb25nIHNldFN0cmluZ0ZvclR5cGUoY29uc3Qg U3RyaW5nJiwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiBwYXN0 ZWJvYXJkTmFtZSkgPSAwOwogI2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHZpcnR1YWwg dm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgV2ViQ29yZTo6 RGF0YU9iamVjdEd0ayopID0gMDsKKyAgICB2aXJ0dWFsIFJlZlB0cjxXZWJDb3JlOjpEYXRhT2Jq ZWN0R3RrPiBnZXRTZWxlY3Rpb24oY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkgPSAwOwor I2VuZGlmIC8vIFBMQVRGT1JNKEdUSykKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIH5QYXN0ZWJv YXJkU3RyYXRlZ3koKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L1BsYXRmb3JtUGFzdGVib2FyZC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1Q YXN0ZWJvYXJkLmgKaW5kZXggMGJiNmUyZC4uYWYwOTU5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKQEAgLTQxLDYgKzQxLDkgQEAgT0JKQ19DTEFT UyBVSVBhc3RlYm9hcmQ7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorI2lmIFBMQVRGT1JNKEdU SykKK2NsYXNzIERhdGFPYmplY3RHdGs7CisjZW5kaWYKIGNsYXNzIENvbG9yOwogY2xhc3MgU2hh cmVkQnVmZmVyOwogY2xhc3MgVVJMOwpAQCAtODEsNiArODQsMTEgQEAgcHVibGljOgogICAgIFdF QkNPUkVfRVhQT1JUIFVSTCByZWFkVVJMKGludCBpbmRleCwgY29uc3QgU3RyaW5nJiBwYXN0ZWJv YXJkVHlwZSk7CiAgICAgV0VCQ09SRV9FWFBPUlQgaW50IGNvdW50KCk7CiAKKyNpZiBQTEFURk9S TShHVEspCisgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBzZXRTZWxlY3Rpb24oRGF0YU9iamVjdEd0 ayopOworICAgIFdFQkNPUkVfRVhQT1JUIERhdGFPYmplY3RHdGsqIGdldFNlbGVjdGlvbigpOwor I2VuZGlmCisKIHByaXZhdGU6CiAjaWYgUExBVEZPUk0oTUFDKQogICAgIFJldGFpblB0cjxOU1Bh c3RlYm9hcmQ+IG1fcGFzdGVib2FyZDsKQEAgLTg4LDYgKzk2LDkgQEAgcHJpdmF0ZToKICNpZiBQ TEFURk9STShJT1MpCiAgICAgUmV0YWluUHRyPFVJUGFzdGVib2FyZD4gbV9wYXN0ZWJvYXJkOwog I2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgIEd0a0NsaXBib2FyZCogbV9jbGlwYm9hcmQ7 CisjZW5kaWYKIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9EYXRhT2JqZWN0R3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9EYXRhT2Jq ZWN0R3RrLmNwcAppbmRleCA4NzA5MjM1Li4wNTZkM2FlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuY3BwCkBAIC0xNDcsMTAgKzE0NywxMCBAQCB2b2lk IERhdGFPYmplY3RHdGs6OmNsZWFyQWxsKCkKICAgICBtX2ZpbGVuYW1lcy5jbGVhcigpOwogfQog CitzdGF0aWMgSGFzaE1hcDxHdGtDbGlwYm9hcmQqLCBSZWZQdHI8RGF0YU9iamVjdEd0az4+IG9i amVjdE1hcDsKKwogRGF0YU9iamVjdEd0ayogRGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkKEd0 a0NsaXBib2FyZCogY2xpcGJvYXJkKQogewotICAgIHN0YXRpYyBIYXNoTWFwPEd0a0NsaXBib2Fy ZCosIFJlZlB0cjxEYXRhT2JqZWN0R3RrPiA+IG9iamVjdE1hcDsKLQogICAgIGF1dG8gYWRkUmVz dWx0ID0gb2JqZWN0TWFwLmFkZChjbGlwYm9hcmQsIG51bGxwdHIpOwogICAgIGlmIChhZGRSZXN1 bHQuaXNOZXdFbnRyeSkKICAgICAgICAgYWRkUmVzdWx0Lml0ZXJhdG9yLT52YWx1ZSA9IERhdGFP YmplY3RHdGs6OmNyZWF0ZSgpOwpAQCAtMTU4LDQgKzE1OCwxMCBAQCBEYXRhT2JqZWN0R3RrKiBE YXRhT2JqZWN0R3RrOjpmb3JDbGlwYm9hcmQoR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQpCiAgICAg cmV0dXJuIGFkZFJlc3VsdC5pdGVyYXRvci0+dmFsdWUuZ2V0KCk7CiB9CiAKK3ZvaWQgRGF0YU9i amVjdEd0azo6c2V0Rm9yQ2xpcGJvYXJkKEd0a0NsaXBib2FyZCogY2xpcGJvYXJkLCBEYXRhT2Jq ZWN0R3RrKiBkYXRhT2JqZWN0KQoreworICAgIGF1dG8gYWRkUmVzdWx0ID0gb2JqZWN0TWFwLmFk ZChjbGlwYm9hcmQsIG51bGxwdHIpOworICAgIGFkZFJlc3VsdC5pdGVyYXRvci0+dmFsdWUgPSBk YXRhT2JqZWN0OworfQorCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvRGF0YU9iamVjdEd0ay5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0RhdGFPYmpl Y3RHdGsuaAppbmRleCAzYWJiMWY4Li5hOTQ4ZjFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9EYXRhT2JqZWN0R3RrLmgKQEAgLTY3LDYgKzY3LDcgQEAgcHVibGljOgogICAgIHZv aWQgY2xlYXJNYXJrdXAoKTsKIAogICAgIHN0YXRpYyBEYXRhT2JqZWN0R3RrKiBmb3JDbGlwYm9h cmQoR3RrQ2xpcGJvYXJkKik7CisgICAgc3RhdGljIHZvaWQgc2V0Rm9yQ2xpcGJvYXJkKEd0a0Ns aXBib2FyZCosIERhdGFPYmplY3RHdGsqKTsKIAogcHJpdmF0ZToKICAgICBTdHJpbmcgbV90ZXh0 OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRHdGsu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRHdGsuY3BwCmluZGV4 IDEzYzBkZDAuLmQ5NmQ2ZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9QYXN0ZWJvYXJkR3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFz dGVib2FyZEd0ay5jcHAKQEAgLTIzLDkgKzIzLDEwIEBACiAjaW5jbHVkZSAiRGF0YU9iamVjdEd0 ay5oIgogI2luY2x1ZGUgIkRyYWdEYXRhLmgiCiAjaW5jbHVkZSAiSW1hZ2UuaCIKKyNpbmNsdWRl ICJQYXN0ZWJvYXJkU3RyYXRlZ3kuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmF0ZWdpZXMuaCIK ICNpbmNsdWRlICJVUkwuaCIKLSNpbmNsdWRlICJQYXN0ZWJvYXJkSGVscGVyLmgiCi0jaW5jbHVk ZSA8Z3RrL2d0ay5oPgorI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKQEAgLTQwLDEyICs0MSwxMiBAQCBlbnVtIENsaXBib2FyZERhdGFUeXBl IHsKIAogc3RkOjp1bmlxdWVfcHRyPFBhc3RlYm9hcmQ+IFBhc3RlYm9hcmQ6OmNyZWF0ZUZvckNv cHlBbmRQYXN0ZSgpCiB7Ci0gICAgcmV0dXJuIHN0ZDo6bWFrZV91bmlxdWU8UGFzdGVib2FyZD4o Z3RrX2NsaXBib2FyZF9nZXQoR0RLX1NFTEVDVElPTl9DTElQQk9BUkQpKTsKKyAgICByZXR1cm4g c3RkOjptYWtlX3VuaXF1ZTxQYXN0ZWJvYXJkPihUeXBlOjpDbGlwYm9hcmQpOwogfQogCiBzdGQ6 OnVuaXF1ZV9wdHI8UGFzdGVib2FyZD4gUGFzdGVib2FyZDo6Y3JlYXRlRm9yR2xvYmFsU2VsZWN0 aW9uKCkKIHsKLSAgICByZXR1cm4gc3RkOjptYWtlX3VuaXF1ZTxQYXN0ZWJvYXJkPihndGtfY2xp cGJvYXJkX2dldChHREtfU0VMRUNUSU9OX1BSSU1BUlkpKTsKKyAgICByZXR1cm4gc3RkOjptYWtl X3VuaXF1ZTxQYXN0ZWJvYXJkPihUeXBlOjpQcmltYXJ5KTsKIH0KIAogc3RkOjp1bmlxdWVfcHRy PFBhc3RlYm9hcmQ+IFBhc3RlYm9hcmQ6OmNyZWF0ZVByaXZhdGUoKQpAQCAtNzYsMTcgKzc3LDE1 IEBAIFBhc3RlYm9hcmRJbWFnZTo6flBhc3RlYm9hcmRJbWFnZSgpCiAKIFBhc3RlYm9hcmQ6OlBh c3RlYm9hcmQoUmVmUHRyPERhdGFPYmplY3RHdGs+JiYgZGF0YU9iamVjdCkKICAgICA6IG1fZGF0 YU9iamVjdChXVEZNb3ZlKGRhdGFPYmplY3QpKQotICAgICwgbV9ndGtDbGlwYm9hcmQobnVsbHB0 cikKIHsKICAgICBBU1NFUlQobV9kYXRhT2JqZWN0KTsKIH0KIAotUGFzdGVib2FyZDo6UGFzdGVi b2FyZChHdGtDbGlwYm9hcmQqIGd0a0NsaXBib2FyZCkKLSAgICA6IG1fZGF0YU9iamVjdChEYXRh T2JqZWN0R3RrOjpmb3JDbGlwYm9hcmQoZ3RrQ2xpcGJvYXJkKSkKLSAgICAsIG1fZ3RrQ2xpcGJv YXJkKGd0a0NsaXBib2FyZCkKK1Bhc3RlYm9hcmQ6OlBhc3RlYm9hcmQoVHlwZSB0eXBlKQorICAg IDogbV9kYXRhT2JqZWN0KERhdGFPYmplY3RHdGs6OmNyZWF0ZSgpKQorICAgICwgbV9wYXN0ZWJv YXJkVHlwZSh0eXBlKQorICAgICwgbV9uYW1lKG5hbWUoKSkKIHsKLSAgICBBU1NFUlQobV9kYXRh T2JqZWN0KTsKLSAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5yZWdpc3RlckNsaXBi b2FyZChndGtDbGlwYm9hcmQpOwogfQogCiBQYXN0ZWJvYXJkOjp+UGFzdGVib2FyZCgpCkBAIC0x MjEsNiArMTIwLDQyIEBAIHN0YXRpYyBDbGlwYm9hcmREYXRhVHlwZSBkYXRhT2JqZWN0VHlwZUZy b21IVE1MQ2xpcGJvYXJkVHlwZShjb25zdCBTdHJpbmcmIHJhd1R5CiAgICAgcmV0dXJuIENsaXBi b2FyZERhdGFUeXBlVW5rbm93bjsKIH0KIAorY29uc3QgU3RyaW5nJiBQYXN0ZWJvYXJkOjpuYW1l KCkgY29uc3QKK3sKKyAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8Y29uc3QgU3RyaW5nPiBwcmlt YXJ5TmFtZShBU0NJSUxpdGVyYWwoIlBSSU1BUlkiKSk7CisgICAgc3RhdGljIE5ldmVyRGVzdHJv eWVkPGNvbnN0IFN0cmluZz4gY2xpcGJvYXJkTmFtZShBU0NJSUxpdGVyYWwoIkNMSVBCT0FSRCIp KTsKKworICAgIHN3aXRjaCAobV9wYXN0ZWJvYXJkVHlwZSkgeworICAgIGNhc2UgVHlwZTo6UHJp bWFyeToKKyAgICAgICAgcmV0dXJuIHByaW1hcnlOYW1lOworICAgIGNhc2UgVHlwZTo6Q2xpcGJv YXJkOgorICAgICAgICByZXR1cm4gY2xpcGJvYXJkTmFtZTsKKyAgICBkZWZhdWx0OgorICAgICAg ICByZXR1cm4gZW1wdHlTdHJpbmcoKTsKKyAgICB9Cit9CisKK3ZvaWQgUGFzdGVib2FyZDo6d3Jp dGVUb0NsaXBib2FyZChTaG91bGRJbmNsdWRlU21hcnRQYXN0ZSBzaG91bGRJbmNsdWRlU21hcnRQ YXN0ZSkKK3sKKyAgICBpZiAobV9uYW1lLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworICAg IFBhc3RlYm9hcmRTdHJhdGVneSYgc3RyYXRlZ3kgPSAqcGxhdGZvcm1TdHJhdGVnaWVzKCktPnBh c3RlYm9hcmRTdHJhdGVneSgpOworICAgIERhdGFPYmplY3RHdGsqIGRhdGFPYmplY3QgPSBtX2Rh dGFPYmplY3QuZ2V0KCk7CisKKyAgICBpZiAoc2hvdWxkSW5jbHVkZVNtYXJ0UGFzdGUgPT0gU2hv dWxkSW5jbHVkZVNtYXJ0UGFzdGU6Ok5vKQorICAgICAgICBkYXRhT2JqZWN0LT5zZXRVbmtub3du VHlwZURhdGEoImFwcGxpY2F0aW9uL3ZuZC53ZWJraXRndGsuc21hcnRwYXN0ZSIsIGVtcHR5U3Ry aW5nKCkpOworICAgIHN0cmF0ZWd5LnNldFNlbGVjdGlvbihtX25hbWUsIGRhdGFPYmplY3QpOwor fQorCit2b2lkIFBhc3RlYm9hcmQ6OnJlYWRGcm9tQ2xpcGJvYXJkKHZvaWQpCit7CisgICAgaWYg KG1fbmFtZS5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKyAgICBQYXN0ZWJvYXJkU3RyYXRl Z3kmIHN0cmF0ZWd5ID0gKnBsYXRmb3JtU3RyYXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3ko KTsKKyAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gZGF0YU9iamVjdCA9IHN0cmF0ZWd5LmdldFNl bGVjdGlvbihtX25hbWUpOworICAgIG1fZGF0YU9iamVjdCA9IGRhdGFPYmplY3QuZ2V0KCk7Cit9 CisKIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVTdHJpbmcoY29uc3QgU3RyaW5nJiB0eXBlLCBjb25z dCBTdHJpbmcmIGRhdGEpCiB7CiAgICAgc3dpdGNoIChkYXRhT2JqZWN0VHlwZUZyb21IVE1MQ2xp cGJvYXJkVHlwZSh0eXBlKSkgewpAQCAtMTQ3LDggKzE4Miw3IEBAIHZvaWQgUGFzdGVib2FyZDo6 d3JpdGVQbGFpblRleHQoY29uc3QgU3RyaW5nJiB0ZXh0LCBTbWFydFJlcGxhY2VPcHRpb24gc21h cnRSZXBsCiAgICAgbV9kYXRhT2JqZWN0LT5jbGVhckFsbCgpOwogICAgIG1fZGF0YU9iamVjdC0+ c2V0VGV4dCh0ZXh0KTsKIAotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVi b2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBi b2FyZCwgKHNtYXJ0UmVwbGFjZU9wdGlvbiA9PSBDYW5TbWFydFJlcGxhY2UpID8gUGFzdGVib2Fy ZEhlbHBlcjo6SW5jbHVkZVNtYXJ0UGFzdGUgOiBQYXN0ZWJvYXJkSGVscGVyOjpEb05vdEluY2x1 ZGVTbWFydFBhc3RlKTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJkKHNtYXJ0UmVwbGFjZU9wdGlvbiA9 PSBDYW5TbWFydFJlcGxhY2UgPyBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6WWVzIDogU2hvdWxk SW5jbHVkZVNtYXJ0UGFzdGU6Ok5vKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25z dCBQYXN0ZWJvYXJkVVJMJiBwYXN0ZWJvYXJkVVJMKQpAQCAtMTU4LDggKzE5Miw3IEBAIHZvaWQg UGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZFVSTCYgcGFzdGVib2FyZFVSTCkKICAg ICBtX2RhdGFPYmplY3QtPmNsZWFyQWxsKCk7CiAgICAgbV9kYXRhT2JqZWN0LT5zZXRVUkwocGFz dGVib2FyZFVSTC51cmwsIHBhc3RlYm9hcmRVUkwudGl0bGUpOwogCi0gICAgaWYgKG1fZ3RrQ2xp cGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBi b2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9 CiAKIHZvaWQgUGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZEltYWdlJiBwYXN0ZWJv YXJkSW1hZ2UpCkBAIC0xNzQsOCArMjA3LDcgQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25z dCBQYXN0ZWJvYXJkSW1hZ2UmIHBhc3RlYm9hcmRJbWFnZSkKICAgICBpZiAocGl4YnVmKQogICAg ICAgICBtX2RhdGFPYmplY3QtPnNldEltYWdlKHBpeGJ1Zi5nZXQoKSk7CiAKLSAgICBpZiAobV9n dGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRl Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIHdyaXRlVG9DbGlwYm9hcmQo KTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkV2ViQ29udGVu dCYgcGFzdGVib2FyZENvbnRlbnQpCkBAIC0xODQsOCArMjE2LDcgQEAgdm9pZCBQYXN0ZWJvYXJk Ojp3cml0ZShjb25zdCBQYXN0ZWJvYXJkV2ViQ29udGVudCYgcGFzdGVib2FyZENvbnRlbnQpCiAg ICAgbV9kYXRhT2JqZWN0LT5zZXRUZXh0KHBhc3RlYm9hcmRDb250ZW50LnRleHQpOwogICAgIG1f ZGF0YU9iamVjdC0+c2V0TWFya3VwKHBhc3RlYm9hcmRDb250ZW50Lm1hcmt1cCk7CiAKLSAgICBp ZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigp LndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsIHBhc3RlYm9hcmRDb250ZW50 LmNhblNtYXJ0Q29weU9yRGVsZXRlID8gUGFzdGVib2FyZEhlbHBlcjo6SW5jbHVkZVNtYXJ0UGFz dGUgOiBQYXN0ZWJvYXJkSGVscGVyOjpEb05vdEluY2x1ZGVTbWFydFBhc3RlLCBwYXN0ZWJvYXJk Q29udGVudC5jYWxsYmFjay5nZXQoKSk7CisgICAgd3JpdGVUb0NsaXBib2FyZChwYXN0ZWJvYXJk Q29udGVudC5jYW5TbWFydENvcHlPckRlbGV0ZSA/IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlOjpZ ZXMgOiBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6Tm8pOwogfQogCiB2b2lkIFBhc3RlYm9hcmQ6 OndyaXRlUGFzdGVib2FyZChjb25zdCBQYXN0ZWJvYXJkJiBzb3VyY2VQYXN0ZWJvYXJkKQpAQCAt MjA4LDggKzIzOSw3IEBAIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVQYXN0ZWJvYXJkKGNvbnN0IFBh c3RlYm9hcmQmIHNvdXJjZVBhc3RlYm9hcmQpCiAgICAgICAgICAgICBtX2RhdGFPYmplY3QtPnNl dFVua25vd25UeXBlRGF0YShpdC5rZXksIGl0LnZhbHVlKTsKICAgICB9CiAKLSAgICBpZiAobV9n dGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRl Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIHdyaXRlVG9DbGlwYm9hcmQo KTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjpjbGVhcigpCkBAIC0yMjAsOCArMjUwLDcgQEAgdm9p ZCBQYXN0ZWJvYXJkOjpjbGVhcigpCiAgICAgLy8gc3RpbGwgY29udGFpbiB0aGUgIkZpbGVzIiBz dHJpbmcgaWYgYW55IGZpbGVzIHdlcmUgaW5jbHVkZWQgaW4gdGhlIGRyYWcpLiIKICAgICBtX2Rh dGFPYmplY3QtPmNsZWFyQWxsRXhjZXB0RmlsZW5hbWVzKCk7CiAKLSAgICBpZiAobV9ndGtDbGlw Ym9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJv YXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQpOworICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0K IAogdm9pZCBQYXN0ZWJvYXJkOjpjbGVhcihjb25zdCBTdHJpbmcmIHR5cGUpCkBAIC0yNDUsMTMg KzI3NCwxMyBAQCB2b2lkIFBhc3RlYm9hcmQ6OmNsZWFyKGNvbnN0IFN0cmluZyYgdHlwZSkKICAg ICAgICAgYnJlYWs7CiAgICAgfQogCi0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQ YXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1fZ3Rr Q2xpcGJvYXJkKTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9CiAKIGJvb2wgUGFzdGVib2Fy ZDo6Y2FuU21hcnRSZXBsYWNlKCkKIHsKLSAgICByZXR1cm4gbV9ndGtDbGlwYm9hcmQgJiYgUGFz dGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuY2xpcGJvYXJkQ29udGVudFN1cHBvcnRzU21hcnRS ZXBsYWNlKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICByZWFkRnJvbUNsaXBib2FyZCgpOworICAgIHJl dHVybiAhbV9kYXRhT2JqZWN0LT51bmtub3duVHlwZURhdGEoImFwcGxpY2F0aW9uL3ZuZC53ZWJr aXRndGsuc21hcnRwYXN0ZSIpLmlzRW1wdHkoKTsKIH0KIAogI2lmIEVOQUJMRShEUkFHX1NVUFBP UlQpCkBAIC0yNjIsMjMgKzI5MSwxOSBAQCB2b2lkIFBhc3RlYm9hcmQ6OnNldERyYWdJbWFnZShE cmFnSW1hZ2VSZWYsIGNvbnN0IEludFBvaW50JikKIAogdm9pZCBQYXN0ZWJvYXJkOjpyZWFkKFBh c3RlYm9hcmRQbGFpblRleHQmIHRleHQpCiB7Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAg ICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyht X2d0a0NsaXBib2FyZCk7CisgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKICAgICB0ZXh0LnRleHQg PSBtX2RhdGFPYmplY3QtPnRleHQoKTsKIH0KIAogYm9vbCBQYXN0ZWJvYXJkOjpoYXNEYXRhKCkK IHsKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNp bmdsZXRvbigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKLQorICAgIHJl YWRGcm9tQ2xpcGJvYXJkKCk7CiAgICAgcmV0dXJuIG1fZGF0YU9iamVjdC0+aGFzVGV4dCgpIHx8 IG1fZGF0YU9iamVjdC0+aGFzTWFya3VwKCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNVUklMaXN0KCkg fHwgbV9kYXRhT2JqZWN0LT5oYXNJbWFnZSgpIHx8IG1fZGF0YU9iamVjdC0+aGFzVW5rbm93blR5 cGVEYXRhKCk7CiB9CiAKIFZlY3RvcjxTdHJpbmc+IFBhc3RlYm9hcmQ6OnR5cGVzKCkKIHsKLSAg ICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRv bigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkKTsKKyAgICByZWFkRnJvbUNs aXBib2FyZCgpOwogCiAgICAgVmVjdG9yPFN0cmluZz4gdHlwZXM7CiAgICAgaWYgKG1fZGF0YU9i amVjdC0+aGFzVGV4dCgpKSB7CkBAIC0zMDYsOCArMzMxLDcgQEAgVmVjdG9yPFN0cmluZz4gUGFz dGVib2FyZDo6dHlwZXMoKQogCiBTdHJpbmcgUGFzdGVib2FyZDo6cmVhZFN0cmluZyhjb25zdCBT dHJpbmcmIHR5cGUpCiB7Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJv YXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2Fy ZCk7CisgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKIAogICAgIHN3aXRjaCAoZGF0YU9iamVjdFR5 cGVGcm9tSFRNTENsaXBib2FyZFR5cGUodHlwZSkpIHsKICAgICBjYXNlIENsaXBib2FyZERhdGFU eXBlVVJJTGlzdDoKQEAgLTMyOSw4ICszNTMsNyBAQCBTdHJpbmcgUGFzdGVib2FyZDo6cmVhZFN0 cmluZyhjb25zdCBTdHJpbmcmIHR5cGUpCiAKIFZlY3RvcjxTdHJpbmc+IFBhc3RlYm9hcmQ6OnJl YWRGaWxlbmFtZXMoKQogewotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVi b2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9h cmQpOworICAgIHJlYWRGcm9tQ2xpcGJvYXJkKCk7CiAKICAgICByZXR1cm4gbV9kYXRhT2JqZWN0 LT5maWxlbmFtZXMoKTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0 ay9QbGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1BsYXRmb3JtUGFzdGVib2FyZEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMC4uOTM0YzhhZQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2d0ay9QbGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwCkBAIC0wLDAgKzEsNDkgQEAKKy8qCisgKiAg Q29weXJpZ2h0IChDKSAyMDE2IFJlZCBIYXQgSW5jLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMg ZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5 IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICog IExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVp dGhlcgorICogIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdO VQorICogIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisg KgorICogIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBu b3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEg RnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNB CisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtUGFzdGVib2Fy ZC5oIgorCisjaW5jbHVkZSAiQ29sb3IuaCIKKyNpbmNsdWRlICJEYXRhT2JqZWN0R3RrLmgiCisj aW5jbHVkZSAiUGFzdGVib2FyZEhlbHBlci5oIgorI2luY2x1ZGUgIlNoYXJlZEJ1ZmZlci5oIgor I2luY2x1ZGUgIlVSTC5oIgorI2luY2x1ZGUgPGd0ay9ndGsuaD4KKworbmFtZXNwYWNlIFdlYkNv cmUgeworCitQbGF0Zm9ybVBhc3RlYm9hcmQ6OlBsYXRmb3JtUGFzdGVib2FyZChjb25zdCBTdHJp bmcmIHBhc3RlYm9hcmROYW1lKQorICAgIDogbV9jbGlwYm9hcmQoZ3RrX2NsaXBib2FyZF9nZXQo Z2RrX2F0b21faW50ZXJuKHBhc3RlYm9hcmROYW1lLnV0ZjgoKS5kYXRhKCksIFRSVUUpKSkKK3sK KyAgICBBU1NFUlQobV9jbGlwYm9hcmQpOworfQorCit2b2lkIFBsYXRmb3JtUGFzdGVib2FyZDo6 c2V0U2VsZWN0aW9uKERhdGFPYmplY3RHdGsqIGRhdGFPYmplY3QpCit7CisgICAgRGF0YU9iamVj dEd0azo6c2V0Rm9yQ2xpcGJvYXJkKG1fY2xpcGJvYXJkLCBkYXRhT2JqZWN0KTsKKyAgICBQYXN0 ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1fY2xpcGJv YXJkKTsKK30KKworRGF0YU9iamVjdEd0ayogUGxhdGZvcm1QYXN0ZWJvYXJkOjpnZXRTZWxlY3Rp b24oKQoreworICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLmdldENsaXBib2FyZENv bnRlbnRzKG1fY2xpcGJvYXJkKTsKKyAgICByZXR1cm4gRGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJv YXJkKG1fY2xpcGJvYXJkKTsKK30KKworfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hh bmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDY3ZmI2OGMuLmJkZjY2ZTMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NiBAQAorMjAxNi0wOS0xMiAgQ2FybG9zIEdhcm5hY2hv ICA8Y2FybG9zZ0Bnbm9tZS5vcmc+CisKKyAgICAgICAgW0dUS11bV2F5bGFuZF0gSW1wbGVtZW50 IGNsaXBib2FyZCBzdXBwb3J0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xNDY1NzQKKworICAgICAgICBBZGQgdGhlIG5lY2Vzc2FyeSBwbHVtYmluZyBm b3IgdGhlIEdUSysgYmFja2VuZCB0byB1c2UgdGhlCisgICAgICAgIFBsYXRmb3JtUGFzdGVib2Fy ZCBpbiBXZWJDb3JlLiBBbGwgc2VsZWN0aW9uIGRhdGEgaXMgdHJhbnNtaXR0ZWQKKyAgICAgICAg YXQgb25jZSB0aHJvdWdoIHRoZSBzZXJpYWxpemF0aW9uIG9mIFBhc3RlYm9hcmRDb250ZW50R3Rr L0RhdGFPYmplY3RHdGsuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZTogQWRkIFBhc3RlYm9hcmRDb250ZW50R3RrLmNw cCBhbmQKKyAgICAgICAgV2ViUGFzdGVib2FyZFByb3h5R3RrLmNwcAorICAgICAgICAqIFNoYXJl ZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuY3BwOgorICAgICAgICAoSVBDOjplbmNvZGUpOgorICAg ICAgICAoSVBDOjpkZWNvZGUpOiBSZW5hbWVkIGZyb20gZW5jb2RlRGF0YU9iamVjdC9kZWNvZGVE YXRhT2JqZWN0CisgICAgICAgIGFuZCBtYWRlIHB1YmxpYy4KKyAgICAgICAgKElQQzo6QXJndW1l bnRDb2RlcjxEcmFnRGF0YT46OmVuY29kZSk6CisgICAgICAgIChJUEM6OkFyZ3VtZW50Q29kZXI8 RHJhZ0RhdGE+OjpkZWNvZGUpOiBVcGRhdGUgRGF0YU9iamVjdEd0aworICAgICAgICBlbmNvZGUv ZGVjb2RlIGNhbGxlcnMuCisgICAgICAgICogU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5o OiBFeHBvc2UgZW5jb2RlL2RlY29kZSBtZXRob2RzIGZvcgorICAgICAgICBEYXRhT2JqZWN0R3Rr LgorICAgICAgICAqIFNoYXJlZC9ndGsvUGFzdGVib2FyZENvbnRlbnRHdGsuY3BwOiBBZGRlZC4g V3JhcHMgYSBEYXRhT2JqZWN0R3RrCisgICAgICAgIHNvIGl0IGNhbiBiZSBzZXJpYWxpemVkIG9u IFdlYlByb2Nlc3MvVUlQcm9jZXNzIG1lc3NhZ2luZy4KKyAgICAgICAgKFdlYktpdDo6UGFzdGVi b2FyZENvbnRlbnRHdGs6OlBhc3RlYm9hcmRDb250ZW50R3RrKToKKyAgICAgICAgKFdlYktpdDo6 UGFzdGVib2FyZENvbnRlbnRHdGs6OmVuY29kZSk6CisgICAgICAgIChXZWJLaXQ6OlBhc3RlYm9h cmRDb250ZW50R3RrOjpkZWNvZGUpOgorICAgICAgICAqIFNoYXJlZC9ndGsvUGFzdGVib2FyZENv bnRlbnRHdGsuaDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94 eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMuaW46 IEFkZGVkIHBsdW1iaW5nIGZvciB0aGUKKyAgICAgICAgR1RLKyBwYXN0ZWJvYXJkIHByb3h5IGZ1 bmN0aW9ucy4KKyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5j cHA6IEFkZGVkCisgICAgICAgIChXZWJLaXQ6OldlYlBhc3RlYm9hcmRQcm94eTo6c2V0U2VsZWN0 aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViUGFzdGVib2FyZFByb3h5OjpnZXRTZWxlY3Rpb24p OkltcGxlbWVudGVkIGZ1bmN0aW9ucyBob29raW5nCisgICAgICAgIGludG8gdGhlIFBsYXRmb3Jt UGFzdGVib2FyZC4gUGVyLXNlbGVjdGlvbiAoaWUuIHByaW1hcnkvY2xpcGJvYXJkKQorICAgICAg ICBQbGF0Zm9ybVBhc3RlYm9hcmRzIGFyZSBrZXB0IGF0IHRoaXMgbGV2ZWwsIHNvIHRob3NlIGFy ZSBpbmRlcGVuZGVudGx5CisgICAgICAgIHNldCBhbmQgZGVhbHQgd2l0aC4KKyAgICAgICAgKiBX ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHA6CisgICAg ICAgIChXZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6c2V0U2VsZWN0aW9uKToKKyAgICAg ICAgKFdlYktpdDo6V2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpnZXRTZWxlY3Rpb24pOgorICAgICAg ICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmg6IEFk ZGVkIG1ldGhvZHMgdG8KKyAgICAgICAgc2VuZCB0aGUgV2ViUHJvY2Vzcy0+VUlQcm9jZXNzIG1l c3NhZ2VzLgorCiAyMDE2LTA5LTA0ICBDb21taXQgUXVldWUgIDxjb21taXQtcXVldWVAd2Via2l0 Lm9yZz4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMjA1NDE1LgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV2ViS2l0Mi9Q bGF0Zm9ybUdUSy5jbWFrZQppbmRleCBlNjQwNjAzLi4yZTUyZDM0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9y bUdUSy5jbWFrZQpAQCAtNzEsNiArNzEsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMK ICAgICBTaGFyZWQvZ3RrL05hdGl2ZVdlYk1vdXNlRXZlbnRHdGsuY3BwCiAgICAgU2hhcmVkL2d0 ay9OYXRpdmVXZWJUb3VjaEV2ZW50R3RrLmNwcAogICAgIFNoYXJlZC9ndGsvTmF0aXZlV2ViV2hl ZWxFdmVudEd0ay5jcHAKKyAgICBTaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50R3RrLmNwcAog ICAgIFNoYXJlZC9ndGsvUHJpbnRJbmZvR3RrLmNwcAogICAgIFNoYXJlZC9ndGsvUHJvY2Vzc0V4 ZWN1dGFibGVQYXRoR3RrLmNwcAogICAgIFNoYXJlZC9ndGsvV2ViQ29udGV4dE1lbnVJdGVtR3Rr LmNwcApAQCAtMzEzLDYgKzMxNCw3IEBAIGxpc3QoQVBQRU5EIFdlYktpdDJfU09VUkNFUwogICAg IFVJUHJvY2Vzcy9ndGsvV2ViSW5zcGVjdG9yQ2xpZW50R3RrLmNwcAogICAgIFVJUHJvY2Vzcy9n dGsvV2ViSW5zcGVjdG9yUHJveHlHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJv eHlHdGsuY3BwCisgICAgVUlQcm9jZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwCiAg ICAgVUlQcm9jZXNzL2d0ay9XZWJQb3B1cE1lbnVQcm94eUd0ay5jcHAKICAgICBVSVByb2Nlc3Mv Z3RrL1dlYlByZWZlcmVuY2VzR3RrLmNwcAogICAgIFVJUHJvY2Vzcy9ndGsvV2ViUHJvY2Vzc1Bv b2xHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50 Q29kZXJzR3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNH dGsuY3BwCmluZGV4IGZkOTQ1YTA2Li4wYzkxYjdkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcApAQCAtODIsNyArODIsNyBAQCBzdGF0aWMg Ym9vbCBkZWNvZGVJbWFnZShEZWNvZGVyJiBkZWNvZGVyLCBHUmVmUHRyPEdka1BpeGJ1Zj4mIHBp eGJ1ZikKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQgZW5jb2RlRGF0YU9iamVj dChFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBEYXRhT2JqZWN0R3RrKiBkYXRhT2JqZWN0KQordm9p ZCBlbmNvZGUoRW5jb2RlciYgZW5jb2RlciwgY29uc3QgRGF0YU9iamVjdEd0ayogZGF0YU9iamVj dCkKIHsKICAgICBib29sIGhhc1RleHQgPSBkYXRhT2JqZWN0LT5oYXNUZXh0KCk7CiAgICAgZW5j b2RlciA8PCBoYXNUZXh0OwpAQCAtMTE1LDcgKzExNSw3IEBAIHN0YXRpYyB2b2lkIGVuY29kZURh dGFPYmplY3QoRW5jb2RlciYgZW5jb2RlciwgY29uc3QgRGF0YU9iamVjdEd0ayogZGF0YU9iamVj dCkKICAgICAgICAgZW5jb2RlciA8PCBkYXRhT2JqZWN0LT51bmtub3duVHlwZXMoKTsKIH0KIAot c3RhdGljIGJvb2wgZGVjb2RlRGF0YU9iamVjdChEZWNvZGVyJiBkZWNvZGVyLCBSZWZQdHI8RGF0 YU9iamVjdEd0az4mIGRhdGFPYmplY3QpCitib29sIGRlY29kZShEZWNvZGVyJiBkZWNvZGVyLCBS ZWZQdHI8RGF0YU9iamVjdEd0az4mIGRhdGFPYmplY3QpCiB7CiAgICAgUmVmUHRyPERhdGFPYmpl Y3RHdGs+IGRhdGEgPSBEYXRhT2JqZWN0R3RrOjpjcmVhdGUoKTsKIApAQCAtMTk4LDcgKzE5OCw3 IEBAIHZvaWQgQXJndW1lbnRDb2RlcjxEcmFnRGF0YT46OmVuY29kZShFbmNvZGVyJiBlbmNvZGVy LCBjb25zdCBEcmFnRGF0YSYgZHJhZ0RhdGEpCiAgICAgRGF0YU9iamVjdEd0ayogcGxhdGZvcm1E YXRhID0gZHJhZ0RhdGEucGxhdGZvcm1EYXRhKCk7CiAgICAgZW5jb2RlciA8PCBzdGF0aWNfY2Fz dDxib29sPihwbGF0Zm9ybURhdGEpOwogICAgIGlmIChwbGF0Zm9ybURhdGEpCi0gICAgICAgIGVu Y29kZURhdGFPYmplY3QoZW5jb2RlciwgcGxhdGZvcm1EYXRhKTsKKyAgICAgICAgSVBDOjplbmNv ZGUoZW5jb2RlciwgcGxhdGZvcm1EYXRhKTsKIH0KIAogYm9vbCBBcmd1bWVudENvZGVyPERyYWdE YXRhPjo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIsIERyYWdEYXRhJiBkcmFnRGF0YSkKQEAgLTIy NSw3ICsyMjUsNyBAQCBib29sIEFyZ3VtZW50Q29kZXI8RHJhZ0RhdGE+OjpkZWNvZGUoRGVjb2Rl ciYgZGVjb2RlciwgRHJhZ0RhdGEmIGRyYWdEYXRhKQogCiAgICAgUmVmUHRyPERhdGFPYmplY3RH dGs+IHBsYXRmb3JtRGF0YTsKICAgICBpZiAoaGFzUGxhdGZvcm1EYXRhKSB7Ci0gICAgICAgIGlm ICghZGVjb2RlRGF0YU9iamVjdChkZWNvZGVyLCBwbGF0Zm9ybURhdGEpKQorICAgICAgICBpZiAo IUlQQzo6ZGVjb2RlKGRlY29kZXIsIHBsYXRmb3JtRGF0YSkpCiAgICAgICAgICAgICByZXR1cm4g ZmFsc2U7CiAgICAgfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0Fy Z3VtZW50Q29kZXJzR3RrLmggYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29k ZXJzR3RrLmgKaW5kZXggMDFhYzRjZi4uMTY5YzY2OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuaApAQCAtNTIsNiArNTIsOSBAQCBib29sIGRlY29k ZShEZWNvZGVyJiwgR1JlZlB0cjxHdGtQcmludFNldHRpbmdzPiYpOwogdm9pZCBlbmNvZGUoRW5j b2RlciYsIEd0a1BhZ2VTZXR1cCopOwogYm9vbCBkZWNvZGUoRGVjb2RlciYsIEdSZWZQdHI8R3Rr UGFnZVNldHVwPiYpOwogCit2b2lkIGVuY29kZShFbmNvZGVyJiwgY29uc3QgV2ViQ29yZTo6RGF0 YU9iamVjdEd0ayopOworYm9vbCBkZWNvZGUoRGVjb2RlciYsIFJlZlB0cjxXZWJDb3JlOjpEYXRh T2JqZWN0R3RrPiYpOworCiB9IC8vIG5hbWVzcGFjZSBJUEMKIAogI2VuZGlmIC8vIEFyZ3VtZW50 Q29kZXJzR3RrX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFzdGVi b2FyZENvbnRlbnRHdGsuY3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL2d0ay9QYXN0ZWJvYXJk Q29udGVudEd0ay5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWJlNmEx MgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFzdGVib2Fy ZENvbnRlbnRHdGsuY3BwCkBAIC0wLDAgKzEsNjEgQEAKKy8qCisgKiAgQ29weXJpZ2h0IChDKSAy MDE2IFJlZCBIYXQgSW5jLgorICoKKyAqICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2UgYXMgcHVi bGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogIHZlcnNp b24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lv bi4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqICBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogIExlc3NlciBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAqICBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRo ZSBGcmVlIFNvZnR3YXJlCisgKiAgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3RyZWV0 LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKi8KKworI2luY2x1 ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlBhc3RlYm9hcmRDb250ZW50R3RrLmgiCisKKyNpbmNs dWRlICJBcmd1bWVudENvZGVyc0d0ay5oIgorI2luY2x1ZGUgIkRhdGFPYmplY3RHdGsuaCIKKyNp bmNsdWRlICJEZWNvZGVyLmgiCisjaW5jbHVkZSAiRW5jb2Rlci5oIgorI2luY2x1ZGUgPHd0Zi9S ZXRhaW5QdHIuaD4KKworbmFtZXNwYWNlIFdlYktpdCB7CisKK1Bhc3RlYm9hcmRDb250ZW50R3Rr OjpQYXN0ZWJvYXJkQ29udGVudEd0aygpCit7Cit9CisKK1Bhc3RlYm9hcmRDb250ZW50R3RrOjpQ YXN0ZWJvYXJkQ29udGVudEd0ayhXZWJDb3JlOjpEYXRhT2JqZWN0R3RrKiBkYXRhKQorICAgIDog ZGF0YU9iamVjdChkYXRhKQoreworfQorCit2b2lkIFBhc3RlYm9hcmRDb250ZW50R3RrOjplbmNv ZGUoSVBDOjpFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAoreworICAgIGVuY29kZXIgPDwgc3RhdGlj X2Nhc3Q8Ym9vbD4oZGF0YU9iamVjdCk7CisgICAgaWYgKGRhdGFPYmplY3QpCisgICAgICAgIElQ Qzo6ZW5jb2RlKGVuY29kZXIsIGRhdGFPYmplY3QuZ2V0KCkpOworfQorCitib29sIFBhc3RlYm9h cmRDb250ZW50R3RrOjpkZWNvZGUoSVBDOjpEZWNvZGVyJiBkZWNvZGVyLCBQYXN0ZWJvYXJkQ29u dGVudEd0ayYgcGFzdGVib2FyZENvbnRlbnQpCit7CisgICAgYm9vbCBoYXNQYXN0ZWJvYXJkQ29u dGVudDsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc1Bhc3RlYm9hcmRDb250ZW50KSkKKyAg ICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgaWYgKCFoYXNQYXN0ZWJvYXJkQ29udGVudCkKKyAg ICAgICAgcmV0dXJuIHRydWU7CisKKyAgICBpZiAoIUlQQzo6ZGVjb2RlKGRlY29kZXIsIHBhc3Rl Ym9hcmRDb250ZW50LmRhdGFPYmplY3QpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICBy ZXR1cm4gdHJ1ZTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50R3RrLmggYi9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50R3RrLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uYTg4MDI1OAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJL aXQyL1NoYXJlZC9ndGsvUGFzdGVib2FyZENvbnRlbnRHdGsuaApAQCAtMCwwICsxLDQzIEBACisv KgorICogIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiAgVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICog IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJs aWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAg TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZvdW5kYXRpb24sIElu Yy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEz MDEgIFVTQQorICovCisKKyNpZm5kZWYgUGFzdGVib2FyZENvbnRlbnRHdGtfaAorI2RlZmluZSBQ YXN0ZWJvYXJkQ29udGVudEd0a19oCisKKyNpbmNsdWRlICJEYXRhT2JqZWN0R3RrLmgiCisKK25h bWVzcGFjZSBJUEMgeworY2xhc3MgRGVjb2RlcjsKK2NsYXNzIEVuY29kZXI7Cit9CisKK25hbWVz cGFjZSBXZWJLaXQgeworCitzdHJ1Y3QgUGFzdGVib2FyZENvbnRlbnRHdGsgeworICAgIFBhc3Rl Ym9hcmRDb250ZW50R3RrKCk7CisgICAgZXhwbGljaXQgUGFzdGVib2FyZENvbnRlbnRHdGsoV2Vi Q29yZTo6RGF0YU9iamVjdEd0ayopOworCisgICAgUmVmUHRyPFdlYkNvcmU6OkRhdGFPYmplY3RH dGs+IGRhdGFPYmplY3Q7CisKKyAgICB2b2lkIGVuY29kZShJUEM6OkVuY29kZXImKSBjb25zdDsK KyAgICBzdGF0aWMgYm9vbCBkZWNvZGUoSVBDOjpEZWNvZGVyJiwgUGFzdGVib2FyZENvbnRlbnRH dGsmKTsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gUGFzdGVib2Fy ZENvbnRlbnRHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBh c3RlYm9hcmRQcm94eS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQ cm94eS5oCmluZGV4IDVlMmE1YjEuLjhlNjY2ZWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmgKQEAgLTQwLDYgKzQwLDEwIEBAIHN0cnVjdCBQYXN0 ZWJvYXJkV2ViQ29udGVudDsKIAogbmFtZXNwYWNlIFdlYktpdCB7CiAKKyNpZiBQTEFURk9STShH VEspCitjbGFzcyBQYXN0ZWJvYXJkQ29udGVudEd0azsKKyNlbmRpZgorCiBjbGFzcyBXZWJQcm9j ZXNzUHJveHk7CiAKIGNsYXNzIFdlYlBhc3RlYm9hcmRQcm94eSA6IHB1YmxpYyBJUEM6Ok1lc3Nh Z2VSZWNlaXZlciB7CkBAIC04MSw2ICs4NSwxMCBAQCBwcml2YXRlOgogICAgIHZvaWQgc2V0UGFz dGVib2FyZFN0cmluZ0ZvclR5cGUoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgY29uc3Qg U3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiwgdWludDY0X3QmIG5ld0NoYW5n ZUNvdW50KTsKICAgICB2b2lkIHNldFBhc3RlYm9hcmRCdWZmZXJGb3JUeXBlKGNvbnN0IFN0cmlu ZyYgcGFzdGVib2FyZE5hbWUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFNo YXJlZE1lbW9yeTo6SGFuZGxlJiwgdWludDY0X3Qgc2l6ZSwgdWludDY0X3QmIG5ld0NoYW5nZUNv dW50KTsKICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2b2lkIHNldFNlbGVjdGlvbihj b25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBXZWJLaXQ6OlBhc3RlYm9hcmRDb250 ZW50R3RrJik7CisgICAgdm9pZCBnZXRTZWxlY3Rpb24oY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJk TmFtZSwgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0ayYpOworI2VuZGlmIC8vIFBMQVRGT1JN KEdUSykKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMuaW4KaW5kZXggZDBk OWZhMS4uMDgyN2EyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBh c3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv V2ViUGFzdGVib2FyZFByb3h5Lm1lc3NhZ2VzLmluCkBAIC00OCw0ICs0OCw5IEBAIG1lc3NhZ2Vz IC0+IFdlYlBhc3RlYm9hcmRQcm94eSB7CiAgICAgU2V0UGFzdGVib2FyZFN0cmluZ0ZvclR5cGUo U3RyaW5nIHBhc3RlYm9hcmROYW1lLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUsIFN0cmluZyBzdHJp bmcpIC0+ICh1aW50NjRfdCBjaGFuZ2VDb3VudCkKICAgICBTZXRQYXN0ZWJvYXJkQnVmZmVyRm9y VHlwZShTdHJpbmcgcGFzdGVib2FyZE5hbWUsIFN0cmluZyBwYXN0ZWJvYXJkVHlwZSwgV2ViS2l0 OjpTaGFyZWRNZW1vcnk6OkhhbmRsZSBoYW5kbGUsIHVpbnQ2NF90IHNpemUpIC0+ICh1aW50NjRf dCBjaGFuZ2VDb3VudCkKICNlbmRpZgorCisjaWYgUExBVEZPUk0oR1RLKQorICAgIFNldFNlbGVj dGlvbihTdHJpbmcgcGFzdGVib2FyZE5hbWUsIHN0cnVjdCBXZWJLaXQ6OlBhc3RlYm9hcmRDb250 ZW50R3RrIHBhc3RlYm9hcmRDb250ZW50KQorICAgIEdldFNlbGVjdGlvbihTdHJpbmcgcGFzdGVi b2FyZE5hbWUpIC0+IChzdHJ1Y3QgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudEd0ayBwYXN0ZWJv YXJkQ29udGVudCkKKyNlbmRpZgogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLmYzMTM0ZTMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKQEAgLTAsMCArMSw0OSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRP UlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1 ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldlYlBhc3RlYm9hcmRQcm94eS5oIgorCisjaW5jbHVk ZSA8U2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudEd0ay5oPgorI2luY2x1ZGUgPFdlYkNvcmUv UGxhdGZvcm1QYXN0ZWJvYXJkLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRl IDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+ CisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgV2ViS2l0IHsKKwordm9p ZCBXZWJQYXN0ZWJvYXJkUHJveHk6OnNldFNlbGVjdGlvbihjb25zdCBTdHJpbmcmIHBhc3RlYm9h cmROYW1lLCBjb25zdCBXZWJLaXQ6OlBhc3RlYm9hcmRDb250ZW50R3RrJiBwYXN0ZWJvYXJkQ29u dGVudCkKK3sKKyAgICBQbGF0Zm9ybVBhc3RlYm9hcmQocGFzdGVib2FyZE5hbWUpLnNldFNlbGVj dGlvbihwYXN0ZWJvYXJkQ29udGVudC5kYXRhT2JqZWN0LmdldCgpKTsKK30KKwordm9pZCBXZWJQ YXN0ZWJvYXJkUHJveHk6OmdldFNlbGVjdGlvbihjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1l LCBXZWJLaXQ6OlBhc3RlYm9hcmRDb250ZW50R3RrJiBwYXN0ZWJvYXJkQ29udGVudCkKK3sKKyAg ICBwYXN0ZWJvYXJkQ29udGVudCA9IFdlYktpdDo6UGFzdGVib2FyZENvbnRlbnRHdGsoUGxhdGZv cm1QYXN0ZWJvYXJkKHBhc3RlYm9hcmROYW1lKS5nZXRTZWxlY3Rpb24oKSk7Cit9CisKK30gLy8g bmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwIGIvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwCmluZGV4 IDAxOWMxMzMuLjY0N2U4ZTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3Mv V2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAK QEAgLTY5LDYgKzY5LDEwIEBACiAjaW5jbHVkZSAiU3RyaW5nVXRpbGl0aWVzLmgiCiAjZW5kaWYK IAorI2lmIFBMQVRGT1JNKEdUSykKKyNpbmNsdWRlICJQYXN0ZWJvYXJkQ29udGVudEd0ay5oIgor I2VuZGlmCisKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCiBuYW1lc3BhY2UgV2ViS2l0IHsK QEAgLTMzOSw0ICszNDMsMjIgQEAgbG9uZyBXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OmNoYW5nZUNv dW50KCkKIAogI2VuZGlmIC8vIFBMQVRGT1JNKENPQ09BKQogCisjaWYgUExBVEZPUk0oR1RLKQor Ly8gUGFzdGVib2FyZFN0cmF0ZWd5CisKK3ZvaWQgV2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpzZXRT ZWxlY3Rpb24oY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgV2ViQ29yZTo6RGF0YU9iamVj dEd0ayogZGF0YU9iamVjdCkKK3sKKyAgICBQYXN0ZWJvYXJkQ29udGVudEd0ayBwYXN0ZWJvYXJk Q29udGVudCA9IFBhc3RlYm9hcmRDb250ZW50R3RrKGRhdGFPYmplY3QpOworICAgIFdlYlByb2Nl c3M6OnNpbmdsZXRvbigpLnBhcmVudFByb2Nlc3NDb25uZWN0aW9uKCktPnNlbmQoTWVzc2FnZXM6 OldlYlBhc3RlYm9hcmRQcm94eTo6U2V0U2VsZWN0aW9uKHBhc3RlYm9hcmROYW1lLCBwYXN0ZWJv YXJkQ29udGVudCksIDApOworfQorCitSZWZQdHI8V2ViQ29yZTo6RGF0YU9iamVjdEd0az4gV2Vi UGxhdGZvcm1TdHJhdGVnaWVzOjpnZXRTZWxlY3Rpb24oY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJk TmFtZSkKK3sKKyAgICBQYXN0ZWJvYXJkQ29udGVudEd0ayBwYXN0ZWJvYXJkQ29udGVudDsKKyAg ICBXZWJQcm9jZXNzOjpzaW5nbGV0b24oKS5wYXJlbnRQcm9jZXNzQ29ubmVjdGlvbigpLT5zZW5k U3luYyhNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5OjpHZXRTZWxlY3Rpb24ocGFzdGVib2Fy ZE5hbWUpLCBNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5OjpHZXRTZWxlY3Rpb246OlJlcGx5 KHBhc3RlYm9hcmRDb250ZW50KSwgMCk7CisgICAgcmV0dXJuIFdURk1vdmUocGFzdGVib2FyZENv bnRlbnQuZGF0YU9iamVjdCk7Cit9CisKKyNlbmRpZiAvLyBQTEFURk9STShHVEspCisKIH0gLy8g bmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9X ZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaCBiL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmgKaW5kZXggNzk4 ZWQyYy4uNTM0MTMzZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJD b3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9X ZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCkBAIC04Niw3 ICs4NiwxMCBAQCBwcml2YXRlOgogICAgIGxvbmcgc2V0UGF0aG5hbWVzRm9yVHlwZShjb25zdCBW ZWN0b3I8U3RyaW5nPiYsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0cmlu ZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJyaWRlOwogICAgIGxvbmcgc2V0U3RyaW5nRm9yVHlwZShj b25zdCBTdHJpbmcmLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJpbmcm IHBhc3RlYm9hcmROYW1lKSBvdmVycmlkZTsKICNlbmRpZgotCisjaWYgUExBVEZPUk0oR1RLKQor ICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUsIFdlYkNv cmU6OkRhdGFPYmplY3RHdGsqKSBvdmVycmlkZTsKKyAgICBSZWZQdHI8V2ViQ29yZTo6RGF0YU9i amVjdEd0az4gZ2V0U2VsZWN0aW9uKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJy aWRlOworI2VuZGlmCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQK 288814 2016-09-14 08:11:27 -0700 2016-09-14 09:19:30 -0700 Patch, implement clipboard as a PlatformPasteboard webkit-platform-gtkclipboard.patch text/plain 51162 carlosg ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3MDRiNzUyLi5jMjY1YWUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzMg QEAKKzIwMTYtMDktMTQgIENhcmxvcyBHYXJuYWNobyA8Y2FybG9zZ0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgW0dUS11bV2F5bGFuZF0gSW1wbGVtZW50IGNsaXBib2FyZCBzdXBwb3J0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDY1NzQKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbXBsZW1lbnQgUGxhdGZv cm1QYXN0ZWJvYXJkIGluIHRoZSBHVEsrIHBsYXRmb3JtLCBhbmQgbW92ZSBQYXN0ZWJvYXJkCisg ICAgICAgIHRvIHVzaW5nIFBhc3RlYm9hcmRTdHJhdGVneSBzbyBjbGlwYm9hcmQgbWFuYWdlbWVu dCBpcyBsZWZ0IHRvIHRoZQorICAgICAgICBVSVByb2Nlc3MuCisKKyAgICAgICAgRGF0YU9iamVj dEd0ayBpcyBzdGlsbCB1c2VkIGluIHRoZSBQYXN0ZWJvYXJkIEdUSyBpbXBsZW1lbnRhdGlvbiwg aXQncworICAgICAgICBub3cganVzdCBuZXZlciBiYWNrZWQgYnkgYSBHdGtDbGlwYm9hcmQsIHRo aXMgb2JqZWN0IGlzIGluc3RlYWQKKyAgICAgICAgc2VyaWFsaXplZCB0aHJvdWdoIFBhc3RlYm9h cmRTdHJhdGVneSwgc28gdGhlIFVJUHJvY2VzcyBzaWRlIGNhbiBtaXJyb3IKKyAgICAgICAgdGhl IGNvbnRlbnQgaW4gYSBHdGtDbGlwYm9hcmQtYmFja2VkIERhdGFPYmplY3RHdGssIHdoaWNoIGlz IHRoZW4KKyAgICAgICAgZXhwb3NlZCB0byB0aGUgd2luZG93aW5nIHRocm91Z2ggUGxhdGZvcm1Q YXN0ZWJvYXJkL1Bhc3RlYm9hcmRIZWxwZXIuCisKKyAgICAgICAgV2hlbiByZXF1ZXN0aW5nIGNs aXBib2FyZCBjb250ZW50LCBpdCB3b3JrcyBzaW1pbGFybHksIHRoZSBVSVByb2Nlc3MKKyAgICAg ICAgc2lkZSBmaXJzdCB1cGRhdGVzIGl0cyBEYXRhT2JqZWN0R3RrLCB3aGljaCBpcyB0aGVuIG1p cnJvcmVkIGJ5IHRoZQorICAgICAgICBXZWJQcm9jZXNzIHRocm91Z2ggdGhlIFBhc3RlYm9hcmRT dHJhdGVneSByZXF1ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOiBBZGRlZCBQ bGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwCisgICAgICAgICogZWRpdGluZy9ndGsvRWRpdG9yR3Rr LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6d3JpdGVTZWxlY3Rpb25Ub1Bhc3RlYm9h cmQpOiBFbGltaW5hdGUgdXNhZ2Ugb2YKKyAgICAgICAgUGFzdGVib2FyZFdlYkNvbnRlbnQgY2Fs bGJhY2sgYXJndW1lbnQuIFRoaXMgaXMgZG9uZSBkaWZmZXJlbnRseSBhcworICAgICAgICB3ZSBo YXZlIHRvIHNpZ25hbCBiYWNrIHRoZSBXZWJQcm9jZXNzLgorICAgICAgICAqIHBsYXRmb3JtL1Bh c3RlYm9hcmQuaDogQ2xlYW5lZCB1cCBvZiBkaXJlY3QgR1RLKyBkZXBlbmRlbmN5LgorICAgICAg ICAqIHBsYXRmb3JtL1Bhc3RlYm9hcmRTdHJhdGVneS5oOiBBZGRlZCBwbHVtYmluZyB0b3dhcmRz IHRoZSBwYXN0ZWJvYXJkCisgICAgICAgIHByb3h5LgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtUGFzdGVib2FyZC5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9EYXRhT2JqZWN0R3RrLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFPYmplY3RHdGs6OmNsZWFyQWxsRXhjZXB0RmlsZW5h bWVzKTogQ2xlYXIgdGhlICJzbWFydAorICAgICAgICBwYXN0ZSIgZmxhZyBpZiBzZXQsIG5vdyB0 aGF0IHRoaXMgaXMgRGF0YU9iamVjdEd0ayBkYXRhLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9E YXRhT2JqZWN0R3RrLmg6CisgICAgICAgIChXZWJDb3JlOjpEYXRhT2JqZWN0R3RrOjpoYXNTbWFy dFBhc3RlKToKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFPYmplY3RHdGs6OnNldEhhc1NtYXJ0UGFz dGUpOiBBZGRlZCBmdW5jdGlvbnMsIGluIG9yZGVyCisgICAgICAgIHRvIGZsYWcgd2hldGhlciBh IERhdGFPYmplY3RHdGsgaGFzIHRoZSAic21hcnQgcGFzdGUiIGZlYXR1cmUgZW5hYmxlZAorICAg ICAgICBvciBub3QuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRHdGsuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6Y3JlYXRlRm9yQ29weUFuZFBhc3RlKToKKyAg ICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OmNyZWF0ZUZvckdsb2JhbFNlbGVjdGlvbik6Cisg ICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpQYXN0ZWJvYXJkKToKKyAgICAgICAgKFdlYkNv cmU6OlBhc3RlYm9hcmQ6OndyaXRlVG9DbGlwYm9hcmQpOgorICAgICAgICAoV2ViQ29yZTo6UGFz dGVib2FyZDo6cmVhZEZyb21DbGlwYm9hcmQpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2Fy ZDo6d3JpdGVQbGFpblRleHQpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6d3JpdGUp OgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6d3JpdGVQYXN0ZWJvYXJkKToKKyAgICAg ICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OmNsZWFyKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OmNhblNtYXJ0UmVwbGFjZSk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpy ZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6Omhhc0RhdGEpOgorICAgICAgICAo V2ViQ29yZTo6UGFzdGVib2FyZDo6dHlwZXMpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2Fy ZDo6cmVhZFN0cmluZyk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpyZWFkRmlsZW5h bWVzKTogTWFkZSB0byB1c2UgdGhlCisgICAgICAgIFBhc3RlYm9hcmRTdHJhdGVneSBpbnN0ZWFk IG9mIFBhc3RlYm9hcmRIZWxwZXIvR1RLKyBBUEkuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1Bh c3RlYm9hcmRIZWxwZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZEhlbHBlcjo6 flBhc3RlYm9hcmRIZWxwZXIpOgorICAgICAgICAoV2ViQ29yZTo6Q2xpcGJvYXJkU2V0RGF0YTo6 Q2xpcGJvYXJkU2V0RGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpjbGVhckNsaXBib2FyZENvbnRl bnRzQ2FsbGJhY2spOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZEhlbHBlcjo6d3JpdGVD bGlwYm9hcmRDb250ZW50cyk6IFJlbW92ZSB0aGUgR0Nsb3N1cmUKKyAgICAgICAgdG8gbm90aWZ5 IHdoZXRoZXIgdGhlIGdsb2JhbCBzZWxlY3Rpb24gaGFzIGJlZW4gcmVwbGFjZWQuIFVzZSBzdGQ6 ZnVuY3Rpb24KKyAgICAgICAgaW5zdGVhZC4gUmVtb3ZlIFNtYXJ0UGFzdGVJbmNsdXNpb24gYXJn dW1lbnQsIG5vdyBmaWd1cmVkIG91dCB0aHJvdWdoCisgICAgICAgIERhdGFPYmplY3RHdGsgaGFz U21hcnRQYXN0ZSgpIG1lbWJlci4KKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhl bHBlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3Bw OiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBsYXRmb3JtUGFzdGVib2FyZDo6UGxhdGZvcm1Q YXN0ZWJvYXJkKToKKyAgICAgICAgKFdlYkNvcmU6OlBsYXRmb3JtUGFzdGVib2FyZDo6d3JpdGVU b0NsaXBib2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6OnJlYWRG cm9tQ2xpcGJvYXJkKTogSW1wbGVtZW50ZWQKKyAgICAgICAgUGxhdGZvcm1QYXN0ZWJvYXJkIHVz aW5nIFBhc3RlYm9hcmRIZWxwZXIvR1RLKyBBUEkuCisKIDIwMTYtMDktMDQgIEFudHRpIEtvaXZp c3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmVyc2Ugb3duZXJzaGlwIHJlbGF0 aW9uIG9mIFN0eWxlQ2FjaGVkSW1hZ2UgYW5kIENTU0ltYWdlVmFsdWUKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1H VEsuY21ha2UKaW5kZXggZjIxZmMwNC4uNmMxMzk1YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvUGxhdGZvcm1HVEsuY21h a2UKQEAgLTIyMSw2ICsyMjEsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlUGxhdGZvcm1HVEtfU09V UkNFUwogICAgIHBsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmNwcAogICAgIHBsYXRmb3Jt L2d0ay9QbGF0Zm9ybUtleWJvYXJkRXZlbnRHdGsuY3BwCiAgICAgcGxhdGZvcm0vZ3RrL1BsYXRm b3JtTW91c2VFdmVudEd0ay5jcHAKKyAgICBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJk R3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9QbGF0Zm9ybVNjcmVlbkd0ay5jcHAKICAgICBwbGF0 Zm9ybS9ndGsvUGxhdGZvcm1XaGVlbEV2ZW50R3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9SZW5k ZXJUaGVtZUdhZGdldC5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvZ3Rr L0VkaXRvckd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2d0ay9FZGl0b3JHdGsuY3Bw CmluZGV4IGE1YTUwYzYuLjRlYTA4NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvZ3RrL0VkaXRvckd0ay5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9ndGsvRWRp dG9yR3RrLmNwcApAQCAtMTI1LDcgKzEyNSw2IEBAIHZvaWQgRWRpdG9yOjp3cml0ZVNlbGVjdGlv blRvUGFzdGVib2FyZChQYXN0ZWJvYXJkJiBwYXN0ZWJvYXJkKQogICAgIHBhc3RlYm9hcmRDb250 ZW50LmNhblNtYXJ0Q29weU9yRGVsZXRlID0gY2FuU21hcnRDb3B5T3JEZWxldGUoKTsKICAgICBw YXN0ZWJvYXJkQ29udGVudC50ZXh0ID0gc2VsZWN0ZWRUZXh0Rm9yRGF0YVRyYW5zZmVyKCk7CiAg ICAgcGFzdGVib2FyZENvbnRlbnQubWFya3VwID0gY3JlYXRlTWFya3VwKCpzZWxlY3RlZFJhbmdl KCksIG51bGxwdHIsIEFubm90YXRlRm9ySW50ZXJjaGFuZ2UsIGZhbHNlLCBSZXNvbHZlTm9uTG9j YWxVUkxzKTsKLSAgICBwYXN0ZWJvYXJkQ29udGVudC5jYWxsYmFjayA9IG51bGxwdHI7CiAgICAg cGFzdGVib2FyZC53cml0ZShwYXN0ZWJvYXJkQ29udGVudCk7CiB9CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL1Bhc3RlYm9hcmQuaAppbmRleCBjYmZiYzNkLi41OWI0OThmIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vUGFzdGVib2FyZC5oCkBAIC0zMiwxMSArMzIsNiBAQAogI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAotI2lmIFBMQVRGT1JNKEdU SykKLXR5cGVkZWYgc3RydWN0IF9HdGtDbGlwYm9hcmQgR3RrQ2xpcGJvYXJkOwotI2luY2x1ZGUg PHd0Zi9nbGliL0dSZWZQdHIuaD4KLSNlbmRpZgotCiAjaWYgUExBVEZPUk0oSU9TKQogT0JKQ19D TEFTUyBOU0FycmF5OwogT0JKQ19DTEFTUyBOU1N0cmluZzsKQEAgLTgzLDcgKzc4LDYgQEAgc3Ry dWN0IFBhc3RlYm9hcmRXZWJDb250ZW50IHsKICAgICBib29sIGNhblNtYXJ0Q29weU9yRGVsZXRl OwogICAgIFN0cmluZyB0ZXh0OwogICAgIFN0cmluZyBtYXJrdXA7Ci0gICAgR1JlZlB0cjxHQ2xv c3VyZT4gY2FsbGJhY2s7CiAjZW5kaWYKIH07CiAKQEAgLTE0Myw4ICsxMzcsOCBAQCBwdWJsaWM6 CiAgICAgflBhc3RlYm9hcmQoKTsKIAogI2lmIFBMQVRGT1JNKEdUSykKKyAgICBleHBsaWNpdCBQ YXN0ZWJvYXJkKGNvbnN0IFN0cmluZyYgbmFtZSk7CiAgICAgZXhwbGljaXQgUGFzdGVib2FyZChS ZWZQdHI8RGF0YU9iamVjdEd0az4mJik7Ci0gICAgZXhwbGljaXQgUGFzdGVib2FyZChHdGtDbGlw Ym9hcmQqKTsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oV0lOKQpAQCAtMjI2LDggKzIyMCwxMSBA QCBwcml2YXRlOgogI2VuZGlmCiAKICNpZiBQTEFURk9STShHVEspCisgICAgZW51bSBjbGFzcyBT aG91bGRJbmNsdWRlU21hcnRQYXN0ZSB7IE5vLCBZZXMgfTsKKyAgICB2b2lkIHdyaXRlVG9DbGlw Ym9hcmQoU2hvdWxkSW5jbHVkZVNtYXJ0UGFzdGUgPSBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6 Tm8pOworICAgIHZvaWQgcmVhZEZyb21DbGlwYm9hcmQoKTsKICAgICBSZWZQdHI8RGF0YU9iamVj dEd0az4gbV9kYXRhT2JqZWN0OwotICAgIEd0a0NsaXBib2FyZCogbV9ndGtDbGlwYm9hcmQ7Cisg ICAgU3RyaW5nIG1fbmFtZTsKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oSU9TKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZFN0cmF0ZWd5LmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkU3RyYXRlZ3kuaAppbmRleCA2MzAwODVlLi44MTcx NmY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkU3RyYXRl Z3kuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkU3RyYXRlZ3kuaApA QCAtMzgsNiArMzgsMTAgQEAgY2xhc3MgVVJMOwogc3RydWN0IFBhc3RlYm9hcmRJbWFnZTsKIHN0 cnVjdCBQYXN0ZWJvYXJkV2ViQ29udGVudDsKIAorI2lmIFBMQVRGT1JNKEdUSykKK2NsYXNzIERh dGFPYmplY3RHdGs7CisjZW5kaWYKKwogY2xhc3MgUGFzdGVib2FyZFN0cmF0ZWd5IHsKIHB1Ymxp YzoKICNpZiBQTEFURk9STShJT1MpCkBAIC02OCw2ICs3MiwxMCBAQCBwdWJsaWM6CiAgICAgdmly dHVhbCBsb25nIHNldFBhdGhuYW1lc0ZvclR5cGUoY29uc3QgVmVjdG9yPFN0cmluZz4mLCBjb25z dCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lKSA9 IDA7CiAgICAgdmlydHVhbCBsb25nIHNldFN0cmluZ0ZvclR5cGUoY29uc3QgU3RyaW5nJiwgY29u c3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkg PSAwOwogI2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHZpcnR1YWwgdm9pZCB3cml0ZVRv Q2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUsIGNvbnN0IFJlZlB0cjxEYXRh T2JqZWN0R3RrPiYpID0gMDsKKyAgICB2aXJ0dWFsIFJlZlB0cjxEYXRhT2JqZWN0R3RrPiByZWFk RnJvbUNsaXBib2FyZChjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lKSA9IDA7CisjZW5kaWYg Ly8gUExBVEZPUk0oR1RLKQogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgflBhc3RlYm9hcmRTdHJh dGVneSgpCiAgICAgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZv cm1QYXN0ZWJvYXJkLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QbGF0Zm9ybVBhc3RlYm9h cmQuaAppbmRleCAwYmI2ZTJkLi42OTViYzBlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9QbGF0Zm9ybVBhc3RlYm9hcmQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9QbGF0Zm9ybVBhc3RlYm9hcmQuaApAQCAtNDcsNiArNDcsMTAgQEAgY2xhc3MgVVJMOwogc3Ry dWN0IFBhc3RlYm9hcmRJbWFnZTsKIHN0cnVjdCBQYXN0ZWJvYXJkV2ViQ29udGVudDsKIAorI2lm IFBMQVRGT1JNKEdUSykKK2NsYXNzIERhdGFPYmplY3RHdGs7CisjZW5kaWYKKwogY2xhc3MgUGxh dGZvcm1QYXN0ZWJvYXJkIHsKIHB1YmxpYzoKICAgICAvLyBGSVhNRTogcHJvYmFibHkgd2UgZG9u J3QgbmVlZCBhIGNvbnN0cnVjdG9yIHRoYXQgdGFrZXMgYSBwYXN0ZWJvYXJkIG5hbWUgZm9yIGlP Uy4KQEAgLTgxLDYgKzg1LDExIEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCBVUkwgcmVh ZFVSTChpbnQgaW5kZXgsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUpOwogICAgIFdFQkNP UkVfRVhQT1JUIGludCBjb3VudCgpOwogCisjaWYgUExBVEZPUk0oR1RLKQorICAgIFdFQkNPUkVf RVhQT1JUIHZvaWQgd3JpdGVUb0NsaXBib2FyZChjb25zdCBSZWZQdHI8RGF0YU9iamVjdEd0az4m LCBzdGQ6OmZ1bmN0aW9uPHZvaWQoKT4mJiBwcmltYXJ5U2VsZWN0aW9uQ2xlYXJlZCk7CisgICAg V0VCQ09SRV9FWFBPUlQgUmVmUHRyPERhdGFPYmplY3RHdGs+IHJlYWRGcm9tQ2xpcGJvYXJkKCk7 CisjZW5kaWYKKwogcHJpdmF0ZToKICNpZiBQTEFURk9STShNQUMpCiAgICAgUmV0YWluUHRyPE5T UGFzdGVib2FyZD4gbV9wYXN0ZWJvYXJkOwpAQCAtODgsNiArOTcsOSBAQCBwcml2YXRlOgogI2lm IFBMQVRGT1JNKElPUykKICAgICBSZXRhaW5QdHI8VUlQYXN0ZWJvYXJkPiBtX3Bhc3RlYm9hcmQ7 CiAjZW5kaWYKKyNpZiBQTEFURk9STShHVEspCisgICAgR3RrQ2xpcGJvYXJkKiBtX2NsaXBib2Fy ZDsKKyNlbmRpZgogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0RhdGFPYmplY3RHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0RhdGFP YmplY3RHdGsuY3BwCmluZGV4IDZkYjBiZGUuLjdhZjI0NTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2d0ay9EYXRhT2JqZWN0R3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5jcHAKQEAgLTEzOSw2ICsxMzksNyBAQCB2b2lk IERhdGFPYmplY3RHdGs6OmNsZWFyQWxsRXhjZXB0RmlsZW5hbWVzKCkKICAgICBtX3VybCA9IFVS TCgpOwogICAgIG1faW1hZ2UgPSBudWxscHRyOwogICAgIG1fdW5rbm93blR5cGVEYXRhLmNsZWFy KCk7CisgICAgbV9oYXNTbWFydFBhc3RlID0gZmFsc2U7CiB9CiAKIHZvaWQgRGF0YU9iamVjdEd0 azo6Y2xlYXJBbGwoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL0Rh dGFPYmplY3RHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9EYXRhT2JqZWN0R3Rr LmgKaW5kZXggNDhhMjAzYy4uYjU2YWFmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvRGF0YU9iamVjdEd0ay5oCkBAIC00Nyw2ICs0Nyw3IEBAIHB1YmxpYzoKICAgICBib29sIGhh c1VSTCgpIGNvbnN0IHsgcmV0dXJuICFtX3VybC5pc0VtcHR5KCkgJiYgbV91cmwuaXNWYWxpZCgp OyB9CiAgICAgYm9vbCBoYXNGaWxlbmFtZXMoKSBjb25zdCB7IHJldHVybiAhbV9maWxlbmFtZXMu aXNFbXB0eSgpOyB9CiAgICAgYm9vbCBoYXNJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIG1faW1hZ2U7 IH0KKyAgICBib29sIGhhc1NtYXJ0UGFzdGUoKSBjb25zdCB7IHJldHVybiBtX2hhc1NtYXJ0UGFz dGU7IH0KICAgICB2b2lkIGNsZWFyVVJJTGlzdCgpIHsgbV91cmlMaXN0ID0gZW1wdHlTdHJpbmco KTsgfQogICAgIHZvaWQgY2xlYXJVUkwoKSB7IG1fdXJsID0gVVJMKCk7IH0KICAgICB2b2lkIGNs ZWFySW1hZ2UoKSB7IG1faW1hZ2UgPSBudWxscHRyOyB9CkBAIC01OSw2ICs2MCw3IEBAIHB1Ymxp YzoKICAgICB2b2lkIHNldE1hcmt1cChjb25zdCBTdHJpbmcmKTsKICAgICB2b2lkIHNldFVua25v d25UeXBlRGF0YShjb25zdCBTdHJpbmcmIHR5cGUsIGNvbnN0IFN0cmluZyYgZGF0YSkgeyBtX3Vu a25vd25UeXBlRGF0YS5zZXQodHlwZSwgZGF0YSk7IH0KICAgICB2b2lkIHNldFVSSUxpc3QoY29u c3QgU3RyaW5nJik7CisgICAgdm9pZCBzZXRIYXNTbWFydFBhc3RlKGJvb2wgaGFzU21hcnRQYXN0 ZSkgeyBtX2hhc1NtYXJ0UGFzdGUgPSBoYXNTbWFydFBhc3RlOyB9CiAgICAgU3RyaW5nIHVybExh YmVsKCkgY29uc3Q7CiAKICAgICB2b2lkIGNsZWFyQWxsRXhjZXB0RmlsZW5hbWVzKCk7CkBAIC03 NCw2ICs3Niw3IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPFN0cmluZz4gbV9maWxlbmFtZXM7CiAg ICAgR1JlZlB0cjxHZGtQaXhidWY+IG1faW1hZ2U7CiAgICAgSGFzaE1hcDxTdHJpbmcsIFN0cmlu Zz4gbV91bmtub3duVHlwZURhdGE7CisgICAgYm9vbCBtX2hhc1NtYXJ0UGFzdGU7CiB9OwogCiB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5jcHAKaW5kZXgg ZDkxMGE5Mi4uZDVhNzQzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Rr L1Bhc3RlYm9hcmRHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QYXN0 ZWJvYXJkR3RrLmNwcApAQCAtMjMsOSArMjMsMTAgQEAKICNpbmNsdWRlICJEYXRhT2JqZWN0R3Rr LmgiCiAjaW5jbHVkZSAiRHJhZ0RhdGEuaCIKICNpbmNsdWRlICJJbWFnZS5oIgorI2luY2x1ZGUg IlBhc3RlYm9hcmRTdHJhdGVneS5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyYXRlZ2llcy5oIgog I2luY2x1ZGUgIlVSTC5oIgotI2luY2x1ZGUgIlBhc3RlYm9hcmRIZWxwZXIuaCIKLSNpbmNsdWRl IDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJveWVkLmg+CiAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIApAQCAtNDAsMTIgKzQxLDEyIEBAIGVudW0gQ2xpcGJvYXJkRGF0YVR5cGUg ewogCiBzdGQ6OnVuaXF1ZV9wdHI8UGFzdGVib2FyZD4gUGFzdGVib2FyZDo6Y3JlYXRlRm9yQ29w eUFuZFBhc3RlKCkKIHsKLSAgICByZXR1cm4gc3RkOjptYWtlX3VuaXF1ZTxQYXN0ZWJvYXJkPihn dGtfY2xpcGJvYXJkX2dldChHREtfU0VMRUNUSU9OX0NMSVBCT0FSRCkpOworICAgIHJldHVybiBz dGQ6Om1ha2VfdW5pcXVlPFBhc3RlYm9hcmQ+KCJDTElQQk9BUkQiKTsKIH0KIAogc3RkOjp1bmlx dWVfcHRyPFBhc3RlYm9hcmQ+IFBhc3RlYm9hcmQ6OmNyZWF0ZUZvckdsb2JhbFNlbGVjdGlvbigp CiB7Ci0gICAgcmV0dXJuIHN0ZDo6bWFrZV91bmlxdWU8UGFzdGVib2FyZD4oZ3RrX2NsaXBib2Fy ZF9nZXQoR0RLX1NFTEVDVElPTl9QUklNQVJZKSk7CisgICAgcmV0dXJuIHN0ZDo6bWFrZV91bmlx dWU8UGFzdGVib2FyZD4oIlBSSU1BUlkiKTsKIH0KIAogc3RkOjp1bmlxdWVfcHRyPFBhc3RlYm9h cmQ+IFBhc3RlYm9hcmQ6OmNyZWF0ZVByaXZhdGUoKQpAQCAtNzYsMTcgKzc3LDE0IEBAIFBhc3Rl Ym9hcmRJbWFnZTo6flBhc3RlYm9hcmRJbWFnZSgpCiAKIFBhc3RlYm9hcmQ6OlBhc3RlYm9hcmQo UmVmUHRyPERhdGFPYmplY3RHdGs+JiYgZGF0YU9iamVjdCkKICAgICA6IG1fZGF0YU9iamVjdChX VEZNb3ZlKGRhdGFPYmplY3QpKQotICAgICwgbV9ndGtDbGlwYm9hcmQobnVsbHB0cikKIHsKICAg ICBBU1NFUlQobV9kYXRhT2JqZWN0KTsKIH0KIAotUGFzdGVib2FyZDo6UGFzdGVib2FyZChHdGtD bGlwYm9hcmQqIGd0a0NsaXBib2FyZCkKK1Bhc3RlYm9hcmQ6OlBhc3RlYm9hcmQoY29uc3QgU3Ry aW5nJiBuYW1lKQogICAgIDogbV9kYXRhT2JqZWN0KERhdGFPYmplY3RHdGs6OmNyZWF0ZSgpKQot ICAgICwgbV9ndGtDbGlwYm9hcmQoZ3RrQ2xpcGJvYXJkKQorICAgICwgbV9uYW1lKG5hbWUpCiB7 Ci0gICAgQVNTRVJUKG1fZGF0YU9iamVjdCk7Ci0gICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xl dG9uKCkucmVnaXN0ZXJDbGlwYm9hcmQoZ3RrQ2xpcGJvYXJkKTsKIH0KIAogUGFzdGVib2FyZDo6 flBhc3RlYm9hcmQoKQpAQCAtMTIxLDYgKzExOSwyMSBAQCBzdGF0aWMgQ2xpcGJvYXJkRGF0YVR5 cGUgZGF0YU9iamVjdFR5cGVGcm9tSFRNTENsaXBib2FyZFR5cGUoY29uc3QgU3RyaW5nJiByYXdU eQogICAgIHJldHVybiBDbGlwYm9hcmREYXRhVHlwZVVua25vd247CiB9CiAKK3ZvaWQgUGFzdGVi b2FyZDo6d3JpdGVUb0NsaXBib2FyZChTaG91bGRJbmNsdWRlU21hcnRQYXN0ZSBzaG91bGRJbmNs dWRlU21hcnRQYXN0ZSkKK3sKKyAgICBpZiAobV9uYW1lLmlzTnVsbCgpKQorICAgICAgICByZXR1 cm47CisgICAgbV9kYXRhT2JqZWN0LT5zZXRIYXNTbWFydFBhc3RlKHNob3VsZEluY2x1ZGVTbWFy dFBhc3RlID09IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlOjpZZXMpOworICAgIHBsYXRmb3JtU3Ry YXRlZ2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKS0+d3JpdGVUb0NsaXBib2FyZChtX25hbWUs IG1fZGF0YU9iamVjdCk7Cit9CisKK3ZvaWQgUGFzdGVib2FyZDo6cmVhZEZyb21DbGlwYm9hcmQo KQoreworICAgIGlmIChtX25hbWUuaXNOdWxsKCkpCisgICAgICAgIHJldHVybjsKKyAgICBtX2Rh dGFPYmplY3QgPSBwbGF0Zm9ybVN0cmF0ZWdpZXMoKS0+cGFzdGVib2FyZFN0cmF0ZWd5KCktPnJl YWRGcm9tQ2xpcGJvYXJkKG1fbmFtZSk7Cit9CisKIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVTdHJp bmcoY29uc3QgU3RyaW5nJiB0eXBlLCBjb25zdCBTdHJpbmcmIGRhdGEpCiB7CiAgICAgc3dpdGNo IChkYXRhT2JqZWN0VHlwZUZyb21IVE1MQ2xpcGJvYXJkVHlwZSh0eXBlKSkgewpAQCAtMTQ3LDgg KzE2MCw3IEBAIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVQbGFpblRleHQoY29uc3QgU3RyaW5nJiB0 ZXh0LCBTbWFydFJlcGxhY2VPcHRpb24gc21hcnRSZXBsCiAgICAgbV9kYXRhT2JqZWN0LT5jbGVh ckFsbCgpOwogICAgIG1fZGF0YU9iamVjdC0+c2V0VGV4dCh0ZXh0KTsKIAotICAgIGlmIChtX2d0 a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVD bGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCwgKHNtYXJ0UmVw bGFjZU9wdGlvbiA9PSBDYW5TbWFydFJlcGxhY2UpID8gUGFzdGVib2FyZEhlbHBlcjo6SW5jbHVk ZVNtYXJ0UGFzdGUgOiBQYXN0ZWJvYXJkSGVscGVyOjpEb05vdEluY2x1ZGVTbWFydFBhc3RlKTsK KyAgICB3cml0ZVRvQ2xpcGJvYXJkKHNtYXJ0UmVwbGFjZU9wdGlvbiA9PSBDYW5TbWFydFJlcGxh Y2UgPyBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6WWVzIDogU2hvdWxkSW5jbHVkZVNtYXJ0UGFz dGU6Ok5vKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkVVJM JiBwYXN0ZWJvYXJkVVJMKQpAQCAtMTU4LDggKzE3MCw3IEBAIHZvaWQgUGFzdGVib2FyZDo6d3Jp dGUoY29uc3QgUGFzdGVib2FyZFVSTCYgcGFzdGVib2FyZFVSTCkKICAgICBtX2RhdGFPYmplY3Qt PmNsZWFyQWxsKCk7CiAgICAgbV9kYXRhT2JqZWN0LT5zZXRVUkwocGFzdGVib2FyZFVSTC51cmws IHBhc3RlYm9hcmRVUkwudGl0bGUpOwogCi0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAg ICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1f Z3RrQ2xpcGJvYXJkLCAqbV9kYXRhT2JqZWN0KTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJkKCk7CiB9 CiAKIHZvaWQgUGFzdGVib2FyZDo6d3JpdGUoY29uc3QgUGFzdGVib2FyZEltYWdlJiBwYXN0ZWJv YXJkSW1hZ2UpCkBAIC0xNzQsOCArMTg1LDcgQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25z dCBQYXN0ZWJvYXJkSW1hZ2UmIHBhc3RlYm9hcmRJbWFnZSkKICAgICBpZiAocGl4YnVmKQogICAg ICAgICBtX2RhdGFPYmplY3QtPnNldEltYWdlKHBpeGJ1Zi5nZXQoKSk7CiAKLSAgICBpZiAobV9n dGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRl Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsICptX2RhdGFPYmplY3QpOworICAgIHdy aXRlVG9DbGlwYm9hcmQoKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0 ZWJvYXJkV2ViQ29udGVudCYgcGFzdGVib2FyZENvbnRlbnQpCkBAIC0xODQsOCArMTk0LDcgQEAg dm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkV2ViQ29udGVudCYgcGFzdGVi b2FyZENvbnRlbnQpCiAgICAgbV9kYXRhT2JqZWN0LT5zZXRUZXh0KHBhc3RlYm9hcmRDb250ZW50 LnRleHQpOwogICAgIG1fZGF0YU9iamVjdC0+c2V0TWFya3VwKHBhc3RlYm9hcmRDb250ZW50Lm1h cmt1cCk7CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxw ZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsICpt X2RhdGFPYmplY3QsIHBhc3RlYm9hcmRDb250ZW50LmNhblNtYXJ0Q29weU9yRGVsZXRlID8gUGFz dGVib2FyZEhlbHBlcjo6SW5jbHVkZVNtYXJ0UGFzdGUgOiBQYXN0ZWJvYXJkSGVscGVyOjpEb05v dEluY2x1ZGVTbWFydFBhc3RlLCBwYXN0ZWJvYXJkQ29udGVudC5jYWxsYmFjay5nZXQoKSk7Cisg ICAgd3JpdGVUb0NsaXBib2FyZCgpOwogfQogCiB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlUGFzdGVi b2FyZChjb25zdCBQYXN0ZWJvYXJkJiBzb3VyY2VQYXN0ZWJvYXJkKQpAQCAtMjA4LDggKzIxNyw3 IEBAIHZvaWQgUGFzdGVib2FyZDo6d3JpdGVQYXN0ZWJvYXJkKGNvbnN0IFBhc3RlYm9hcmQmIHNv dXJjZVBhc3RlYm9hcmQpCiAgICAgICAgICAgICBtX2RhdGFPYmplY3QtPnNldFVua25vd25UeXBl RGF0YShpdC5rZXksIGl0LnZhbHVlKTsKICAgICB9CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQp Ci0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29u dGVudHMobV9ndGtDbGlwYm9hcmQsICptX2RhdGFPYmplY3QpOworICAgIHdyaXRlVG9DbGlwYm9h cmQoKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjpjbGVhcigpCkBAIC0yMTksOSArMjI3LDcgQEAg dm9pZCBQYXN0ZWJvYXJkOjpjbGVhcigpCiAgICAgLy8gYXR0cmlidXRlJ3MgbGlzdCBtaWdodCBz dGlsbCBub3QgYmUgZW1wdHkgYWZ0ZXIgY2FsbGluZyBjbGVhckRhdGEoKSAoaXQgd291bGQKICAg ICAvLyBzdGlsbCBjb250YWluIHRoZSAiRmlsZXMiIHN0cmluZyBpZiBhbnkgZmlsZXMgd2VyZSBp bmNsdWRlZCBpbiB0aGUgZHJhZykuIgogICAgIG1fZGF0YU9iamVjdC0+Y2xlYXJBbGxFeGNlcHRG aWxlbmFtZXMoKTsKLQotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2Fy ZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2Fy ZCwgKm1fZGF0YU9iamVjdCk7CisgICAgd3JpdGVUb0NsaXBib2FyZCgpOwogfQogCiB2b2lkIFBh c3RlYm9hcmQ6OmNsZWFyKGNvbnN0IFN0cmluZyYgdHlwZSkKQEAgLTI0NSwxMyArMjUxLDEzIEBA IHZvaWQgUGFzdGVib2FyZDo6Y2xlYXIoY29uc3QgU3RyaW5nJiB0eXBlKQogICAgICAgICBicmVh azsKICAgICB9CiAKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRI ZWxwZXI6OnNpbmdsZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQs ICptX2RhdGFPYmplY3QpOworICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0KIAogYm9vbCBQYXN0 ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UoKQogewotICAgIHJldHVybiBtX2d0a0NsaXBib2FyZCAm JiBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5jbGlwYm9hcmRDb250ZW50U3VwcG9ydHNT bWFydFJlcGxhY2UobV9ndGtDbGlwYm9hcmQpOworICAgIHJlYWRGcm9tQ2xpcGJvYXJkKCk7Cisg ICAgcmV0dXJuICFtX2RhdGFPYmplY3QtPnVua25vd25UeXBlRGF0YSgiYXBwbGljYXRpb24vdm5k LndlYmtpdGd0ay5zbWFydHBhc3RlIikuaXNFbXB0eSgpOwogfQogCiAjaWYgRU5BQkxFKERSQUdf U1VQUE9SVCkKQEAgLTI2MiwyMyArMjY4LDE5IEBAIHZvaWQgUGFzdGVib2FyZDo6c2V0RHJhZ0lt YWdlKERyYWdJbWFnZVJlZiwgY29uc3QgSW50UG9pbnQmKQogCiB2b2lkIFBhc3RlYm9hcmQ6OnJl YWQoUGFzdGVib2FyZFBsYWluVGV4dCYgdGV4dCkKIHsKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQp Ci0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLmdldENsaXBib2FyZENvbnRl bnRzKG1fZ3RrQ2xpcGJvYXJkLCAqbV9kYXRhT2JqZWN0KTsKKyAgICByZWFkRnJvbUNsaXBib2Fy ZCgpOwogICAgIHRleHQudGV4dCA9IG1fZGF0YU9iamVjdC0+dGV4dCgpOwogfQogCiBib29sIFBh c3RlYm9hcmQ6Omhhc0RhdGEoKQogewotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAg UGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVudHMobV9ndGtD bGlwYm9hcmQsICptX2RhdGFPYmplY3QpOwotCisgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKICAg ICByZXR1cm4gbV9kYXRhT2JqZWN0LT5oYXNUZXh0KCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNNYXJr dXAoKSB8fCBtX2RhdGFPYmplY3QtPmhhc1VSSUxpc3QoKSB8fCBtX2RhdGFPYmplY3QtPmhhc0lt YWdlKCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNVbmtub3duVHlwZURhdGEoKTsKIH0KIAogVmVjdG9y PFN0cmluZz4gUGFzdGVib2FyZDo6dHlwZXMoKQogewotICAgIGlmIChtX2d0a0NsaXBib2FyZCkK LSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZ2V0Q2xpcGJvYXJkQ29udGVu dHMobV9ndGtDbGlwYm9hcmQsICptX2RhdGFPYmplY3QpOworICAgIHJlYWRGcm9tQ2xpcGJvYXJk KCk7CiAKICAgICBWZWN0b3I8U3RyaW5nPiB0eXBlczsKICAgICBpZiAobV9kYXRhT2JqZWN0LT5o YXNUZXh0KCkpIHsKQEAgLTMwNiw4ICszMDgsNyBAQCBWZWN0b3I8U3RyaW5nPiBQYXN0ZWJvYXJk Ojp0eXBlcygpCiAKIFN0cmluZyBQYXN0ZWJvYXJkOjpyZWFkU3RyaW5nKGNvbnN0IFN0cmluZyYg dHlwZSkKIHsKLSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxw ZXI6OnNpbmdsZXRvbigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkLCAqbV9k YXRhT2JqZWN0KTsKKyAgICByZWFkRnJvbUNsaXBib2FyZCgpOwogCiAgICAgc3dpdGNoIChkYXRh T2JqZWN0VHlwZUZyb21IVE1MQ2xpcGJvYXJkVHlwZSh0eXBlKSkgewogICAgIGNhc2UgQ2xpcGJv YXJkRGF0YVR5cGVVUklMaXN0OgpAQCAtMzI5LDkgKzMzMCw3IEBAIFN0cmluZyBQYXN0ZWJvYXJk OjpyZWFkU3RyaW5nKGNvbnN0IFN0cmluZyYgdHlwZSkKIAogVmVjdG9yPFN0cmluZz4gUGFzdGVi b2FyZDo6cmVhZEZpbGVuYW1lcygpCiB7Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAg ICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0 a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCk7Ci0KKyAgICByZWFkRnJvbUNsaXBib2FyZCgpOwog ICAgIHJldHVybiBtX2RhdGFPYmplY3QtPmZpbGVuYW1lcygpOwogfQogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhlbHBlci5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhlbHBlci5jcHAKaW5kZXggNjJkNzA1ZS4u YTI4YzVlYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9h cmRIZWxwZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJk SGVscGVyLmNwcApAQCAtNzYsOCArNzYsNiBAQCBQYXN0ZWJvYXJkSGVscGVyOjpQYXN0ZWJvYXJk SGVscGVyKCkKIAogUGFzdGVib2FyZEhlbHBlcjo6flBhc3RlYm9hcmRIZWxwZXIoKQogewotICAg IGZvciAoYXV0byogY2xpcGJvYXJkIDogbV9ndGtDbGlwYm9hcmRzKQotICAgICAgICBndGtfY2xp cGJvYXJkX3N0b3JlKGNsaXBib2FyZCk7CiB9CiAKIEd0a1RhcmdldExpc3QqIFBhc3RlYm9hcmRI ZWxwZXI6OnRhcmdldExpc3QoKSBjb25zdApAQCAtMjU3LDkgKzI1NSw5IEBAIFZlY3RvcjxHZGtB dG9tPiBQYXN0ZWJvYXJkSGVscGVyOjpkcm9wQXRvbXNGb3JDb250ZXh0KEd0a1dpZGdldCogd2lk Z2V0LCBHZGtEcmFnCiBzdGF0aWMgRGF0YU9iamVjdEd0ayogc2V0dGluZ0NsaXBib2FyZERhdGFP YmplY3QgPSAwOwogCiBzdHJ1Y3QgQ2xpcGJvYXJkU2V0RGF0YSB7Ci0gICAgQ2xpcGJvYXJkU2V0 RGF0YShEYXRhT2JqZWN0R3RrKiBkYXRhT2JqZWN0LCBHQ2xvc3VyZSogY2FsbGJhY2spCisgICAg Q2xpcGJvYXJkU2V0RGF0YShEYXRhT2JqZWN0R3RrKiBkYXRhT2JqZWN0LCBzdGQ6OmZ1bmN0aW9u PHZvaWQoKT4mJiBzZWxlY3Rpb25DbGVhcmVkQ2FsbGJhY2spCiAgICAgICAgIDogZGF0YU9iamVj dChkYXRhT2JqZWN0KQotICAgICAgICAsIGNhbGxiYWNrKGNhbGxiYWNrKQorICAgICAgICAsIHNl bGVjdGlvbkNsZWFyZWRDYWxsYmFjayhXVEZNb3ZlKHNlbGVjdGlvbkNsZWFyZWRDYWxsYmFjaykp CiAgICAgewogICAgIH0KIApAQCAtMjY4LDcgKzI2Niw3IEBAIHN0cnVjdCBDbGlwYm9hcmRTZXRE YXRhIHsKICAgICB9CiAKICAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gZGF0YU9iamVjdDsKLSAg ICBHUmVmUHRyPEdDbG9zdXJlPiBjYWxsYmFjazsKKyAgICBzdGQ6OmZ1bmN0aW9uPHZvaWQoKT4g c2VsZWN0aW9uQ2xlYXJlZENhbGxiYWNrOwogfTsKIAogc3RhdGljIHZvaWQgZ2V0Q2xpcGJvYXJk Q29udGVudHNDYWxsYmFjayhHdGtDbGlwYm9hcmQqLCBHdGtTZWxlY3Rpb25EYXRhICpzZWxlY3Rp b25EYXRhLCBndWludCBpbmZvLCBncG9pbnRlciB1c2VyRGF0YSkKQEAgLTI3Nyw3ICsyNzUsNyBA QCBzdGF0aWMgdm9pZCBnZXRDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrKEd0a0NsaXBib2FyZCos IEd0a1NlbGVjdGlvbkRhdGEgKnNlbGVjdAogICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRv bigpLmZpbGxTZWxlY3Rpb25EYXRhKHNlbGVjdGlvbkRhdGEsIGluZm8sICpkYXRhLT5kYXRhT2Jq ZWN0KTsKIH0KIAotc3RhdGljIHZvaWQgY2xlYXJDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrKEd0 a0NsaXBib2FyZCogY2xpcGJvYXJkLCBncG9pbnRlciB1c2VyRGF0YSkKK3N0YXRpYyB2b2lkIGNs ZWFyQ2xpcGJvYXJkQ29udGVudHNDYWxsYmFjayhHdGtDbGlwYm9hcmQqLCBncG9pbnRlciB1c2Vy RGF0YSkKIHsKICAgICBzdGQ6OnVuaXF1ZV9wdHI8Q2xpcGJvYXJkU2V0RGF0YT4gZGF0YShzdGF0 aWNfY2FzdDxDbGlwYm9hcmRTZXREYXRhKj4odXNlckRhdGEpKTsKIApAQCAtMjg1LDE4ICsyODMs MTMgQEAgc3RhdGljIHZvaWQgY2xlYXJDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrKEd0a0NsaXBi b2FyZCogY2xpcGJvYXJkLCBncG9pbnRlciB1c2UKICAgICBpZiAoZGF0YS0+ZGF0YU9iamVjdC5n ZXQoKSAhPSBzZXR0aW5nQ2xpcGJvYXJkRGF0YU9iamVjdCkKICAgICAgICAgZGF0YS0+ZGF0YU9i amVjdC0+Y2xlYXJBbGwoKTsKIAotICAgIGlmICghZGF0YS0+Y2FsbGJhY2spCi0gICAgICAgIHJl dHVybjsKLQotICAgIEdWYWx1ZSBmaXJzdEFyZ3VtZW50ID0gezAsIHt7MH19fTsKLSAgICBnX3Zh bHVlX2luaXQoJmZpcnN0QXJndW1lbnQsIEdfVFlQRV9QT0lOVEVSKTsKLSAgICBnX3ZhbHVlX3Nl dF9wb2ludGVyKCZmaXJzdEFyZ3VtZW50LCBjbGlwYm9hcmQpOwotICAgIGdfY2xvc3VyZV9pbnZv a2UoZGF0YS0+Y2FsbGJhY2suZ2V0KCksIG51bGxwdHIsIDEsICZmaXJzdEFyZ3VtZW50LCAwKTsK KyAgICBpZiAoZGF0YS0+c2VsZWN0aW9uQ2xlYXJlZENhbGxiYWNrKQorICAgICAgICBkYXRhLT5z ZWxlY3Rpb25DbGVhcmVkQ2FsbGJhY2soKTsKIH0KIAotdm9pZCBQYXN0ZWJvYXJkSGVscGVyOjp3 cml0ZUNsaXBib2FyZENvbnRlbnRzKEd0a0NsaXBib2FyZCogY2xpcGJvYXJkLCBjb25zdCBEYXRh T2JqZWN0R3RrJiBkYXRhT2JqZWN0LCBTbWFydFBhc3RlSW5jbHVzaW9uIGluY2x1ZGVTbWFydFBh c3RlLCBHQ2xvc3VyZSogY2FsbGJhY2spCit2b2lkIFBhc3RlYm9hcmRIZWxwZXI6OndyaXRlQ2xp cGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQsIGNvbnN0IERhdGFPYmplY3RH dGsmIGRhdGFPYmplY3QsIHN0ZDo6ZnVuY3Rpb248dm9pZCgpPiYmIHByaW1hcnlTZWxlY3Rpb25D bGVhcmVkKQogewotICAgIEdSZWZQdHI8R3RrVGFyZ2V0TGlzdD4gbGlzdCA9IHRhcmdldExpc3RG b3JEYXRhT2JqZWN0KGRhdGFPYmplY3QsIGluY2x1ZGVTbWFydFBhc3RlKTsKKyAgICBHUmVmUHRy PEd0a1RhcmdldExpc3Q+IGxpc3QgPSB0YXJnZXRMaXN0Rm9yRGF0YU9iamVjdChkYXRhT2JqZWN0 LCBkYXRhT2JqZWN0Lmhhc1NtYXJ0UGFzdGUoKSA/IEluY2x1ZGVTbWFydFBhc3RlIDogRG9Ob3RJ bmNsdWRlU21hcnRQYXN0ZSk7CiAKICAgICBpbnQgbnVtYmVyT2ZUYXJnZXRzOwogICAgIEd0a1Rh cmdldEVudHJ5KiB0YWJsZSA9IGd0a190YXJnZXRfdGFibGVfbmV3X2Zyb21fbGlzdChsaXN0Lmdl dCgpLCAmbnVtYmVyT2ZUYXJnZXRzKTsKQEAgLTMwNCw3ICsyOTcsNyBAQCB2b2lkIFBhc3RlYm9h cmRIZWxwZXI6OndyaXRlQ2xpcGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQs IGNvbnN0IERhdAogICAgIGlmIChudW1iZXJPZlRhcmdldHMgPiAwICYmIHRhYmxlKSB7CiAgICAg ICAgIHNldHRpbmdDbGlwYm9hcmREYXRhT2JqZWN0ID0gY29uc3RfY2FzdDxEYXRhT2JqZWN0R3Rr Kj4oJmRhdGFPYmplY3QpOwogCi0gICAgICAgIGF1dG8gZGF0YSA9IHN0ZDo6bWFrZV91bmlxdWU8 Q2xpcGJvYXJkU2V0RGF0YT4oc2V0dGluZ0NsaXBib2FyZERhdGFPYmplY3QsIGNhbGxiYWNrKTsK KyAgICAgICAgYXV0byBkYXRhID0gc3RkOjptYWtlX3VuaXF1ZTxDbGlwYm9hcmRTZXREYXRhPihz ZXR0aW5nQ2xpcGJvYXJkRGF0YU9iamVjdCwgV1RGTW92ZShwcmltYXJ5U2VsZWN0aW9uQ2xlYXJl ZCkpOwogICAgICAgICBpZiAoZ3RrX2NsaXBib2FyZF9zZXRfd2l0aF9kYXRhKGNsaXBib2FyZCwg dGFibGUsIG51bWJlck9mVGFyZ2V0cywgZ2V0Q2xpcGJvYXJkQ29udGVudHNDYWxsYmFjaywgY2xl YXJDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrLCBkYXRhLmdldCgpKSkgewogICAgICAgICAgICAg Z3RrX2NsaXBib2FyZF9zZXRfY2FuX3N0b3JlKGNsaXBib2FyZCwgbnVsbHB0ciwgMCk7CiAgICAg ICAgICAgICAvLyBXaGVuIGd0a19jbGlwYm9hcmRfc2V0X3dpdGhfZGF0YSBmYWlscyB0aGUgY2Fs bGJhY2tzIGFyZSBpZ25vcmVkLCBzbyB3ZSBuZWVkIHRvIGxlYWsgdGhlIGRhdGEgd2Ugd2VyZSBw YXNzaW5nIHRvIGNsZWFyQ2xpcGJvYXJkQ29udGVudHNDYWxsYmFjay4KQEAgLTMyNCwxMSArMzE3 LDUgQEAgYm9vbCBQYXN0ZWJvYXJkSGVscGVyOjpjbGlwYm9hcmRDb250ZW50U3VwcG9ydHNTbWFy dFJlcGxhY2UoR3RrQ2xpcGJvYXJkKiBjbGlwYm8KICAgICByZXR1cm4gZ3RrX2NsaXBib2FyZF93 YWl0X2lzX3RhcmdldF9hdmFpbGFibGUoY2xpcGJvYXJkLCBzbWFydFBhc3RlQXRvbSk7CiB9CiAK LXZvaWQgUGFzdGVib2FyZEhlbHBlcjo6cmVnaXN0ZXJDbGlwYm9hcmQoR3RrQ2xpcGJvYXJkKiBj bGlwYm9hcmQpCi17Ci0gICAgQVNTRVJUKGNsaXBib2FyZCk7Ci0gICAgbV9ndGtDbGlwYm9hcmRz LmFkZChjbGlwYm9hcmQpOwotfQotCiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n dGsvUGFzdGVib2FyZEhlbHBlci5oCmluZGV4IGE3ZmE3ZDYuLjE2YjNiYWQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRIZWxwZXIuaApAQCAtMjYsNyArMjYs NiBAQAogI2RlZmluZSBQYXN0ZWJvYXJkSGVscGVyX2gKIAogI2luY2x1ZGUgIkdSZWZQdHJHdGsu aCIKLSNpbmNsdWRlIDx3dGYvSGFzaFNldC5oPgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5o PgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KICNpbmNsdWRlIDx3dGYvZ2xpYi9HUmVmUHRyLmg+ CkBAIC00Nyw3ICs0Niw3IEBAIHB1YmxpYzoKICAgICB2b2lkIGZpbGxTZWxlY3Rpb25EYXRhKEd0 a1NlbGVjdGlvbkRhdGEqLCBndWludCwgY29uc3QgRGF0YU9iamVjdEd0ayYpOwogICAgIHZvaWQg ZmlsbERhdGFPYmplY3RGcm9tRHJvcERhdGEoR3RrU2VsZWN0aW9uRGF0YSosIGd1aW50LCBEYXRh T2JqZWN0R3RrJik7CiAgICAgVmVjdG9yPEdka0F0b20+IGRyb3BBdG9tc0ZvckNvbnRleHQoR3Rr V2lkZ2V0KiwgR2RrRHJhZ0NvbnRleHQqKTsKLSAgICB2b2lkIHdyaXRlQ2xpcGJvYXJkQ29udGVu dHMoR3RrQ2xpcGJvYXJkKiwgY29uc3QgRGF0YU9iamVjdEd0ayYsIFNtYXJ0UGFzdGVJbmNsdXNp b24gPSBEb05vdEluY2x1ZGVTbWFydFBhc3RlLCBHQ2xvc3VyZSogPSAwKTsKKyAgICB2b2lkIHdy aXRlQ2xpcGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiwgY29uc3QgRGF0YU9iamVjdEd0ayYs IHN0ZDo6ZnVuY3Rpb248dm9pZCgpPiYmIHByaW1hcnlTZWxlY3Rpb25DbGVhcmVkID0gbnVsbHB0 cik7CiAgICAgdm9pZCBnZXRDbGlwYm9hcmRDb250ZW50cyhHdGtDbGlwYm9hcmQqLCBEYXRhT2Jq ZWN0R3RrJik7CiAKICAgICBlbnVtIFBhc3RlYm9hcmRUYXJnZXRUeXBlIHsgVGFyZ2V0VHlwZU1h cmt1cCwgVGFyZ2V0VHlwZVRleHQsIFRhcmdldFR5cGVJbWFnZSwgVGFyZ2V0VHlwZVVSSUxpc3Qs IFRhcmdldFR5cGVOZXRzY2FwZVVSTCwgVGFyZ2V0VHlwZVNtYXJ0UGFzdGUsIFRhcmdldFR5cGVV bmtub3duIH07CkBAIC02MCw3ICs1OSw2IEBAIHByaXZhdGU6CiAgICAgflBhc3RlYm9hcmRIZWxw ZXIoKTsKIAogICAgIEdSZWZQdHI8R3RrVGFyZ2V0TGlzdD4gbV90YXJnZXRMaXN0OwotICAgIEhh c2hTZXQ8R3RrQ2xpcGJvYXJkKj4gbV9ndGtDbGlwYm9hcmRzOwogfTsKIAogfQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BsYXRmb3JtUGFzdGVib2FyZEd0ay5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3RrLmNwcApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iN2NiZWFkCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1BsYXRmb3JtUGFzdGVib2FyZEd0ay5j cHAKQEAgLTAsMCArMSw0OSBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTYgUmVkIEhhdCBJ bmMuCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqICBU aGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVz ZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExpY2Vuc2Ug YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdh cmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29y LCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiUGxhdGZvcm1QYXN0ZWJvYXJkLmgiCisKKyNpbmNsdWRlICJDb2xvci5oIgor I2luY2x1ZGUgIkRhdGFPYmplY3RHdGsuaCIKKyNpbmNsdWRlICJQYXN0ZWJvYXJkSGVscGVyLmgi CisjaW5jbHVkZSAiU2hhcmVkQnVmZmVyLmgiCisjaW5jbHVkZSAiVVJMLmgiCisjaW5jbHVkZSA8 Z3RrL2d0ay5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK1BsYXRmb3JtUGFzdGVib2FyZDo6 UGxhdGZvcm1QYXN0ZWJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpCisgICAgOiBt X2NsaXBib2FyZChndGtfY2xpcGJvYXJkX2dldChnZGtfYXRvbV9pbnRlcm4ocGFzdGVib2FyZE5h bWUudXRmOCgpLmRhdGEoKSwgVFJVRSkpKQoreworICAgIEFTU0VSVChtX2NsaXBib2FyZCk7Cit9 CisKK3ZvaWQgUGxhdGZvcm1QYXN0ZWJvYXJkOjp3cml0ZVRvQ2xpcGJvYXJkKGNvbnN0IFJlZlB0 cjxEYXRhT2JqZWN0R3RrPiYgZGF0YU9iamVjdCwgc3RkOjpmdW5jdGlvbjx2b2lkKCk+JiYgcHJp bWFyeVNlbGVjdGlvbkNsZWFyZWQpCit7CisgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9u KCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2NsaXBib2FyZCwgKmRhdGFPYmplY3QsIGd0a19j bGlwYm9hcmRfZ2V0KEdES19TRUxFQ1RJT05fUFJJTUFSWSkgPT0gbV9jbGlwYm9hcmQgPyBXVEZN b3ZlKHByaW1hcnlTZWxlY3Rpb25DbGVhcmVkKSA6IG51bGxwdHIpOworfQorCitSZWZQdHI8RGF0 YU9iamVjdEd0az4gUGxhdGZvcm1QYXN0ZWJvYXJkOjpyZWFkRnJvbUNsaXBib2FyZCgpCit7Cisg ICAgUmVmUHRyPERhdGFPYmplY3RHdGs+IGRhdGFPYmplY3QgPSBEYXRhT2JqZWN0R3RrOjpjcmVh dGUoKTsKKyAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250 ZW50cyhtX2NsaXBib2FyZCwgKmRhdGFPYmplY3QpOworICAgIHJldHVybiBkYXRhT2JqZWN0Owor fQorCit9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cKaW5kZXggNzcwOWZhNi4uNDQ4MzNiMSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDY4IEBACisyMDE2LTA5LTE0ICBDYXJsb3MgR2FybmFjaG8gIDxjYXJsb3NnQGdub21lLm9y Zz4KKworICAgICAgICBbR1RLXVtXYXlsYW5kXSBJbXBsZW1lbnQgY2xpcGJvYXJkIHN1cHBvcnQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NjU3NAor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCB0aGUg bmVjZXNzYXJ5IHBsdW1iaW5nIGZvciB0aGUgR1RLKyBiYWNrZW5kIHRvIHVzZSB0aGUKKyAgICAg ICAgUGxhdGZvcm1QYXN0ZWJvYXJkIGluIFdlYkNvcmUuIEFsbCBzZWxlY3Rpb24gZGF0YSBpcyB0 cmFuc21pdHRlZAorICAgICAgICBhdCBvbmNlIHRocm91Z2ggdGhlIHNlcmlhbGl6YXRpb24gb2Yg UGFzdGVib2FyZENvbnRlbnRHdGsvRGF0YU9iamVjdEd0ay4KKworICAgICAgICAqIFBsYXRmb3Jt R1RLLmNtYWtlOiBBZGQgUGFzdGVib2FyZENvbnRlbnRHdGsuY3BwIGFuZAorICAgICAgICBXZWJQ YXN0ZWJvYXJkUHJveHlHdGsuY3BwCisgICAgICAgICogU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVy c0d0ay5jcHA6CisgICAgICAgIChJUEM6OmVuY29kZSk6CisgICAgICAgIChJUEM6OmRlY29kZSk6 IFJlbmFtZWQgZnJvbSBlbmNvZGVEYXRhT2JqZWN0L2RlY29kZURhdGFPYmplY3QKKyAgICAgICAg YW5kIG1hZGUgcHVibGljLgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVyPERyYWdEYXRhPjo6 ZW5jb2RlKToKKyAgICAgICAgKElQQzo6QXJndW1lbnRDb2RlcjxEcmFnRGF0YT46OmRlY29kZSk6 IFVwZGF0ZSBEYXRhT2JqZWN0R3RrCisgICAgICAgIGVuY29kZS9kZWNvZGUgY2FsbGVycy4KKyAg ICAgICAgKiBTaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmg6IEV4cG9zZSBlbmNvZGUvZGVj b2RlIG1ldGhvZHMgZm9yCisgICAgICAgIERhdGFPYmplY3RHdGsuCisgICAgICAgICogU2hhcmVk L2d0ay9QYXN0ZWJvYXJkQ29udGVudC5jcHA6IEFkZGVkLiBXcmFwcyBhIERhdGFPYmplY3RHdGsK KyAgICAgICAgc28gaXQgY2FuIGJlIHNlcmlhbGl6ZWQgb24gV2ViUHJvY2Vzcy9VSVByb2Nlc3Mg bWVzc2FnaW5nLgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudDo6UGFzdGVib2Fy ZENvbnRlbnQpOgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudDo6ZW5jb2RlKToK KyAgICAgICAgKFdlYktpdDo6UGFzdGVib2FyZENvbnRlbnQ6OmRlY29kZSk6IE1ldGhvZHMgdG8g ZW5jb2RlL2RlY29kZSBhCisgICAgICAgIFBhc3RlYm9hcmRDb250ZW50LgorICAgICAgICAqIFNo YXJlZC9ndGsvUGFzdGVib2FyZENvbnRlbnQuaDogQWRkZWQuCisgICAgICAgICogVUlQcm9jZXNz L1dlYkZyYW1lUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZVByb3h5Ojpjb2xs YXBzZVNlbGVjdGlvbik6IEFkZGVkIHBsdW1iaW5nIHRvIGFsbG93CisgICAgICAgIGNvbGxhcHNp bmcgdGhlIGdsb2JhbCBzZWxlY3Rpb24gZnJvbSB0aGUgVUkgcHJvY2VzcyBzaWRlLgorICAgICAg ICAqIFVJUHJvY2Vzcy9XZWJGcmFtZVByb3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL1dlYlBh c3RlYm9hcmRQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHku bWVzc2FnZXMuaW46IEFkZGVkIHBsdW1iaW5nIGZvciB0aGUKKyAgICAgICAgR1RLKyBwYXN0ZWJv YXJkIHByb3h5IGZ1bmN0aW9ucy4KKyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94 eUd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6ZWRpdG9yU3RhdGVDaGFu Z2VkKToKKyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHA6 IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OndyaXRlVG9DbGlw Ym9hcmQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OnJlYWRGcm9tQ2xp cGJvYXJkKTogSW1wbGVtZW50ZWQgZnVuY3Rpb25zCisgICAgICAgIGhvb2tpbmcgaW50byB0aGUg UGxhdGZvcm1QYXN0ZWJvYXJkLiBQZXItc2VsZWN0aW9uIChpZS4KKyAgICAgICAgcHJpbWFyeS9j bGlwYm9hcmQpIFBsYXRmb3JtUGFzdGVib2FyZHMgYXJlIGtlcHQgYXQgdGhpcyBsZXZlbCwgc28g dGhvc2UKKyAgICAgICAgYXJlIGluZGVwZW5kZW50bHkgc2V0IGFuZCBkZWFsdCB3aXRoLgorICAg ICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OnNldFByaW1hcnlTZWxlY3Rpb25Pd25l cik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhc3RlYm9hcmRQcm94eTo6ZGlkRGVzdHJveUZyYW1l KTogSW1wbGVtZW50ZWQgZnVuY3Rpb25zCisgICAgICAgIHRvIG1hbmFnZSB0aGUgZnJhbWUgY3Vy cmVudGx5IGJlaW5nIGN1cnJlbnRseSBpbnRlcmFjdGVkLCBzbyB3ZSBjYW4KKyAgICAgICAgc2ln bmFsIGJhY2sgd2hlbiB0aGUgZ2xvYmFsIHNlbGVjdGlvbiBoYXMgYmVlbiByZXBsYWNlZC4KKyAg ICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5j cHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6d3JpdGVUb0NsaXBi b2FyZCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6cmVhZEZyb21D bGlwYm9hcmQpOiBBZGRlZCBtZXRob2RzIHRvCisgICAgICAgIHNlbmQgdGhlIFdlYlByb2Nlc3Mt PlVJUHJvY2VzcyBtZXNzYWdlcy4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29yZVN1 cHBvcnQvZ3RrL1dlYkVkaXRvckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkVk aXRvckNsaWVudDo6dXBkYXRlR2xvYmFsU2VsZWN0aW9uKTogUmVtb3ZlIEdDbG9zdXJlIHRvCisg ICAgICAgIGdldCBub3RpZmljYXRpb25zIGFib3V0IGNoYW5nZXMgaW4gZ2xvYmFsIHNlbGVjdGlv biBvd25lcnNoaXAuIFRoaXMKKyAgICAgICAgaXMgZG9uZSB0aHJvdWdoIGEgV2ViUGFnZSBtZXNz YWdlIG5vdywgYXMgdGhlIFVJIHByb2Nlc3MgbWFuYWdlcyB0aGUKKyAgICAgICAgY2xpcGJvYXJk LgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmg6CisgICAgICAgICogV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW46CisgICAgICAgICogV2ViUHJvY2Vz cy9XZWJQYWdlL2d0ay9XZWJQYWdlR3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZTo6 Y29sbGFwc2VTZWxlY3Rpb25JbkZyYW1lKTogQWRkZWQgbWV0aG9kcyB0byBzZW5kCisgICAgICAg IHRoZSBVSVByb2Nlc3MtPldlYlByb2Nlc3Mgbm90aWZpY2F0aW9uIHRoYXQgdGhlIGdsb2JhbCBz ZWxlY3Rpb24gaGFzCisgICAgICAgIGJlZW4gcmVwbGFjZWQuCisKIDIwMTYtMDktMTMgIENhcmxv cyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIEdl dCByaWQgb2YgRGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkIGFuZCBjbGVhbnVwIHBhc3RlYm9h cmQgY29kZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2UgYi9T b3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBlNjQwNjAzLi5jZTJiYWFmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2Uv V2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtNzEsNiArNzEsNyBAQCBsaXN0KEFQUEVORCBX ZWJLaXQyX1NPVVJDRVMKICAgICBTaGFyZWQvZ3RrL05hdGl2ZVdlYk1vdXNlRXZlbnRHdGsuY3Bw CiAgICAgU2hhcmVkL2d0ay9OYXRpdmVXZWJUb3VjaEV2ZW50R3RrLmNwcAogICAgIFNoYXJlZC9n dGsvTmF0aXZlV2ViV2hlZWxFdmVudEd0ay5jcHAKKyAgICBTaGFyZWQvZ3RrL1Bhc3RlYm9hcmRD b250ZW50LmNwcAogICAgIFNoYXJlZC9ndGsvUHJpbnRJbmZvR3RrLmNwcAogICAgIFNoYXJlZC9n dGsvUHJvY2Vzc0V4ZWN1dGFibGVQYXRoR3RrLmNwcAogICAgIFNoYXJlZC9ndGsvV2ViQ29udGV4 dE1lbnVJdGVtR3RrLmNwcApAQCAtMzEzLDYgKzMxNCw3IEBAIGxpc3QoQVBQRU5EIFdlYktpdDJf U09VUkNFUwogICAgIFVJUHJvY2Vzcy9ndGsvV2ViSW5zcGVjdG9yQ2xpZW50R3RrLmNwcAogICAg IFVJUHJvY2Vzcy9ndGsvV2ViSW5zcGVjdG9yUHJveHlHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0 ay9XZWJQYWdlUHJveHlHdGsuY3BwCisgICAgVUlQcm9jZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJv eHlHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJQb3B1cE1lbnVQcm94eUd0ay5jcHAKICAg ICBVSVByb2Nlc3MvZ3RrL1dlYlByZWZlcmVuY2VzR3RrLmNwcAogICAgIFVJUHJvY2Vzcy9ndGsv V2ViUHJvY2Vzc1Bvb2xHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQv Z3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJn dW1lbnRDb2RlcnNHdGsuY3BwCmluZGV4IGZkOTQ1YTA2Li45ZmRjZmJkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcApAQCAtODIsNyArODIs NyBAQCBzdGF0aWMgYm9vbCBkZWNvZGVJbWFnZShEZWNvZGVyJiBkZWNvZGVyLCBHUmVmUHRyPEdk a1BpeGJ1Zj4mIHBpeGJ1ZikKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQgZW5j b2RlRGF0YU9iamVjdChFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBEYXRhT2JqZWN0R3RrKiBkYXRh T2JqZWN0KQordm9pZCBlbmNvZGUoRW5jb2RlciYgZW5jb2RlciwgY29uc3QgRGF0YU9iamVjdEd0 ayogZGF0YU9iamVjdCkKIHsKICAgICBib29sIGhhc1RleHQgPSBkYXRhT2JqZWN0LT5oYXNUZXh0 KCk7CiAgICAgZW5jb2RlciA8PCBoYXNUZXh0OwpAQCAtMTEzLDkgKzExMywxMiBAQCBzdGF0aWMg dm9pZCBlbmNvZGVEYXRhT2JqZWN0KEVuY29kZXImIGVuY29kZXIsIGNvbnN0IERhdGFPYmplY3RH dGsqIGRhdGFPYmplY3QpCiAgICAgZW5jb2RlciA8PCBoYXNVbmtub3duVHlwZURhdGE7CiAgICAg aWYgKGhhc1Vua25vd25UeXBlRGF0YSkKICAgICAgICAgZW5jb2RlciA8PCBkYXRhT2JqZWN0LT51 bmtub3duVHlwZXMoKTsKKworICAgIGJvb2wgaGFzU21hcnRQYXN0ZSA9IGRhdGFPYmplY3QtPmhh c1NtYXJ0UGFzdGUoKTsKKyAgICBlbmNvZGVyIDw8IGhhc1NtYXJ0UGFzdGU7CiB9CiAKLXN0YXRp YyBib29sIGRlY29kZURhdGFPYmplY3QoRGVjb2RlciYgZGVjb2RlciwgUmVmUHRyPERhdGFPYmpl Y3RHdGs+JiBkYXRhT2JqZWN0KQorYm9vbCBkZWNvZGUoRGVjb2RlciYgZGVjb2RlciwgUmVmUHRy PERhdGFPYmplY3RHdGs+JiBkYXRhT2JqZWN0KQogewogICAgIFJlZlB0cjxEYXRhT2JqZWN0R3Rr PiBkYXRhID0gRGF0YU9iamVjdEd0azo6Y3JlYXRlKCk7CiAKQEAgLTE4Miw2ICsxODUsMTEgQEAg c3RhdGljIGJvb2wgZGVjb2RlRGF0YU9iamVjdChEZWNvZGVyJiBkZWNvZGVyLCBSZWZQdHI8RGF0 YU9iamVjdEd0az4mIGRhdGFPYmplY3QKICAgICAgICAgICAgIGRhdGEtPnNldFVua25vd25UeXBl RGF0YShpdC0+a2V5LCBpdC0+dmFsdWUpOwogICAgIH0KIAorICAgIGJvb2wgaGFzU21hcnRQYXN0 ZTsKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKGhhc1NtYXJ0UGFzdGUpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgZGF0YS0+c2V0SGFzU21hcnRQYXN0ZShoYXNTbWFydFBhc3RlKTsKKwog ICAgIGRhdGFPYmplY3QgPSBkYXRhOwogCiAgICAgcmV0dXJuIHRydWU7CkBAIC0xOTgsNyArMjA2 LDcgQEAgdm9pZCBBcmd1bWVudENvZGVyPERyYWdEYXRhPjo6ZW5jb2RlKEVuY29kZXImIGVuY29k ZXIsIGNvbnN0IERyYWdEYXRhJiBkcmFnRGF0YSkKICAgICBEYXRhT2JqZWN0R3RrKiBwbGF0Zm9y bURhdGEgPSBkcmFnRGF0YS5wbGF0Zm9ybURhdGEoKTsKICAgICBlbmNvZGVyIDw8IHN0YXRpY19j YXN0PGJvb2w+KHBsYXRmb3JtRGF0YSk7CiAgICAgaWYgKHBsYXRmb3JtRGF0YSkKLSAgICAgICAg ZW5jb2RlRGF0YU9iamVjdChlbmNvZGVyLCBwbGF0Zm9ybURhdGEpOworICAgICAgICBJUEM6OmVu Y29kZShlbmNvZGVyLCBwbGF0Zm9ybURhdGEpOwogfQogCiBib29sIEFyZ3VtZW50Q29kZXI8RHJh Z0RhdGE+OjpkZWNvZGUoRGVjb2RlciYgZGVjb2RlciwgRHJhZ0RhdGEmIGRyYWdEYXRhKQpAQCAt MjI1LDcgKzIzMyw3IEBAIGJvb2wgQXJndW1lbnRDb2RlcjxEcmFnRGF0YT46OmRlY29kZShEZWNv ZGVyJiBkZWNvZGVyLCBEcmFnRGF0YSYgZHJhZ0RhdGEpCiAKICAgICBSZWZQdHI8RGF0YU9iamVj dEd0az4gcGxhdGZvcm1EYXRhOwogICAgIGlmIChoYXNQbGF0Zm9ybURhdGEpIHsKLSAgICAgICAg aWYgKCFkZWNvZGVEYXRhT2JqZWN0KGRlY29kZXIsIHBsYXRmb3JtRGF0YSkpCisgICAgICAgIGlm ICghSVBDOjpkZWNvZGUoZGVjb2RlciwgcGxhdGZvcm1EYXRhKSkKICAgICAgICAgICAgIHJldHVy biBmYWxzZTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsv QXJndW1lbnRDb2RlcnNHdGsuaCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRD b2RlcnNHdGsuaAppbmRleCAwMWFjNGNmLi4xNjljNjY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmgKKysrIGIvU291cmNlL1dlYktpdDIv U2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5oCkBAIC01Miw2ICs1Miw5IEBAIGJvb2wgZGVj b2RlKERlY29kZXImLCBHUmVmUHRyPEd0a1ByaW50U2V0dGluZ3M+Jik7CiB2b2lkIGVuY29kZShF bmNvZGVyJiwgR3RrUGFnZVNldHVwKik7CiBib29sIGRlY29kZShEZWNvZGVyJiwgR1JlZlB0cjxH dGtQYWdlU2V0dXA+Jik7CiAKK3ZvaWQgZW5jb2RlKEVuY29kZXImLCBjb25zdCBXZWJDb3JlOjpE YXRhT2JqZWN0R3RrKik7Citib29sIGRlY29kZShEZWNvZGVyJiwgUmVmUHRyPFdlYkNvcmU6OkRh dGFPYmplY3RHdGs+Jik7CisKIH0gLy8gbmFtZXNwYWNlIElQQwogCiAjZW5kaWYgLy8gQXJndW1l bnRDb2RlcnNHdGtfaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL2d0ay9QYXN0 ZWJvYXJkQ29udGVudC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRD b250ZW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODJjMTIyCi0t LSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL2d0ay9QYXN0ZWJvYXJkQ29u dGVudC5jcHAKQEAgLTAsMCArMSw0NiBAQAorLyoKKyAqICBDb3B5cmlnaHQgKEMpIDIwMTYgUmVk IEhhdCBJbmMuCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiAgdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoK KyAqICBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0 aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiAgTGVzc2VyIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiAgWW91IHNob3VsZCBoYXZl IHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogIExp Y2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUg U29mdHdhcmUKKyAqICBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpZnRo IEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiUGFzdGVib2FyZENvbnRlbnQuaCIKKworI2luY2x1ZGUgIkFyZ3Vt ZW50Q29kZXJzR3RrLmgiCisjaW5jbHVkZSAiRGF0YU9iamVjdEd0ay5oIgorI2luY2x1ZGUgIkRl Y29kZXIuaCIKKyNpbmNsdWRlICJFbmNvZGVyLmgiCisjaW5jbHVkZSA8d3RmL1JldGFpblB0ci5o PgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworUGFzdGVib2FyZENvbnRlbnQ6OlBhc3RlYm9hcmRD b250ZW50KFJlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPiBkYXRhKQorICAgIDogZGF0YU9i amVjdChkYXRhKQoreworICAgIEFTU0VSVChkYXRhT2JqZWN0KTsKK30KKwordm9pZCBQYXN0ZWJv YXJkQ29udGVudDo6ZW5jb2RlKElQQzo6RW5jb2RlciYgZW5jb2RlcikgY29uc3QKK3sKKyAgICBJ UEM6OmVuY29kZShlbmNvZGVyLCBkYXRhT2JqZWN0LmdldCgpKTsKK30KKworYm9vbCBQYXN0ZWJv YXJkQ29udGVudDo6ZGVjb2RlKElQQzo6RGVjb2RlciYgZGVjb2RlciwgUGFzdGVib2FyZENvbnRl bnQmIHBhc3RlYm9hcmRDb250ZW50KQoreworICAgIHJldHVybiBJUEM6OmRlY29kZShkZWNvZGVy LCBwYXN0ZWJvYXJkQ29udGVudC5kYXRhT2JqZWN0KTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2Vi S2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250 ZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50LmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDg2ZjlmZAotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFzdGVib2FyZENvbnRlbnQuaApAQCAtMCww ICsxLDQzIEBACisvKgorICogIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisg KiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZv dW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3Rvbiwg TUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpZm5kZWYgUGFzdGVib2FyZENvbnRlbnRfaAor I2RlZmluZSBQYXN0ZWJvYXJkQ29udGVudF9oCisKKyNpbmNsdWRlICJEYXRhT2JqZWN0R3RrLmgi CisKK25hbWVzcGFjZSBJUEMgeworY2xhc3MgRGVjb2RlcjsKK2NsYXNzIEVuY29kZXI7Cit9CisK K25hbWVzcGFjZSBXZWJLaXQgeworCitzdHJ1Y3QgUGFzdGVib2FyZENvbnRlbnQgeworICAgIFBh c3RlYm9hcmRDb250ZW50KCkgPSBkZWZhdWx0OworICAgIGV4cGxpY2l0IFBhc3RlYm9hcmRDb250 ZW50KFJlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPik7CisKKyAgICBSZWZQdHI8V2ViQ29y ZTo6RGF0YU9iamVjdEd0az4gZGF0YU9iamVjdDsKKworICAgIHZvaWQgZW5jb2RlKElQQzo6RW5j b2RlciYpIGNvbnN0OworICAgIHN0YXRpYyBib29sIGRlY29kZShJUEM6OkRlY29kZXImLCBQYXN0 ZWJvYXJkQ29udGVudCYpOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAv LyBQYXN0ZWJvYXJkQ29udGVudF9oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViRnJhbWVQcm94eS5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViRnJhbWVQ cm94eS5jcHAKaW5kZXggY2Q3MDY5OC4uNDZkZjdmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYkZyYW1lUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9XZWJGcmFtZVByb3h5LmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIldlYkZy YW1lUG9saWN5TGlzdGVuZXJQcm94eS5oIgogI2luY2x1ZGUgIldlYlBhZ2VNZXNzYWdlcy5oIgog I2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgorI2luY2x1ZGUgIldlYlBhc3RlYm9hcmRQcm94eS5o IgogI2luY2x1ZGUgIldlYlByb2Nlc3NQb29sLmgiCiAjaW5jbHVkZSA8V2ViQ29yZS9JbWFnZS5o PgogI2luY2x1ZGUgPFdlYkNvcmUvTUlNRVR5cGVSZWdpc3RyeS5oPgpAQCAtNTIsNiArNTMsOSBA QCBXZWJGcmFtZVByb3h5OjpXZWJGcmFtZVByb3h5KFdlYlBhZ2VQcm94eSogcGFnZSwgdWludDY0 X3QgZnJhbWVJRCkKIFdlYkZyYW1lUHJveHk6On5XZWJGcmFtZVByb3h5KCkKIHsKICAgICBXZWJQ cm9jZXNzUG9vbDo6c3RhdGlzdGljcygpLndrRnJhbWVDb3VudC0tOworI2lmIFBMQVRGT1JNKEdU SykKKyAgICBXZWJQYXN0ZWJvYXJkUHJveHk6OnNpbmdsZXRvbigpLmRpZERlc3Ryb3lGcmFtZSh0 aGlzKTsKKyNlbmRpZgogfQogCiB2b2lkIFdlYkZyYW1lUHJveHk6OndlYlByb2Nlc3NXaWxsU2h1 dERvd24oKQpAQCAtMjU0LDQgKzI1OCwxNCBAQCBib29sIFdlYkZyYW1lUHJveHk6OmRpZEhhbmRs ZUNvbnRlbnRGaWx0ZXJVbmJsb2NrTmF2aWdhdGlvbihjb25zdCBXZWJDb3JlOjpSZXNvdQogfQog I2VuZGlmCiAKKyNpZiBQTEFURk9STShHVEspCit2b2lkIFdlYkZyYW1lUHJveHk6OmNvbGxhcHNl U2VsZWN0aW9uKCkKK3sKKyAgICBpZiAoIW1fcGFnZSkKKyAgICAgICAgcmV0dXJuOworCisgICAg bV9wYWdlLT5wcm9jZXNzKCkuc2VuZChNZXNzYWdlczo6V2ViUGFnZTo6Q29sbGFwc2VTZWxlY3Rp b25JbkZyYW1lKG1fZnJhbWVJRCksIG1fcGFnZS0+cGFnZUlEKCkpOworfQorI2VuZGlmCisKIH0g Ly8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNz L1dlYkZyYW1lUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJGcmFtZVByb3h5 LmgKaW5kZXggNjcwNDU4MC4uNTgwOGJmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYkZyYW1lUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2Vi RnJhbWVQcm94eS5oCkBAIC0xMjQsNiArMTI0LDEwIEBAIHB1YmxpYzoKICAgICBib29sIGRpZEhh bmRsZUNvbnRlbnRGaWx0ZXJVbmJsb2NrTmF2aWdhdGlvbihjb25zdCBXZWJDb3JlOjpSZXNvdXJj ZVJlcXVlc3QmKTsKICNlbmRpZgogCisjaWYgUExBVEZPUk0oR1RLKQorICAgIHZvaWQgY29sbGFw c2VTZWxlY3Rpb24oKTsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIFdlYkZyYW1lUHJveHkoV2Vi UGFnZVByb3h5KiBwYWdlLCB1aW50NjRfdCBmcmFtZUlEKTsKIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5oIGIvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5oCmluZGV4IDVlMmE1YjEuLmU4NDAwMzIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkuaAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmgKQEAgLTQw LDggKzQwLDEzIEBAIHN0cnVjdCBQYXN0ZWJvYXJkV2ViQ29udGVudDsKIAogbmFtZXNwYWNlIFdl YktpdCB7CiAKK2NsYXNzIFdlYkZyYW1lUHJveHk7CiBjbGFzcyBXZWJQcm9jZXNzUHJveHk7CiAK KyNpZiBQTEFURk9STShHVEspCitjbGFzcyBQYXN0ZWJvYXJkQ29udGVudDsKKyNlbmRpZgorCiBj bGFzcyBXZWJQYXN0ZWJvYXJkUHJveHkgOiBwdWJsaWMgSVBDOjpNZXNzYWdlUmVjZWl2ZXIgewog ICAgIFdURl9NQUtFX05PTkNPUFlBQkxFKFdlYlBhc3RlYm9hcmRQcm94eSk7CiAgICAgZnJpZW5k IGNsYXNzIExhenlOZXZlckRlc3Ryb3llZDxXZWJQYXN0ZWJvYXJkUHJveHk+OwpAQCAtNTAsNiAr NTUsMTEgQEAgcHVibGljOgogCiAgICAgdm9pZCBhZGRXZWJQcm9jZXNzUHJveHkoV2ViUHJvY2Vz c1Byb3h5Jik7CiAKKyNpZiBQTEFURk9STShHVEspCisgICAgdm9pZCBzZXRQcmltYXJ5U2VsZWN0 aW9uT3duZXIoV2ViRnJhbWVQcm94eSopOworICAgIHZvaWQgZGlkRGVzdHJveUZyYW1lKFdlYkZy YW1lUHJveHkqKTsKKyNlbmRpZgorCiBwcml2YXRlOgogICAgIFdlYlBhc3RlYm9hcmRQcm94eSgp OwogCkBAIC04MSw2ICs5MSwxMyBAQCBwcml2YXRlOgogICAgIHZvaWQgc2V0UGFzdGVib2FyZFN0 cmluZ0ZvclR5cGUoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgU3RyaW5nJiBw YXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiwgdWludDY0X3QmIG5ld0NoYW5nZUNvdW50KTsK ICAgICB2b2lkIHNldFBhc3RlYm9hcmRCdWZmZXJGb3JUeXBlKGNvbnN0IFN0cmluZyYgcGFzdGVi b2FyZE5hbWUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFNoYXJlZE1lbW9y eTo6SGFuZGxlJiwgdWludDY0X3Qgc2l6ZSwgdWludDY0X3QmIG5ld0NoYW5nZUNvdW50KTsKICNl bmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2b2lkIHdyaXRlVG9DbGlwYm9hcmQoY29uc3Qg U3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgUGFzdGVib2FyZENvbnRlbnQmKTsKKyAgICB2 b2lkIHJlYWRGcm9tQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUsIFBhc3Rl Ym9hcmRDb250ZW50Jik7CisKKyAgICBXZWJGcmFtZVByb3h5KiBtX3ByaW1hcnlTZWxlY3Rpb25P d25lciB7IG51bGxwdHIgfTsKKyAgICBXZWJGcmFtZVByb3h5KiBtX2ZyYW1lV3JpdGluZ1RvQ2xp cGJvYXJkIHsgbnVsbHB0ciB9OworI2VuZGlmIC8vIFBMQVRGT1JNKEdUSykKIH07CiAKIH0gLy8g bmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dl YlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9X ZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMuaW4KaW5kZXggZDBkOWZhMS4uMTk1ZTZiMCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNz YWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5 Lm1lc3NhZ2VzLmluCkBAIC00OCw0ICs0OCw5IEBAIG1lc3NhZ2VzIC0+IFdlYlBhc3RlYm9hcmRQ cm94eSB7CiAgICAgU2V0UGFzdGVib2FyZFN0cmluZ0ZvclR5cGUoU3RyaW5nIHBhc3RlYm9hcmRO YW1lLCBTdHJpbmcgcGFzdGVib2FyZFR5cGUsIFN0cmluZyBzdHJpbmcpIC0+ICh1aW50NjRfdCBj aGFuZ2VDb3VudCkKICAgICBTZXRQYXN0ZWJvYXJkQnVmZmVyRm9yVHlwZShTdHJpbmcgcGFzdGVi b2FyZE5hbWUsIFN0cmluZyBwYXN0ZWJvYXJkVHlwZSwgV2ViS2l0OjpTaGFyZWRNZW1vcnk6Okhh bmRsZSBoYW5kbGUsIHVpbnQ2NF90IHNpemUpIC0+ICh1aW50NjRfdCBjaGFuZ2VDb3VudCkKICNl bmRpZgorCisjaWYgUExBVEZPUk0oR1RLKQorICAgIFdyaXRlVG9DbGlwYm9hcmQoU3RyaW5nIHBh c3RlYm9hcmROYW1lLCBzdHJ1Y3QgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudCBwYXN0ZWJvYXJk Q29udGVudCkKKyAgICBSZWFkRnJvbUNsaXBib2FyZChTdHJpbmcgcGFzdGVib2FyZE5hbWUpIC0+ IChzdHJ1Y3QgV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudCBwYXN0ZWJvYXJkQ29udGVudCkKKyNl bmRpZgogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdl UHJveHlHdGsuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlH dGsuY3BwCmluZGV4IDJkYmFlMDUuLmY1YTg0YmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94eUd0ay5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNs dWRlICJQYWdlQ2xpZW50SW1wbC5oIgogI2luY2x1ZGUgIldlYktpdFdlYlZpZXdCYXNlUHJpdmF0 ZS5oIgogI2luY2x1ZGUgIldlYlBhZ2VNZXNzYWdlcy5oIgorI2luY2x1ZGUgIldlYlBhc3RlYm9h cmRQcm94eS5oIgogI2luY2x1ZGUgIldlYlByb2Nlc3NQcm94eS5oIgogI2luY2x1ZGUgIldlYnNp dGVEYXRhU3RvcmUuaCIKICNpbmNsdWRlIDxXZWJDb3JlL1VzZXJBZ2VudEd0ay5oPgpAQCAtNzks NiArODAsOCBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6ZWRpdG9yU3RhdGVDaGFuZ2VkKGNvbnN0IEVk aXRvclN0YXRlJiBlZGl0b3JTdGF0ZSkKICAgICAKICAgICBpZiAoZWRpdG9yU3RhdGUuc2hvdWxk SWdub3JlQ29tcG9zaXRpb25TZWxlY3Rpb25DaGFuZ2UpCiAgICAgICAgIHJldHVybjsKKyAgICBp ZiAobV9lZGl0b3JTdGF0ZS5zZWxlY3Rpb25Jc1JhbmdlKQorICAgICAgICBXZWJQYXN0ZWJvYXJk UHJveHk6OnNpbmdsZXRvbigpLnNldFByaW1hcnlTZWxlY3Rpb25Pd25lcihmb2N1c2VkRnJhbWUo KSk7CiAgICAgbV9wYWdlQ2xpZW50LnNlbGVjdGlvbkRpZENoYW5nZSgpOwogfQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5j cHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5j cHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTVmOTBkMwotLS0gL2Rldi9u dWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFzdGVib2FyZFByb3h5 R3RrLmNwcApAQCAtMCwwICsxLDczIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IFJlZCBI YXQgSW5jLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5h cnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVk IHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICog MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAor ICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisg KiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICog Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiV2ViUGFz dGVib2FyZFByb3h5LmgiCisKKyNpbmNsdWRlICJQYXN0ZWJvYXJkQ29udGVudC5oIgorI2luY2x1 ZGUgIldlYkZyYW1lUHJveHkuaCIKKyNpbmNsdWRlIDxXZWJDb3JlL1BsYXRmb3JtUGFzdGVib2Fy ZC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL05ldmVyRGVzdHJv eWVkLmg+CisjaW5jbHVkZSA8d3RmL1RlbXBvcmFyeUNoYW5nZS5oPgorI2luY2x1ZGUgPHd0Zi90 ZXh0L1N0cmluZ0hhc2guaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFj ZSBXZWJLaXQgeworCit2b2lkIFdlYlBhc3RlYm9hcmRQcm94eTo6d3JpdGVUb0NsaXBib2FyZChj b25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBQYXN0ZWJvYXJkQ29udGVudCYgcGFz dGVib2FyZENvbnRlbnQpCit7CisgICAgVGVtcG9yYXJ5Q2hhbmdlPFdlYkZyYW1lUHJveHkqPiBm cmFtZVdyaXRpbmdUb0NsaXBib2FyZChtX2ZyYW1lV3JpdGluZ1RvQ2xpcGJvYXJkLCBtX3ByaW1h cnlTZWxlY3Rpb25Pd25lcik7CisgICAgUGxhdGZvcm1QYXN0ZWJvYXJkKHBhc3RlYm9hcmROYW1l KS53cml0ZVRvQ2xpcGJvYXJkKHBhc3RlYm9hcmRDb250ZW50LmRhdGFPYmplY3QsIFt0aGlzXSB7 CisgICAgICAgIGlmIChtX2ZyYW1lV3JpdGluZ1RvQ2xpcGJvYXJkID09IG1fcHJpbWFyeVNlbGVj dGlvbk93bmVyKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBzZXRQcmltYXJ5U2VsZWN0 aW9uT3duZXIobnVsbHB0cik7CisgICAgfSk7Cit9CisKK3ZvaWQgV2ViUGFzdGVib2FyZFByb3h5 OjpyZWFkRnJvbUNsaXBib2FyZChjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBQYXN0ZWJv YXJkQ29udGVudCYgcGFzdGVib2FyZENvbnRlbnQpCit7CisgICAgcGFzdGVib2FyZENvbnRlbnQg PSBQYXN0ZWJvYXJkQ29udGVudChQbGF0Zm9ybVBhc3RlYm9hcmQocGFzdGVib2FyZE5hbWUpLnJl YWRGcm9tQ2xpcGJvYXJkKCkuZ2V0KCkpOworfQorCit2b2lkIFdlYlBhc3RlYm9hcmRQcm94eTo6 c2V0UHJpbWFyeVNlbGVjdGlvbk93bmVyKFdlYkZyYW1lUHJveHkqIGZyYW1lKQoreworICAgIGlm IChtX3ByaW1hcnlTZWxlY3Rpb25Pd25lciA9PSBmcmFtZSkKKyAgICAgICAgcmV0dXJuOworCisg ICAgaWYgKG1fcHJpbWFyeVNlbGVjdGlvbk93bmVyKQorICAgICAgICBtX3ByaW1hcnlTZWxlY3Rp b25Pd25lci0+Y29sbGFwc2VTZWxlY3Rpb24oKTsKKworICAgIG1fcHJpbWFyeVNlbGVjdGlvbk93 bmVyID0gZnJhbWU7Cit9CisKK3ZvaWQgV2ViUGFzdGVib2FyZFByb3h5OjpkaWREZXN0cm95RnJh bWUoV2ViRnJhbWVQcm94eSogZnJhbWUpCit7CisgICAgaWYgKGZyYW1lID09IG1fcHJpbWFyeVNl bGVjdGlvbk93bmVyKQorICAgICAgICBtX3ByaW1hcnlTZWxlY3Rpb25Pd25lciA9IG51bGxwdHI7 Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdp ZXMuY3BwCmluZGV4IDAxOWMxMzMuLjkyODBhOTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3Ry YXRlZ2llcy5jcHAKQEAgLTY5LDYgKzY5LDEwIEBACiAjaW5jbHVkZSAiU3RyaW5nVXRpbGl0aWVz LmgiCiAjZW5kaWYKIAorI2lmIFBMQVRGT1JNKEdUSykKKyNpbmNsdWRlICJQYXN0ZWJvYXJkQ29u dGVudC5oIgorI2VuZGlmCisKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogCiBuYW1lc3BhY2Ug V2ViS2l0IHsKQEAgLTMzOSw0ICszNDMsMjIgQEAgbG9uZyBXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6 OmNoYW5nZUNvdW50KCkKIAogI2VuZGlmIC8vIFBMQVRGT1JNKENPQ09BKQogCisjaWYgUExBVEZP Uk0oR1RLKQorLy8gUGFzdGVib2FyZFN0cmF0ZWd5CisKK3ZvaWQgV2ViUGxhdGZvcm1TdHJhdGVn aWVzOjp3cml0ZVRvQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUsIGNvbnN0 IFJlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPiYgZGF0YU9iamVjdCkKK3sKKyAgICBQYXN0 ZWJvYXJkQ29udGVudCBwYXN0ZWJvYXJkQ29udGVudCA9IFBhc3RlYm9hcmRDb250ZW50KGRhdGFP YmplY3QuZ2V0KCkpOworICAgIFdlYlByb2Nlc3M6OnNpbmdsZXRvbigpLnBhcmVudFByb2Nlc3ND b25uZWN0aW9uKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhc3RlYm9hcmRQcm94eTo6V3JpdGVUb0Ns aXBib2FyZChwYXN0ZWJvYXJkTmFtZSwgcGFzdGVib2FyZENvbnRlbnQpLCAwKTsKK30KKworUmVm UHRyPFdlYkNvcmU6OkRhdGFPYmplY3RHdGs+IFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6cmVhZEZy b21DbGlwYm9hcmQoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkKK3sKKyAgICBQYXN0ZWJv YXJkQ29udGVudCBwYXN0ZWJvYXJkQ29udGVudDsKKyAgICBXZWJQcm9jZXNzOjpzaW5nbGV0b24o KS5wYXJlbnRQcm9jZXNzQ29ubmVjdGlvbigpLT5zZW5kU3luYyhNZXNzYWdlczo6V2ViUGFzdGVi b2FyZFByb3h5OjpSZWFkRnJvbUNsaXBib2FyZChwYXN0ZWJvYXJkTmFtZSksIE1lc3NhZ2VzOjpX ZWJQYXN0ZWJvYXJkUHJveHk6OlJlYWRGcm9tQ2xpcGJvYXJkOjpSZXBseShwYXN0ZWJvYXJkQ29u dGVudCksIDApOworICAgIHJldHVybiBwYXN0ZWJvYXJkQ29udGVudC5kYXRhT2JqZWN0OworfQor CisjZW5kaWYgLy8gUExBVEZPUk0oR1RLKQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZv cm1TdHJhdGVnaWVzLmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCmluZGV4IDc5OGVkMmMuLmYzZTVkODEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1T dHJhdGVnaWVzLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaApAQCAtODYsNyArODYsMTAgQEAgcHJpdmF0ZToKICAg ICBsb25nIHNldFBhdGhuYW1lc0ZvclR5cGUoY29uc3QgVmVjdG9yPFN0cmluZz4mLCBjb25zdCBT dHJpbmcmIHBhc3RlYm9hcmRUeXBlLCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lKSBvdmVy cmlkZTsKICAgICBsb25nIHNldFN0cmluZ0ZvclR5cGUoY29uc3QgU3RyaW5nJiwgY29uc3QgU3Ry aW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkgb3ZlcnJp ZGU7CiAjZW5kaWYKLQorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2b2lkIHdyaXRlVG9DbGlwYm9h cmQoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgY29uc3QgUmVmUHRyPFdlYkNvcmU6OkRh dGFPYmplY3RHdGs+Jikgb3ZlcnJpZGU7CisgICAgUmVmUHRyPFdlYkNvcmU6OkRhdGFPYmplY3RH dGs+IHJlYWRGcm9tQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJy aWRlOworI2VuZGlmCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvZ3RrL1dlYkVkaXRvckNsaWVu dEd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L2d0ay9X ZWJFZGl0b3JDbGllbnRHdGsuY3BwCmluZGV4IDUxMTAwMjUuLmM0OGI4NjMgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvZ3RrL1dlYkVkaXRvckNs aWVudEd0ay5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9y dC9ndGsvV2ViRWRpdG9yQ2xpZW50R3RrLmNwcApAQCAtMTE5LDQ1ICsxMTksNiBAQCB2b2lkIFdl YkVkaXRvckNsaWVudDo6aGFuZGxlSW5wdXRNZXRob2RLZXlkb3duKEtleWJvYXJkRXZlbnQqIGV2 ZW50KQogICAgICAgICBldmVudC0+c2V0RGVmYXVsdEhhbmRsZWQoKTsKIH0KIAotY2xhc3MgRWRp dG9yQ2xpZW50RnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyIDogRnJhbWVEZXN0cnVjdGlvbk9ic2Vy dmVyIHsKLXB1YmxpYzoKLSAgICBFZGl0b3JDbGllbnRGcmFtZURlc3RydWN0aW9uT2JzZXJ2ZXIo RnJhbWUqIGZyYW1lLCBHQ2xvc3VyZSogY2xvc3VyZSkKLSAgICAgICAgOiBGcmFtZURlc3RydWN0 aW9uT2JzZXJ2ZXIoZnJhbWUpCi0gICAgICAgICwgbV9jbG9zdXJlKGNsb3N1cmUpCi0gICAgewot ICAgICAgICBnX2Nsb3N1cmVfYWRkX2ZpbmFsaXplX25vdGlmaWVyKG1fY2xvc3VyZSwgdGhpcywg ZGVzdHJveU9uQ2xvc3VyZUZpbmFsaXphdGlvbik7Ci0gICAgfQotCi0gICAgdm9pZCBmcmFtZURl c3Ryb3llZCgpCi0gICAgewotICAgICAgICBnX2Nsb3N1cmVfaW52YWxpZGF0ZShtX2Nsb3N1cmUp OwotICAgICAgICBGcmFtZURlc3RydWN0aW9uT2JzZXJ2ZXI6OmZyYW1lRGVzdHJveWVkKCk7Ci0g ICAgfQotcHJpdmF0ZToKLSAgICBHQ2xvc3VyZSogbV9jbG9zdXJlOwotCi0gICAgc3RhdGljIHZv aWQgZGVzdHJveU9uQ2xvc3VyZUZpbmFsaXphdGlvbihncG9pbnRlciBkYXRhLCBHQ2xvc3VyZSop Ci0gICAgewotICAgICAgICAvLyBDYWxsaW5nIGRlbGV0ZSB2b2lkKiB3aWxsIGZyZWUgdGhlIG1l bW9yeSBidXQgd29uJ3QgaW52b2tlCi0gICAgICAgIC8vIHRoZSBkZXN0cnVjdG9yLCBzb21ldGhp bmcgdGhhdCBpcyBhIG11c3QgZm9yIHVzLgotICAgICAgICBFZGl0b3JDbGllbnRGcmFtZURlc3Ry dWN0aW9uT2JzZXJ2ZXIqIG9ic2VydmVyID0gc3RhdGljX2Nhc3Q8RWRpdG9yQ2xpZW50RnJhbWVE ZXN0cnVjdGlvbk9ic2VydmVyKj4oZGF0YSk7Ci0gICAgICAgIGRlbGV0ZSBvYnNlcnZlcjsKLSAg ICB9Ci19OwotCi1zdGF0aWMgRnJhbWUqIGZyYW1lU2V0dGluZ0NsaXBib2FyZDsKLQotc3RhdGlj IHZvaWQgY29sbGFwc2VTZWxlY3Rpb24oR3RrQ2xpcGJvYXJkKiwgRnJhbWUqIGZyYW1lKQotewot ICAgIGlmIChmcmFtZVNldHRpbmdDbGlwYm9hcmQgJiYgZnJhbWVTZXR0aW5nQ2xpcGJvYXJkID09 IGZyYW1lKQotICAgICAgICByZXR1cm47Ci0KLSAgICAvLyBDb2xsYXBzZSB0aGUgc2VsZWN0aW9u IHdpdGhvdXQgY2xlYXJpbmcgaXQuCi0gICAgQVNTRVJUKGZyYW1lKTsKLSAgICBjb25zdCBWaXNp YmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24gPSBmcmFtZS0+c2VsZWN0aW9uKCkuc2VsZWN0aW9uKCk7 Ci0gICAgZnJhbWUtPnNlbGVjdGlvbigpLnNldEJhc2Uoc2VsZWN0aW9uLmV4dGVudCgpLCBzZWxl Y3Rpb24uYWZmaW5pdHkoKSk7Ci19Ci0KIHZvaWQgV2ViRWRpdG9yQ2xpZW50Ojp1cGRhdGVHbG9i YWxTZWxlY3Rpb24oRnJhbWUqIGZyYW1lKQogewogICAgIGlmICghZnJhbWUtPnNlbGVjdGlvbigp LmlzUmFuZ2UoKSkKQEAgLTE2NiwyMSArMTI3LDExIEBAIHZvaWQgV2ViRWRpdG9yQ2xpZW50Ojp1 cGRhdGVHbG9iYWxTZWxlY3Rpb24oRnJhbWUqIGZyYW1lKQogICAgIGlmICghcmFuZ2UpCiAgICAg ICAgIHJldHVybjsKIAotICAgIGZyYW1lU2V0dGluZ0NsaXBib2FyZCA9IGZyYW1lOwotICAgIEdS ZWZQdHI8R0Nsb3N1cmU+IGNhbGxiYWNrID0gYWRvcHRHUmVmKGdfY2Nsb3N1cmVfbmV3KEdfQ0FM TEJBQ0soY29sbGFwc2VTZWxlY3Rpb24pLCBmcmFtZSwgbnVsbHB0cikpOwotICAgIC8vIFRoaXMg b2JzZXJ2ZXIgd2lsbCBiZSBzZWxmLWRlc3Ryb3llZCBvbiBjbG9zdXJlIGZpbmFsaXphdGlvbiwK LSAgICAvLyB0aGF0IHdpbGwgaGFwcGVuIGVpdGhlciBhZnRlciBjbG9zdXJlIGV4ZWN1dGlvbiBv ciBhZnRlcgotICAgIC8vIGNsb3N1cmUgaW52YWxpZGF0aW9uLgotICAgIG5ldyBFZGl0b3JDbGll bnRGcmFtZURlc3RydWN0aW9uT2JzZXJ2ZXIoZnJhbWUsIGNhbGxiYWNrLmdldCgpKTsKLSAgICBn X2Nsb3N1cmVfc2V0X21hcnNoYWwoY2FsbGJhY2suZ2V0KCksIGdfY2Nsb3N1cmVfbWFyc2hhbF9W T0lEX19WT0lEKTsKLQogICAgIFBhc3RlYm9hcmRXZWJDb250ZW50IHBhc3RlYm9hcmRDb250ZW50 OwogICAgIHBhc3RlYm9hcmRDb250ZW50LmNhblNtYXJ0Q29weU9yRGVsZXRlID0gZmFsc2U7CiAg ICAgcGFzdGVib2FyZENvbnRlbnQudGV4dCA9IHJhbmdlLT50ZXh0KCk7CiAgICAgcGFzdGVib2Fy ZENvbnRlbnQubWFya3VwID0gY3JlYXRlTWFya3VwKCpyYW5nZSwgbnVsbHB0ciwgQW5ub3RhdGVG b3JJbnRlcmNoYW5nZSwgZmFsc2UsIFJlc29sdmVOb25Mb2NhbFVSTHMpOwotICAgIHBhc3RlYm9h cmRDb250ZW50LmNhbGxiYWNrID0gY2FsbGJhY2s7CiAgICAgUGFzdGVib2FyZDo6Y3JlYXRlRm9y R2xvYmFsU2VsZWN0aW9uKCktPndyaXRlKHBhc3RlYm9hcmRDb250ZW50KTsKLSAgICBmcmFtZVNl dHRpbmdDbGlwYm9hcmQgPSBudWxscHRyOwogfQogCiBib29sIFdlYkVkaXRvckNsaWVudDo6c2hv dWxkU2hvd1VuaWNvZGVNZW51KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nl c3MvV2ViUGFnZS9XZWJQYWdlLmggYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViUGFnZS5oCmluZGV4IDBjNzZmNjUuLjc3ZmZmODEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgKKysrIGIvU291cmNlL1dlYktpdDIvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaApAQCAtNjQ2LDYgKzY0Niw4IEBAIHB1YmxpYzoKICAg ICB2b2lkIHNldENvbXBvc2l0aW9uKGNvbnN0IFN0cmluZyYgdGV4dCwgY29uc3QgVmVjdG9yPFdl YkNvcmU6OkNvbXBvc2l0aW9uVW5kZXJsaW5lPiYgdW5kZXJsaW5lcywgdWludDY0X3Qgc2VsZWN0 aW9uU3RhcnQsIHVpbnQ2NF90IHNlbGVjdGlvbkVuZCwgdWludDY0X3QgcmVwbGFjZW1lbnRSYW5n ZVN0YXJ0LCB1aW50NjRfdCByZXBsYWNlbWVudFJhbmdlTGVuZ3RoKTsKICAgICB2b2lkIGNvbmZp cm1Db21wb3NpdGlvbihjb25zdCBTdHJpbmcmIHRleHQsIGludDY0X3Qgc2VsZWN0aW9uU3RhcnQs IGludDY0X3Qgc2VsZWN0aW9uTGVuZ3RoKTsKICAgICB2b2lkIGNhbmNlbENvbXBvc2l0aW9uKCk7 CisKKyAgICB2b2lkIGNvbGxhcHNlU2VsZWN0aW9uSW5GcmFtZSh1aW50NjRfdCBmcmFtZUlEKTsK ICNlbmRpZgogCiAjaWYgUExBVEZPUk0gKEdUSykgJiYgSEFWRShHVEtfR0VTVFVSRVMpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdl cy5pbiBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2Vz LmluCmluZGV4IDM5ZjhkZjAuLjNjMTFjYTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dl YlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmluCisrKyBiL1NvdXJjZS9XZWJLaXQy L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLm1lc3NhZ2VzLmluCkBAIC0zNDAsNiArMzQwLDgg QEAgbWVzc2FnZXMgLT4gV2ViUGFnZSBMZWdhY3lSZWNlaXZlciB7CiAgICAgU2V0Q29tcG9zaXRp b24oU3RyaW5nIHRleHQsIFZlY3RvcjxXZWJDb3JlOjpDb21wb3NpdGlvblVuZGVybGluZT4gdW5k ZXJsaW5lcywgdWludDY0X3Qgc2VsZWN0aW9uU3RhcnQsIHVpbnQ2NF90IHNlbGVjdGlvbkVuZCwg dWludDY0X3QgcmVwbGFjZW1lbnRSYW5nZVN0YXJ0LCB1aW50NjRfdCByZXBsYWNlbWVudFJhbmdl RW5kKQogICAgIENvbmZpcm1Db21wb3NpdGlvbihTdHJpbmcgdGV4dCwgaW50NjRfdCBzZWxlY3Rp b25TdGFydCwgaW50NjRfdCBzZWxlY3Rpb25MZW5ndGgpCiAgICAgQ2FuY2VsQ29tcG9zaXRpb24o KQorCisgICAgQ29sbGFwc2VTZWxlY3Rpb25JbkZyYW1lKHVpbnQ2NF90IGZyYW1lSUQpCiAjZW5k aWYKIAogI2lmIFBMQVRGT1JNIChHVEspICYmIEhBVkUoR1RLX0dFU1RVUkVTKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL2d0ay9XZWJQYWdlR3RrLmNwcCBi L1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9ndGsvV2ViUGFnZUd0ay5jcHAKaW5k ZXggZTZiODA3NC4uNGE2ZWFkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9XZWJQYWdlL2d0ay9XZWJQYWdlR3RrLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL1dlYlBhZ2UvZ3RrL1dlYlBhZ2VHdGsuY3BwCkBAIC0zMSw4ICszMSwxMCBAQAogI2luY2x1 ZGUgIkVkaXRvclN0YXRlLmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50ZWQuaCIKICNpbmNsdWRl ICJXZWJFdmVudC5oIgorI2luY2x1ZGUgIldlYkZyYW1lLmgiCiAjaW5jbHVkZSAiV2ViUGFnZUFj Y2Vzc2liaWxpdHlPYmplY3QuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHlNZXNzYWdlcy5oIgor I2luY2x1ZGUgIldlYlByb2Nlc3MuaCIKICNpbmNsdWRlICJXaW5kb3dzS2V5Ym9hcmRDb2Rlcy5o IgogI2luY2x1ZGUgPFdlYkNvcmUvQmFja0ZvcndhcmRDb250cm9sbGVyLmg+CiAjaW5jbHVkZSA8 V2ViQ29yZS9FdmVudEhhbmRsZXIuaD4KQEAgLTIxNiw0ICsyMTgsMTUgQEAgdm9pZCBXZWJQYWdl OjpzZXRJbnB1dE1ldGhvZFN0YXRlKGJvb2wgZW5hYmxlZCkKICAgICBzZW5kKE1lc3NhZ2VzOjpX ZWJQYWdlUHJveHk6OlNldElucHV0TWV0aG9kU3RhdGUoZW5hYmxlZCkpOwogfQogCit2b2lkIFdl YlBhZ2U6OmNvbGxhcHNlU2VsZWN0aW9uSW5GcmFtZSh1aW50NjRfdCBmcmFtZUlEKQoreworICAg IFdlYkZyYW1lKiBmcmFtZSA9IFdlYlByb2Nlc3M6OnNpbmdsZXRvbigpLndlYkZyYW1lKGZyYW1l SUQpOworICAgIGlmICghZnJhbWUgfHwgIWZyYW1lLT5jb3JlRnJhbWUoKSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgLy8gQ29sbGFwc2UgdGhlIHNlbGVjdGlvbiB3aXRob3V0IGNsZWFyaW5nIGl0 LgorICAgIGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiA9IGZyYW1lLT5jb3JlRnJh bWUoKS0+c2VsZWN0aW9uKCkuc2VsZWN0aW9uKCk7CisgICAgZnJhbWUtPmNvcmVGcmFtZSgpLT5z ZWxlY3Rpb24oKS5zZXRCYXNlKHNlbGVjdGlvbi5leHRlbnQoKSwgc2VsZWN0aW9uLmFmZmluaXR5 KCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQK 288825 2016-09-14 09:19:30 -0700 2016-09-14 09:47:55 -0700 Patch, implement clipboard as a PlatformPasteboard webkit-platform-gtkclipboard.patch text/plain 53074 carlosg ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA3MDRiNzUyLi41YzBhNjg1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNzMg QEAKKzIwMTYtMDktMTQgIENhcmxvcyBHYXJuYWNobyA8Y2FybG9zZ0Bnbm9tZS5vcmc+CisKKyAg ICAgICAgW0dUS11bV2F5bGFuZF0gSW1wbGVtZW50IGNsaXBib2FyZCBzdXBwb3J0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDY1NzQKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBJbXBsZW1lbnQgUGxhdGZv cm1QYXN0ZWJvYXJkIGluIHRoZSBHVEsrIHBsYXRmb3JtLCBhbmQgbW92ZSBQYXN0ZWJvYXJkCisg ICAgICAgIHRvIHVzaW5nIFBhc3RlYm9hcmRTdHJhdGVneSBzbyBjbGlwYm9hcmQgbWFuYWdlbWVu dCBpcyBsZWZ0IHRvIHRoZQorICAgICAgICBVSVByb2Nlc3MuCisKKyAgICAgICAgRGF0YU9iamVj dEd0ayBpcyBzdGlsbCB1c2VkIGluIHRoZSBQYXN0ZWJvYXJkIEdUSyBpbXBsZW1lbnRhdGlvbiwg aXQncworICAgICAgICBub3cganVzdCBuZXZlciBiYWNrZWQgYnkgYSBHdGtDbGlwYm9hcmQsIHRo aXMgb2JqZWN0IGlzIGluc3RlYWQKKyAgICAgICAgc2VyaWFsaXplZCB0aHJvdWdoIFBhc3RlYm9h cmRTdHJhdGVneSwgc28gdGhlIFVJUHJvY2VzcyBzaWRlIGNhbiBtaXJyb3IKKyAgICAgICAgdGhl IGNvbnRlbnQgaW4gYSBHdGtDbGlwYm9hcmQtYmFja2VkIERhdGFPYmplY3RHdGssIHdoaWNoIGlz IHRoZW4KKyAgICAgICAgZXhwb3NlZCB0byB0aGUgd2luZG93aW5nIHRocm91Z2ggUGxhdGZvcm1Q YXN0ZWJvYXJkL1Bhc3RlYm9hcmRIZWxwZXIuCisKKyAgICAgICAgV2hlbiByZXF1ZXN0aW5nIGNs aXBib2FyZCBjb250ZW50LCBpdCB3b3JrcyBzaW1pbGFybHksIHRoZSBVSVByb2Nlc3MKKyAgICAg ICAgc2lkZSBmaXJzdCB1cGRhdGVzIGl0cyBEYXRhT2JqZWN0R3RrLCB3aGljaCBpcyB0aGVuIG1p cnJvcmVkIGJ5IHRoZQorICAgICAgICBXZWJQcm9jZXNzIHRocm91Z2ggdGhlIFBhc3RlYm9hcmRT dHJhdGVneSByZXF1ZXN0cy4KKworICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOiBBZGRlZCBQ bGF0Zm9ybVBhc3RlYm9hcmRHdGsuY3BwCisgICAgICAgICogZWRpdGluZy9ndGsvRWRpdG9yR3Rr LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkVkaXRvcjo6d3JpdGVTZWxlY3Rpb25Ub1Bhc3RlYm9h cmQpOiBFbGltaW5hdGUgdXNhZ2Ugb2YKKyAgICAgICAgUGFzdGVib2FyZFdlYkNvbnRlbnQgY2Fs bGJhY2sgYXJndW1lbnQuIFRoaXMgaXMgZG9uZSBkaWZmZXJlbnRseSBhcworICAgICAgICB3ZSBo YXZlIHRvIHNpZ25hbCBiYWNrIHRoZSBXZWJQcm9jZXNzLgorICAgICAgICAqIHBsYXRmb3JtL1Bh c3RlYm9hcmQuaDogQ2xlYW5lZCB1cCBvZiBkaXJlY3QgR1RLKyBkZXBlbmRlbmN5LgorICAgICAg ICAqIHBsYXRmb3JtL1Bhc3RlYm9hcmRTdHJhdGVneS5oOiBBZGRlZCBwbHVtYmluZyB0b3dhcmRz IHRoZSBwYXN0ZWJvYXJkCisgICAgICAgIHByb3h5LgorICAgICAgICAqIHBsYXRmb3JtL1BsYXRm b3JtUGFzdGVib2FyZC5oOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9EYXRhT2JqZWN0R3RrLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkRhdGFPYmplY3RHdGs6OmNsZWFyQWxsRXhjZXB0RmlsZW5h bWVzKTogQ2xlYXIgdGhlICJzbWFydAorICAgICAgICBwYXN0ZSIgZmxhZyBpZiBzZXQsIG5vdyB0 aGF0IHRoaXMgaXMgRGF0YU9iamVjdEd0ayBkYXRhLgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9E YXRhT2JqZWN0R3RrLmg6CisgICAgICAgIChXZWJDb3JlOjpEYXRhT2JqZWN0R3RrOjpjYW5TbWFy dFJlcGxhY2UpOgorICAgICAgICAoV2ViQ29yZTo6RGF0YU9iamVjdEd0azo6c2V0Q2FuU21hcnRS ZXBsYWNlKTogQWRkZWQgZnVuY3Rpb25zLCBpbiBvcmRlcgorICAgICAgICB0byBmbGFnIHdoZXRo ZXIgYSBEYXRhT2JqZWN0R3RrIGhhcyB0aGUgInNtYXJ0IHBhc3RlIiBmZWF0dXJlIGVuYWJsZWQK KyAgICAgICAgb3Igbm90LgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkR3RrLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OmNyZWF0ZUZvckNvcHlBbmRQYXN0ZSk6 CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjcmVhdGVGb3JHbG9iYWxTZWxlY3Rpb24p OgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6UGFzdGVib2FyZCk6CisgICAgICAgIChX ZWJDb3JlOjpQYXN0ZWJvYXJkOjp3cml0ZVRvQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNvcmU6 OlBhc3RlYm9hcmQ6OnJlYWRGcm9tQ2xpcGJvYXJkKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OndyaXRlUGxhaW5UZXh0KToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6Ondy aXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OndyaXRlUGFzdGVib2FyZCk6Cisg ICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpjbGVhcik6CisgICAgICAgIChXZWJDb3JlOjpQ YXN0ZWJvYXJkOjpjYW5TbWFydFJlcGxhY2UpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2Fy ZDo6cmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpQYXN0ZWJvYXJkOjpoYXNEYXRhKToKKyAgICAg ICAgKFdlYkNvcmU6OlBhc3RlYm9hcmQ6OnR5cGVzKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3Rl Ym9hcmQ6OnJlYWRTdHJpbmcpOgorICAgICAgICAoV2ViQ29yZTo6UGFzdGVib2FyZDo6cmVhZEZp bGVuYW1lcyk6IE1hZGUgdG8gdXNlIHRoZQorICAgICAgICBQYXN0ZWJvYXJkU3RyYXRlZ3kgaW5z dGVhZCBvZiBQYXN0ZWJvYXJkSGVscGVyL0dUSysgQVBJLgorICAgICAgICAqIHBsYXRmb3JtL2d0 ay9QYXN0ZWJvYXJkSGVscGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmRIZWxw ZXI6On5QYXN0ZWJvYXJkSGVscGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkNsaXBib2FyZFNldERh dGE6OkNsaXBib2FyZFNldERhdGEpOgorICAgICAgICAoV2ViQ29yZTo6Y2xlYXJDbGlwYm9hcmRD b250ZW50c0NhbGxiYWNrKToKKyAgICAgICAgKFdlYkNvcmU6OlBhc3RlYm9hcmRIZWxwZXI6Ondy aXRlQ2xpcGJvYXJkQ29udGVudHMpOiBSZW1vdmUgdGhlIEdDbG9zdXJlCisgICAgICAgIHRvIG5v dGlmeSB3aGV0aGVyIHRoZSBnbG9iYWwgc2VsZWN0aW9uIGhhcyBiZWVuIHJlcGxhY2VkLiBVc2Ug c3RkOmZ1bmN0aW9uCisgICAgICAgIGluc3RlYWQuIFJlbW92ZSBTbWFydFBhc3RlSW5jbHVzaW9u IGFyZ3VtZW50LCBub3cgZmlndXJlZCBvdXQgdGhyb3VnaAorICAgICAgICBEYXRhT2JqZWN0R3Rr IGNhblNtYXJ0UGFzdGUoKSBtZW1iZXIuCisgICAgICAgICogcGxhdGZvcm0vZ3RrL1Bhc3RlYm9h cmRIZWxwZXIuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1QYXN0ZWJvYXJkR3Rr LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6OlBsYXRm b3JtUGFzdGVib2FyZCk6CisgICAgICAgIChXZWJDb3JlOjpQbGF0Zm9ybVBhc3RlYm9hcmQ6Ondy aXRlVG9DbGlwYm9hcmQpOgorICAgICAgICAoV2ViQ29yZTo6UGxhdGZvcm1QYXN0ZWJvYXJkOjpy ZWFkRnJvbUNsaXBib2FyZCk6IEltcGxlbWVudGVkCisgICAgICAgIFBsYXRmb3JtUGFzdGVib2Fy ZCB1c2luZyBQYXN0ZWJvYXJkSGVscGVyL0dUSysgQVBJLgorCiAyMDE2LTA5LTA0ICBBbnR0aSBL b2l2aXN0byAgPGFudHRpQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZlcnNlIG93bmVyc2hpcCBy ZWxhdGlvbiBvZiBTdHlsZUNhY2hlZEltYWdlIGFuZCBDU1NJbWFnZVZhbHVlCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9QbGF0Zm9ybUdUSy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1BsYXRm b3JtR1RLLmNtYWtlCmluZGV4IGYyMWZjMDQuLjZjMTM5NWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL1BsYXRmb3JtR1RLLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1BsYXRmb3JtR1RL LmNtYWtlCkBAIC0yMjEsNiArMjIxLDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZVBsYXRmb3JtR1RL X1NPVVJDRVMKICAgICBwbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhlbHBlci5jcHAKICAgICBwbGF0 Zm9ybS9ndGsvUGxhdGZvcm1LZXlib2FyZEV2ZW50R3RrLmNwcAogICAgIHBsYXRmb3JtL2d0ay9Q bGF0Zm9ybU1vdXNlRXZlbnRHdGsuY3BwCisgICAgcGxhdGZvcm0vZ3RrL1BsYXRmb3JtUGFzdGVi b2FyZEd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsvUGxhdGZvcm1TY3JlZW5HdGsuY3BwCiAgICAg cGxhdGZvcm0vZ3RrL1BsYXRmb3JtV2hlZWxFdmVudEd0ay5jcHAKICAgICBwbGF0Zm9ybS9ndGsv UmVuZGVyVGhlbWVHYWRnZXQuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L2d0ay9FZGl0b3JHdGsuY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9ndGsvRWRpdG9yR3Rr LmNwcAppbmRleCBhNWE1MGM2Li40ZWEwODUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL2d0ay9FZGl0b3JHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvZ3Rr L0VkaXRvckd0ay5jcHAKQEAgLTEyNSw3ICsxMjUsNiBAQCB2b2lkIEVkaXRvcjo6d3JpdGVTZWxl Y3Rpb25Ub1Bhc3RlYm9hcmQoUGFzdGVib2FyZCYgcGFzdGVib2FyZCkKICAgICBwYXN0ZWJvYXJk Q29udGVudC5jYW5TbWFydENvcHlPckRlbGV0ZSA9IGNhblNtYXJ0Q29weU9yRGVsZXRlKCk7CiAg ICAgcGFzdGVib2FyZENvbnRlbnQudGV4dCA9IHNlbGVjdGVkVGV4dEZvckRhdGFUcmFuc2Zlcigp OwogICAgIHBhc3RlYm9hcmRDb250ZW50Lm1hcmt1cCA9IGNyZWF0ZU1hcmt1cCgqc2VsZWN0ZWRS YW5nZSgpLCBudWxscHRyLCBBbm5vdGF0ZUZvckludGVyY2hhbmdlLCBmYWxzZSwgUmVzb2x2ZU5v bkxvY2FsVVJMcyk7Ci0gICAgcGFzdGVib2FyZENvbnRlbnQuY2FsbGJhY2sgPSBudWxscHRyOwog ICAgIHBhc3RlYm9hcmQud3JpdGUocGFzdGVib2FyZENvbnRlbnQpOwogfQogCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9QYXN0ZWJvYXJkLmggYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9QYXN0ZWJvYXJkLmgKaW5kZXggY2JmYmMzZC4uNTliNDk4ZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZC5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL1Bhc3RlYm9hcmQuaApAQCAtMzIsMTEgKzMyLDYgQEAKICNpbmNsdWRlIDx3dGYv VmVjdG9yLmg+CiAjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKLSNpZiBQTEFURk9S TShHVEspCi10eXBlZGVmIHN0cnVjdCBfR3RrQ2xpcGJvYXJkIEd0a0NsaXBib2FyZDsKLSNpbmNs dWRlIDx3dGYvZ2xpYi9HUmVmUHRyLmg+Ci0jZW5kaWYKLQogI2lmIFBMQVRGT1JNKElPUykKIE9C SkNfQ0xBU1MgTlNBcnJheTsKIE9CSkNfQ0xBU1MgTlNTdHJpbmc7CkBAIC04Myw3ICs3OCw2IEBA IHN0cnVjdCBQYXN0ZWJvYXJkV2ViQ29udGVudCB7CiAgICAgYm9vbCBjYW5TbWFydENvcHlPckRl bGV0ZTsKICAgICBTdHJpbmcgdGV4dDsKICAgICBTdHJpbmcgbWFya3VwOwotICAgIEdSZWZQdHI8 R0Nsb3N1cmU+IGNhbGxiYWNrOwogI2VuZGlmCiB9OwogCkBAIC0xNDMsOCArMTM3LDggQEAgcHVi bGljOgogICAgIH5QYXN0ZWJvYXJkKCk7CiAKICNpZiBQTEFURk9STShHVEspCisgICAgZXhwbGlj aXQgUGFzdGVib2FyZChjb25zdCBTdHJpbmcmIG5hbWUpOwogICAgIGV4cGxpY2l0IFBhc3RlYm9h cmQoUmVmUHRyPERhdGFPYmplY3RHdGs+JiYpOwotICAgIGV4cGxpY2l0IFBhc3RlYm9hcmQoR3Rr Q2xpcGJvYXJkKik7CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNKFdJTikKQEAgLTIyNiw4ICsyMjAs MTEgQEAgcHJpdmF0ZToKICNlbmRpZgogCiAjaWYgUExBVEZPUk0oR1RLKQorICAgIGVudW0gY2xh c3MgU2hvdWxkSW5jbHVkZVNtYXJ0UGFzdGUgeyBObywgWWVzIH07CisgICAgdm9pZCB3cml0ZVRv Q2xpcGJvYXJkKFNob3VsZEluY2x1ZGVTbWFydFBhc3RlID0gU2hvdWxkSW5jbHVkZVNtYXJ0UGFz dGU6Ok5vKTsKKyAgICB2b2lkIHJlYWRGcm9tQ2xpcGJvYXJkKCk7CiAgICAgUmVmUHRyPERhdGFP YmplY3RHdGs+IG1fZGF0YU9iamVjdDsKLSAgICBHdGtDbGlwYm9hcmQqIG1fZ3RrQ2xpcGJvYXJk OworICAgIFN0cmluZyBtX25hbWU7CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNKElPUykKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bhc3RlYm9hcmRTdHJhdGVneS5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZFN0cmF0ZWd5LmgKaW5kZXggNjMwMDg1ZS4u ODE3MTZmNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZFN0 cmF0ZWd5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGFzdGVib2FyZFN0cmF0ZWd5 LmgKQEAgLTM4LDYgKzM4LDEwIEBAIGNsYXNzIFVSTDsKIHN0cnVjdCBQYXN0ZWJvYXJkSW1hZ2U7 CiBzdHJ1Y3QgUGFzdGVib2FyZFdlYkNvbnRlbnQ7CiAKKyNpZiBQTEFURk9STShHVEspCitjbGFz cyBEYXRhT2JqZWN0R3RrOworI2VuZGlmCisKIGNsYXNzIFBhc3RlYm9hcmRTdHJhdGVneSB7CiBw dWJsaWM6CiAjaWYgUExBVEZPUk0oSU9TKQpAQCAtNjgsNiArNzIsMTAgQEAgcHVibGljOgogICAg IHZpcnR1YWwgbG9uZyBzZXRQYXRobmFtZXNGb3JUeXBlKGNvbnN0IFZlY3RvcjxTdHJpbmc+Jiwg Y29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFt ZSkgPSAwOwogICAgIHZpcnR1YWwgbG9uZyBzZXRTdHJpbmdGb3JUeXBlKGNvbnN0IFN0cmluZyYs IGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5h bWUpID0gMDsKICNlbmRpZgorI2lmIFBMQVRGT1JNKEdUSykKKyAgICB2aXJ0dWFsIHZvaWQgd3Jp dGVUb0NsaXBib2FyZChjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBSZWZQdHI8 RGF0YU9iamVjdEd0az4mKSA9IDA7CisgICAgdmlydHVhbCBSZWZQdHI8RGF0YU9iamVjdEd0az4g cmVhZEZyb21DbGlwYm9hcmQoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkgPSAwOworI2Vu ZGlmIC8vIFBMQVRGT1JNKEdUSykKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIH5QYXN0ZWJvYXJk U3RyYXRlZ3koKQogICAgIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL1Bs YXRmb3JtUGFzdGVib2FyZC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vUGxhdGZvcm1QYXN0 ZWJvYXJkLmgKaW5kZXggMGJiNmUyZC4uNjk1YmMwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vUGxhdGZvcm1QYXN0ZWJvYXJkLmgKQEAgLTQ3LDYgKzQ3LDEwIEBAIGNsYXNzIFVSTDsK IHN0cnVjdCBQYXN0ZWJvYXJkSW1hZ2U7CiBzdHJ1Y3QgUGFzdGVib2FyZFdlYkNvbnRlbnQ7CiAK KyNpZiBQTEFURk9STShHVEspCitjbGFzcyBEYXRhT2JqZWN0R3RrOworI2VuZGlmCisKIGNsYXNz IFBsYXRmb3JtUGFzdGVib2FyZCB7CiBwdWJsaWM6CiAgICAgLy8gRklYTUU6IHByb2JhYmx5IHdl IGRvbid0IG5lZWQgYSBjb25zdHJ1Y3RvciB0aGF0IHRha2VzIGEgcGFzdGVib2FyZCBuYW1lIGZv ciBpT1MuCkBAIC04MSw2ICs4NSwxMSBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgVVJM IHJlYWRVUkwoaW50IGluZGV4LCBjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmRUeXBlKTsKICAgICBX RUJDT1JFX0VYUE9SVCBpbnQgY291bnQoKTsKIAorI2lmIFBMQVRGT1JNKEdUSykKKyAgICBXRUJD T1JFX0VYUE9SVCB2b2lkIHdyaXRlVG9DbGlwYm9hcmQoY29uc3QgUmVmUHRyPERhdGFPYmplY3RH dGs+Jiwgc3RkOjpmdW5jdGlvbjx2b2lkKCk+JiYgcHJpbWFyeVNlbGVjdGlvbkNsZWFyZWQpOwor ICAgIFdFQkNPUkVfRVhQT1JUIFJlZlB0cjxEYXRhT2JqZWN0R3RrPiByZWFkRnJvbUNsaXBib2Fy ZCgpOworI2VuZGlmCisKIHByaXZhdGU6CiAjaWYgUExBVEZPUk0oTUFDKQogICAgIFJldGFpblB0 cjxOU1Bhc3RlYm9hcmQ+IG1fcGFzdGVib2FyZDsKQEAgLTg4LDYgKzk3LDkgQEAgcHJpdmF0ZToK ICNpZiBQTEFURk9STShJT1MpCiAgICAgUmV0YWluUHRyPFVJUGFzdGVib2FyZD4gbV9wYXN0ZWJv YXJkOwogI2VuZGlmCisjaWYgUExBVEZPUk0oR1RLKQorICAgIEd0a0NsaXBib2FyZCogbV9jbGlw Ym9hcmQ7CisjZW5kaWYKIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9EYXRhT2JqZWN0R3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9E YXRhT2JqZWN0R3RrLmNwcAppbmRleCA2ZGIwYmRlLi43YTVlZjY5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuY3BwCkBAIC0xMzksNiArMTM5LDcgQEAg dm9pZCBEYXRhT2JqZWN0R3RrOjpjbGVhckFsbEV4Y2VwdEZpbGVuYW1lcygpCiAgICAgbV91cmwg PSBVUkwoKTsKICAgICBtX2ltYWdlID0gbnVsbHB0cjsKICAgICBtX3Vua25vd25UeXBlRGF0YS5j bGVhcigpOworICAgIG1fY2FuU21hcnRSZXBsYWNlID0gZmFsc2U7CiB9CiAKIHZvaWQgRGF0YU9i amVjdEd0azo6Y2xlYXJBbGwoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3RrL0RhdGFPYmplY3RHdGsuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9EYXRhT2Jq ZWN0R3RrLmgKaW5kZXggNDhhMjAzYy4uZTI5M2IyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3RrL0RhdGFPYmplY3RHdGsuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ndGsvRGF0YU9iamVjdEd0ay5oCkBAIC00Nyw2ICs0Nyw3IEBAIHB1YmxpYzoKICAgICBi b29sIGhhc1VSTCgpIGNvbnN0IHsgcmV0dXJuICFtX3VybC5pc0VtcHR5KCkgJiYgbV91cmwuaXNW YWxpZCgpOyB9CiAgICAgYm9vbCBoYXNGaWxlbmFtZXMoKSBjb25zdCB7IHJldHVybiAhbV9maWxl bmFtZXMuaXNFbXB0eSgpOyB9CiAgICAgYm9vbCBoYXNJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIG1f aW1hZ2U7IH0KKyAgICBib29sIGNhblNtYXJ0UmVwbGFjZSgpIGNvbnN0IHsgcmV0dXJuIG1fY2Fu U21hcnRSZXBsYWNlOyB9CiAgICAgdm9pZCBjbGVhclVSSUxpc3QoKSB7IG1fdXJpTGlzdCA9IGVt cHR5U3RyaW5nKCk7IH0KICAgICB2b2lkIGNsZWFyVVJMKCkgeyBtX3VybCA9IFVSTCgpOyB9CiAg ICAgdm9pZCBjbGVhckltYWdlKCkgeyBtX2ltYWdlID0gbnVsbHB0cjsgfQpAQCAtNTksNiArNjAs NyBAQCBwdWJsaWM6CiAgICAgdm9pZCBzZXRNYXJrdXAoY29uc3QgU3RyaW5nJik7CiAgICAgdm9p ZCBzZXRVbmtub3duVHlwZURhdGEoY29uc3QgU3RyaW5nJiB0eXBlLCBjb25zdCBTdHJpbmcmIGRh dGEpIHsgbV91bmtub3duVHlwZURhdGEuc2V0KHR5cGUsIGRhdGEpOyB9CiAgICAgdm9pZCBzZXRV UklMaXN0KGNvbnN0IFN0cmluZyYpOworICAgIHZvaWQgc2V0Q2FuU21hcnRSZXBsYWNlKGJvb2wg Y2FuU21hcnRSZXBsYWNlKSB7IG1fY2FuU21hcnRSZXBsYWNlID0gY2FuU21hcnRSZXBsYWNlOyB9 CiAgICAgU3RyaW5nIHVybExhYmVsKCkgY29uc3Q7CiAKICAgICB2b2lkIGNsZWFyQWxsRXhjZXB0 RmlsZW5hbWVzKCk7CkBAIC03NCw2ICs3Niw3IEBAIHByaXZhdGU6CiAgICAgVmVjdG9yPFN0cmlu Zz4gbV9maWxlbmFtZXM7CiAgICAgR1JlZlB0cjxHZGtQaXhidWY+IG1faW1hZ2U7CiAgICAgSGFz aE1hcDxTdHJpbmcsIFN0cmluZz4gbV91bmtub3duVHlwZURhdGE7CisgICAgYm9vbCBtX2NhblNt YXJ0UmVwbGFjZSB7IGZhbHNlIH07CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEd0ay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ndGsvUGFzdGVib2FyZEd0ay5jcHAKaW5kZXggZDkxMGE5Mi4uYjcwMjc2NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRHdGsuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkR3RrLmNwcApAQCAtMjMsOSArMjMs MTAgQEAKICNpbmNsdWRlICJEYXRhT2JqZWN0R3RrLmgiCiAjaW5jbHVkZSAiRHJhZ0RhdGEuaCIK ICNpbmNsdWRlICJJbWFnZS5oIgorI2luY2x1ZGUgIlBhc3RlYm9hcmRTdHJhdGVneS5oIgorI2lu Y2x1ZGUgIlBsYXRmb3JtU3RyYXRlZ2llcy5oIgogI2luY2x1ZGUgIlVSTC5oIgotI2luY2x1ZGUg IlBhc3RlYm9hcmRIZWxwZXIuaCIKLSNpbmNsdWRlIDxndGsvZ3RrLmg+CisjaW5jbHVkZSA8d3Rm L05ldmVyRGVzdHJveWVkLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtNDAsMTIgKzQx LDEyIEBAIGVudW0gQ2xpcGJvYXJkRGF0YVR5cGUgewogCiBzdGQ6OnVuaXF1ZV9wdHI8UGFzdGVi b2FyZD4gUGFzdGVib2FyZDo6Y3JlYXRlRm9yQ29weUFuZFBhc3RlKCkKIHsKLSAgICByZXR1cm4g c3RkOjptYWtlX3VuaXF1ZTxQYXN0ZWJvYXJkPihndGtfY2xpcGJvYXJkX2dldChHREtfU0VMRUNU SU9OX0NMSVBCT0FSRCkpOworICAgIHJldHVybiBzdGQ6Om1ha2VfdW5pcXVlPFBhc3RlYm9hcmQ+ KCJDTElQQk9BUkQiKTsKIH0KIAogc3RkOjp1bmlxdWVfcHRyPFBhc3RlYm9hcmQ+IFBhc3RlYm9h cmQ6OmNyZWF0ZUZvckdsb2JhbFNlbGVjdGlvbigpCiB7Ci0gICAgcmV0dXJuIHN0ZDo6bWFrZV91 bmlxdWU8UGFzdGVib2FyZD4oZ3RrX2NsaXBib2FyZF9nZXQoR0RLX1NFTEVDVElPTl9QUklNQVJZ KSk7CisgICAgcmV0dXJuIHN0ZDo6bWFrZV91bmlxdWU8UGFzdGVib2FyZD4oIlBSSU1BUlkiKTsK IH0KIAogc3RkOjp1bmlxdWVfcHRyPFBhc3RlYm9hcmQ+IFBhc3RlYm9hcmQ6OmNyZWF0ZVByaXZh dGUoKQpAQCAtNzYsMTcgKzc3LDE0IEBAIFBhc3RlYm9hcmRJbWFnZTo6flBhc3RlYm9hcmRJbWFn ZSgpCiAKIFBhc3RlYm9hcmQ6OlBhc3RlYm9hcmQoUmVmUHRyPERhdGFPYmplY3RHdGs+JiYgZGF0 YU9iamVjdCkKICAgICA6IG1fZGF0YU9iamVjdChXVEZNb3ZlKGRhdGFPYmplY3QpKQotICAgICwg bV9ndGtDbGlwYm9hcmQobnVsbHB0cikKIHsKICAgICBBU1NFUlQobV9kYXRhT2JqZWN0KTsKIH0K IAotUGFzdGVib2FyZDo6UGFzdGVib2FyZChHdGtDbGlwYm9hcmQqIGd0a0NsaXBib2FyZCkKK1Bh c3RlYm9hcmQ6OlBhc3RlYm9hcmQoY29uc3QgU3RyaW5nJiBuYW1lKQogICAgIDogbV9kYXRhT2Jq ZWN0KERhdGFPYmplY3RHdGs6OmNyZWF0ZSgpKQotICAgICwgbV9ndGtDbGlwYm9hcmQoZ3RrQ2xp cGJvYXJkKQorICAgICwgbV9uYW1lKG5hbWUpCiB7Ci0gICAgQVNTRVJUKG1fZGF0YU9iamVjdCk7 Ci0gICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkucmVnaXN0ZXJDbGlwYm9hcmQoZ3Rr Q2xpcGJvYXJkKTsKIH0KIAogUGFzdGVib2FyZDo6flBhc3RlYm9hcmQoKQpAQCAtMTIxLDYgKzEx OSwyMSBAQCBzdGF0aWMgQ2xpcGJvYXJkRGF0YVR5cGUgZGF0YU9iamVjdFR5cGVGcm9tSFRNTENs aXBib2FyZFR5cGUoY29uc3QgU3RyaW5nJiByYXdUeQogICAgIHJldHVybiBDbGlwYm9hcmREYXRh VHlwZVVua25vd247CiB9CiAKK3ZvaWQgUGFzdGVib2FyZDo6d3JpdGVUb0NsaXBib2FyZChTaG91 bGRJbmNsdWRlU21hcnRQYXN0ZSBzaG91bGRJbmNsdWRlU21hcnRQYXN0ZSkKK3sKKyAgICBpZiAo bV9uYW1lLmlzTnVsbCgpKQorICAgICAgICByZXR1cm47CisgICAgbV9kYXRhT2JqZWN0LT5zZXRD YW5TbWFydFJlcGxhY2Uoc2hvdWxkSW5jbHVkZVNtYXJ0UGFzdGUgPT0gU2hvdWxkSW5jbHVkZVNt YXJ0UGFzdGU6Olllcyk7CisgICAgcGxhdGZvcm1TdHJhdGVnaWVzKCktPnBhc3RlYm9hcmRTdHJh dGVneSgpLT53cml0ZVRvQ2xpcGJvYXJkKG1fbmFtZSwgbV9kYXRhT2JqZWN0KTsKK30KKwordm9p ZCBQYXN0ZWJvYXJkOjpyZWFkRnJvbUNsaXBib2FyZCgpCit7CisgICAgaWYgKG1fbmFtZS5pc051 bGwoKSkKKyAgICAgICAgcmV0dXJuOworICAgIG1fZGF0YU9iamVjdCA9IHBsYXRmb3JtU3RyYXRl Z2llcygpLT5wYXN0ZWJvYXJkU3RyYXRlZ3koKS0+cmVhZEZyb21DbGlwYm9hcmQobV9uYW1lKTsK K30KKwogdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZVN0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUsIGNv bnN0IFN0cmluZyYgZGF0YSkKIHsKICAgICBzd2l0Y2ggKGRhdGFPYmplY3RUeXBlRnJvbUhUTUxD bGlwYm9hcmRUeXBlKHR5cGUpKSB7CkBAIC0xNDcsOCArMTYwLDcgQEAgdm9pZCBQYXN0ZWJvYXJk Ojp3cml0ZVBsYWluVGV4dChjb25zdCBTdHJpbmcmIHRleHQsIFNtYXJ0UmVwbGFjZU9wdGlvbiBz bWFydFJlcGwKICAgICBtX2RhdGFPYmplY3QtPmNsZWFyQWxsKCk7CiAgICAgbV9kYXRhT2JqZWN0 LT5zZXRUZXh0KHRleHQpOwogCi0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0 ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xp cGJvYXJkLCAqbV9kYXRhT2JqZWN0LCAoc21hcnRSZXBsYWNlT3B0aW9uID09IENhblNtYXJ0UmVw bGFjZSkgPyBQYXN0ZWJvYXJkSGVscGVyOjpJbmNsdWRlU21hcnRQYXN0ZSA6IFBhc3RlYm9hcmRI ZWxwZXI6OkRvTm90SW5jbHVkZVNtYXJ0UGFzdGUpOworICAgIHdyaXRlVG9DbGlwYm9hcmQoc21h cnRSZXBsYWNlT3B0aW9uID09IENhblNtYXJ0UmVwbGFjZSA/IFNob3VsZEluY2x1ZGVTbWFydFBh c3RlOjpZZXMgOiBTaG91bGRJbmNsdWRlU21hcnRQYXN0ZTo6Tm8pOwogfQogCiB2b2lkIFBhc3Rl Ym9hcmQ6OndyaXRlKGNvbnN0IFBhc3RlYm9hcmRVUkwmIHBhc3RlYm9hcmRVUkwpCkBAIC0xNTgs OCArMTcwLDcgQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZShjb25zdCBQYXN0ZWJvYXJkVVJMJiBw YXN0ZWJvYXJkVVJMKQogICAgIG1fZGF0YU9iamVjdC0+Y2xlYXJBbGwoKTsKICAgICBtX2RhdGFP YmplY3QtPnNldFVSTChwYXN0ZWJvYXJkVVJMLnVybCwgcGFzdGVib2FyZFVSTC50aXRsZSk7CiAK LSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmds ZXRvbigpLndyaXRlQ2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsICptX2RhdGFPYmpl Y3QpOworICAgIHdyaXRlVG9DbGlwYm9hcmQoKTsKIH0KIAogdm9pZCBQYXN0ZWJvYXJkOjp3cml0 ZShjb25zdCBQYXN0ZWJvYXJkSW1hZ2UmIHBhc3RlYm9hcmRJbWFnZSkKQEAgLTE3NCw4ICsxODUs NyBAQCB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlKGNvbnN0IFBhc3RlYm9hcmRJbWFnZSYgcGFzdGVi b2FyZEltYWdlKQogICAgIGlmIChwaXhidWYpCiAgICAgICAgIG1fZGF0YU9iamVjdC0+c2V0SW1h Z2UocGl4YnVmLmdldCgpKTsKIAotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFz dGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0Ns aXBib2FyZCwgKm1fZGF0YU9iamVjdCk7CisgICAgd3JpdGVUb0NsaXBib2FyZCgpOwogfQogCiB2 b2lkIFBhc3RlYm9hcmQ6OndyaXRlKGNvbnN0IFBhc3RlYm9hcmRXZWJDb250ZW50JiBwYXN0ZWJv YXJkQ29udGVudCkKQEAgLTE4NCw4ICsxOTQsNyBAQCB2b2lkIFBhc3RlYm9hcmQ6OndyaXRlKGNv bnN0IFBhc3RlYm9hcmRXZWJDb250ZW50JiBwYXN0ZWJvYXJkQ29udGVudCkKICAgICBtX2RhdGFP YmplY3QtPnNldFRleHQocGFzdGVib2FyZENvbnRlbnQudGV4dCk7CiAgICAgbV9kYXRhT2JqZWN0 LT5zZXRNYXJrdXAocGFzdGVib2FyZENvbnRlbnQubWFya3VwKTsKIAotICAgIGlmIChtX2d0a0Ns aXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlw Ym9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCwgcGFzdGVib2FyZENv bnRlbnQuY2FuU21hcnRDb3B5T3JEZWxldGUgPyBQYXN0ZWJvYXJkSGVscGVyOjpJbmNsdWRlU21h cnRQYXN0ZSA6IFBhc3RlYm9hcmRIZWxwZXI6OkRvTm90SW5jbHVkZVNtYXJ0UGFzdGUsIHBhc3Rl Ym9hcmRDb250ZW50LmNhbGxiYWNrLmdldCgpKTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJkKHBhc3Rl Ym9hcmRDb250ZW50LmNhblNtYXJ0Q29weU9yRGVsZXRlID8gU2hvdWxkSW5jbHVkZVNtYXJ0UGFz dGU6OlllcyA6IFNob3VsZEluY2x1ZGVTbWFydFBhc3RlOjpObyk7CiB9CiAKIHZvaWQgUGFzdGVi b2FyZDo6d3JpdGVQYXN0ZWJvYXJkKGNvbnN0IFBhc3RlYm9hcmQmIHNvdXJjZVBhc3RlYm9hcmQp CkBAIC0yMDgsOCArMjE3LDcgQEAgdm9pZCBQYXN0ZWJvYXJkOjp3cml0ZVBhc3RlYm9hcmQoY29u c3QgUGFzdGVib2FyZCYgc291cmNlUGFzdGVib2FyZCkKICAgICAgICAgICAgIG1fZGF0YU9iamVj dC0+c2V0VW5rbm93blR5cGVEYXRhKGl0LmtleSwgaXQudmFsdWUpOwogICAgIH0KIAotICAgIGlm IChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCku d3JpdGVDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCk7Cisg ICAgd3JpdGVUb0NsaXBib2FyZCgpOwogfQogCiB2b2lkIFBhc3RlYm9hcmQ6OmNsZWFyKCkKQEAg LTIxOSw5ICsyMjcsNyBAQCB2b2lkIFBhc3RlYm9hcmQ6OmNsZWFyKCkKICAgICAvLyBhdHRyaWJ1 dGUncyBsaXN0IG1pZ2h0IHN0aWxsIG5vdCBiZSBlbXB0eSBhZnRlciBjYWxsaW5nIGNsZWFyRGF0 YSgpIChpdCB3b3VsZAogICAgIC8vIHN0aWxsIGNvbnRhaW4gdGhlICJGaWxlcyIgc3RyaW5nIGlm IGFueSBmaWxlcyB3ZXJlIGluY2x1ZGVkIGluIHRoZSBkcmFnKS4iCiAgICAgbV9kYXRhT2JqZWN0 LT5jbGVhckFsbEV4Y2VwdEZpbGVuYW1lcygpOwotCi0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQot ICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRl bnRzKG1fZ3RrQ2xpcGJvYXJkLCAqbV9kYXRhT2JqZWN0KTsKKyAgICB3cml0ZVRvQ2xpcGJvYXJk KCk7CiB9CiAKIHZvaWQgUGFzdGVib2FyZDo6Y2xlYXIoY29uc3QgU3RyaW5nJiB0eXBlKQpAQCAt MjQ1LDEzICsyNTEsMTMgQEAgdm9pZCBQYXN0ZWJvYXJkOjpjbGVhcihjb25zdCBTdHJpbmcmIHR5 cGUpCiAgICAgICAgIGJyZWFrOwogICAgIH0KIAotICAgIGlmIChtX2d0a0NsaXBib2FyZCkKLSAg ICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCkud3JpdGVDbGlwYm9hcmRDb250ZW50 cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCk7CisgICAgd3JpdGVUb0NsaXBib2FyZCgp OwogfQogCiBib29sIFBhc3RlYm9hcmQ6OmNhblNtYXJ0UmVwbGFjZSgpCiB7Ci0gICAgcmV0dXJu IG1fZ3RrQ2xpcGJvYXJkICYmIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLmNsaXBib2Fy ZENvbnRlbnRTdXBwb3J0c1NtYXJ0UmVwbGFjZShtX2d0a0NsaXBib2FyZCk7CisgICAgcmVhZEZy b21DbGlwYm9hcmQoKTsKKyAgICByZXR1cm4gbV9kYXRhT2JqZWN0LT5jYW5TbWFydFJlcGxhY2Uo KTsKIH0KIAogI2lmIEVOQUJMRShEUkFHX1NVUFBPUlQpCkBAIC0yNjIsMjMgKzI2OCwxOSBAQCB2 b2lkIFBhc3RlYm9hcmQ6OnNldERyYWdJbWFnZShEcmFnSW1hZ2VSZWYsIGNvbnN0IEludFBvaW50 JikKIAogdm9pZCBQYXN0ZWJvYXJkOjpyZWFkKFBhc3RlYm9hcmRQbGFpblRleHQmIHRleHQpCiB7 Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJkKQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5n bGV0b24oKS5nZXRDbGlwYm9hcmRDb250ZW50cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVj dCk7CisgICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKICAgICB0ZXh0LnRleHQgPSBtX2RhdGFPYmpl Y3QtPnRleHQoKTsKIH0KIAogYm9vbCBQYXN0ZWJvYXJkOjpoYXNEYXRhKCkKIHsKLSAgICBpZiAo bV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRvbigpLmdl dENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkLCAqbV9kYXRhT2JqZWN0KTsKLQorICAg IHJlYWRGcm9tQ2xpcGJvYXJkKCk7CiAgICAgcmV0dXJuIG1fZGF0YU9iamVjdC0+aGFzVGV4dCgp IHx8IG1fZGF0YU9iamVjdC0+aGFzTWFya3VwKCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNVUklMaXN0 KCkgfHwgbV9kYXRhT2JqZWN0LT5oYXNJbWFnZSgpIHx8IG1fZGF0YU9iamVjdC0+aGFzVW5rbm93 blR5cGVEYXRhKCk7CiB9CiAKIFZlY3RvcjxTdHJpbmc+IFBhc3RlYm9hcmQ6OnR5cGVzKCkKIHsK LSAgICBpZiAobV9ndGtDbGlwYm9hcmQpCi0gICAgICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmds ZXRvbigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fZ3RrQ2xpcGJvYXJkLCAqbV9kYXRhT2JqZWN0 KTsKKyAgICByZWFkRnJvbUNsaXBib2FyZCgpOwogCiAgICAgVmVjdG9yPFN0cmluZz4gdHlwZXM7 CiAgICAgaWYgKG1fZGF0YU9iamVjdC0+aGFzVGV4dCgpKSB7CkBAIC0zMDYsOCArMzA4LDcgQEAg VmVjdG9yPFN0cmluZz4gUGFzdGVib2FyZDo6dHlwZXMoKQogCiBTdHJpbmcgUGFzdGVib2FyZDo6 cmVhZFN0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUpCiB7Ci0gICAgaWYgKG1fZ3RrQ2xpcGJvYXJk KQotICAgICAgICBQYXN0ZWJvYXJkSGVscGVyOjpzaW5nbGV0b24oKS5nZXRDbGlwYm9hcmRDb250 ZW50cyhtX2d0a0NsaXBib2FyZCwgKm1fZGF0YU9iamVjdCk7CisgICAgcmVhZEZyb21DbGlwYm9h cmQoKTsKIAogICAgIHN3aXRjaCAoZGF0YU9iamVjdFR5cGVGcm9tSFRNTENsaXBib2FyZFR5cGUo dHlwZSkpIHsKICAgICBjYXNlIENsaXBib2FyZERhdGFUeXBlVVJJTGlzdDoKQEAgLTMyOSw5ICsz MzAsNyBAQCBTdHJpbmcgUGFzdGVib2FyZDo6cmVhZFN0cmluZyhjb25zdCBTdHJpbmcmIHR5cGUp CiAKIFZlY3RvcjxTdHJpbmc+IFBhc3RlYm9hcmQ6OnJlYWRGaWxlbmFtZXMoKQogewotICAgIGlm IChtX2d0a0NsaXBib2FyZCkKLSAgICAgICAgUGFzdGVib2FyZEhlbHBlcjo6c2luZ2xldG9uKCku Z2V0Q2xpcGJvYXJkQ29udGVudHMobV9ndGtDbGlwYm9hcmQsICptX2RhdGFPYmplY3QpOwotCisg ICAgcmVhZEZyb21DbGlwYm9hcmQoKTsKICAgICByZXR1cm4gbV9kYXRhT2JqZWN0LT5maWxlbmFt ZXMoKTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3Rl Ym9hcmRIZWxwZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRI ZWxwZXIuY3BwCmluZGV4IDYyZDcwNWUuLmMzYjg1NzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhlbHBlci5jcHAKQEAgLTc2LDggKzc2LDYgQEAgUGFz dGVib2FyZEhlbHBlcjo6UGFzdGVib2FyZEhlbHBlcigpCiAKIFBhc3RlYm9hcmRIZWxwZXI6On5Q YXN0ZWJvYXJkSGVscGVyKCkKIHsKLSAgICBmb3IgKGF1dG8qIGNsaXBib2FyZCA6IG1fZ3RrQ2xp cGJvYXJkcykKLSAgICAgICAgZ3RrX2NsaXBib2FyZF9zdG9yZShjbGlwYm9hcmQpOwogfQogCiBH dGtUYXJnZXRMaXN0KiBQYXN0ZWJvYXJkSGVscGVyOjp0YXJnZXRMaXN0KCkgY29uc3QKQEAgLTEx NSw2ICsxMTMsOCBAQCB2b2lkIFBhc3RlYm9hcmRIZWxwZXI6OmdldENsaXBib2FyZENvbnRlbnRz KEd0a0NsaXBib2FyZCogY2xpcGJvYXJkLCBEYXRhT2JqZWN0RwogICAgICAgICAgICAgZ3RrX3Nl bGVjdGlvbl9kYXRhX2ZyZWUoZGF0YSk7CiAgICAgICAgIH0KICAgICB9CisKKyAgICBkYXRhT2Jq ZWN0LnNldENhblNtYXJ0UmVwbGFjZShndGtfY2xpcGJvYXJkX3dhaXRfaXNfdGFyZ2V0X2F2YWls YWJsZShjbGlwYm9hcmQsIHNtYXJ0UGFzdGVBdG9tKSk7CiB9CiAKIHZvaWQgUGFzdGVib2FyZEhl bHBlcjo6ZmlsbFNlbGVjdGlvbkRhdGEoR3RrU2VsZWN0aW9uRGF0YSogc2VsZWN0aW9uRGF0YSwg Z3VpbnQgaW5mbywgY29uc3QgRGF0YU9iamVjdEd0ayYgZGF0YU9iamVjdCkKQEAgLTE2OSw3ICsx NjksNyBAQCB2b2lkIFBhc3RlYm9hcmRIZWxwZXI6OmZpbGxTZWxlY3Rpb25EYXRhKEd0a1NlbGVj dGlvbkRhdGEqIHNlbGVjdGlvbkRhdGEsIGd1aW50CiAgICAgfQogfQogCi1HUmVmUHRyPEd0a1Rh cmdldExpc3Q+IFBhc3RlYm9hcmRIZWxwZXI6OnRhcmdldExpc3RGb3JEYXRhT2JqZWN0KGNvbnN0 IERhdGFPYmplY3RHdGsmIGRhdGFPYmplY3QsIFNtYXJ0UGFzdGVJbmNsdXNpb24gc2hvdWxkSW5s dWRlU21hcnRQYXN0ZSkKK0dSZWZQdHI8R3RrVGFyZ2V0TGlzdD4gUGFzdGVib2FyZEhlbHBlcjo6 dGFyZ2V0TGlzdEZvckRhdGFPYmplY3QoY29uc3QgRGF0YU9iamVjdEd0ayYgZGF0YU9iamVjdCkK IHsKICAgICBHUmVmUHRyPEd0a1RhcmdldExpc3Q+IGxpc3QgPSBhZG9wdEdSZWYoZ3RrX3Rhcmdl dF9saXN0X25ldyhudWxscHRyLCAwKSk7CiAKQEAgLTE5MCw3ICsxOTAsNyBAQCBHUmVmUHRyPEd0 a1RhcmdldExpc3Q+IFBhc3RlYm9hcmRIZWxwZXI6OnRhcmdldExpc3RGb3JEYXRhT2JqZWN0KGNv bnN0IERhdGFPYmplYwogICAgIGlmIChkYXRhT2JqZWN0Lmhhc1Vua25vd25UeXBlRGF0YSgpKQog ICAgICAgICBndGtfdGFyZ2V0X2xpc3RfYWRkKGxpc3QuZ2V0KCksIHVua25vd25BdG9tLCAwLCBU YXJnZXRUeXBlVW5rbm93bik7CiAKLSAgICBpZiAoc2hvdWxkSW5sdWRlU21hcnRQYXN0ZSA9PSBJ bmNsdWRlU21hcnRQYXN0ZSkKKyAgICBpZiAoZGF0YU9iamVjdC5jYW5TbWFydFJlcGxhY2UoKSkK ICAgICAgICAgZ3RrX3RhcmdldF9saXN0X2FkZChsaXN0LmdldCgpLCBzbWFydFBhc3RlQXRvbSwg MCwgVGFyZ2V0VHlwZVNtYXJ0UGFzdGUpOwogCiAgICAgcmV0dXJuIGxpc3Q7CkBAIC0yNTcsOSAr MjU3LDkgQEAgVmVjdG9yPEdka0F0b20+IFBhc3RlYm9hcmRIZWxwZXI6OmRyb3BBdG9tc0ZvckNv bnRleHQoR3RrV2lkZ2V0KiB3aWRnZXQsIEdka0RyYWcKIHN0YXRpYyBEYXRhT2JqZWN0R3RrKiBz ZXR0aW5nQ2xpcGJvYXJkRGF0YU9iamVjdCA9IDA7CiAKIHN0cnVjdCBDbGlwYm9hcmRTZXREYXRh IHsKLSAgICBDbGlwYm9hcmRTZXREYXRhKERhdGFPYmplY3RHdGsqIGRhdGFPYmplY3QsIEdDbG9z dXJlKiBjYWxsYmFjaykKKyAgICBDbGlwYm9hcmRTZXREYXRhKERhdGFPYmplY3RHdGsqIGRhdGFP YmplY3QsIHN0ZDo6ZnVuY3Rpb248dm9pZCgpPiYmIHNlbGVjdGlvbkNsZWFyZWRDYWxsYmFjaykK ICAgICAgICAgOiBkYXRhT2JqZWN0KGRhdGFPYmplY3QpCi0gICAgICAgICwgY2FsbGJhY2soY2Fs bGJhY2spCisgICAgICAgICwgc2VsZWN0aW9uQ2xlYXJlZENhbGxiYWNrKFdURk1vdmUoc2VsZWN0 aW9uQ2xlYXJlZENhbGxiYWNrKSkKICAgICB7CiAgICAgfQogCkBAIC0yNjgsNyArMjY4LDcgQEAg c3RydWN0IENsaXBib2FyZFNldERhdGEgewogICAgIH0KIAogICAgIFJlZlB0cjxEYXRhT2JqZWN0 R3RrPiBkYXRhT2JqZWN0OwotICAgIEdSZWZQdHI8R0Nsb3N1cmU+IGNhbGxiYWNrOworICAgIHN0 ZDo6ZnVuY3Rpb248dm9pZCgpPiBzZWxlY3Rpb25DbGVhcmVkQ2FsbGJhY2s7CiB9OwogCiBzdGF0 aWMgdm9pZCBnZXRDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrKEd0a0NsaXBib2FyZCosIEd0a1Nl bGVjdGlvbkRhdGEgKnNlbGVjdGlvbkRhdGEsIGd1aW50IGluZm8sIGdwb2ludGVyIHVzZXJEYXRh KQpAQCAtMjc3LDcgKzI3Nyw3IEBAIHN0YXRpYyB2b2lkIGdldENsaXBib2FyZENvbnRlbnRzQ2Fs bGJhY2soR3RrQ2xpcGJvYXJkKiwgR3RrU2VsZWN0aW9uRGF0YSAqc2VsZWN0CiAgICAgUGFzdGVi b2FyZEhlbHBlcjo6c2luZ2xldG9uKCkuZmlsbFNlbGVjdGlvbkRhdGEoc2VsZWN0aW9uRGF0YSwg aW5mbywgKmRhdGEtPmRhdGFPYmplY3QpOwogfQogCi1zdGF0aWMgdm9pZCBjbGVhckNsaXBib2Fy ZENvbnRlbnRzQ2FsbGJhY2soR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQsIGdwb2ludGVyIHVzZXJE YXRhKQorc3RhdGljIHZvaWQgY2xlYXJDbGlwYm9hcmRDb250ZW50c0NhbGxiYWNrKEd0a0NsaXBi b2FyZCosIGdwb2ludGVyIHVzZXJEYXRhKQogewogICAgIHN0ZDo6dW5pcXVlX3B0cjxDbGlwYm9h cmRTZXREYXRhPiBkYXRhKHN0YXRpY19jYXN0PENsaXBib2FyZFNldERhdGEqPih1c2VyRGF0YSkp OwogCkBAIC0yODUsMTggKzI4NSwxMyBAQCBzdGF0aWMgdm9pZCBjbGVhckNsaXBib2FyZENvbnRl bnRzQ2FsbGJhY2soR3RrQ2xpcGJvYXJkKiBjbGlwYm9hcmQsIGdwb2ludGVyIHVzZQogICAgIGlm IChkYXRhLT5kYXRhT2JqZWN0LmdldCgpICE9IHNldHRpbmdDbGlwYm9hcmREYXRhT2JqZWN0KQog ICAgICAgICBkYXRhLT5kYXRhT2JqZWN0LT5jbGVhckFsbCgpOwogCi0gICAgaWYgKCFkYXRhLT5j YWxsYmFjaykKLSAgICAgICAgcmV0dXJuOwotCi0gICAgR1ZhbHVlIGZpcnN0QXJndW1lbnQgPSB7 MCwge3swfX19OwotICAgIGdfdmFsdWVfaW5pdCgmZmlyc3RBcmd1bWVudCwgR19UWVBFX1BPSU5U RVIpOwotICAgIGdfdmFsdWVfc2V0X3BvaW50ZXIoJmZpcnN0QXJndW1lbnQsIGNsaXBib2FyZCk7 Ci0gICAgZ19jbG9zdXJlX2ludm9rZShkYXRhLT5jYWxsYmFjay5nZXQoKSwgbnVsbHB0ciwgMSwg JmZpcnN0QXJndW1lbnQsIDApOworICAgIGlmIChkYXRhLT5zZWxlY3Rpb25DbGVhcmVkQ2FsbGJh Y2spCisgICAgICAgIGRhdGEtPnNlbGVjdGlvbkNsZWFyZWRDYWxsYmFjaygpOwogfQogCi12b2lk IFBhc3RlYm9hcmRIZWxwZXI6OndyaXRlQ2xpcGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiBj bGlwYm9hcmQsIGNvbnN0IERhdGFPYmplY3RHdGsmIGRhdGFPYmplY3QsIFNtYXJ0UGFzdGVJbmNs dXNpb24gaW5jbHVkZVNtYXJ0UGFzdGUsIEdDbG9zdXJlKiBjYWxsYmFjaykKK3ZvaWQgUGFzdGVi b2FyZEhlbHBlcjo6d3JpdGVDbGlwYm9hcmRDb250ZW50cyhHdGtDbGlwYm9hcmQqIGNsaXBib2Fy ZCwgY29uc3QgRGF0YU9iamVjdEd0ayYgZGF0YU9iamVjdCwgc3RkOjpmdW5jdGlvbjx2b2lkKCk+ JiYgcHJpbWFyeVNlbGVjdGlvbkNsZWFyZWQpCiB7Ci0gICAgR1JlZlB0cjxHdGtUYXJnZXRMaXN0 PiBsaXN0ID0gdGFyZ2V0TGlzdEZvckRhdGFPYmplY3QoZGF0YU9iamVjdCwgaW5jbHVkZVNtYXJ0 UGFzdGUpOworICAgIEdSZWZQdHI8R3RrVGFyZ2V0TGlzdD4gbGlzdCA9IHRhcmdldExpc3RGb3JE YXRhT2JqZWN0KGRhdGFPYmplY3QpOwogCiAgICAgaW50IG51bWJlck9mVGFyZ2V0czsKICAgICBH dGtUYXJnZXRFbnRyeSogdGFibGUgPSBndGtfdGFyZ2V0X3RhYmxlX25ld19mcm9tX2xpc3QobGlz dC5nZXQoKSwgJm51bWJlck9mVGFyZ2V0cyk7CkBAIC0zMDQsNyArMjk5LDcgQEAgdm9pZCBQYXN0 ZWJvYXJkSGVscGVyOjp3cml0ZUNsaXBib2FyZENvbnRlbnRzKEd0a0NsaXBib2FyZCogY2xpcGJv YXJkLCBjb25zdCBEYXQKICAgICBpZiAobnVtYmVyT2ZUYXJnZXRzID4gMCAmJiB0YWJsZSkgewog ICAgICAgICBzZXR0aW5nQ2xpcGJvYXJkRGF0YU9iamVjdCA9IGNvbnN0X2Nhc3Q8RGF0YU9iamVj dEd0ayo+KCZkYXRhT2JqZWN0KTsKIAotICAgICAgICBhdXRvIGRhdGEgPSBzdGQ6Om1ha2VfdW5p cXVlPENsaXBib2FyZFNldERhdGE+KHNldHRpbmdDbGlwYm9hcmREYXRhT2JqZWN0LCBjYWxsYmFj ayk7CisgICAgICAgIGF1dG8gZGF0YSA9IHN0ZDo6bWFrZV91bmlxdWU8Q2xpcGJvYXJkU2V0RGF0 YT4oc2V0dGluZ0NsaXBib2FyZERhdGFPYmplY3QsIFdURk1vdmUocHJpbWFyeVNlbGVjdGlvbkNs ZWFyZWQpKTsKICAgICAgICAgaWYgKGd0a19jbGlwYm9hcmRfc2V0X3dpdGhfZGF0YShjbGlwYm9h cmQsIHRhYmxlLCBudW1iZXJPZlRhcmdldHMsIGdldENsaXBib2FyZENvbnRlbnRzQ2FsbGJhY2ss IGNsZWFyQ2xpcGJvYXJkQ29udGVudHNDYWxsYmFjaywgZGF0YS5nZXQoKSkpIHsKICAgICAgICAg ICAgIGd0a19jbGlwYm9hcmRfc2V0X2Nhbl9zdG9yZShjbGlwYm9hcmQsIG51bGxwdHIsIDApOwog ICAgICAgICAgICAgLy8gV2hlbiBndGtfY2xpcGJvYXJkX3NldF93aXRoX2RhdGEgZmFpbHMgdGhl IGNhbGxiYWNrcyBhcmUgaWdub3JlZCwgc28gd2UgbmVlZCB0byBsZWFrIHRoZSBkYXRhIHdlIHdl cmUgcGFzc2luZyB0byBjbGVhckNsaXBib2FyZENvbnRlbnRzQ2FsbGJhY2suCkBAIC0zMTksMTYg KzMxNCw1IEBAIHZvaWQgUGFzdGVib2FyZEhlbHBlcjo6d3JpdGVDbGlwYm9hcmRDb250ZW50cyhH dGtDbGlwYm9hcmQqIGNsaXBib2FyZCwgY29uc3QgRGF0CiAgICAgICAgIGd0a190YXJnZXRfdGFi bGVfZnJlZSh0YWJsZSwgbnVtYmVyT2ZUYXJnZXRzKTsKIH0KIAotYm9vbCBQYXN0ZWJvYXJkSGVs cGVyOjpjbGlwYm9hcmRDb250ZW50U3VwcG9ydHNTbWFydFJlcGxhY2UoR3RrQ2xpcGJvYXJkKiBj bGlwYm9hcmQpCi17Ci0gICAgcmV0dXJuIGd0a19jbGlwYm9hcmRfd2FpdF9pc190YXJnZXRfYXZh aWxhYmxlKGNsaXBib2FyZCwgc21hcnRQYXN0ZUF0b20pOwotfQotCi12b2lkIFBhc3RlYm9hcmRI ZWxwZXI6OnJlZ2lzdGVyQ2xpcGJvYXJkKEd0a0NsaXBib2FyZCogY2xpcGJvYXJkKQotewotICAg IEFTU0VSVChjbGlwYm9hcmQpOwotICAgIG1fZ3RrQ2xpcGJvYXJkcy5hZGQoY2xpcGJvYXJkKTsK LX0KLQogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGFzdGVi b2FyZEhlbHBlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3RrL1Bhc3RlYm9hcmRIZWxw ZXIuaAppbmRleCBhN2ZhN2Q2Li5iMTVmYmVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ndGsvUGFzdGVib2FyZEhlbHBlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2d0ay9QYXN0ZWJvYXJkSGVscGVyLmgKQEAgLTI2LDcgKzI2LDYgQEAKICNkZWZpbmUgUGFz dGVib2FyZEhlbHBlcl9oCiAKICNpbmNsdWRlICJHUmVmUHRyR3RrLmgiCi0jaW5jbHVkZSA8d3Rm L0hhc2hTZXQuaD4KICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYv VmVjdG9yLmg+CiAjaW5jbHVkZSA8d3RmL2dsaWIvR1JlZlB0ci5oPgpAQCAtNDMsMjQgKzQyLDIw IEBAIHB1YmxpYzoKICAgICBlbnVtIFNtYXJ0UGFzdGVJbmNsdXNpb24geyBJbmNsdWRlU21hcnRQ YXN0ZSwgRG9Ob3RJbmNsdWRlU21hcnRQYXN0ZSB9OwogCiAgICAgR3RrVGFyZ2V0TGlzdCogdGFy Z2V0TGlzdCgpIGNvbnN0OwotICAgIEdSZWZQdHI8R3RrVGFyZ2V0TGlzdD4gdGFyZ2V0TGlzdEZv ckRhdGFPYmplY3QoY29uc3QgRGF0YU9iamVjdEd0ayYsIFNtYXJ0UGFzdGVJbmNsdXNpb24gPSBE b05vdEluY2x1ZGVTbWFydFBhc3RlKTsKKyAgICBHUmVmUHRyPEd0a1RhcmdldExpc3Q+IHRhcmdl dExpc3RGb3JEYXRhT2JqZWN0KGNvbnN0IERhdGFPYmplY3RHdGsmKTsKICAgICB2b2lkIGZpbGxT ZWxlY3Rpb25EYXRhKEd0a1NlbGVjdGlvbkRhdGEqLCBndWludCwgY29uc3QgRGF0YU9iamVjdEd0 ayYpOwogICAgIHZvaWQgZmlsbERhdGFPYmplY3RGcm9tRHJvcERhdGEoR3RrU2VsZWN0aW9uRGF0 YSosIGd1aW50LCBEYXRhT2JqZWN0R3RrJik7CiAgICAgVmVjdG9yPEdka0F0b20+IGRyb3BBdG9t c0ZvckNvbnRleHQoR3RrV2lkZ2V0KiwgR2RrRHJhZ0NvbnRleHQqKTsKLSAgICB2b2lkIHdyaXRl Q2xpcGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiwgY29uc3QgRGF0YU9iamVjdEd0ayYsIFNt YXJ0UGFzdGVJbmNsdXNpb24gPSBEb05vdEluY2x1ZGVTbWFydFBhc3RlLCBHQ2xvc3VyZSogPSAw KTsKKyAgICB2b2lkIHdyaXRlQ2xpcGJvYXJkQ29udGVudHMoR3RrQ2xpcGJvYXJkKiwgY29uc3Qg RGF0YU9iamVjdEd0ayYsIHN0ZDo6ZnVuY3Rpb248dm9pZCgpPiYmIHByaW1hcnlTZWxlY3Rpb25D bGVhcmVkID0gbnVsbHB0cik7CiAgICAgdm9pZCBnZXRDbGlwYm9hcmRDb250ZW50cyhHdGtDbGlw Ym9hcmQqLCBEYXRhT2JqZWN0R3RrJik7CiAKICAgICBlbnVtIFBhc3RlYm9hcmRUYXJnZXRUeXBl IHsgVGFyZ2V0VHlwZU1hcmt1cCwgVGFyZ2V0VHlwZVRleHQsIFRhcmdldFR5cGVJbWFnZSwgVGFy Z2V0VHlwZVVSSUxpc3QsIFRhcmdldFR5cGVOZXRzY2FwZVVSTCwgVGFyZ2V0VHlwZVNtYXJ0UGFz dGUsIFRhcmdldFR5cGVVbmtub3duIH07Ci0gICAgYm9vbCBjbGlwYm9hcmRDb250ZW50U3VwcG9y dHNTbWFydFJlcGxhY2UoR3RrQ2xpcGJvYXJkKik7Ci0KLSAgICB2b2lkIHJlZ2lzdGVyQ2xpcGJv YXJkKEd0a0NsaXBib2FyZCopOwogCiBwcml2YXRlOgogICAgIFBhc3RlYm9hcmRIZWxwZXIoKTsK ICAgICB+UGFzdGVib2FyZEhlbHBlcigpOwogCiAgICAgR1JlZlB0cjxHdGtUYXJnZXRMaXN0PiBt X3RhcmdldExpc3Q7Ci0gICAgSGFzaFNldDxHdGtDbGlwYm9hcmQqPiBtX2d0a0NsaXBib2FyZHM7 CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGxhdGZv cm1QYXN0ZWJvYXJkR3RrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2d0ay9QbGF0Zm9y bVBhc3RlYm9hcmRHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI3 Y2JlYWQKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ndGsvUGxh dGZvcm1QYXN0ZWJvYXJkR3RrLmNwcApAQCAtMCwwICsxLDQ5IEBACisvKgorICogIENvcHlyaWdo dCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRl ciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAq ICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZ IG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwg UHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0 ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGlu IFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisK KyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVBhc3RlYm9hcmQuaCIKKwor I2luY2x1ZGUgIkNvbG9yLmgiCisjaW5jbHVkZSAiRGF0YU9iamVjdEd0ay5oIgorI2luY2x1ZGUg IlBhc3RlYm9hcmRIZWxwZXIuaCIKKyNpbmNsdWRlICJTaGFyZWRCdWZmZXIuaCIKKyNpbmNsdWRl ICJVUkwuaCIKKyNpbmNsdWRlIDxndGsvZ3RrLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor UGxhdGZvcm1QYXN0ZWJvYXJkOjpQbGF0Zm9ybVBhc3RlYm9hcmQoY29uc3QgU3RyaW5nJiBwYXN0 ZWJvYXJkTmFtZSkKKyAgICA6IG1fY2xpcGJvYXJkKGd0a19jbGlwYm9hcmRfZ2V0KGdka19hdG9t X2ludGVybihwYXN0ZWJvYXJkTmFtZS51dGY4KCkuZGF0YSgpLCBUUlVFKSkpCit7CisgICAgQVNT RVJUKG1fY2xpcGJvYXJkKTsKK30KKwordm9pZCBQbGF0Zm9ybVBhc3RlYm9hcmQ6OndyaXRlVG9D bGlwYm9hcmQoY29uc3QgUmVmUHRyPERhdGFPYmplY3RHdGs+JiBkYXRhT2JqZWN0LCBzdGQ6OmZ1 bmN0aW9uPHZvaWQoKT4mJiBwcmltYXJ5U2VsZWN0aW9uQ2xlYXJlZCkKK3sKKyAgICBQYXN0ZWJv YXJkSGVscGVyOjpzaW5nbGV0b24oKS53cml0ZUNsaXBib2FyZENvbnRlbnRzKG1fY2xpcGJvYXJk LCAqZGF0YU9iamVjdCwgZ3RrX2NsaXBib2FyZF9nZXQoR0RLX1NFTEVDVElPTl9QUklNQVJZKSA9 PSBtX2NsaXBib2FyZCA/IFdURk1vdmUocHJpbWFyeVNlbGVjdGlvbkNsZWFyZWQpIDogbnVsbHB0 cik7Cit9CisKK1JlZlB0cjxEYXRhT2JqZWN0R3RrPiBQbGF0Zm9ybVBhc3RlYm9hcmQ6OnJlYWRG cm9tQ2xpcGJvYXJkKCkKK3sKKyAgICBSZWZQdHI8RGF0YU9iamVjdEd0az4gZGF0YU9iamVjdCA9 IERhdGFPYmplY3RHdGs6OmNyZWF0ZSgpOworICAgIFBhc3RlYm9hcmRIZWxwZXI6OnNpbmdsZXRv bigpLmdldENsaXBib2FyZENvbnRlbnRzKG1fY2xpcGJvYXJkLCAqZGF0YU9iamVjdCk7CisgICAg cmV0dXJuIGRhdGFPYmplY3Q7Cit9CisKK30KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwppbmRleCA3NzA5ZmE2Li4xNDJkOTcx IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNjggQEAKKzIwMTYtMDktMTQgIENhcmxvcyBHYXJuYWNo byAgPGNhcmxvc2dAZ25vbWUub3JnPgorCisgICAgICAgIFtHVEtdW1dheWxhbmRdIEltcGxlbWVu dCBjbGlwYm9hcmQgc3VwcG9ydAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTQ2NTc0CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkIHRoZSBuZWNlc3NhcnkgcGx1bWJpbmcgZm9yIHRoZSBHVEsrIGJhY2tl bmQgdG8gdXNlIHRoZQorICAgICAgICBQbGF0Zm9ybVBhc3RlYm9hcmQgaW4gV2ViQ29yZS4gQWxs IHNlbGVjdGlvbiBkYXRhIGlzIHRyYW5zbWl0dGVkCisgICAgICAgIGF0IG9uY2UgdGhyb3VnaCB0 aGUgc2VyaWFsaXphdGlvbiBvZiBQYXN0ZWJvYXJkQ29udGVudEd0ay9EYXRhT2JqZWN0R3RrLgor CisgICAgICAgICogUGxhdGZvcm1HVEsuY21ha2U6IEFkZCBQYXN0ZWJvYXJkQ29udGVudEd0ay5j cHAgYW5kCisgICAgICAgIFdlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKKyAgICAgICAgKiBTaGFy ZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcDoKKyAgICAgICAgKElQQzo6ZW5jb2RlKToKKyAg ICAgICAgKElQQzo6ZGVjb2RlKTogUmVuYW1lZCBmcm9tIGVuY29kZURhdGFPYmplY3QvZGVjb2Rl RGF0YU9iamVjdAorICAgICAgICBhbmQgbWFkZSBwdWJsaWMuCisgICAgICAgIChJUEM6OkFyZ3Vt ZW50Q29kZXI8RHJhZ0RhdGE+OjplbmNvZGUpOgorICAgICAgICAoSVBDOjpBcmd1bWVudENvZGVy PERyYWdEYXRhPjo6ZGVjb2RlKTogVXBkYXRlIERhdGFPYmplY3RHdGsKKyAgICAgICAgZW5jb2Rl L2RlY29kZSBjYWxsZXJzLiBFbmNvZGUgdGhlIGV4dHJhIGNhblNtYXJ0UmVwbGFjZSBmaWVsZC4K KyAgICAgICAgKiBTaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmg6IEV4cG9zZSBlbmNvZGUv ZGVjb2RlIG1ldGhvZHMgZm9yCisgICAgICAgIERhdGFPYmplY3RHdGsuCisgICAgICAgICogU2hh cmVkL2d0ay9QYXN0ZWJvYXJkQ29udGVudC5jcHA6IEFkZGVkLiBXcmFwcyBhIERhdGFPYmplY3RH dGsKKyAgICAgICAgc28gaXQgY2FuIGJlIHNlcmlhbGl6ZWQgb24gV2ViUHJvY2Vzcy9VSVByb2Nl c3MgbWVzc2FnaW5nLgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudDo6UGFzdGVi b2FyZENvbnRlbnQpOgorICAgICAgICAoV2ViS2l0OjpQYXN0ZWJvYXJkQ29udGVudDo6ZW5jb2Rl KToKKyAgICAgICAgKFdlYktpdDo6UGFzdGVib2FyZENvbnRlbnQ6OmRlY29kZSk6IE1ldGhvZHMg dG8gZW5jb2RlL2RlY29kZSBhCisgICAgICAgIFBhc3RlYm9hcmRDb250ZW50LgorICAgICAgICAq IFNoYXJlZC9ndGsvUGFzdGVib2FyZENvbnRlbnQuaDogQWRkZWQuCisgICAgICAgICogVUlQcm9j ZXNzL1dlYkZyYW1lUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJGcmFtZVByb3h5Ojpj b2xsYXBzZVNlbGVjdGlvbik6IEFkZGVkIHBsdW1iaW5nIHRvIGFsbG93CisgICAgICAgIGNvbGxh cHNpbmcgdGhlIGdsb2JhbCBzZWxlY3Rpb24gZnJvbSB0aGUgVUkgcHJvY2VzcyBzaWRlLgorICAg ICAgICAqIFVJUHJvY2Vzcy9XZWJGcmFtZVByb3h5Lmg6CisgICAgICAgICogVUlQcm9jZXNzL1dl YlBhc3RlYm9hcmRQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJv eHkubWVzc2FnZXMuaW46IEFkZGVkIHBsdW1iaW5nIGZvciB0aGUKKyAgICAgICAgR1RLKyBwYXN0 ZWJvYXJkIHByb3h5IGZ1bmN0aW9ucy4KKyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQ cm94eUd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6ZWRpdG9yU3RhdGVD aGFuZ2VkKToKKyAgICAgICAgKiBVSVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5j cHA6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OndyaXRlVG9D bGlwYm9hcmQpOgorICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OnJlYWRGcm9t Q2xpcGJvYXJkKTogSW1wbGVtZW50ZWQgZnVuY3Rpb25zCisgICAgICAgIGhvb2tpbmcgaW50byB0 aGUgUGxhdGZvcm1QYXN0ZWJvYXJkLiBQZXItc2VsZWN0aW9uIChpZS4KKyAgICAgICAgcHJpbWFy eS9jbGlwYm9hcmQpIFBsYXRmb3JtUGFzdGVib2FyZHMgYXJlIGtlcHQgYXQgdGhpcyBsZXZlbCwg c28gdGhvc2UKKyAgICAgICAgYXJlIGluZGVwZW5kZW50bHkgc2V0IGFuZCBkZWFsdCB3aXRoLgor ICAgICAgICAoV2ViS2l0OjpXZWJQYXN0ZWJvYXJkUHJveHk6OnNldFByaW1hcnlTZWxlY3Rpb25P d25lcik6CisgICAgICAgIChXZWJLaXQ6OldlYlBhc3RlYm9hcmRQcm94eTo6ZGlkRGVzdHJveUZy YW1lKTogSW1wbGVtZW50ZWQgZnVuY3Rpb25zCisgICAgICAgIHRvIG1hbmFnZSB0aGUgZnJhbWUg Y3VycmVudGx5IGJlaW5nIGN1cnJlbnRseSBpbnRlcmFjdGVkLCBzbyB3ZSBjYW4KKyAgICAgICAg c2lnbmFsIGJhY2sgd2hlbiB0aGUgZ2xvYmFsIHNlbGVjdGlvbiBoYXMgYmVlbiByZXBsYWNlZC4K KyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2ll cy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6d3JpdGVUb0Ns aXBib2FyZCk6CisgICAgICAgIChXZWJLaXQ6OldlYlBsYXRmb3JtU3RyYXRlZ2llczo6cmVhZEZy b21DbGlwYm9hcmQpOiBBZGRlZCBtZXRob2RzIHRvCisgICAgICAgIHNlbmQgdGhlIFdlYlByb2Nl c3MtPlVJUHJvY2VzcyBtZXNzYWdlcy4KKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYkNvcmVTdXBw b3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViQ29y ZVN1cHBvcnQvZ3RrL1dlYkVkaXRvckNsaWVudEd0ay5jcHA6CisgICAgICAgIChXZWJLaXQ6Oldl YkVkaXRvckNsaWVudDo6dXBkYXRlR2xvYmFsU2VsZWN0aW9uKTogUmVtb3ZlIEdDbG9zdXJlIHRv CisgICAgICAgIGdldCBub3RpZmljYXRpb25zIGFib3V0IGNoYW5nZXMgaW4gZ2xvYmFsIHNlbGVj dGlvbiBvd25lcnNoaXAuIFRoaXMKKyAgICAgICAgaXMgZG9uZSB0aHJvdWdoIGEgV2ViUGFnZSBt ZXNzYWdlIG5vdywgYXMgdGhlIFVJIHByb2Nlc3MgbWFuYWdlcyB0aGUKKyAgICAgICAgY2xpcGJv YXJkLgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmg6CisgICAgICAgICog V2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW46CisgICAgICAgICogV2ViUHJv Y2Vzcy9XZWJQYWdlL2d0ay9XZWJQYWdlR3RrLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFn ZTo6Y29sbGFwc2VTZWxlY3Rpb25JbkZyYW1lKTogQWRkZWQgbWV0aG9kcyB0byBzZW5kCisgICAg ICAgIHRoZSBVSVByb2Nlc3MtPldlYlByb2Nlc3Mgbm90aWZpY2F0aW9uIHRoYXQgdGhlIGdsb2Jh bCBzZWxlY3Rpb24gaGFzCisgICAgICAgIGJlZW4gcmVwbGFjZWQuCisKIDIwMTYtMDktMTMgIENh cmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtd IEdldCByaWQgb2YgRGF0YU9iamVjdEd0azo6Zm9yQ2xpcGJvYXJkIGFuZCBjbGVhbnVwIHBhc3Rl Ym9hcmQgY29kZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21ha2Ug Yi9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBlNjQwNjAzLi5jZTJiYWFm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtNzEsNiArNzEsNyBAQCBsaXN0KEFQUEVO RCBXZWJLaXQyX1NPVVJDRVMKICAgICBTaGFyZWQvZ3RrL05hdGl2ZVdlYk1vdXNlRXZlbnRHdGsu Y3BwCiAgICAgU2hhcmVkL2d0ay9OYXRpdmVXZWJUb3VjaEV2ZW50R3RrLmNwcAogICAgIFNoYXJl ZC9ndGsvTmF0aXZlV2ViV2hlZWxFdmVudEd0ay5jcHAKKyAgICBTaGFyZWQvZ3RrL1Bhc3RlYm9h cmRDb250ZW50LmNwcAogICAgIFNoYXJlZC9ndGsvUHJpbnRJbmZvR3RrLmNwcAogICAgIFNoYXJl ZC9ndGsvUHJvY2Vzc0V4ZWN1dGFibGVQYXRoR3RrLmNwcAogICAgIFNoYXJlZC9ndGsvV2ViQ29u dGV4dE1lbnVJdGVtR3RrLmNwcApAQCAtMzEzLDYgKzMxNCw3IEBAIGxpc3QoQVBQRU5EIFdlYktp dDJfU09VUkNFUwogICAgIFVJUHJvY2Vzcy9ndGsvV2ViSW5zcGVjdG9yQ2xpZW50R3RrLmNwcAog ICAgIFVJUHJvY2Vzcy9ndGsvV2ViSW5zcGVjdG9yUHJveHlHdGsuY3BwCiAgICAgVUlQcm9jZXNz L2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCisgICAgVUlQcm9jZXNzL2d0ay9XZWJQYXN0ZWJvYXJk UHJveHlHdGsuY3BwCiAgICAgVUlQcm9jZXNzL2d0ay9XZWJQb3B1cE1lbnVQcm94eUd0ay5jcHAK ICAgICBVSVByb2Nlc3MvZ3RrL1dlYlByZWZlcmVuY2VzR3RrLmNwcAogICAgIFVJUHJvY2Vzcy9n dGsvV2ViUHJvY2Vzc1Bvb2xHdGsuY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFy ZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsv QXJndW1lbnRDb2RlcnNHdGsuY3BwCmluZGV4IGZkOTQ1YTA2Li5jNmQyMzU4IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcAorKysgYi9T b3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmNwcApAQCAtODIsNyAr ODIsNyBAQCBzdGF0aWMgYm9vbCBkZWNvZGVJbWFnZShEZWNvZGVyJiBkZWNvZGVyLCBHUmVmUHRy PEdka1BpeGJ1Zj4mIHBpeGJ1ZikKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotc3RhdGljIHZvaWQg ZW5jb2RlRGF0YU9iamVjdChFbmNvZGVyJiBlbmNvZGVyLCBjb25zdCBEYXRhT2JqZWN0R3RrKiBk YXRhT2JqZWN0KQordm9pZCBlbmNvZGUoRW5jb2RlciYgZW5jb2RlciwgY29uc3QgRGF0YU9iamVj dEd0ayogZGF0YU9iamVjdCkKIHsKICAgICBib29sIGhhc1RleHQgPSBkYXRhT2JqZWN0LT5oYXNU ZXh0KCk7CiAgICAgZW5jb2RlciA8PCBoYXNUZXh0OwpAQCAtMTEzLDkgKzExMywxMiBAQCBzdGF0 aWMgdm9pZCBlbmNvZGVEYXRhT2JqZWN0KEVuY29kZXImIGVuY29kZXIsIGNvbnN0IERhdGFPYmpl Y3RHdGsqIGRhdGFPYmplY3QpCiAgICAgZW5jb2RlciA8PCBoYXNVbmtub3duVHlwZURhdGE7CiAg ICAgaWYgKGhhc1Vua25vd25UeXBlRGF0YSkKICAgICAgICAgZW5jb2RlciA8PCBkYXRhT2JqZWN0 LT51bmtub3duVHlwZXMoKTsKKworICAgIGJvb2wgY2FuU21hcnRSZXBsYWNlID0gZGF0YU9iamVj dC0+Y2FuU21hcnRSZXBsYWNlKCk7CisgICAgZW5jb2RlciA8PCBjYW5TbWFydFJlcGxhY2U7CiB9 CiAKLXN0YXRpYyBib29sIGRlY29kZURhdGFPYmplY3QoRGVjb2RlciYgZGVjb2RlciwgUmVmUHRy PERhdGFPYmplY3RHdGs+JiBkYXRhT2JqZWN0KQorYm9vbCBkZWNvZGUoRGVjb2RlciYgZGVjb2Rl ciwgUmVmUHRyPERhdGFPYmplY3RHdGs+JiBkYXRhT2JqZWN0KQogewogICAgIFJlZlB0cjxEYXRh T2JqZWN0R3RrPiBkYXRhID0gRGF0YU9iamVjdEd0azo6Y3JlYXRlKCk7CiAKQEAgLTE4Miw2ICsx ODUsMTEgQEAgc3RhdGljIGJvb2wgZGVjb2RlRGF0YU9iamVjdChEZWNvZGVyJiBkZWNvZGVyLCBS ZWZQdHI8RGF0YU9iamVjdEd0az4mIGRhdGFPYmplY3QKICAgICAgICAgICAgIGRhdGEtPnNldFVu a25vd25UeXBlRGF0YShpdC0+a2V5LCBpdC0+dmFsdWUpOwogICAgIH0KIAorICAgIGJvb2wgY2Fu U21hcnRSZXBsYWNlOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUoY2FuU21hcnRSZXBsYWNlKSkK KyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGRhdGEtPnNldENhblNtYXJ0UmVwbGFjZShjYW5T bWFydFJlcGxhY2UpOworCiAgICAgZGF0YU9iamVjdCA9IGRhdGE7CiAKICAgICByZXR1cm4gdHJ1 ZTsKQEAgLTE5OCw3ICsyMDYsNyBAQCB2b2lkIEFyZ3VtZW50Q29kZXI8RHJhZ0RhdGE+OjplbmNv ZGUoRW5jb2RlciYgZW5jb2RlciwgY29uc3QgRHJhZ0RhdGEmIGRyYWdEYXRhKQogICAgIERhdGFP YmplY3RHdGsqIHBsYXRmb3JtRGF0YSA9IGRyYWdEYXRhLnBsYXRmb3JtRGF0YSgpOwogICAgIGVu Y29kZXIgPDwgc3RhdGljX2Nhc3Q8Ym9vbD4ocGxhdGZvcm1EYXRhKTsKICAgICBpZiAocGxhdGZv cm1EYXRhKQotICAgICAgICBlbmNvZGVEYXRhT2JqZWN0KGVuY29kZXIsIHBsYXRmb3JtRGF0YSk7 CisgICAgICAgIElQQzo6ZW5jb2RlKGVuY29kZXIsIHBsYXRmb3JtRGF0YSk7CiB9CiAKIGJvb2wg QXJndW1lbnRDb2RlcjxEcmFnRGF0YT46OmRlY29kZShEZWNvZGVyJiBkZWNvZGVyLCBEcmFnRGF0 YSYgZHJhZ0RhdGEpCkBAIC0yMjUsNyArMjMzLDcgQEAgYm9vbCBBcmd1bWVudENvZGVyPERyYWdE YXRhPjo6ZGVjb2RlKERlY29kZXImIGRlY29kZXIsIERyYWdEYXRhJiBkcmFnRGF0YSkKIAogICAg IFJlZlB0cjxEYXRhT2JqZWN0R3RrPiBwbGF0Zm9ybURhdGE7CiAgICAgaWYgKGhhc1BsYXRmb3Jt RGF0YSkgewotICAgICAgICBpZiAoIWRlY29kZURhdGFPYmplY3QoZGVjb2RlciwgcGxhdGZvcm1E YXRhKSkKKyAgICAgICAgaWYgKCFJUEM6OmRlY29kZShkZWNvZGVyLCBwbGF0Zm9ybURhdGEpKQog ICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvU2hhcmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5oIGIvU291cmNlL1dlYktpdDIvU2hh cmVkL2d0ay9Bcmd1bWVudENvZGVyc0d0ay5oCmluZGV4IDAxYWM0Y2YuLjE2OWM2NjkgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvQXJndW1lbnRDb2RlcnNHdGsuaAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3RrL0FyZ3VtZW50Q29kZXJzR3RrLmgKQEAgLTUyLDYg KzUyLDkgQEAgYm9vbCBkZWNvZGUoRGVjb2RlciYsIEdSZWZQdHI8R3RrUHJpbnRTZXR0aW5ncz4m KTsKIHZvaWQgZW5jb2RlKEVuY29kZXImLCBHdGtQYWdlU2V0dXAqKTsKIGJvb2wgZGVjb2RlKERl Y29kZXImLCBHUmVmUHRyPEd0a1BhZ2VTZXR1cD4mKTsKIAordm9pZCBlbmNvZGUoRW5jb2RlciYs IGNvbnN0IFdlYkNvcmU6OkRhdGFPYmplY3RHdGsqKTsKK2Jvb2wgZGVjb2RlKERlY29kZXImLCBS ZWZQdHI8V2ViQ29yZTo6RGF0YU9iamVjdEd0az4mKTsKKwogfSAvLyBuYW1lc3BhY2UgSVBDCiAK ICNlbmRpZiAvLyBBcmd1bWVudENvZGVyc0d0a19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 Mi9TaGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJl ZC9ndGsvUGFzdGVib2FyZENvbnRlbnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAuLmI4OWVlNTYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQv Z3RrL1Bhc3RlYm9hcmRDb250ZW50LmNwcApAQCAtMCwwICsxLDQ2IEBACisvKgorICogIENvcHly aWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNl bnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIK KyAqICB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5U WTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAq ICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAq ICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVy YWwgUHVibGljCisgKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3 cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5r bGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQYXN0ZWJvYXJkQ29udGVudC5oIgor CisjaW5jbHVkZSAiQXJndW1lbnRDb2RlcnNHdGsuaCIKKyNpbmNsdWRlICJEYXRhT2JqZWN0R3Rr LmgiCisjaW5jbHVkZSAiRGVjb2Rlci5oIgorI2luY2x1ZGUgIkVuY29kZXIuaCIKKyNpbmNsdWRl IDx3dGYvUmV0YWluUHRyLmg+CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitQYXN0ZWJvYXJkQ29u dGVudDo6UGFzdGVib2FyZENvbnRlbnQoY29uc3QgUmVmUHRyPFdlYkNvcmU6OkRhdGFPYmplY3RH dGs+JiBkYXRhKQorICAgIDogZGF0YU9iamVjdChkYXRhKQoreworICAgIEFTU0VSVChkYXRhT2Jq ZWN0KTsKK30KKwordm9pZCBQYXN0ZWJvYXJkQ29udGVudDo6ZW5jb2RlKElQQzo6RW5jb2RlciYg ZW5jb2RlcikgY29uc3QKK3sKKyAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBkYXRhT2JqZWN0Lmdl dCgpKTsKK30KKworYm9vbCBQYXN0ZWJvYXJkQ29udGVudDo6ZGVjb2RlKElQQzo6RGVjb2RlciYg ZGVjb2RlciwgUGFzdGVib2FyZENvbnRlbnQmIHBhc3RlYm9hcmRDb250ZW50KQoreworICAgIHJl dHVybiBJUEM6OmRlY29kZShkZWNvZGVyLCBwYXN0ZWJvYXJkQ29udGVudC5kYXRhT2JqZWN0KTsK K30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvZ3RrL1Bhc3RlYm9hcmRDb250ZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvZ3Rr L1Bhc3RlYm9hcmRDb250ZW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u MDk4ZDE3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9ndGsvUGFz dGVib2FyZENvbnRlbnQuaApAQCAtMCwwICsxLDQzIEBACisvKgorICogIENvcHlyaWdodCAoQykg MjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiAgVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogIG1vZGlmeSBpdCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAqICBMaWNlbnNlIGFzIHB1 Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqICB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisgKgorICogIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91 dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqICBMZXNzZXIg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGlj CisgKiAgTGljZW5zZSBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCB3cml0ZSB0byB0 aGUgRnJlZSBTb2Z0d2FyZQorICogIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0cmVl dCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICovCisKKyNpZm5k ZWYgUGFzdGVib2FyZENvbnRlbnRfaAorI2RlZmluZSBQYXN0ZWJvYXJkQ29udGVudF9oCisKKyNp bmNsdWRlICJEYXRhT2JqZWN0R3RrLmgiCisKK25hbWVzcGFjZSBJUEMgeworY2xhc3MgRGVjb2Rl cjsKK2NsYXNzIEVuY29kZXI7Cit9CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitzdHJ1Y3QgUGFz dGVib2FyZENvbnRlbnQgeworICAgIFBhc3RlYm9hcmRDb250ZW50KCkgPSBkZWZhdWx0OworICAg IGV4cGxpY2l0IFBhc3RlYm9hcmRDb250ZW50KGNvbnN0IFJlZlB0cjxXZWJDb3JlOjpEYXRhT2Jq ZWN0R3RrPiYpOworCisgICAgUmVmUHRyPFdlYkNvcmU6OkRhdGFPYmplY3RHdGs+IGRhdGFPYmpl Y3Q7CisKKyAgICB2b2lkIGVuY29kZShJUEM6OkVuY29kZXImKSBjb25zdDsKKyAgICBzdGF0aWMg Ym9vbCBkZWNvZGUoSVBDOjpEZWNvZGVyJiwgUGFzdGVib2FyZENvbnRlbnQmKTsKK307CisKK30g Ly8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gUGFzdGVib2FyZENvbnRlbnRfaApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYkZyYW1lUHJveHkuY3BwIGIvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYkZyYW1lUHJveHkuY3BwCmluZGV4IGNkNzA2OTguLjQ2 ZGY3ZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJGcmFtZVByb3h5 LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViRnJhbWVQcm94eS5jcHAKQEAg LTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJXZWJGcmFtZVBvbGljeUxpc3RlbmVyUHJveHkuaCIK ICNpbmNsdWRlICJXZWJQYWdlTWVzc2FnZXMuaCIKICNpbmNsdWRlICJXZWJQYWdlUHJveHkuaCIK KyNpbmNsdWRlICJXZWJQYXN0ZWJvYXJkUHJveHkuaCIKICNpbmNsdWRlICJXZWJQcm9jZXNzUG9v bC5oIgogI2luY2x1ZGUgPFdlYkNvcmUvSW1hZ2UuaD4KICNpbmNsdWRlIDxXZWJDb3JlL01JTUVU eXBlUmVnaXN0cnkuaD4KQEAgLTUyLDYgKzUzLDkgQEAgV2ViRnJhbWVQcm94eTo6V2ViRnJhbWVQ cm94eShXZWJQYWdlUHJveHkqIHBhZ2UsIHVpbnQ2NF90IGZyYW1lSUQpCiBXZWJGcmFtZVByb3h5 Ojp+V2ViRnJhbWVQcm94eSgpCiB7CiAgICAgV2ViUHJvY2Vzc1Bvb2w6OnN0YXRpc3RpY3MoKS53 a0ZyYW1lQ291bnQtLTsKKyNpZiBQTEFURk9STShHVEspCisgICAgV2ViUGFzdGVib2FyZFByb3h5 OjpzaW5nbGV0b24oKS5kaWREZXN0cm95RnJhbWUodGhpcyk7CisjZW5kaWYKIH0KIAogdm9pZCBX ZWJGcmFtZVByb3h5Ojp3ZWJQcm9jZXNzV2lsbFNodXREb3duKCkKQEAgLTI1NCw0ICsyNTgsMTQg QEAgYm9vbCBXZWJGcmFtZVByb3h5OjpkaWRIYW5kbGVDb250ZW50RmlsdGVyVW5ibG9ja05hdmln YXRpb24oY29uc3QgV2ViQ29yZTo6UmVzb3UKIH0KICNlbmRpZgogCisjaWYgUExBVEZPUk0oR1RL KQordm9pZCBXZWJGcmFtZVByb3h5Ojpjb2xsYXBzZVNlbGVjdGlvbigpCit7CisgICAgaWYgKCFt X3BhZ2UpCisgICAgICAgIHJldHVybjsKKworICAgIG1fcGFnZS0+cHJvY2VzcygpLnNlbmQoTWVz c2FnZXM6OldlYlBhZ2U6OkNvbGxhcHNlU2VsZWN0aW9uSW5GcmFtZShtX2ZyYW1lSUQpLCBtX3Bh Z2UtPnBhZ2VJRCgpKTsKK30KKyNlbmRpZgorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJGcmFtZVByb3h5LmggYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvV2ViRnJhbWVQcm94eS5oCmluZGV4IDY3MDQ1ODAuLjU4MDhiZjEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJGcmFtZVByb3h5LmgKKysr IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYkZyYW1lUHJveHkuaApAQCAtMTI0LDYgKzEy NCwxMCBAQCBwdWJsaWM6CiAgICAgYm9vbCBkaWRIYW5kbGVDb250ZW50RmlsdGVyVW5ibG9ja05h dmlnYXRpb24oY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Jik7CiAjZW5kaWYKIAorI2lm IFBMQVRGT1JNKEdUSykKKyAgICB2b2lkIGNvbGxhcHNlU2VsZWN0aW9uKCk7CisjZW5kaWYKKwog cHJpdmF0ZToKICAgICBXZWJGcmFtZVByb3h5KFdlYlBhZ2VQcm94eSogcGFnZSwgdWludDY0X3Qg ZnJhbWVJRCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0 ZWJvYXJkUHJveHkuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJv eHkuaAppbmRleCA1ZTJhNWIxLi5lODQwMDMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5oCkBAIC00MCw4ICs0MCwxMyBAQCBzdHJ1Y3QgUGFzdGVi b2FyZFdlYkNvbnRlbnQ7CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCitjbGFzcyBXZWJGcmFtZVBy b3h5OwogY2xhc3MgV2ViUHJvY2Vzc1Byb3h5OwogCisjaWYgUExBVEZPUk0oR1RLKQorY2xhc3Mg UGFzdGVib2FyZENvbnRlbnQ7CisjZW5kaWYKKwogY2xhc3MgV2ViUGFzdGVib2FyZFByb3h5IDog cHVibGljIElQQzo6TWVzc2FnZVJlY2VpdmVyIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShX ZWJQYXN0ZWJvYXJkUHJveHkpOwogICAgIGZyaWVuZCBjbGFzcyBMYXp5TmV2ZXJEZXN0cm95ZWQ8 V2ViUGFzdGVib2FyZFByb3h5PjsKQEAgLTUwLDYgKzU1LDExIEBAIHB1YmxpYzoKIAogICAgIHZv aWQgYWRkV2ViUHJvY2Vzc1Byb3h5KFdlYlByb2Nlc3NQcm94eSYpOwogCisjaWYgUExBVEZPUk0o R1RLKQorICAgIHZvaWQgc2V0UHJpbWFyeVNlbGVjdGlvbk93bmVyKFdlYkZyYW1lUHJveHkqKTsK KyAgICB2b2lkIGRpZERlc3Ryb3lGcmFtZShXZWJGcmFtZVByb3h5Kik7CisjZW5kaWYKKwogcHJp dmF0ZToKICAgICBXZWJQYXN0ZWJvYXJkUHJveHkoKTsKIApAQCAtODEsNiArOTEsMTMgQEAgcHJp dmF0ZToKICAgICB2b2lkIHNldFBhc3RlYm9hcmRTdHJpbmdGb3JUeXBlKGNvbnN0IFN0cmluZyYg cGFzdGVib2FyZE5hbWUsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0IFN0cmlu ZyYsIHVpbnQ2NF90JiBuZXdDaGFuZ2VDb3VudCk7CiAgICAgdm9pZCBzZXRQYXN0ZWJvYXJkQnVm ZmVyRm9yVHlwZShjb25zdCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBTdHJpbmcmIHBh c3RlYm9hcmRUeXBlLCBjb25zdCBTaGFyZWRNZW1vcnk6OkhhbmRsZSYsIHVpbnQ2NF90IHNpemUs IHVpbnQ2NF90JiBuZXdDaGFuZ2VDb3VudCk7CiAjZW5kaWYKKyNpZiBQTEFURk9STShHVEspCisg ICAgdm9pZCB3cml0ZVRvQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZE5hbWUsIGNv bnN0IFBhc3RlYm9hcmRDb250ZW50Jik7CisgICAgdm9pZCByZWFkRnJvbUNsaXBib2FyZChjb25z dCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBQYXN0ZWJvYXJkQ29udGVudCYpOworCisgICAgV2Vi RnJhbWVQcm94eSogbV9wcmltYXJ5U2VsZWN0aW9uT3duZXIgeyBudWxscHRyIH07CisgICAgV2Vi RnJhbWVQcm94eSogbV9mcmFtZVdyaXRpbmdUb0NsaXBib2FyZCB7IG51bGxwdHIgfTsKKyNlbmRp ZiAvLyBQTEFURk9STShHVEspCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMu aW4gYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFzdGVib2FyZFByb3h5Lm1lc3NhZ2Vz LmluCmluZGV4IGQwZDlmYTEuLjE5NWU2YjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9XZWJQYXN0ZWJvYXJkUHJveHkubWVzc2FnZXMuaW4KKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlBhc3RlYm9hcmRQcm94eS5tZXNzYWdlcy5pbgpAQCAtNDgsNCArNDgs OSBAQCBtZXNzYWdlcyAtPiBXZWJQYXN0ZWJvYXJkUHJveHkgewogICAgIFNldFBhc3RlYm9hcmRT dHJpbmdGb3JUeXBlKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSwgU3RyaW5nIHBhc3RlYm9hcmRUeXBl LCBTdHJpbmcgc3RyaW5nKSAtPiAodWludDY0X3QgY2hhbmdlQ291bnQpCiAgICAgU2V0UGFzdGVi b2FyZEJ1ZmZlckZvclR5cGUoU3RyaW5nIHBhc3RlYm9hcmROYW1lLCBTdHJpbmcgcGFzdGVib2Fy ZFR5cGUsIFdlYktpdDo6U2hhcmVkTWVtb3J5OjpIYW5kbGUgaGFuZGxlLCB1aW50NjRfdCBzaXpl KSAtPiAodWludDY0X3QgY2hhbmdlQ291bnQpCiAjZW5kaWYKKworI2lmIFBMQVRGT1JNKEdUSykK KyAgICBXcml0ZVRvQ2xpcGJvYXJkKFN0cmluZyBwYXN0ZWJvYXJkTmFtZSwgc3RydWN0IFdlYktp dDo6UGFzdGVib2FyZENvbnRlbnQgcGFzdGVib2FyZENvbnRlbnQpCisgICAgUmVhZEZyb21DbGlw Ym9hcmQoU3RyaW5nIHBhc3RlYm9hcmROYW1lKSAtPiAoc3RydWN0IFdlYktpdDo6UGFzdGVib2Fy ZENvbnRlbnQgcGFzdGVib2FyZENvbnRlbnQpCisjZW5kaWYKIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcCBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcAppbmRleCAyZGJhZTA1Li5mNWE4 NGJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQcm94 eUd0ay5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlH dGsuY3BwCkBAIC0zMSw2ICszMSw3IEBACiAjaW5jbHVkZSAiUGFnZUNsaWVudEltcGwuaCIKICNp bmNsdWRlICJXZWJLaXRXZWJWaWV3QmFzZVByaXZhdGUuaCIKICNpbmNsdWRlICJXZWJQYWdlTWVz c2FnZXMuaCIKKyNpbmNsdWRlICJXZWJQYXN0ZWJvYXJkUHJveHkuaCIKICNpbmNsdWRlICJXZWJQ cm9jZXNzUHJveHkuaCIKICNpbmNsdWRlICJXZWJzaXRlRGF0YVN0b3JlLmgiCiAjaW5jbHVkZSA8 V2ViQ29yZS9Vc2VyQWdlbnRHdGsuaD4KQEAgLTc5LDYgKzgwLDggQEAgdm9pZCBXZWJQYWdlUHJv eHk6OmVkaXRvclN0YXRlQ2hhbmdlZChjb25zdCBFZGl0b3JTdGF0ZSYgZWRpdG9yU3RhdGUpCiAg ICAgCiAgICAgaWYgKGVkaXRvclN0YXRlLnNob3VsZElnbm9yZUNvbXBvc2l0aW9uU2VsZWN0aW9u Q2hhbmdlKQogICAgICAgICByZXR1cm47CisgICAgaWYgKG1fZWRpdG9yU3RhdGUuc2VsZWN0aW9u SXNSYW5nZSkKKyAgICAgICAgV2ViUGFzdGVib2FyZFByb3h5OjpzaW5nbGV0b24oKS5zZXRQcmlt YXJ5U2VsZWN0aW9uT3duZXIoZm9jdXNlZEZyYW1lKCkpOwogICAgIG1fcGFnZUNsaWVudC5zZWxl Y3Rpb25EaWRDaGFuZ2UoKTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2d0ay9XZWJQYXN0ZWJvYXJkUHJveHlHdGsuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjE1ZjkwZDMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvZ3RrL1dlYlBhc3RlYm9hcmRQcm94eUd0ay5jcHAKQEAgLTAsMCArMSw3MyBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBSZWQgSGF0IEluYy4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAy LiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3Zl IGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRP UlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENP TlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1 ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIldlYlBhc3RlYm9hcmRQcm94eS5oIgorCisjaW5jbHVk ZSAiUGFzdGVib2FyZENvbnRlbnQuaCIKKyNpbmNsdWRlICJXZWJGcmFtZVByb3h5LmgiCisjaW5j bHVkZSA8V2ViQ29yZS9QbGF0Zm9ybVBhc3RlYm9hcmQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1h cC5oPgorI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgorI2luY2x1ZGUgPHd0Zi9UZW1w b3JhcnlDaGFuZ2UuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdIYXNoLmg+CisKK3VzaW5n IG5hbWVzcGFjZSBXZWJDb3JlOworCituYW1lc3BhY2UgV2ViS2l0IHsKKwordm9pZCBXZWJQYXN0 ZWJvYXJkUHJveHk6OndyaXRlVG9DbGlwYm9hcmQoY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFt ZSwgY29uc3QgUGFzdGVib2FyZENvbnRlbnQmIHBhc3RlYm9hcmRDb250ZW50KQoreworICAgIFRl bXBvcmFyeUNoYW5nZTxXZWJGcmFtZVByb3h5Kj4gZnJhbWVXcml0aW5nVG9DbGlwYm9hcmQobV9m cmFtZVdyaXRpbmdUb0NsaXBib2FyZCwgbV9wcmltYXJ5U2VsZWN0aW9uT3duZXIpOworICAgIFBs YXRmb3JtUGFzdGVib2FyZChwYXN0ZWJvYXJkTmFtZSkud3JpdGVUb0NsaXBib2FyZChwYXN0ZWJv YXJkQ29udGVudC5kYXRhT2JqZWN0LCBbdGhpc10geworICAgICAgICBpZiAobV9mcmFtZVdyaXRp bmdUb0NsaXBib2FyZCA9PSBtX3ByaW1hcnlTZWxlY3Rpb25Pd25lcikKKyAgICAgICAgICAgIHJl dHVybjsKKyAgICAgICAgc2V0UHJpbWFyeVNlbGVjdGlvbk93bmVyKG51bGxwdHIpOworICAgIH0p OworfQorCit2b2lkIFdlYlBhc3RlYm9hcmRQcm94eTo6cmVhZEZyb21DbGlwYm9hcmQoY29uc3Qg U3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSwgUGFzdGVib2FyZENvbnRlbnQmIHBhc3RlYm9hcmRDb250 ZW50KQoreworICAgIHBhc3RlYm9hcmRDb250ZW50ID0gUGFzdGVib2FyZENvbnRlbnQoUGxhdGZv cm1QYXN0ZWJvYXJkKHBhc3RlYm9hcmROYW1lKS5yZWFkRnJvbUNsaXBib2FyZCgpLmdldCgpKTsK K30KKwordm9pZCBXZWJQYXN0ZWJvYXJkUHJveHk6OnNldFByaW1hcnlTZWxlY3Rpb25Pd25lcihX ZWJGcmFtZVByb3h5KiBmcmFtZSkKK3sKKyAgICBpZiAobV9wcmltYXJ5U2VsZWN0aW9uT3duZXIg PT0gZnJhbWUpCisgICAgICAgIHJldHVybjsKKworICAgIGlmIChtX3ByaW1hcnlTZWxlY3Rpb25P d25lcikKKyAgICAgICAgbV9wcmltYXJ5U2VsZWN0aW9uT3duZXItPmNvbGxhcHNlU2VsZWN0aW9u KCk7CisKKyAgICBtX3ByaW1hcnlTZWxlY3Rpb25Pd25lciA9IGZyYW1lOworfQorCit2b2lkIFdl YlBhc3RlYm9hcmRQcm94eTo6ZGlkRGVzdHJveUZyYW1lKFdlYkZyYW1lUHJveHkqIGZyYW1lKQor eworICAgIGlmIChmcmFtZSA9PSBtX3ByaW1hcnlTZWxlY3Rpb25Pd25lcikKKyAgICAgICAgbV9w cmltYXJ5U2VsZWN0aW9uT3duZXIgPSBudWxscHRyOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJL aXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQv V2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2Vi Q29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmNwcAppbmRleCAwMTljMTMzLi45Mjgw YTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0 L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vz cy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuY3BwCkBAIC02OSw2ICs2OSwx MCBAQAogI2luY2x1ZGUgIlN0cmluZ1V0aWxpdGllcy5oIgogI2VuZGlmCiAKKyNpZiBQTEFURk9S TShHVEspCisjaW5jbHVkZSAiUGFzdGVib2FyZENvbnRlbnQuaCIKKyNlbmRpZgorCiB1c2luZyBu YW1lc3BhY2UgV2ViQ29yZTsKIAogbmFtZXNwYWNlIFdlYktpdCB7CkBAIC0zMzksNCArMzQzLDIy IEBAIGxvbmcgV2ViUGxhdGZvcm1TdHJhdGVnaWVzOjpjaGFuZ2VDb3VudCgpCiAKICNlbmRpZiAv LyBQTEFURk9STShDT0NPQSkKIAorI2lmIFBMQVRGT1JNKEdUSykKKy8vIFBhc3RlYm9hcmRTdHJh dGVneQorCit2b2lkIFdlYlBsYXRmb3JtU3RyYXRlZ2llczo6d3JpdGVUb0NsaXBib2FyZChjb25z dCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lLCBjb25zdCBSZWZQdHI8V2ViQ29yZTo6RGF0YU9iamVj dEd0az4mIGRhdGFPYmplY3QpCit7CisgICAgUGFzdGVib2FyZENvbnRlbnQgcGFzdGVib2FyZENv bnRlbnQgPSBQYXN0ZWJvYXJkQ29udGVudChkYXRhT2JqZWN0LmdldCgpKTsKKyAgICBXZWJQcm9j ZXNzOjpzaW5nbGV0b24oKS5wYXJlbnRQcm9jZXNzQ29ubmVjdGlvbigpLT5zZW5kKE1lc3NhZ2Vz OjpXZWJQYXN0ZWJvYXJkUHJveHk6OldyaXRlVG9DbGlwYm9hcmQocGFzdGVib2FyZE5hbWUsIHBh c3RlYm9hcmRDb250ZW50KSwgMCk7Cit9CisKK1JlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3Rr PiBXZWJQbGF0Zm9ybVN0cmF0ZWdpZXM6OnJlYWRGcm9tQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYg cGFzdGVib2FyZE5hbWUpCit7CisgICAgUGFzdGVib2FyZENvbnRlbnQgcGFzdGVib2FyZENvbnRl bnQ7CisgICAgV2ViUHJvY2Vzczo6c2luZ2xldG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24o KS0+c2VuZFN5bmMoTWVzc2FnZXM6OldlYlBhc3RlYm9hcmRQcm94eTo6UmVhZEZyb21DbGlwYm9h cmQocGFzdGVib2FyZE5hbWUpLCBNZXNzYWdlczo6V2ViUGFzdGVib2FyZFByb3h5OjpSZWFkRnJv bUNsaXBib2FyZDo6UmVwbHkocGFzdGVib2FyZENvbnRlbnQpLCAwKTsKKyAgICByZXR1cm4gcGFz dGVib2FyZENvbnRlbnQuZGF0YU9iamVjdDsKK30KKworI2VuZGlmIC8vIFBMQVRGT1JNKEdUSykK KwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oIGIvU291cmNlL1dl YktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9XZWJQbGF0Zm9ybVN0cmF0ZWdpZXMuaApp bmRleCA3OThlZDJjLi5mM2U1ZDgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9j ZXNzL1dlYkNvcmVTdXBwb3J0L1dlYlBsYXRmb3JtU3RyYXRlZ2llcy5oCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvV2ViUGxhdGZvcm1TdHJhdGVnaWVzLmgK QEAgLTg2LDcgKzg2LDEwIEBAIHByaXZhdGU6CiAgICAgbG9uZyBzZXRQYXRobmFtZXNGb3JUeXBl KGNvbnN0IFZlY3RvcjxTdHJpbmc+JiwgY29uc3QgU3RyaW5nJiBwYXN0ZWJvYXJkVHlwZSwgY29u c3QgU3RyaW5nJiBwYXN0ZWJvYXJkTmFtZSkgb3ZlcnJpZGU7CiAgICAgbG9uZyBzZXRTdHJpbmdG b3JUeXBlKGNvbnN0IFN0cmluZyYsIGNvbnN0IFN0cmluZyYgcGFzdGVib2FyZFR5cGUsIGNvbnN0 IFN0cmluZyYgcGFzdGVib2FyZE5hbWUpIG92ZXJyaWRlOwogI2VuZGlmCi0KKyNpZiBQTEFURk9S TShHVEspCisgICAgdm9pZCB3cml0ZVRvQ2xpcGJvYXJkKGNvbnN0IFN0cmluZyYgcGFzdGVib2Fy ZE5hbWUsIGNvbnN0IFJlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPiYpIG92ZXJyaWRlOwor ICAgIFJlZlB0cjxXZWJDb3JlOjpEYXRhT2JqZWN0R3RrPiByZWFkRnJvbUNsaXBib2FyZChjb25z dCBTdHJpbmcmIHBhc3RlYm9hcmROYW1lKSBvdmVycmlkZTsKKyNlbmRpZgogfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dl YkNvcmVTdXBwb3J0L2d0ay9XZWJFZGl0b3JDbGllbnRHdGsuY3BwIGIvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9ndGsvV2ViRWRpdG9yQ2xpZW50R3RrLmNwcAppbmRl eCA1MTEwMDI1Li5jNDhiODYzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYkNvcmVTdXBwb3J0L2d0ay9XZWJFZGl0b3JDbGllbnRHdGsuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvZ3RrL1dlYkVkaXRvckNsaWVudEd0ay5j cHAKQEAgLTExOSw0NSArMTE5LDYgQEAgdm9pZCBXZWJFZGl0b3JDbGllbnQ6OmhhbmRsZUlucHV0 TWV0aG9kS2V5ZG93bihLZXlib2FyZEV2ZW50KiBldmVudCkKICAgICAgICAgZXZlbnQtPnNldERl ZmF1bHRIYW5kbGVkKCk7CiB9CiAKLWNsYXNzIEVkaXRvckNsaWVudEZyYW1lRGVzdHJ1Y3Rpb25P YnNlcnZlciA6IEZyYW1lRGVzdHJ1Y3Rpb25PYnNlcnZlciB7Ci1wdWJsaWM6Ci0gICAgRWRpdG9y Q2xpZW50RnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyKEZyYW1lKiBmcmFtZSwgR0Nsb3N1cmUqIGNs b3N1cmUpCi0gICAgICAgIDogRnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyKGZyYW1lKQotICAgICAg ICAsIG1fY2xvc3VyZShjbG9zdXJlKQotICAgIHsKLSAgICAgICAgZ19jbG9zdXJlX2FkZF9maW5h bGl6ZV9ub3RpZmllcihtX2Nsb3N1cmUsIHRoaXMsIGRlc3Ryb3lPbkNsb3N1cmVGaW5hbGl6YXRp b24pOwotICAgIH0KLQotICAgIHZvaWQgZnJhbWVEZXN0cm95ZWQoKQotICAgIHsKLSAgICAgICAg Z19jbG9zdXJlX2ludmFsaWRhdGUobV9jbG9zdXJlKTsKLSAgICAgICAgRnJhbWVEZXN0cnVjdGlv bk9ic2VydmVyOjpmcmFtZURlc3Ryb3llZCgpOwotICAgIH0KLXByaXZhdGU6Ci0gICAgR0Nsb3N1 cmUqIG1fY2xvc3VyZTsKLQotICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lPbkNsb3N1cmVGaW5hbGl6 YXRpb24oZ3BvaW50ZXIgZGF0YSwgR0Nsb3N1cmUqKQotICAgIHsKLSAgICAgICAgLy8gQ2FsbGlu ZyBkZWxldGUgdm9pZCogd2lsbCBmcmVlIHRoZSBtZW1vcnkgYnV0IHdvbid0IGludm9rZQotICAg ICAgICAvLyB0aGUgZGVzdHJ1Y3Rvciwgc29tZXRoaW5nIHRoYXQgaXMgYSBtdXN0IGZvciB1cy4K LSAgICAgICAgRWRpdG9yQ2xpZW50RnJhbWVEZXN0cnVjdGlvbk9ic2VydmVyKiBvYnNlcnZlciA9 IHN0YXRpY19jYXN0PEVkaXRvckNsaWVudEZyYW1lRGVzdHJ1Y3Rpb25PYnNlcnZlcio+KGRhdGEp OwotICAgICAgICBkZWxldGUgb2JzZXJ2ZXI7Ci0gICAgfQotfTsKLQotc3RhdGljIEZyYW1lKiBm cmFtZVNldHRpbmdDbGlwYm9hcmQ7Ci0KLXN0YXRpYyB2b2lkIGNvbGxhcHNlU2VsZWN0aW9uKEd0 a0NsaXBib2FyZCosIEZyYW1lKiBmcmFtZSkKLXsKLSAgICBpZiAoZnJhbWVTZXR0aW5nQ2xpcGJv YXJkICYmIGZyYW1lU2V0dGluZ0NsaXBib2FyZCA9PSBmcmFtZSkKLSAgICAgICAgcmV0dXJuOwot Ci0gICAgLy8gQ29sbGFwc2UgdGhlIHNlbGVjdGlvbiB3aXRob3V0IGNsZWFyaW5nIGl0LgotICAg IEFTU0VSVChmcmFtZSk7Ci0gICAgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uID0g ZnJhbWUtPnNlbGVjdGlvbigpLnNlbGVjdGlvbigpOwotICAgIGZyYW1lLT5zZWxlY3Rpb24oKS5z ZXRCYXNlKHNlbGVjdGlvbi5leHRlbnQoKSwgc2VsZWN0aW9uLmFmZmluaXR5KCkpOwotfQotCiB2 b2lkIFdlYkVkaXRvckNsaWVudDo6dXBkYXRlR2xvYmFsU2VsZWN0aW9uKEZyYW1lKiBmcmFtZSkK IHsKICAgICBpZiAoIWZyYW1lLT5zZWxlY3Rpb24oKS5pc1JhbmdlKCkpCkBAIC0xNjYsMjEgKzEy NywxMSBAQCB2b2lkIFdlYkVkaXRvckNsaWVudDo6dXBkYXRlR2xvYmFsU2VsZWN0aW9uKEZyYW1l KiBmcmFtZSkKICAgICBpZiAoIXJhbmdlKQogICAgICAgICByZXR1cm47CiAKLSAgICBmcmFtZVNl dHRpbmdDbGlwYm9hcmQgPSBmcmFtZTsKLSAgICBHUmVmUHRyPEdDbG9zdXJlPiBjYWxsYmFjayA9 IGFkb3B0R1JlZihnX2NjbG9zdXJlX25ldyhHX0NBTExCQUNLKGNvbGxhcHNlU2VsZWN0aW9uKSwg ZnJhbWUsIG51bGxwdHIpKTsKLSAgICAvLyBUaGlzIG9ic2VydmVyIHdpbGwgYmUgc2VsZi1kZXN0 cm95ZWQgb24gY2xvc3VyZSBmaW5hbGl6YXRpb24sCi0gICAgLy8gdGhhdCB3aWxsIGhhcHBlbiBl aXRoZXIgYWZ0ZXIgY2xvc3VyZSBleGVjdXRpb24gb3IgYWZ0ZXIKLSAgICAvLyBjbG9zdXJlIGlu dmFsaWRhdGlvbi4KLSAgICBuZXcgRWRpdG9yQ2xpZW50RnJhbWVEZXN0cnVjdGlvbk9ic2VydmVy KGZyYW1lLCBjYWxsYmFjay5nZXQoKSk7Ci0gICAgZ19jbG9zdXJlX3NldF9tYXJzaGFsKGNhbGxi YWNrLmdldCgpLCBnX2NjbG9zdXJlX21hcnNoYWxfVk9JRF9fVk9JRCk7Ci0KICAgICBQYXN0ZWJv YXJkV2ViQ29udGVudCBwYXN0ZWJvYXJkQ29udGVudDsKICAgICBwYXN0ZWJvYXJkQ29udGVudC5j YW5TbWFydENvcHlPckRlbGV0ZSA9IGZhbHNlOwogICAgIHBhc3RlYm9hcmRDb250ZW50LnRleHQg PSByYW5nZS0+dGV4dCgpOwogICAgIHBhc3RlYm9hcmRDb250ZW50Lm1hcmt1cCA9IGNyZWF0ZU1h cmt1cCgqcmFuZ2UsIG51bGxwdHIsIEFubm90YXRlRm9ySW50ZXJjaGFuZ2UsIGZhbHNlLCBSZXNv bHZlTm9uTG9jYWxVUkxzKTsKLSAgICBwYXN0ZWJvYXJkQ29udGVudC5jYWxsYmFjayA9IGNhbGxi YWNrOwogICAgIFBhc3RlYm9hcmQ6OmNyZWF0ZUZvckdsb2JhbFNlbGVjdGlvbigpLT53cml0ZShw YXN0ZWJvYXJkQ29udGVudCk7Ci0gICAgZnJhbWVTZXR0aW5nQ2xpcGJvYXJkID0gbnVsbHB0cjsK IH0KIAogYm9vbCBXZWJFZGl0b3JDbGllbnQ6OnNob3VsZFNob3dVbmljb2RlTWVudSgpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5oIGIvU291 cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UuaAppbmRleCAwYzc2ZjY1Li43 N2ZmZjgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2Vi UGFnZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJQYWdlLmgK QEAgLTY0Niw2ICs2NDYsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBzZXRDb21wb3NpdGlvbihjb25z dCBTdHJpbmcmIHRleHQsIGNvbnN0IFZlY3RvcjxXZWJDb3JlOjpDb21wb3NpdGlvblVuZGVybGlu ZT4mIHVuZGVybGluZXMsIHVpbnQ2NF90IHNlbGVjdGlvblN0YXJ0LCB1aW50NjRfdCBzZWxlY3Rp b25FbmQsIHVpbnQ2NF90IHJlcGxhY2VtZW50UmFuZ2VTdGFydCwgdWludDY0X3QgcmVwbGFjZW1l bnRSYW5nZUxlbmd0aCk7CiAgICAgdm9pZCBjb25maXJtQ29tcG9zaXRpb24oY29uc3QgU3RyaW5n JiB0ZXh0LCBpbnQ2NF90IHNlbGVjdGlvblN0YXJ0LCBpbnQ2NF90IHNlbGVjdGlvbkxlbmd0aCk7 CiAgICAgdm9pZCBjYW5jZWxDb21wb3NpdGlvbigpOworCisgICAgdm9pZCBjb2xsYXBzZVNlbGVj dGlvbkluRnJhbWUodWludDY0X3QgZnJhbWVJRCk7CiAjZW5kaWYKIAogI2lmIFBMQVRGT1JNIChH VEspICYmIEhBVkUoR1RLX0dFU1RVUkVTKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYlBhZ2UubWVzc2FnZXMuaW4gYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQ cm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5tZXNzYWdlcy5pbgppbmRleCAzOWY4ZGYwLi4zYzExY2Ey IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFnZS5t ZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViUGFn ZS5tZXNzYWdlcy5pbgpAQCAtMzQwLDYgKzM0MCw4IEBAIG1lc3NhZ2VzIC0+IFdlYlBhZ2UgTGVn YWN5UmVjZWl2ZXIgewogICAgIFNldENvbXBvc2l0aW9uKFN0cmluZyB0ZXh0LCBWZWN0b3I8V2Vi Q29yZTo6Q29tcG9zaXRpb25VbmRlcmxpbmU+IHVuZGVybGluZXMsIHVpbnQ2NF90IHNlbGVjdGlv blN0YXJ0LCB1aW50NjRfdCBzZWxlY3Rpb25FbmQsIHVpbnQ2NF90IHJlcGxhY2VtZW50UmFuZ2VT dGFydCwgdWludDY0X3QgcmVwbGFjZW1lbnRSYW5nZUVuZCkKICAgICBDb25maXJtQ29tcG9zaXRp b24oU3RyaW5nIHRleHQsIGludDY0X3Qgc2VsZWN0aW9uU3RhcnQsIGludDY0X3Qgc2VsZWN0aW9u TGVuZ3RoKQogICAgIENhbmNlbENvbXBvc2l0aW9uKCkKKworICAgIENvbGxhcHNlU2VsZWN0aW9u SW5GcmFtZSh1aW50NjRfdCBmcmFtZUlEKQogI2VuZGlmCiAKICNpZiBQTEFURk9STSAoR1RLKSAm JiBIQVZFKEdUS19HRVNUVVJFUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nl c3MvV2ViUGFnZS9ndGsvV2ViUGFnZUd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYlBhZ2UvZ3RrL1dlYlBhZ2VHdGsuY3BwCmluZGV4IGU2YjgwNzQuLjRhNmVhZDYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUGFnZS9ndGsvV2ViUGFnZUd0ay5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQYWdlL2d0ay9XZWJQYWdlR3Rr LmNwcApAQCAtMzEsOCArMzEsMTAgQEAKICNpbmNsdWRlICJFZGl0b3JTdGF0ZS5oIgogI2luY2x1 ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiV2ViRXZlbnQuaCIKKyNpbmNsdWRlICJX ZWJGcmFtZS5oIgogI2luY2x1ZGUgIldlYlBhZ2VBY2Nlc3NpYmlsaXR5T2JqZWN0LmgiCiAjaW5j bHVkZSAiV2ViUGFnZVByb3h5TWVzc2FnZXMuaCIKKyNpbmNsdWRlICJXZWJQcm9jZXNzLmgiCiAj aW5jbHVkZSAiV2luZG93c0tleWJvYXJkQ29kZXMuaCIKICNpbmNsdWRlIDxXZWJDb3JlL0JhY2tG b3J3YXJkQ29udHJvbGxlci5oPgogI2luY2x1ZGUgPFdlYkNvcmUvRXZlbnRIYW5kbGVyLmg+CkBA IC0yMTYsNCArMjE4LDE1IEBAIHZvaWQgV2ViUGFnZTo6c2V0SW5wdXRNZXRob2RTdGF0ZShib29s IGVuYWJsZWQpCiAgICAgc2VuZChNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpTZXRJbnB1dE1ldGhv ZFN0YXRlKGVuYWJsZWQpKTsKIH0KIAordm9pZCBXZWJQYWdlOjpjb2xsYXBzZVNlbGVjdGlvbklu RnJhbWUodWludDY0X3QgZnJhbWVJRCkKK3sKKyAgICBXZWJGcmFtZSogZnJhbWUgPSBXZWJQcm9j ZXNzOjpzaW5nbGV0b24oKS53ZWJGcmFtZShmcmFtZUlEKTsKKyAgICBpZiAoIWZyYW1lIHx8ICFm cmFtZS0+Y29yZUZyYW1lKCkpCisgICAgICAgIHJldHVybjsKKworICAgIC8vIENvbGxhcHNlIHRo ZSBzZWxlY3Rpb24gd2l0aG91dCBjbGVhcmluZyBpdC4KKyAgICBjb25zdCBWaXNpYmxlU2VsZWN0 aW9uJiBzZWxlY3Rpb24gPSBmcmFtZS0+Y29yZUZyYW1lKCktPnNlbGVjdGlvbigpLnNlbGVjdGlv bigpOworICAgIGZyYW1lLT5jb3JlRnJhbWUoKS0+c2VsZWN0aW9uKCkuc2V0QmFzZShzZWxlY3Rp b24uZXh0ZW50KCksIHNlbGVjdGlvbi5hZmZpbml0eSgpKTsKK30KKwogfSAvLyBuYW1lc3BhY2Ug V2ViS2l0Cg==