155255 2016-03-09 13:27:56 -0800 MemoryPressureHandler doesn't work if cgroups aren't present in Linux 2018-04-03 06:01:04 -0700 1 1 1 Unclassified WebKit Platform WebKit Local Build Unspecified Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=123532 https://bugs.webkit.org/show_bug.cgi?id=184261 P2 Normal --- 159346 1 eocanha webkit-unassigned cgarcia changseok changseok clopez commit-queue jdapena mcatanzaro mrobinson svillar tonikitoo zan oldest_to_newest 1172721 0 eocanha 2016-03-09 13:27:56 -0800 The current Linux implementation of MemoryPressureHandler relies on /sys/fs/cgroup/memory to be properly setup. This isn't the case for all desktop systems and embedded devices, so having an alternative method to measure memory pressure should be desirable (especially on embedded devices with limited memory). 1172732 1 273468 eocanha 2016-03-09 13:40:11 -0800 Created attachment 273468 Patch 1173774 2 mcatanzaro 2016-03-11 10:19:39 -0800 Related: the current code tries to read /sys/fs/cgroup/memory/memory.pressure_level, but this file has no read permission set, at least on Fedora, so I have no clue how the current code could possibly work. ChangSeok, any thoughts on this? 1173775 3 mcatanzaro 2016-03-11 10:21:00 -0800 By the way, I noticed this when debugging seccomp filters months ago, looking at calls to open() that were failing. In /sys/fs/cgroup/memory, I see: $ ls -l total 0 -rw-r--r--. 1 root root 0 Mar 11 12:17 cgroup.clone_children --w--w--w-. 1 root root 0 Mar 11 12:17 cgroup.event_control -rw-r--r--. 1 root root 0 Mar 11 12:17 cgroup.procs -r--r--r--. 1 root root 0 Mar 11 12:17 cgroup.sane_behavior -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.failcnt --w-------. 1 root root 0 Mar 11 12:17 memory.force_empty -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.failcnt -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.limit_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.max_usage_in_bytes -r--r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.slabinfo -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.tcp.failcnt -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.tcp.limit_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.tcp.max_usage_in_bytes -r--r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.tcp.usage_in_bytes -r--r--r--. 1 root root 0 Mar 11 12:17 memory.kmem.usage_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.limit_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.max_usage_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.memsw.failcnt -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.memsw.limit_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.memsw.max_usage_in_bytes -r--r--r--. 1 root root 0 Mar 11 12:17 memory.memsw.usage_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.move_charge_at_immigrate -r--r--r--. 1 root root 0 Mar 11 12:17 memory.numa_stat -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.oom_control ----------. 1 root root 0 Mar 11 12:17 memory.pressure_level -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.soft_limit_in_bytes -r--r--r--. 1 root root 0 Mar 11 12:17 memory.stat -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.swappiness -r--r--r--. 1 root root 0 Mar 11 12:17 memory.usage_in_bytes -rw-r--r--. 1 root root 0 Mar 11 12:17 memory.use_hierarchy -rw-r--r--. 1 root root 0 Mar 11 12:17 notify_on_release -rw-r--r--. 1 root root 0 Mar 11 12:17 release_agent -rw-r--r--. 1 root root 0 Mar 11 12:17 tasks Note the ----------. permission on memory.pressure_level 1173779 4 273468 mrobinson 2016-03-11 10:30:54 -0800 Comment on attachment 273468 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=273468&action=review Looks good, but I think it needs a little bit of cleanup. Thanks! > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:54 > +static const unsigned s_pollTimeSec = 1; We try to avoid abbreviated variable names in WebKit. How about s_pollingIntervalInSeconds? > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:56 > +static const size_t s_memCriticalLimit = 100 * KB * KB; // 100 MB > +static const size_t s_memNonCriticalLimit = 300 * KB * KB; // 300 MB memory isn't abbreviated below, so it probably shouldn't be abbreviated here. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:118 > + size_t memFree = static_cast<size_t>(-1); // bytes I think this comment could be expanded. What does "bytes" signify here. Comments in WebKit should be complete sentences with periods. If you are trying to say that this value is stored in bytes, a better method would simply be to call this variable "memoryFreeInBytes." > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:135 > + bool critical = memFree < s_memCriticalLimit; Maybe better to call this underMemoryPressure or something similar. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:210 > + } while (false); Probably better to use a helper function here rather than do { } while. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:225 > + do { > + m_threadID = createThread(pollMemoryPressure, this, "WebCore: MemoryPressureHandler"); > + if (!m_threadID) { > + logErrorAndCloseFDs("Failed to create a thread for MemoryPressureHandler"); > + break; > + } > + > + LOG(MemoryPressure, "Vmstat memory pressure handler installed."); > + vmstatPressureHandlerOk = true; > + } while (false); Probably better to use a helper function here rather than do { } while. 1173805 5 273748 eocanha 2016-03-11 11:31:38 -0800 Created attachment 273748 Patch 1173812 6 273748 mrobinson 2016-03-11 11:47:07 -0800 Comment on attachment 273748 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=273748&action=review Looks good to me, but I think it makes sense to have someone more closely involved with the port sign off an polling proc every second. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:56 > +static const size_t s_memoryCriticalLimit = 100 * KB * KB; // 100 MB > +static const size_t s_memoryNonCriticalLimit = 300 * KB * KB; // 300 MB It might be worth discussing a bit where these numbers come from. A comment here or a note in the ChangeLog or bug is fine. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:224 > + if (!installUsingCgroups() && !installUsingMeminfo()) > + return; Much nicer! > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:227 > if (ReliefLogger::loggingEnabled() && isUnderMemoryPressure()) > LOG(MemoryPressure, "System is no longer under memory pressure."); This is quite strange. If isUnderMemoryPressure returns true, a message is printed that the system is not under memory pressure. Do you have understand why this is? 1173816 7 eocanha 2016-03-11 12:08:07 -0800 (In reply to comment #6) > Looks good to me, but I think it makes sense to have someone more closely > involved with the port sign off an polling proc every second. Ok. > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:56 > > +static const size_t s_memoryCriticalLimit = 100 * KB * KB; // 100 MB > > +static const size_t s_memoryNonCriticalLimit = 300 * KB * KB; // 300 MB > It might be worth discussing a bit where these numbers come from. A comment > here or a note in the ChangeLog or bug is fine. Those numbers are arbitrary. I found them right for our downstream port, where we're interested in minimizing the RAM usage. > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:227 > > if (ReliefLogger::loggingEnabled() && isUnderMemoryPressure()) > > LOG(MemoryPressure, "System is no longer under memory pressure."); > > This is quite strange. If isUnderMemoryPressure returns true, a message is > printed that the system is not under memory pressure. Do you have understand > why this is? Hmmm... actually not. Changseok should know. 1173927 8 mcatanzaro 2016-03-11 16:55:50 -0800 (In reply to comment #6) > Looks good to me, but I think it makes sense to have someone more closely > involved with the port sign off an polling proc every second. I can't think of any reason not to. Once per second is reasonable. But it'd probably be nicer to do this with real poll or epoll, rather than sleep, so we don't need a new thread for it? 1173935 9 mcatanzaro 2016-03-11 17:45:25 -0800 (In reply to comment #8) > But it'd probably be nicer to do this with real poll or epoll, rather than > sleep, so we don't need a new thread for it? I talked with mrobinson about this; we think it's fine as-is. 1173961 10 changseok 2016-03-11 21:30:11 -0800 (In reply to comment #0) > The current Linux implementation of MemoryPressureHandler relies on > /sys/fs/cgroup/memory to be properly setup. This isn't the case for all > desktop systems and embedded devices, so having an alternative method to > measure memory pressure should be desirable (especially on embedded devices > with limited memory). As I rememeber, the polling way was considered but it was rejected because of a concern that regularly waking up cpu to read meminfo itself badly affected on performance. https://bugs.webkit.org/show_bug.cgi?id=123532#c2 . For the reason, it is intended that MemoryPressureHandler works for only cgroup avaiable platforms. I know there is a small difference between this approach and previous one, using a timer or sleep() in a separate thread. I am also glad to see this alernative memory handler though, I would like to ask if there is anything different from using timer way and this patch is actually useful on real embeded systems. How about performance there? Is it acceptable? 1174000 11 cgarcia 2016-03-12 01:02:32 -0800 (In reply to comment #8) > (In reply to comment #6) > > Looks good to me, but I think it makes sense to have someone more closely > > involved with the port sign off an polling proc every second. > > I can't think of any reason not to. Once per second is reasonable. > > But it'd probably be nicer to do this with real poll or epoll, rather than > sleep, so we don't need a new thread for it? I'm not sure /proc/meminfo is pollable, the kernel probably gives the contents directly when reading, but I haven't actually checked, it's just a guess. 1174001 12 cgarcia 2016-03-12 01:07:01 -0800 (In reply to comment #10) > (In reply to comment #0) > > The current Linux implementation of MemoryPressureHandler relies on > > /sys/fs/cgroup/memory to be properly setup. This isn't the case for all > > desktop systems and embedded devices, so having an alternative method to > > measure memory pressure should be desirable (especially on embedded devices > > with limited memory). > > As I rememeber, the polling way was considered but it was rejected because > of a concern that regularly waking up cpu to read meminfo itself badly > affected on performance. https://bugs.webkit.org/show_bug.cgi?id=123532#c2 . > For the reason, it is intended that MemoryPressureHandler works for only > cgroup avaiable platforms. I know there is a small difference between this > approach and previous one, using a timer or sleep() in a separate thread. I > am also glad to see this alernative memory handler though, I would like to > ask if there is anything different from using timer way and this patch is > actually useful on real embeded systems. How about performance there? Is it > acceptable? I agree, for embedded devices these wakeups could affect the battery life. 1174003 13 273748 cgarcia 2016-03-12 01:18:57 -0800 Comment on attachment 273748 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=273748&action=review cq- for now while we discuss whether it's worth it supporting this or not. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:143 > + if (ReliefLogger::loggingEnabled()) > + LOG(MemoryPressure, "Polled memory pressure (%s)", isUnderMemoryPressure ? "critical" : "non-critical"); > + > + MemoryPressureHandler::singleton().setUnderMemoryPressure(isUnderMemoryPressure); > + callOnMainThread([isUnderMemoryPressure] { > + MemoryPressureHandler::singleton().respondToMemoryPressure(isUnderMemoryPressure ? Critical::Yes : Critical::No); > + }); This is mostly duplicated code, we could probably move it to a function that receives the isUnderMemoryPressure value. > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:149 > + sleep(s_pollingIntervalInSeconds); > + } while (true); I'm not happy with this either, but I have no idea how to do this if meminfo is not pollable. Note that there's one memory pressure handler per process . . . 1174018 14 eocanha 2016-03-12 03:22:58 -0800 (In reply to comment #11) > I'm not sure /proc/meminfo is pollable, the kernel probably gives the > contents directly when reading, but I haven't actually checked, it's just a > guess. /proc/meminfo doesn't seem to be pollable. I've tried the script "inotifywait /proc/meminfo" and it doesn't get any event, while for a normal text file modified from another terminal it does get the events. 1174021 15 eocanha 2016-03-12 03:40:16 -0800 (In reply to comment #13) > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:149 > > + sleep(s_pollingIntervalInSeconds); > > + } while (true); > > I'm not happy with this either, but I have no idea how to do this if meminfo > is not pollable. Note that there's one memory pressure handler per process . We can use a larger polling interval (5 sec?) and wider memory threshold margins so that we trigger the pressure condition earlier without needing such a high monitoring frequency. Actually, I thing that the current thresholds for remaining memory of 300MB (non critical) and 100MB (critical) are wide enough. About battery consumption, take into account the relative expense of "opening a text file, parsing its first lines and closing it". What can it be, some milliseconds? I can't believe it's so expensive compared to the huge amount of time (in terms of CPU time scale) that the thread is going to be idle. 1174023 16 eocanha 2016-03-12 03:56:47 -0800 (In reply to comment #10) > As I rememeber, the polling way was considered but it was rejected because > of a concern that regularly waking up cpu to read meminfo itself badly > affected on performance. https://bugs.webkit.org/show_bug.cgi?id=123532#c2 . > For the reason, it is intended that MemoryPressureHandler works for only > cgroup avaiable platforms. I know there is a small difference between this > approach and previous one, using a timer or sleep() in a separate thread. I > am also glad to see this alernative memory handler though, I would like to > ask if there is anything different from using timer way and this patch is > actually useful on real embeded systems. How about performance there? Is it > acceptable? I understand the concerns of polling on battery-backed devices, but for our use case (a RaspberryPi2 acting as a Set Top Box) the power consumption isn't a problem. What is really worrying is not being able to control the memory usage and having our application being OOM killed. I invested several days studying our browser with valgrind in our device only to find that we weren't actually having any leak, just a memory pressure handler that wasn't doing its job. In any case, if battery usage is more worrying than OOM for battery-backed devices, what about reading some environment variables when the object is created and enable polling on demand? We could even parameterize the memory limits (per each process) if we use env vars. 1174025 17 273833 eocanha 2016-03-12 04:44:45 -0800 Created attachment 273833 Patch 1174326 18 cgarcia 2016-03-13 23:43:30 -0700 (In reply to comment #15) > (In reply to comment #13) > > > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:149 > > > + sleep(s_pollingIntervalInSeconds); > > > + } while (true); > > > > I'm not happy with this either, but I have no idea how to do this if meminfo > > is not pollable. Note that there's one memory pressure handler per process . > > We can use a larger polling interval (5 sec?) and wider memory threshold > margins so that we trigger the pressure condition earlier without needing > such a high monitoring frequency. Actually, I thing that the current > thresholds for remaining memory of 300MB (non critical) and 100MB (critical) > are wide enough. > > About battery consumption, take into account the relative expense of > "opening a text file, parsing its first lines and closing it". What can it > be, some milliseconds? I can't believe it's so expensive compared to the > huge amount of time (in terms of CPU time scale) that the thread is going to > be idle. The problem is precisely that the thread is never going to be idle, it's going to wake up every second. It's not only a matter of what you do when you wake up, it's just that you are waking up every second. I've seen patches in embedded devices to fix battery drain that simply removed loops like this one. If there's no other way to do this, we should figure out if it's possible to disable this while there's no activity, or pages are all hidden, etc. 1174335 19 changseok 2016-03-14 00:26:45 -0700 (In reply to comment #15) > (In reply to comment #13) > > > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:149 > > > + sleep(s_pollingIntervalInSeconds); > > > + } while (true); > > > > I'm not happy with this either, but I have no idea how to do this if meminfo > > is not pollable. Note that there's one memory pressure handler per process . > > We can use a larger polling interval (5 sec?) and wider memory threshold > margins so that we trigger the pressure condition earlier without needing > such a high monitoring frequency. Actually, I thing that the current > thresholds for remaining memory of 300MB (non critical) and 100MB (critical) > are wide enough. Larger polling interval, less useful MemoryPressureHandler. Memory drain sometimes happen instantly. It means the hitting rate on OOM would decrease, larger interval is set. I don't know how we could figure out a proper threadhold which makes all systems happy. the thresholds you said sound very heuristic to me. I understand the necessity of your patch for RPi, but this is upstream. We need to consider not only RPi but also other systems using gtk. > > About battery consumption, take into account the relative expense of > "opening a text file, parsing its first lines and closing it". What can it > be, some milliseconds? I can't believe it's so expensive compared to the > huge amount of time (in terms of CPU time scale) that the thread is going to > be idle. As KaL explained, opening/reading a file is quite different from what this patch does. The former is a one-time usecase but the latter is something happening forever. Regularly waking a cpu up would prevents systems from going sleep mode or low-power mode. I don't know if this should be covered in application level. The best way would be that we adopt an interface provided by the linux system and that is why the current MemoryPressureHandler is based on the cgroup even though it is not perfect. I hope the cgroup memory management to be improved near time soon. :P 1174359 20 svillar 2016-03-14 02:05:07 -0700 (In reply to comment #18) > (In reply to comment #15) > > (In reply to comment #13) > > > > > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:149 > > > > + sleep(s_pollingIntervalInSeconds); > > > > + } while (true); > > > > > > I'm not happy with this either, but I have no idea how to do this if meminfo > > > is not pollable. Note that there's one memory pressure handler per process . > > > > We can use a larger polling interval (5 sec?) and wider memory threshold > > margins so that we trigger the pressure condition earlier without needing > > such a high monitoring frequency. Actually, I thing that the current > > thresholds for remaining memory of 300MB (non critical) and 100MB (critical) > > are wide enough. > > > > About battery consumption, take into account the relative expense of > > "opening a text file, parsing its first lines and closing it". What can it > > be, some milliseconds? I can't believe it's so expensive compared to the > > huge amount of time (in terms of CPU time scale) that the thread is going to > > be idle. > > The problem is precisely that the thread is never going to be idle, it's > going to wake up every second. It's not only a matter of what you do when > you wake up, it's just that you are waking up every second. I've seen > patches in embedded devices to fix battery drain that simply removed loops > like this one. If there's no other way to do this, we should figure out if > it's possible to disable this while there's no activity, or pages are all > hidden, etc. Yes please, let's not land something like this unless we want embedded devices not to use webkitgtk 1174365 21 eocanha 2016-03-14 02:34:11 -0700 (In reply to comment #16) > In any case, if battery usage is more worrying than OOM for battery-backed > devices, what about reading some environment variables when the object is > created and enable polling on demand? We could even parameterize the memory > limits (per each process) if we use env vars. Nobody commented anything about this proposal of using an environment variable to enable and parameterize the new memory measurement alternative. It would be disabled if there's no environment variable defined and enabled otherwise. An example of how this environment variable could be defined: export MEMORY_PRESSURE_HANDLER_MEMINFO=MiniBrowser:500M,WebProcess:100M/20M,*Process:500M/100M The pattern is: MEMORY_PRESSURE_HANDLER_MEMINFO=<process-name-pattern>:[<optional-non-critical-limit>/]<critical-limit>, ... I think this alternative would make everybody happy: no battery drain by default (when the variable isn't defined), and the memory exhaustion problem solved "if it's important enough for your use case and you know what you're doing". 1179058 22 clopez 2016-03-30 08:10:54 -0700 I think we need something like this, because WebKit don't drops caches if the memory pressure handler is not working, which causes that the memory usage continues to grow forever causing all sorts of problems. The current implementation based on cgroups doesn't work on a "standard" GNU/Linux system, because memory cgroups don't work out of the box. To enable memory cgroups you need to configure quite a few things, you even have to modify the kernel boot parameters (by setting at least cgroup_enable=memory on it). Also the interfaces /sys/fs/cgroup/memory/cgroup.event_control and /sys/fs/cgroup/memory/memory.pressure_level are not accessible by a normal user by default (only by root) So I doubt our current implementation based on cgroups is actually working on any system other than those the admin took care of fine tuning this or on embedded devices running webkit as root. So I think this patch is a good fallback for the rest of systems (mainly Desktops running a standard Linux distribution like ours). Regarding the concerns about that the wakeups could affect the battery life I propose that we only enable this fallback memory pressure handler when the system is not running on battery. We can reliably detect this by inspecting some values on /sys. For example, we can borrow either the systemd implementation to detect this <https://github.com/systemd/systemd/blob/master/src/basic/util.c#L498> or the e2fsprogs one <http://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/tree/e2fsck/unix.c#n284> (yes, fsck avoids running automatically if it detects you are on battery) And I don't think we should hide this feature behind an obscure environment variable than other than we developers and power users will know about, but make it run by default when the cgroup based memory pressure handler fails and when the system is not running on battery. Note: is a shame that Linux (in 2016!) don't has a standard/reliable way to poll for low memory conditions. 1179061 23 cgarcia 2016-03-30 08:37:40 -0700 A better approach could be to never wake up when process is idle, and poll only when there's other activity, since it's very unlikely that the memory grows if the process is idle. I'm not sure how we can detect that, though. Maybe we can invent a run loop source that is only triggered when other run loops are dispatched, or something like that. 1179083 24 clopez 2016-03-30 10:02:20 -0700 (In reply to comment #23) > A better approach could be to never wake up when process is idle, and poll > only when there's other activity, since it's very unlikely that the memory > grows if the process is idle. I'm not sure how we can detect that, though. > Maybe we can invent a run loop source that is only triggered when other run > loops are dispatched, or something like that. I don't think is unlikely at all to enter in a low memory scenario when webkit is idle. Just suppose that the user minimizes the browser and loads up libreoffice or any other application. In that situation webkit should be able to get the memory pressure notification as fast as possible and free the caches potentially keeping the system from swapping. 1193817 25 273833 mcatanzaro 2016-05-17 08:25:40 -0700 Comment on attachment 273833 Patch I think this patch needs to address clopez's feedback: """Regarding the concerns about that the wakeups could affect the battery life I propose that we only enable this fallback memory pressure handler when the system is not running on battery. We can reliably detect this by inspecting some values on /sys. For example, we can borrow either the systemd implementation to detect this <https://github.com/systemd/systemd/blob/master/src/basic/util.c#L498> or the e2fsprogs one <http://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/tree/e2fsck/unix.c#n284> (yes, fsck avoids running automatically if it detects you are on battery) And I don't think we should hide this feature behind an obscure environment variable than other than we developers and power users will know about, but make it run by default when the cgroup based memory pressure handler fails and when the system is not running on battery.""" 1206027 26 tonikitoo 2016-06-28 07:55:36 -0700 (In reply to comment #25) > Comment on attachment 273833 [details] > Patch > > I think this patch needs to address clopez's feedback: > > """Regarding the concerns about that the wakeups could affect the battery > life I propose that we only enable this fallback memory pressure handler > when the system is not running on battery. > > We can reliably detect this by inspecting some values on /sys. For example, > we can borrow either the systemd implementation to detect this > <https://github.com/systemd/systemd/blob/master/src/basic/util.c#L498> or > the e2fsprogs one > <http://git.kernel.org/cgit/fs/ext2/e2fsprogs.git/tree/e2fsck/unix.c#n284> > (yes, fsck avoids running automatically if it detects you are on battery) > > > And I don't think we should hide this feature behind an obscure environment > variable than other than we developers and power users will know about, but > make it run by default when the cgroup based memory pressure handler fails > and when the system is not running on battery.""" For the record, on ChromeOS, the kernel provides a file (available for reading if system is under low mem conditions): // This is the file that will exist if low memory notification is available // on the device. Whenever it becomes readable, it signals a low memory // condition. const char kLowMemFile[] = "/dev/chromeos-low-mem"; No parsing needed of its content, just verifying its presence is enough. The check happens every 1s, and I believe it would not be as expensive as actually reading and parsing /proc/meminfo every 1s. If Linux would have something like this by default, it would do it, as far as I can tell. 1207091 27 282544 cgarcia 2016-07-01 06:20:17 -0700 Created attachment 282544 Different approach This is a different approach to the previous patch. If there' no other way than polling an parsing /proc/meminfo, let's try to minimize the problems. There's a memory pressure handler in every secondary process, not only the web process but also in the network and plugin processes. So, this patch does the polling in a thread in the UI process to ensure it's only one process waking up. It uses eventFD to notify the other processes about memory pressure. The poll interval is calculated depending on the memory usage in every moment, between 1 and 15 seconds, to try to wake up less often when memory usage is low. Also instead of using a fixed size in MB of free memory as a threshold, it uses a percentage of the memory used. Everything can be configured just modifying some global variables in case any of the values I set is not good enough. And finally instead of using the MemFree value from /proce/meminfo, it uses the MemAvailable value, that was added to the kernel in version 3.something, with a fallback implementation based on the MemAvailable values implementation in the kernel in case of using an old kernel. This is still not perfect and it can probably be improved (use different configuration values, stop the poll in case of running on batery, etc.), but hopefully it works well enough. 1207438 28 cgarcia 2016-07-02 01:33:16 -0700 (In reply to comment #27) > Created attachment 282544 [details] > Different approach > > This is a different approach to the previous patch. If there' no other way > than polling an parsing /proc/meminfo, let's try to minimize the problems. > There's a memory pressure handler in every secondary process, not only the > web process but also in the network and plugin processes. So, this patch > does the polling in a thread in the UI process to ensure it's only one > process waking up. It uses eventFD to notify the other processes about > memory pressure. The poll interval is calculated depending on the memory > usage in every moment, between 1 and 15 seconds, Oops, I meant between 1 and 5. 1209011 29 282544 svillar 2016-07-08 01:15:30 -0700 Comment on attachment 282544 Different approach Looks good to me in general, but the mix of negative numbers and size_t is a bit shocking to me. 1209454 30 changseok 2016-07-09 10:48:14 -0700 (In reply to comment #27) > Created attachment 282544 [details] > Different approach > > This is a different approach to the previous patch. If there' no other way > than polling an parsing /proc/meminfo, let's try to minimize the problems. > There's a memory pressure handler in every secondary process, not only the > web process but also in the network and plugin processes. So, this patch > does the polling in a thread in the UI process to ensure it's only one > process waking up. It uses eventFD to notify the other processes about > memory pressure. The poll interval is calculated depending on the memory > usage in every moment, between 1 and 15 seconds, to try to wake up less > often when memory usage is low. Also instead of using a fixed size in MB of > free memory as a threshold, it uses a percentage of the memory used. > Everything can be configured just modifying some global variables in case > any of the values I set is not good enough. And finally instead of using the > MemFree value from /proce/meminfo, it uses the MemAvailable value, that was > added to the kernel in version 3.something, with a fallback implementation > based on the MemAvailable values implementation in the kernel in case of > using an old kernel. This is still not perfect and it can probably be > improved (use different configuration values, stop the poll in case of > running on batery, etc.), but hopefully it works well enough. Fair enough. 1210430 31 283524 cgarcia 2016-07-13 06:31:51 -0700 Created attachment 283524 Updated patch Just rebased after updating patch for bug #159346 1210893 32 cgarcia 2016-07-13 23:47:53 -0700 (In reply to comment #29) > Comment on attachment 282544 [details] > Different approach > > Looks good to me in general, but the mix of negative numbers and size_t is a > bit shocking to me. We can make the code a bit better by using a macro or global variable like DFGValidate or Vector do: #define notSet (static_cast<size_t>(-1)) const size_t notFound = static_cast<size_t>(-1); 1210898 33 283609 cgarcia 2016-07-14 00:01:36 -0700 Created attachment 283609 Updated patch 1210899 34 commit-queue 2016-07-14 00:03:38 -0700 Attachment 283609 did not pass style-queue: ERROR: Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:230: More than one command on the same line [whitespace/newline] [4] Total errors found: 1 in 20 files If any of these errors are false positives, please file a bug against check-webkit-style. 1210930 35 283624 cgarcia 2016-07-14 01:23:34 -0700 Created attachment 283624 Try to fix builds 1210931 36 commit-queue 2016-07-14 01:25:47 -0700 Attachment 283624 did not pass style-queue: ERROR: Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:231: More than one command on the same line [whitespace/newline] [4] Total errors found: 1 in 20 files If any of these errors are false positives, please file a bug against check-webkit-style. 1211926 37 283624 svillar 2016-07-18 01:34:01 -0700 Comment on attachment 283624 Try to fix builds View in context: https://bugs.webkit.org/attachment.cgi?id=283624&action=review > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:196 > +bool MemoryPressureHandler::tryEnsureEventFD() tryEnsure seems a bit weird name to me. > Source/WebKit2/NetworkProcess/NetworkProcess.cpp:196 > +void NetworkProcess::initializeNetworkProcess(NetworkProcessCreationParameters&& parameters) Seems unrelated > Source/WebKit2/PluginProcess/PluginProcess.cpp:142 > + memoryPressureHandler.install(); I understand you move this here because you need to set the handle before the install, I hope this does not add any race condition I've seen before when moving stuff like this. > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:47 > +static const size_t notSet = static_cast<size_t>(-1); Instead of notSet, consider making lowWatermarkPages() and calculateMemoryAvailable() return an Optional<size_t>. > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:189 > + // See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773 I'd find more useful to have this link just above the function definition. > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:195 > + return ((memoryTotal - memoryAvailable) * 100) / memoryTotal; Do we have any guarantee that memoryTotal is not 0? Do we have any guarantee that memoryTotal > memoryAvailable ? 1211931 38 cgarcia 2016-07-18 01:41:55 -0700 (In reply to comment #37) > Comment on attachment 283624 [details] > Try to fix builds > > View in context: > https://bugs.webkit.org/attachment.cgi?id=283624&action=review Thanks for the review. > > Source/WebCore/platform/linux/MemoryPressureHandlerLinux.cpp:196 > > +bool MemoryPressureHandler::tryEnsureEventFD() > > tryEnsure seems a bit weird name to me. It tries to ensure an eventFD. The try is because it can fail, and the ensure is because it doesn't return the new FD, but updates the member, and does nothing if we already have an fd. > > Source/WebKit2/NetworkProcess/NetworkProcess.cpp:196 > > +void NetworkProcess::initializeNetworkProcess(NetworkProcessCreationParameters&& parameters) > > Seems unrelated It's not actually. We can't do Attachment::releaseFileDescriptor with a const reference. This change is consistent with all other initializeFooProcess methods. > > Source/WebKit2/PluginProcess/PluginProcess.cpp:142 > > + memoryPressureHandler.install(); > > I understand you move this here because you need to set the handle before > the install, I hope this does not add any race condition I've seen before > when moving stuff like this. No, I don't think so, this is what all other processes do, so this is also consistent. > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:47 > > +static const size_t notSet = static_cast<size_t>(-1); > > Instead of notSet, consider making lowWatermarkPages() and > calculateMemoryAvailable() return an Optional<size_t>. Ok, I'll check it again. > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:189 > > + // See https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773 > > I'd find more useful to have this link just above the function definition. > > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:195 > > + return ((memoryTotal - memoryAvailable) * 100) / memoryTotal; > > Do we have any guarantee that memoryTotal is not 0? > > Do we have any guarantee that memoryTotal > memoryAvailable ? I'll check this 1211936 39 cgarcia 2016-07-18 02:05:15 -0700 Committed r203342: <http://trac.webkit.org/changeset/203342> 1212057 40 283624 tonikitoo 2016-07-18 12:50:37 -0700 Comment on attachment 283624 Try to fix builds View in context: https://bugs.webkit.org/attachment.cgi?id=283624&action=review > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:29 > +#if OS(LINUX) is OS(LINUX) needed given that we are within Source/WebKit2/UIProcess/*linux*/...? > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:128 > +static size_t calculateMemoryAvailable(size_t memoryFree, size_t activeFile, size_t inactiveFile, size_t slabReclaimable) > +{ > + if (memoryFree == notSet || activeFile == notSet || inactiveFile == notSet || slabReclaimable == notSet) > + return notSet; > + > + size_t lowWatermark = lowWatermarkPages(); > + if (lowWatermark == notSet) > + return notSet; > + > + lowWatermark *= systemPageSize() / KB; > + > + // Estimate the amount of memory available for userspace allocations, without causing swapping. > + // Free memory cannot be taken below the low watermark, before the system starts swapping. > + lowWatermark *= systemPageSize() / KB; > + size_t memoryAvailable = memoryFree - lowWatermark; > + > + // Not all the page cache can be freed, otherwise the system will start swapping. Assume at least > + // half of the page cache, or the low watermark worth of cache, needs to stay. > + size_t pageCache = activeFile + inactiveFile; > + pageCache -= std::min(pageCache / 2, lowWatermark); > + memoryAvailable += pageCache; > + > + // Part of the reclaimable slab consists of items that are in use, and cannot be freed. > + // Cap this estimate at the low watermark. > + memoryAvailable += slabReclaimable - std::min(slabReclaimable / 2, lowWatermark); > + return memoryAvailable; Getting late to the party here, but is it really worth to to add support for kernels older than 2014/January? this adds some complexity to the patch that I would rather avoid if possible. > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:186 > + if (memoryAvailable == notSet) { I believe most recent kernels have "MemAvailable" in /proc/meminfo. So cant we shortcut it here by only reading "MemFree", "Active(file)", "Inactive(file)" and "SReclaimable" only if mem == notSet? So move part of the switch above (lines 150 - 176) to with the "if" line 186. Also, we could name it explicitly like "readProcMemInfoEntriesForAncientKernels" or so. > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:227 > +bool MemoryPressureMonitor::isEnabled() const? 1212293 41 cgarcia 2016-07-19 00:19:08 -0700 (In reply to comment #40) > Comment on attachment 283624 [details] > Try to fix builds > > View in context: > https://bugs.webkit.org/attachment.cgi?id=283624&action=review > > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:29 > > +#if OS(LINUX) > > is OS(LINUX) needed given that we are within > Source/WebKit2/UIProcess/*linux*/...? Right! we don't really need that here. > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:128 > > +static size_t calculateMemoryAvailable(size_t memoryFree, size_t activeFile, size_t inactiveFile, size_t slabReclaimable) > > +{ > > + if (memoryFree == notSet || activeFile == notSet || inactiveFile == notSet || slabReclaimable == notSet) > > + return notSet; > > + > > + size_t lowWatermark = lowWatermarkPages(); > > + if (lowWatermark == notSet) > > + return notSet; > > + > > + lowWatermark *= systemPageSize() / KB; > > + > > + // Estimate the amount of memory available for userspace allocations, without causing swapping. > > + // Free memory cannot be taken below the low watermark, before the system starts swapping. > > + lowWatermark *= systemPageSize() / KB; > > + size_t memoryAvailable = memoryFree - lowWatermark; > > + > > + // Not all the page cache can be freed, otherwise the system will start swapping. Assume at least > > + // half of the page cache, or the low watermark worth of cache, needs to stay. > > + size_t pageCache = activeFile + inactiveFile; > > + pageCache -= std::min(pageCache / 2, lowWatermark); > > + memoryAvailable += pageCache; > > + > > + // Part of the reclaimable slab consists of items that are in use, and cannot be freed. > > + // Cap this estimate at the low watermark. > > + memoryAvailable += slabReclaimable - std::min(slabReclaimable / 2, lowWatermark); > > + return memoryAvailable; > > Getting late to the party here, but is it really worth to to add support for > kernels older than 2014/January? this adds some complexity to the patch that > I would rather avoid if possible. We support versions of our deps released even earlier (for example GTK+ 3.6, cairo 1.10.2, etc. released in 2012), because of old distros. I haven't checked the kernel version used by old distros, though, but I assumed it could be older. We don't really have a minimum kernel version supported. This is the same discussion of the minimum versions supported by our deps. I don't think it's that much complexity in any case. > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:186 > > + if (memoryAvailable == notSet) { > > I believe most recent kernels have "MemAvailable" in /proc/meminfo. Yes. > So cant we shortcut it here by only reading "MemFree", "Active(file)", > "Inactive(file)" and "SReclaimable" only if mem == notSet? There's an early break before, so as soon as we read MemAvailable we stop reading more. > So move part of the switch above (lines 150 - 176) to with the "if" line 186. And reading twice? I prefer to read once and break as soon as we have the indo we need as we currently do. We stop reading when we have MemAvailable or all others needed for the fallback implementation. > Also, we could name it explicitly like > "readProcMemInfoEntriesForAncientKernels" or so. There's a comment explaining why we have that function, but yes we could probably rename it. It's a private function in a cpp file, so not a big deal in any case. > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:227 > > +bool MemoryPressureMonitor::isEnabled() > > const? It's static, this is used to avoid creating the singleton instance in case of using cgroups. 1212706 42 cgarcia 2016-07-20 05:23:46 -0700 (In reply to comment #41) > (In reply to comment #40) > > Comment on attachment 283624 [details] > > Try to fix builds > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=283624&action=review > > > > > Source/WebKit2/UIProcess/linux/MemoryPressureMonitor.cpp:29 > > > +#if OS(LINUX) > > > > is OS(LINUX) needed given that we are within > > Source/WebKit2/UIProcess/*linux*/...? > > Right! we don't really need that here. We actually need it, because we are unconditionally adding the file to the build, even for other unix systems like freebsd or macosx. 273468 2016-03-09 13:40:11 -0800 2016-03-11 11:31:27 -0800 Patch bug-155255-20160309213957.patch text/plain 7490 eocanha U3VidmVyc2lvbiBSZXZpc2lvbjogMTk3ODU3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWZmMjRlMDNkMjZiYzVj NDRkNjlhMGFlNjI1Y2I2ZjljYTQ3OTBiNC4uYmE0ODE3Y2Q3M2ZkYWYzMWExZGU3NDMxZjBmMzNh MTNkYTMxZmNlZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE2LTAzLTA5ICBFbnJp cXVlIE9jYcOxYSBHb256w6FsZXogIDxlb2NhbmhhQGlnYWxpYS5jb20+CisKKyAgICAgICAgUG9s bCAvcHJvYy9tZW1pbmZvIHRvIG1lYXN1cmUgbWVtb3J5IHByZXNzdXJlIG9uIExpbnV4IGlmIGNn cm91cHMgaXNuJ3QgYXZhaWxhYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNTUyNTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBObyBuZXcgdGVzdHMgbmVlZGVkLgorCisgICAgICAgICogcGxhdGZvcm0v TWVtb3J5UHJlc3N1cmVIYW5kbGVyLmg6IEFkZGVkIHBvbGxNZW1vcnlQcmVzc3VyZSgpLgorICAg ICAgICAqIHBsYXRmb3JtL2xpbnV4L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcDogQWRk ZWQgbWVtaW5mbyBmYWxsYmFjaworICAgICAgICBpZiBjZ3JvdXBzIGFyZW4ndCBwcmVzZW50Lgor ICAgICAgICAoV2ViQ29yZTo6TWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpwb2xsTWVtb3J5UHJlc3N1 cmUpOiBPcGVuIC9wcm9jL21lbWluZm8sCisgICAgICAgIHBhcnNlIGl0IGFuZCByZXBvcnQgcHJl c3N1cmUgaWYgVm1TaXplIGlzIGJleW9uZCB0aGUgcHJlZGVmaW5lZAorICAgICAgICB0aHJlc2hv bGRzLiBLZWVwIHBvbGxpbmcgcGVyaW9kaWNhbGx5IGlmIG5vdC4KKyAgICAgICAgKFdlYkNvcmU6 Ok1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCk6IE1hbmFnZSBib3RoIHdheXMgdG8gZGV0 ZWN0CisgICAgICAgIHByZXNzdXJlLgorCiAyMDE2LTAzLTA5ICBNYW51ZWwgUmVnbyBDYXNhc25v dmFzICA8cmVnb0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFtjc3MtZ3JpZF0gQWxsb3cgdG8gcGxh Y2UgcG9zaXRpb25lZCBncmlkIGl0ZW1zIG9uIHRoZSBwYWRkaW5nCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL01lbW9yeVByZXNzdXJlSGFuZGxlci5oCmluZGV4IDcxMTRkMmMyNTc1YTk5 ZjEwZDM5MmEyYjY2MDFiNDc3ZjdmN2RkOTkuLjQyYTk5ZTM4YzNjOTJlOTZiZWYxMjg3NjhmMTY2 ZWIwNjZlMjA3MTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVBy ZXNzdXJlSGFuZGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVByZXNz dXJlSGFuZGxlci5oCkBAIC04MSw2ICs4MSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlc3BvbmRU b01lbW9yeVByZXNzdXJlSWZOZWVkZWQoKTsKICNlbGlmIE9TKExJTlVYKQogICAgIHN0YXRpYyB2 b2lkIHdhaXRGb3JNZW1vcnlQcmVzc3VyZUV2ZW50KHZvaWQqKTsKKyAgICBzdGF0aWMgdm9pZCBw b2xsTWVtb3J5UHJlc3N1cmUodm9pZCopOwogI2VuZGlmCiAKICAgICBjbGFzcyBSZWxpZWZMb2dn ZXIgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbGludXgvTWVtb3J5UHJl c3N1cmVIYW5kbGVyTGludXguY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbGludXgvTWVt b3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCmluZGV4IGQwZDEzNmFjYzEzNGViZTk5NzFiYzQx ZGQzMDU0NTJhM2E0NTExOTUuLjU4ZDRmZDkyYjE4OTE2ODYyOThkMjI4NGI3ZTU2NTI4NGRiYTYz OWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2xpbnV4L01lbW9yeVByZXNz dXJlSGFuZGxlckxpbnV4LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9saW51eC9N ZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKQEAgLTUxLDEwICs1MSwxNSBAQCBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAvLyBsb3cgbWVtb3J5IGV2ZW50cywgZ3JlYXRseSByZWR1Y2luZyBDUFUg dXNhZ2UuCiBzdGF0aWMgY29uc3QgdW5zaWduZWQgc19taW5pbXVtSG9sZE9mZlRpbWUgPSA1Owog c3RhdGljIGNvbnN0IHVuc2lnbmVkIHNfaG9sZE9mZk11bHRpcGxpZXIgPSAyMDsKK3N0YXRpYyBj b25zdCB1bnNpZ25lZCBzX3BvbGxUaW1lU2VjID0gMTsKK3N0YXRpYyBjb25zdCBzaXplX3Qgc19t ZW1Dcml0aWNhbExpbWl0ID0gMTAwICogS0IgKiBLQjsgLy8gMTAwIE1CCitzdGF0aWMgY29uc3Qg c2l6ZV90IHNfbWVtTm9uQ3JpdGljYWxMaW1pdCA9IDMwMCAqIEtCICogS0I7IC8vIDMwMCBNQgog CiBzdGF0aWMgY29uc3QgY2hhciogc19jZ3JvdXBNZW1vcnlQcmVzc3VyZUxldmVsID0gIi9zeXMv ZnMvY2dyb3VwL21lbW9yeS9tZW1vcnkucHJlc3N1cmVfbGV2ZWwiOwogc3RhdGljIGNvbnN0IGNo YXIqIHNfY2dyb3VwRXZlbnRDb250cm9sID0gIi9zeXMvZnMvY2dyb3VwL21lbW9yeS9jZ3JvdXAu ZXZlbnRfY29udHJvbCI7CiBzdGF0aWMgY29uc3QgY2hhciogc19wcm9jZXNzU3RhdHVzID0gIi9w cm9jL3NlbGYvc3RhdHVzIjsKK3N0YXRpYyBjb25zdCBjaGFyKiBzX21lbUluZm8gPSAiL3Byb2Mv bWVtaW5mbyI7CisKIAogc3RhdGljIGlubGluZSBTdHJpbmcgbmV4dFRva2VuKEZJTEUqIGZpbGUp CiB7CkBAIC0xMDUsNiArMTEwLDQ1IEBAIHZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjp3YWl0 Rm9yTWVtb3J5UHJlc3N1cmVFdmVudCh2b2lkKikKICAgICB9KTsKIH0KIAordm9pZCBNZW1vcnlQ cmVzc3VyZUhhbmRsZXI6OnBvbGxNZW1vcnlQcmVzc3VyZSh2b2lkKikKK3sKKyAgICBBU1NFUlQo IWlzTWFpblRocmVhZCgpKTsKKworICAgIGRvIHsKKyAgICAgICAgc2l6ZV90IG1lbUZyZWUgPSBz dGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsgLy8gYnl0ZXMKKworICAgICAgICBGSUxFKiBmaWxlID0g Zm9wZW4oc19tZW1JbmZvLCAiciIpOworICAgICAgICBpZiAoIWZpbGUpCisgICAgICAgICAgICBy ZXR1cm47CisKKyAgICAgICAgU3RyaW5nIHRva2VuID0gbmV4dFRva2VuKGZpbGUpOworICAgICAg ICB3aGlsZSAoIXRva2VuLmlzRW1wdHkoKSkgeworICAgICAgICAgICAgaWYgKHRva2VuID09ICJN ZW1GcmVlOiIpIHsKKyAgICAgICAgICAgICAgICBtZW1GcmVlID0gbmV4dFRva2VuKGZpbGUpLnRv VUludDY0KCkgKiBLQjsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIHRva2VuID0gbmV4dFRva2VuKGZpbGUpOworICAgICAgICB9CisgICAgICAgIGZj bG9zZShmaWxlKTsKKworICAgICAgICBpZiAobWVtRnJlZSA8IHNfbWVtTm9uQ3JpdGljYWxMaW1p dCkgeworICAgICAgICAgICAgYm9vbCBjcml0aWNhbCA9IG1lbUZyZWUgPCBzX21lbUNyaXRpY2Fs TGltaXQ7CisKKyAgICAgICAgICAgIGlmIChSZWxpZWZMb2dnZXI6OmxvZ2dpbmdFbmFibGVkKCkp CisgICAgICAgICAgICAgICAgTE9HKE1lbW9yeVByZXNzdXJlLCAiUG9sbGVkIG1lbW9yeSBwcmVz c3VyZSAoJXMpIiwgY3JpdGljYWwgPyAiY3JpdGljYWwiIDogIm5vbi1jcml0aWNhbCIpOworCisg ICAgICAgICAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRvbigpLnNldFVuZGVyTWVt b3J5UHJlc3N1cmUoY3JpdGljYWwpOworICAgICAgICAgICAgY2FsbE9uTWFpblRocmVhZChbY3Jp dGljYWxdIHsKKyAgICAgICAgICAgICAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRv bigpLnJlc3BvbmRUb01lbW9yeVByZXNzdXJlKGNyaXRpY2FsID8gQ3JpdGljYWw6OlllcyA6IENy aXRpY2FsOjpObyk7CisgICAgICAgICAgICB9KTsKKworICAgICAgICAgICAgcmV0dXJuOworICAg ICAgICB9CisKKyAgICAgICAgc2xlZXAoc19wb2xsVGltZVNlYyk7CisgICAgfSB3aGlsZSAodHJ1 ZSk7Cit9CisKIGlubGluZSB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6bG9nRXJyb3JBbmRD bG9zZUZEcyhjb25zdCBjaGFyKiBsb2cpCiB7CiAgICAgaWYgKGxvZykKQEAgLTEyNSwzOCArMTY5 LDY0IEBAIHZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjppbnN0YWxsKCkKICAgICBpZiAobV9p bnN0YWxsZWQpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fZXZlbnRGRCA9IGV2ZW50ZmQoMCwg RUZEX0NMT0VYRUMpOwotICAgIGlmIChtX2V2ZW50RkQgPT0gLTEpIHsKLSAgICAgICAgTE9HKE1l bW9yeVByZXNzdXJlLCAiZXZlbnRmZCgpIGZhaWxlZDogJW0iKTsKLSAgICAgICAgcmV0dXJuOwot ICAgIH0KKyAgICBib29sIGNncm91cHNQcmVzc3VyZUhhbmRsZXJPayA9IGZhbHNlOwogCi0gICAg bV9wcmVzc3VyZUxldmVsRkQgPSBvcGVuKHNfY2dyb3VwTWVtb3J5UHJlc3N1cmVMZXZlbCwgT19D TE9FWEVDIHwgT19SRE9OTFkpOwotICAgIGlmIChtX3ByZXNzdXJlTGV2ZWxGRCA9PSAtMSkgewot ICAgICAgICBsb2dFcnJvckFuZENsb3NlRkRzKCJGYWlsZWQgdG8gb3BlbiBtZW1vcnkucHJlc3N1 cmVfbGV2ZWwiKTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KKyAgICBkbyB7CisgICAgICAgIG1f ZXZlbnRGRCA9IGV2ZW50ZmQoMCwgRUZEX0NMT0VYRUMpOworICAgICAgICBpZiAobV9ldmVudEZE ID09IC0xKSB7CisgICAgICAgICAgICBMT0coTWVtb3J5UHJlc3N1cmUsICJldmVudGZkKCkgZmFp bGVkOiAlbSIpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KIAotICAgIGludCBmZCA9 IG9wZW4oc19jZ3JvdXBFdmVudENvbnRyb2wsIE9fQ0xPRVhFQyB8IE9fV1JPTkxZKTsKLSAgICBp ZiAoZmQgPT0gLTEpIHsKLSAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIG9w ZW4gY2dyb3VwLmV2ZW50X2NvbnRyb2wiKTsKLSAgICAgICAgcmV0dXJuOwotICAgIH0KKyAgICAg ICAgbV9wcmVzc3VyZUxldmVsRkQgPSBvcGVuKHNfY2dyb3VwTWVtb3J5UHJlc3N1cmVMZXZlbCwg T19DTE9FWEVDIHwgT19SRE9OTFkpOworICAgICAgICBpZiAobV9wcmVzc3VyZUxldmVsRkQgPT0g LTEpIHsKKyAgICAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byBvcGVuIG1l bW9yeS5wcmVzc3VyZV9sZXZlbCIpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KIAot ICAgIGNoYXIgbGluZVsxMjhdID0gezAsIH07Ci0gICAgaWYgKHNucHJpbnRmKGxpbmUsIHNpemVv ZihsaW5lKSwgIiVkICVkIGxvdyIsIG1fZXZlbnRGRCwgbV9wcmVzc3VyZUxldmVsRkQpIDwgMAot ICAgICAgICB8fCB3cml0ZShmZCwgbGluZSwgc3RybGVuKGxpbmUpICsgMSkgPCAwKSB7Ci0gICAg ICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byB3cml0ZSBjZ3JvdXAuZXZlbnRfY29u dHJvbCIpOworICAgICAgICBpbnQgZmQgPSBvcGVuKHNfY2dyb3VwRXZlbnRDb250cm9sLCBPX0NM T0VYRUMgfCBPX1dST05MWSk7CisgICAgICAgIGlmIChmZCA9PSAtMSkgeworICAgICAgICAgICAg bG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIG9wZW4gY2dyb3VwLmV2ZW50X2NvbnRyb2wi KTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisKKyAgICAgICAgY2hhciBsaW5lWzEy OF0gPSB7MCwgfTsKKyAgICAgICAgaWYgKHNucHJpbnRmKGxpbmUsIHNpemVvZihsaW5lKSwgIiVk ICVkIGxvdyIsIG1fZXZlbnRGRCwgbV9wcmVzc3VyZUxldmVsRkQpIDwgMAorICAgICAgICAgICAg fHwgd3JpdGUoZmQsIGxpbmUsIHN0cmxlbihsaW5lKSArIDEpIDwgMCkgeworICAgICAgICAgICAg bG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIHdyaXRlIGNncm91cC5ldmVudF9jb250cm9s Iik7CisgICAgICAgICAgICBjbG9zZShmZCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAg fQogICAgICAgICBjbG9zZShmZCk7Ci0gICAgICAgIHJldHVybjsKKworICAgICAgICBtX3RocmVh ZElEID0gY3JlYXRlVGhyZWFkKHdhaXRGb3JNZW1vcnlQcmVzc3VyZUV2ZW50LCB0aGlzLCAiV2Vi Q29yZTogTWVtb3J5UHJlc3N1cmVIYW5kbGVyIik7CisgICAgICAgIGlmICghbV90aHJlYWRJRCkg eworICAgICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIGNyZWF0ZSBhIHRo cmVhZCBmb3IgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIik7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgfQorCisgICAgICAgIExPRyhNZW1vcnlQcmVzc3VyZSwgIkNncm91cHMgbWVtb3J5IHBy ZXNzdXJlIGhhbmRsZXIgaW5zdGFsbGVkLiIpOworICAgICAgICBjZ3JvdXBzUHJlc3N1cmVIYW5k bGVyT2sgPSB0cnVlOworICAgIH0gd2hpbGUgKGZhbHNlKTsKKworICAgIGJvb2wgdm1zdGF0UHJl c3N1cmVIYW5kbGVyT2sgPSBmYWxzZTsKKworICAgIC8vIElmIGNncm91cHMgaXNuJ3QgYXZhaWxh YmxlLCB0cnkgdG8gdXNlIGEgc2ltcGxlciBwb2xsIG1ldGhvZCBiYXNlZCBvbiBtZW1pbmZvLgor ICAgIGlmICghY2dyb3Vwc1ByZXNzdXJlSGFuZGxlck9rKSB7CisgICAgICAgIGRvIHsKKyAgICAg ICAgICAgIG1fdGhyZWFkSUQgPSBjcmVhdGVUaHJlYWQocG9sbE1lbW9yeVByZXNzdXJlLCB0aGlz LCAiV2ViQ29yZTogTWVtb3J5UHJlc3N1cmVIYW5kbGVyIik7CisgICAgICAgICAgICBpZiAoIW1f dGhyZWFkSUQpIHsKKyAgICAgICAgICAgICAgICBsb2dFcnJvckFuZENsb3NlRkRzKCJGYWlsZWQg dG8gY3JlYXRlIGEgdGhyZWFkIGZvciBNZW1vcnlQcmVzc3VyZUhhbmRsZXIiKTsKKyAgICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgTE9HKE1lbW9yeVBy ZXNzdXJlLCAiVm1zdGF0IG1lbW9yeSBwcmVzc3VyZSBoYW5kbGVyIGluc3RhbGxlZC4iKTsKKyAg ICAgICAgICAgIHZtc3RhdFByZXNzdXJlSGFuZGxlck9rID0gdHJ1ZTsKKyAgICAgICAgfSB3aGls ZSAoZmFsc2UpOwogICAgIH0KLSAgICBjbG9zZShmZCk7CiAKLSAgICBtX3RocmVhZElEID0gY3Jl YXRlVGhyZWFkKHdhaXRGb3JNZW1vcnlQcmVzc3VyZUV2ZW50LCB0aGlzLCAiV2ViQ29yZTogTWVt b3J5UHJlc3N1cmVIYW5kbGVyIik7Ci0gICAgaWYgKCFtX3RocmVhZElEKSB7Ci0gICAgICAgIGxv Z0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byBjcmVhdGUgYSB0aHJlYWQgZm9yIE1lbW9yeVBy ZXNzdXJlSGFuZGxlciIpOworICAgIGlmICghY2dyb3Vwc1ByZXNzdXJlSGFuZGxlck9rICYmICF2 bXN0YXRQcmVzc3VyZUhhbmRsZXJPaykKICAgICAgICAgcmV0dXJuOwotICAgIH0KIAogICAgIGlm IChSZWxpZWZMb2dnZXI6OmxvZ2dpbmdFbmFibGVkKCkgJiYgaXNVbmRlck1lbW9yeVByZXNzdXJl KCkpCiAgICAgICAgIExPRyhNZW1vcnlQcmVzc3VyZSwgIlN5c3RlbSBpcyBubyBsb25nZXIgdW5k ZXIgbWVtb3J5IHByZXNzdXJlLiIpOwo= 273748 2016-03-11 11:31:38 -0800 2016-03-12 04:44:35 -0800 Patch bug-155255-20160311193126.patch text/plain 6894 eocanha U3VidmVyc2lvbiBSZXZpc2lvbjogMTk3ODU3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWZmMjRlMDNkMjZiYzVj NDRkNjlhMGFlNjI1Y2I2ZjljYTQ3OTBiNC4uZDZhZTE5MzU3OTY4N2QwMDY4ZTQ4ZjkxODk4MTIz MTdkOTllYjhjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIzIEBACisyMDE2LTAzLTExICBFbnJp cXVlIE9jYcOxYSBHb256w6FsZXogIDxlb2NhbmhhQGlnYWxpYS5jb20+CisKKyAgICAgICAgUG9s bCAvcHJvYy9tZW1pbmZvIHRvIG1lYXN1cmUgbWVtb3J5IHByZXNzdXJlIG9uIExpbnV4IGlmIGNn cm91cHMgaXNuJ3QgYXZhaWxhYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNTUyNTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBObyBuZXcgdGVzdHMgbmVlZGVkLgorCisgICAgICAgICogcGxhdGZvcm0v TWVtb3J5UHJlc3N1cmVIYW5kbGVyLmg6IEFkZGVkIG5ldyBmdW5jdGlvbnMuCisgICAgICAgICog cGxhdGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwOiBBZGRlZCBtZW1p bmZvIGZhbGxiYWNrCisgICAgICAgIGlmIGNncm91cHMgYXJlbid0IHByZXNlbnQuCisgICAgICAg IChXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnBvbGxNZW1vcnlQcmVzc3VyZSk6IE9w ZW4gL3Byb2MvbWVtaW5mbywKKyAgICAgICAgcGFyc2UgaXQgYW5kIHJlcG9ydCBwcmVzc3VyZSBp ZiBNZW1GcmVlIGlzIGJlbG93IHRoZSBwcmVkZWZpbmVkCisgICAgICAgIHRocmVzaG9sZHMuIEtl ZXAgcG9sbGluZyBwZXJpb2RpY2FsbHkgaWYgbm90LgorICAgICAgICAoV2ViQ29yZTo6TWVtb3J5 UHJlc3N1cmVIYW5kbGVyOjppbnN0YWxsVXNpbmdDZ3JvdXBzKTogT2xkIGNvZGUgdG8gdHJ5IHRv IGluc3RhbGwgdXNpbmcgY2dyb3Vwcy4KKyAgICAgICAgKFdlYkNvcmU6Ok1lbW9yeVByZXNzdXJl SGFuZGxlcjo6aW5zdGFsbFVzaW5nTWVtaW5mbyk6IE5ldyBjb2RlIHRvIHRyeSB0byBpbnN0YWxs IHVzaW5nIG1lbWluZm8uCisgICAgICAgIChXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6 Omluc3RhbGwpOiBNYW5hZ2UgYm90aCB3YXlzIHRvIGRldGVjdAorICAgICAgICBwcmVzc3VyZS4K KwogMjAxNi0wMy0wOSAgTWFudWVsIFJlZ28gQ2FzYXNub3ZhcyAgPHJlZ29AaWdhbGlhLmNvbT4K IAogICAgICAgICBbY3NzLWdyaWRdIEFsbG93IHRvIHBsYWNlIHBvc2l0aW9uZWQgZ3JpZCBpdGVt cyBvbiB0aGUgcGFkZGluZwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vTWVt b3J5UHJlc3N1cmVIYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVz c3VyZUhhbmRsZXIuaAppbmRleCA3MTE0ZDJjMjU3NWE5OWYxMGQzOTJhMmI2NjAxYjQ3N2Y3Zjdk ZDk5Li44Y2RjMjRlMzBiMDIyZWFjNTU3NzM5MWYzYmU5ZTY2OGYwMjk3OTlhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaApAQCAtODEsNiAr ODEsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCByZXNwb25kVG9NZW1vcnlQcmVzc3VyZUlmTmVlZGVk KCk7CiAjZWxpZiBPUyhMSU5VWCkKICAgICBzdGF0aWMgdm9pZCB3YWl0Rm9yTWVtb3J5UHJlc3N1 cmVFdmVudCh2b2lkKik7CisgICAgc3RhdGljIHZvaWQgcG9sbE1lbW9yeVByZXNzdXJlKHZvaWQq KTsKICNlbmRpZgogCiAgICAgY2xhc3MgUmVsaWVmTG9nZ2VyIHsKQEAgLTE1NCw2ICsxNTUsOCBA QCBwcml2YXRlOgogICAgIFRpbWVyIG1faG9sZE9mZlRpbWVyOwogICAgIHZvaWQgaG9sZE9mZlRp bWVyRmlyZWQoKTsKICAgICB2b2lkIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoY29uc3QgY2hhciogZXJy b3IpOworICAgIGJvb2wgaW5zdGFsbFVzaW5nQ2dyb3VwcygpOworICAgIGJvb2wgaW5zdGFsbFVz aW5nTWVtaW5mbygpOwogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKaW5kZXgg ZDBkMTM2YWNjMTM0ZWJlOTk3MWJjNDFkZDMwNTQ1MmEzYTQ1MTE5NS4uZjZmYTczZDA5NDg2YjY2 NmMwMTcyNjY4NWE4YTI2Zjk2NjcwMTZjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2xpbnV4L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcApAQCAt NTEsMTAgKzUxLDE1IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIC8vIGxvdyBtZW1vcnkgZXZlbnRz LCBncmVhdGx5IHJlZHVjaW5nIENQVSB1c2FnZS4KIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBzX21p bmltdW1Ib2xkT2ZmVGltZSA9IDU7CiBzdGF0aWMgY29uc3QgdW5zaWduZWQgc19ob2xkT2ZmTXVs dGlwbGllciA9IDIwOworc3RhdGljIGNvbnN0IHVuc2lnbmVkIHNfcG9sbGluZ0ludGVydmFsSW5T ZWNvbmRzID0gMTsKK3N0YXRpYyBjb25zdCBzaXplX3Qgc19tZW1vcnlDcml0aWNhbExpbWl0ID0g MTAwICogS0IgKiBLQjsgLy8gMTAwIE1CCitzdGF0aWMgY29uc3Qgc2l6ZV90IHNfbWVtb3J5Tm9u Q3JpdGljYWxMaW1pdCA9IDMwMCAqIEtCICogS0I7IC8vIDMwMCBNQgogCiBzdGF0aWMgY29uc3Qg Y2hhciogc19jZ3JvdXBNZW1vcnlQcmVzc3VyZUxldmVsID0gIi9zeXMvZnMvY2dyb3VwL21lbW9y eS9tZW1vcnkucHJlc3N1cmVfbGV2ZWwiOwogc3RhdGljIGNvbnN0IGNoYXIqIHNfY2dyb3VwRXZl bnRDb250cm9sID0gIi9zeXMvZnMvY2dyb3VwL21lbW9yeS9jZ3JvdXAuZXZlbnRfY29udHJvbCI7 CiBzdGF0aWMgY29uc3QgY2hhciogc19wcm9jZXNzU3RhdHVzID0gIi9wcm9jL3NlbGYvc3RhdHVz IjsKK3N0YXRpYyBjb25zdCBjaGFyKiBzX21lbUluZm8gPSAiL3Byb2MvbWVtaW5mbyI7CisKIAog c3RhdGljIGlubGluZSBTdHJpbmcgbmV4dFRva2VuKEZJTEUqIGZpbGUpCiB7CkBAIC0xMDUsNiAr MTEwLDQ1IEBAIHZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjp3YWl0Rm9yTWVtb3J5UHJlc3N1 cmVFdmVudCh2b2lkKikKICAgICB9KTsKIH0KIAordm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6 OnBvbGxNZW1vcnlQcmVzc3VyZSh2b2lkKikKK3sKKyAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgp KTsKKworICAgIGRvIHsKKyAgICAgICAgc2l6ZV90IG1lbW9yeUZyZWVJbkJ5dGVzID0gc3RhdGlj X2Nhc3Q8c2l6ZV90PigtMSk7CisKKyAgICAgICAgRklMRSogZmlsZSA9IGZvcGVuKHNfbWVtSW5m bywgInIiKTsKKyAgICAgICAgaWYgKCFmaWxlKQorICAgICAgICAgICAgcmV0dXJuOworCisgICAg ICAgIFN0cmluZyB0b2tlbiA9IG5leHRUb2tlbihmaWxlKTsKKyAgICAgICAgd2hpbGUgKCF0b2tl bi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgIGlmICh0b2tlbiA9PSAiTWVtRnJlZToiKSB7Cisg ICAgICAgICAgICAgICAgbWVtb3J5RnJlZUluQnl0ZXMgPSBuZXh0VG9rZW4oZmlsZSkudG9VSW50 NjQoKSAqIEtCOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAg ICAgICAgdG9rZW4gPSBuZXh0VG9rZW4oZmlsZSk7CisgICAgICAgIH0KKyAgICAgICAgZmNsb3Nl KGZpbGUpOworCisgICAgICAgIGlmIChtZW1vcnlGcmVlSW5CeXRlcyA8IHNfbWVtb3J5Tm9uQ3Jp dGljYWxMaW1pdCkgeworICAgICAgICAgICAgYm9vbCBpc1VuZGVyTWVtb3J5UHJlc3N1cmUgPSBt ZW1vcnlGcmVlSW5CeXRlcyA8IHNfbWVtb3J5Q3JpdGljYWxMaW1pdDsKKworICAgICAgICAgICAg aWYgKFJlbGllZkxvZ2dlcjo6bG9nZ2luZ0VuYWJsZWQoKSkKKyAgICAgICAgICAgICAgICBMT0co TWVtb3J5UHJlc3N1cmUsICJQb2xsZWQgbWVtb3J5IHByZXNzdXJlICglcykiLCBpc1VuZGVyTWVt b3J5UHJlc3N1cmUgPyAiY3JpdGljYWwiIDogIm5vbi1jcml0aWNhbCIpOworCisgICAgICAgICAg ICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRvbigpLnNldFVuZGVyTWVtb3J5UHJlc3N1 cmUoaXNVbmRlck1lbW9yeVByZXNzdXJlKTsKKyAgICAgICAgICAgIGNhbGxPbk1haW5UaHJlYWQo W2lzVW5kZXJNZW1vcnlQcmVzc3VyZV0geworICAgICAgICAgICAgICAgIE1lbW9yeVByZXNzdXJl SGFuZGxlcjo6c2luZ2xldG9uKCkucmVzcG9uZFRvTWVtb3J5UHJlc3N1cmUoaXNVbmRlck1lbW9y eVByZXNzdXJlID8gQ3JpdGljYWw6OlllcyA6IENyaXRpY2FsOjpObyk7CisgICAgICAgICAgICB9 KTsKKworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAgICAgc2xlZXAoc19w b2xsaW5nSW50ZXJ2YWxJblNlY29uZHMpOworICAgIH0gd2hpbGUgKHRydWUpOworfQorCiBpbmxp bmUgdm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OmxvZ0Vycm9yQW5kQ2xvc2VGRHMoY29uc3Qg Y2hhciogbG9nKQogewogICAgIGlmIChsb2cpCkBAIC0xMjAsMjcgKzE2NCwyNCBAQCBpbmxpbmUg dm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OmxvZ0Vycm9yQW5kQ2xvc2VGRHMoY29uc3QgY2hh ciogbG9nKQogICAgIH0KIH0KIAotdm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6Omluc3RhbGwo KQorYm9vbCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6Omluc3RhbGxVc2luZ0Nncm91cHMoKQogewot ICAgIGlmIChtX2luc3RhbGxlZCkKLSAgICAgICAgcmV0dXJuOwotCiAgICAgbV9ldmVudEZEID0g ZXZlbnRmZCgwLCBFRkRfQ0xPRVhFQyk7CiAgICAgaWYgKG1fZXZlbnRGRCA9PSAtMSkgewogICAg ICAgICBMT0coTWVtb3J5UHJlc3N1cmUsICJldmVudGZkKCkgZmFpbGVkOiAlbSIpOwotICAgICAg ICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBtX3ByZXNzdXJl TGV2ZWxGRCA9IG9wZW4oc19jZ3JvdXBNZW1vcnlQcmVzc3VyZUxldmVsLCBPX0NMT0VYRUMgfCBP X1JET05MWSk7CiAgICAgaWYgKG1fcHJlc3N1cmVMZXZlbEZEID09IC0xKSB7CiAgICAgICAgIGxv Z0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byBvcGVuIG1lbW9yeS5wcmVzc3VyZV9sZXZlbCIp OwotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBp bnQgZmQgPSBvcGVuKHNfY2dyb3VwRXZlbnRDb250cm9sLCBPX0NMT0VYRUMgfCBPX1dST05MWSk7 CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxl ZCB0byBvcGVuIGNncm91cC5ldmVudF9jb250cm9sIik7Ci0gICAgICAgIHJldHVybjsKKyAgICAg ICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIAogICAgIGNoYXIgbGluZVsxMjhdID0gezAsIH07CkBA IC0xNDgsMTYgKzE4OSw0MCBAQCB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCgp CiAgICAgICAgIHx8IHdyaXRlKGZkLCBsaW5lLCBzdHJsZW4obGluZSkgKyAxKSA8IDApIHsKICAg ICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIHdyaXRlIGNncm91cC5ldmVudF9j b250cm9sIik7CiAgICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuOworICAgICAgICBy ZXR1cm4gZmFsc2U7CiAgICAgfQogICAgIGNsb3NlKGZkKTsKIAogICAgIG1fdGhyZWFkSUQgPSBj cmVhdGVUaHJlYWQod2FpdEZvck1lbW9yeVByZXNzdXJlRXZlbnQsIHRoaXMsICJXZWJDb3JlOiBN ZW1vcnlQcmVzc3VyZUhhbmRsZXIiKTsKICAgICBpZiAoIW1fdGhyZWFkSUQpIHsKICAgICAgICAg bG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIGNyZWF0ZSBhIHRocmVhZCBmb3IgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyIik7Ci0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIH0KKworICAgIExPRyhNZW1vcnlQcmVzc3VyZSwgIkNncm91cHMgbWVtb3J5IHByZXNz dXJlIGhhbmRsZXIgaW5zdGFsbGVkLiIpOworICAgIHJldHVybiB0cnVlOworfQorCitib29sIE1l bW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbFVzaW5nTWVtaW5mbygpCit7CisgICAgbV90aHJl YWRJRCA9IGNyZWF0ZVRocmVhZChwb2xsTWVtb3J5UHJlc3N1cmUsIHRoaXMsICJXZWJDb3JlOiBN ZW1vcnlQcmVzc3VyZUhhbmRsZXIiKTsKKyAgICBpZiAoIW1fdGhyZWFkSUQpIHsKKyAgICAgICAg bG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIGNyZWF0ZSBhIHRocmVhZCBmb3IgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyIik7CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKKyAgICBM T0coTWVtb3J5UHJlc3N1cmUsICJNZW1pbmZvIG1lbW9yeSBwcmVzc3VyZSBoYW5kbGVyIGluc3Rh bGxlZC4iKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRs ZXI6Omluc3RhbGwoKQoreworICAgIGlmIChtX2luc3RhbGxlZCkKKyAgICAgICAgcmV0dXJuOwor CisgICAgaWYgKCFpbnN0YWxsVXNpbmdDZ3JvdXBzKCkgJiYgIWluc3RhbGxVc2luZ01lbWluZm8o KSkKKyAgICAgICAgcmV0dXJuOworCiAgICAgaWYgKFJlbGllZkxvZ2dlcjo6bG9nZ2luZ0VuYWJs ZWQoKSAmJiBpc1VuZGVyTWVtb3J5UHJlc3N1cmUoKSkKICAgICAgICAgTE9HKE1lbW9yeVByZXNz dXJlLCAiU3lzdGVtIGlzIG5vIGxvbmdlciB1bmRlciBtZW1vcnkgcHJlc3N1cmUuIik7CiAK 273833 2016-03-12 04:44:45 -0800 2016-07-01 06:20:17 -0700 Patch bug-155255-20160312124432.patch text/plain 8108 eocanha U3VidmVyc2lvbiBSZXZpc2lvbjogMTk3ODU3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYWZmMjRlMDNkMjZiYzVj NDRkNjlhMGFlNjI1Y2I2ZjljYTQ3OTBiNC4uZDkyMTM4MWJlZDc5YWM0YzI5ZTcwMzcxMDdhZTY1 NGY2YzU3YjQ2ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDE2LTAzLTEyICBFbnJp cXVlIE9jYcOxYSBHb256w6FsZXogIDxlb2NhbmhhQGlnYWxpYS5jb20+CisKKyAgICAgICAgUG9s bCAvcHJvYy9tZW1pbmZvIHRvIG1lYXN1cmUgbWVtb3J5IHByZXNzdXJlIG9uIExpbnV4IGlmIGNn cm91cHMgaXNuJ3QgYXZhaWxhYmxlCisKKyAgICAgICAgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIGRv ZXNuJ3Qgd29yayBpZiBjZ3JvdXBzIGFyZW4ndCBwcmVzZW50IGluIExpbnV4CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTUyNTUKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBuZXcgdGVzdHMgbmVlZGVk LgorCisgICAgICAgICogcGxhdGZvcm0vTWVtb3J5UHJlc3N1cmVIYW5kbGVyLmg6IEFkZGVkIG5l dyBmdW5jdGlvbnMuCisgICAgICAgICogcGxhdGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5k bGVyTGludXguY3BwOiBBZGRlZCBtZW1pbmZvIGZhbGxiYWNrCisgICAgICAgIGlmIGNncm91cHMg YXJlbid0IHByZXNlbnQuCisgICAgICAgIChXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6 Om5vdGlmeU1lbW9yeVByZXNzdXJlVG9NYWluVGhyZWFkKTogQXZvaWRzIGNvZGUgZHVwbGljYXRp b24uCisgICAgICAgIChXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OndhaXRGb3JNZW1v cnlQcmVzc3VyZUV2ZW50KTogUmVmYWN0b3JpbmcuCisgICAgICAgIChXZWJDb3JlOjpNZW1vcnlQ cmVzc3VyZUhhbmRsZXI6OnBvbGxNZW1vcnlQcmVzc3VyZSk6IE9wZW4gL3Byb2MvbWVtaW5mbywK KyAgICAgICAgcGFyc2UgaXQgYW5kIHJlcG9ydCBwcmVzc3VyZSBpZiBNZW1GcmVlIGlzIGJlbG93 IHRoZSBwcmVkZWZpbmVkCisgICAgICAgIHRocmVzaG9sZHMuIEtlZXAgcG9sbGluZyBwZXJpb2Rp Y2FsbHkgaWYgbm90LgorICAgICAgICAoV2ViQ29yZTo6TWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpp bnN0YWxsVXNpbmdDZ3JvdXBzKTogT2xkIGNvZGUgdG8gdHJ5IHRvIGluc3RhbGwgdXNpbmcgY2dy b3Vwcy4KKyAgICAgICAgKFdlYkNvcmU6Ok1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbFVz aW5nTWVtaW5mbyk6IE5ldyBjb2RlIHRvIHRyeSB0byBpbnN0YWxsIHVzaW5nIG1lbWluZm8uCisg ICAgICAgIChXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6Omluc3RhbGwpOiBNYW5hZ2Ug Ym90aCB3YXlzIHRvIGRldGVjdAorICAgICAgICBwcmVzc3VyZS4KKwogMjAxNi0wMy0wOSAgTWFu dWVsIFJlZ28gQ2FzYXNub3ZhcyAgPHJlZ29AaWdhbGlhLmNvbT4KIAogICAgICAgICBbY3NzLWdy aWRdIEFsbG93IHRvIHBsYWNlIHBvc2l0aW9uZWQgZ3JpZCBpdGVtcyBvbiB0aGUgcGFkZGluZwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vTWVtb3J5UHJlc3N1cmVIYW5kbGVy LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaAppbmRl eCA3MTE0ZDJjMjU3NWE5OWYxMGQzOTJhMmI2NjAxYjQ3N2Y3ZjdkZDk5Li5iMmFhYzlmMTNmOWVk MjlhMmE1N2Y0ZjgyNGZiMWYxNTkwNGZhNGQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaApAQCAtODEsNiArODEsNyBAQCBwdWJsaWM6CiAg ICAgdm9pZCByZXNwb25kVG9NZW1vcnlQcmVzc3VyZUlmTmVlZGVkKCk7CiAjZWxpZiBPUyhMSU5V WCkKICAgICBzdGF0aWMgdm9pZCB3YWl0Rm9yTWVtb3J5UHJlc3N1cmVFdmVudCh2b2lkKik7Cisg ICAgc3RhdGljIHZvaWQgcG9sbE1lbW9yeVByZXNzdXJlKHZvaWQqKTsKICNlbmRpZgogCiAgICAg Y2xhc3MgUmVsaWVmTG9nZ2VyIHsKQEAgLTE1NCw2ICsxNTUsOSBAQCBwcml2YXRlOgogICAgIFRp bWVyIG1faG9sZE9mZlRpbWVyOwogICAgIHZvaWQgaG9sZE9mZlRpbWVyRmlyZWQoKTsKICAgICB2 b2lkIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoY29uc3QgY2hhciogZXJyb3IpOworICAgIGJvb2wgaW5z dGFsbFVzaW5nQ2dyb3VwcygpOworICAgIGJvb2wgaW5zdGFsbFVzaW5nTWVtaW5mbygpOworICAg IHN0YXRpYyB2b2lkIG5vdGlmeU1lbW9yeVByZXNzdXJlVG9NYWluVGhyZWFkKGJvb2wpOwogI2Vu ZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9saW51eC9NZW1v cnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9saW51 eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKaW5kZXggZDBkMTM2YWNjMTM0ZWJlOTk3 MWJjNDFkZDMwNTQ1MmEzYTQ1MTE5NS4uZGQ0MTZlYzg2ZTc3ODEyZWZkN2M5YmNiM2U5ZmFkNTFh MjVmYmI2MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbGludXgvTWVtb3J5 UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2xp bnV4L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcApAQCAtNTEsMTAgKzUxLDE1IEBAIG5h bWVzcGFjZSBXZWJDb3JlIHsKIC8vIGxvdyBtZW1vcnkgZXZlbnRzLCBncmVhdGx5IHJlZHVjaW5n IENQVSB1c2FnZS4KIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBzX21pbmltdW1Ib2xkT2ZmVGltZSA9 IDU7CiBzdGF0aWMgY29uc3QgdW5zaWduZWQgc19ob2xkT2ZmTXVsdGlwbGllciA9IDIwOworc3Rh dGljIGNvbnN0IHVuc2lnbmVkIHNfcG9sbGluZ0ludGVydmFsSW5TZWNvbmRzID0gMTsKK3N0YXRp YyBjb25zdCBzaXplX3Qgc19tZW1vcnlDcml0aWNhbExpbWl0ID0gMTAwICogS0IgKiBLQjsgLy8g MTAwIE1CCitzdGF0aWMgY29uc3Qgc2l6ZV90IHNfbWVtb3J5Tm9uQ3JpdGljYWxMaW1pdCA9IDMw MCAqIEtCICogS0I7IC8vIDMwMCBNQgogCiBzdGF0aWMgY29uc3QgY2hhciogc19jZ3JvdXBNZW1v cnlQcmVzc3VyZUxldmVsID0gIi9zeXMvZnMvY2dyb3VwL21lbW9yeS9tZW1vcnkucHJlc3N1cmVf bGV2ZWwiOwogc3RhdGljIGNvbnN0IGNoYXIqIHNfY2dyb3VwRXZlbnRDb250cm9sID0gIi9zeXMv ZnMvY2dyb3VwL21lbW9yeS9jZ3JvdXAuZXZlbnRfY29udHJvbCI7CiBzdGF0aWMgY29uc3QgY2hh ciogc19wcm9jZXNzU3RhdHVzID0gIi9wcm9jL3NlbGYvc3RhdHVzIjsKK3N0YXRpYyBjb25zdCBj aGFyKiBzX21lbUluZm8gPSAiL3Byb2MvbWVtaW5mbyI7CisKIAogc3RhdGljIGlubGluZSBTdHJp bmcgbmV4dFRva2VuKEZJTEUqIGZpbGUpCiB7CkBAIC03Nyw2ICs4MiwxOSBAQCBzdGF0aWMgaW5s aW5lIFN0cmluZyBuZXh0VG9rZW4oRklMRSogZmlsZSkKICAgICByZXR1cm4gU3RyaW5nKGJ1ZmZl cik7CiB9CiAKK3ZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpub3RpZnlNZW1vcnlQcmVzc3Vy ZVRvTWFpblRocmVhZChib29sIGNyaXRpY2FsKQoreworICAgIEFTU0VSVCghaXNNYWluVGhyZWFk KCkpOworCisgICAgaWYgKFJlbGllZkxvZ2dlcjo6bG9nZ2luZ0VuYWJsZWQoKSkKKyAgICAgICAg TE9HKE1lbW9yeVByZXNzdXJlLCAiR290IG1lbW9yeSBwcmVzc3VyZSBub3RpZmljYXRpb24gKCVz KSIsIGNyaXRpY2FsID8gImNyaXRpY2FsIiA6ICJub24tY3JpdGljYWwiKTsKKworICAgIE1lbW9y eVByZXNzdXJlSGFuZGxlcjo6c2luZ2xldG9uKCkuc2V0VW5kZXJNZW1vcnlQcmVzc3VyZShjcml0 aWNhbCk7CisgICAgY2FsbE9uTWFpblRocmVhZChbY3JpdGljYWxdIHsKKyAgICAgICAgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyOjpzaW5nbGV0b24oKS5yZXNwb25kVG9NZW1vcnlQcmVzc3VyZShjcml0 aWNhbCA/IENyaXRpY2FsOjpZZXMgOiBDcml0aWNhbDo6Tm8pOworICAgIH0pOworfQorCiB2b2lk IE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6d2FpdEZvck1lbW9yeVByZXNzdXJlRXZlbnQodm9pZCop CiB7CiAgICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CkBAIC05NSwxNCArMTEzLDM0IEBAIHZv aWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjp3YWl0Rm9yTWVtb3J5UHJlc3N1cmVFdmVudCh2b2lk KikKICAgICAvLyBGSVhNRTogQ3VycmVudCBtZW1jZyBkb2VzIG5vdCBwcm92aWRlIGFueSB3YXkg Zm9yIHVzZXJzIHRvIGtub3cgaG93IHNlcmlvdXMgdGhlIG1lbW9yeSBwcmVzc3VyZSBpcy4KICAg ICAvLyBTbyB3ZSBhc3N1bWUgYWxsIG5vdGlmaWNhdGlvbnMgZnJvbSBtZW1jZyBhcmUgY3JpdGlj YWwgZm9yIG5vdy4gSWYgbWVtY2cgaGFkIGJldHRlciBpbmZlcmZhY2VzCiAgICAgLy8gdG8gZ2V0 IGEgZGV0YWlsZWQgbWVtb3J5IHByZXNzdXJlIGxldmVsIGluIHRoZSBmdXR1cmUsIHdlIHNob3Vs ZCB1cGRhdGUgaGVyZSBhY2NvcmRpbmdseS4KLSAgICBib29sIGNyaXRpY2FsID0gdHJ1ZTsKLSAg ICBpZiAoUmVsaWVmTG9nZ2VyOjpsb2dnaW5nRW5hYmxlZCgpKQotICAgICAgICBMT0coTWVtb3J5 UHJlc3N1cmUsICJHb3QgbWVtb3J5IHByZXNzdXJlIG5vdGlmaWNhdGlvbiAoJXMpIiwgY3JpdGlj YWwgPyAiY3JpdGljYWwiIDogIm5vbi1jcml0aWNhbCIpOworICAgIG5vdGlmeU1lbW9yeVByZXNz dXJlVG9NYWluVGhyZWFkKHRydWUpOworfQogCi0gICAgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpz aW5nbGV0b24oKS5zZXRVbmRlck1lbW9yeVByZXNzdXJlKGNyaXRpY2FsKTsKLSAgICBjYWxsT25N YWluVGhyZWFkKFtjcml0aWNhbF0gewotICAgICAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNp bmdsZXRvbigpLnJlc3BvbmRUb01lbW9yeVByZXNzdXJlKGNyaXRpY2FsID8gQ3JpdGljYWw6Olll cyA6IENyaXRpY2FsOjpObyk7Ci0gICAgfSk7Cit2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6 cG9sbE1lbW9yeVByZXNzdXJlKHZvaWQqKQoreworICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkp OworCisgICAgc2l6ZV90IG1lbW9yeUZyZWVJbkJ5dGVzID0gc3RhdGljX2Nhc3Q8c2l6ZV90Pigt MSk7CisKKyAgICBkbyB7CisgICAgICAgIHNsZWVwKHNfcG9sbGluZ0ludGVydmFsSW5TZWNvbmRz KTsKKworICAgICAgICBGSUxFKiBmaWxlID0gZm9wZW4oc19tZW1JbmZvLCAiciIpOworICAgICAg ICBpZiAoIWZpbGUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgU3RyaW5nIHRva2Vu ID0gbmV4dFRva2VuKGZpbGUpOworICAgICAgICB3aGlsZSAoIXRva2VuLmlzRW1wdHkoKSkgewor ICAgICAgICAgICAgaWYgKHRva2VuID09ICJNZW1GcmVlOiIpIHsKKyAgICAgICAgICAgICAgICBt ZW1vcnlGcmVlSW5CeXRlcyA9IG5leHRUb2tlbihmaWxlKS50b1VJbnQ2NCgpICogS0I7CisgICAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgICB0b2tlbiA9IG5l eHRUb2tlbihmaWxlKTsKKyAgICAgICAgfQorICAgICAgICBmY2xvc2UoZmlsZSk7CisgICAgfSB3 aGlsZSAobWVtb3J5RnJlZUluQnl0ZXMgPj0gc19tZW1vcnlOb25Dcml0aWNhbExpbWl0KTsKKwor ICAgIG5vdGlmeU1lbW9yeVByZXNzdXJlVG9NYWluVGhyZWFkKG1lbW9yeUZyZWVJbkJ5dGVzIDwg c19tZW1vcnlDcml0aWNhbExpbWl0KTsKIH0KIAogaW5saW5lIHZvaWQgTWVtb3J5UHJlc3N1cmVI YW5kbGVyOjpsb2dFcnJvckFuZENsb3NlRkRzKGNvbnN0IGNoYXIqIGxvZykKQEAgLTEyMCwyNyAr MTU4LDI0IEBAIGlubGluZSB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6bG9nRXJyb3JBbmRD bG9zZUZEcyhjb25zdCBjaGFyKiBsb2cpCiAgICAgfQogfQogCi12b2lkIE1lbW9yeVByZXNzdXJl SGFuZGxlcjo6aW5zdGFsbCgpCitib29sIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbFVz aW5nQ2dyb3VwcygpCiB7Ci0gICAgaWYgKG1faW5zdGFsbGVkKQotICAgICAgICByZXR1cm47Ci0K ICAgICBtX2V2ZW50RkQgPSBldmVudGZkKDAsIEVGRF9DTE9FWEVDKTsKICAgICBpZiAobV9ldmVu dEZEID09IC0xKSB7CiAgICAgICAgIExPRyhNZW1vcnlQcmVzc3VyZSwgImV2ZW50ZmQoKSBmYWls ZWQ6ICVtIik7Ci0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0K IAogICAgIG1fcHJlc3N1cmVMZXZlbEZEID0gb3BlbihzX2Nncm91cE1lbW9yeVByZXNzdXJlTGV2 ZWwsIE9fQ0xPRVhFQyB8IE9fUkRPTkxZKTsKICAgICBpZiAobV9wcmVzc3VyZUxldmVsRkQgPT0g LTEpIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIG9wZW4gbWVtb3J5 LnByZXNzdXJlX2xldmVsIik7Ci0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgIH0KIAogICAgIGludCBmZCA9IG9wZW4oc19jZ3JvdXBFdmVudENvbnRyb2wsIE9fQ0xP RVhFQyB8IE9fV1JPTkxZKTsKICAgICBpZiAoZmQgPT0gLTEpIHsKICAgICAgICAgbG9nRXJyb3JB bmRDbG9zZUZEcygiRmFpbGVkIHRvIG9wZW4gY2dyb3VwLmV2ZW50X2NvbnRyb2wiKTsKLSAgICAg ICAgcmV0dXJuOworICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogCiAgICAgY2hhciBsaW5l WzEyOF0gPSB7MCwgfTsKQEAgLTE0OCwxNiArMTgzLDQwIEBAIHZvaWQgTWVtb3J5UHJlc3N1cmVI YW5kbGVyOjppbnN0YWxsKCkKICAgICAgICAgfHwgd3JpdGUoZmQsIGxpbmUsIHN0cmxlbihsaW5l KSArIDEpIDwgMCkgewogICAgICAgICBsb2dFcnJvckFuZENsb3NlRkRzKCJGYWlsZWQgdG8gd3Jp dGUgY2dyb3VwLmV2ZW50X2NvbnRyb2wiKTsKICAgICAgICAgY2xvc2UoZmQpOwotICAgICAgICBy ZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAgICAgY2xvc2UoZmQpOwogCiAg ICAgbV90aHJlYWRJRCA9IGNyZWF0ZVRocmVhZCh3YWl0Rm9yTWVtb3J5UHJlc3N1cmVFdmVudCwg dGhpcywgIldlYkNvcmU6IE1lbW9yeVByZXNzdXJlSGFuZGxlciIpOwogICAgIGlmICghbV90aHJl YWRJRCkgewogICAgICAgICBsb2dFcnJvckFuZENsb3NlRkRzKCJGYWlsZWQgdG8gY3JlYXRlIGEg dGhyZWFkIGZvciBNZW1vcnlQcmVzc3VyZUhhbmRsZXIiKTsKLSAgICAgICAgcmV0dXJuOworICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgTE9HKE1lbW9yeVByZXNzdXJlLCAiQ2dy b3VwcyBtZW1vcnkgcHJlc3N1cmUgaGFuZGxlciBpbnN0YWxsZWQuIik7CisgICAgcmV0dXJuIHRy dWU7Cit9CisKK2Jvb2wgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjppbnN0YWxsVXNpbmdNZW1pbmZv KCkKK3sKKyAgICBtX3RocmVhZElEID0gY3JlYXRlVGhyZWFkKHBvbGxNZW1vcnlQcmVzc3VyZSwg dGhpcywgIldlYkNvcmU6IE1lbW9yeVByZXNzdXJlSGFuZGxlciIpOworICAgIGlmICghbV90aHJl YWRJRCkgeworICAgICAgICBsb2dFcnJvckFuZENsb3NlRkRzKCJGYWlsZWQgdG8gY3JlYXRlIGEg dGhyZWFkIGZvciBNZW1vcnlQcmVzc3VyZUhhbmRsZXIiKTsKKyAgICAgICAgcmV0dXJuIGZhbHNl OwogICAgIH0KIAorICAgIExPRyhNZW1vcnlQcmVzc3VyZSwgIk1lbWluZm8gbWVtb3J5IHByZXNz dXJlIGhhbmRsZXIgaW5zdGFsbGVkLiIpOworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIE1l bW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCgpCit7CisgICAgaWYgKG1faW5zdGFsbGVkKQor ICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIWluc3RhbGxVc2luZ0Nncm91cHMoKSAmJiAhaW5z dGFsbFVzaW5nTWVtaW5mbygpKQorICAgICAgICByZXR1cm47CisKICAgICBpZiAoUmVsaWVmTG9n Z2VyOjpsb2dnaW5nRW5hYmxlZCgpICYmIGlzVW5kZXJNZW1vcnlQcmVzc3VyZSgpKQogICAgICAg ICBMT0coTWVtb3J5UHJlc3N1cmUsICJTeXN0ZW0gaXMgbm8gbG9uZ2VyIHVuZGVyIG1lbW9yeSBw cmVzc3VyZS4iKTsKIAo= 282544 2016-07-01 06:20:17 -0700 2016-07-13 06:31:51 -0700 Different approach wk2-memory-pressure-monitor.diff text/plain 35889 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAyYzViYzRmLi5hMzViMjdjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTgg QEAKIDIwMTYtMDctMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgogCisgICAgICAgIE1lbW9yeVByZXNzdXJlSGFuZGxlciBkb2Vzbid0IHdvcmsgaWYgY2dyb3Vw cyBhcmVuJ3QgcHJlc2VudCBpbiBMaW51eAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTU1MjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWxsb3cgdG8gcGFzcyBhbiBldmVudEZEIGZpbGUgZGVzY3JpcHRv ciB0byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIHRvIGJlIG1vbml0b3JpemVkIGluIGNhc2Ug Y2dyb3VwcyBhcmUgbm90CisgICAgICAgIGF2YWlsYWJsZS4KKworICAgICAgICAqIHBsYXRmb3Jt L01lbW9yeVByZXNzdXJlSGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2xpbnV4L01lbW9y eVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcDoKKworMjAxNi0wNy0wMSAgQ2FybG9zIEdhcmNpYSBD YW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKICAgICAgICAgW0dMaWJdIFVzZSBhIEdTb3Vy Y2UgaW5zdGVhZCBvZiBhIHRocmVhZCB0byBwb2xsIG1lbW9yeSBwcmVzc3VyZSBldmVudEZEIGlu IGxpbnV4IGltcGxlbWVudGF0aW9uCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNTkzNDYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vTWVtb3J5UHJlc3N1cmVIYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1v cnlQcmVzc3VyZUhhbmRsZXIuaAppbmRleCBhZWRmOWMxLi44YmJlNGNkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaApAQCAtODQsNiArODQs OCBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBjbGVhck1lbW9yeVByZXNzdXJl KCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBzaG91bGRXYWl0Rm9yTWVtb3J5Q2xlYXJNZXNz YWdlKCk7CiAgICAgdm9pZCByZXNwb25kVG9NZW1vcnlQcmVzc3VyZUlmTmVlZGVkKCk7CisjZWxp ZiBPUyhMSU5VWCkKKyAgICB2b2lkIHNldE1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZShpbnQg ZmQpOwogI2VuZGlmCiAKICAgICBjbGFzcyBSZWxpZWZMb2dnZXIgewpAQCAtMTc4LDYgKzE4MCw3 IEBAIHByaXZhdGU6CiAgICAgUnVuTG9vcDo6VGltZXI8TWVtb3J5UHJlc3N1cmVIYW5kbGVyPiBt X2hvbGRPZmZUaW1lcjsKICAgICB2b2lkIGhvbGRPZmZUaW1lckZpcmVkKCk7CiAgICAgdm9pZCBs b2dFcnJvckFuZENsb3NlRkRzKGNvbnN0IGNoYXIqIGVycm9yKTsKKyAgICBib29sIHRyeUVuc3Vy ZUV2ZW50RkQoKTsKICNlbmRpZgogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCmluZGV4IDNl ZWMwMWQuLmQyZmU5MzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2xpbnV4 L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKQEAgLTE5MywyNyArMTkz LDI4IEBAIGlubGluZSB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6bG9nRXJyb3JBbmRDbG9z ZUZEcyhjb25zdCBjaGFyKiBsb2cpCiAgICAgfQogfQogCi12b2lkIE1lbW9yeVByZXNzdXJlSGFu ZGxlcjo6aW5zdGFsbCgpCitib29sIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6dHJ5RW5zdXJlRXZl bnRGRCgpCiB7Ci0gICAgaWYgKG1faW5zdGFsbGVkIHx8IG1faG9sZE9mZlRpbWVyLmlzQWN0aXZl KCkpCi0gICAgICAgIHJldHVybjsKKyAgICBpZiAobV9ldmVudEZEICE9IC0xKQorICAgICAgICBy ZXR1cm4gdHJ1ZTsKIAorICAgIC8vIFRyeSB0byB1ZSBzeXN0ZW1kIGluc3RlYWQuCiAgICAgbV9l dmVudEZEID0gZXZlbnRmZCgwLCBFRkRfQ0xPRVhFQyk7CiAgICAgaWYgKG1fZXZlbnRGRCA9PSAt MSkgewogICAgICAgICBMT0coTWVtb3J5UHJlc3N1cmUsICJldmVudGZkKCkgZmFpbGVkOiAlbSIp OwotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBt X3ByZXNzdXJlTGV2ZWxGRCA9IG9wZW4oc19jZ3JvdXBNZW1vcnlQcmVzc3VyZUxldmVsLCBPX0NM T0VYRUMgfCBPX1JET05MWSk7CiAgICAgaWYgKG1fcHJlc3N1cmVMZXZlbEZEID09IC0xKSB7CiAg ICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byBvcGVuIG1lbW9yeS5wcmVzc3Vy ZV9sZXZlbCIpOwotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9 CiAKICAgICBpbnQgZmQgPSBvcGVuKHNfY2dyb3VwRXZlbnRDb250cm9sLCBPX0NMT0VYRUMgfCBP X1dST05MWSk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VG RHMoIkZhaWxlZCB0byBvcGVuIGNncm91cC5ldmVudF9jb250cm9sIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIAogICAgIGNoYXIgbGluZVsxMjhdID0g ezAsIH07CkBAIC0yMjEsMTAgKzIyMiwyMSBAQCB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6 aW5zdGFsbCgpCiAgICAgICAgIHx8IHdyaXRlKGZkLCBsaW5lLCBzdHJsZW4obGluZSkgKyAxKSA8 IDApIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIHdyaXRlIGNncm91 cC5ldmVudF9jb250cm9sIik7CiAgICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuOwor ICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogICAgIGNsb3NlKGZkKTsKIAorICAgIHJldHVy biB0cnVlOworfQorCit2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCgpCit7Cisg ICAgaWYgKG1faW5zdGFsbGVkIHx8IG1faG9sZE9mZlRpbWVyLmlzQWN0aXZlKCkpCisgICAgICAg IHJldHVybjsKKworICAgIGlmICghdHJ5RW5zdXJlRXZlbnRGRCgpKQorICAgICAgICByZXR1cm47 CisKICAgICBtX2V2ZW50RkRQb2xsZXIgPSBzdGQ6Om1ha2VfdW5pcXVlPEV2ZW50RkRQb2xsZXI+ KG1fZXZlbnRGRCwgW3RoaXNdIHsKICAgICAgICAgLy8gRklYTUU6IEN1cnJlbnQgbWVtY2cgZG9l cyBub3QgcHJvdmlkZSBhbnkgd2F5IGZvciB1c2VycyB0byBrbm93IGhvdyBzZXJpb3VzIHRoZSBt ZW1vcnkgcHJlc3N1cmUgaXMuCiAgICAgICAgIC8vIFNvIHdlIGFzc3VtZSBhbGwgbm90aWZpY2F0 aW9ucyBmcm9tIG1lbWNnIGFyZSBjcml0aWNhbCBmb3Igbm93LiBJZiBtZW1jZyBoYWQgYmV0dGVy IGluZmVyZmFjZXMKQEAgLTI1NSw3ICsyNjcsMTcgQEAgdm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRs ZXI6OnVuaW5zdGFsbCgpCiAgICAgbV9ob2xkT2ZmVGltZXIuc3RvcCgpOwogICAgIG1fZXZlbnRG RFBvbGxlciA9IG51bGxwdHI7CiAKLSAgICBsb2dFcnJvckFuZENsb3NlRkRzKG51bGxwdHIpOwor ICAgIGlmIChtX3ByZXNzdXJlTGV2ZWxGRCAhPSAtMSkgeworICAgICAgICBjbG9zZShtX3ByZXNz dXJlTGV2ZWxGRCk7CisgICAgICAgIG1fcHJlc3N1cmVMZXZlbEZEID0gLTE7CisKKyAgICAgICAg Ly8gT25seSBjbG9zZSB0aGUgZXZlbnRGRCB1c2VkIGZvciBzeXN0ZW1kLgorICAgICAgICBpZiAo bV9ldmVudEZEICE9IC0xKSB7CisgICAgICAgICAgICBjbG9zZShtX2V2ZW50RkQpOworICAgICAg ICAgICAgbV9ldmVudEZEID0gLTE7CisgICAgICAgIH0KKyAgICB9CisKICAgICBtX2luc3RhbGxl ZCA9IGZhbHNlOwogfQogCkBAIC0zMDcsNiArMzI5LDEyIEBAIHNpemVfdCBNZW1vcnlQcmVzc3Vy ZUhhbmRsZXI6OlJlbGllZkxvZ2dlcjo6cGxhdGZvcm1NZW1vcnlVc2FnZSgpCiAgICAgcmV0dXJu IHZtU2l6ZTsKIH0KIAordm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNldE1lbW9yeVByZXNz dXJlTW9uaXRvckhhbmRsZShpbnQgZmQpCit7CisgICAgQVNTRVJUKG1fZXZlbnRGRCAhPSAtMSk7 CisgICAgbV9ldmVudEZEID0gZmQ7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2Vu ZGlmIC8vIE9TKExJTlVYKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDIxMjk2MDguLjFkMWYxZTAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VM b2cKQEAgLTEsMyArMSw2OCBAQAorMjAxNi0wNy0wMSAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxj Z2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIGRvZXNu J3Qgd29yayBpZiBjZ3JvdXBzIGFyZW4ndCBwcmVzZW50IGluIExpbnV4CisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTUyNTUKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGVyZSdzIG5vIHdheSB0byBnZXQg bm90aWZpY2F0aW9ucyBhYm91dCBtZW1vcnkgcHJlc3N1cmUgaW4gTGludXggd2l0aG91dCB1c2lu ZyBjZ3JvdXBzIHRoYXQgZG9lc24ndCByZXF1aXJlIGEKKyAgICAgICAgbWFudWFsIHBvbGxpbmcu IFdlIGNhbiBnZXQgdGhhdCBpbmZvcm1hdGlvbiBmcm9tIC9wcm9jL21lbWluZm8sIGJ1dCB0aGF0 J3Mgbm90IHBvbGxhYmxlIHNvIGl0IHJlcXVpcmVzIHRvCisgICAgICAgIG1hbnVhbGx5IGNoZWNr IGl0cyBjb250ZW50cyBpbiBhIGxvb3Agc2xlZXBpbmcgZm9yIGEgd2hpbGUgYmV0d2VlbiBjaGVj a3MuIFRoaXMgbWVhbnMgd2Ugd291bGQgYmUgd2FraW5nIHVwIHRoZQorICAgICAgICBwcm9jZXNz IG9uIGV2ZXJ5IHBvbGwgaXRlcmF0aW9uLCBtb3N0IG9mIHRoZSB0aW1lcyBmb3Igbm90aGluZy4g VGhhdCdzIHNwZWNpYWxseSBwcm9ibGVtYXRpYyBvbiBkZXZpY2VzIHJ1bm5pbmcKKyAgICAgICAg b24gYmF0dGVyeS4gQW5kIHRha2luZyBpbnRvIGFjY291bnQgdGhhdCB0aGVyZSdzIGEgbWVtb3J5 IHByZXNzdXJlIGhhbmRsZXIgaW4gZXZlcnkgc2Vjb25kYXJ5IHByb2Nlc3MgKFdlYiwKKyAgICAg ICAgTmV0d29yayBhbmQgUGx1Z2luKSwgd2Ugd291bGQgYmUgd2FraW5nIHVwIGFsbCB0aG9zZSBw cm9jZXNzIGFsbCB0aGUgdGltZS4gSG93ZXZlciwgbm90IGhhdmluZyBhIG1lbW9yeSBwcmVzc3Vy ZQorICAgICAgICBoYW5kbGVyIGlzIGV2ZW4gbW9yZSBwcm9ibGVtYXRpYyB0aGFuIHRoZSBtYW51 YWwgcG9sbGluZy4KKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIGEgY2xhc3MgTWVtb3J5UHJlc3N1 cmVNb25pdG9yIHRvIHRoZSBtYW51YWwgcG9sbGluZyBvZiAvcHJvYy9tZW1pbmZvLCBidXQgcnVu cyBpbiB0aGUgVUkKKyAgICAgICAgcHJvY2VzcywgdG8gYXZvaWQgdGhlIHdlYWt1cHMgaW4gYWxs IG90aGVyIHNlY29uZGFyeSBwcm9jZXNzZXMsIGFuZCB1c2VzIGFuIGV2ZW50RkQgdG8gbm90aWZ5 IGFsbCBvdGhlcgorICAgICAgICBwcm9jZXNzZXMuIEl0J3Mgb25seSB1c2VkIGluIGNhc2UgY2dy b3VwcyBpcyBub3QgYXZhaWxhYmxlLiBUaGUgZXZlbnRGRCBkZXNjcmlwdG9yIGlzIHNlbnQgdG8g YWxsIG90aGVyCisgICAgICAgIHByb2Nlc3NlcyBhdCBzdGFydHVwLCBhbmQgcGFzc2VkIHRvIHRo ZSBNZW1vcnlQcmVzc3VyZUhhbmRsZXIgYmVmb3JlIGluc3RhbGwoKSBpcyBjYWxsZWQgZm9yIHRo ZSBmaXJzdAorICAgICAgICB0aW1lLiBUbyBtaW5pbWl6ZSB0aGUgd2FrZXVwcyBldmVuIGluIHRo ZSBVSSBwcm9jZXNzLCB0aGUgcG9sbCBpbnRlcnZhbCBpcyBjYWxjdWxhdGVkIGZyb20gMSB0byA1 IHNlY29uZHMKKyAgICAgICAgZGVwZW5kaW5nIG9uIHRoZSBjdXJyZW50IG1lbW9yeSB1c2VkLCBz byBpbiBjYXNlIG9mIGxvdyBtZW1vcnkgbGV2ZWwgd2Ugc2xlZXAgZm9yIGEgbG9uZ2VyIHRpbWUu CisgICAgICAgIEl0J3MgYWxzbyBpbXBvcnRhbnQgdG8gbWFrZSB0aGUgbWVtb3J5IGNhbGN1bGF0 aW9ucyBhcyBhY2N1cmF0ZSBhcyBwb3NzaWJsZSB0byBhdm9pZCBjbGVhbmluZyByZXNvdXJjZXMg aW4gdGhlCisgICAgICAgIHNlY29uZGFyeSBwcm9jZXNzZXMgdW5uZWNlc3NhcmlseS4KKworICAg ICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktp dDo6TmV0d29ya1Byb2Nlc3M6OmluaXRpYWxpemVOZXR3b3JrUHJvY2Vzcyk6IFBhc3MgdGhlIG1l bW9yeSBwcmVzc3VyZSBtb25pdG9yIGZpbGUgZGVzY3JpcHRvciB0byB0aGUgTWVtb3J5UHJlc3N1 cmVIYW5kbGVyLgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmg6Cisg ICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMu Y3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6 ZW5jb2RlKTogRW5jb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAgICAg KFdlYktpdDo6TmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZSk6IERlY29k ZSBtZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBoYW5kbGUuCisgICAgICAgICogTmV0d29ya1Byb2Nl c3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaDoKKyAgICAgICAgKiBQbGF0Zm9y bUVmbC5jbWFrZTogQWRkIG5ldyBmaWxlIHRvIGNvbXBpbGF0aW9uLCBhbmQgdXBkYXRlIGluY2x1 ZGUgZGlycy4KKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZTogRGl0dG8uCisgICAgICAgICog UGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2lu UHJvY2Vzczo6aW5pdGlhbGl6ZVBsdWdpblByb2Nlc3MpOiBQYXNzIHRoZSBtZW1vcnkgcHJlc3N1 cmUgbW9uaXRvciBmaWxlIGRlc2NyaXB0b3IgdG8gdGhlIE1lbW9yeVByZXNzdXJlSGFuZGxlci4K KyAgICAgICAgKiBTaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6 ZW5jb2RlKTogRW5jb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAgICAg KFdlYktpdDo6UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKTogRGVjb2Rl IG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAgICAgKiBTaGFyZWQvUGx1Z2lu cy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmg6CisgICAgICAgICogU2hhcmVkL1dl YlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9j ZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUgbWVtb3J5IHByZXNzdXJlIG1v bml0b3IgaGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzOjpkZWNvZGUpOiBEZWNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlLgorICAg ICAgICAqIFNoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmg6CisgICAgICAgICog VUlQcm9jZXNzL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc1Byb3h5LmNwcDoKKyAgICAgICAgKFdlYktp dDo6UGx1Z2luUHJvY2Vzc1Byb3h5OjpkaWRGaW5pc2hMYXVuY2hpbmcpOiBDcmVhdGUgdGhlIG1l bW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZSBmb3IgdGhlIHBsdWdpbgorICAgICAgICBwcm9j ZXNzIGlmIG5lZWRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwOgor ICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzUG9vbDo6ZW5zdXJlTmV0d29ya1Byb2Nlc3MpOiBD cmVhdGUgdGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZSBmb3IgdGhlIG5ldHdvcmsK KyAgICAgICAgcHJvY2VzcyBpZiBuZWVkZWQuCisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQ b29sOjpjcmVhdGVOZXdXZWJQcm9jZXNzKTogQ3JlYXRlIHRoZSBtZW1vcnkgcHJlc3N1cmUgbW9u aXRvciBoYW5kbGUgZm9yIHRoZSB3ZWIgcHJvY2VzcyBpZgorICAgICAgICBuZWVkZWQuCisgICAg ICAgICogVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHA6IEFkZGVkLgor ICAgICAgICAoV2ViS2l0Ojpsb3dXYXRlcm1hcmtQYWdlcyk6CisgICAgICAgIChXZWJLaXQ6OnN5 c3RlbVBhZ2VTaXplKToKKyAgICAgICAgKFdlYktpdDo6Y2FsY3VsYXRlTWVtb3J5QXZhaWxhYmxl KToKKyAgICAgICAgKFdlYktpdDo6c3lzdGVtTWVtb3J5VXNlZEFzUGVyY2VudGFnZSk6CisgICAg ICAgIChXZWJLaXQ6OnBvbGxJbnRlcnZhbEZvclVzZWRNZW1vcnlQZXJjZW50YWdlKToKKyAgICAg ICAgKFdlYktpdDo6aXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25pdG9yQXZhaWxhYmxlKToKKyAg ICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjppc0VuYWJsZWQpOgorICAgICAg ICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbik6CisgICAgICAgIChX ZWJLaXQ6Ok1lbW9yeVByZXNzdXJlTW9uaXRvcjo6TWVtb3J5UHJlc3N1cmVNb25pdG9yKToKKyAg ICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjpjcmVhdGVIYW5kbGUpOgorICAg ICAgICAqIFVJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuaDoKKyAgICAgICAg KiBXZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNz Ojppbml0aWFsaXplV2ViUHJvY2Vzcyk6IFBhc3MgdGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9y IGZpbGUgZGVzY3JpcHRvciB0byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyLgorCiAyMDE2LTA2 LTMwICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAg ICBbQ29vcmRpbmF0ZWQgR3JhcGhpY3NdIE1vdmUgQ29tcG9zaXRpbmdDb29yZGluYXRvciBmcm9t IHBsYXRmb3JtIHRvIFdlYktpdDIgbGF5ZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05l dHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcAppbmRleCA4OTUzOTNjLi5hMmFkMGQ2IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAKKysr IGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwCkBAIC0x OTMsNyArMTkzLDcgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzczo6bG93TWVtb3J5SGFuZGxlcihDcml0 aWNhbCBjcml0aWNhbCkKICAgICBXVEY6OnJlbGVhc2VGYXN0TWFsbG9jRnJlZU1lbW9yeSgpOwog fQogCi12b2lkIE5ldHdvcmtQcm9jZXNzOjppbml0aWFsaXplTmV0d29ya1Byb2Nlc3MoY29uc3Qg TmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmIHBhcmFtZXRlcnMpCit2b2lkIE5ldHdv cmtQcm9jZXNzOjppbml0aWFsaXplTmV0d29ya1Byb2Nlc3MoTmV0d29ya1Byb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMmJiBwYXJhbWV0ZXJzKQogewogICAgIHBsYXRmb3JtSW5pdGlhbGl6ZU5ldHdv cmtQcm9jZXNzKHBhcmFtZXRlcnMpOwogCkBAIC0yMDIsNiArMjAyLDEwIEBAIHZvaWQgTmV0d29y a1Byb2Nlc3M6OmluaXRpYWxpemVOZXR3b3JrUHJvY2Vzcyhjb25zdCBOZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1lCiAgICAgbV9zdXBwcmVzc01lbW9yeVByZXNzdXJlSGFuZGxlciA9IHBhcmFt ZXRlcnMuc2hvdWxkU3VwcHJlc3NNZW1vcnlQcmVzc3VyZUhhbmRsZXI7CiAgICAgaWYgKCFtX3N1 cHByZXNzTWVtb3J5UHJlc3N1cmVIYW5kbGVyKSB7CiAgICAgICAgIGF1dG8mIG1lbW9yeVByZXNz dXJlSGFuZGxlciA9IE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6c2luZ2xldG9uKCk7CisjaWYgT1Mo TElOVVgpCisgICAgICAgIGlmIChwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRs ZS5maWxlRGVzY3JpcHRvcigpICE9IC0xKQorICAgICAgICAgICAgbWVtb3J5UHJlc3N1cmVIYW5k bGVyLnNldE1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNz dXJlTW9uaXRvckhhbmRsZS5yZWxlYXNlRmlsZURlc2NyaXB0b3IoKSk7CisjZW5kaWYKICAgICAg ICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldExvd01lbW9yeUhhbmRsZXIoW3RoaXNdIChDcml0 aWNhbCBjcml0aWNhbCwgU3luY2hyb25vdXMpIHsKICAgICAgICAgICAgIGxvd01lbW9yeUhhbmRs ZXIoY3JpdGljYWwpOwogICAgICAgICB9KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05l dHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmggYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCmluZGV4IGM4OTc5OTguLmI3MzI1MTcgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmgKKysrIGIvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaApAQCAtMTU5LDcgKzE1 OSw3IEBAIHByaXZhdGU6CiAgICAgLy8gTWVzc2FnZSBIYW5kbGVycwogICAgIHZvaWQgZGlkUmVj ZWl2ZU5ldHdvcmtQcm9jZXNzTWVzc2FnZShJUEM6OkNvbm5lY3Rpb24mLCBJUEM6Ok1lc3NhZ2VE ZWNvZGVyJik7CiAgICAgdm9pZCBkaWRSZWNlaXZlU3luY05ldHdvcmtQcm9jZXNzTWVzc2FnZShJ UEM6OkNvbm5lY3Rpb24mLCBJUEM6Ok1lc3NhZ2VEZWNvZGVyJiwgc3RkOjp1bmlxdWVfcHRyPElQ Qzo6TWVzc2FnZUVuY29kZXI+Jik7Ci0gICAgdm9pZCBpbml0aWFsaXplTmV0d29ya1Byb2Nlc3Mo Y29uc3QgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmKTsKKyAgICB2b2lkIGluaXRp YWxpemVOZXR3b3JrUHJvY2VzcyhOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYmKTsK ICAgICB2b2lkIGNyZWF0ZU5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzKCk7CiAgICAgdm9p ZCBkZXN0cm95UHJpdmF0ZUJyb3dzaW5nU2Vzc2lvbihXZWJDb3JlOjpTZXNzaW9uSUQpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5kZXggYjQ4ZmQwMC4uYmMzNTQwNCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNz L05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcApAQCAtODIsNiArODIsOSBAQCB2 b2lkIE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpBcmd1bWVu dEVuY29kZXImIGVuY29kZXIpIGNvbgogICAgIGVuY29kZXIgPDwgaWdub3JlVExTRXJyb3JzOwog ICAgIGVuY29kZXIgPDwgbGFuZ3VhZ2VzOwogI2VuZGlmCisjaWYgT1MoTElOVVgpCisgICAgZW5j b2RlciA8PCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYKIH0KIAogYm9vbCBO ZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNv ZGVyJiBkZWNvZGVyLCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYgcmVzdWx0KQpA QCAtMTU4LDYgKzE2MSwxMSBAQCBib29sIE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjpkZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIsIE5ldAogICAgICAgICByZXR1 cm4gZmFsc2U7CiAjZW5kaWYKIAorI2lmIE9TKExJTlVYKQorICAgIGlmICghZGVjb2Rlci5kZWNv ZGUocmVzdWx0Lm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZSkpCisgICAgICAgIHJldHVybiBm YWxzZTsKKyNlbmRpZgorCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmggYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycy5oCmluZGV4IDRhNThlNGEuLjU2ODgxOTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgK KysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMuaApAQCAtMjYsNiArMjYsNyBAQAogI2lmbmRlZiBOZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVyc19oCiAjZGVmaW5lIE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzX2gKIAorI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIKICNpbmNsdWRlICJDYWNoZU1vZGVsLmgi CiAjaW5jbHVkZSAiU2FuZGJveEV4dGVuc2lvbi5oIgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4K QEAgLTk1LDYgKzk2LDEwIEBAIHN0cnVjdCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cyB7CiAgICAgYm9vbCBpZ25vcmVUTFNFcnJvcnM7CiAgICAgVmVjdG9yPFN0cmluZz4gbGFuZ3Vh Z2VzOwogI2VuZGlmCisKKyNpZiBPUyhMSU5VWCkKKyAgICBJUEM6OkF0dGFjaG1lbnQgbWVtb3J5 UHJlc3N1cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJL aXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtlIGIvU291cmNl L1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggZGQ3NjNkZC4uN2M4N2RjNCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UKKysrIGIvU291cmNlL1dlYktp dDIvUGxhdGZvcm1FZmwuY21ha2UKQEAgLTE3MSw2ICsxNzEsOCBAQCBsaXN0KEFQUEVORCBXZWJL aXQyX1NPVVJDRVMKICAgICBVSVByb2Nlc3MvZ3N0cmVhbWVyL0luc3RhbGxNaXNzaW5nTWVkaWFQ bHVnaW5zUGVybWlzc2lvblJlcXVlc3QuY3BwCiAgICAgVUlQcm9jZXNzL2dzdHJlYW1lci9XZWJQ YWdlUHJveHlHU3RyZWFtZXIuY3BwCiAKKyAgICBVSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1 cmVNb25pdG9yLmNwcAorCiAgICAgVUlQcm9jZXNzL3NvdXAvV2ViQ29va2llTWFuYWdlclByb3h5 U291cC5jcHAKICAgICBVSVByb2Nlc3Mvc291cC9XZWJQcm9jZXNzUG9vbFNvdXAuY3BwCiAKQEAg LTI1Niw2ICsyNTgsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX0lOQ0xVREVfRElSRUNUT1JJRVMK ICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0Nvb3JkaW5hdGVkR3JhcGhpY3MiCiAgICAg IiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9zb3VwIgog ICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvZWZsIgorICAgICIke1dFQktJVDJfRElSfS9V SVByb2Nlc3MvbGludXgiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9zb3VwIgogICAg ICIke1dFQktJVDJfRElSfS9XZWJQcm9jZXNzL2VmbCIKICAgICAiJHtXRUJLSVQyX0RJUn0vV2Vi UHJvY2Vzcy9zb3VwIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsuY21h a2UgYi9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQppbmRleCBhN2Y0ZjdlLi5mMTQ5 NWZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9T b3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMjczLDYgKzI3Myw4IEBAIGxpc3Qo QVBQRU5EIFdlYktpdDJfU09VUkNFUwogCiAgICAgVUlQcm9jZXNzL0xhdW5jaGVyL2d0ay9Qcm9j ZXNzTGF1bmNoZXJHdGsuY3BwCiAKKyAgICBVSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVN b25pdG9yLmNwcAorCiAgICAgVUlQcm9jZXNzL05ldHdvcmsvQ3VzdG9tUHJvdG9jb2xzL3NvdXAv Q3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHlTb3VwLmNwcAogICAgIFVJUHJvY2Vzcy9OZXR3b3Jr L0N1c3RvbVByb3RvY29scy9zb3VwL1dlYlNvdXBDdXN0b21Qcm90b2NvbFJlcXVlc3RNYW5hZ2Vy LmNwcAogICAgIFVJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9zb3VwL1dlYlNvdXBD dXN0b21Qcm90b2NvbFJlcXVlc3RNYW5hZ2VyQ2xpZW50LmNwcApAQCAtNTEyLDYgKzUxNCw3IEBA IGxpc3QoQVBQRU5EIFdlYktpdDJfSU5DTFVERV9ESVJFQ1RPUklFUwogICAgICIke1dFQktJVDJf RElSfS9VSVByb2Nlc3MvUGx1Z2lucy9ndGsiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vz cy9nc3RyZWFtZXIiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9ndGsiCisgICAgIiR7 V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9saW51eCIKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9j ZXNzL3NvdXAiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1dlYlByb2Nlc3MvSW5qZWN0ZWRCdW5kbGUv QVBJL2d0ayIKICAgICAiJHtXRUJLSVQyX0RJUn0vV2ViUHJvY2Vzcy9QbHVnaW5zL05ldHNjYXBl L3VuaXgiCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9QbHVnaW5Qcm9jZXNzL1BsdWdpblBy b2Nlc3MuY3BwIGIvU291cmNlL1dlYktpdDIvUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNw cAppbmRleCA3NTU1NzAyLi42MWU2NmYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbHVn aW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1BsdWdpblBy b2Nlc3MvUGx1Z2luUHJvY2Vzcy5jcHAKQEAgLTcxLDEzICs3MSw2IEBAIHZvaWQgUGx1Z2luUHJv Y2Vzczo6aW5pdGlhbGl6ZVByb2Nlc3MoY29uc3QgQ2hpbGRQcm9jZXNzSW5pdGlhbGl6YXRpb25Q YXJhbWV0ZXJzCiB7CiAgICAgbV9wbHVnaW5QYXRoID0gcGFyYW1ldGVycy5leHRyYUluaXRpYWxp emF0aW9uRGF0YS5nZXQoInBsdWdpbi1wYXRoIik7CiAgICAgcGxhdGZvcm1Jbml0aWFsaXplUHJv Y2VzcyhwYXJhbWV0ZXJzKTsKLQotICAgIGF1dG8mIG1lbW9yeVByZXNzdXJlSGFuZGxlciA9IE1l bW9yeVByZXNzdXJlSGFuZGxlcjo6c2luZ2xldG9uKCk7Ci0gICAgbWVtb3J5UHJlc3N1cmVIYW5k bGVyLnNldExvd01lbW9yeUhhbmRsZXIoW3RoaXNdIChDcml0aWNhbCwgU3luY2hyb25vdXMpIHsK LSAgICAgICAgaWYgKHNob3VsZFRlcm1pbmF0ZSgpKQotICAgICAgICAgICAgdGVybWluYXRlKCk7 Ci0gICAgfSk7Ci0gICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLmluc3RhbGwoKTsKIH0KIAogdm9p ZCBQbHVnaW5Qcm9jZXNzOjpyZW1vdmVXZWJQcm9jZXNzQ29ubmVjdGlvbihXZWJQcm9jZXNzQ29u bmVjdGlvbiogd2ViUHJvY2Vzc0Nvbm5lY3Rpb24pCkBAIC0xMzcsNiArMTMwLDE3IEBAIHZvaWQg UGx1Z2luUHJvY2Vzczo6aW5pdGlhbGl6ZVBsdWdpblByb2Nlc3MoUGx1Z2luUHJvY2Vzc0NyZWF0 aW9uUGFyYW1ldGVycyYmIHBhCiB7CiAgICAgQVNTRVJUKCFtX3BsdWdpbk1vZHVsZSk7CiAKKyAg ICBhdXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNp bmdsZXRvbigpOworI2lmIE9TKExJTlVYKQorICAgIGlmIChwYXJhbWV0ZXJzLm1lbW9yeVByZXNz dXJlTW9uaXRvckhhbmRsZS5maWxlRGVzY3JpcHRvcigpICE9IC0xKQorICAgICAgICBtZW1vcnlQ cmVzc3VyZUhhbmRsZXIuc2V0TWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlKHBhcmFtZXRlcnMu bWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlLnJlbGVhc2VGaWxlRGVzY3JpcHRvcigpKTsKKyNl bmRpZgorICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRMb3dNZW1vcnlIYW5kbGVyKFt0aGlz XSAoQ3JpdGljYWwsIFN5bmNocm9ub3VzKSB7CisgICAgICAgIGlmIChzaG91bGRUZXJtaW5hdGUo KSkKKyAgICAgICAgICAgIHRlcm1pbmF0ZSgpOworICAgIH0pOworICAgIG1lbW9yeVByZXNzdXJl SGFuZGxlci5pbnN0YWxsKCk7CisKICAgICBtX3N1cHBvcnRzQXN5bmNocm9ub3VzUGx1Z2luSW5p dGlhbGl6YXRpb24gPSBwYXJhbWV0ZXJzLnN1cHBvcnRzQXN5bmNocm9ub3VzUGx1Z2luSW5pdGlh bGl6YXRpb247CiAgICAgc2V0TWluaW11bUxpZmV0aW1lKHBhcmFtZXRlcnMubWluaW11bUxpZmV0 aW1lKTsKICAgICBzZXRUZXJtaW5hdGlvblRpbWVvdXQocGFyYW1ldGVycy50ZXJtaW5hdGlvblRp bWVvdXQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2lu UHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvUGx1 Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAppbmRleCBlM2UxZmZkLi4z MDE1NGM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvUGx1Z2lucy9QbHVnaW5Q cm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQv UGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcApAQCAtNTEsNiArNTEs OSBAQCB2b2lkIFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVuY29kZShJUEM6OkFy Z3VtZW50RW5jb2RlciYgZW5jb2RlcikgY29ucwogICAgIElQQzo6ZW5jb2RlKGVuY29kZXIsIG5l dHdvcmtBVFNDb250ZXh0LmdldCgpKTsKICNlbmRpZgogI2VuZGlmCisjaWYgT1MoTElOVVgpCisg ICAgZW5jb2RlciA8PCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYKIH0KIAog Ym9vbCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpkZWNvZGUoSVBDOjpBcmd1bWVu dERlY29kZXImIGRlY29kZXIsIFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmIHJlc3Vs dCkKQEAgLTcxLDYgKzc0LDEwIEBAIGJvb2wgUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy czo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBQbHVnCiAgICAgICAgIHJl dHVybiBmYWxzZTsKICNlbmRpZgogI2VuZGlmCisjaWYgT1MoTElOVVgpCisgICAgaWYgKCFkZWNv ZGVyLmRlY29kZShyZXN1bHQubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlKSkKKyAgICAgICAg cmV0dXJuIGZhbHNlOworI2VuZGlmCiAKICAgICByZXR1cm4gdHJ1ZTsKIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnMuaCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVh dGlvblBhcmFtZXRlcnMuaAppbmRleCBhYzdkNjM4Li5kNjE3MTM5IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmgKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0 aW9uUGFyYW1ldGVycy5oCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpZiBFTkFCTEUoTkVUU0NBUEVf UExVR0lOX0FQSSkKIAorI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIKICNpbmNsdWRlICJQbHVnaW5Q cm9jZXNzQXR0cmlidXRlcy5oIgogCiAjaWYgUExBVEZPUk0oQ09DT0EpCkBAIC01OSw2ICs2MCw5 IEBAIHN0cnVjdCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzIHsKICAgICBSZXRhaW5Q dHI8Q0ZEYXRhUmVmPiBuZXR3b3JrQVRTQ29udGV4dDsKICNlbmRpZgogI2VuZGlmCisjaWYgT1Mo TElOVVgpCisgICAgSVBDOjpBdHRhY2htZW50IG1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZTsK KyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAgYi9Tb3VyY2Uv V2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5kZXggYTUz MWU0NS4uMWEyYjBkNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQ cm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcApAQCAtMTQxLDYgKzE0MSwxMCBAQCB2b2lkIFdl YlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVuY29kZShJUEM6OkFyZ3VtZW50RW5jb2RlciYg ZW5jb2RlcikgY29uc3QKICNpZiBUQVJHRVRfT1NfSVBIT05FIHx8IChQTEFURk9STShNQUMpICYm IF9fTUFDX09TX1hfVkVSU0lPTl9NSU5fUkVRVUlSRUQgPj0gMTAxMTAwKQogICAgIElQQzo6ZW5j b2RlKGVuY29kZXIsIG5ldHdvcmtBVFNDb250ZXh0LmdldCgpKTsKICNlbmRpZgorCisjaWYgT1Mo TElOVVgpCisgICAgZW5jb2RlciA8PCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5k aWYKIH0KIAogYm9vbCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpkZWNvZGUoSVBDOjpB cmd1bWVudERlY29kZXImIGRlY29kZXIsIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmIHBh cmFtZXRlcnMpCkBAIC0yOTYsNiArMzAwLDExIEBAIGJvb2wgV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBXZWJQcm9jCiAg ICAgICAgIHJldHVybiBmYWxzZTsKICNlbmRpZgogCisjaWYgT1MoTElOVVgpCisgICAgaWYgKCFk ZWNvZGVyLmRlY29kZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZSkpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzLmggYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cy5oCmluZGV4IGFkZDg0ZjMuLmM5YWEyYzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNlL1dlYktpdDIv U2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAtMTY2LDYgKzE2NiwxMCBA QCBzdHJ1Y3QgV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyB7CiAjaWYgVEFSR0VUX09TX0lQ SE9ORSB8fCAoUExBVEZPUk0oTUFDKSAmJiBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JFUVVJUkVE ID49IDEwMTEwMCkKICAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBuZXR3b3JrQVRTQ29udGV4dDsK ICNlbmRpZgorCisjaWYgT1MoTElOVVgpCisgICAgSVBDOjpBdHRhY2htZW50IG1lbW9yeVByZXNz dXJlTW9uaXRvckhhbmRsZTsKKyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy9QbHVnaW5Qcm9jZXNz UHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvUGx1Z2luUHJvY2Vz c1Byb3h5LmNwcAppbmRleCA4ZjUwNWE2Li5lNzA5MTI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzUHJveHkuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblByb2Nlc3NQcm94eS5jcHAKQEAgLTI4 LDYgKzI4LDcgQEAKIAogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVHSU5fQVBJKQogCisjaW5jbHVk ZSAiTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgiCiAjaW5jbHVkZSAiUGx1Z2luUHJvY2Vzc0Nvbm5l Y3Rpb25NYW5hZ2VyTWVzc2FnZXMuaCIKICNpbmNsdWRlICJQbHVnaW5Qcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiUGx1Z2luUHJvY2Vzc01hbmFnZXIuaCIKQEAgLTIyOSw2 ICsyMzAsMTIgQEAgdm9pZCBQbHVnaW5Qcm9jZXNzUHJveHk6OmRpZEZpbmlzaExhdW5jaGluZyhQ cm9jZXNzTGF1bmNoZXIqLCBJUEM6OkNvbm5lY3Rpb246OkkKICAgICAgICAgcGFyYW1ldGVycy5t aW5pbXVtTGlmZXRpbWUgPSBtaW5pbXVtTGlmZXRpbWU7CiAgICAgICAgIHBhcmFtZXRlcnMudGVy bWluYXRpb25UaW1lb3V0ID0gc2h1dGRvd25UaW1lb3V0OwogICAgIH0KKworI2lmIE9TKExJTlVY KQorICAgIGlmIChNZW1vcnlQcmVzc3VyZU1vbml0b3I6OmlzRW5hYmxlZCgpKQorICAgICAgICBw YXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZSA9IE1lbW9yeVByZXNzdXJlTW9u aXRvcjo6c2luZ2xldG9uKCkuY3JlYXRlSGFuZGxlKCk7CisjZW5kaWYKKwogICAgIHBsYXRmb3Jt SW5pdGlhbGl6ZVBsdWdpblByb2Nlc3MocGFyYW1ldGVycyk7CiAKICAgICAvLyBJbml0aWFsaXpl IHRoZSBwbHVnLWluIGhvc3QgcHJvY2Vzcy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJ UHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2Vi UHJvY2Vzc1Bvb2wuY3BwCmluZGV4IGE3ZTAzNDYuLmVhZGJhNGEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHAKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1 ZGUgIkRvd25sb2FkUHJveHkuaCIKICNpbmNsdWRlICJEb3dubG9hZFByb3h5TWVzc2FnZXMuaCIK ICNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAiTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgi CiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCIKICNpbmNsdWRl ICJOZXR3b3JrUHJvY2Vzc01lc3NhZ2VzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3NQcm94 eS5oIgpAQCAtMzcwLDYgKzM3MSwxMSBAQCBOZXR3b3JrUHJvY2Vzc1Byb3h5JiBXZWJQcm9jZXNz UG9vbDo6ZW5zdXJlTmV0d29ya1Byb2Nlc3MoKQogICAgICAgICBTYW5kYm94RXh0ZW5zaW9uOjpj cmVhdGVIYW5kbGUocGFyZW50QnVuZGxlRGlyZWN0b3J5LCBTYW5kYm94RXh0ZW5zaW9uOjpSZWFk T25seSwgcGFyYW1ldGVycy5wYXJlbnRCdW5kbGVEaXJlY3RvcnlFeHRlbnNpb25IYW5kbGUpOwog I2VuZGlmCiAKKyNpZiBPUyhMSU5VWCkKKyAgICBpZiAoTWVtb3J5UHJlc3N1cmVNb25pdG9yOjpp c0VuYWJsZWQoKSkKKyAgICAgICAgcGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5k bGUgPSBNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbigpLmNyZWF0ZUhhbmRsZSgpOwor I2VuZGlmCisKICAgICBwYXJhbWV0ZXJzLnNob3VsZFVzZVRlc3RpbmdOZXR3b3JrU2Vzc2lvbiA9 IG1fc2hvdWxkVXNlVGVzdGluZ05ldHdvcmtTZXNzaW9uOwogCiAgICAgLy8gQWRkIGFueSBwbGF0 Zm9ybSBzcGVjaWZpYyBwYXJhbWV0ZXJzCkBAIC02MjYsNiArNjMyLDggQEAgV2ViUHJvY2Vzc1By b3h5JiBXZWJQcm9jZXNzUG9vbDo6Y3JlYXRlTmV3V2ViUHJvY2VzcygpCiAKICNpZiBPUyhMSU5V WCkKICAgICBwYXJhbWV0ZXJzLnNob3VsZEVuYWJsZU1lbW9yeVByZXNzdXJlUmVsaWVmTG9nZ2lu ZyA9IHRydWU7CisgICAgaWYgKE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6aXNFbmFibGVkKCkpCisg ICAgICAgIHBhcmFtZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlID0gTWVtb3J5UHJl c3N1cmVNb25pdG9yOjpzaW5nbGV0b24oKS5jcmVhdGVIYW5kbGUoKTsKICNlbmRpZgogCiAgICAg cGFyYW1ldGVycy5yZXNvdXJjZUxvYWRTdGF0aXN0aWNzRW5hYmxlZCA9IHJlc291cmNlTG9hZFN0 YXRpc3RpY3NFbmFibGVkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv bGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAuLjllOTgxY2YKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNwcApAQCAtMCwwICsxLDI5MSBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5MLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq IDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAq IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJV VE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVS UE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMg Q09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJ REVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICogU1VCU1RJ VFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9S IEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhF T1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJ VFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAqIEFSSVNJ TkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgiCisKKyNp ZiBPUyhMSU5VWCkKKworI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIKKyNpbmNsdWRlIDxmY250bC5o PgorI2luY2x1ZGUgPG11dGV4PgorI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUgPHN0cmlu Zy5oPgorI2luY2x1ZGUgPHN5cy9ldmVudGZkLmg+CisjaW5jbHVkZSA8c3lzL3N0YXQuaD4KKyNp bmNsdWRlIDxzeXMvdHlwZXMuaD4KKyNpbmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDx3dGYv Q3VycmVudFRpbWUuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CisjaW5jbHVkZSA8d3Rm L1VuaVN0ZEV4dHJhcy5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworc3RhdGljIGNvbnN0IGRv dWJsZSBzX21pblBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcyA9IDE7CitzdGF0aWMgY29uc3QgZG91 YmxlIHNfbWF4UG9sbGluZ0ludGVydmFsSW5TZWNvbmRzID0gNTsKK3N0YXRpYyBjb25zdCBkb3Vi bGUgc19taW5Vc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcgPSA1MDsKK3N0YXRpYyBjb25z dCBkb3VibGUgc19tYXhVc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcgPSA5MDsKK3N0YXRp YyBjb25zdCBpbnQgc19tZW1vcnlQcmVzdXJlUGVyY2VudGFnZVRocmVzaG9sZCA9IDk1OworCitz dGF0aWMgc2l6ZV90IGxvd1dhdGVybWFya1BhZ2VzKCkKK3sKKyAgICBGSUxFKiBmaWxlID0gZm9w ZW4oIi9wcm9jL3pvbmVpbmZvIiwgInIiKTsKKyAgICBpZiAoIWZpbGUpCisgICAgICAgIHJldHVy biBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsKKworICAgIHNpemVfdCBsb3cgPSAwOworICAgIGJv b2wgaW5ab25lID0gZmFsc2U7CisgICAgYm9vbCBmb3VuZExvdyA9IGZhbHNlOworICAgIGNoYXIg YnVmZmVyWzEyOF07CisgICAgd2hpbGUgKGNoYXIqIGxpbmUgPSBmZ2V0cyhidWZmZXIsIDEyOCwg ZmlsZSkpIHsKKyAgICAgICAgaWYgKCFzdHJjbXAobGluZSwgIk5vZGUiKSkgeworICAgICAgICAg ICAgaW5ab25lID0gdHJ1ZTsKKyAgICAgICAgICAgIGZvdW5kTG93ID0gZmFsc2U7CisgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGNoYXIqIHRva2VuID0gc3RydG9r KGxpbmUsICIgIik7CisgICAgICAgIGlmICghdG9rZW4pCisgICAgICAgICAgICBjb250aW51ZTsK KworICAgICAgICBpZiAoIXN0cmNtcCh0b2tlbiwgImxvdyIpKSB7CisgICAgICAgICAgICBpZiAo IWluWm9uZSB8fCBmb3VuZExvdykgeworICAgICAgICAgICAgICAgIGxvdyA9IHN0YXRpY19jYXN0 PHNpemVfdD4oLTEpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAg ICAgICAgICAgdG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKTsKKyAgICAgICAgICAgIGlmICgh dG9rZW4pIHsKKyAgICAgICAgICAgICAgICBsb3cgPSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsK KyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIGxvdyAr PSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICBmb3VuZExvdyA9IHRydWU7CisgICAgICAgIH0K KyAgICB9CisgICAgZmNsb3NlKGZpbGUpOworCisgICAgcmV0dXJuIGxvdzsKK30KKworc3RhdGlj IGlubGluZSBzaXplX3Qgc3lzdGVtUGFnZVNpemUoKQoreworICAgIHN0YXRpYyBzaXplX3QgcGFn ZVNpemUgPSAwOworICAgIGlmICghcGFnZVNpemUpCisgICAgICAgIHBhZ2VTaXplID0gc3lzY29u ZihfU0NfUEFHRV9TSVpFKTsKKyAgICByZXR1cm4gcGFnZVNpemU7Cit9CisKK3N0YXRpYyBzaXpl X3QgY2FsY3VsYXRlTWVtb3J5QXZhaWxhYmxlKHNpemVfdCBtZW1vcnlGcmVlLCBzaXplX3QgYWN0 aXZlRmlsZSwgc2l6ZV90IGluYWN0aXZlRmlsZSwgc2l6ZV90IHNsYWJSZWNsYWltYWJsZSkKK3sK KyAgICBpZiAobWVtb3J5RnJlZSA9PSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICB8 fCBhY3RpdmVGaWxlID09IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpCisgICAgICAgIHx8IGluYWN0 aXZlRmlsZSA9PSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICB8fCBzbGFiUmVjbGFp bWFibGUgPT0gc3RhdGljX2Nhc3Q8c2l6ZV90PigtMSkpCisgICAgICAgIHJldHVybiBzdGF0aWNf Y2FzdDxzaXplX3Q+KC0xKTsKKworICAgIHNpemVfdCBsb3dXYXRlcm1hcmsgPSBsb3dXYXRlcm1h cmtQYWdlcygpOworICAgIGlmIChsb3dXYXRlcm1hcmsgPT0gc3RhdGljX2Nhc3Q8c2l6ZV90Pigt MSkpCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsKKworICAgIGxvd1dh dGVybWFyayAqPSBzeXN0ZW1QYWdlU2l6ZSgpIC8gS0I7CisKKyAgICAvLyBFc3RpbWF0ZSB0aGUg YW1vdW50IG9mIG1lbW9yeSBhdmFpbGFibGUgZm9yIHVzZXJzcGFjZSBhbGxvY2F0aW9ucywgd2l0 aG91dCBjYXVzaW5nIHN3YXBwaW5nLgorICAgIC8vIEZyZWUgbWVtb3J5IGNhbm5vdCBiZSB0YWtl biBiZWxvdyB0aGUgbG93IHdhdGVybWFyaywgYmVmb3JlIHRoZSBzeXN0ZW0gc3RhcnRzIHN3YXBw aW5nLgorICAgIGxvd1dhdGVybWFyayAqPSBzeXN0ZW1QYWdlU2l6ZSgpIC8gS0I7CisgICAgc2l6 ZV90IG1lbW9yeUF2YWlsYWJsZSA9IG1lbW9yeUZyZWUgLSBsb3dXYXRlcm1hcms7CisKKyAgICAv LyBOb3QgYWxsIHRoZSBwYWdlIGNhY2hlIGNhbiBiZSBmcmVlZCwgb3RoZXJ3aXNlIHRoZSBzeXN0 ZW0gd2lsbCBzdGFydCBzd2FwcGluZy4gQXNzdW1lIGF0IGxlYXN0CisgICAgLy8gaGFsZiBvZiB0 aGUgcGFnZSBjYWNoZSwgb3IgdGhlIGxvdyB3YXRlcm1hcmsgd29ydGggb2YgY2FjaGUsIG5lZWRz IHRvIHN0YXkuCisgICAgc2l6ZV90IHBhZ2VDYWNoZSA9IGFjdGl2ZUZpbGUgKyBpbmFjdGl2ZUZp bGU7CisgICAgcGFnZUNhY2hlIC09IHN0ZDo6bWluKHBhZ2VDYWNoZSAvIDIsIGxvd1dhdGVybWFy ayk7CisgICAgbWVtb3J5QXZhaWxhYmxlICs9IHBhZ2VDYWNoZTsKKworICAgIC8vIFBhcnQgb2Yg dGhlIHJlY2xhaW1hYmxlIHNsYWIgY29uc2lzdHMgb2YgaXRlbXMgdGhhdCBhcmUgaW4gdXNlLCBh bmQgY2Fubm90IGJlIGZyZWVkLgorICAgIC8vIENhcCB0aGlzIGVzdGltYXRlIGF0IHRoZSBsb3cg d2F0ZXJtYXJrLgorICAgIG1lbW9yeUF2YWlsYWJsZSArPSBzbGFiUmVjbGFpbWFibGUgLSBzdGQ6 Om1pbihzbGFiUmVjbGFpbWFibGUgLyAyLCBsb3dXYXRlcm1hcmspOworICAgIHJldHVybiBtZW1v cnlBdmFpbGFibGU7Cit9CisKK3N0YXRpYyBpbnQgc3lzdGVtTWVtb3J5VXNlZEFzUGVyY2VudGFn ZSgpCit7CisgICAgRklMRSogZmlsZSA9IGZvcGVuKCIvcHJvYy9tZW1pbmZvIiwgInIiKTsKKyAg ICBpZiAoIWZpbGUpCisgICAgICAgIHJldHVybiAtMTsKKworICAgIHNpemVfdCBtZW1vcnlBdmFp bGFibGUsIG1lbW9yeVRvdGFsLCBtZW1vcnlGcmVlLCBhY3RpdmVGaWxlLCBpbmFjdGl2ZUZpbGUs IHNsYWJSZWNsYWltYWJsZTsKKyAgICBtZW1vcnlBdmFpbGFibGUgPSBtZW1vcnlUb3RhbCA9IG1l bW9yeUZyZWUgPSBhY3RpdmVGaWxlID0gaW5hY3RpdmVGaWxlID0gc2xhYlJlY2xhaW1hYmxlID0g c3RhdGljX2Nhc3Q8c2l6ZV90PigtMSk7CisgICAgY2hhciBidWZmZXJbMTI4XTsKKyAgICB3aGls ZSAoY2hhciogbGluZSA9IGZnZXRzKGJ1ZmZlciwgMTI4LCBmaWxlKSkgeworICAgICAgICBjaGFy KiB0b2tlbiA9IHN0cnRvayhsaW5lLCAiICIpOworICAgICAgICBpZiAoIXRva2VuKQorICAgICAg ICAgICAgYnJlYWs7CisKKyAgICAgICAgaWYgKCFzdHJjbXAodG9rZW4sICJNZW1BdmFpbGFibGU6 IikpIHsKKyAgICAgICAgICAgIGlmICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpIHsK KyAgICAgICAgICAgICAgICBtZW1vcnlBdmFpbGFibGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAg ICAgICAgICAgaWYgKG1lbW9yeVRvdGFsICE9IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpKQorICAg ICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIGlm ICghc3RyY21wKHRva2VuLCAiTWVtVG90YWw6IikpIHsKKyAgICAgICAgICAgIGlmICgodG9rZW4g PSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpCisgICAgICAgICAgICAgICAgbWVtb3J5VG90YWwgPSBh dG9sbCh0b2tlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7Cisg ICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIk1lbUZyZWU6IikpIHsKKyAgICAgICAg ICAgIGlmICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpCisgICAgICAgICAgICAgICAg bWVtb3J5RnJlZSA9IGF0b2xsKHRva2VuKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgfSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAiQWN0aXZlKGZp bGUpOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikp KQorICAgICAgICAgICAgICAgIGFjdGl2ZUZpbGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNt cCh0b2tlbiwgIkluYWN0aXZlKGZpbGUpOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0g c3RydG9rKG51bGxwdHIsICIgIikpKQorICAgICAgICAgICAgICAgIGluYWN0aXZlRmlsZSA9IGF0 b2xsKHRva2VuKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgfSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAiU1JlY2xhaW1hYmxlOiIpKSB7CisgICAg ICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikpKQorICAgICAgICAgICAg ICAgIHNsYWJSZWNsYWltYWJsZSA9IGF0b2xsKHRva2VuKTsKKyAgICAgICAgICAgIGVsc2UKKyAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAgICAgIGlmIChtZW1vcnlUb3Rh bCAhPSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAgICAgJiYgbWVtb3J5RnJlZSAh PSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAgICAgJiYgYWN0aXZlRmlsZSAhPSBz dGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAgICAgJiYgaW5hY3RpdmVGaWxlICE9IHN0 YXRpY19jYXN0PHNpemVfdD4oLTEpCisgICAgICAgICAgICAmJiBzbGFiUmVjbGFpbWFibGUgIT0g c3RhdGljX2Nhc3Q8c2l6ZV90PigtMSkpCisgICAgICAgICAgICBicmVhazsKKyAgICB9CisgICAg ZmNsb3NlKGZpbGUpOworCisgICAgaWYgKG1lbW9yeVRvdGFsID09IHN0YXRpY19jYXN0PHNpemVf dD4oLTEpKQorICAgICAgICByZXR1cm4gLTE7CisKKyAgICBpZiAobWVtb3J5QXZhaWxhYmxlID09 IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpKSB7CisgICAgICAgIC8vIElmIE1lbUF2YWlsYWJsZSB3 YXMgbm90IHByZXNlbnQgaW4gL3Byb2MvbWVtaW5mbywgYmVjYXVzZSBpdCdzIGFuIG9sZCBrZXJu ZWwgdmVyc2lvbiwKKyAgICAgICAgLy8gd2UgY2FuIGRvIHRoZSBzYW1lIGNhbGN1bGF0aW9uIHdp dGggdGhlIGluZm9ybWF0aW9uIHdlIGhhdmUgZnJvbSBtZW1pbmZvIGFuZCB0aGUgbG93IHdhdGVy bWFrcy4KKyAgICAgICAgLy8gU2VlIGh0dHBzOi8vZ2l0Lmtlcm5lbC5vcmcvY2dpdC9saW51eC9r ZXJuZWwvZ2l0L3RvcnZhbGRzL2xpbnV4LmdpdC9jb21taXQvP2lkPTM0ZTQzMWIwYWUzOThmYzU0 ZWE2OWZmODVlYzcwMDcyMmM5ZGE3NzMKKyAgICAgICAgbWVtb3J5QXZhaWxhYmxlID0gY2FsY3Vs YXRlTWVtb3J5QXZhaWxhYmxlKG1lbW9yeUZyZWUsIGFjdGl2ZUZpbGUsIGluYWN0aXZlRmlsZSwg c2xhYlJlY2xhaW1hYmxlKTsKKyAgICAgICAgaWYgKG1lbW9yeUF2YWlsYWJsZSA9PSBzdGF0aWNf Y2FzdDxzaXplX3Q+KC0xKSkKKyAgICAgICAgICAgIHJldHVybiAtMTsKKyAgICB9CisKKyAgICBy ZXR1cm4gKChtZW1vcnlUb3RhbCAtIG1lbW9yeUF2YWlsYWJsZSkgKiAxMDApIC8gbWVtb3J5VG90 YWw7Cit9CisKK3N0YXRpYyBpbmxpbmUgZG91YmxlIHBvbGxJbnRlcnZhbEZvclVzZWRNZW1vcnlQ ZXJjZW50YWdlKGludCB1c2VkUGVyY2VudGFnZSkKK3sKKyAgICAvLyBVc2UgYSBkaWZmZXJlbnQg cG9sbCBpbnRlcnZhbCBkZXBlbmRpbmcgb24gdGhlIGN1cnJlbnRseSBtZW1vcnkgdXNlZCwKKyAg ICAvLyB0byBhdm9pZCBwb2xsaW5nIHRvbyBvZnRlbiB3aGVuIHRoZSBzeXN0ZW0gaXMgdW5kZXIg bG93IG1lbW9yeSB1c2FnZS4KKyAgICBpZiAodXNlZFBlcmNlbnRhZ2UgPCBzX21pblVzZWRNZW1v cnlQZXJjZW50YWdlRm9yUG9sbGluZykKKyAgICAgICAgcmV0dXJuIHNfbWF4UG9sbGluZ0ludGVy dmFsSW5TZWNvbmRzOworCisgICAgaWYgKHVzZWRQZXJjZW50YWdlID49IHNfbWF4VXNlZE1lbW9y eVBlcmNlbnRhZ2VGb3JQb2xsaW5nKQorICAgICAgICByZXR1cm4gc19taW5Qb2xsaW5nSW50ZXJ2 YWxJblNlY29uZHM7CisKKyAgICByZXR1cm4gc19taW5Qb2xsaW5nSW50ZXJ2YWxJblNlY29uZHMg KyAoc19tYXhQb2xsaW5nSW50ZXJ2YWxJblNlY29uZHMgLSBzX21pblBvbGxpbmdJbnRlcnZhbElu U2Vjb25kcykgKgorICAgICAgICAoKHVzZWRQZXJjZW50YWdlIC0gc19taW5Vc2VkTWVtb3J5UGVy Y2VudGFnZUZvclBvbGxpbmcpIC8gKHNfbWF4VXNlZE1lbW9yeVBlcmNlbnRhZ2VGb3JQb2xsaW5n IC0gc19taW5Vc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcpKTsKK30KKworc3RhdGljIGJv b2wgaXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25pdG9yQXZhaWxhYmxlKCkKK3sKKyAgICBpbnQg ZmQgPSBvcGVuKCIvc3lzL2ZzL2Nncm91cC9tZW1vcnkvbWVtb3J5LnByZXNzdXJlX2xldmVsIiwg T19DTE9FWEVDIHwgT19SRE9OTFkpOworICAgIGlmIChmZCA9PSAtMSkKKyAgICAgICAgcmV0dXJu IGZhbHNlOworICAgIGNsb3NlKGZkKTsKKworICAgIGZkID0gb3BlbigiL3N5cy9mcy9jZ3JvdXAv bWVtb3J5L2Nncm91cC5ldmVudF9jb250cm9sIiwgT19DTE9FWEVDIHwgT19XUk9OTFkpOworICAg IGlmIChmZCA9PSAtMSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGNsb3NlKGZkKTsKKwor ICAgIHJldHVybiB0cnVlOworfQorCitib29sIE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6aXNFbmFi bGVkKCkKK3sKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25jZUZsYWc7CisgICAgc3RhdGlj IGJvb2wgZW5hYmxlZDsKKyAgICBzdGQ6OmNhbGxfb25jZShvbmNlRmxhZywgW10geyBlbmFibGVk ID0gIWlzU3lzdGVtZE1lbW9yeVByZXNzdXJlTW9uaXRvckF2YWlsYWJsZSgpOyB9KTsKKyAgICBy ZXR1cm4gZW5hYmxlZDsKK30KKworTWVtb3J5UHJlc3N1cmVNb25pdG9yJiBNZW1vcnlQcmVzc3Vy ZU1vbml0b3I6OnNpbmdsZXRvbigpCit7CisgICAgQVNTRVJUKGlzRW5hYmxlZCgpKTsKKyAgICBz dGF0aWMgTmV2ZXJEZXN0cm95ZWQ8TWVtb3J5UHJlc3N1cmVNb25pdG9yPiBtZW1vcnlNb25pdG9y OworICAgIHJldHVybiBtZW1vcnlNb25pdG9yOworfQorCitNZW1vcnlQcmVzc3VyZU1vbml0b3I6 Ok1lbW9yeVByZXNzdXJlTW9uaXRvcigpCisgICAgOiBtX2V2ZW50RkQoZXZlbnRmZCgwLCBFRkRf Q0xPRVhFQykpCit7CisgICAgaWYgKG1fZXZlbnRGRCA9PSAtMSkKKyAgICAgICAgcmV0dXJuOwor CisgICAgVGhyZWFkSWRlbnRpZmllciB0aHJlYWRJZGVudGlmaWVyID0gY3JlYXRlVGhyZWFkKCJN ZW1vcnlQcmVzc3VyZU1vbml0b3IiLCBbdGhpc10geworICAgICAgICBkb3VibGUgcG9sbEludGVy dmFsID0gc19tYXhQb2xsaW5nSW50ZXJ2YWxJblNlY29uZHM7CisgICAgICAgIHdoaWxlICh0cnVl KSB7CisgICAgICAgICAgICBzbGVlcChwb2xsSW50ZXJ2YWwpOworCisgICAgICAgICAgICBpbnQg dXNlZFBlcmNlbnRhZ2UgPSBzeXN0ZW1NZW1vcnlVc2VkQXNQZXJjZW50YWdlKCk7CisgICAgICAg ICAgICBpZiAodXNlZFBlcmNlbnRhZ2UgPj0gc19tZW1vcnlQcmVzdXJlUGVyY2VudGFnZVRocmVz aG9sZCkgeworICAgICAgICAgICAgICAgIHVpbnQ2NF90IGZkRXZlbnQgPSAxOworICAgICAgICAg ICAgICAgIHdyaXRlKG1fZXZlbnRGRCwgJmZkRXZlbnQsIHNpemVvZih1aW50NjRfdCkpOworICAg ICAgICAgICAgfQorICAgICAgICAgICAgcG9sbEludGVydmFsID0gcG9sbEludGVydmFsRm9yVXNl ZE1lbW9yeVBlcmNlbnRhZ2UodXNlZFBlcmNlbnRhZ2UpOworICAgICAgICB9CisgICAgICAgIGNs b3NlKG1fZXZlbnRGRCk7CisgICAgfSk7CisgICAgZGV0YWNoVGhyZWFkKHRocmVhZElkZW50aWZp ZXIpOworfQorCitJUEM6OkF0dGFjaG1lbnQgTWVtb3J5UHJlc3N1cmVNb25pdG9yOjpjcmVhdGVI YW5kbGUoKSBjb25zdAoreworICAgIGludCBkdXBsaWNhdGVkSGFuZGxlOworICAgIHdoaWxlICgo ZHVwbGljYXRlZEhhbmRsZSA9IGR1cChtX2V2ZW50RkQpKSA9PSAtMSkgeworICAgICAgICBpZiAo ZXJybm8gIT0gRUlOVFIpIHsKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg ICAgICAgICAgcmV0dXJuIHsgfTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHdoaWxlIChmY250 bChkdXBsaWNhdGVkSGFuZGxlLCBGX1NFVEZELCBGRF9DTE9FWEVDKSA9PSAtMSkgeworICAgICAg ICBpZiAoZXJybm8gIT0gRUlOVFIpIHsKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgp OworICAgICAgICAgICAgY2xvc2VXaXRoUmV0cnkoZHVwbGljYXRlZEhhbmRsZSk7CisgICAgICAg ICAgICByZXR1cm4geyB9OworICAgICAgICB9CisgICAgfQorICAgIHJldHVybiBJUEM6OkF0dGFj aG1lbnQoZHVwbGljYXRlZEhhbmRsZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisj ZW5kaWYgLy8gT1MoTElOVVgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv bGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mv bGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uMzg3NGQ5MAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuaApAQCAtMCwwICsxLDU4IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBg QVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklC VVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25j ZQorCisjaWYgT1MoTElOVVgpCisKKyNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KKyNp bmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKworbmFtZXNwYWNlIElQQyB7CitjbGFzcyBBdHRh Y2htZW50OworfQorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgTWVtb3J5UHJlc3N1cmVN b25pdG9yIHsKKyAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZW1vcnlQcmVzc3VyZU1vbml0b3Ip OworICAgIGZyaWVuZCBjbGFzcyBOZXZlckRlc3Ryb3llZDxNZW1vcnlQcmVzc3VyZU1vbml0b3I+ OworcHVibGljOgorICAgIHN0YXRpYyBNZW1vcnlQcmVzc3VyZU1vbml0b3ImIHNpbmdsZXRvbigp OworICAgIHN0YXRpYyBib29sIGlzRW5hYmxlZCgpOworCisgICAgfk1lbW9yeVByZXNzdXJlTW9u aXRvcigpOworCisgICAgSVBDOjpBdHRhY2htZW50IGNyZWF0ZUhhbmRsZSgpIGNvbnN0OworCitw cml2YXRlOgorICAgIE1lbW9yeVByZXNzdXJlTW9uaXRvcigpOworCisgICAgaW50IG1fZXZlbnRG RCB7IC0xIH07Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIE9TKExJ TlVYKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNw cCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHAKaW5kZXggNmQ0MzIy My4uMmM5NmM3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQcm9j ZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwCkBA IC0yNjYsNyArMjY2LDkgQEAgdm9pZCBXZWJQcm9jZXNzOjppbml0aWFsaXplV2ViUHJvY2VzcyhX ZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1ldGVycykKICAgICBBU1NFUlQobV9w YWdlTWFwLmlzRW1wdHkoKSk7CiAKICNpZiBPUyhMSU5VWCkKLSAgICBXZWJDb3JlOjpNZW1vcnlQ cmVzc3VyZUhhbmRsZXI6OlJlbGllZkxvZ2dlcjo6c2V0TG9nZ2luZ0VuYWJsZWQocGFyYW1ldGVy cy5zaG91bGRFbmFibGVNZW1vcnlQcmVzc3VyZVJlbGllZkxvZ2dpbmcpOworICAgIGlmIChwYXJh bWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZS5maWxlRGVzY3JpcHRvcigpICE9IC0x KQorICAgICAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRvbigpLnNldE1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRs ZS5yZWxlYXNlRmlsZURlc2NyaXB0b3IoKSk7CisgICAgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpS ZWxpZWZMb2dnZXI6OnNldExvZ2dpbmdFbmFibGVkKHBhcmFtZXRlcnMuc2hvdWxkRW5hYmxlTWVt b3J5UHJlc3N1cmVSZWxpZWZMb2dnaW5nKTsKICNlbmRpZgogCiAgICAgcGxhdGZvcm1Jbml0aWFs aXplV2ViUHJvY2VzcyhXVEZNb3ZlKHBhcmFtZXRlcnMpKTsK 283524 2016-07-13 06:31:51 -0700 2016-07-14 00:01:36 -0700 Updated patch wk2-memory-pressure.diff text/plain 35907 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA0MGQ2NDQ3Li42ZTI5MWEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTgg QEAKIDIwMTYtMDctMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgogCisgICAgICAgIE1lbW9yeVByZXNzdXJlSGFuZGxlciBkb2Vzbid0IHdvcmsgaWYgY2dyb3Vw cyBhcmVuJ3QgcHJlc2VudCBpbiBMaW51eAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTU1MjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWxsb3cgdG8gcGFzcyBhbiBldmVudEZEIGZpbGUgZGVzY3JpcHRv ciB0byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIHRvIGJlIG1vbml0b3JpemVkIGluIGNhc2Ug Y2dyb3VwcyBhcmUgbm90CisgICAgICAgIGF2YWlsYWJsZS4KKworICAgICAgICAqIHBsYXRmb3Jt L01lbW9yeVByZXNzdXJlSGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2xpbnV4L01lbW9y eVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcDoKKworMjAxNi0wNy0wMSAgQ2FybG9zIEdhcmNpYSBD YW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKICAgICAgICAgW0dMaWJdIFVzZSBhIEdTb3Vy Y2UgaW5zdGVhZCBvZiBhIHRocmVhZCB0byBwb2xsIG1lbW9yeSBwcmVzc3VyZSBldmVudEZEIGlu IGxpbnV4IGltcGxlbWVudGF0aW9uCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0xNTkzNDYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vTWVtb3J5UHJlc3N1cmVIYW5kbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1v cnlQcmVzc3VyZUhhbmRsZXIuaAppbmRleCAwMWZkODE0Li44YjA0ZDQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaApAQCAtODQsNiArODQs OCBAQCBwdWJsaWM6CiAgICAgV0VCQ09SRV9FWFBPUlQgdm9pZCBjbGVhck1lbW9yeVByZXNzdXJl KCk7CiAgICAgV0VCQ09SRV9FWFBPUlQgYm9vbCBzaG91bGRXYWl0Rm9yTWVtb3J5Q2xlYXJNZXNz YWdlKCk7CiAgICAgdm9pZCByZXNwb25kVG9NZW1vcnlQcmVzc3VyZUlmTmVlZGVkKCk7CisjZWxp ZiBPUyhMSU5VWCkKKyAgICB2b2lkIHNldE1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZShpbnQg ZmQpOwogI2VuZGlmCiAKICAgICBjbGFzcyBSZWxpZWZMb2dnZXIgewpAQCAtMTc5LDYgKzE4MSw3 IEBAIHByaXZhdGU6CiAgICAgUnVuTG9vcDo6VGltZXI8TWVtb3J5UHJlc3N1cmVIYW5kbGVyPiBt X2hvbGRPZmZUaW1lcjsKICAgICB2b2lkIGhvbGRPZmZUaW1lckZpcmVkKCk7CiAgICAgdm9pZCBs b2dFcnJvckFuZENsb3NlRkRzKGNvbnN0IGNoYXIqIGVycm9yKTsKKyAgICBib29sIHRyeUVuc3Vy ZUV2ZW50RkQoKTsKICNlbmRpZgogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbGludXgvTWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCmluZGV4IDEy YzYxODYuLjYwOGUwYzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2xpbnV4 L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKQEAgLTE5MywyOSArMTkz LDMwIEBAIGlubGluZSB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6bG9nRXJyb3JBbmRDbG9z ZUZEcyhjb25zdCBjaGFyKiBsb2cpCiAgICAgfQogfQogCi12b2lkIE1lbW9yeVByZXNzdXJlSGFu ZGxlcjo6aW5zdGFsbCgpCitib29sIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6dHJ5RW5zdXJlRXZl bnRGRCgpCiB7Ci0gICAgaWYgKG1faW5zdGFsbGVkIHx8IG1faG9sZE9mZlRpbWVyLmlzQWN0aXZl KCkpCi0gICAgICAgIHJldHVybjsKKyAgICBpZiAoIW1fZXZlbnRGRCkKKyAgICAgICAgcmV0dXJu IHRydWU7CiAKKyAgICAvLyBUcnkgdG8gdWUgc3lzdGVtZCBpbnN0ZWFkLgogICAgIGludCBmZCA9 IGV2ZW50ZmQoMCwgRUZEX0NMT0VYRUMpOwogICAgIGlmIChmZCA9PSAtMSkgewogICAgICAgICBM T0coTWVtb3J5UHJlc3N1cmUsICJldmVudGZkKCkgZmFpbGVkOiAlbSIpOwotICAgICAgICByZXR1 cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAgICAgbV9ldmVudEZEID0gZmQ7CiAK ICAgICBmZCA9IG9wZW4oc19jZ3JvdXBNZW1vcnlQcmVzc3VyZUxldmVsLCBPX0NMT0VYRUMgfCBP X1JET05MWSk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VG RHMoIkZhaWxlZCB0byBvcGVuIG1lbW9yeS5wcmVzc3VyZV9sZXZlbCIpOwotICAgICAgICByZXR1 cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAgICAgbV9wcmVzc3VyZUxldmVsRkQg PSBmZDsKIAogICAgIGZkID0gb3BlbihzX2Nncm91cEV2ZW50Q29udHJvbCwgT19DTE9FWEVDIHwg T19XUk9OTFkpOwogICAgIGlmIChmZCA9PSAtMSkgewogICAgICAgICBsb2dFcnJvckFuZENsb3Nl RkRzKCJGYWlsZWQgdG8gb3BlbiBjZ3JvdXAuZXZlbnRfY29udHJvbCIpOwotICAgICAgICByZXR1 cm47CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKICAgICBjaGFyIGxpbmVbMTI4XSA9 IHswLCB9OwpAQCAtMjIzLDEwICsyMjQsMjEgQEAgdm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6 Omluc3RhbGwoKQogICAgICAgICB8fCB3cml0ZShmZCwgbGluZSwgc3RybGVuKGxpbmUpICsgMSkg PCAwKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMoIkZhaWxlZCB0byB3cml0ZSBjZ3Jv dXAuZXZlbnRfY29udHJvbCIpOwogICAgICAgICBjbG9zZShmZCk7Ci0gICAgICAgIHJldHVybjsK KyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBjbG9zZShmZCk7CiAKKyAgICByZXR1 cm4gdHJ1ZTsKK30KKwordm9pZCBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6Omluc3RhbGwoKQorewor ICAgIGlmIChtX2luc3RhbGxlZCB8fCBtX2hvbGRPZmZUaW1lci5pc0FjdGl2ZSgpKQorICAgICAg ICByZXR1cm47CisKKyAgICBpZiAoIXRyeUVuc3VyZUV2ZW50RkQoKSkKKyAgICAgICAgcmV0dXJu OworCiAgICAgbV9ldmVudEZEUG9sbGVyID0gc3RkOjptYWtlX3VuaXF1ZTxFdmVudEZEUG9sbGVy PihtX2V2ZW50RkQudmFsdWUoKSwgW3RoaXNdIHsKICAgICAgICAgLy8gRklYTUU6IEN1cnJlbnQg bWVtY2cgZG9lcyBub3QgcHJvdmlkZSBhbnkgd2F5IGZvciB1c2VycyB0byBrbm93IGhvdyBzZXJp b3VzIHRoZSBtZW1vcnkgcHJlc3N1cmUgaXMuCiAgICAgICAgIC8vIFNvIHdlIGFzc3VtZSBhbGwg bm90aWZpY2F0aW9ucyBmcm9tIG1lbWNnIGFyZSBjcml0aWNhbCBmb3Igbm93LiBJZiBtZW1jZyBo YWQgYmV0dGVyIGluZmVyZmFjZXMKQEAgLTI1Nyw3ICsyNjksMTcgQEAgdm9pZCBNZW1vcnlQcmVz c3VyZUhhbmRsZXI6OnVuaW5zdGFsbCgpCiAgICAgbV9ob2xkT2ZmVGltZXIuc3RvcCgpOwogICAg IG1fZXZlbnRGRFBvbGxlciA9IG51bGxwdHI7CiAKLSAgICBsb2dFcnJvckFuZENsb3NlRkRzKG51 bGxwdHIpOworICAgIGlmIChtX3ByZXNzdXJlTGV2ZWxGRCkgeworICAgICAgICBjbG9zZShtX3By ZXNzdXJlTGV2ZWxGRC52YWx1ZSgpKTsKKyAgICAgICAgbV9wcmVzc3VyZUxldmVsRkQgPSBOdWxs b3B0OworCisgICAgICAgIC8vIE9ubHkgY2xvc2UgdGhlIGV2ZW50RkQgdXNlZCBmb3Igc3lzdGVt ZC4KKyAgICAgICAgaWYgKG1fZXZlbnRGRCkgeworICAgICAgICAgICAgY2xvc2UobV9ldmVudEZE LnZhbHVlKCkpOworICAgICAgICAgICAgbV9ldmVudEZEID0gTnVsbG9wdDsKKyAgICAgICAgfQor ICAgIH0KKwogICAgIG1faW5zdGFsbGVkID0gZmFsc2U7CiB9CiAKQEAgLTMwOSw2ICszMzEsMTIg QEAgc2l6ZV90IE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6UmVsaWVmTG9nZ2VyOjpwbGF0Zm9ybU1l bW9yeVVzYWdlKCkKICAgICByZXR1cm4gdm1TaXplOwogfQogCit2b2lkIE1lbW9yeVByZXNzdXJl SGFuZGxlcjo6c2V0TWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlKGludCBmZCkKK3sKKyAgICBB U1NFUlQoIW1fZXZlbnRGRCk7CisgICAgbV9ldmVudEZEID0gZmQ7Cit9CisKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIE9TKExJTlVYKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IGI4MmNiOTEu LjI5MzZhNzQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSw2OCBAQAorMjAxNi0wNy0wMSAgQ2FybG9z IEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CisKKyAgICAgICAgTWVtb3J5UHJl c3N1cmVIYW5kbGVyIGRvZXNuJ3Qgd29yayBpZiBjZ3JvdXBzIGFyZW4ndCBwcmVzZW50IGluIExp bnV4CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNTUy NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGVy ZSdzIG5vIHdheSB0byBnZXQgbm90aWZpY2F0aW9ucyBhYm91dCBtZW1vcnkgcHJlc3N1cmUgaW4g TGludXggd2l0aG91dCB1c2luZyBjZ3JvdXBzIHRoYXQgZG9lc24ndCByZXF1aXJlIGEKKyAgICAg ICAgbWFudWFsIHBvbGxpbmcuIFdlIGNhbiBnZXQgdGhhdCBpbmZvcm1hdGlvbiBmcm9tIC9wcm9j L21lbWluZm8sIGJ1dCB0aGF0J3Mgbm90IHBvbGxhYmxlIHNvIGl0IHJlcXVpcmVzIHRvCisgICAg ICAgIG1hbnVhbGx5IGNoZWNrIGl0cyBjb250ZW50cyBpbiBhIGxvb3Agc2xlZXBpbmcgZm9yIGEg d2hpbGUgYmV0d2VlbiBjaGVja3MuIFRoaXMgbWVhbnMgd2Ugd291bGQgYmUgd2FraW5nIHVwIHRo ZQorICAgICAgICBwcm9jZXNzIG9uIGV2ZXJ5IHBvbGwgaXRlcmF0aW9uLCBtb3N0IG9mIHRoZSB0 aW1lcyBmb3Igbm90aGluZy4gVGhhdCdzIHNwZWNpYWxseSBwcm9ibGVtYXRpYyBvbiBkZXZpY2Vz IHJ1bm5pbmcKKyAgICAgICAgb24gYmF0dGVyeS4gQW5kIHRha2luZyBpbnRvIGFjY291bnQgdGhh dCB0aGVyZSdzIGEgbWVtb3J5IHByZXNzdXJlIGhhbmRsZXIgaW4gZXZlcnkgc2Vjb25kYXJ5IHBy b2Nlc3MgKFdlYiwKKyAgICAgICAgTmV0d29yayBhbmQgUGx1Z2luKSwgd2Ugd291bGQgYmUgd2Fr aW5nIHVwIGFsbCB0aG9zZSBwcm9jZXNzIGFsbCB0aGUgdGltZS4gSG93ZXZlciwgbm90IGhhdmlu ZyBhIG1lbW9yeSBwcmVzc3VyZQorICAgICAgICBoYW5kbGVyIGlzIGV2ZW4gbW9yZSBwcm9ibGVt YXRpYyB0aGFuIHRoZSBtYW51YWwgcG9sbGluZy4KKyAgICAgICAgVGhpcyBwYXRjaCBhZGRzIGEg Y2xhc3MgTWVtb3J5UHJlc3N1cmVNb25pdG9yIHRvIHRoZSBtYW51YWwgcG9sbGluZyBvZiAvcHJv Yy9tZW1pbmZvLCBidXQgcnVucyBpbiB0aGUgVUkKKyAgICAgICAgcHJvY2VzcywgdG8gYXZvaWQg dGhlIHdlYWt1cHMgaW4gYWxsIG90aGVyIHNlY29uZGFyeSBwcm9jZXNzZXMsIGFuZCB1c2VzIGFu IGV2ZW50RkQgdG8gbm90aWZ5IGFsbCBvdGhlcgorICAgICAgICBwcm9jZXNzZXMuIEl0J3Mgb25s eSB1c2VkIGluIGNhc2UgY2dyb3VwcyBpcyBub3QgYXZhaWxhYmxlLiBUaGUgZXZlbnRGRCBkZXNj cmlwdG9yIGlzIHNlbnQgdG8gYWxsIG90aGVyCisgICAgICAgIHByb2Nlc3NlcyBhdCBzdGFydHVw LCBhbmQgcGFzc2VkIHRvIHRoZSBNZW1vcnlQcmVzc3VyZUhhbmRsZXIgYmVmb3JlIGluc3RhbGwo KSBpcyBjYWxsZWQgZm9yIHRoZSBmaXJzdAorICAgICAgICB0aW1lLiBUbyBtaW5pbWl6ZSB0aGUg d2FrZXVwcyBldmVuIGluIHRoZSBVSSBwcm9jZXNzLCB0aGUgcG9sbCBpbnRlcnZhbCBpcyBjYWxj dWxhdGVkIGZyb20gMSB0byA1IHNlY29uZHMKKyAgICAgICAgZGVwZW5kaW5nIG9uIHRoZSBjdXJy ZW50IG1lbW9yeSB1c2VkLCBzbyBpbiBjYXNlIG9mIGxvdyBtZW1vcnkgbGV2ZWwgd2Ugc2xlZXAg Zm9yIGEgbG9uZ2VyIHRpbWUuCisgICAgICAgIEl0J3MgYWxzbyBpbXBvcnRhbnQgdG8gbWFrZSB0 aGUgbWVtb3J5IGNhbGN1bGF0aW9ucyBhcyBhY2N1cmF0ZSBhcyBwb3NzaWJsZSB0byBhdm9pZCBj bGVhbmluZyByZXNvdXJjZXMgaW4gdGhlCisgICAgICAgIHNlY29uZGFyeSBwcm9jZXNzZXMgdW5u ZWNlc3NhcmlseS4KKworICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNw cDoKKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nlc3M6OmluaXRpYWxpemVOZXR3b3JrUHJv Y2Vzcyk6IFBhc3MgdGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGZpbGUgZGVzY3JpcHRvciB0 byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyLgorICAgICAgICAqIE5ldHdvcmtQcm9jZXNzL05l dHdvcmtQcm9jZXNzLmg6CisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwOgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVyczo6ZW5jb2RlKTogRW5jb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9y IGhhbmRsZS4KKyAgICAgICAgKFdlYktpdDo6TmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnM6OmRlY29kZSk6IERlY29kZSBtZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBoYW5kbGUuCisgICAg ICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaDoK KyAgICAgICAgKiBQbGF0Zm9ybUVmbC5jbWFrZTogQWRkIG5ldyBmaWxlIHRvIGNvbXBpbGF0aW9u LCBhbmQgdXBkYXRlIGluY2x1ZGUgZGlycy4KKyAgICAgICAgKiBQbGF0Zm9ybUdUSy5jbWFrZTog RGl0dG8uCisgICAgICAgICogUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNwcDoKKyAgICAg ICAgKFdlYktpdDo6UGx1Z2luUHJvY2Vzczo6aW5pdGlhbGl6ZVBsdWdpblByb2Nlc3MpOiBQYXNz IHRoZSBtZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBmaWxlIGRlc2NyaXB0b3IgdG8gdGhlIE1lbW9y eVByZXNzdXJlSGFuZGxlci4KKyAgICAgICAgKiBTaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2luUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVyczo6ZW5jb2RlKTogRW5jb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9y IGhhbmRsZS4KKyAgICAgICAgKFdlYktpdDo6UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy czo6ZGVjb2RlKTogRGVjb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAg ICAgKiBTaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmg6Cisg ICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwOgorICAgICAg ICAoV2ViS2l0OjpXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUg bWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9j ZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpkZWNvZGUpOiBEZWNvZGUgbWVtb3J5IHByZXNzdXJlIG1v bml0b3IgaGFuZGxlLgorICAgICAgICAqIFNoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzLmg6CisgICAgICAgICogVUlQcm9jZXNzL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc1Byb3h5LmNw cDoKKyAgICAgICAgKFdlYktpdDo6UGx1Z2luUHJvY2Vzc1Byb3h5OjpkaWRGaW5pc2hMYXVuY2hp bmcpOiBDcmVhdGUgdGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZSBmb3IgdGhlIHBs dWdpbgorICAgICAgICBwcm9jZXNzIGlmIG5lZWRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvV2Vi UHJvY2Vzc1Bvb2wuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzUG9vbDo6ZW5zdXJl TmV0d29ya1Byb2Nlc3MpOiBDcmVhdGUgdGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRs ZSBmb3IgdGhlIG5ldHdvcmsKKyAgICAgICAgcHJvY2VzcyBpZiBuZWVkZWQuCisgICAgICAgIChX ZWJLaXQ6OldlYlByb2Nlc3NQb29sOjpjcmVhdGVOZXdXZWJQcm9jZXNzKTogQ3JlYXRlIHRoZSBt ZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBoYW5kbGUgZm9yIHRoZSB3ZWIgcHJvY2VzcyBpZgorICAg ICAgICBuZWVkZWQuCisgICAgICAgICogVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9u aXRvci5jcHA6IEFkZGVkLgorICAgICAgICAoV2ViS2l0Ojpsb3dXYXRlcm1hcmtQYWdlcyk6Cisg ICAgICAgIChXZWJLaXQ6OnN5c3RlbVBhZ2VTaXplKToKKyAgICAgICAgKFdlYktpdDo6Y2FsY3Vs YXRlTWVtb3J5QXZhaWxhYmxlKToKKyAgICAgICAgKFdlYktpdDo6c3lzdGVtTWVtb3J5VXNlZEFz UGVyY2VudGFnZSk6CisgICAgICAgIChXZWJLaXQ6OnBvbGxJbnRlcnZhbEZvclVzZWRNZW1vcnlQ ZXJjZW50YWdlKToKKyAgICAgICAgKFdlYktpdDo6aXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25p dG9yQXZhaWxhYmxlKToKKyAgICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjpp c0VuYWJsZWQpOgorICAgICAgICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmds ZXRvbik6CisgICAgICAgIChXZWJLaXQ6Ok1lbW9yeVByZXNzdXJlTW9uaXRvcjo6TWVtb3J5UHJl c3N1cmVNb25pdG9yKToKKyAgICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjpj cmVhdGVIYW5kbGUpOgorICAgICAgICAqIFVJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1v bml0b3IuaDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJQcm9jZXNzOjppbml0aWFsaXplV2ViUHJvY2Vzcyk6IFBhc3MgdGhlIG1lbW9y eSBwcmVzc3VyZSBtb25pdG9yIGZpbGUgZGVzY3JpcHRvciB0byB0aGUgTWVtb3J5UHJlc3N1cmVI YW5kbGVyLgorCiAyMDE2LTA3LTEzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdh bGlhLmNvbT4KIAogICAgICAgICBbQ29vcmRpbmF0ZWQgR3JhcGhpY3NdIFJlbW92ZSB0b0Nvb3Jk aW5hdGVkR3JhcGhpY3NMYXllciBhbmQgdXNlIGRvd25jYXN0IGluc3RlYWQKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcCBiL1NvdXJj ZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcAppbmRleCA4OTUzOTNj Li5hMmFkMGQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzcy5jcHAKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29y a1Byb2Nlc3MuY3BwCkBAIC0xOTMsNyArMTkzLDcgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzczo6bG93 TWVtb3J5SGFuZGxlcihDcml0aWNhbCBjcml0aWNhbCkKICAgICBXVEY6OnJlbGVhc2VGYXN0TWFs bG9jRnJlZU1lbW9yeSgpOwogfQogCi12b2lkIE5ldHdvcmtQcm9jZXNzOjppbml0aWFsaXplTmV0 d29ya1Byb2Nlc3MoY29uc3QgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmIHBhcmFt ZXRlcnMpCit2b2lkIE5ldHdvcmtQcm9jZXNzOjppbml0aWFsaXplTmV0d29ya1Byb2Nlc3MoTmV0 d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJiBwYXJhbWV0ZXJzKQogewogICAgIHBsYXRm b3JtSW5pdGlhbGl6ZU5ldHdvcmtQcm9jZXNzKHBhcmFtZXRlcnMpOwogCkBAIC0yMDIsNiArMjAy LDEwIEBAIHZvaWQgTmV0d29ya1Byb2Nlc3M6OmluaXRpYWxpemVOZXR3b3JrUHJvY2Vzcyhjb25z dCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1lCiAgICAgbV9zdXBwcmVzc01lbW9yeVByZXNz dXJlSGFuZGxlciA9IHBhcmFtZXRlcnMuc2hvdWxkU3VwcHJlc3NNZW1vcnlQcmVzc3VyZUhhbmRs ZXI7CiAgICAgaWYgKCFtX3N1cHByZXNzTWVtb3J5UHJlc3N1cmVIYW5kbGVyKSB7CiAgICAgICAg IGF1dG8mIG1lbW9yeVByZXNzdXJlSGFuZGxlciA9IE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6c2lu Z2xldG9uKCk7CisjaWYgT1MoTElOVVgpCisgICAgICAgIGlmIChwYXJhbWV0ZXJzLm1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZS5maWxlRGVzY3JpcHRvcigpICE9IC0xKQorICAgICAgICAgICAg bWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldE1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZShwYXJh bWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZS5yZWxlYXNlRmlsZURlc2NyaXB0b3Io KSk7CisjZW5kaWYKICAgICAgICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldExvd01lbW9yeUhh bmRsZXIoW3RoaXNdIChDcml0aWNhbCBjcml0aWNhbCwgU3luY2hyb25vdXMpIHsKICAgICAgICAg ICAgIGxvd01lbW9yeUhhbmRsZXIoY3JpdGljYWwpOwogICAgICAgICB9KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzLmggYi9Tb3VyY2Uv V2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCmluZGV4IGM4OTc5OTguLmI3 MzI1MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQ cm9jZXNzLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nl c3MuaApAQCAtMTU5LDcgKzE1OSw3IEBAIHByaXZhdGU6CiAgICAgLy8gTWVzc2FnZSBIYW5kbGVy cwogICAgIHZvaWQgZGlkUmVjZWl2ZU5ldHdvcmtQcm9jZXNzTWVzc2FnZShJUEM6OkNvbm5lY3Rp b24mLCBJUEM6Ok1lc3NhZ2VEZWNvZGVyJik7CiAgICAgdm9pZCBkaWRSZWNlaXZlU3luY05ldHdv cmtQcm9jZXNzTWVzc2FnZShJUEM6OkNvbm5lY3Rpb24mLCBJUEM6Ok1lc3NhZ2VEZWNvZGVyJiwg c3RkOjp1bmlxdWVfcHRyPElQQzo6TWVzc2FnZUVuY29kZXI+Jik7Ci0gICAgdm9pZCBpbml0aWFs aXplTmV0d29ya1Byb2Nlc3MoY29uc3QgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMm KTsKKyAgICB2b2lkIGluaXRpYWxpemVOZXR3b3JrUHJvY2VzcyhOZXR3b3JrUHJvY2Vzc0NyZWF0 aW9uUGFyYW1ldGVycyYmKTsKICAgICB2b2lkIGNyZWF0ZU5ldHdvcmtDb25uZWN0aW9uVG9XZWJQ cm9jZXNzKCk7CiAgICAgdm9pZCBkZXN0cm95UHJpdmF0ZUJyb3dzaW5nU2Vzc2lvbihXZWJDb3Jl OjpTZXNzaW9uSUQpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vz cy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9O ZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5kZXgg YjQ4ZmQwMC4uYmMzNTQwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nl c3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcApA QCAtODIsNiArODIsOSBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpl bmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNvbgogICAgIGVuY29kZXIgPDwg aWdub3JlVExTRXJyb3JzOwogICAgIGVuY29kZXIgPDwgbGFuZ3VhZ2VzOwogI2VuZGlmCisjaWYg T1MoTElOVVgpCisgICAgZW5jb2RlciA8PCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7Cisj ZW5kaWYKIH0KIAogYm9vbCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2Rl KElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycyYgcmVzdWx0KQpAQCAtMTU4LDYgKzE2MSwxMSBAQCBib29sIE5ldHdvcmtQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzOjpkZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIs IE5ldAogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5kaWYKIAorI2lmIE9TKExJTlVYKQorICAg IGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0Lm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZSkp CisgICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorCiAgICAgcmV0dXJuIHRydWU7CiB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCmluZGV4IDRhNThlNGEuLjU2ODgxOTQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0 d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAtMjYsNiArMjYsNyBAQAogI2lmbmRl ZiBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyc19oCiAjZGVmaW5lIE5ldHdvcmtQcm9j ZXNzQ3JlYXRpb25QYXJhbWV0ZXJzX2gKIAorI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIKICNpbmNs dWRlICJDYWNoZU1vZGVsLmgiCiAjaW5jbHVkZSAiU2FuZGJveEV4dGVuc2lvbi5oIgogI2luY2x1 ZGUgPHd0Zi9WZWN0b3IuaD4KQEAgLTk1LDYgKzk2LDEwIEBAIHN0cnVjdCBOZXR3b3JrUHJvY2Vz c0NyZWF0aW9uUGFyYW1ldGVycyB7CiAgICAgYm9vbCBpZ25vcmVUTFNFcnJvcnM7CiAgICAgVmVj dG9yPFN0cmluZz4gbGFuZ3VhZ2VzOwogI2VuZGlmCisKKyNpZiBPUyhMSU5VWCkKKyAgICBJUEM6 OkF0dGFjaG1lbnQgbWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9OwogCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3Jt RWZsLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UKaW5kZXggMTA4NTZj OC4uMjAyMGZiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UK KysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1FZmwuY21ha2UKQEAgLTE3MSw2ICsxNzEsOCBA QCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKICAgICBVSVByb2Nlc3MvZ3N0cmVhbWVyL0lu c3RhbGxNaXNzaW5nTWVkaWFQbHVnaW5zUGVybWlzc2lvblJlcXVlc3QuY3BwCiAgICAgVUlQcm9j ZXNzL2dzdHJlYW1lci9XZWJQYWdlUHJveHlHU3RyZWFtZXIuY3BwCiAKKyAgICBVSVByb2Nlc3Mv bGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNwcAorCiAgICAgVUlQcm9jZXNzL3NvdXAvV2Vi Q29va2llTWFuYWdlclByb3h5U291cC5jcHAKICAgICBVSVByb2Nlc3Mvc291cC9XZWJQcm9jZXNz UG9vbFNvdXAuY3BwCiAKQEAgLTI1Niw2ICsyNTgsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX0lO Q0xVREVfRElSRUNUT1JJRVMKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL0Nvb3JkaW5h dGVkR3JhcGhpY3MiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9OZXR3b3JrL0N1c3Rv bVByb3RvY29scy9zb3VwIgogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvZWZsIgorICAg ICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvbGludXgiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJ UHJvY2Vzcy9zb3VwIgogICAgICIke1dFQktJVDJfRElSfS9XZWJQcm9jZXNzL2VmbCIKICAgICAi JHtXRUJLSVQyX0RJUn0vV2ViUHJvY2Vzcy9zb3VwIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQpp bmRleCBiM2MyYWRiLi5mZDIxNjgwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9y bUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMjcz LDYgKzI3Myw4IEBAIGxpc3QoQVBQRU5EIFdlYktpdDJfU09VUkNFUwogCiAgICAgVUlQcm9jZXNz L0xhdW5jaGVyL2d0ay9Qcm9jZXNzTGF1bmNoZXJHdGsuY3BwCiAKKyAgICBVSVByb2Nlc3MvbGlu dXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNwcAorCiAgICAgVUlQcm9jZXNzL05ldHdvcmsvQ3Vz dG9tUHJvdG9jb2xzL3NvdXAvQ3VzdG9tUHJvdG9jb2xNYW5hZ2VyUHJveHlTb3VwLmNwcAogICAg IFVJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9zb3VwL1dlYlNvdXBDdXN0b21Qcm90 b2NvbFJlcXVlc3RNYW5hZ2VyLmNwcAogICAgIFVJUHJvY2Vzcy9OZXR3b3JrL0N1c3RvbVByb3Rv Y29scy9zb3VwL1dlYlNvdXBDdXN0b21Qcm90b2NvbFJlcXVlc3RNYW5hZ2VyQ2xpZW50LmNwcApA QCAtNTEzLDYgKzUxNSw3IEBAIGxpc3QoQVBQRU5EIFdlYktpdDJfSU5DTFVERV9ESVJFQ1RPUklF UwogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvUGx1Z2lucy9ndGsiCiAgICAgIiR7V0VC S0lUMl9ESVJ9L1VJUHJvY2Vzcy9nc3RyZWFtZXIiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9ndGsiCisgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9saW51eCIKICAgICAiJHtX RUJLSVQyX0RJUn0vVUlQcm9jZXNzL3NvdXAiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1dlYlByb2Nl c3MvSW5qZWN0ZWRCdW5kbGUvQVBJL2d0ayIKICAgICAiJHtXRUJLSVQyX0RJUn0vV2ViUHJvY2Vz cy9QbHVnaW5zL05ldHNjYXBlL3VuaXgiCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9QbHVn aW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwIGIvU291cmNlL1dlYktpdDIvUGx1Z2luUHJvY2Vz cy9QbHVnaW5Qcm9jZXNzLmNwcAppbmRleCA3NTU1NzAyLi42MWU2NmYwIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0Mi9QbHVnaW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQyL1BsdWdpblByb2Nlc3MvUGx1Z2luUHJvY2Vzcy5jcHAKQEAgLTcxLDEzICs3MSw2 IEBAIHZvaWQgUGx1Z2luUHJvY2Vzczo6aW5pdGlhbGl6ZVByb2Nlc3MoY29uc3QgQ2hpbGRQcm9j ZXNzSW5pdGlhbGl6YXRpb25QYXJhbWV0ZXJzCiB7CiAgICAgbV9wbHVnaW5QYXRoID0gcGFyYW1l dGVycy5leHRyYUluaXRpYWxpemF0aW9uRGF0YS5nZXQoInBsdWdpbi1wYXRoIik7CiAgICAgcGxh dGZvcm1Jbml0aWFsaXplUHJvY2VzcyhwYXJhbWV0ZXJzKTsKLQotICAgIGF1dG8mIG1lbW9yeVBy ZXNzdXJlSGFuZGxlciA9IE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6c2luZ2xldG9uKCk7Ci0gICAg bWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldExvd01lbW9yeUhhbmRsZXIoW3RoaXNdIChDcml0aWNh bCwgU3luY2hyb25vdXMpIHsKLSAgICAgICAgaWYgKHNob3VsZFRlcm1pbmF0ZSgpKQotICAgICAg ICAgICAgdGVybWluYXRlKCk7Ci0gICAgfSk7Ci0gICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLmlu c3RhbGwoKTsKIH0KIAogdm9pZCBQbHVnaW5Qcm9jZXNzOjpyZW1vdmVXZWJQcm9jZXNzQ29ubmVj dGlvbihXZWJQcm9jZXNzQ29ubmVjdGlvbiogd2ViUHJvY2Vzc0Nvbm5lY3Rpb24pCkBAIC0xMzcs NiArMTMwLDE3IEBAIHZvaWQgUGx1Z2luUHJvY2Vzczo6aW5pdGlhbGl6ZVBsdWdpblByb2Nlc3Mo UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYmIHBhCiB7CiAgICAgQVNTRVJUKCFtX3Bs dWdpbk1vZHVsZSk7CiAKKyAgICBhdXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQ cmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRvbigpOworI2lmIE9TKExJTlVYKQorICAgIGlmIChwYXJh bWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZS5maWxlRGVzY3JpcHRvcigpICE9IC0x KQorICAgICAgICBtZW1vcnlQcmVzc3VyZUhhbmRsZXIuc2V0TWVtb3J5UHJlc3N1cmVNb25pdG9y SGFuZGxlKHBhcmFtZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlLnJlbGVhc2VGaWxl RGVzY3JpcHRvcigpKTsKKyNlbmRpZgorICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRMb3dN ZW1vcnlIYW5kbGVyKFt0aGlzXSAoQ3JpdGljYWwsIFN5bmNocm9ub3VzKSB7CisgICAgICAgIGlm IChzaG91bGRUZXJtaW5hdGUoKSkKKyAgICAgICAgICAgIHRlcm1pbmF0ZSgpOworICAgIH0pOwor ICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5pbnN0YWxsKCk7CisKICAgICBtX3N1cHBvcnRzQXN5 bmNocm9ub3VzUGx1Z2luSW5pdGlhbGl6YXRpb24gPSBwYXJhbWV0ZXJzLnN1cHBvcnRzQXN5bmNo cm9ub3VzUGx1Z2luSW5pdGlhbGl6YXRpb247CiAgICAgc2V0TWluaW11bUxpZmV0aW1lKHBhcmFt ZXRlcnMubWluaW11bUxpZmV0aW1lKTsKICAgICBzZXRUZXJtaW5hdGlvblRpbWVvdXQocGFyYW1l dGVycy50ZXJtaW5hdGlvblRpbWVvdXQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hh cmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAgYi9Tb3VyY2Uv V2ViS2l0Mi9TaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNw cAppbmRleCBlM2UxZmZkLi4zMDE1NGM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFy ZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAorKysgYi9Tb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmNwcApAQCAtNTEsNiArNTEsOSBAQCB2b2lkIFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnM6OmVuY29kZShJUEM6OkFyZ3VtZW50RW5jb2RlciYgZW5jb2RlcikgY29ucwogICAgIElQQzo6 ZW5jb2RlKGVuY29kZXIsIG5ldHdvcmtBVFNDb250ZXh0LmdldCgpKTsKICNlbmRpZgogI2VuZGlm CisjaWYgT1MoTElOVVgpCisgICAgZW5jb2RlciA8PCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5k bGU7CisjZW5kaWYKIH0KIAogYm9vbCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzOjpk ZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFBsdWdpblByb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMmIHJlc3VsdCkKQEAgLTcxLDYgKzc0LDEwIEBAIGJvb2wgUGx1Z2luUHJvY2Vz c0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVy LCBQbHVnCiAgICAgICAgIHJldHVybiBmYWxzZTsKICNlbmRpZgogI2VuZGlmCisjaWYgT1MoTElO VVgpCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShyZXN1bHQubWVtb3J5UHJlc3N1cmVNb25pdG9y SGFuZGxlKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCiAKICAgICByZXR1cm4gdHJ1 ZTsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5zL1BsdWdpblBy b2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaCBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5z L1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCBhYzdkNjM4Li5kNjE3MTM5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmgKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMv UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCkBAIC0yOCw2ICsyOCw3IEBACiAKICNp ZiBFTkFCTEUoTkVUU0NBUEVfUExVR0lOX0FQSSkKIAorI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIK ICNpbmNsdWRlICJQbHVnaW5Qcm9jZXNzQXR0cmlidXRlcy5oIgogCiAjaWYgUExBVEZPUk0oQ09D T0EpCkBAIC01OSw2ICs2MCw5IEBAIHN0cnVjdCBQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzIHsKICAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBuZXR3b3JrQVRTQ29udGV4dDsKICNlbmRp ZgogI2VuZGlmCisjaWYgT1MoTElOVVgpCisgICAgSVBDOjpBdHRhY2htZW50IG1lbW9yeVByZXNz dXJlTW9uaXRvckhhbmRsZTsKKyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1l dGVycy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1l dGVycy5jcHAKaW5kZXggYTUzMWU0NS4uMWEyYjBkNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dDIvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcApAQCAtMTQxLDYg KzE0MSwxMCBAQCB2b2lkIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVuY29kZShJUEM6 OkFyZ3VtZW50RW5jb2RlciYgZW5jb2RlcikgY29uc3QKICNpZiBUQVJHRVRfT1NfSVBIT05FIHx8 IChQTEFURk9STShNQUMpICYmIF9fTUFDX09TX1hfVkVSU0lPTl9NSU5fUkVRVUlSRUQgPj0gMTAx MTAwKQogICAgIElQQzo6ZW5jb2RlKGVuY29kZXIsIG5ldHdvcmtBVFNDb250ZXh0LmdldCgpKTsK ICNlbmRpZgorCisjaWYgT1MoTElOVVgpCisgICAgZW5jb2RlciA8PCBtZW1vcnlQcmVzc3VyZU1v bml0b3JIYW5kbGU7CisjZW5kaWYKIH0KIAogYm9vbCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0 ZXJzOjpkZWNvZGUoSVBDOjpBcmd1bWVudERlY29kZXImIGRlY29kZXIsIFdlYlByb2Nlc3NDcmVh dGlvblBhcmFtZXRlcnMmIHBhcmFtZXRlcnMpCkBAIC0yOTYsNiArMzAwLDExIEBAIGJvb2wgV2Vi UHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBk ZWNvZGVyLCBXZWJQcm9jCiAgICAgICAgIHJldHVybiBmYWxzZTsKICNlbmRpZgogCisjaWYgT1Mo TElOVVgpCisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJl TW9uaXRvckhhbmRsZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorCiAgICAgcmV0 dXJuIHRydWU7CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9j ZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vz c0NyZWF0aW9uUGFyYW1ldGVycy5oCmluZGV4IGFkZDg0ZjMuLmM5YWEyYzkgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKKysr IGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApA QCAtMTY2LDYgKzE2NiwxMCBAQCBzdHJ1Y3QgV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyB7 CiAjaWYgVEFSR0VUX09TX0lQSE9ORSB8fCAoUExBVEZPUk0oTUFDKSAmJiBfX01BQ19PU19YX1ZF UlNJT05fTUlOX1JFUVVJUkVEID49IDEwMTEwMCkKICAgICBSZXRhaW5QdHI8Q0ZEYXRhUmVmPiBu ZXR3b3JrQVRTQ29udGV4dDsKICNlbmRpZgorCisjaWYgT1MoTElOVVgpCisgICAgSVBDOjpBdHRh Y2htZW50IG1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZTsKKyNlbmRpZgogfTsKIAogfSAvLyBu YW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1 Z2lucy9QbHVnaW5Qcm9jZXNzUHJveHkuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1Bs dWdpbnMvUGx1Z2luUHJvY2Vzc1Byb3h5LmNwcAppbmRleCA4ZjUwNWE2Li5lNzA5MTI0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzUHJv eHkuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblByb2Nl c3NQcm94eS5jcHAKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2lmIEVOQUJMRShORVRTQ0FQRV9QTFVH SU5fQVBJKQogCisjaW5jbHVkZSAiTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgiCiAjaW5jbHVkZSAi UGx1Z2luUHJvY2Vzc0Nvbm5lY3Rpb25NYW5hZ2VyTWVzc2FnZXMuaCIKICNpbmNsdWRlICJQbHVn aW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiUGx1Z2luUHJvY2Vzc01h bmFnZXIuaCIKQEAgLTIyOSw2ICsyMzAsMTIgQEAgdm9pZCBQbHVnaW5Qcm9jZXNzUHJveHk6OmRp ZEZpbmlzaExhdW5jaGluZyhQcm9jZXNzTGF1bmNoZXIqLCBJUEM6OkNvbm5lY3Rpb246OkkKICAg ICAgICAgcGFyYW1ldGVycy5taW5pbXVtTGlmZXRpbWUgPSBtaW5pbXVtTGlmZXRpbWU7CiAgICAg ICAgIHBhcmFtZXRlcnMudGVybWluYXRpb25UaW1lb3V0ID0gc2h1dGRvd25UaW1lb3V0OwogICAg IH0KKworI2lmIE9TKExJTlVYKQorICAgIGlmIChNZW1vcnlQcmVzc3VyZU1vbml0b3I6OmlzRW5h YmxlZCgpKQorICAgICAgICBwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZSA9 IE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xldG9uKCkuY3JlYXRlSGFuZGxlKCk7CisjZW5k aWYKKwogICAgIHBsYXRmb3JtSW5pdGlhbGl6ZVBsdWdpblByb2Nlc3MocGFyYW1ldGVycyk7CiAK ICAgICAvLyBJbml0aWFsaXplIHRoZSBwbHVnLWluIGhvc3QgcHJvY2Vzcy4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHAgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwCmluZGV4IDJmOWJmMDkuLjkzOGQ3ZTIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHAK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcApAQCAtMzYs NiArMzYsNyBAQAogI2luY2x1ZGUgIkRvd25sb2FkUHJveHkuaCIKICNpbmNsdWRlICJEb3dubG9h ZFByb3h5TWVzc2FnZXMuaCIKICNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAiTWVtb3J5 UHJlc3N1cmVNb25pdG9yLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnMuaCIKICNpbmNsdWRlICJOZXR3b3JrUHJvY2Vzc01lc3NhZ2VzLmgiCiAjaW5jbHVkZSAi TmV0d29ya1Byb2Nlc3NQcm94eS5oIgpAQCAtMzcwLDYgKzM3MSwxMSBAQCBOZXR3b3JrUHJvY2Vz c1Byb3h5JiBXZWJQcm9jZXNzUG9vbDo6ZW5zdXJlTmV0d29ya1Byb2Nlc3MoKQogICAgICAgICBT YW5kYm94RXh0ZW5zaW9uOjpjcmVhdGVIYW5kbGUocGFyZW50QnVuZGxlRGlyZWN0b3J5LCBTYW5k Ym94RXh0ZW5zaW9uOjpSZWFkT25seSwgcGFyYW1ldGVycy5wYXJlbnRCdW5kbGVEaXJlY3RvcnlF eHRlbnNpb25IYW5kbGUpOwogI2VuZGlmCiAKKyNpZiBPUyhMSU5VWCkKKyAgICBpZiAoTWVtb3J5 UHJlc3N1cmVNb25pdG9yOjppc0VuYWJsZWQoKSkKKyAgICAgICAgcGFyYW1ldGVycy5tZW1vcnlQ cmVzc3VyZU1vbml0b3JIYW5kbGUgPSBNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbigp LmNyZWF0ZUhhbmRsZSgpOworI2VuZGlmCisKICAgICBwYXJhbWV0ZXJzLnNob3VsZFVzZVRlc3Rp bmdOZXR3b3JrU2Vzc2lvbiA9IG1fc2hvdWxkVXNlVGVzdGluZ05ldHdvcmtTZXNzaW9uOwogCiAg ICAgLy8gQWRkIGFueSBwbGF0Zm9ybSBzcGVjaWZpYyBwYXJhbWV0ZXJzCkBAIC02MjYsNiArNjMy LDggQEAgV2ViUHJvY2Vzc1Byb3h5JiBXZWJQcm9jZXNzUG9vbDo6Y3JlYXRlTmV3V2ViUHJvY2Vz cygpCiAKICNpZiBPUyhMSU5VWCkKICAgICBwYXJhbWV0ZXJzLnNob3VsZEVuYWJsZU1lbW9yeVBy ZXNzdXJlUmVsaWVmTG9nZ2luZyA9IHRydWU7CisgICAgaWYgKE1lbW9yeVByZXNzdXJlTW9uaXRv cjo6aXNFbmFibGVkKCkpCisgICAgICAgIHBhcmFtZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9y SGFuZGxlID0gTWVtb3J5UHJlc3N1cmVNb25pdG9yOjpzaW5nbGV0b24oKS5jcmVhdGVIYW5kbGUo KTsKICNlbmRpZgogCiAgICAgcGFyYW1ldGVycy5yZXNvdXJjZUxvYWRTdGF0aXN0aWNzRW5hYmxl ZCA9IHJlc291cmNlTG9hZFN0YXRpc3RpY3NFbmFibGVkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNwcCBiL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjllOTgxY2YKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmNw cApAQCAtMCwwICsxLDI5MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBJZ2FsaWEgUy5M LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVk aXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0 IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBk b2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlz dHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5D LiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhF IElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRgorICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkKKyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiTWVtb3J5UHJlc3N1 cmVNb25pdG9yLmgiCisKKyNpZiBPUyhMSU5VWCkKKworI2luY2x1ZGUgIkF0dGFjaG1lbnQuaCIK KyNpbmNsdWRlIDxmY250bC5oPgorI2luY2x1ZGUgPG11dGV4PgorI2luY2x1ZGUgPHN0ZGxpYi5o PgorI2luY2x1ZGUgPHN0cmluZy5oPgorI2luY2x1ZGUgPHN5cy9ldmVudGZkLmg+CisjaW5jbHVk ZSA8c3lzL3N0YXQuaD4KKyNpbmNsdWRlIDxzeXMvdHlwZXMuaD4KKyNpbmNsdWRlIDx1bmlzdGQu aD4KKyNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5n Lmg+CisjaW5jbHVkZSA8d3RmL1VuaVN0ZEV4dHJhcy5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsK Kworc3RhdGljIGNvbnN0IGRvdWJsZSBzX21pblBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcyA9IDE7 CitzdGF0aWMgY29uc3QgZG91YmxlIHNfbWF4UG9sbGluZ0ludGVydmFsSW5TZWNvbmRzID0gNTsK K3N0YXRpYyBjb25zdCBkb3VibGUgc19taW5Vc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcg PSA1MDsKK3N0YXRpYyBjb25zdCBkb3VibGUgc19tYXhVc2VkTWVtb3J5UGVyY2VudGFnZUZvclBv bGxpbmcgPSA5MDsKK3N0YXRpYyBjb25zdCBpbnQgc19tZW1vcnlQcmVzdXJlUGVyY2VudGFnZVRo cmVzaG9sZCA9IDk1OworCitzdGF0aWMgc2l6ZV90IGxvd1dhdGVybWFya1BhZ2VzKCkKK3sKKyAg ICBGSUxFKiBmaWxlID0gZm9wZW4oIi9wcm9jL3pvbmVpbmZvIiwgInIiKTsKKyAgICBpZiAoIWZp bGUpCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsKKworICAgIHNpemVf dCBsb3cgPSAwOworICAgIGJvb2wgaW5ab25lID0gZmFsc2U7CisgICAgYm9vbCBmb3VuZExvdyA9 IGZhbHNlOworICAgIGNoYXIgYnVmZmVyWzEyOF07CisgICAgd2hpbGUgKGNoYXIqIGxpbmUgPSBm Z2V0cyhidWZmZXIsIDEyOCwgZmlsZSkpIHsKKyAgICAgICAgaWYgKCFzdHJjbXAobGluZSwgIk5v ZGUiKSkgeworICAgICAgICAgICAgaW5ab25lID0gdHJ1ZTsKKyAgICAgICAgICAgIGZvdW5kTG93 ID0gZmFsc2U7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGNo YXIqIHRva2VuID0gc3RydG9rKGxpbmUsICIgIik7CisgICAgICAgIGlmICghdG9rZW4pCisgICAg ICAgICAgICBjb250aW51ZTsKKworICAgICAgICBpZiAoIXN0cmNtcCh0b2tlbiwgImxvdyIpKSB7 CisgICAgICAgICAgICBpZiAoIWluWm9uZSB8fCBmb3VuZExvdykgeworICAgICAgICAgICAgICAg IGxvdyA9IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpOworICAgICAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICAgICAgfQorICAgICAgICAgICAgdG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKTsK KyAgICAgICAgICAgIGlmICghdG9rZW4pIHsKKyAgICAgICAgICAgICAgICBsb3cgPSBzdGF0aWNf Y2FzdDxzaXplX3Q+KC0xKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0K KyAgICAgICAgICAgIGxvdyArPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICBmb3VuZExvdyA9 IHRydWU7CisgICAgICAgIH0KKyAgICB9CisgICAgZmNsb3NlKGZpbGUpOworCisgICAgcmV0dXJu IGxvdzsKK30KKworc3RhdGljIGlubGluZSBzaXplX3Qgc3lzdGVtUGFnZVNpemUoKQoreworICAg IHN0YXRpYyBzaXplX3QgcGFnZVNpemUgPSAwOworICAgIGlmICghcGFnZVNpemUpCisgICAgICAg IHBhZ2VTaXplID0gc3lzY29uZihfU0NfUEFHRV9TSVpFKTsKKyAgICByZXR1cm4gcGFnZVNpemU7 Cit9CisKK3N0YXRpYyBzaXplX3QgY2FsY3VsYXRlTWVtb3J5QXZhaWxhYmxlKHNpemVfdCBtZW1v cnlGcmVlLCBzaXplX3QgYWN0aXZlRmlsZSwgc2l6ZV90IGluYWN0aXZlRmlsZSwgc2l6ZV90IHNs YWJSZWNsYWltYWJsZSkKK3sKKyAgICBpZiAobWVtb3J5RnJlZSA9PSBzdGF0aWNfY2FzdDxzaXpl X3Q+KC0xKQorICAgICAgICB8fCBhY3RpdmVGaWxlID09IHN0YXRpY19jYXN0PHNpemVfdD4oLTEp CisgICAgICAgIHx8IGluYWN0aXZlRmlsZSA9PSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAg ICAgICB8fCBzbGFiUmVjbGFpbWFibGUgPT0gc3RhdGljX2Nhc3Q8c2l6ZV90PigtMSkpCisgICAg ICAgIHJldHVybiBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKTsKKworICAgIHNpemVfdCBsb3dXYXRl cm1hcmsgPSBsb3dXYXRlcm1hcmtQYWdlcygpOworICAgIGlmIChsb3dXYXRlcm1hcmsgPT0gc3Rh dGljX2Nhc3Q8c2l6ZV90PigtMSkpCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxzaXplX3Q+ KC0xKTsKKworICAgIGxvd1dhdGVybWFyayAqPSBzeXN0ZW1QYWdlU2l6ZSgpIC8gS0I7CisKKyAg ICAvLyBFc3RpbWF0ZSB0aGUgYW1vdW50IG9mIG1lbW9yeSBhdmFpbGFibGUgZm9yIHVzZXJzcGFj ZSBhbGxvY2F0aW9ucywgd2l0aG91dCBjYXVzaW5nIHN3YXBwaW5nLgorICAgIC8vIEZyZWUgbWVt b3J5IGNhbm5vdCBiZSB0YWtlbiBiZWxvdyB0aGUgbG93IHdhdGVybWFyaywgYmVmb3JlIHRoZSBz eXN0ZW0gc3RhcnRzIHN3YXBwaW5nLgorICAgIGxvd1dhdGVybWFyayAqPSBzeXN0ZW1QYWdlU2l6 ZSgpIC8gS0I7CisgICAgc2l6ZV90IG1lbW9yeUF2YWlsYWJsZSA9IG1lbW9yeUZyZWUgLSBsb3dX YXRlcm1hcms7CisKKyAgICAvLyBOb3QgYWxsIHRoZSBwYWdlIGNhY2hlIGNhbiBiZSBmcmVlZCwg b3RoZXJ3aXNlIHRoZSBzeXN0ZW0gd2lsbCBzdGFydCBzd2FwcGluZy4gQXNzdW1lIGF0IGxlYXN0 CisgICAgLy8gaGFsZiBvZiB0aGUgcGFnZSBjYWNoZSwgb3IgdGhlIGxvdyB3YXRlcm1hcmsgd29y dGggb2YgY2FjaGUsIG5lZWRzIHRvIHN0YXkuCisgICAgc2l6ZV90IHBhZ2VDYWNoZSA9IGFjdGl2 ZUZpbGUgKyBpbmFjdGl2ZUZpbGU7CisgICAgcGFnZUNhY2hlIC09IHN0ZDo6bWluKHBhZ2VDYWNo ZSAvIDIsIGxvd1dhdGVybWFyayk7CisgICAgbWVtb3J5QXZhaWxhYmxlICs9IHBhZ2VDYWNoZTsK KworICAgIC8vIFBhcnQgb2YgdGhlIHJlY2xhaW1hYmxlIHNsYWIgY29uc2lzdHMgb2YgaXRlbXMg dGhhdCBhcmUgaW4gdXNlLCBhbmQgY2Fubm90IGJlIGZyZWVkLgorICAgIC8vIENhcCB0aGlzIGVz dGltYXRlIGF0IHRoZSBsb3cgd2F0ZXJtYXJrLgorICAgIG1lbW9yeUF2YWlsYWJsZSArPSBzbGFi UmVjbGFpbWFibGUgLSBzdGQ6Om1pbihzbGFiUmVjbGFpbWFibGUgLyAyLCBsb3dXYXRlcm1hcmsp OworICAgIHJldHVybiBtZW1vcnlBdmFpbGFibGU7Cit9CisKK3N0YXRpYyBpbnQgc3lzdGVtTWVt b3J5VXNlZEFzUGVyY2VudGFnZSgpCit7CisgICAgRklMRSogZmlsZSA9IGZvcGVuKCIvcHJvYy9t ZW1pbmZvIiwgInIiKTsKKyAgICBpZiAoIWZpbGUpCisgICAgICAgIHJldHVybiAtMTsKKworICAg IHNpemVfdCBtZW1vcnlBdmFpbGFibGUsIG1lbW9yeVRvdGFsLCBtZW1vcnlGcmVlLCBhY3RpdmVG aWxlLCBpbmFjdGl2ZUZpbGUsIHNsYWJSZWNsYWltYWJsZTsKKyAgICBtZW1vcnlBdmFpbGFibGUg PSBtZW1vcnlUb3RhbCA9IG1lbW9yeUZyZWUgPSBhY3RpdmVGaWxlID0gaW5hY3RpdmVGaWxlID0g c2xhYlJlY2xhaW1hYmxlID0gc3RhdGljX2Nhc3Q8c2l6ZV90PigtMSk7CisgICAgY2hhciBidWZm ZXJbMTI4XTsKKyAgICB3aGlsZSAoY2hhciogbGluZSA9IGZnZXRzKGJ1ZmZlciwgMTI4LCBmaWxl KSkgeworICAgICAgICBjaGFyKiB0b2tlbiA9IHN0cnRvayhsaW5lLCAiICIpOworICAgICAgICBp ZiAoIXRva2VuKQorICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgaWYgKCFzdHJjbXAodG9r ZW4sICJNZW1BdmFpbGFibGU6IikpIHsKKyAgICAgICAgICAgIGlmICgodG9rZW4gPSBzdHJ0b2so bnVsbHB0ciwgIiAiKSkpIHsKKyAgICAgICAgICAgICAgICBtZW1vcnlBdmFpbGFibGUgPSBhdG9s bCh0b2tlbik7CisgICAgICAgICAgICAgICAgaWYgKG1lbW9yeVRvdGFsICE9IHN0YXRpY19jYXN0 PHNpemVfdD4oLTEpKQorICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0K KyAgICAgICAgfSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAiTWVtVG90YWw6IikpIHsKKyAgICAg ICAgICAgIGlmICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpCisgICAgICAgICAgICAg ICAgbWVtb3J5VG90YWwgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIk1lbUZy ZWU6IikpIHsKKyAgICAgICAgICAgIGlmICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkp CisgICAgICAgICAgICAgICAgbWVtb3J5RnJlZSA9IGF0b2xsKHRva2VuKTsKKyAgICAgICAgICAg IGVsc2UKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfSBlbHNlIGlmICghc3RyY21w KHRva2VuLCAiQWN0aXZlKGZpbGUpOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3Ry dG9rKG51bGxwdHIsICIgIikpKQorICAgICAgICAgICAgICAgIGFjdGl2ZUZpbGUgPSBhdG9sbCh0 b2tlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAg IH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIkluYWN0aXZlKGZpbGUpOiIpKSB7CisgICAgICAg ICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikpKQorICAgICAgICAgICAgICAg IGluYWN0aXZlRmlsZSA9IGF0b2xsKHRva2VuKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgfSBlbHNlIGlmICghc3RyY21wKHRva2VuLCAiU1JlY2xh aW1hYmxlOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIg IikpKQorICAgICAgICAgICAgICAgIHNsYWJSZWNsYWltYWJsZSA9IGF0b2xsKHRva2VuKTsKKyAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAg ICAgIGlmIChtZW1vcnlUb3RhbCAhPSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAg ICAgJiYgbWVtb3J5RnJlZSAhPSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAgICAg JiYgYWN0aXZlRmlsZSAhPSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKQorICAgICAgICAgICAgJiYg aW5hY3RpdmVGaWxlICE9IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpCisgICAgICAgICAgICAmJiBz bGFiUmVjbGFpbWFibGUgIT0gc3RhdGljX2Nhc3Q8c2l6ZV90PigtMSkpCisgICAgICAgICAgICBi cmVhazsKKyAgICB9CisgICAgZmNsb3NlKGZpbGUpOworCisgICAgaWYgKG1lbW9yeVRvdGFsID09 IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpKQorICAgICAgICByZXR1cm4gLTE7CisKKyAgICBpZiAo bWVtb3J5QXZhaWxhYmxlID09IHN0YXRpY19jYXN0PHNpemVfdD4oLTEpKSB7CisgICAgICAgIC8v IElmIE1lbUF2YWlsYWJsZSB3YXMgbm90IHByZXNlbnQgaW4gL3Byb2MvbWVtaW5mbywgYmVjYXVz ZSBpdCdzIGFuIG9sZCBrZXJuZWwgdmVyc2lvbiwKKyAgICAgICAgLy8gd2UgY2FuIGRvIHRoZSBz YW1lIGNhbGN1bGF0aW9uIHdpdGggdGhlIGluZm9ybWF0aW9uIHdlIGhhdmUgZnJvbSBtZW1pbmZv IGFuZCB0aGUgbG93IHdhdGVybWFrcy4KKyAgICAgICAgLy8gU2VlIGh0dHBzOi8vZ2l0Lmtlcm5l bC5vcmcvY2dpdC9saW51eC9rZXJuZWwvZ2l0L3RvcnZhbGRzL2xpbnV4LmdpdC9jb21taXQvP2lk PTM0ZTQzMWIwYWUzOThmYzU0ZWE2OWZmODVlYzcwMDcyMmM5ZGE3NzMKKyAgICAgICAgbWVtb3J5 QXZhaWxhYmxlID0gY2FsY3VsYXRlTWVtb3J5QXZhaWxhYmxlKG1lbW9yeUZyZWUsIGFjdGl2ZUZp bGUsIGluYWN0aXZlRmlsZSwgc2xhYlJlY2xhaW1hYmxlKTsKKyAgICAgICAgaWYgKG1lbW9yeUF2 YWlsYWJsZSA9PSBzdGF0aWNfY2FzdDxzaXplX3Q+KC0xKSkKKyAgICAgICAgICAgIHJldHVybiAt MTsKKyAgICB9CisKKyAgICByZXR1cm4gKChtZW1vcnlUb3RhbCAtIG1lbW9yeUF2YWlsYWJsZSkg KiAxMDApIC8gbWVtb3J5VG90YWw7Cit9CisKK3N0YXRpYyBpbmxpbmUgZG91YmxlIHBvbGxJbnRl cnZhbEZvclVzZWRNZW1vcnlQZXJjZW50YWdlKGludCB1c2VkUGVyY2VudGFnZSkKK3sKKyAgICAv LyBVc2UgYSBkaWZmZXJlbnQgcG9sbCBpbnRlcnZhbCBkZXBlbmRpbmcgb24gdGhlIGN1cnJlbnRs eSBtZW1vcnkgdXNlZCwKKyAgICAvLyB0byBhdm9pZCBwb2xsaW5nIHRvbyBvZnRlbiB3aGVuIHRo ZSBzeXN0ZW0gaXMgdW5kZXIgbG93IG1lbW9yeSB1c2FnZS4KKyAgICBpZiAodXNlZFBlcmNlbnRh Z2UgPCBzX21pblVzZWRNZW1vcnlQZXJjZW50YWdlRm9yUG9sbGluZykKKyAgICAgICAgcmV0dXJu IHNfbWF4UG9sbGluZ0ludGVydmFsSW5TZWNvbmRzOworCisgICAgaWYgKHVzZWRQZXJjZW50YWdl ID49IHNfbWF4VXNlZE1lbW9yeVBlcmNlbnRhZ2VGb3JQb2xsaW5nKQorICAgICAgICByZXR1cm4g c19taW5Qb2xsaW5nSW50ZXJ2YWxJblNlY29uZHM7CisKKyAgICByZXR1cm4gc19taW5Qb2xsaW5n SW50ZXJ2YWxJblNlY29uZHMgKyAoc19tYXhQb2xsaW5nSW50ZXJ2YWxJblNlY29uZHMgLSBzX21p blBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcykgKgorICAgICAgICAoKHVzZWRQZXJjZW50YWdlIC0g c19taW5Vc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcpIC8gKHNfbWF4VXNlZE1lbW9yeVBl cmNlbnRhZ2VGb3JQb2xsaW5nIC0gc19taW5Vc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcp KTsKK30KKworc3RhdGljIGJvb2wgaXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25pdG9yQXZhaWxh YmxlKCkKK3sKKyAgICBpbnQgZmQgPSBvcGVuKCIvc3lzL2ZzL2Nncm91cC9tZW1vcnkvbWVtb3J5 LnByZXNzdXJlX2xldmVsIiwgT19DTE9FWEVDIHwgT19SRE9OTFkpOworICAgIGlmIChmZCA9PSAt MSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGNsb3NlKGZkKTsKKworICAgIGZkID0gb3Bl bigiL3N5cy9mcy9jZ3JvdXAvbWVtb3J5L2Nncm91cC5ldmVudF9jb250cm9sIiwgT19DTE9FWEVD IHwgT19XUk9OTFkpOworICAgIGlmIChmZCA9PSAtMSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIGNsb3NlKGZkKTsKKworICAgIHJldHVybiB0cnVlOworfQorCitib29sIE1lbW9yeVByZXNz dXJlTW9uaXRvcjo6aXNFbmFibGVkKCkKK3sKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcgb25j ZUZsYWc7CisgICAgc3RhdGljIGJvb2wgZW5hYmxlZDsKKyAgICBzdGQ6OmNhbGxfb25jZShvbmNl RmxhZywgW10geyBlbmFibGVkID0gIWlzU3lzdGVtZE1lbW9yeVByZXNzdXJlTW9uaXRvckF2YWls YWJsZSgpOyB9KTsKKyAgICByZXR1cm4gZW5hYmxlZDsKK30KKworTWVtb3J5UHJlc3N1cmVNb25p dG9yJiBNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbigpCit7CisgICAgQVNTRVJUKGlz RW5hYmxlZCgpKTsKKyAgICBzdGF0aWMgTmV2ZXJEZXN0cm95ZWQ8TWVtb3J5UHJlc3N1cmVNb25p dG9yPiBtZW1vcnlNb25pdG9yOworICAgIHJldHVybiBtZW1vcnlNb25pdG9yOworfQorCitNZW1v cnlQcmVzc3VyZU1vbml0b3I6Ok1lbW9yeVByZXNzdXJlTW9uaXRvcigpCisgICAgOiBtX2V2ZW50 RkQoZXZlbnRmZCgwLCBFRkRfQ0xPRVhFQykpCit7CisgICAgaWYgKG1fZXZlbnRGRCA9PSAtMSkK KyAgICAgICAgcmV0dXJuOworCisgICAgVGhyZWFkSWRlbnRpZmllciB0aHJlYWRJZGVudGlmaWVy ID0gY3JlYXRlVGhyZWFkKCJNZW1vcnlQcmVzc3VyZU1vbml0b3IiLCBbdGhpc10geworICAgICAg ICBkb3VibGUgcG9sbEludGVydmFsID0gc19tYXhQb2xsaW5nSW50ZXJ2YWxJblNlY29uZHM7Cisg ICAgICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgICAgICBzbGVlcChwb2xsSW50ZXJ2YWwpOwor CisgICAgICAgICAgICBpbnQgdXNlZFBlcmNlbnRhZ2UgPSBzeXN0ZW1NZW1vcnlVc2VkQXNQZXJj ZW50YWdlKCk7CisgICAgICAgICAgICBpZiAodXNlZFBlcmNlbnRhZ2UgPj0gc19tZW1vcnlQcmVz dXJlUGVyY2VudGFnZVRocmVzaG9sZCkgeworICAgICAgICAgICAgICAgIHVpbnQ2NF90IGZkRXZl bnQgPSAxOworICAgICAgICAgICAgICAgIHdyaXRlKG1fZXZlbnRGRCwgJmZkRXZlbnQsIHNpemVv Zih1aW50NjRfdCkpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgcG9sbEludGVydmFsID0g cG9sbEludGVydmFsRm9yVXNlZE1lbW9yeVBlcmNlbnRhZ2UodXNlZFBlcmNlbnRhZ2UpOworICAg ICAgICB9CisgICAgICAgIGNsb3NlKG1fZXZlbnRGRCk7CisgICAgfSk7CisgICAgZGV0YWNoVGhy ZWFkKHRocmVhZElkZW50aWZpZXIpOworfQorCitJUEM6OkF0dGFjaG1lbnQgTWVtb3J5UHJlc3N1 cmVNb25pdG9yOjpjcmVhdGVIYW5kbGUoKSBjb25zdAoreworICAgIGludCBkdXBsaWNhdGVkSGFu ZGxlOworICAgIHdoaWxlICgoZHVwbGljYXRlZEhhbmRsZSA9IGR1cChtX2V2ZW50RkQpKSA9PSAt MSkgeworICAgICAgICBpZiAoZXJybm8gIT0gRUlOVFIpIHsKKyAgICAgICAgICAgIEFTU0VSVF9O T1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgcmV0dXJuIHsgfTsKKyAgICAgICAgfQorICAgIH0K KworICAgIHdoaWxlIChmY250bChkdXBsaWNhdGVkSGFuZGxlLCBGX1NFVEZELCBGRF9DTE9FWEVD KSA9PSAtMSkgeworICAgICAgICBpZiAoZXJybm8gIT0gRUlOVFIpIHsKKyAgICAgICAgICAgIEFT U0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgY2xvc2VXaXRoUmV0cnkoZHVwbGljYXRl ZEhhbmRsZSk7CisgICAgICAgICAgICByZXR1cm4geyB9OworICAgICAgICB9CisgICAgfQorICAg IHJldHVybiBJUEM6OkF0dGFjaG1lbnQoZHVwbGljYXRlZEhhbmRsZSk7Cit9CisKK30gLy8gbmFt ZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gT1MoTElOVVgpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmggYi9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzg3NGQ5MAotLS0gL2Rldi9udWxsCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuaApAQCAt MCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgor ICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0 aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhh dCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRp b24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJ VFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G CisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgT1MoTElOVVgpCisKKyNpbmNsdWRlIDx3dGYvTmV2 ZXJEZXN0cm95ZWQuaD4KKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKworbmFtZXNwYWNl IElQQyB7CitjbGFzcyBBdHRhY2htZW50OworfQorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xh c3MgTWVtb3J5UHJlc3N1cmVNb25pdG9yIHsKKyAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZW1v cnlQcmVzc3VyZU1vbml0b3IpOworICAgIGZyaWVuZCBjbGFzcyBOZXZlckRlc3Ryb3llZDxNZW1v cnlQcmVzc3VyZU1vbml0b3I+OworcHVibGljOgorICAgIHN0YXRpYyBNZW1vcnlQcmVzc3VyZU1v bml0b3ImIHNpbmdsZXRvbigpOworICAgIHN0YXRpYyBib29sIGlzRW5hYmxlZCgpOworCisgICAg fk1lbW9yeVByZXNzdXJlTW9uaXRvcigpOworCisgICAgSVBDOjpBdHRhY2htZW50IGNyZWF0ZUhh bmRsZSgpIGNvbnN0OworCitwcml2YXRlOgorICAgIE1lbW9yeVByZXNzdXJlTW9uaXRvcigpOwor CisgICAgaW50IG1fZXZlbnRGRCB7IC0xIH07Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQK KworI2VuZGlmIC8vIE9TKExJTlVYKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJv Y2Vzcy9XZWJQcm9jZXNzLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUHJvY2Vz cy5jcHAKaW5kZXggNmQ0MzIyMy4uMmM5NmM3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv V2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNz L1dlYlByb2Nlc3MuY3BwCkBAIC0yNjYsNyArMjY2LDkgQEAgdm9pZCBXZWJQcm9jZXNzOjppbml0 aWFsaXplV2ViUHJvY2VzcyhXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1ldGVy cykKICAgICBBU1NFUlQobV9wYWdlTWFwLmlzRW1wdHkoKSk7CiAKICNpZiBPUyhMSU5VWCkKLSAg ICBXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OlJlbGllZkxvZ2dlcjo6c2V0TG9nZ2lu Z0VuYWJsZWQocGFyYW1ldGVycy5zaG91bGRFbmFibGVNZW1vcnlQcmVzc3VyZVJlbGllZkxvZ2dp bmcpOworICAgIGlmIChwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZS5maWxl RGVzY3JpcHRvcigpICE9IC0xKQorICAgICAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmds ZXRvbigpLnNldE1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZS5yZWxlYXNlRmlsZURlc2NyaXB0b3IoKSk7CisgICAgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyOjpSZWxpZWZMb2dnZXI6OnNldExvZ2dpbmdFbmFibGVkKHBhcmFtZXRl cnMuc2hvdWxkRW5hYmxlTWVtb3J5UHJlc3N1cmVSZWxpZWZMb2dnaW5nKTsKICNlbmRpZgogCiAg ICAgcGxhdGZvcm1Jbml0aWFsaXplV2ViUHJvY2VzcyhXVEZNb3ZlKHBhcmFtZXRlcnMpKTsK 283609 2016-07-14 00:01:36 -0700 2016-07-14 01:23:34 -0700 Updated patch wk2-memory-pressure-linux.diff text/plain 35193 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1NzZiMTZkLi4xNDUyYmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTYtMDctMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIE1lbW9yeVByZXNzdXJlSGFuZGxlciBkb2Vzbid0IHdvcmsgaWYgY2dyb3Vw cyBhcmVuJ3QgcHJlc2VudCBpbiBMaW51eAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTU1MjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWxsb3cgdG8gcGFzcyBhbiBldmVudEZEIGZpbGUgZGVzY3JpcHRv ciB0byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIHRvIGJlIG1vbml0b3JpemVkIGluIGNhc2Ug Y2dyb3VwcyBhcmUgbm90CisgICAgICAgIGF2YWlsYWJsZS4KKworICAgICAgICAqIHBsYXRmb3Jt L01lbW9yeVByZXNzdXJlSGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2xpbnV4L01lbW9y eVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcDoKKwogMjAxNi0wNy0xMyAgQ2FybG9zIEdhcmNpYSBD YW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dMaWJdIFVzZSBhIEdTb3Vy Y2UgaW5zdGVhZCBvZiBhIHRocmVhZCB0byBwb2xsIG1lbW9yeSBwcmVzc3VyZSBldmVudEZEIGlu IGxpbnV4IGltcGxlbWVudGF0aW9uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9y eVByZXNzdXJlSGFuZGxlci5oCmluZGV4IDAxZmQ4MTQuLjhiMDRkNDggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVByZXNzdXJlSGFuZGxlci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVByZXNzdXJlSGFuZGxlci5oCkBAIC04NCw2ICs4NCw4 IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsZWFyTWVtb3J5UHJlc3N1cmUo KTsKICAgICBXRUJDT1JFX0VYUE9SVCBib29sIHNob3VsZFdhaXRGb3JNZW1vcnlDbGVhck1lc3Nh Z2UoKTsKICAgICB2b2lkIHJlc3BvbmRUb01lbW9yeVByZXNzdXJlSWZOZWVkZWQoKTsKKyNlbGlm IE9TKExJTlVYKQorICAgIHZvaWQgc2V0TWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlKGludCBm ZCk7CiAjZW5kaWYKIAogICAgIGNsYXNzIFJlbGllZkxvZ2dlciB7CkBAIC0xNzksNiArMTgxLDcg QEAgcHJpdmF0ZToKICAgICBSdW5Mb29wOjpUaW1lcjxNZW1vcnlQcmVzc3VyZUhhbmRsZXI+IG1f aG9sZE9mZlRpbWVyOwogICAgIHZvaWQgaG9sZE9mZlRpbWVyRmlyZWQoKTsKICAgICB2b2lkIGxv Z0Vycm9yQW5kQ2xvc2VGRHMoY29uc3QgY2hhciogZXJyb3IpOworICAgIGJvb2wgdHJ5RW5zdXJl RXZlbnRGRCgpOwogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKaW5kZXggMTJj NjE4Ni4uYjIzNTcwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbGludXgv TWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2xpbnV4L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcApAQCAtMTkzLDI5ICsxOTMs MzAgQEAgaW5saW5lIHZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpsb2dFcnJvckFuZENsb3Nl RkRzKGNvbnN0IGNoYXIqIGxvZykKICAgICB9CiB9CiAKLXZvaWQgTWVtb3J5UHJlc3N1cmVIYW5k bGVyOjppbnN0YWxsKCkKK2Jvb2wgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjp0cnlFbnN1cmVFdmVu dEZEKCkKIHsKLSAgICBpZiAobV9pbnN0YWxsZWQgfHwgbV9ob2xkT2ZmVGltZXIuaXNBY3RpdmUo KSkKLSAgICAgICAgcmV0dXJuOworICAgIGlmIChtX2V2ZW50RkQpCisgICAgICAgIHJldHVybiB0 cnVlOwogCisgICAgLy8gVHJ5IHRvIHVzZSBjZ3JvdXBzIGluc3RlYWQuCiAgICAgaW50IGZkID0g ZXZlbnRmZCgwLCBFRkRfQ0xPRVhFQyk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIExP RyhNZW1vcnlQcmVzc3VyZSwgImV2ZW50ZmQoKSBmYWlsZWQ6ICVtIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBtX2V2ZW50RkQgPSBmZDsKIAog ICAgIGZkID0gb3BlbihzX2Nncm91cE1lbW9yeVByZXNzdXJlTGV2ZWwsIE9fQ0xPRVhFQyB8IE9f UkRPTkxZKTsKICAgICBpZiAoZmQgPT0gLTEpIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZE cygiRmFpbGVkIHRvIG9wZW4gbWVtb3J5LnByZXNzdXJlX2xldmVsIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBtX3ByZXNzdXJlTGV2ZWxGRCA9 IGZkOwogCiAgICAgZmQgPSBvcGVuKHNfY2dyb3VwRXZlbnRDb250cm9sLCBPX0NMT0VYRUMgfCBP X1dST05MWSk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VG RHMoIkZhaWxlZCB0byBvcGVuIGNncm91cC5ldmVudF9jb250cm9sIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIAogICAgIGNoYXIgbGluZVsxMjhdID0g ezAsIH07CkBAIC0yMjMsMTAgKzIyNCwyMSBAQCB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6 aW5zdGFsbCgpCiAgICAgICAgIHx8IHdyaXRlKGZkLCBsaW5lLCBzdHJsZW4obGluZSkgKyAxKSA8 IDApIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIHdyaXRlIGNncm91 cC5ldmVudF9jb250cm9sIik7CiAgICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuOwor ICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogICAgIGNsb3NlKGZkKTsKIAorICAgIHJldHVy biB0cnVlOworfQorCit2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCgpCit7Cisg ICAgaWYgKG1faW5zdGFsbGVkIHx8IG1faG9sZE9mZlRpbWVyLmlzQWN0aXZlKCkpCisgICAgICAg IHJldHVybjsKKworICAgIGlmICghdHJ5RW5zdXJlRXZlbnRGRCgpKQorICAgICAgICByZXR1cm47 CisKICAgICBtX2V2ZW50RkRQb2xsZXIgPSBzdGQ6Om1ha2VfdW5pcXVlPEV2ZW50RkRQb2xsZXI+ KG1fZXZlbnRGRC52YWx1ZSgpLCBbdGhpc10gewogICAgICAgICAvLyBGSVhNRTogQ3VycmVudCBt ZW1jZyBkb2VzIG5vdCBwcm92aWRlIGFueSB3YXkgZm9yIHVzZXJzIHRvIGtub3cgaG93IHNlcmlv dXMgdGhlIG1lbW9yeSBwcmVzc3VyZSBpcy4KICAgICAgICAgLy8gU28gd2UgYXNzdW1lIGFsbCBu b3RpZmljYXRpb25zIGZyb20gbWVtY2cgYXJlIGNyaXRpY2FsIGZvciBub3cuIElmIG1lbWNnIGhh ZCBiZXR0ZXIgaW5mZXJmYWNlcwpAQCAtMjU3LDcgKzI2OSwxNyBAQCB2b2lkIE1lbW9yeVByZXNz dXJlSGFuZGxlcjo6dW5pbnN0YWxsKCkKICAgICBtX2hvbGRPZmZUaW1lci5zdG9wKCk7CiAgICAg bV9ldmVudEZEUG9sbGVyID0gbnVsbHB0cjsKIAotICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMobnVs bHB0cik7CisgICAgaWYgKG1fcHJlc3N1cmVMZXZlbEZEKSB7CisgICAgICAgIGNsb3NlKG1fcHJl c3N1cmVMZXZlbEZELnZhbHVlKCkpOworICAgICAgICBtX3ByZXNzdXJlTGV2ZWxGRCA9IE51bGxv cHQ7CisKKyAgICAgICAgLy8gT25seSBjbG9zZSB0aGUgZXZlbnRGRCB1c2VkIGZvciBjZ3JvdXBz LgorICAgICAgICBpZiAobV9ldmVudEZEKSB7CisgICAgICAgICAgICBjbG9zZShtX2V2ZW50RkQu dmFsdWUoKSk7CisgICAgICAgICAgICBtX2V2ZW50RkQgPSBOdWxsb3B0OworICAgICAgICB9Cisg ICAgfQorCiAgICAgbV9pbnN0YWxsZWQgPSBmYWxzZTsKIH0KIApAQCAtMzA5LDYgKzMzMSwxMiBA QCBzaXplX3QgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpSZWxpZWZMb2dnZXI6OnBsYXRmb3JtTWVt b3J5VXNhZ2UoKQogICAgIHJldHVybiB2bVNpemU7CiB9CiAKK3ZvaWQgTWVtb3J5UHJlc3N1cmVI YW5kbGVyOjpzZXRNZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUoaW50IGZkKQoreworICAgIEFT U0VSVCghbV9ldmVudEZEKTsKKyAgICBtX2V2ZW50RkQgPSBmZDsKK30KKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gT1MoTElOVVgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZGNlYTkxZS4u Mzk3Njg3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY4IEBACisyMDE2LTA3LTAxICBDYXJsb3Mg R2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKworICAgICAgICBNZW1vcnlQcmVz c3VyZUhhbmRsZXIgZG9lc24ndCB3b3JrIGlmIGNncm91cHMgYXJlbid0IHByZXNlbnQgaW4gTGlu dXgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTI1 NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZXJl J3Mgbm8gd2F5IHRvIGdldCBub3RpZmljYXRpb25zIGFib3V0IG1lbW9yeSBwcmVzc3VyZSBpbiBM aW51eCB3aXRob3V0IHVzaW5nIGNncm91cHMgdGhhdCBkb2Vzbid0IHJlcXVpcmUgYQorICAgICAg ICBtYW51YWwgcG9sbGluZy4gV2UgY2FuIGdldCB0aGF0IGluZm9ybWF0aW9uIGZyb20gL3Byb2Mv bWVtaW5mbywgYnV0IHRoYXQncyBub3QgcG9sbGFibGUgc28gaXQgcmVxdWlyZXMgdG8KKyAgICAg ICAgbWFudWFsbHkgY2hlY2sgaXRzIGNvbnRlbnRzIGluIGEgbG9vcCBzbGVlcGluZyBmb3IgYSB3 aGlsZSBiZXR3ZWVuIGNoZWNrcy4gVGhpcyBtZWFucyB3ZSB3b3VsZCBiZSB3YWtpbmcgdXAgdGhl CisgICAgICAgIHByb2Nlc3Mgb24gZXZlcnkgcG9sbCBpdGVyYXRpb24sIG1vc3Qgb2YgdGhlIHRp bWVzIGZvciBub3RoaW5nLiBUaGF0J3Mgc3BlY2lhbGx5IHByb2JsZW1hdGljIG9uIGRldmljZXMg cnVubmluZworICAgICAgICBvbiBiYXR0ZXJ5LiBBbmQgdGFraW5nIGludG8gYWNjb3VudCB0aGF0 IHRoZXJlJ3MgYSBtZW1vcnkgcHJlc3N1cmUgaGFuZGxlciBpbiBldmVyeSBzZWNvbmRhcnkgcHJv Y2VzcyAoV2ViLAorICAgICAgICBOZXR3b3JrIGFuZCBQbHVnaW4pLCB3ZSB3b3VsZCBiZSB3YWtp bmcgdXAgYWxsIHRob3NlIHByb2Nlc3MgYWxsIHRoZSB0aW1lLiBIb3dldmVyLCBub3QgaGF2aW5n IGEgbWVtb3J5IHByZXNzdXJlCisgICAgICAgIGhhbmRsZXIgaXMgZXZlbiBtb3JlIHByb2JsZW1h dGljIHRoYW4gdGhlIG1hbnVhbCBwb2xsaW5nLgorICAgICAgICBUaGlzIHBhdGNoIGFkZHMgYSBj bGFzcyBNZW1vcnlQcmVzc3VyZU1vbml0b3IgdG8gdGhlIG1hbnVhbCBwb2xsaW5nIG9mIC9wcm9j L21lbWluZm8sIGJ1dCBydW5zIGluIHRoZSBVSQorICAgICAgICBwcm9jZXNzLCB0byBhdm9pZCB0 aGUgd2Vha3VwcyBpbiBhbGwgb3RoZXIgc2Vjb25kYXJ5IHByb2Nlc3NlcywgYW5kIHVzZXMgYW4g ZXZlbnRGRCB0byBub3RpZnkgYWxsIG90aGVyCisgICAgICAgIHByb2Nlc3Nlcy4gSXQncyBvbmx5 IHVzZWQgaW4gY2FzZSBjZ3JvdXBzIGlzIG5vdCBhdmFpbGFibGUuIFRoZSBldmVudEZEIGRlc2Ny aXB0b3IgaXMgc2VudCB0byBhbGwgb3RoZXIKKyAgICAgICAgcHJvY2Vzc2VzIGF0IHN0YXJ0dXAs IGFuZCBwYXNzZWQgdG8gdGhlIE1lbW9yeVByZXNzdXJlSGFuZGxlciBiZWZvcmUgaW5zdGFsbCgp IGlzIGNhbGxlZCBmb3IgdGhlIGZpcnN0CisgICAgICAgIHRpbWUuIFRvIG1pbmltaXplIHRoZSB3 YWtldXBzIGV2ZW4gaW4gdGhlIFVJIHByb2Nlc3MsIHRoZSBwb2xsIGludGVydmFsIGlzIGNhbGN1 bGF0ZWQgZnJvbSAxIHRvIDUgc2Vjb25kcworICAgICAgICBkZXBlbmRpbmcgb24gdGhlIGN1cnJl bnQgbWVtb3J5IHVzZWQsIHNvIGluIGNhc2Ugb2YgbG93IG1lbW9yeSBsZXZlbCB3ZSBzbGVlcCBm b3IgYSBsb25nZXIgdGltZS4KKyAgICAgICAgSXQncyBhbHNvIGltcG9ydGFudCB0byBtYWtlIHRo ZSBtZW1vcnkgY2FsY3VsYXRpb25zIGFzIGFjY3VyYXRlIGFzIHBvc3NpYmxlIHRvIGF2b2lkIGNs ZWFuaW5nIHJlc291cmNlcyBpbiB0aGUKKyAgICAgICAgc2Vjb25kYXJ5IHByb2Nlc3NlcyB1bm5l Y2Vzc2FyaWx5LgorCisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3Bw OgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzczo6aW5pdGlhbGl6ZU5ldHdvcmtQcm9j ZXNzKTogUGFzcyB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgZmlsZSBkZXNjcmlwdG9yIHRv IHRoZSBNZW1vcnlQcmVzc3VyZUhhbmRsZXIuCisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0 d29ya1Byb2Nlc3MuaDoKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycy5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3Ig aGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy czo6ZGVjb2RlKTogRGVjb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAg ICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oOgor ICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOiBBZGQgbmV3IGZpbGUgdG8gY29tcGlsYXRpb24s IGFuZCB1cGRhdGUgaW5jbHVkZSBkaXJzLgorICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOiBE aXR0by4KKyAgICAgICAgKiBQbHVnaW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwOgorICAgICAg ICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzOjppbml0aWFsaXplUGx1Z2luUHJvY2Vzcyk6IFBhc3Mg dGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGZpbGUgZGVzY3JpcHRvciB0byB0aGUgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyLgorICAgICAgICAqIFNoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwOgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3Ig aGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjpkZWNvZGUpOiBEZWNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlLgorICAgICAg ICAqIFNoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaDoKKyAg ICAgICAgKiBTaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHA6CisgICAgICAg IChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVuY29kZSk6IEVuY29kZSBt ZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBoYW5kbGUuCisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZSk6IERlY29kZSBtZW1vcnkgcHJlc3N1cmUgbW9u aXRvciBoYW5kbGUuCisgICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzUHJveHkuY3Bw OgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzUHJveHk6OmRpZEZpbmlzaExhdW5jaGlu Zyk6IENyZWF0ZSB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlIGZvciB0aGUgcGx1 Z2luCisgICAgICAgIHByb2Nlc3MgaWYgbmVlZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQ cm9jZXNzUG9vbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQb29sOjplbnN1cmVO ZXR3b3JrUHJvY2Vzcyk6IENyZWF0ZSB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxl IGZvciB0aGUgbmV0d29yaworICAgICAgICBwcm9jZXNzIGlmIG5lZWRlZC4KKyAgICAgICAgKFdl YktpdDo6V2ViUHJvY2Vzc1Bvb2w6OmNyZWF0ZU5ld1dlYlByb2Nlc3MpOiBDcmVhdGUgdGhlIG1l bW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZSBmb3IgdGhlIHdlYiBwcm9jZXNzIGlmCisgICAg ICAgIG5lZWRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25p dG9yLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6Omxvd1dhdGVybWFya1BhZ2VzKToKKyAg ICAgICAgKFdlYktpdDo6c3lzdGVtUGFnZVNpemUpOgorICAgICAgICAoV2ViS2l0OjpjYWxjdWxh dGVNZW1vcnlBdmFpbGFibGUpOgorICAgICAgICAoV2ViS2l0OjpzeXN0ZW1NZW1vcnlVc2VkQXNQ ZXJjZW50YWdlKToKKyAgICAgICAgKFdlYktpdDo6cG9sbEludGVydmFsRm9yVXNlZE1lbW9yeVBl cmNlbnRhZ2UpOgorICAgICAgICAoV2ViS2l0Ojppc1N5c3RlbWRNZW1vcnlQcmVzc3VyZU1vbml0 b3JBdmFpbGFibGUpOgorICAgICAgICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6Omlz RW5hYmxlZCk6CisgICAgICAgIChXZWJLaXQ6Ok1lbW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xl dG9uKToKKyAgICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjpNZW1vcnlQcmVz c3VyZU1vbml0b3IpOgorICAgICAgICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6OmNy ZWF0ZUhhbmRsZSk6CisgICAgICAgICogVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9u aXRvci5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlByb2Nlc3M6OmluaXRpYWxpemVXZWJQcm9jZXNzKTogUGFzcyB0aGUgbWVtb3J5 IHByZXNzdXJlIG1vbml0b3IgZmlsZSBkZXNjcmlwdG9yIHRvIHRoZSBNZW1vcnlQcmVzc3VyZUhh bmRsZXIuCisKIDIwMTYtMDctMTMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2Fs aWEuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04ocjIwMjI3Myk6IFtHVEtdIFJlZGlyZWN0ZWQg WCB3aW5kb3cgaXMgcmVzaXplZCB0byB0aGUgcHJldmlvdXMgc2l6ZSBvbiBzaXplIGFsbG9jYXRl CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vz cy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAK aW5kZXggODk1MzkzYy4uYTJhZDBkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcApAQCAtMTkzLDcgKzE5Myw3IEBAIHZvaWQgTmV0d29y a1Byb2Nlc3M6Omxvd01lbW9yeUhhbmRsZXIoQ3JpdGljYWwgY3JpdGljYWwpCiAgICAgV1RGOjpy ZWxlYXNlRmFzdE1hbGxvY0ZyZWVNZW1vcnkoKTsKIH0KIAotdm9pZCBOZXR3b3JrUHJvY2Vzczo6 aW5pdGlhbGl6ZU5ldHdvcmtQcm9jZXNzKGNvbnN0IE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJh bWV0ZXJzJiBwYXJhbWV0ZXJzKQordm9pZCBOZXR3b3JrUHJvY2Vzczo6aW5pdGlhbGl6ZU5ldHdv cmtQcm9jZXNzKE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1ldGVycykK IHsKICAgICBwbGF0Zm9ybUluaXRpYWxpemVOZXR3b3JrUHJvY2VzcyhwYXJhbWV0ZXJzKTsKIApA QCAtMjAyLDYgKzIwMiwxMCBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzOjppbml0aWFsaXplTmV0d29y a1Byb2Nlc3MoY29uc3QgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZQogICAgIG1fc3VwcHJl c3NNZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBwYXJhbWV0ZXJzLnNob3VsZFN1cHByZXNzTWVtb3J5 UHJlc3N1cmVIYW5kbGVyOwogICAgIGlmICghbV9zdXBwcmVzc01lbW9yeVByZXNzdXJlSGFuZGxl cikgewogICAgICAgICBhdXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQcmVzc3Vy ZUhhbmRsZXI6OnNpbmdsZXRvbigpOworI2lmIE9TKExJTlVYKQorICAgICAgICBpZiAocGFyYW1l dGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUuZmlsZURlc2NyaXB0b3IoKSAhPSAtMSkK KyAgICAgICAgICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRNZW1vcnlQcmVzc3VyZU1vbml0 b3JIYW5kbGUocGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUucmVsZWFzZUZp bGVEZXNjcmlwdG9yKCkpOworI2VuZGlmCiAgICAgICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5z ZXRMb3dNZW1vcnlIYW5kbGVyKFt0aGlzXSAoQ3JpdGljYWwgY3JpdGljYWwsIFN5bmNocm9ub3Vz KSB7CiAgICAgICAgICAgICBsb3dNZW1vcnlIYW5kbGVyKGNyaXRpY2FsKTsKICAgICAgICAgfSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vz cy5oIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaAppbmRl eCBjODk3OTk4Li5iNzMyNTE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNz L05ldHdvcmtQcm9jZXNzLmgKQEAgLTE1OSw3ICsxNTksNyBAQCBwcml2YXRlOgogICAgIC8vIE1l c3NhZ2UgSGFuZGxlcnMKICAgICB2b2lkIGRpZFJlY2VpdmVOZXR3b3JrUHJvY2Vzc01lc3NhZ2Uo SVBDOjpDb25uZWN0aW9uJiwgSVBDOjpNZXNzYWdlRGVjb2RlciYpOwogICAgIHZvaWQgZGlkUmVj ZWl2ZVN5bmNOZXR3b3JrUHJvY2Vzc01lc3NhZ2UoSVBDOjpDb25uZWN0aW9uJiwgSVBDOjpNZXNz YWdlRGVjb2RlciYsIHN0ZDo6dW5pcXVlX3B0cjxJUEM6Ok1lc3NhZ2VFbmNvZGVyPiYpOwotICAg IHZvaWQgaW5pdGlhbGl6ZU5ldHdvcmtQcm9jZXNzKGNvbnN0IE5ldHdvcmtQcm9jZXNzQ3JlYXRp b25QYXJhbWV0ZXJzJik7CisgICAgdm9pZCBpbml0aWFsaXplTmV0d29ya1Byb2Nlc3MoTmV0d29y a1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJik7CiAgICAgdm9pZCBjcmVhdGVOZXR3b3JrQ29u bmVjdGlvblRvV2ViUHJvY2VzcygpOwogICAgIHZvaWQgZGVzdHJveVByaXZhdGVCcm93c2luZ1Nl c3Npb24oV2ViQ29yZTo6U2Vzc2lvbklEKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv TmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuY3BwCmluZGV4IGI0OGZkMDAuLmJjMzU0MDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5jcHAKQEAgLTgyLDYgKzgyLDkgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVyczo6ZW5jb2RlKElQQzo6QXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyKSBjb24KICAg ICBlbmNvZGVyIDw8IGlnbm9yZVRMU0Vycm9yczsKICAgICBlbmNvZGVyIDw8IGxhbmd1YWdlczsK ICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVtb3J5UHJlc3N1cmVNb25p dG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnM6OmRlY29kZShJUEM6OkFyZ3VtZW50RGVjb2RlciYgZGVjb2RlciwgTmV0d29ya1Byb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMmIHJlc3VsdCkKQEAgLTE1OCw2ICsxNjEsMTEgQEAgYm9vbCBO ZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNv ZGVyJiBkZWNvZGVyLCBOZXQKICAgICAgICAgcmV0dXJuIGZhbHNlOwogI2VuZGlmCiAKKyNpZiBP UyhMSU5VWCkKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5tZW1vcnlQcmVzc3VyZU1v bml0b3JIYW5kbGUpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKKwogICAgIHJldHVy biB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9O ZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdDIvTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCA0YTU4ZTRh Li41Njg4MTk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdv cmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKQEAgLTI2LDYgKzI2 LDcgQEAKICNpZm5kZWYgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnNfaAogI2RlZmlu ZSBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyc19oCiAKKyNpbmNsdWRlICJBdHRhY2ht ZW50LmgiCiAjaW5jbHVkZSAiQ2FjaGVNb2RlbC5oIgogI2luY2x1ZGUgIlNhbmRib3hFeHRlbnNp b24uaCIKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CkBAIC05NSw2ICs5NiwxMCBAQCBzdHJ1Y3Qg TmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMgewogICAgIGJvb2wgaWdub3JlVExTRXJy b3JzOwogICAgIFZlY3RvcjxTdHJpbmc+IGxhbmd1YWdlczsKICNlbmRpZgorCisjaWYgT1MoTElO VVgpCisgICAgSVBDOjpBdHRhY2htZW50IG1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZTsKKyNl bmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9QbGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtl CmluZGV4IDEwODU2YzguLjIwMjBmYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1BsYXRm b3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0x NzEsNiArMTcxLDggQEAgbGlzdChBUFBFTkQgV2ViS2l0Ml9TT1VSQ0VTCiAgICAgVUlQcm9jZXNz L2dzdHJlYW1lci9JbnN0YWxsTWlzc2luZ01lZGlhUGx1Z2luc1Blcm1pc3Npb25SZXF1ZXN0LmNw cAogICAgIFVJUHJvY2Vzcy9nc3RyZWFtZXIvV2ViUGFnZVByb3h5R1N0cmVhbWVyLmNwcAogCisg ICAgVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHAKKwogICAgIFVJUHJv Y2Vzcy9zb3VwL1dlYkNvb2tpZU1hbmFnZXJQcm94eVNvdXAuY3BwCiAgICAgVUlQcm9jZXNzL3Nv dXAvV2ViUHJvY2Vzc1Bvb2xTb3VwLmNwcAogCkBAIC0yNTYsNiArMjU4LDcgQEAgbGlzdChBUFBF TkQgV2ViS2l0Ml9JTkNMVURFX0RJUkVDVE9SSUVTCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzIgogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3Mv TmV0d29yay9DdXN0b21Qcm90b2NvbHMvc291cCIKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9j ZXNzL2VmbCIKKyAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL2xpbnV4IgogICAgICIke1dF QktJVDJfRElSfS9VSVByb2Nlc3Mvc291cCIKICAgICAiJHtXRUJLSVQyX0RJUn0vV2ViUHJvY2Vz cy9lZmwiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1dlYlByb2Nlc3Mvc291cCIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZv cm1HVEsuY21ha2UKaW5kZXggYjNjMmFkYi4uZmQyMTY4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsu Y21ha2UKQEAgLTI3Myw2ICsyNzMsOCBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKIAog ICAgIFVJUHJvY2Vzcy9MYXVuY2hlci9ndGsvUHJvY2Vzc0xhdW5jaGVyR3RrLmNwcAogCisgICAg VUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHAKKwogICAgIFVJUHJvY2Vz cy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9zb3VwL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5 U291cC5jcHAKICAgICBVSVByb2Nlc3MvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvc291cC9XZWJT b3VwQ3VzdG9tUHJvdG9jb2xSZXF1ZXN0TWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3MvTmV0d29y ay9DdXN0b21Qcm90b2NvbHMvc291cC9XZWJTb3VwQ3VzdG9tUHJvdG9jb2xSZXF1ZXN0TWFuYWdl ckNsaWVudC5jcHAKQEAgLTUxMyw2ICs1MTUsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX0lOQ0xV REVfRElSRUNUT1JJRVMKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL1BsdWdpbnMvZ3Rr IgogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvZ3N0cmVhbWVyIgogICAgICIke1dFQktJ VDJfRElSfS9VSVByb2Nlc3MvZ3RrIgorICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvbGlu dXgiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9zb3VwIgogICAgICIke1dFQktJVDJf RElSfS9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsiCiAgICAgIiR7V0VCS0lUMl9E SVJ9L1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS91bml4IgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNwcCBiL1NvdXJjZS9XZWJLaXQy L1BsdWdpblByb2Nlc3MvUGx1Z2luUHJvY2Vzcy5jcHAKaW5kZXggNzU1NTcwMi4uNjFlNjZmMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9QbHVnaW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwCkBA IC03MSwxMyArNzEsNiBAQCB2b2lkIFBsdWdpblByb2Nlc3M6OmluaXRpYWxpemVQcm9jZXNzKGNv bnN0IENoaWxkUHJvY2Vzc0luaXRpYWxpemF0aW9uUGFyYW1ldGVycwogewogICAgIG1fcGx1Z2lu UGF0aCA9IHBhcmFtZXRlcnMuZXh0cmFJbml0aWFsaXphdGlvbkRhdGEuZ2V0KCJwbHVnaW4tcGF0 aCIpOwogICAgIHBsYXRmb3JtSW5pdGlhbGl6ZVByb2Nlc3MocGFyYW1ldGVycyk7Ci0KLSAgICBh dXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmds ZXRvbigpOwotICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRMb3dNZW1vcnlIYW5kbGVyKFt0 aGlzXSAoQ3JpdGljYWwsIFN5bmNocm9ub3VzKSB7Ci0gICAgICAgIGlmIChzaG91bGRUZXJtaW5h dGUoKSkKLSAgICAgICAgICAgIHRlcm1pbmF0ZSgpOwotICAgIH0pOwotICAgIG1lbW9yeVByZXNz dXJlSGFuZGxlci5pbnN0YWxsKCk7CiB9CiAKIHZvaWQgUGx1Z2luUHJvY2Vzczo6cmVtb3ZlV2Vi UHJvY2Vzc0Nvbm5lY3Rpb24oV2ViUHJvY2Vzc0Nvbm5lY3Rpb24qIHdlYlByb2Nlc3NDb25uZWN0 aW9uKQpAQCAtMTM3LDYgKzEzMCwxNyBAQCB2b2lkIFBsdWdpblByb2Nlc3M6OmluaXRpYWxpemVQ bHVnaW5Qcm9jZXNzKFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJiBwYQogewogICAg IEFTU0VSVCghbV9wbHVnaW5Nb2R1bGUpOwogCisgICAgYXV0byYgbWVtb3J5UHJlc3N1cmVIYW5k bGVyID0gTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpzaW5nbGV0b24oKTsKKyNpZiBPUyhMSU5VWCkK KyAgICBpZiAocGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUuZmlsZURlc2Ny aXB0b3IoKSAhPSAtMSkKKyAgICAgICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldE1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRs ZS5yZWxlYXNlRmlsZURlc2NyaXB0b3IoKSk7CisjZW5kaWYKKyAgICBtZW1vcnlQcmVzc3VyZUhh bmRsZXIuc2V0TG93TWVtb3J5SGFuZGxlcihbdGhpc10gKENyaXRpY2FsLCBTeW5jaHJvbm91cykg eworICAgICAgICBpZiAoc2hvdWxkVGVybWluYXRlKCkpCisgICAgICAgICAgICB0ZXJtaW5hdGUo KTsKKyAgICB9KTsKKyAgICBtZW1vcnlQcmVzc3VyZUhhbmRsZXIuaW5zdGFsbCgpOworCiAgICAg bV9zdXBwb3J0c0FzeW5jaHJvbm91c1BsdWdpbkluaXRpYWxpemF0aW9uID0gcGFyYW1ldGVycy5z dXBwb3J0c0FzeW5jaHJvbm91c1BsdWdpbkluaXRpYWxpemF0aW9uOwogICAgIHNldE1pbmltdW1M aWZldGltZShwYXJhbWV0ZXJzLm1pbmltdW1MaWZldGltZSk7CiAgICAgc2V0VGVybWluYXRpb25U aW1lb3V0KHBhcmFtZXRlcnMudGVybWluYXRpb25UaW1lb3V0KTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMu Y3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycy5jcHAKaW5kZXggZTNlMWZmZC4uMzAxNTRjNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0 aW9uUGFyYW1ldGVycy5jcHAKQEAgLTUxLDYgKzUxLDkgQEAgdm9pZCBQbHVnaW5Qcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNv bnMKICAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBuZXR3b3JrQVRTQ29udGV4dC5nZXQoKSk7CiAj ZW5kaWYKICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVtb3J5UHJlc3N1 cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgUGx1Z2luUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBQbHVnaW5Q cm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiByZXN1bHQpCkBAIC03MSw2ICs3NCwxMCBAQCBib29s IFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJUEM6OkFyZ3VtZW50RGVj b2RlciYgZGVjb2RlciwgUGx1ZwogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5kaWYKICNlbmRp ZgorI2lmIE9TKExJTlVYKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0Lm1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgogCiAg ICAgcmV0dXJuIHRydWU7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvUGx1 Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKaW5kZXggYWM3 ZDYzOC4uZDYxNzEzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMv UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAtMjgsNiAr MjgsNyBAQAogCiAjaWYgRU5BQkxFKE5FVFNDQVBFX1BMVUdJTl9BUEkpCiAKKyNpbmNsdWRlICJB dHRhY2htZW50LmgiCiAjaW5jbHVkZSAiUGx1Z2luUHJvY2Vzc0F0dHJpYnV0ZXMuaCIKIAogI2lm IFBMQVRGT1JNKENPQ09BKQpAQCAtNTksNiArNjAsOSBAQCBzdHJ1Y3QgUGx1Z2luUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycyB7CiAgICAgUmV0YWluUHRyPENGRGF0YVJlZj4gbmV0d29ya0FUU0Nv bnRleHQ7CiAjZW5kaWYKICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIElQQzo6QXR0YWNobWVu dCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNw YWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwCmluZGV4IGE1MzFlNDUuLjFhMmIwZDUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5j cHAKQEAgLTE0MSw2ICsxNDEsMTAgQEAgdm9pZCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiAjaWYgVEFSR0VU X09TX0lQSE9ORSB8fCAoUExBVEZPUk0oTUFDKSAmJiBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JF UVVJUkVEID49IDEwMTEwMCkKICAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBuZXR3b3JrQVRTQ29u dGV4dC5nZXQoKSk7CiAjZW5kaWYKKworI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVt b3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgV2ViUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBX ZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiBwYXJhbWV0ZXJzKQpAQCAtMjk2LDYgKzMwMCwx MSBAQCBib29sIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJUEM6OkFyZ3Vt ZW50RGVjb2RlciYgZGVjb2RlciwgV2ViUHJvYwogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5k aWYKIAorI2lmIE9TKExJTlVYKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5t ZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisjZW5k aWYKKwogICAgIHJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdDIvU2hh cmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCBhZGQ4NGYzLi5jOWFhMmM5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzLmgKQEAgLTE2Niw2ICsxNjYsMTAgQEAgc3RydWN0IFdlYlByb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMgewogI2lmIFRBUkdFVF9PU19JUEhPTkUgfHwgKFBMQVRGT1JNKE1BQykgJiYg X19NQUNfT1NfWF9WRVJTSU9OX01JTl9SRVFVSVJFRCA+PSAxMDExMDApCiAgICAgUmV0YWluUHRy PENGRGF0YVJlZj4gbmV0d29ya0FUU0NvbnRleHQ7CiAjZW5kaWYKKworI2lmIE9TKExJTlVYKQor ICAgIElQQzo6QXR0YWNobWVudCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYK IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblByb2Nlc3NQcm94eS5jcHAKaW5kZXggOGY1MDVhNi4u ZTcwOTEyNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvUGx1 Z2luUHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lu cy9QbHVnaW5Qcm9jZXNzUHJveHkuY3BwCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpZiBFTkFCTEUo TkVUU0NBUEVfUExVR0lOX0FQSSkKIAorI2luY2x1ZGUgIk1lbW9yeVByZXNzdXJlTW9uaXRvci5o IgogI2luY2x1ZGUgIlBsdWdpblByb2Nlc3NDb25uZWN0aW9uTWFuYWdlck1lc3NhZ2VzLmgiCiAj aW5jbHVkZSAiUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIgogI2luY2x1ZGUgIlBs dWdpblByb2Nlc3NNYW5hZ2VyLmgiCkBAIC0yMjksNiArMjMwLDEyIEBAIHZvaWQgUGx1Z2luUHJv Y2Vzc1Byb3h5OjpkaWRGaW5pc2hMYXVuY2hpbmcoUHJvY2Vzc0xhdW5jaGVyKiwgSVBDOjpDb25u ZWN0aW9uOjpJCiAgICAgICAgIHBhcmFtZXRlcnMubWluaW11bUxpZmV0aW1lID0gbWluaW11bUxp ZmV0aW1lOwogICAgICAgICBwYXJhbWV0ZXJzLnRlcm1pbmF0aW9uVGltZW91dCA9IHNodXRkb3du VGltZW91dDsKICAgICB9CisKKyNpZiBPUyhMSU5VWCkKKyAgICBpZiAoTWVtb3J5UHJlc3N1cmVN b25pdG9yOjppc0VuYWJsZWQoKSkKKyAgICAgICAgcGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1v bml0b3JIYW5kbGUgPSBNZW1vcnlQcmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbigpLmNyZWF0ZUhh bmRsZSgpOworI2VuZGlmCisKICAgICBwbGF0Zm9ybUluaXRpYWxpemVQbHVnaW5Qcm9jZXNzKHBh cmFtZXRlcnMpOwogCiAgICAgLy8gSW5pdGlhbGl6ZSB0aGUgcGx1Zy1pbiBob3N0IHByb2Nlc3Mu CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3Bw IGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcAppbmRleCAyZjli ZjA5Li45MzhkN2UyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUHJv Y2Vzc1Bvb2wuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQcm9jZXNzUG9v bC5jcHAKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlICJEb3dubG9hZFByb3h5LmgiCiAjaW5j bHVkZSAiRG93bmxvYWRQcm94eU1lc3NhZ2VzLmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2lu Y2x1ZGUgIk1lbW9yeVByZXNzdXJlTW9uaXRvci5oIgogI2luY2x1ZGUgIk5ldHdvcmtQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmgiCiAjaW5jbHVkZSAiTmV0d29ya1Byb2Nlc3NNZXNzYWdlcy5o IgogI2luY2x1ZGUgIk5ldHdvcmtQcm9jZXNzUHJveHkuaCIKQEAgLTM3MCw2ICszNzEsMTEgQEAg TmV0d29ya1Byb2Nlc3NQcm94eSYgV2ViUHJvY2Vzc1Bvb2w6OmVuc3VyZU5ldHdvcmtQcm9jZXNz KCkKICAgICAgICAgU2FuZGJveEV4dGVuc2lvbjo6Y3JlYXRlSGFuZGxlKHBhcmVudEJ1bmRsZURp cmVjdG9yeSwgU2FuZGJveEV4dGVuc2lvbjo6UmVhZE9ubHksIHBhcmFtZXRlcnMucGFyZW50QnVu ZGxlRGlyZWN0b3J5RXh0ZW5zaW9uSGFuZGxlKTsKICNlbmRpZgogCisjaWYgT1MoTElOVVgpCisg ICAgaWYgKE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6aXNFbmFibGVkKCkpCisgICAgICAgIHBhcmFt ZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlID0gTWVtb3J5UHJlc3N1cmVNb25pdG9y OjpzaW5nbGV0b24oKS5jcmVhdGVIYW5kbGUoKTsKKyNlbmRpZgorCiAgICAgcGFyYW1ldGVycy5z aG91bGRVc2VUZXN0aW5nTmV0d29ya1Nlc3Npb24gPSBtX3Nob3VsZFVzZVRlc3RpbmdOZXR3b3Jr U2Vzc2lvbjsKIAogICAgIC8vIEFkZCBhbnkgcGxhdGZvcm0gc3BlY2lmaWMgcGFyYW1ldGVycwpA QCAtNjI2LDYgKzYzMiw4IEBAIFdlYlByb2Nlc3NQcm94eSYgV2ViUHJvY2Vzc1Bvb2w6OmNyZWF0 ZU5ld1dlYlByb2Nlc3MoKQogCiAjaWYgT1MoTElOVVgpCiAgICAgcGFyYW1ldGVycy5zaG91bGRF bmFibGVNZW1vcnlQcmVzc3VyZVJlbGllZkxvZ2dpbmcgPSB0cnVlOworICAgIGlmIChNZW1vcnlQ cmVzc3VyZU1vbml0b3I6OmlzRW5hYmxlZCgpKQorICAgICAgICBwYXJhbWV0ZXJzLm1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZSA9IE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xldG9uKCku Y3JlYXRlSGFuZGxlKCk7CiAjZW5kaWYKIAogICAgIHBhcmFtZXRlcnMucmVzb3VyY2VMb2FkU3Rh dGlzdGljc0VuYWJsZWQgPSByZXNvdXJjZUxvYWRTdGF0aXN0aWNzRW5hYmxlZCgpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRv ci5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25p dG9yLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hOWZhODg3Ci0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNz dXJlTW9uaXRvci5jcHAKQEAgLTAsMCArMSwyNzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTYgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxF IEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExP U1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9O KSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJ VFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg Ik1lbW9yeVByZXNzdXJlTW9uaXRvci5oIgorCisjaWYgT1MoTElOVVgpCisKKyNpbmNsdWRlICJB dHRhY2htZW50LmgiCisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRlIDxtdXRleD4KKyNpbmNs dWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDxzeXMvZXZlbnRm ZC5oPgorI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5j bHVkZSA8dW5pc3RkLmg+CisjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CisjaW5jbHVkZSA8 d3RmL1RocmVhZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9VbmlTdGRFeHRyYXMuaD4KKworbmFtZXNw YWNlIFdlYktpdCB7CisKK3N0YXRpYyBjb25zdCBzaXplX3Qgbm90U2V0ID0gc3RhdGljX2Nhc3Q8 c2l6ZV90PigtMSk7CisKK3N0YXRpYyBjb25zdCBkb3VibGUgc19taW5Qb2xsaW5nSW50ZXJ2YWxJ blNlY29uZHMgPSAxOworc3RhdGljIGNvbnN0IGRvdWJsZSBzX21heFBvbGxpbmdJbnRlcnZhbElu U2Vjb25kcyA9IDU7CitzdGF0aWMgY29uc3QgZG91YmxlIHNfbWluVXNlZE1lbW9yeVBlcmNlbnRh Z2VGb3JQb2xsaW5nID0gNTA7CitzdGF0aWMgY29uc3QgZG91YmxlIHNfbWF4VXNlZE1lbW9yeVBl cmNlbnRhZ2VGb3JQb2xsaW5nID0gOTA7CitzdGF0aWMgY29uc3QgaW50IHNfbWVtb3J5UHJlc3Vy ZVBlcmNlbnRhZ2VUaHJlc2hvbGQgPSA5NTsKKworc3RhdGljIHNpemVfdCBsb3dXYXRlcm1hcmtQ YWdlcygpCit7CisgICAgRklMRSogZmlsZSA9IGZvcGVuKCIvcHJvYy96b25laW5mbyIsICJyIik7 CisgICAgaWYgKCFmaWxlKQorICAgICAgICByZXR1cm4gbm90U2V0OworCisgICAgc2l6ZV90IGxv dyA9IDA7CisgICAgYm9vbCBpblpvbmUgPSBmYWxzZTsKKyAgICBib29sIGZvdW5kTG93ID0gZmFs c2U7CisgICAgY2hhciBidWZmZXJbMTI4XTsKKyAgICB3aGlsZSAoY2hhciogbGluZSA9IGZnZXRz KGJ1ZmZlciwgMTI4LCBmaWxlKSkgeworICAgICAgICBpZiAoIXN0cmNtcChsaW5lLCAiTm9kZSIp KSB7CisgICAgICAgICAgICBpblpvbmUgPSB0cnVlOworICAgICAgICAgICAgZm91bmRMb3cgPSBm YWxzZTsKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgY2hhciog dG9rZW4gPSBzdHJ0b2sobGluZSwgIiAiKTsKKyAgICAgICAgaWYgKCF0b2tlbikKKyAgICAgICAg ICAgIGNvbnRpbnVlOworCisgICAgICAgIGlmICghc3RyY21wKHRva2VuLCAibG93IikpIHsKKyAg ICAgICAgICAgIGlmICghaW5ab25lIHx8IGZvdW5kTG93KSB7CisgICAgICAgICAgICAgICAgbG93 ID0gbm90U2V0OworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAg ICAgICAgdG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKTsKKyAgICAgICAgICAgIGlmICghdG9r ZW4pIHsKKyAgICAgICAgICAgICAgICBsb3cgPSBub3RTZXQ7CisgICAgICAgICAgICAgICAgYnJl YWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBsb3cgKz0gYXRvbGwodG9rZW4pOworICAg ICAgICAgICAgZm91bmRMb3cgPSB0cnVlOworICAgICAgICB9CisgICAgfQorICAgIGZjbG9zZShm aWxlKTsKKworICAgIHJldHVybiBsb3c7Cit9CisKK3N0YXRpYyBpbmxpbmUgc2l6ZV90IHN5c3Rl bVBhZ2VTaXplKCkKK3sKKyAgICBzdGF0aWMgc2l6ZV90IHBhZ2VTaXplID0gMDsKKyAgICBpZiAo IXBhZ2VTaXplKQorICAgICAgICBwYWdlU2l6ZSA9IHN5c2NvbmYoX1NDX1BBR0VfU0laRSk7Cisg ICAgcmV0dXJuIHBhZ2VTaXplOworfQorCitzdGF0aWMgc2l6ZV90IGNhbGN1bGF0ZU1lbW9yeUF2 YWlsYWJsZShzaXplX3QgbWVtb3J5RnJlZSwgc2l6ZV90IGFjdGl2ZUZpbGUsIHNpemVfdCBpbmFj dGl2ZUZpbGUsIHNpemVfdCBzbGFiUmVjbGFpbWFibGUpCit7CisgICAgaWYgKG1lbW9yeUZyZWUg PT0gbm90U2V0IHx8IGFjdGl2ZUZpbGUgPT0gbm90U2V0IHx8IGluYWN0aXZlRmlsZSA9PSBub3RT ZXQgfHwgc2xhYlJlY2xhaW1hYmxlID09IG5vdFNldCkKKyAgICAgICAgcmV0dXJuIG5vdFNldDsK KworICAgIHNpemVfdCBsb3dXYXRlcm1hcmsgPSBsb3dXYXRlcm1hcmtQYWdlcygpOworICAgIGlm IChsb3dXYXRlcm1hcmsgPT0gbm90U2V0KQorICAgICAgICByZXR1cm4gbm90U2V0OworCisgICAg bG93V2F0ZXJtYXJrICo9IHN5c3RlbVBhZ2VTaXplKCkgLyBLQjsKKworICAgIC8vIEVzdGltYXRl IHRoZSBhbW91bnQgb2YgbWVtb3J5IGF2YWlsYWJsZSBmb3IgdXNlcnNwYWNlIGFsbG9jYXRpb25z LCB3aXRob3V0IGNhdXNpbmcgc3dhcHBpbmcuCisgICAgLy8gRnJlZSBtZW1vcnkgY2Fubm90IGJl IHRha2VuIGJlbG93IHRoZSBsb3cgd2F0ZXJtYXJrLCBiZWZvcmUgdGhlIHN5c3RlbSBzdGFydHMg c3dhcHBpbmcuCisgICAgbG93V2F0ZXJtYXJrICo9IHN5c3RlbVBhZ2VTaXplKCkgLyBLQjsKKyAg ICBzaXplX3QgbWVtb3J5QXZhaWxhYmxlID0gbWVtb3J5RnJlZSAtIGxvd1dhdGVybWFyazsKKwor ICAgIC8vIE5vdCBhbGwgdGhlIHBhZ2UgY2FjaGUgY2FuIGJlIGZyZWVkLCBvdGhlcndpc2UgdGhl IHN5c3RlbSB3aWxsIHN0YXJ0IHN3YXBwaW5nLiBBc3N1bWUgYXQgbGVhc3QKKyAgICAvLyBoYWxm IG9mIHRoZSBwYWdlIGNhY2hlLCBvciB0aGUgbG93IHdhdGVybWFyayB3b3J0aCBvZiBjYWNoZSwg bmVlZHMgdG8gc3RheS4KKyAgICBzaXplX3QgcGFnZUNhY2hlID0gYWN0aXZlRmlsZSArIGluYWN0 aXZlRmlsZTsKKyAgICBwYWdlQ2FjaGUgLT0gc3RkOjptaW4ocGFnZUNhY2hlIC8gMiwgbG93V2F0 ZXJtYXJrKTsKKyAgICBtZW1vcnlBdmFpbGFibGUgKz0gcGFnZUNhY2hlOworCisgICAgLy8gUGFy dCBvZiB0aGUgcmVjbGFpbWFibGUgc2xhYiBjb25zaXN0cyBvZiBpdGVtcyB0aGF0IGFyZSBpbiB1 c2UsIGFuZCBjYW5ub3QgYmUgZnJlZWQuCisgICAgLy8gQ2FwIHRoaXMgZXN0aW1hdGUgYXQgdGhl IGxvdyB3YXRlcm1hcmsuCisgICAgbWVtb3J5QXZhaWxhYmxlICs9IHNsYWJSZWNsYWltYWJsZSAt IHN0ZDo6bWluKHNsYWJSZWNsYWltYWJsZSAvIDIsIGxvd1dhdGVybWFyayk7CisgICAgcmV0dXJu IG1lbW9yeUF2YWlsYWJsZTsKK30KKworc3RhdGljIGludCBzeXN0ZW1NZW1vcnlVc2VkQXNQZXJj ZW50YWdlKCkKK3sKKyAgICBGSUxFKiBmaWxlID0gZm9wZW4oIi9wcm9jL21lbWluZm8iLCAiciIp OworICAgIGlmICghZmlsZSkKKyAgICAgICAgcmV0dXJuIC0xOworCisgICAgc2l6ZV90IG1lbW9y eUF2YWlsYWJsZSwgbWVtb3J5VG90YWwsIG1lbW9yeUZyZWUsIGFjdGl2ZUZpbGUsIGluYWN0aXZl RmlsZSwgc2xhYlJlY2xhaW1hYmxlOworICAgIG1lbW9yeUF2YWlsYWJsZSA9IG1lbW9yeVRvdGFs ID0gbWVtb3J5RnJlZSA9IGFjdGl2ZUZpbGUgPSBpbmFjdGl2ZUZpbGUgPSBzbGFiUmVjbGFpbWFi bGUgPSBub3RTZXQ7CisgICAgY2hhciBidWZmZXJbMTI4XTsKKyAgICB3aGlsZSAoY2hhciogbGlu ZSA9IGZnZXRzKGJ1ZmZlciwgMTI4LCBmaWxlKSkgeworICAgICAgICBjaGFyKiB0b2tlbiA9IHN0 cnRvayhsaW5lLCAiICIpOworICAgICAgICBpZiAoIXRva2VuKQorICAgICAgICAgICAgYnJlYWs7 CisKKyAgICAgICAgaWYgKCFzdHJjbXAodG9rZW4sICJNZW1BdmFpbGFibGU6IikpIHsKKyAgICAg ICAgICAgIGlmICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpIHsKKyAgICAgICAgICAg ICAgICBtZW1vcnlBdmFpbGFibGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICAgICAgaWYg KG1lbW9yeVRvdGFsICE9IG5vdFNldCkKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIk1lbVRvdGFsOiIp KSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikpKQorICAg ICAgICAgICAgICAgIG1lbW9yeVRvdGFsID0gYXRvbGwodG9rZW4pOworICAgICAgICAgICAgZWxz ZQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9IGVsc2UgaWYgKCFzdHJjbXAodG9r ZW4sICJNZW1GcmVlOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxw dHIsICIgIikpKQorICAgICAgICAgICAgICAgIG1lbW9yeUZyZWUgPSBhdG9sbCh0b2tlbik7Cisg ICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBp ZiAoIXN0cmNtcCh0b2tlbiwgIkFjdGl2ZShmaWxlKToiKSkgeworICAgICAgICAgICAgaWYgKCh0 b2tlbiA9IHN0cnRvayhudWxscHRyLCAiICIpKSkKKyAgICAgICAgICAgICAgICBhY3RpdmVGaWxl ID0gYXRvbGwodG9rZW4pOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGJyZWFr OworICAgICAgICB9IGVsc2UgaWYgKCFzdHJjbXAodG9rZW4sICJJbmFjdGl2ZShmaWxlKToiKSkg eworICAgICAgICAgICAgaWYgKCh0b2tlbiA9IHN0cnRvayhudWxscHRyLCAiICIpKSkKKyAgICAg ICAgICAgICAgICBpbmFjdGl2ZUZpbGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICBlbHNl CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tl biwgIlNSZWNsYWltYWJsZToiKSkgeworICAgICAgICAgICAgaWYgKCh0b2tlbiA9IHN0cnRvayhu dWxscHRyLCAiICIpKSkKKyAgICAgICAgICAgICAgICBzbGFiUmVjbGFpbWFibGUgPSBhdG9sbCh0 b2tlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAg IH0KKworICAgICAgICBpZiAobWVtb3J5VG90YWwgIT0gbm90U2V0ICYmIG1lbW9yeUZyZWUgIT0g bm90U2V0ICYmIGFjdGl2ZUZpbGUgIT0gbm90U2V0ICYmIGluYWN0aXZlRmlsZSAhPSBub3RTZXQg JiYgc2xhYlJlY2xhaW1hYmxlICE9IG5vdFNldCkKKyAgICAgICAgICAgIGJyZWFrOworICAgIH0K KyAgICBmY2xvc2UoZmlsZSk7CisKKyAgICBpZiAobWVtb3J5VG90YWwgPT0gbm90U2V0KQorICAg ICAgICByZXR1cm4gLTE7CisKKyAgICBpZiAobWVtb3J5QXZhaWxhYmxlID09IG5vdFNldCkgewor ICAgICAgICAvLyBJZiBNZW1BdmFpbGFibGUgd2FzIG5vdCBwcmVzZW50IGluIC9wcm9jL21lbWlu Zm8sIGJlY2F1c2UgaXQncyBhbiBvbGQga2VybmVsIHZlcnNpb24sCisgICAgICAgIC8vIHdlIGNh biBkbyB0aGUgc2FtZSBjYWxjdWxhdGlvbiB3aXRoIHRoZSBpbmZvcm1hdGlvbiB3ZSBoYXZlIGZy b20gbWVtaW5mbyBhbmQgdGhlIGxvdyB3YXRlcm1ha3MuCisgICAgICAgIC8vIFNlZSBodHRwczov L2dpdC5rZXJuZWwub3JnL2NnaXQvbGludXgva2VybmVsL2dpdC90b3J2YWxkcy9saW51eC5naXQv Y29tbWl0Lz9pZD0zNGU0MzFiMGFlMzk4ZmM1NGVhNjlmZjg1ZWM3MDA3MjJjOWRhNzczCisgICAg ICAgIG1lbW9yeUF2YWlsYWJsZSA9IGNhbGN1bGF0ZU1lbW9yeUF2YWlsYWJsZShtZW1vcnlGcmVl LCBhY3RpdmVGaWxlLCBpbmFjdGl2ZUZpbGUsIHNsYWJSZWNsYWltYWJsZSk7CisgICAgICAgIGlm IChtZW1vcnlBdmFpbGFibGUgPT0gbm90U2V0KQorICAgICAgICAgICAgcmV0dXJuIC0xOworICAg IH0KKworICAgIHJldHVybiAoKG1lbW9yeVRvdGFsIC0gbWVtb3J5QXZhaWxhYmxlKSAqIDEwMCkg LyBtZW1vcnlUb3RhbDsKK30KKworc3RhdGljIGlubGluZSBkb3VibGUgcG9sbEludGVydmFsRm9y VXNlZE1lbW9yeVBlcmNlbnRhZ2UoaW50IHVzZWRQZXJjZW50YWdlKQoreworICAgIC8vIFVzZSBh IGRpZmZlcmVudCBwb2xsIGludGVydmFsIGRlcGVuZGluZyBvbiB0aGUgY3VycmVudGx5IG1lbW9y eSB1c2VkLAorICAgIC8vIHRvIGF2b2lkIHBvbGxpbmcgdG9vIG9mdGVuIHdoZW4gdGhlIHN5c3Rl bSBpcyB1bmRlciBsb3cgbWVtb3J5IHVzYWdlLgorICAgIGlmICh1c2VkUGVyY2VudGFnZSA8IHNf bWluVXNlZE1lbW9yeVBlcmNlbnRhZ2VGb3JQb2xsaW5nKQorICAgICAgICByZXR1cm4gc19tYXhQ b2xsaW5nSW50ZXJ2YWxJblNlY29uZHM7CisKKyAgICBpZiAodXNlZFBlcmNlbnRhZ2UgPj0gc19t YXhVc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxpbmcpCisgICAgICAgIHJldHVybiBzX21pblBv bGxpbmdJbnRlcnZhbEluU2Vjb25kczsKKworICAgIHJldHVybiBzX21pblBvbGxpbmdJbnRlcnZh bEluU2Vjb25kcyArIChzX21heFBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcyAtIHNfbWluUG9sbGlu Z0ludGVydmFsSW5TZWNvbmRzKSAqCisgICAgICAgICgodXNlZFBlcmNlbnRhZ2UgLSBzX21pblVz ZWRNZW1vcnlQZXJjZW50YWdlRm9yUG9sbGluZykgLyAoc19tYXhVc2VkTWVtb3J5UGVyY2VudGFn ZUZvclBvbGxpbmcgLSBzX21pblVzZWRNZW1vcnlQZXJjZW50YWdlRm9yUG9sbGluZykpOworfQor CitzdGF0aWMgYm9vbCBpc1N5c3RlbWRNZW1vcnlQcmVzc3VyZU1vbml0b3JBdmFpbGFibGUoKQor eworICAgIGludCBmZCA9IG9wZW4oIi9zeXMvZnMvY2dyb3VwL21lbW9yeS9tZW1vcnkucHJlc3N1 cmVfbGV2ZWwiLCBPX0NMT0VYRUMgfCBPX1JET05MWSk7CisgICAgaWYgKGZkID09IC0xKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgY2xvc2UoZmQpOworCisgICAgZmQgPSBvcGVuKCIvc3lz L2ZzL2Nncm91cC9tZW1vcnkvY2dyb3VwLmV2ZW50X2NvbnRyb2wiLCBPX0NMT0VYRUMgfCBPX1dS T05MWSk7CisgICAgaWYgKGZkID09IC0xKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgY2xv c2UoZmQpOworCisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgTWVtb3J5UHJlc3N1cmVNb25p dG9yOjppc0VuYWJsZWQoKQoreworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBvbmNlRmxhZzsK KyAgICBzdGF0aWMgYm9vbCBlbmFibGVkOworICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2VGbGFnLCBb XSB7IGVuYWJsZWQgPSAhaXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25pdG9yQXZhaWxhYmxlKCk7 IH0pOworICAgIHJldHVybiBlbmFibGVkOworfQorCitNZW1vcnlQcmVzc3VyZU1vbml0b3ImIE1l bW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xldG9uKCkKK3sKKyAgICBBU1NFUlQoaXNFbmFibGVk KCkpOworICAgIHN0YXRpYyBOZXZlckRlc3Ryb3llZDxNZW1vcnlQcmVzc3VyZU1vbml0b3I+IG1l bW9yeU1vbml0b3I7CisgICAgcmV0dXJuIG1lbW9yeU1vbml0b3I7Cit9CisKK01lbW9yeVByZXNz dXJlTW9uaXRvcjo6TWVtb3J5UHJlc3N1cmVNb25pdG9yKCkKKyAgICA6IG1fZXZlbnRGRChldmVu dGZkKDAsIEVGRF9DTE9FWEVDKSkKK3sKKyAgICBpZiAobV9ldmVudEZEID09IC0xKQorICAgICAg ICByZXR1cm47CisKKyAgICBUaHJlYWRJZGVudGlmaWVyIHRocmVhZElkZW50aWZpZXIgPSBjcmVh dGVUaHJlYWQoIk1lbW9yeVByZXNzdXJlTW9uaXRvciIsIFt0aGlzXSB7CisgICAgICAgIGRvdWJs ZSBwb2xsSW50ZXJ2YWwgPSBzX21heFBvbGxpbmdJbnRlcnZhbEluU2Vjb25kczsKKyAgICAgICAg d2hpbGUgKHRydWUpIHsKKyAgICAgICAgICAgIHNsZWVwKHBvbGxJbnRlcnZhbCk7CisKKyAgICAg ICAgICAgIGludCB1c2VkUGVyY2VudGFnZSA9IHN5c3RlbU1lbW9yeVVzZWRBc1BlcmNlbnRhZ2Uo KTsKKyAgICAgICAgICAgIGlmICh1c2VkUGVyY2VudGFnZSA+PSBzX21lbW9yeVByZXN1cmVQZXJj ZW50YWdlVGhyZXNob2xkKSB7CisgICAgICAgICAgICAgICAgdWludDY0X3QgZmRFdmVudCA9IDE7 CisgICAgICAgICAgICAgICAgd3JpdGUobV9ldmVudEZELCAmZmRFdmVudCwgc2l6ZW9mKHVpbnQ2 NF90KSk7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBwb2xsSW50ZXJ2YWwgPSBwb2xsSW50 ZXJ2YWxGb3JVc2VkTWVtb3J5UGVyY2VudGFnZSh1c2VkUGVyY2VudGFnZSk7CisgICAgICAgIH0K KyAgICAgICAgY2xvc2UobV9ldmVudEZEKTsKKyAgICB9KTsKKyAgICBkZXRhY2hUaHJlYWQodGhy ZWFkSWRlbnRpZmllcik7Cit9CisKK0lQQzo6QXR0YWNobWVudCBNZW1vcnlQcmVzc3VyZU1vbml0 b3I6OmNyZWF0ZUhhbmRsZSgpIGNvbnN0Cit7CisgICAgaW50IGR1cGxpY2F0ZWRIYW5kbGUgPSBk dXBDbG9zZU9uRXhlYyhtX2V2ZW50RkQpOworICAgIGlmIChkdXBsaWNhdGVkSGFuZGxlID09IC0x KQorICAgICAgICByZXR1cm4geyB9OworICAgIHJldHVybiBJUEM6OkF0dGFjaG1lbnQoZHVwbGlj YXRlZEhhbmRsZSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gT1Mo TElOVVgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5 UHJlc3N1cmVNb25pdG9yLmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbGludXgvTWVtb3J5 UHJlc3N1cmVNb25pdG9yLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzg3 NGQ5MAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9saW51eC9N ZW1vcnlQcmVzc3VyZU1vbml0b3IuaApAQCAtMCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICog QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgT1Mo TElOVVgpCisKKyNpbmNsdWRlIDx3dGYvTmV2ZXJEZXN0cm95ZWQuaD4KKyNpbmNsdWRlIDx3dGYv Tm9uY29weWFibGUuaD4KKworbmFtZXNwYWNlIElQQyB7CitjbGFzcyBBdHRhY2htZW50OworfQor CituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgTWVtb3J5UHJlc3N1cmVNb25pdG9yIHsKKyAg ICBXVEZfTUFLRV9OT05DT1BZQUJMRShNZW1vcnlQcmVzc3VyZU1vbml0b3IpOworICAgIGZyaWVu ZCBjbGFzcyBOZXZlckRlc3Ryb3llZDxNZW1vcnlQcmVzc3VyZU1vbml0b3I+OworcHVibGljOgor ICAgIHN0YXRpYyBNZW1vcnlQcmVzc3VyZU1vbml0b3ImIHNpbmdsZXRvbigpOworICAgIHN0YXRp YyBib29sIGlzRW5hYmxlZCgpOworCisgICAgfk1lbW9yeVByZXNzdXJlTW9uaXRvcigpOworCisg ICAgSVBDOjpBdHRhY2htZW50IGNyZWF0ZUhhbmRsZSgpIGNvbnN0OworCitwcml2YXRlOgorICAg IE1lbW9yeVByZXNzdXJlTW9uaXRvcigpOworCisgICAgaW50IG1fZXZlbnRGRCB7IC0xIH07Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIE9TKExJTlVYKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcCBiL1NvdXJjZS9X ZWJLaXQyL1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHAKaW5kZXggMTJkYWQwYi4uZWIxNmYyNCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwCkBAIC0yNjYsNyArMjY2 LDkgQEAgdm9pZCBXZWJQcm9jZXNzOjppbml0aWFsaXplV2ViUHJvY2VzcyhXZWJQcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1ldGVycykKICAgICBBU1NFUlQobV9wYWdlTWFwLmlzRW1w dHkoKSk7CiAKICNpZiBPUyhMSU5VWCkKLSAgICBXZWJDb3JlOjpNZW1vcnlQcmVzc3VyZUhhbmRs ZXI6OlJlbGllZkxvZ2dlcjo6c2V0TG9nZ2luZ0VuYWJsZWQocGFyYW1ldGVycy5zaG91bGRFbmFi bGVNZW1vcnlQcmVzc3VyZVJlbGllZkxvZ2dpbmcpOworICAgIGlmIChwYXJhbWV0ZXJzLm1lbW9y eVByZXNzdXJlTW9uaXRvckhhbmRsZS5maWxlRGVzY3JpcHRvcigpICE9IC0xKQorICAgICAgICBN ZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmdsZXRvbigpLnNldE1lbW9yeVByZXNzdXJlTW9uaXRv ckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZS5yZWxlYXNlRmls ZURlc2NyaXB0b3IoKSk7CisgICAgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpSZWxpZWZMb2dnZXI6 OnNldExvZ2dpbmdFbmFibGVkKHBhcmFtZXRlcnMuc2hvdWxkRW5hYmxlTWVtb3J5UHJlc3N1cmVS ZWxpZWZMb2dnaW5nKTsKICNlbmRpZgogCiAgICAgcGxhdGZvcm1Jbml0aWFsaXplV2ViUHJvY2Vz cyhXVEZNb3ZlKHBhcmFtZXRlcnMpKTsK 283624 2016-07-14 01:23:34 -0700 2016-07-18 01:34:01 -0700 Try to fix builds wk2-memory-pressure-linux.diff text/plain 35360 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1NzZiMTZkLi4xNDUyYmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTYtMDctMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIE1lbW9yeVByZXNzdXJlSGFuZGxlciBkb2Vzbid0IHdvcmsgaWYgY2dyb3Vw cyBhcmVuJ3QgcHJlc2VudCBpbiBMaW51eAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTU1MjU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWxsb3cgdG8gcGFzcyBhbiBldmVudEZEIGZpbGUgZGVzY3JpcHRv ciB0byB0aGUgTWVtb3J5UHJlc3N1cmVIYW5kbGVyIHRvIGJlIG1vbml0b3JpemVkIGluIGNhc2Ug Y2dyb3VwcyBhcmUgbm90CisgICAgICAgIGF2YWlsYWJsZS4KKworICAgICAgICAqIHBsYXRmb3Jt L01lbW9yeVByZXNzdXJlSGFuZGxlci5oOgorICAgICAgICAqIHBsYXRmb3JtL2xpbnV4L01lbW9y eVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcDoKKwogMjAxNi0wNy0xMyAgQ2FybG9zIEdhcmNpYSBD YW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0dMaWJdIFVzZSBhIEdTb3Vy Y2UgaW5zdGVhZCBvZiBhIHRocmVhZCB0byBwb2xsIG1lbW9yeSBwcmVzc3VyZSBldmVudEZEIGlu IGxpbnV4IGltcGxlbWVudGF0aW9uCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9NZW1vcnlQcmVzc3VyZUhhbmRsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9y eVByZXNzdXJlSGFuZGxlci5oCmluZGV4IDAxZmQ4MTQuLjhiMDRkNDggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVByZXNzdXJlSGFuZGxlci5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL01lbW9yeVByZXNzdXJlSGFuZGxlci5oCkBAIC04NCw2ICs4NCw4 IEBAIHB1YmxpYzoKICAgICBXRUJDT1JFX0VYUE9SVCB2b2lkIGNsZWFyTWVtb3J5UHJlc3N1cmUo KTsKICAgICBXRUJDT1JFX0VYUE9SVCBib29sIHNob3VsZFdhaXRGb3JNZW1vcnlDbGVhck1lc3Nh Z2UoKTsKICAgICB2b2lkIHJlc3BvbmRUb01lbW9yeVByZXNzdXJlSWZOZWVkZWQoKTsKKyNlbGlm IE9TKExJTlVYKQorICAgIHZvaWQgc2V0TWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlKGludCBm ZCk7CiAjZW5kaWYKIAogICAgIGNsYXNzIFJlbGllZkxvZ2dlciB7CkBAIC0xNzksNiArMTgxLDcg QEAgcHJpdmF0ZToKICAgICBSdW5Mb29wOjpUaW1lcjxNZW1vcnlQcmVzc3VyZUhhbmRsZXI+IG1f aG9sZE9mZlRpbWVyOwogICAgIHZvaWQgaG9sZE9mZlRpbWVyRmlyZWQoKTsKICAgICB2b2lkIGxv Z0Vycm9yQW5kQ2xvc2VGRHMoY29uc3QgY2hhciogZXJyb3IpOworICAgIGJvb2wgdHJ5RW5zdXJl RXZlbnRGRCgpOwogI2VuZGlmCiB9OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9saW51eC9NZW1vcnlQcmVzc3VyZUhhbmRsZXJMaW51eC5jcHAKaW5kZXggMTJj NjE4Ni4uYjIzNTcwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbGludXgv TWVtb3J5UHJlc3N1cmVIYW5kbGVyTGludXguY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2xpbnV4L01lbW9yeVByZXNzdXJlSGFuZGxlckxpbnV4LmNwcApAQCAtMTkzLDI5ICsxOTMs MzAgQEAgaW5saW5lIHZvaWQgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpsb2dFcnJvckFuZENsb3Nl RkRzKGNvbnN0IGNoYXIqIGxvZykKICAgICB9CiB9CiAKLXZvaWQgTWVtb3J5UHJlc3N1cmVIYW5k bGVyOjppbnN0YWxsKCkKK2Jvb2wgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjp0cnlFbnN1cmVFdmVu dEZEKCkKIHsKLSAgICBpZiAobV9pbnN0YWxsZWQgfHwgbV9ob2xkT2ZmVGltZXIuaXNBY3RpdmUo KSkKLSAgICAgICAgcmV0dXJuOworICAgIGlmIChtX2V2ZW50RkQpCisgICAgICAgIHJldHVybiB0 cnVlOwogCisgICAgLy8gVHJ5IHRvIHVzZSBjZ3JvdXBzIGluc3RlYWQuCiAgICAgaW50IGZkID0g ZXZlbnRmZCgwLCBFRkRfQ0xPRVhFQyk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIExP RyhNZW1vcnlQcmVzc3VyZSwgImV2ZW50ZmQoKSBmYWlsZWQ6ICVtIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBtX2V2ZW50RkQgPSBmZDsKIAog ICAgIGZkID0gb3BlbihzX2Nncm91cE1lbW9yeVByZXNzdXJlTGV2ZWwsIE9fQ0xPRVhFQyB8IE9f UkRPTkxZKTsKICAgICBpZiAoZmQgPT0gLTEpIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZE cygiRmFpbGVkIHRvIG9wZW4gbWVtb3J5LnByZXNzdXJlX2xldmVsIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KICAgICBtX3ByZXNzdXJlTGV2ZWxGRCA9 IGZkOwogCiAgICAgZmQgPSBvcGVuKHNfY2dyb3VwRXZlbnRDb250cm9sLCBPX0NMT0VYRUMgfCBP X1dST05MWSk7CiAgICAgaWYgKGZkID09IC0xKSB7CiAgICAgICAgIGxvZ0Vycm9yQW5kQ2xvc2VG RHMoIkZhaWxlZCB0byBvcGVuIGNncm91cC5ldmVudF9jb250cm9sIik7Ci0gICAgICAgIHJldHVy bjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0KIAogICAgIGNoYXIgbGluZVsxMjhdID0g ezAsIH07CkBAIC0yMjMsMTAgKzIyNCwyMSBAQCB2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6 aW5zdGFsbCgpCiAgICAgICAgIHx8IHdyaXRlKGZkLCBsaW5lLCBzdHJsZW4obGluZSkgKyAxKSA8 IDApIHsKICAgICAgICAgbG9nRXJyb3JBbmRDbG9zZUZEcygiRmFpbGVkIHRvIHdyaXRlIGNncm91 cC5ldmVudF9jb250cm9sIik7CiAgICAgICAgIGNsb3NlKGZkKTsKLSAgICAgICAgcmV0dXJuOwor ICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQogICAgIGNsb3NlKGZkKTsKIAorICAgIHJldHVy biB0cnVlOworfQorCit2b2lkIE1lbW9yeVByZXNzdXJlSGFuZGxlcjo6aW5zdGFsbCgpCit7Cisg ICAgaWYgKG1faW5zdGFsbGVkIHx8IG1faG9sZE9mZlRpbWVyLmlzQWN0aXZlKCkpCisgICAgICAg IHJldHVybjsKKworICAgIGlmICghdHJ5RW5zdXJlRXZlbnRGRCgpKQorICAgICAgICByZXR1cm47 CisKICAgICBtX2V2ZW50RkRQb2xsZXIgPSBzdGQ6Om1ha2VfdW5pcXVlPEV2ZW50RkRQb2xsZXI+ KG1fZXZlbnRGRC52YWx1ZSgpLCBbdGhpc10gewogICAgICAgICAvLyBGSVhNRTogQ3VycmVudCBt ZW1jZyBkb2VzIG5vdCBwcm92aWRlIGFueSB3YXkgZm9yIHVzZXJzIHRvIGtub3cgaG93IHNlcmlv dXMgdGhlIG1lbW9yeSBwcmVzc3VyZSBpcy4KICAgICAgICAgLy8gU28gd2UgYXNzdW1lIGFsbCBu b3RpZmljYXRpb25zIGZyb20gbWVtY2cgYXJlIGNyaXRpY2FsIGZvciBub3cuIElmIG1lbWNnIGhh ZCBiZXR0ZXIgaW5mZXJmYWNlcwpAQCAtMjU3LDcgKzI2OSwxNyBAQCB2b2lkIE1lbW9yeVByZXNz dXJlSGFuZGxlcjo6dW5pbnN0YWxsKCkKICAgICBtX2hvbGRPZmZUaW1lci5zdG9wKCk7CiAgICAg bV9ldmVudEZEUG9sbGVyID0gbnVsbHB0cjsKIAotICAgIGxvZ0Vycm9yQW5kQ2xvc2VGRHMobnVs bHB0cik7CisgICAgaWYgKG1fcHJlc3N1cmVMZXZlbEZEKSB7CisgICAgICAgIGNsb3NlKG1fcHJl c3N1cmVMZXZlbEZELnZhbHVlKCkpOworICAgICAgICBtX3ByZXNzdXJlTGV2ZWxGRCA9IE51bGxv cHQ7CisKKyAgICAgICAgLy8gT25seSBjbG9zZSB0aGUgZXZlbnRGRCB1c2VkIGZvciBjZ3JvdXBz LgorICAgICAgICBpZiAobV9ldmVudEZEKSB7CisgICAgICAgICAgICBjbG9zZShtX2V2ZW50RkQu dmFsdWUoKSk7CisgICAgICAgICAgICBtX2V2ZW50RkQgPSBOdWxsb3B0OworICAgICAgICB9Cisg ICAgfQorCiAgICAgbV9pbnN0YWxsZWQgPSBmYWxzZTsKIH0KIApAQCAtMzA5LDYgKzMzMSwxMiBA QCBzaXplX3QgTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpSZWxpZWZMb2dnZXI6OnBsYXRmb3JtTWVt b3J5VXNhZ2UoKQogICAgIHJldHVybiB2bVNpemU7CiB9CiAKK3ZvaWQgTWVtb3J5UHJlc3N1cmVI YW5kbGVyOjpzZXRNZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUoaW50IGZkKQoreworICAgIEFT U0VSVCghbV9ldmVudEZEKTsKKyAgICBtX2V2ZW50RkQgPSBmZDsKK30KKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gT1MoTElOVVgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKaW5kZXggZGNlYTkxZS4u Mzk3Njg3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQyL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY4IEBACisyMDE2LTA3LTAxICBDYXJsb3Mg R2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKworICAgICAgICBNZW1vcnlQcmVz c3VyZUhhbmRsZXIgZG9lc24ndCB3b3JrIGlmIGNncm91cHMgYXJlbid0IHByZXNlbnQgaW4gTGlu dXgKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTI1 NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZXJl J3Mgbm8gd2F5IHRvIGdldCBub3RpZmljYXRpb25zIGFib3V0IG1lbW9yeSBwcmVzc3VyZSBpbiBM aW51eCB3aXRob3V0IHVzaW5nIGNncm91cHMgdGhhdCBkb2Vzbid0IHJlcXVpcmUgYQorICAgICAg ICBtYW51YWwgcG9sbGluZy4gV2UgY2FuIGdldCB0aGF0IGluZm9ybWF0aW9uIGZyb20gL3Byb2Mv bWVtaW5mbywgYnV0IHRoYXQncyBub3QgcG9sbGFibGUgc28gaXQgcmVxdWlyZXMgdG8KKyAgICAg ICAgbWFudWFsbHkgY2hlY2sgaXRzIGNvbnRlbnRzIGluIGEgbG9vcCBzbGVlcGluZyBmb3IgYSB3 aGlsZSBiZXR3ZWVuIGNoZWNrcy4gVGhpcyBtZWFucyB3ZSB3b3VsZCBiZSB3YWtpbmcgdXAgdGhl CisgICAgICAgIHByb2Nlc3Mgb24gZXZlcnkgcG9sbCBpdGVyYXRpb24sIG1vc3Qgb2YgdGhlIHRp bWVzIGZvciBub3RoaW5nLiBUaGF0J3Mgc3BlY2lhbGx5IHByb2JsZW1hdGljIG9uIGRldmljZXMg cnVubmluZworICAgICAgICBvbiBiYXR0ZXJ5LiBBbmQgdGFraW5nIGludG8gYWNjb3VudCB0aGF0 IHRoZXJlJ3MgYSBtZW1vcnkgcHJlc3N1cmUgaGFuZGxlciBpbiBldmVyeSBzZWNvbmRhcnkgcHJv Y2VzcyAoV2ViLAorICAgICAgICBOZXR3b3JrIGFuZCBQbHVnaW4pLCB3ZSB3b3VsZCBiZSB3YWtp bmcgdXAgYWxsIHRob3NlIHByb2Nlc3MgYWxsIHRoZSB0aW1lLiBIb3dldmVyLCBub3QgaGF2aW5n IGEgbWVtb3J5IHByZXNzdXJlCisgICAgICAgIGhhbmRsZXIgaXMgZXZlbiBtb3JlIHByb2JsZW1h dGljIHRoYW4gdGhlIG1hbnVhbCBwb2xsaW5nLgorICAgICAgICBUaGlzIHBhdGNoIGFkZHMgYSBj bGFzcyBNZW1vcnlQcmVzc3VyZU1vbml0b3IgdG8gdGhlIG1hbnVhbCBwb2xsaW5nIG9mIC9wcm9j L21lbWluZm8sIGJ1dCBydW5zIGluIHRoZSBVSQorICAgICAgICBwcm9jZXNzLCB0byBhdm9pZCB0 aGUgd2Vha3VwcyBpbiBhbGwgb3RoZXIgc2Vjb25kYXJ5IHByb2Nlc3NlcywgYW5kIHVzZXMgYW4g ZXZlbnRGRCB0byBub3RpZnkgYWxsIG90aGVyCisgICAgICAgIHByb2Nlc3Nlcy4gSXQncyBvbmx5 IHVzZWQgaW4gY2FzZSBjZ3JvdXBzIGlzIG5vdCBhdmFpbGFibGUuIFRoZSBldmVudEZEIGRlc2Ny aXB0b3IgaXMgc2VudCB0byBhbGwgb3RoZXIKKyAgICAgICAgcHJvY2Vzc2VzIGF0IHN0YXJ0dXAs IGFuZCBwYXNzZWQgdG8gdGhlIE1lbW9yeVByZXNzdXJlSGFuZGxlciBiZWZvcmUgaW5zdGFsbCgp IGlzIGNhbGxlZCBmb3IgdGhlIGZpcnN0CisgICAgICAgIHRpbWUuIFRvIG1pbmltaXplIHRoZSB3 YWtldXBzIGV2ZW4gaW4gdGhlIFVJIHByb2Nlc3MsIHRoZSBwb2xsIGludGVydmFsIGlzIGNhbGN1 bGF0ZWQgZnJvbSAxIHRvIDUgc2Vjb25kcworICAgICAgICBkZXBlbmRpbmcgb24gdGhlIGN1cnJl bnQgbWVtb3J5IHVzZWQsIHNvIGluIGNhc2Ugb2YgbG93IG1lbW9yeSBsZXZlbCB3ZSBzbGVlcCBm b3IgYSBsb25nZXIgdGltZS4KKyAgICAgICAgSXQncyBhbHNvIGltcG9ydGFudCB0byBtYWtlIHRo ZSBtZW1vcnkgY2FsY3VsYXRpb25zIGFzIGFjY3VyYXRlIGFzIHBvc3NpYmxlIHRvIGF2b2lkIGNs ZWFuaW5nIHJlc291cmNlcyBpbiB0aGUKKyAgICAgICAgc2Vjb25kYXJ5IHByb2Nlc3NlcyB1bm5l Y2Vzc2FyaWx5LgorCisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3Bw OgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzczo6aW5pdGlhbGl6ZU5ldHdvcmtQcm9j ZXNzKTogUGFzcyB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgZmlsZSBkZXNjcmlwdG9yIHRv IHRoZSBNZW1vcnlQcmVzc3VyZUhhbmRsZXIuCisgICAgICAgICogTmV0d29ya1Byb2Nlc3MvTmV0 d29ya1Byb2Nlc3MuaDoKKyAgICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycy5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5ldHdvcmtQcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3Ig aGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy czo6ZGVjb2RlKTogRGVjb2RlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZS4KKyAgICAg ICAgKiBOZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oOgor ICAgICAgICAqIFBsYXRmb3JtRWZsLmNtYWtlOiBBZGQgbmV3IGZpbGUgdG8gY29tcGlsYXRpb24s IGFuZCB1cGRhdGUgaW5jbHVkZSBkaXJzLgorICAgICAgICAqIFBsYXRmb3JtR1RLLmNtYWtlOiBE aXR0by4KKyAgICAgICAgKiBQbHVnaW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwOgorICAgICAg ICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzOjppbml0aWFsaXplUGx1Z2luUHJvY2Vzcyk6IFBhc3Mg dGhlIG1lbW9yeSBwcmVzc3VyZSBtb25pdG9yIGZpbGUgZGVzY3JpcHRvciB0byB0aGUgTWVtb3J5 UHJlc3N1cmVIYW5kbGVyLgorICAgICAgICAqIFNoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwOgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUpOiBFbmNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3Ig aGFuZGxlLgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjpkZWNvZGUpOiBEZWNvZGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlLgorICAgICAg ICAqIFNoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaDoKKyAg ICAgICAgKiBTaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHA6CisgICAgICAg IChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmVuY29kZSk6IEVuY29kZSBt ZW1vcnkgcHJlc3N1cmUgbW9uaXRvciBoYW5kbGUuCisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZSk6IERlY29kZSBtZW1vcnkgcHJlc3N1cmUgbW9u aXRvciBoYW5kbGUuCisgICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzUHJveHkuY3Bw OgorICAgICAgICAoV2ViS2l0OjpQbHVnaW5Qcm9jZXNzUHJveHk6OmRpZEZpbmlzaExhdW5jaGlu Zyk6IENyZWF0ZSB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxlIGZvciB0aGUgcGx1 Z2luCisgICAgICAgIHByb2Nlc3MgaWYgbmVlZGVkLgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQ cm9jZXNzUG9vbC5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQb29sOjplbnN1cmVO ZXR3b3JrUHJvY2Vzcyk6IENyZWF0ZSB0aGUgbWVtb3J5IHByZXNzdXJlIG1vbml0b3IgaGFuZGxl IGZvciB0aGUgbmV0d29yaworICAgICAgICBwcm9jZXNzIGlmIG5lZWRlZC4KKyAgICAgICAgKFdl YktpdDo6V2ViUHJvY2Vzc1Bvb2w6OmNyZWF0ZU5ld1dlYlByb2Nlc3MpOiBDcmVhdGUgdGhlIG1l bW9yeSBwcmVzc3VyZSBtb25pdG9yIGhhbmRsZSBmb3IgdGhlIHdlYiBwcm9jZXNzIGlmCisgICAg ICAgIG5lZWRlZC4KKyAgICAgICAgKiBVSVByb2Nlc3MvbGludXgvTWVtb3J5UHJlc3N1cmVNb25p dG9yLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6Omxvd1dhdGVybWFya1BhZ2VzKToKKyAg ICAgICAgKFdlYktpdDo6c3lzdGVtUGFnZVNpemUpOgorICAgICAgICAoV2ViS2l0OjpjYWxjdWxh dGVNZW1vcnlBdmFpbGFibGUpOgorICAgICAgICAoV2ViS2l0OjpzeXN0ZW1NZW1vcnlVc2VkQXNQ ZXJjZW50YWdlKToKKyAgICAgICAgKFdlYktpdDo6cG9sbEludGVydmFsRm9yVXNlZE1lbW9yeVBl cmNlbnRhZ2UpOgorICAgICAgICAoV2ViS2l0Ojppc1N5c3RlbWRNZW1vcnlQcmVzc3VyZU1vbml0 b3JBdmFpbGFibGUpOgorICAgICAgICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6Omlz RW5hYmxlZCk6CisgICAgICAgIChXZWJLaXQ6Ok1lbW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xl dG9uKToKKyAgICAgICAgKFdlYktpdDo6TWVtb3J5UHJlc3N1cmVNb25pdG9yOjpNZW1vcnlQcmVz c3VyZU1vbml0b3IpOgorICAgICAgICAoV2ViS2l0OjpNZW1vcnlQcmVzc3VyZU1vbml0b3I6OmNy ZWF0ZUhhbmRsZSk6CisgICAgICAgICogVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9u aXRvci5oOgorICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHA6CisgICAgICAgIChX ZWJLaXQ6OldlYlByb2Nlc3M6OmluaXRpYWxpemVXZWJQcm9jZXNzKTogUGFzcyB0aGUgbWVtb3J5 IHByZXNzdXJlIG1vbml0b3IgZmlsZSBkZXNjcmlwdG9yIHRvIHRoZSBNZW1vcnlQcmVzc3VyZUhh bmRsZXIuCisKIDIwMTYtMDctMTMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2Fs aWEuY29tPgogCiAgICAgICAgIFJFR1JFU1NJT04ocjIwMjI3Myk6IFtHVEtdIFJlZGlyZWN0ZWQg WCB3aW5kb3cgaXMgcmVzaXplZCB0byB0aGUgcHJldmlvdXMgc2l6ZSBvbiBzaXplIGFsbG9jYXRl CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vz cy5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzcy5jcHAK aW5kZXggODk1MzkzYy4uYTJhZDBkNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQ cm9jZXNzL05ldHdvcmtQcm9jZXNzLmNwcApAQCAtMTkzLDcgKzE5Myw3IEBAIHZvaWQgTmV0d29y a1Byb2Nlc3M6Omxvd01lbW9yeUhhbmRsZXIoQ3JpdGljYWwgY3JpdGljYWwpCiAgICAgV1RGOjpy ZWxlYXNlRmFzdE1hbGxvY0ZyZWVNZW1vcnkoKTsKIH0KIAotdm9pZCBOZXR3b3JrUHJvY2Vzczo6 aW5pdGlhbGl6ZU5ldHdvcmtQcm9jZXNzKGNvbnN0IE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJh bWV0ZXJzJiBwYXJhbWV0ZXJzKQordm9pZCBOZXR3b3JrUHJvY2Vzczo6aW5pdGlhbGl6ZU5ldHdv cmtQcm9jZXNzKE5ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiYgcGFyYW1ldGVycykK IHsKICAgICBwbGF0Zm9ybUluaXRpYWxpemVOZXR3b3JrUHJvY2VzcyhwYXJhbWV0ZXJzKTsKIApA QCAtMjAyLDYgKzIwMiwxMCBAQCB2b2lkIE5ldHdvcmtQcm9jZXNzOjppbml0aWFsaXplTmV0d29y a1Byb2Nlc3MoY29uc3QgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZQogICAgIG1fc3VwcHJl c3NNZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBwYXJhbWV0ZXJzLnNob3VsZFN1cHByZXNzTWVtb3J5 UHJlc3N1cmVIYW5kbGVyOwogICAgIGlmICghbV9zdXBwcmVzc01lbW9yeVByZXNzdXJlSGFuZGxl cikgewogICAgICAgICBhdXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQcmVzc3Vy ZUhhbmRsZXI6OnNpbmdsZXRvbigpOworI2lmIE9TKExJTlVYKQorICAgICAgICBpZiAocGFyYW1l dGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUuZmlsZURlc2NyaXB0b3IoKSAhPSAtMSkK KyAgICAgICAgICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRNZW1vcnlQcmVzc3VyZU1vbml0 b3JIYW5kbGUocGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUucmVsZWFzZUZp bGVEZXNjcmlwdG9yKCkpOworI2VuZGlmCiAgICAgICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5z ZXRMb3dNZW1vcnlIYW5kbGVyKFt0aGlzXSAoQ3JpdGljYWwgY3JpdGljYWwsIFN5bmNocm9ub3Vz KSB7CiAgICAgICAgICAgICBsb3dNZW1vcnlIYW5kbGVyKGNyaXRpY2FsKTsKICAgICAgICAgfSk7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vz cy5oIGIvU291cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3MuaAppbmRl eCBjODk3OTk4Li5iNzMyNTE3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJv Y2Vzcy9OZXR3b3JrUHJvY2Vzcy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdvcmtQcm9jZXNz L05ldHdvcmtQcm9jZXNzLmgKQEAgLTE1OSw3ICsxNTksNyBAQCBwcml2YXRlOgogICAgIC8vIE1l c3NhZ2UgSGFuZGxlcnMKICAgICB2b2lkIGRpZFJlY2VpdmVOZXR3b3JrUHJvY2Vzc01lc3NhZ2Uo SVBDOjpDb25uZWN0aW9uJiwgSVBDOjpNZXNzYWdlRGVjb2RlciYpOwogICAgIHZvaWQgZGlkUmVj ZWl2ZVN5bmNOZXR3b3JrUHJvY2Vzc01lc3NhZ2UoSVBDOjpDb25uZWN0aW9uJiwgSVBDOjpNZXNz YWdlRGVjb2RlciYsIHN0ZDo6dW5pcXVlX3B0cjxJUEM6Ok1lc3NhZ2VFbmNvZGVyPiYpOwotICAg IHZvaWQgaW5pdGlhbGl6ZU5ldHdvcmtQcm9jZXNzKGNvbnN0IE5ldHdvcmtQcm9jZXNzQ3JlYXRp b25QYXJhbWV0ZXJzJik7CisgICAgdm9pZCBpbml0aWFsaXplTmV0d29ya1Byb2Nlc3MoTmV0d29y a1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJik7CiAgICAgdm9pZCBjcmVhdGVOZXR3b3JrQ29u bmVjdGlvblRvV2ViUHJvY2VzcygpOwogICAgIHZvaWQgZGVzdHJveVByaXZhdGVCcm93c2luZ1Nl c3Npb24oV2ViQ29yZTo6U2Vzc2lvbklEKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv TmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291 cmNlL1dlYktpdDIvTmV0d29ya1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMuY3BwCmluZGV4IGI0OGZkMDAuLmJjMzU0MDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQy L05ldHdvcmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5jcHAKQEAgLTgyLDYgKzgyLDkgQEAgdm9pZCBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVyczo6ZW5jb2RlKElQQzo6QXJndW1lbnRFbmNvZGVyJiBlbmNvZGVyKSBjb24KICAg ICBlbmNvZGVyIDw8IGlnbm9yZVRMU0Vycm9yczsKICAgICBlbmNvZGVyIDw8IGxhbmd1YWdlczsK ICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVtb3J5UHJlc3N1cmVNb25p dG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnM6OmRlY29kZShJUEM6OkFyZ3VtZW50RGVjb2RlciYgZGVjb2RlciwgTmV0d29ya1Byb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMmIHJlc3VsdCkKQEAgLTE1OCw2ICsxNjEsMTEgQEAgYm9vbCBO ZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNv ZGVyJiBkZWNvZGVyLCBOZXQKICAgICAgICAgcmV0dXJuIGZhbHNlOwogI2VuZGlmCiAKKyNpZiBP UyhMSU5VWCkKKyAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHJlc3VsdC5tZW1vcnlQcmVzc3VyZU1v bml0b3JIYW5kbGUpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKKwogICAgIHJldHVy biB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9O ZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdDIvTmV0d29y a1Byb2Nlc3MvTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCA0YTU4ZTRh Li41Njg4MTk0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9OZXR3b3JrUHJvY2Vzcy9OZXR3 b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL05ldHdv cmtQcm9jZXNzL05ldHdvcmtQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKQEAgLTI2LDYgKzI2 LDcgQEAKICNpZm5kZWYgTmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnNfaAogI2RlZmlu ZSBOZXR3b3JrUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVyc19oCiAKKyNpbmNsdWRlICJBdHRhY2ht ZW50LmgiCiAjaW5jbHVkZSAiQ2FjaGVNb2RlbC5oIgogI2luY2x1ZGUgIlNhbmRib3hFeHRlbnNp b24uaCIKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CkBAIC05NSw2ICs5NiwxMCBAQCBzdHJ1Y3Qg TmV0d29ya1Byb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMgewogICAgIGJvb2wgaWdub3JlVExTRXJy b3JzOwogICAgIFZlY3RvcjxTdHJpbmc+IGxhbmd1YWdlczsKICNlbmRpZgorCisjaWYgT1MoTElO VVgpCisgICAgSVBDOjpBdHRhY2htZW50IG1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRsZTsKKyNl bmRpZgogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0Mi9QbGF0Zm9ybUVmbC5jbWFrZSBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtl CmluZGV4IDEwODU2YzguLjIwMjBmYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1BsYXRm b3JtRWZsLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtRWZsLmNtYWtlCkBAIC0x NzEsNiArMTcxLDggQEAgbGlzdChBUFBFTkQgV2ViS2l0Ml9TT1VSQ0VTCiAgICAgVUlQcm9jZXNz L2dzdHJlYW1lci9JbnN0YWxsTWlzc2luZ01lZGlhUGx1Z2luc1Blcm1pc3Npb25SZXF1ZXN0LmNw cAogICAgIFVJUHJvY2Vzcy9nc3RyZWFtZXIvV2ViUGFnZVByb3h5R1N0cmVhbWVyLmNwcAogCisg ICAgVUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHAKKwogICAgIFVJUHJv Y2Vzcy9zb3VwL1dlYkNvb2tpZU1hbmFnZXJQcm94eVNvdXAuY3BwCiAgICAgVUlQcm9jZXNzL3Nv dXAvV2ViUHJvY2Vzc1Bvb2xTb3VwLmNwcAogCkBAIC0yNTYsNiArMjU4LDcgQEAgbGlzdChBUFBF TkQgV2ViS2l0Ml9JTkNMVURFX0RJUkVDVE9SSUVTCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJv Y2Vzcy9Db29yZGluYXRlZEdyYXBoaWNzIgogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3Mv TmV0d29yay9DdXN0b21Qcm90b2NvbHMvc291cCIKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9j ZXNzL2VmbCIKKyAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL2xpbnV4IgogICAgICIke1dF QktJVDJfRElSfS9VSVByb2Nlc3Mvc291cCIKICAgICAiJHtXRUJLSVQyX0RJUn0vV2ViUHJvY2Vz cy9lZmwiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1dlYlByb2Nlc3Mvc291cCIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQyL1BsYXRmb3JtR1RLLmNtYWtlIGIvU291cmNlL1dlYktpdDIvUGxhdGZv cm1HVEsuY21ha2UKaW5kZXggYjNjMmFkYi4uZmQyMTY4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvUGxhdGZvcm1HVEsuY21ha2UKKysrIGIvU291cmNlL1dlYktpdDIvUGxhdGZvcm1HVEsu Y21ha2UKQEAgLTI3Myw2ICsyNzMsOCBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX1NPVVJDRVMKIAog ICAgIFVJUHJvY2Vzcy9MYXVuY2hlci9ndGsvUHJvY2Vzc0xhdW5jaGVyR3RrLmNwcAogCisgICAg VUlQcm9jZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHAKKwogICAgIFVJUHJvY2Vz cy9OZXR3b3JrL0N1c3RvbVByb3RvY29scy9zb3VwL0N1c3RvbVByb3RvY29sTWFuYWdlclByb3h5 U291cC5jcHAKICAgICBVSVByb2Nlc3MvTmV0d29yay9DdXN0b21Qcm90b2NvbHMvc291cC9XZWJT b3VwQ3VzdG9tUHJvdG9jb2xSZXF1ZXN0TWFuYWdlci5jcHAKICAgICBVSVByb2Nlc3MvTmV0d29y ay9DdXN0b21Qcm90b2NvbHMvc291cC9XZWJTb3VwQ3VzdG9tUHJvdG9jb2xSZXF1ZXN0TWFuYWdl ckNsaWVudC5jcHAKQEAgLTUxMyw2ICs1MTUsNyBAQCBsaXN0KEFQUEVORCBXZWJLaXQyX0lOQ0xV REVfRElSRUNUT1JJRVMKICAgICAiJHtXRUJLSVQyX0RJUn0vVUlQcm9jZXNzL1BsdWdpbnMvZ3Rr IgogICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvZ3N0cmVhbWVyIgogICAgICIke1dFQktJ VDJfRElSfS9VSVByb2Nlc3MvZ3RrIgorICAgICIke1dFQktJVDJfRElSfS9VSVByb2Nlc3MvbGlu dXgiCiAgICAgIiR7V0VCS0lUMl9ESVJ9L1VJUHJvY2Vzcy9zb3VwIgogICAgICIke1dFQktJVDJf RElSfS9XZWJQcm9jZXNzL0luamVjdGVkQnVuZGxlL0FQSS9ndGsiCiAgICAgIiR7V0VCS0lUMl9E SVJ9L1dlYlByb2Nlc3MvUGx1Z2lucy9OZXRzY2FwZS91bml4IgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdDIvUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNwcCBiL1NvdXJjZS9XZWJLaXQy L1BsdWdpblByb2Nlc3MvUGx1Z2luUHJvY2Vzcy5jcHAKaW5kZXggNzU1NTcwMi4uNjFlNjZmMCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvUGx1Z2luUHJvY2Vzcy9QbHVnaW5Qcm9jZXNzLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9QbHVnaW5Qcm9jZXNzL1BsdWdpblByb2Nlc3MuY3BwCkBA IC03MSwxMyArNzEsNiBAQCB2b2lkIFBsdWdpblByb2Nlc3M6OmluaXRpYWxpemVQcm9jZXNzKGNv bnN0IENoaWxkUHJvY2Vzc0luaXRpYWxpemF0aW9uUGFyYW1ldGVycwogewogICAgIG1fcGx1Z2lu UGF0aCA9IHBhcmFtZXRlcnMuZXh0cmFJbml0aWFsaXphdGlvbkRhdGEuZ2V0KCJwbHVnaW4tcGF0 aCIpOwogICAgIHBsYXRmb3JtSW5pdGlhbGl6ZVByb2Nlc3MocGFyYW1ldGVycyk7Ci0KLSAgICBh dXRvJiBtZW1vcnlQcmVzc3VyZUhhbmRsZXIgPSBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OnNpbmds ZXRvbigpOwotICAgIG1lbW9yeVByZXNzdXJlSGFuZGxlci5zZXRMb3dNZW1vcnlIYW5kbGVyKFt0 aGlzXSAoQ3JpdGljYWwsIFN5bmNocm9ub3VzKSB7Ci0gICAgICAgIGlmIChzaG91bGRUZXJtaW5h dGUoKSkKLSAgICAgICAgICAgIHRlcm1pbmF0ZSgpOwotICAgIH0pOwotICAgIG1lbW9yeVByZXNz dXJlSGFuZGxlci5pbnN0YWxsKCk7CiB9CiAKIHZvaWQgUGx1Z2luUHJvY2Vzczo6cmVtb3ZlV2Vi UHJvY2Vzc0Nvbm5lY3Rpb24oV2ViUHJvY2Vzc0Nvbm5lY3Rpb24qIHdlYlByb2Nlc3NDb25uZWN0 aW9uKQpAQCAtMTM3LDYgKzEzMCwxNyBAQCB2b2lkIFBsdWdpblByb2Nlc3M6OmluaXRpYWxpemVQ bHVnaW5Qcm9jZXNzKFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJiBwYQogewogICAg IEFTU0VSVCghbV9wbHVnaW5Nb2R1bGUpOwogCisgICAgYXV0byYgbWVtb3J5UHJlc3N1cmVIYW5k bGVyID0gTWVtb3J5UHJlc3N1cmVIYW5kbGVyOjpzaW5nbGV0b24oKTsKKyNpZiBPUyhMSU5VWCkK KyAgICBpZiAocGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUuZmlsZURlc2Ny aXB0b3IoKSAhPSAtMSkKKyAgICAgICAgbWVtb3J5UHJlc3N1cmVIYW5kbGVyLnNldE1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZShwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhhbmRs ZS5yZWxlYXNlRmlsZURlc2NyaXB0b3IoKSk7CisjZW5kaWYKKyAgICBtZW1vcnlQcmVzc3VyZUhh bmRsZXIuc2V0TG93TWVtb3J5SGFuZGxlcihbdGhpc10gKENyaXRpY2FsLCBTeW5jaHJvbm91cykg eworICAgICAgICBpZiAoc2hvdWxkVGVybWluYXRlKCkpCisgICAgICAgICAgICB0ZXJtaW5hdGUo KTsKKyAgICB9KTsKKyAgICBtZW1vcnlQcmVzc3VyZUhhbmRsZXIuaW5zdGFsbCgpOworCiAgICAg bV9zdXBwb3J0c0FzeW5jaHJvbm91c1BsdWdpbkluaXRpYWxpemF0aW9uID0gcGFyYW1ldGVycy5z dXBwb3J0c0FzeW5jaHJvbm91c1BsdWdpbkluaXRpYWxpemF0aW9uOwogICAgIHNldE1pbmltdW1M aWZldGltZShwYXJhbWV0ZXJzLm1pbmltdW1MaWZldGltZSk7CiAgICAgc2V0VGVybWluYXRpb25U aW1lb3V0KHBhcmFtZXRlcnMudGVybWluYXRpb25UaW1lb3V0KTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQyL1NoYXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMu Y3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycy5jcHAKaW5kZXggZTNlMWZmZC4uMzAxNTRjNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5j cHAKKysrIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc0NyZWF0 aW9uUGFyYW1ldGVycy5jcHAKQEAgLTUxLDYgKzUxLDkgQEAgdm9pZCBQbHVnaW5Qcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNv bnMKICAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBuZXR3b3JrQVRTQ29udGV4dC5nZXQoKSk7CiAj ZW5kaWYKICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVtb3J5UHJlc3N1 cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgUGx1Z2luUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBQbHVnaW5Q cm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiByZXN1bHQpCkBAIC03MSw2ICs3NCwxMCBAQCBib29s IFBsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJUEM6OkFyZ3VtZW50RGVj b2RlciYgZGVjb2RlciwgUGx1ZwogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5kaWYKICNlbmRp ZgorI2lmIE9TKExJTlVYKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocmVzdWx0Lm1lbW9yeVBy ZXNzdXJlTW9uaXRvckhhbmRsZSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgogCiAg ICAgcmV0dXJuIHRydWU7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvUGx1 Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvUGx1Z2lucy9QbHVnaW5Qcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmgKaW5kZXggYWM3 ZDYzOC4uZDYxNzEzOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1BsdWdpbnMv UGx1Z2luUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1No YXJlZC9QbHVnaW5zL1BsdWdpblByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaApAQCAtMjgsNiAr MjgsNyBAQAogCiAjaWYgRU5BQkxFKE5FVFNDQVBFX1BMVUdJTl9BUEkpCiAKKyNpbmNsdWRlICJB dHRhY2htZW50LmgiCiAjaW5jbHVkZSAiUGx1Z2luUHJvY2Vzc0F0dHJpYnV0ZXMuaCIKIAogI2lm IFBMQVRGT1JNKENPQ09BKQpAQCAtNTksNiArNjAsOSBAQCBzdHJ1Y3QgUGx1Z2luUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVycyB7CiAgICAgUmV0YWluUHRyPENGRGF0YVJlZj4gbmV0d29ya0FUU0Nv bnRleHQ7CiAjZW5kaWYKICNlbmRpZgorI2lmIE9TKExJTlVYKQorICAgIElQQzo6QXR0YWNobWVu dCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNw YWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291cmNlL1dlYktpdDIvU2hhcmVkL1dlYlByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuY3BwCmluZGV4IGE1MzFlNDUuLjFhMmIwZDUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5j cHAKQEAgLTE0MSw2ICsxNDEsMTAgQEAgdm9pZCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz OjplbmNvZGUoSVBDOjpBcmd1bWVudEVuY29kZXImIGVuY29kZXIpIGNvbnN0CiAjaWYgVEFSR0VU X09TX0lQSE9ORSB8fCAoUExBVEZPUk0oTUFDKSAmJiBfX01BQ19PU19YX1ZFUlNJT05fTUlOX1JF UVVJUkVEID49IDEwMTEwMCkKICAgICBJUEM6OmVuY29kZShlbmNvZGVyLCBuZXR3b3JrQVRTQ29u dGV4dC5nZXQoKSk7CiAjZW5kaWYKKworI2lmIE9TKExJTlVYKQorICAgIGVuY29kZXIgPDwgbWVt b3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlOworI2VuZGlmCiB9CiAKIGJvb2wgV2ViUHJvY2Vzc0Ny ZWF0aW9uUGFyYW1ldGVyczo6ZGVjb2RlKElQQzo6QXJndW1lbnREZWNvZGVyJiBkZWNvZGVyLCBX ZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJzJiBwYXJhbWV0ZXJzKQpAQCAtMjk2LDYgKzMwMCwx MSBAQCBib29sIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnM6OmRlY29kZShJUEM6OkFyZ3Vt ZW50RGVjb2RlciYgZGVjb2RlciwgV2ViUHJvYwogICAgICAgICByZXR1cm4gZmFsc2U7CiAjZW5k aWYKIAorI2lmIE9TKExJTlVYKQorICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5t ZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisjZW5k aWYKKwogICAgIHJldHVybiB0cnVlOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9T aGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5oIGIvU291cmNlL1dlYktpdDIvU2hh cmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCBhZGQ4NGYzLi5jOWFhMmM5 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzLmgKQEAgLTE2Niw2ICsxNjYsMTAgQEAgc3RydWN0IFdlYlByb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMgewogI2lmIFRBUkdFVF9PU19JUEhPTkUgfHwgKFBMQVRGT1JNKE1BQykgJiYg X19NQUNfT1NfWF9WRVJTSU9OX01JTl9SRVFVSVJFRCA+PSAxMDExMDApCiAgICAgUmV0YWluUHRy PENGRGF0YVJlZj4gbmV0d29ya0FUU0NvbnRleHQ7CiAjZW5kaWYKKworI2lmIE9TKExJTlVYKQor ICAgIElQQzo6QXR0YWNobWVudCBtZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGU7CisjZW5kaWYK IH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL1BsdWdpbnMvUGx1Z2luUHJvY2Vzc1Byb3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9QbHVnaW5zL1BsdWdpblByb2Nlc3NQcm94eS5jcHAKaW5kZXggOGY1MDVhNi4u OTQxZTU2YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BsdWdpbnMvUGx1 Z2luUHJvY2Vzc1Byb3h5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGx1Z2lu cy9QbHVnaW5Qcm9jZXNzUHJveHkuY3BwCkBAIC0zOCw2ICszOCwxMCBAQAogI2luY2x1ZGUgPFdl YkNvcmUvTm90SW1wbGVtZW50ZWQuaD4KICNpbmNsdWRlIDx3dGYvUnVuTG9vcC5oPgogCisjaWYg T1MoTElOVVgpCisjaW5jbHVkZSAiTWVtb3J5UHJlc3N1cmVNb25pdG9yLmgiCisjZW5kaWYKKwog dXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtMjI5LDYg KzIzMywxMiBAQCB2b2lkIFBsdWdpblByb2Nlc3NQcm94eTo6ZGlkRmluaXNoTGF1bmNoaW5nKFBy b2Nlc3NMYXVuY2hlciosIElQQzo6Q29ubmVjdGlvbjo6SQogICAgICAgICBwYXJhbWV0ZXJzLm1p bmltdW1MaWZldGltZSA9IG1pbmltdW1MaWZldGltZTsKICAgICAgICAgcGFyYW1ldGVycy50ZXJt aW5hdGlvblRpbWVvdXQgPSBzaHV0ZG93blRpbWVvdXQ7CiAgICAgfQorCisjaWYgT1MoTElOVVgp CisgICAgaWYgKE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6aXNFbmFibGVkKCkpCisgICAgICAgIHBh cmFtZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlID0gTWVtb3J5UHJlc3N1cmVNb25p dG9yOjpzaW5nbGV0b24oKS5jcmVhdGVIYW5kbGUoKTsKKyNlbmRpZgorCiAgICAgcGxhdGZvcm1J bml0aWFsaXplUGx1Z2luUHJvY2VzcyhwYXJhbWV0ZXJzKTsKIAogICAgIC8vIEluaXRpYWxpemUg dGhlIHBsdWctaW4gaG9zdCBwcm9jZXNzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ cm9jZXNzUG9vbC5jcHAKaW5kZXggMmY5YmYwOS4uOTJkYzJlYSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdDIvVUlQcm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwCkBAIC05Myw2ICs5MywxMCBAQAogI2luY2x1 ZGUgIldlYlNvdXBDdXN0b21Qcm90b2NvbFJlcXVlc3RNYW5hZ2VyLmgiCiAjZW5kaWYKIAorI2lm IE9TKExJTlVYKQorI2luY2x1ZGUgIk1lbW9yeVByZXNzdXJlTW9uaXRvci5oIgorI2VuZGlmCisK ICNpZm5kZWYgTkRFQlVHCiAjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWRMZWFrQ291bnRlci5oPgog I2VuZGlmCkBAIC0zNzAsNiArMzc0LDExIEBAIE5ldHdvcmtQcm9jZXNzUHJveHkmIFdlYlByb2Nl c3NQb29sOjplbnN1cmVOZXR3b3JrUHJvY2VzcygpCiAgICAgICAgIFNhbmRib3hFeHRlbnNpb246 OmNyZWF0ZUhhbmRsZShwYXJlbnRCdW5kbGVEaXJlY3RvcnksIFNhbmRib3hFeHRlbnNpb246OlJl YWRPbmx5LCBwYXJhbWV0ZXJzLnBhcmVudEJ1bmRsZURpcmVjdG9yeUV4dGVuc2lvbkhhbmRsZSk7 CiAjZW5kaWYKIAorI2lmIE9TKExJTlVYKQorICAgIGlmIChNZW1vcnlQcmVzc3VyZU1vbml0b3I6 OmlzRW5hYmxlZCgpKQorICAgICAgICBwYXJhbWV0ZXJzLm1lbW9yeVByZXNzdXJlTW9uaXRvckhh bmRsZSA9IE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6c2luZ2xldG9uKCkuY3JlYXRlSGFuZGxlKCk7 CisjZW5kaWYKKwogICAgIHBhcmFtZXRlcnMuc2hvdWxkVXNlVGVzdGluZ05ldHdvcmtTZXNzaW9u ID0gbV9zaG91bGRVc2VUZXN0aW5nTmV0d29ya1Nlc3Npb247CiAKICAgICAvLyBBZGQgYW55IHBs YXRmb3JtIHNwZWNpZmljIHBhcmFtZXRlcnMKQEAgLTYyNiw2ICs2MzUsOCBAQCBXZWJQcm9jZXNz UHJveHkmIFdlYlByb2Nlc3NQb29sOjpjcmVhdGVOZXdXZWJQcm9jZXNzKCkKIAogI2lmIE9TKExJ TlVYKQogICAgIHBhcmFtZXRlcnMuc2hvdWxkRW5hYmxlTWVtb3J5UHJlc3N1cmVSZWxpZWZMb2dn aW5nID0gdHJ1ZTsKKyAgICBpZiAoTWVtb3J5UHJlc3N1cmVNb25pdG9yOjppc0VuYWJsZWQoKSkK KyAgICAgICAgcGFyYW1ldGVycy5tZW1vcnlQcmVzc3VyZU1vbml0b3JIYW5kbGUgPSBNZW1vcnlQ cmVzc3VyZU1vbml0b3I6OnNpbmdsZXRvbigpLmNyZWF0ZUhhbmRsZSgpOwogI2VuZGlmCiAKICAg ICBwYXJhbWV0ZXJzLnJlc291cmNlTG9hZFN0YXRpc3RpY3NFbmFibGVkID0gcmVzb3VyY2VMb2Fk U3RhdGlzdGljc0VuYWJsZWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL2xpbnV4L01lbW9yeVByZXNzdXJlTW9uaXRvci5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMC4uY2U2NmZkOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVzc3VyZU1vbml0b3IuY3BwCkBAIC0wLDAgKzEsMjc5 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IElnYWxpYSBTLkwuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJ QlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElU UyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRgorICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJNZW1vcnlQcmVzc3VyZU1vbml0b3IuaCIKKwor I2lmIE9TKExJTlVYKQorCisjaW5jbHVkZSAiQXR0YWNobWVudC5oIgorI2luY2x1ZGUgPGVycm5v Lmg+CisjaW5jbHVkZSA8ZmNudGwuaD4KKyNpbmNsdWRlIDxtdXRleD4KKyNpbmNsdWRlIDxzdGRs aWIuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDxzeXMvZXZlbnRmZC5oPgorI2lu Y2x1ZGUgPHN5cy9zdGF0Lmg+CisjaW5jbHVkZSA8c3lzL3R5cGVzLmg+CisjaW5jbHVkZSA8dW5p c3RkLmg+CisjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CisjaW5jbHVkZSA8d3RmL1RocmVh ZGluZy5oPgorI2luY2x1ZGUgPHd0Zi9VbmlTdGRFeHRyYXMuaD4KKworbmFtZXNwYWNlIFdlYktp dCB7CisKK3N0YXRpYyBjb25zdCBzaXplX3Qgbm90U2V0ID0gc3RhdGljX2Nhc3Q8c2l6ZV90Pigt MSk7CisKK3N0YXRpYyBjb25zdCBkb3VibGUgc19taW5Qb2xsaW5nSW50ZXJ2YWxJblNlY29uZHMg PSAxOworc3RhdGljIGNvbnN0IGRvdWJsZSBzX21heFBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcyA9 IDU7CitzdGF0aWMgY29uc3QgZG91YmxlIHNfbWluVXNlZE1lbW9yeVBlcmNlbnRhZ2VGb3JQb2xs aW5nID0gNTA7CitzdGF0aWMgY29uc3QgZG91YmxlIHNfbWF4VXNlZE1lbW9yeVBlcmNlbnRhZ2VG b3JQb2xsaW5nID0gOTA7CitzdGF0aWMgY29uc3QgaW50IHNfbWVtb3J5UHJlc3VyZVBlcmNlbnRh Z2VUaHJlc2hvbGQgPSA5NTsKKworc3RhdGljIHNpemVfdCBsb3dXYXRlcm1hcmtQYWdlcygpCit7 CisgICAgRklMRSogZmlsZSA9IGZvcGVuKCIvcHJvYy96b25laW5mbyIsICJyIik7CisgICAgaWYg KCFmaWxlKQorICAgICAgICByZXR1cm4gbm90U2V0OworCisgICAgc2l6ZV90IGxvdyA9IDA7Cisg ICAgYm9vbCBpblpvbmUgPSBmYWxzZTsKKyAgICBib29sIGZvdW5kTG93ID0gZmFsc2U7CisgICAg Y2hhciBidWZmZXJbMTI4XTsKKyAgICB3aGlsZSAoY2hhciogbGluZSA9IGZnZXRzKGJ1ZmZlciwg MTI4LCBmaWxlKSkgeworICAgICAgICBpZiAoIXN0cmNtcChsaW5lLCAiTm9kZSIpKSB7CisgICAg ICAgICAgICBpblpvbmUgPSB0cnVlOworICAgICAgICAgICAgZm91bmRMb3cgPSBmYWxzZTsKKyAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CisKKyAgICAgICAgY2hhciogdG9rZW4gPSBz dHJ0b2sobGluZSwgIiAiKTsKKyAgICAgICAgaWYgKCF0b2tlbikKKyAgICAgICAgICAgIGNvbnRp bnVlOworCisgICAgICAgIGlmICghc3RyY21wKHRva2VuLCAibG93IikpIHsKKyAgICAgICAgICAg IGlmICghaW5ab25lIHx8IGZvdW5kTG93KSB7CisgICAgICAgICAgICAgICAgbG93ID0gbm90U2V0 OworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICAgICAgdG9r ZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKTsKKyAgICAgICAgICAgIGlmICghdG9rZW4pIHsKKyAg ICAgICAgICAgICAgICBsb3cgPSBub3RTZXQ7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgICAgICB9CisgICAgICAgICAgICBsb3cgKz0gYXRvbGwodG9rZW4pOworICAgICAgICAgICAg Zm91bmRMb3cgPSB0cnVlOworICAgICAgICB9CisgICAgfQorICAgIGZjbG9zZShmaWxlKTsKKwor ICAgIHJldHVybiBsb3c7Cit9CisKK3N0YXRpYyBpbmxpbmUgc2l6ZV90IHN5c3RlbVBhZ2VTaXpl KCkKK3sKKyAgICBzdGF0aWMgc2l6ZV90IHBhZ2VTaXplID0gMDsKKyAgICBpZiAoIXBhZ2VTaXpl KQorICAgICAgICBwYWdlU2l6ZSA9IHN5c2NvbmYoX1NDX1BBR0VfU0laRSk7CisgICAgcmV0dXJu IHBhZ2VTaXplOworfQorCitzdGF0aWMgc2l6ZV90IGNhbGN1bGF0ZU1lbW9yeUF2YWlsYWJsZShz aXplX3QgbWVtb3J5RnJlZSwgc2l6ZV90IGFjdGl2ZUZpbGUsIHNpemVfdCBpbmFjdGl2ZUZpbGUs IHNpemVfdCBzbGFiUmVjbGFpbWFibGUpCit7CisgICAgaWYgKG1lbW9yeUZyZWUgPT0gbm90U2V0 IHx8IGFjdGl2ZUZpbGUgPT0gbm90U2V0IHx8IGluYWN0aXZlRmlsZSA9PSBub3RTZXQgfHwgc2xh YlJlY2xhaW1hYmxlID09IG5vdFNldCkKKyAgICAgICAgcmV0dXJuIG5vdFNldDsKKworICAgIHNp emVfdCBsb3dXYXRlcm1hcmsgPSBsb3dXYXRlcm1hcmtQYWdlcygpOworICAgIGlmIChsb3dXYXRl cm1hcmsgPT0gbm90U2V0KQorICAgICAgICByZXR1cm4gbm90U2V0OworCisgICAgbG93V2F0ZXJt YXJrICo9IHN5c3RlbVBhZ2VTaXplKCkgLyBLQjsKKworICAgIC8vIEVzdGltYXRlIHRoZSBhbW91 bnQgb2YgbWVtb3J5IGF2YWlsYWJsZSBmb3IgdXNlcnNwYWNlIGFsbG9jYXRpb25zLCB3aXRob3V0 IGNhdXNpbmcgc3dhcHBpbmcuCisgICAgLy8gRnJlZSBtZW1vcnkgY2Fubm90IGJlIHRha2VuIGJl bG93IHRoZSBsb3cgd2F0ZXJtYXJrLCBiZWZvcmUgdGhlIHN5c3RlbSBzdGFydHMgc3dhcHBpbmcu CisgICAgbG93V2F0ZXJtYXJrICo9IHN5c3RlbVBhZ2VTaXplKCkgLyBLQjsKKyAgICBzaXplX3Qg bWVtb3J5QXZhaWxhYmxlID0gbWVtb3J5RnJlZSAtIGxvd1dhdGVybWFyazsKKworICAgIC8vIE5v dCBhbGwgdGhlIHBhZ2UgY2FjaGUgY2FuIGJlIGZyZWVkLCBvdGhlcndpc2UgdGhlIHN5c3RlbSB3 aWxsIHN0YXJ0IHN3YXBwaW5nLiBBc3N1bWUgYXQgbGVhc3QKKyAgICAvLyBoYWxmIG9mIHRoZSBw YWdlIGNhY2hlLCBvciB0aGUgbG93IHdhdGVybWFyayB3b3J0aCBvZiBjYWNoZSwgbmVlZHMgdG8g c3RheS4KKyAgICBzaXplX3QgcGFnZUNhY2hlID0gYWN0aXZlRmlsZSArIGluYWN0aXZlRmlsZTsK KyAgICBwYWdlQ2FjaGUgLT0gc3RkOjptaW4ocGFnZUNhY2hlIC8gMiwgbG93V2F0ZXJtYXJrKTsK KyAgICBtZW1vcnlBdmFpbGFibGUgKz0gcGFnZUNhY2hlOworCisgICAgLy8gUGFydCBvZiB0aGUg cmVjbGFpbWFibGUgc2xhYiBjb25zaXN0cyBvZiBpdGVtcyB0aGF0IGFyZSBpbiB1c2UsIGFuZCBj YW5ub3QgYmUgZnJlZWQuCisgICAgLy8gQ2FwIHRoaXMgZXN0aW1hdGUgYXQgdGhlIGxvdyB3YXRl cm1hcmsuCisgICAgbWVtb3J5QXZhaWxhYmxlICs9IHNsYWJSZWNsYWltYWJsZSAtIHN0ZDo6bWlu KHNsYWJSZWNsYWltYWJsZSAvIDIsIGxvd1dhdGVybWFyayk7CisgICAgcmV0dXJuIG1lbW9yeUF2 YWlsYWJsZTsKK30KKworc3RhdGljIGludCBzeXN0ZW1NZW1vcnlVc2VkQXNQZXJjZW50YWdlKCkK K3sKKyAgICBGSUxFKiBmaWxlID0gZm9wZW4oIi9wcm9jL21lbWluZm8iLCAiciIpOworICAgIGlm ICghZmlsZSkKKyAgICAgICAgcmV0dXJuIC0xOworCisgICAgc2l6ZV90IG1lbW9yeUF2YWlsYWJs ZSwgbWVtb3J5VG90YWwsIG1lbW9yeUZyZWUsIGFjdGl2ZUZpbGUsIGluYWN0aXZlRmlsZSwgc2xh YlJlY2xhaW1hYmxlOworICAgIG1lbW9yeUF2YWlsYWJsZSA9IG1lbW9yeVRvdGFsID0gbWVtb3J5 RnJlZSA9IGFjdGl2ZUZpbGUgPSBpbmFjdGl2ZUZpbGUgPSBzbGFiUmVjbGFpbWFibGUgPSBub3RT ZXQ7CisgICAgY2hhciBidWZmZXJbMTI4XTsKKyAgICB3aGlsZSAoY2hhciogbGluZSA9IGZnZXRz KGJ1ZmZlciwgMTI4LCBmaWxlKSkgeworICAgICAgICBjaGFyKiB0b2tlbiA9IHN0cnRvayhsaW5l LCAiICIpOworICAgICAgICBpZiAoIXRva2VuKQorICAgICAgICAgICAgYnJlYWs7CisKKyAgICAg ICAgaWYgKCFzdHJjbXAodG9rZW4sICJNZW1BdmFpbGFibGU6IikpIHsKKyAgICAgICAgICAgIGlm ICgodG9rZW4gPSBzdHJ0b2sobnVsbHB0ciwgIiAiKSkpIHsKKyAgICAgICAgICAgICAgICBtZW1v cnlBdmFpbGFibGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICAgICAgaWYgKG1lbW9yeVRv dGFsICE9IG5vdFNldCkKKyAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9 CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIk1lbVRvdGFsOiIpKSB7CisgICAg ICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikpKQorICAgICAgICAgICAg ICAgIG1lbW9yeVRvdGFsID0gYXRvbGwodG9rZW4pOworICAgICAgICAgICAgZWxzZQorICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICB9IGVsc2UgaWYgKCFzdHJjbXAodG9rZW4sICJNZW1G cmVlOiIpKSB7CisgICAgICAgICAgICBpZiAoKHRva2VuID0gc3RydG9rKG51bGxwdHIsICIgIikp KQorICAgICAgICAgICAgICAgIG1lbW9yeUZyZWUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNt cCh0b2tlbiwgIkFjdGl2ZShmaWxlKToiKSkgeworICAgICAgICAgICAgaWYgKCh0b2tlbiA9IHN0 cnRvayhudWxscHRyLCAiICIpKSkKKyAgICAgICAgICAgICAgICBhY3RpdmVGaWxlID0gYXRvbGwo dG9rZW4pOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAg ICB9IGVsc2UgaWYgKCFzdHJjbXAodG9rZW4sICJJbmFjdGl2ZShmaWxlKToiKSkgeworICAgICAg ICAgICAgaWYgKCh0b2tlbiA9IHN0cnRvayhudWxscHRyLCAiICIpKSkKKyAgICAgICAgICAgICAg ICBpbmFjdGl2ZUZpbGUgPSBhdG9sbCh0b2tlbik7CisgICAgICAgICAgICBlbHNlCisgICAgICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgIH0gZWxzZSBpZiAoIXN0cmNtcCh0b2tlbiwgIlNSZWNs YWltYWJsZToiKSkgeworICAgICAgICAgICAgaWYgKCh0b2tlbiA9IHN0cnRvayhudWxscHRyLCAi ICIpKSkKKyAgICAgICAgICAgICAgICBzbGFiUmVjbGFpbWFibGUgPSBhdG9sbCh0b2tlbik7Cisg ICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKworICAg ICAgICBpZiAobWVtb3J5VG90YWwgIT0gbm90U2V0ICYmIG1lbW9yeUZyZWUgIT0gbm90U2V0ICYm IGFjdGl2ZUZpbGUgIT0gbm90U2V0ICYmIGluYWN0aXZlRmlsZSAhPSBub3RTZXQgJiYgc2xhYlJl Y2xhaW1hYmxlICE9IG5vdFNldCkKKyAgICAgICAgICAgIGJyZWFrOworICAgIH0KKyAgICBmY2xv c2UoZmlsZSk7CisKKyAgICBpZiAobWVtb3J5VG90YWwgPT0gbm90U2V0KQorICAgICAgICByZXR1 cm4gLTE7CisKKyAgICBpZiAobWVtb3J5QXZhaWxhYmxlID09IG5vdFNldCkgeworICAgICAgICAv LyBJZiBNZW1BdmFpbGFibGUgd2FzIG5vdCBwcmVzZW50IGluIC9wcm9jL21lbWluZm8sIGJlY2F1 c2UgaXQncyBhbiBvbGQga2VybmVsIHZlcnNpb24sCisgICAgICAgIC8vIHdlIGNhbiBkbyB0aGUg c2FtZSBjYWxjdWxhdGlvbiB3aXRoIHRoZSBpbmZvcm1hdGlvbiB3ZSBoYXZlIGZyb20gbWVtaW5m byBhbmQgdGhlIGxvdyB3YXRlcm1ha3MuCisgICAgICAgIC8vIFNlZSBodHRwczovL2dpdC5rZXJu ZWwub3JnL2NnaXQvbGludXgva2VybmVsL2dpdC90b3J2YWxkcy9saW51eC5naXQvY29tbWl0Lz9p ZD0zNGU0MzFiMGFlMzk4ZmM1NGVhNjlmZjg1ZWM3MDA3MjJjOWRhNzczCisgICAgICAgIG1lbW9y eUF2YWlsYWJsZSA9IGNhbGN1bGF0ZU1lbW9yeUF2YWlsYWJsZShtZW1vcnlGcmVlLCBhY3RpdmVG aWxlLCBpbmFjdGl2ZUZpbGUsIHNsYWJSZWNsYWltYWJsZSk7CisgICAgICAgIGlmIChtZW1vcnlB dmFpbGFibGUgPT0gbm90U2V0KQorICAgICAgICAgICAgcmV0dXJuIC0xOworICAgIH0KKworICAg IHJldHVybiAoKG1lbW9yeVRvdGFsIC0gbWVtb3J5QXZhaWxhYmxlKSAqIDEwMCkgLyBtZW1vcnlU b3RhbDsKK30KKworc3RhdGljIGlubGluZSBkb3VibGUgcG9sbEludGVydmFsRm9yVXNlZE1lbW9y eVBlcmNlbnRhZ2UoaW50IHVzZWRQZXJjZW50YWdlKQoreworICAgIC8vIFVzZSBhIGRpZmZlcmVu dCBwb2xsIGludGVydmFsIGRlcGVuZGluZyBvbiB0aGUgY3VycmVudGx5IG1lbW9yeSB1c2VkLAor ICAgIC8vIHRvIGF2b2lkIHBvbGxpbmcgdG9vIG9mdGVuIHdoZW4gdGhlIHN5c3RlbSBpcyB1bmRl ciBsb3cgbWVtb3J5IHVzYWdlLgorICAgIGlmICh1c2VkUGVyY2VudGFnZSA8IHNfbWluVXNlZE1l bW9yeVBlcmNlbnRhZ2VGb3JQb2xsaW5nKQorICAgICAgICByZXR1cm4gc19tYXhQb2xsaW5nSW50 ZXJ2YWxJblNlY29uZHM7CisKKyAgICBpZiAodXNlZFBlcmNlbnRhZ2UgPj0gc19tYXhVc2VkTWVt b3J5UGVyY2VudGFnZUZvclBvbGxpbmcpCisgICAgICAgIHJldHVybiBzX21pblBvbGxpbmdJbnRl cnZhbEluU2Vjb25kczsKKworICAgIHJldHVybiBzX21pblBvbGxpbmdJbnRlcnZhbEluU2Vjb25k cyArIChzX21heFBvbGxpbmdJbnRlcnZhbEluU2Vjb25kcyAtIHNfbWluUG9sbGluZ0ludGVydmFs SW5TZWNvbmRzKSAqCisgICAgICAgICgodXNlZFBlcmNlbnRhZ2UgLSBzX21pblVzZWRNZW1vcnlQ ZXJjZW50YWdlRm9yUG9sbGluZykgLyAoc19tYXhVc2VkTWVtb3J5UGVyY2VudGFnZUZvclBvbGxp bmcgLSBzX21pblVzZWRNZW1vcnlQZXJjZW50YWdlRm9yUG9sbGluZykpOworfQorCitzdGF0aWMg Ym9vbCBpc1N5c3RlbWRNZW1vcnlQcmVzc3VyZU1vbml0b3JBdmFpbGFibGUoKQoreworICAgIGlu dCBmZCA9IG9wZW4oIi9zeXMvZnMvY2dyb3VwL21lbW9yeS9tZW1vcnkucHJlc3N1cmVfbGV2ZWwi LCBPX0NMT0VYRUMgfCBPX1JET05MWSk7CisgICAgaWYgKGZkID09IC0xKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisgICAgY2xvc2UoZmQpOworCisgICAgZmQgPSBvcGVuKCIvc3lzL2ZzL2Nncm91 cC9tZW1vcnkvY2dyb3VwLmV2ZW50X2NvbnRyb2wiLCBPX0NMT0VYRUMgfCBPX1dST05MWSk7Cisg ICAgaWYgKGZkID09IC0xKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgY2xvc2UoZmQpOwor CisgICAgcmV0dXJuIHRydWU7Cit9CisKK2Jvb2wgTWVtb3J5UHJlc3N1cmVNb25pdG9yOjppc0Vu YWJsZWQoKQoreworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBvbmNlRmxhZzsKKyAgICBzdGF0 aWMgYm9vbCBlbmFibGVkOworICAgIHN0ZDo6Y2FsbF9vbmNlKG9uY2VGbGFnLCBbXSB7IGVuYWJs ZWQgPSAhaXNTeXN0ZW1kTWVtb3J5UHJlc3N1cmVNb25pdG9yQXZhaWxhYmxlKCk7IH0pOworICAg IHJldHVybiBlbmFibGVkOworfQorCitNZW1vcnlQcmVzc3VyZU1vbml0b3ImIE1lbW9yeVByZXNz dXJlTW9uaXRvcjo6c2luZ2xldG9uKCkKK3sKKyAgICBBU1NFUlQoaXNFbmFibGVkKCkpOworICAg IHN0YXRpYyBOZXZlckRlc3Ryb3llZDxNZW1vcnlQcmVzc3VyZU1vbml0b3I+IG1lbW9yeU1vbml0 b3I7CisgICAgcmV0dXJuIG1lbW9yeU1vbml0b3I7Cit9CisKK01lbW9yeVByZXNzdXJlTW9uaXRv cjo6TWVtb3J5UHJlc3N1cmVNb25pdG9yKCkKKyAgICA6IG1fZXZlbnRGRChldmVudGZkKDAsIEVG RF9DTE9FWEVDKSkKK3sKKyAgICBpZiAobV9ldmVudEZEID09IC0xKQorICAgICAgICByZXR1cm47 CisKKyAgICBUaHJlYWRJZGVudGlmaWVyIHRocmVhZElkZW50aWZpZXIgPSBjcmVhdGVUaHJlYWQo Ik1lbW9yeVByZXNzdXJlTW9uaXRvciIsIFt0aGlzXSB7CisgICAgICAgIGRvdWJsZSBwb2xsSW50 ZXJ2YWwgPSBzX21heFBvbGxpbmdJbnRlcnZhbEluU2Vjb25kczsKKyAgICAgICAgd2hpbGUgKHRy dWUpIHsKKyAgICAgICAgICAgIHNsZWVwKHBvbGxJbnRlcnZhbCk7CisKKyAgICAgICAgICAgIGlu dCB1c2VkUGVyY2VudGFnZSA9IHN5c3RlbU1lbW9yeVVzZWRBc1BlcmNlbnRhZ2UoKTsKKyAgICAg ICAgICAgIGlmICh1c2VkUGVyY2VudGFnZSA+PSBzX21lbW9yeVByZXN1cmVQZXJjZW50YWdlVGhy ZXNob2xkKSB7CisgICAgICAgICAgICAgICAgdWludDY0X3QgZmRFdmVudCA9IDE7CisgICAgICAg ICAgICAgICAgc3NpemVfdCBieXRlc1dyaXR0ZW4gPSB3cml0ZShtX2V2ZW50RkQsICZmZEV2ZW50 LCBzaXplb2YodWludDY0X3QpKTsKKyAgICAgICAgICAgICAgICBpZiAoYnl0ZXNXcml0dGVuICE9 IHNpemVvZih1aW50NjRfdCkpIHsKKyAgICAgICAgICAgICAgICAgICAgV1RGTG9nQWx3YXlzKCJF cnJvciB3cml0aW5nIHRvIE1lbW9yeVByZXNzdXJlTW9uaXRvciBldmVudEZEOiAlcyIsIHN0cmVy cm9yKGVycm5vKSk7CisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHBvbGxJbnRlcnZhbCA9IHBvbGxJbnRlcnZh bEZvclVzZWRNZW1vcnlQZXJjZW50YWdlKHVzZWRQZXJjZW50YWdlKTsKKyAgICAgICAgfQorICAg ICAgICBjbG9zZShtX2V2ZW50RkQpOworICAgIH0pOworICAgIGRldGFjaFRocmVhZCh0aHJlYWRJ ZGVudGlmaWVyKTsKK30KKworSVBDOjpBdHRhY2htZW50IE1lbW9yeVByZXNzdXJlTW9uaXRvcjo6 Y3JlYXRlSGFuZGxlKCkgY29uc3QKK3sKKyAgICBpbnQgZHVwbGljYXRlZEhhbmRsZSA9IGR1cENs b3NlT25FeGVjKG1fZXZlbnRGRCk7CisgICAgaWYgKGR1cGxpY2F0ZWRIYW5kbGUgPT0gLTEpCisg ICAgICAgIHJldHVybiB7IH07CisgICAgcmV0dXJuIElQQzo6QXR0YWNobWVudChkdXBsaWNhdGVk SGFuZGxlKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZiAvLyBPUyhMSU5V WCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVz c3VyZU1vbml0b3IuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9saW51eC9NZW1vcnlQcmVz c3VyZU1vbml0b3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zODc0ZDkw Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL2xpbnV4L01lbW9y eVByZXNzdXJlTW9uaXRvci5oCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTYgSWdhbGlhIFMuTC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUgorICogQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4KKyAqIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBPUyhMSU5V WCkKKworI2luY2x1ZGUgPHd0Zi9OZXZlckRlc3Ryb3llZC5oPgorI2luY2x1ZGUgPHd0Zi9Ob25j b3B5YWJsZS5oPgorCituYW1lc3BhY2UgSVBDIHsKK2NsYXNzIEF0dGFjaG1lbnQ7Cit9CisKK25h bWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBNZW1vcnlQcmVzc3VyZU1vbml0b3IgeworICAgIFdU Rl9NQUtFX05PTkNPUFlBQkxFKE1lbW9yeVByZXNzdXJlTW9uaXRvcik7CisgICAgZnJpZW5kIGNs YXNzIE5ldmVyRGVzdHJveWVkPE1lbW9yeVByZXNzdXJlTW9uaXRvcj47CitwdWJsaWM6CisgICAg c3RhdGljIE1lbW9yeVByZXNzdXJlTW9uaXRvciYgc2luZ2xldG9uKCk7CisgICAgc3RhdGljIGJv b2wgaXNFbmFibGVkKCk7CisKKyAgICB+TWVtb3J5UHJlc3N1cmVNb25pdG9yKCk7CisKKyAgICBJ UEM6OkF0dGFjaG1lbnQgY3JlYXRlSGFuZGxlKCkgY29uc3Q7CisKK3ByaXZhdGU6CisgICAgTWVt b3J5UHJlc3N1cmVNb25pdG9yKCk7CisKKyAgICBpbnQgbV9ldmVudEZEIHsgLTEgfTsKK307CisK K30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYgLy8gT1MoTElOVVgpCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwIGIvU291cmNlL1dlYktp dDIvV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcAppbmRleCAxMmRhZDBiLi5lYjE2ZjI0IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwCisrKyBiL1Nv dXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHAKQEAgLTI2Niw3ICsyNjYsOSBA QCB2b2lkIFdlYlByb2Nlc3M6OmluaXRpYWxpemVXZWJQcm9jZXNzKFdlYlByb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnMmJiBwYXJhbWV0ZXJzKQogICAgIEFTU0VSVChtX3BhZ2VNYXAuaXNFbXB0eSgp KTsKIAogI2lmIE9TKExJTlVYKQotICAgIFdlYkNvcmU6Ok1lbW9yeVByZXNzdXJlSGFuZGxlcjo6 UmVsaWVmTG9nZ2VyOjpzZXRMb2dnaW5nRW5hYmxlZChwYXJhbWV0ZXJzLnNob3VsZEVuYWJsZU1l bW9yeVByZXNzdXJlUmVsaWVmTG9nZ2luZyk7CisgICAgaWYgKHBhcmFtZXRlcnMubWVtb3J5UHJl c3N1cmVNb25pdG9ySGFuZGxlLmZpbGVEZXNjcmlwdG9yKCkgIT0gLTEpCisgICAgICAgIE1lbW9y eVByZXNzdXJlSGFuZGxlcjo6c2luZ2xldG9uKCkuc2V0TWVtb3J5UHJlc3N1cmVNb25pdG9ySGFu ZGxlKHBhcmFtZXRlcnMubWVtb3J5UHJlc3N1cmVNb25pdG9ySGFuZGxlLnJlbGVhc2VGaWxlRGVz Y3JpcHRvcigpKTsKKyAgICBNZW1vcnlQcmVzc3VyZUhhbmRsZXI6OlJlbGllZkxvZ2dlcjo6c2V0 TG9nZ2luZ0VuYWJsZWQocGFyYW1ldGVycy5zaG91bGRFbmFibGVNZW1vcnlQcmVzc3VyZVJlbGll ZkxvZ2dpbmcpOwogI2VuZGlmCiAKICAgICBwbGF0Zm9ybUluaXRpYWxpemVXZWJQcm9jZXNzKFdU Rk1vdmUocGFyYW1ldGVycykpOwo=