53659 2011-02-02 21:01:14 -0800 Web Inspector: Better support for finding "leaked" DOM 2011-03-17 03:16:10 -0700 1 1 1 Unclassified WebKit Web Inspector (Deprecated) 528+ (Nightly build) All All RESOLVED FIXED P2 Enhancement --- 1 tonyg mnaganov abarth antonm apavlov ap bweinstein dglazkov eae eric gregsimon jamesr joepeck keishi loislo mihaip mnaganov ngm peter pfeldman pmuellr rik timothy vitalyr webkit.review.bot yurys oldest_to_newest 344517 0 tonyg 2011-02-02 21:01:14 -0800 James and I have been working with some folks on the Gmail team to track down a memory growth bug. They have a caching system which caches large numbers of DOM nodes that aren't currently attached to the document. However, there appear to be leaks -- perhaps caused by forgetting to detach event handlers? But we have no good way to track down what is holding the references alive. Our goal is to find DOM objects which are unattached from the document but being held alive by JS alone. We don't have an idea for a silver bullet solution, but had a few ideas for additional information that the heap profile could expose to help us troubleshoot. Is it possible to add any of the following information for each JS object which references a node in a DOM tree which is held alive by JS references alone? 1. A count of the number of DOM nodes in DOM trees which are held alive by JS references alone (with the understanding that this JS object may not be the only JS object referencing it). 2. The id of the element referenced or at least the id of the element at the root of the referenced tree (if it has an id). 3. Allow sorting by number of DOM nodes referenced. Bonus points if we can somehow surface the largest trees with fewest number of references. 344629 1 mnaganov 2011-02-03 04:28:51 -0800 Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? Some questions: - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? 345060 2 tonyg 2011-02-03 15:31:09 -0800 (In reply to comment #1) > Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. I've added eae who might be able to explain a little better. But as a simplistic example, imagine a fixed size array where each item points to a DOM node that is no longer attached to the document. As new nodes are added to the front of the array, old nodes are pushed out the end. The app expects that the ones pushed out the end are collected. However, there is some other piece of code (other than the caching array) which has a reference to the node and is preventing its collection. But given the size of the codebase it is difficult to pinpoint what other piece of code is holding the reference alive. > > For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? It sounds like the same problem, but I from the description in the bug, I don't fully understand the new feature. > > Some questions: > - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? The DOM node's id. <div id=foo></div> I know this may seem awkward because it isn't always available, but when it is available it is the key piece of information that could help a web app developer understand which node this is. > - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? I'm not very familiar with how GC works, but Jamesr give me a quick overview. Perhaps we can consider it help only from the VM if the object groups's refcount is equal to the number of JS references. 345433 3 antonm 2011-02-04 03:24:40 -0800 (In reply to comment #2) > (In reply to comment #1) > > Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. > > I've added eae who might be able to explain a little better. But as a simplistic example, imagine a fixed size array where each item points to a DOM node that is no longer attached to the document. As new nodes are added to the front of the array, old nodes are pushed out the end. The app expects that the ones pushed out the end are collected. However, there is some other piece of code (other than the caching array) which has a reference to the node and is preventing its collection. But given the size of the codebase it is difficult to pinpoint what other piece of code is holding the reference alive. Just in case, if detached nodes form tree of its own (traversable via parent, children, sibling), they are treated as an object group and therefore should be eligible to GC in the same time, so retainers could be objects in the cache itself. If it's not impossible, I'd suggest you to trace object grouping as well. BTW, Mikhail should be able to explain it in more details, but I think he has this feature---list all the retainers of the object---in the heap profiler, at least in experimental variant. BTW, Mikhail, do your retainer thing supports tracing object groups? > > > > > For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? > > It sounds like the same problem, but I from the description in the bug, I don't fully understand the new feature. There was a confusion over term 'id'. You meant HTML element's id while we rather thought of JS object identity. Mikhail's ids are unique ids for the whole life of JS objects (that's trickier than plain pointer as GC can move objects). So if you'd like to trace the life of the object, your best bet is Mikhail's ids. > > > > > Some questions: > > - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? > > The DOM node's id. > <div id=foo></div> > I know this may seem awkward because it isn't always available, but when it is available it is the key piece of information that could help a web app developer understand which node this is. > > > - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? > > I'm not very familiar with how GC works, but Jamesr give me a quick overview. Perhaps we can consider it help only from the VM if the object groups's refcount is equal to the number of JS references. Object groups have no refcounts at all (and nothing in V8 is ref count). There are several complications. For example, JS objects can be retained not only by pure JS references, but by various types of C++ handles (these are counterparts of JS references in C++ land). It might be a good experiment to check how many JS wrapped objects have refcount 1 (when you wrap an object, you ref it), it might indeed reveal some leaks. 345567 4 mnaganov 2011-02-04 10:03:52 -0800 (In reply to comment #3) > (In reply to comment #2) > > (In reply to comment #1) > > > Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. > > > > I've added eae who might be able to explain a little better. But as a simplistic example, imagine a fixed size array where each item points to a DOM node that is no longer attached to the document. As new nodes are added to the front of the array, old nodes are pushed out the end. The app expects that the ones pushed out the end are collected. However, there is some other piece of code (other than the caching array) which has a reference to the node and is preventing its collection. But given the size of the codebase it is difficult to pinpoint what other piece of code is holding the reference alive. > > Just in case, if detached nodes form tree of its own (traversable via parent, children, sibling), they are treated as an object group and therefore should be eligible to GC in the same time, so retainers could be objects in the cache itself. If it's not impossible, I'd suggest you to trace object grouping as well. > > BTW, Mikhail should be able to explain it in more details, but I think he has this feature---list all the retainers of the object---in the heap profiler, at least in experimental variant. BTW, Mikhail, do your retainer thing supports tracing object groups? > I see that I need to include object groups on par with VM GC roots, as they can also prevent objects from deletion. > > > > > > > > For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? > > > > It sounds like the same problem, but I from the description in the bug, I don't fully understand the new feature. > > There was a confusion over term 'id'. You meant HTML element's id while we rather thought of JS object identity. Mikhail's ids are unique ids for the whole life of JS objects (that's trickier than plain pointer as GC can move objects). So if you'd like to trace the life of the object, your best bet is Mikhail's ids. > > > > > > > > > Some questions: > > > - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? > > > > The DOM node's id. > > <div id=foo></div> > > I know this may seem awkward because it isn't always available, but when it is available it is the key piece of information that could help a web app developer understand which node this is. > > OK, got it. Although, no data from DOM nodes is stored in VM's heap, I think it is possible to retrieve it during heap sampling. > > > - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? > > > > I'm not very familiar with how GC works, but Jamesr give me a quick overview. Perhaps we can consider it help only from the VM if the object groups's refcount is equal to the number of JS references. > > Object groups have no refcounts at all (and nothing in V8 is ref count). There are several complications. For example, JS objects can be retained not only by pure JS references, but by various types of C++ handles (these are counterparts of JS references in C++ land). > > It might be a good experiment to check how many JS wrapped objects have refcount 1 (when you wrap an object, you ref it), it might indeed reveal some leaks. 345763 5 jamesr 2011-02-04 13:49:10 -0800 (In reply to comment #4) > (In reply to comment #3) > > (In reply to comment #2) > > > (In reply to comment #1) > > > > Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. > > > > > > I've added eae who might be able to explain a little better. But as a simplistic example, imagine a fixed size array where each item points to a DOM node that is no longer attached to the document. As new nodes are added to the front of the array, old nodes are pushed out the end. The app expects that the ones pushed out the end are collected. However, there is some other piece of code (other than the caching array) which has a reference to the node and is preventing its collection. But given the size of the codebase it is difficult to pinpoint what other piece of code is holding the reference alive. > > > > Just in case, if detached nodes form tree of its own (traversable via parent, children, sibling), they are treated as an object group and therefore should be eligible to GC in the same time, so retainers could be objects in the cache itself. If it's not impossible, I'd suggest you to trace object grouping as well. > > > > BTW, Mikhail should be able to explain it in more details, but I think he has this feature---list all the retainers of the object---in the heap profiler, at least in experimental variant. BTW, Mikhail, do your retainer thing supports tracing object groups? > > > > I see that I need to include object groups on par with VM GC roots, as they can also prevent objects from deletion. > > > > > > > > > > > > For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? > > > > > > It sounds like the same problem, but I from the description in the bug, I don't fully understand the new feature. > > > > There was a confusion over term 'id'. You meant HTML element's id while we rather thought of JS object identity. Mikhail's ids are unique ids for the whole life of JS objects (that's trickier than plain pointer as GC can move objects). So if you'd like to trace the life of the object, your best bet is Mikhail's ids. > > > > > > > > > > > > > Some questions: > > > > - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? > > > > > > The DOM node's id. > > > <div id=foo></div> > > > I know this may seem awkward because it isn't always available, but when it is available it is the key piece of information that could help a web app developer understand which node this is. > > > > > OK, got it. Although, no data from DOM nodes is stored in VM's heap, I think it is possible to retrieve it during heap sampling. My thought was that during the object grouping phase in V8GCController the NodeGrouperVisitor could annotate the object group with additional information like "this object group represents a DOM subtree with 25 nodes and the root node has the DOM id attribute 'foo'". Then references to this object group could also be blamed for that 25 node chunk, even though the actual memory for those DOM nodes is external to the V8 heap. Does that make sense? > > > > > - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? > > > > > > I'm not very familiar with how GC works, but Jamesr give me a quick overview. Perhaps we can consider it help only from the VM if the object groups's refcount is equal to the number of JS references. > > > > Object groups have no refcounts at all (and nothing in V8 is ref count). There are several complications. For example, JS objects can be retained not only by pure JS references, but by various types of C++ handles (these are counterparts of JS references in C++ land). > > > > It might be a good experiment to check how many JS wrapped objects have refcount 1 (when you wrap an object, you ref it), it might indeed reveal some leaks. 345940 6 pmuellr 2011-02-04 17:26:44 -0800 I'm not completely following the discussion here, but have a meta-comment. I suspect the scenario you're wanting to track may be something that not everyone needs. And on the flip-side, there are other similarly-scoped scenarios that other people have, that they'd like to have specialized debugging support for. What I'm wondering is: is there some way that we can give you some low-level tools (JS APIs, at this point, I guess) so you could build the analyzer you want, without having to wait for it to show up in Web Inspector? Turn a default/command-line option on, to enable the additional JS APIs available. 346534 7 antonm 2011-02-07 03:51:49 -0800 (In reply to comment #5) > (In reply to comment #4) > > (In reply to comment #3) > > > (In reply to comment #2) > > > > (In reply to comment #1) > > > > > Can you please provide more info about the caching system (or provide me with source code pointers privately): what the caching system does? If a node is either in cache or in page's DOM tree, it should be never collected, right? So apparently there is some scenario for nodes disposal. > > > > > > > > I've added eae who might be able to explain a little better. But as a simplistic example, imagine a fixed size array where each item points to a DOM node that is no longer attached to the document. As new nodes are added to the front of the array, old nodes are pushed out the end. The app expects that the ones pushed out the end are collected. However, there is some other piece of code (other than the caching array) which has a reference to the node and is preventing its collection. But given the size of the codebase it is difficult to pinpoint what other piece of code is holding the reference alive. > > > > > > Just in case, if detached nodes form tree of its own (traversable via parent, children, sibling), they are treated as an object group and therefore should be eligible to GC in the same time, so retainers could be objects in the cache itself. If it's not impossible, I'd suggest you to trace object grouping as well. > > > > > > BTW, Mikhail should be able to explain it in more details, but I think he has this feature---list all the retainers of the object---in the heap profiler, at least in experimental variant. BTW, Mikhail, do your retainer thing supports tracing object groups? > > > > > > > I see that I need to include object groups on par with VM GC roots, as they can also prevent objects from deletion. > > > > > > > > > > > > > > > > For the new heap profiler (see https://bugs.webkit.org/show_bug.cgi?id=50510) I maintain a map of unique object IDs for heap contents that help to track objects lifetime. Will this help you? > > > > > > > > It sounds like the same problem, but I from the description in the bug, I don't fully understand the new feature. > > > > > > There was a confusion over term 'id'. You meant HTML element's id while we rather thought of JS object identity. Mikhail's ids are unique ids for the whole life of JS objects (that's trickier than plain pointer as GC can move objects). So if you'd like to trace the life of the object, your best bet is Mikhail's ids. > > > > > > > > > > > > > > > > > Some questions: > > > > > - by 'id of the element' do you mean DOM nodes implementation (C++) object addresses, or what? > > > > > > > > The DOM node's id. > > > > <div id=foo></div> > > > > I know this may seem awkward because it isn't always available, but when it is available it is the key piece of information that could help a web app developer understand which node this is. > > > > > > > > OK, got it. Although, no data from DOM nodes is stored in VM's heap, I think it is possible to retrieve it during heap sampling. > > My thought was that during the object grouping phase in V8GCController the NodeGrouperVisitor could annotate the object group with additional information like "this object group represents a DOM subtree with 25 nodes and the root node has the DOM id attribute 'foo'". Then references to this object group could also be blamed for that 25 node chunk, even though the actual memory for those DOM nodes is external to the V8 heap. Does that make sense? James, I think it makes a lot of sense. And if I understand Mikhail right, he was going to implement something like that. I am not sure he was going to collect additional DOM info, but at least make object groups understood by his retainer stuff. > > > > > > > - how can I know that a DOM node is held only from VM -- by verifying that refcount == 1? > > > > > > > > I'm not very familiar with how GC works, but Jamesr give me a quick overview. Perhaps we can consider it help only from the VM if the object groups's refcount is equal to the number of JS references. > > > > > > Object groups have no refcounts at all (and nothing in V8 is ref count). There are several complications. For example, JS objects can be retained not only by pure JS references, but by various types of C++ handles (these are counterparts of JS references in C++ land). > > > > > > It might be a good experiment to check how many JS wrapped objects have refcount 1 (when you wrap an object, you ref it), it might indeed reveal some leaks. 346535 8 antonm 2011-02-07 03:54:14 -0800 (In reply to comment #6) > I'm not completely following the discussion here, but have a meta-comment. > > I suspect the scenario you're wanting to track may be something that not everyone needs. And on the flip-side, there are other similarly-scoped scenarios that other people have, that they'd like to have specialized debugging support for. > > What I'm wondering is: is there some way that we can give you some low-level tools (JS APIs, at this point, I guess) so you could build the analyzer you want, without having to wait for it to show up in Web Inspector? > > Turn a default/command-line option on, to enable the additional JS APIs available. Patrik, the problem is what exact kind of API you want? Plus those low-level APIs sometimes can expose security stuff. But we can always run a private version of Chromium with some additional stuff exposed and somehow (e.g. C++ defines, or something else) disable it for prod builds. But main problem is what kind of API people want and who have enough time and interest to implement them :) 346546 9 pmuellr 2011-02-07 05:26:14 -0800 (In reply to comment #8) > Patrik, the problem is what exact kind of API you want? Plus those low-level APIs sometimes can expose security stuff. But we can always run a private version of Chromium with some additional stuff exposed and somehow (e.g. C++ defines, or something else) disable it for prod builds. > > But main problem is what kind of API people want and who have enough time and interest to implement them :) Again, keep in mind this is a meta-comment; it seems like the original problem description is pretty narrow - it's easy to imagine all sorts of "queries" people might want to have like this - to chase down various types of problems. In terms of an API, the thing I'm most familiar with, publicly, is the Java JVMTI interface: http://download.oracle.com/javase/6/docs/platform/jvmti/jvmti.html here's the API for walking the object space: http://download.oracle.com/javase/6/docs/platform/jvmti/jvmti.html#Heap Yes, YOU can always run a private version of Chrome. Not many people have that luxury :-) 346712 10 mnaganov 2011-02-07 12:19:13 -0800 > > My thought was that during the object grouping phase in V8GCController the NodeGrouperVisitor could annotate the object group with additional information like "this object group represents a DOM subtree with 25 nodes and the root node has the DOM id attribute 'foo'". Then references to this object group could also be blamed for that 25 node chunk, even though the actual memory for those DOM nodes is external to the V8 heap. Does that make sense? > > James, I think it makes a lot of sense. And if I understand Mikhail right, he was going to implement something like that. I am not sure he was going to collect additional DOM info, but at least make object groups understood by his retainer stuff. > > > Yes, the new heap profiler is coming, and I'll enhance it with support for object groups. > > Again, keep in mind this is a meta-comment; it seems like the original problem description is pretty narrow - it's easy to imagine all sorts of "queries" people might want to have like this - to chase down various types of problems. > > In terms of an API, the thing I'm most familiar with, publicly, is the Java JVMTI interface: > > http://download.oracle.com/javase/6/docs/platform/jvmti/jvmti.html > > here's the API for walking the object space: > > http://download.oracle.com/javase/6/docs/platform/jvmti/jvmti.html#Heap > > Yes, YOU can always run a private version of Chrome. Not many people have that luxury :-) Having such an API is nice. It's indispensable when a VM runs on the server side. For client side it may be easier to allow dumping performance data, so people can write analyzers. There is already an ability to send out CPU profiles using 'console.profiles' (although it looks weird that application performance data is exposed to the application itself). And it's also possible to dump heap contents as JSON in V8. Hopefully, we will establish some "standard" on how perf data should be exported for JavaScript, so people will start writing 3rd party analyzers. 355605 11 83390 gregsimon 2011-02-22 14:24:38 -0800 Created attachment 83390 Example showing how JS can cause native growth that can not currently be measured from web inspector or heap profiler Here is a simple example that demonstrates how to "leak" DOM -- here the allocation shows up in the native heap, not the JS heap (meaning you can't use any js heap profilers to figure it out). Also, because the nodes are out of the document, web inspector does not report anything amiss either. What is keeping them alive is a JS binding on the parent of this DOM subtree. 365150 12 85320 mnaganov 2011-03-10 07:17:51 -0800 Created attachment 85320 Enable reporting of object groups and DOM-related entities to the new heap profiler I will need to wait until V8 support will be rolled into Chromium. Until that, the patch will fail to compile. 365154 13 85320 antonm 2011-03-10 07:27:25 -0800 Comment on attachment 85320 Enable reporting of object groups and DOM-related entities to the new heap profiler View in context: https://bugs.webkit.org/attachment.cgi?id=85320&action=review > Source/WebCore/bindings/v8/ScriptProfiler.cpp:101 > + Node* node = reinterpret_cast<Node*>(object->GetPointerFromInternalField(v8DOMWrapperObjectIndex)); I think it should be V8Node::toNative 365163 14 webkit.review.bot 2011-03-10 07:35:12 -0800 Attachment 85320 did not build on chromium: Build output: http://queues.webkit.org/results/8117860 365208 15 vitalyr 2011-03-10 08:37:10 -0800 (In reply to comment #12) > Created an attachment (id=85320) [details] > Enable reporting of object groups and DOM-related entities to the new heap profiler > > I will need to wait until V8 support will be rolled into Chromium. Until that, the patch will fail to compile. Looks good. Given that we can extract the root from any GrouperItem I don't think we need stable sort or "rootIndex". 365940 16 mnaganov 2011-03-11 05:17:54 -0800 (In reply to comment #13) > (From update of attachment 85320 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=85320&action=review > > > Source/WebCore/bindings/v8/ScriptProfiler.cpp:101 > > + Node* node = reinterpret_cast<Node*>(object->GetPointerFromInternalField(v8DOMWrapperObjectIndex)); > > I think it should be V8Node::toNative Thanks! You are right. (In reply to comment #15) > (In reply to comment #12) > > Created an attachment (id=85320) [details] [details] > > Enable reporting of object groups and DOM-related entities to the new heap profiler > > > > I will need to wait until V8 support will be rolled into Chromium. Until that, the patch will fail to compile. > > Looks good. Given that we can extract the root from any GrouperItem I don't think we need stable sort or "rootIndex". Sure. That was a rudimentary change, really unneeded. 365947 17 85463 mnaganov 2011-03-11 05:40:12 -0800 Created attachment 85463 Comments addressed, merged with antonm's changes, added new files that I forgot to add Will still not compile on Chromium, because the new V8 hasn't been rolled yet. 365953 18 webkit.review.bot 2011-03-11 05:55:13 -0800 Attachment 85463 did not build on chromium: Build output: http://queues.webkit.org/results/8132249 366485 19 eric 2011-03-11 19:33:52 -0800 Attachment 85463 did not build on chromium: Build output: http://queues.webkit.org/results/8133564 367628 20 mnaganov 2011-03-15 05:24:05 -0700 V8 version has been updated in Chrome -- it's now possible to land this patch. I'll update Chromium DEPS upstream for WebKit Chromium bots. Anybody to review? 367775 21 abarth 2011-03-15 10:54:32 -0700 I'd be happy to look at it. My only hesitation is that this patch is related to the inspector and I've been criticized in the past for reviewing inspector-related changed. 367784 22 mnaganov 2011-03-15 11:00:46 -0700 (In reply to comment #21) > I'd be happy to look at it. My only hesitation is that this patch is related to the inspector and I've been criticized in the past for reviewing inspector-related changed. I think, Pavel (pfeldman@) can look at Inspector's part. There are also bindings change you can look at. 367849 23 85463 abarth 2011-03-15 12:27:25 -0700 Comment on attachment 85463 Comments addressed, merged with antonm's changes, added new files that I forgot to add View in context: https://bugs.webkit.org/attachment.cgi?id=85463&action=review I didn't look at the inspector parts of the patch. > Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:39 > + : m_root(root) Too much indent. Should be four spaces. > Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:57 > + return other == this > + || reinterpret_cast<WebCore::RetainedObjectInfo*>(other)->GetEquivalenceClass() == this->GetEquivalenceClass(); Should be one line. Also, shouldn't reinterpret_cast be static_cast here? > Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:60 > +intptr_t RetainedDOMInfo::GetHash() All these functions should start with a lower-case letter. Also, WebKit frowns upon names that begin with "get", so this should probably just be "hashValue()" or just "hash()" if it's clear that it's a noun and not a verb. > Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:65 > +const char* RetainedDOMInfo::GetLabel() This should definitely just be "label()" > Source/WebCore/bindings/v8/RetainedDOMInfo.h:53 > + // V8 guarantees to keep RetainedObjectInfos alive only during a GC or heap snapshotting round, when renderer > + // doesn't get control. This allows us to use raw pointers. Can we assert that's the case? > Source/WebCore/bindings/v8/ScriptProfiler.cpp:103 > +static v8::RetainedObjectInfo* getRetainedDOMInfo(uint16_t classId, v8::Handle<v8::Value> wrapper) Another "get" function. > Source/WebCore/bindings/v8/V8GCController.cpp:187 > + { > + } These should not be indented. > Source/WebCore/bindings/v8/V8GCController.cpp:201 > - uintptr_t m_groupId; > + void* m_root; This looks like a hack. Why not use separate types and avoid the reinterpret_casts above? > Source/WebCore/bindings/v8/V8GCController.cpp:203 > + bool m_isDom; Seems like this be removed in favor of null checking a Node* pointer. > Source/WebCore/bindings/v8/V8GCController.cpp:218 > + : m_object(object) too much indent. > Source/WebCore/bindings/v8/V8GCController.cpp:232 > + virtual intptr_t GetHash() Ah, these are overriding v8 virtual methods? That's why they have V8-style names and not WebKit-style names... > Source/WebCore/bindings/v8/V8GCController.cpp:291 > + v8::V8::AddObjectGroup(&group[0], group.size(), new RetainedDOMInfo(rootNode)); The memory management for these object is scary. WebKit very rarely uses manual new/delete, but I understand that V8 is forcing our hands here. 367872 24 timothy 2011-03-15 12:58:03 -0700 Where is the bug requesting parity with JSC bindings? 367963 25 mnaganov 2011-03-15 14:56:05 -0700 (In reply to comment #24) > Where is the bug requesting parity with JSC bindings? My understanding is that JSC is more tightly integrated with WebCore -- as far as I can see in JSDOMBinding code, GC can access DOM objects directly. Thus, it doesn't need the kind of interaction we have implemented for WebKit+V8. 367966 26 pfeldman 2011-03-15 14:59:57 -0700 (In reply to comment #25) > (In reply to comment #24) > > Where is the bug requesting parity with JSC bindings? > > My understanding is that JSC is more tightly integrated with WebCore -- as far as I can see in JSDOMBinding code, GC can access DOM objects directly. Thus, it doesn't need the kind of interaction we have implemented for WebKit+V8. Mikhail, there is an agreement, that all the features of the inspector that are not yet implemented in JSC and are already implemented in V8 are tracked under bugs with xenon in the CC. There should be a clear way / interfaces for JSC bindings to support every feature front-end exposes. Please make sure corresponding bugs are filed and APIs are established. 368330 27 85463 mnaganov 2011-03-16 08:03:26 -0700 Comment on attachment 85463 Comments addressed, merged with antonm's changes, added new files that I forgot to add View in context: https://bugs.webkit.org/attachment.cgi?id=85463&action=review >> Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:39 >> + : m_root(root) > > Too much indent. Should be four spaces. Fixed. >> Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:57 >> + || reinterpret_cast<WebCore::RetainedObjectInfo*>(other)->GetEquivalenceClass() == this->GetEquivalenceClass(); > > Should be one line. Also, shouldn't reinterpret_cast be static_cast here? Fixed. >> Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:60 >> +intptr_t RetainedDOMInfo::GetHash() > > All these functions should start with a lower-case letter. Also, WebKit frowns upon names that begin with "get", so this should probably just be "hashValue()" or just "hash()" if it's clear that it's a noun and not a verb. This class implements an interface from V8 API. That's why V8-style names are used. I've added a comment into RetainedDOMInfo header about this. >> Source/WebCore/bindings/v8/RetainedDOMInfo.cpp:65 >> +const char* RetainedDOMInfo::GetLabel() > > This should definitely just be "label()" ditto >> Source/WebCore/bindings/v8/RetainedDOMInfo.h:53 >> + // doesn't get control. This allows us to use raw pointers. > > Can we assert that's the case? No. We can't ask V8 about it's current state. >> Source/WebCore/bindings/v8/ScriptProfiler.cpp:103 >> +static v8::RetainedObjectInfo* getRetainedDOMInfo(uint16_t classId, v8::Handle<v8::Value> wrapper) > > Another "get" function. Fixed. >> Source/WebCore/bindings/v8/V8GCController.cpp:187 >> + } > > These should not be indented. Fixed. >> Source/WebCore/bindings/v8/V8GCController.cpp:201 >> + void* m_root; > > This looks like a hack. Why not use separate types and avoid the reinterpret_casts above? To save memory, as these cases are mutually exclusive. Changed to union to avoid casts. >> Source/WebCore/bindings/v8/V8GCController.cpp:203 >> + bool m_isDom; > > Seems like this be removed in favor of null checking a Node* pointer. Using enum type for clarity. >> Source/WebCore/bindings/v8/V8GCController.cpp:218 >> + : m_object(object) > > too much indent. Fixed. >> Source/WebCore/bindings/v8/V8GCController.cpp:232 >> + virtual intptr_t GetHash() > > Ah, these are overriding v8 virtual methods? That's why they have V8-style names and not WebKit-style names... Sure. >> Source/WebCore/bindings/v8/V8GCController.cpp:291 >> + v8::V8::AddObjectGroup(&group[0], group.size(), new RetainedDOMInfo(rootNode)); > > The memory management for these object is scary. WebKit very rarely uses manual new/delete, but I understand that V8 is forcing our hands here. We probably can use reference counting and do a deref in 'Dispose' method. But I don't think this will look less scary. 368334 28 85931 mnaganov 2011-03-16 08:24:15 -0700 Created attachment 85931 Again merged with new Anton's change, addressed Adam's comments 368346 29 mnaganov 2011-03-16 09:00:36 -0700 (In reply to comment #26) > (In reply to comment #25) > > (In reply to comment #24) > > > Where is the bug requesting parity with JSC bindings? > > > > My understanding is that JSC is more tightly integrated with WebCore -- as far as I can see in JSDOMBinding code, GC can access DOM objects directly. Thus, it doesn't need the kind of interaction we have implemented for WebKit+V8. > > Mikhail, there is an agreement, that all the features of the inspector that are not yet implemented in JSC and are already implemented in V8 are tracked under bugs with xenon in the CC. There should be a clear way / interfaces for JSC bindings to support every feature front-end exposes. Please make sure corresponding bugs are filed and APIs are established. Filed https://bugs.webkit.org/show_bug.cgi?id=56460 368395 30 85931 pfeldman 2011-03-16 11:06:43 -0700 Comment on attachment 85931 Again merged with new Anton's change, addressed Adam's comments View in context: https://bugs.webkit.org/attachment.cgi?id=85931&action=review > Source/WebCore/inspector/front-end/DetailedHeapshotView.js:296 > + this.appendChild(new WebInspector.DataGridNode({path:WebInspector.UIString("Can't find any paths."), len:""}, false)); Make sure localized string is added. > Source/WebCore/inspector/front-end/DetailedHeapshotView.js:401 > + retainingPathsTitle.textContent = WebInspector.UIString("Paths from the selected object"); ditto 368398 31 antonm 2011-03-16 11:08:28 -0700 LGTM 368430 32 mnaganov 2011-03-16 11:38:37 -0700 (In reply to comment #30) > (From update of attachment 85931 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=85931&action=review > > > Source/WebCore/inspector/front-end/DetailedHeapshotView.js:296 > > + this.appendChild(new WebInspector.DataGridNode({path:WebInspector.UIString("Can't find any paths."), len:""}, false)); > > Make sure localized string is added. > > > Source/WebCore/inspector/front-end/DetailedHeapshotView.js:401 > > + retainingPathsTitle.textContent = WebInspector.UIString("Paths from the selected object"); > > ditto Good catch! I will add them prior to committing. 368960 33 mnaganov 2011-03-17 03:16:10 -0700 Manually committed: http://trac.webkit.org/changeset/81265 2011-03-16 Mikhail Naganov < mnaganov@chromium.org> Reviewed by Pavel Feldman. [Chromium] Report object groups and single DOM-related objects to the new heap profiler. https://bugs.webkit.org/show_bug.cgi?id=53659 * Android.v8bindings.mk: * WebCore.gypi: * WebCore.pro: * bindings/scripts/CodeGeneratorV8.pm: * bindings/v8/RetainedDOMInfo.cpp: Added. (WebCore::RetainedDOMInfo::RetainedDOMInfo): * bindings/v8/RetainedDOMInfo.h: Added. * bindings/v8/RetainedObjectInfo.h: Added. * bindings/v8/ScriptProfiler.cpp: (WebCore::retainedDOMInfo): (WebCore::ScriptProfiler::initialize): * bindings/v8/ScriptProfiler.h: * bindings/v8/V8DOMWindowShell.cpp: (WebCore::V8DOMWindowShell::initContextIfNeeded): * bindings/v8/V8GCController.cpp: (WebCore::GroupId::GrouperItem::GrouperItem): (WebCore::GroupId::GrouperItem::groupId): (WebCore::GroupId::GrouperItem::createRetainedObjectInfo): (WebCore::calculateGroupId): (WebCore::GrouperVisitor::visitDOMWrapper): (WebCore::GrouperVisitor::applyGrouping): * bindings/v8/WrapperTypeInfo.h: * inspector/front-end/DetailedHeapshotGridNodes.js: (WebInspector.HeapSnapshotConstructorNode): (WebInspector.HeapSnapshotConstructorNode.prototype._createNodesProvider): (WebInspector.HeapSnapshotDiffNode): (WebInspector.HeapSnapshotDiffNode.prototype._createNodesProvider.createProvider): (WebInspector.HeapSnapshotDiffNode.prototype._createNodesProvider): * inspector/front-end/DetailedHeapshotView.js: (WebInspector.HeapSnapshotRetainingPathsList.prototype.setDataSource): (WebInspector.HeapSnapshotRetainingPathsList.prototype.refresh): (WebInspector.HeapSnapshotRetainingPathsList.prototype.showNext.startSearching): (WebInspector.HeapSnapshotRetainingPathsList.prototype.showNext): (WebInspector.HeapSnapshotRetainingPathsList.prototype._setRootChildrenForFinder): (WebInspector.DetailedHeapshotView.prototype._changeRetainingPathsRoot): (WebInspector.DetailedHeapshotView.prototype.get isTracingToWindowObjects): * inspector/front-end/HeapSnapshot.js: (WebInspector.HeapSnapshotNode.prototype.get className): (WebInspector.HeapSnapshot.prototype._buildAggregates): (WebInspector.HeapSnapshotPathFinder.prototype.updateRoots): (WebInspector.HeapSnapshotPathFinder.prototype._fillRootChildren): * inspector/front-end/heapProfiler.css: (.detailed-heapshot-view .retaining-paths-view .title > span): (.detailed-heapshot-view .retaining-paths-to-windows): 83390 2011-02-22 14:24:38 -0800 2011-02-22 14:24:38 -0800 Example showing how JS can cause native growth that can not currently be measured from web inspector or heap profiler dom-leak.html text/html 733 gregsimon PCEtLSAKCU1lbW9yeSBncm93dGggc2NlbnJpbwoJCglUaGlzIGNhdXNlcyBuYXRpdmUgbWVtb3J5 IGdyb3d0aCB0aGF0IGNhbiBub3QgYmUgY3VycmVudGx5IHRyYWNrZWQgZnJvbSAKCXRoZSB3ZWIg aW5zcGVjdG9yIG9yIHY4IG1lbW9yeSBwcm9maWxlci4KLS0+CjxodG1sPgoJPGhlYWQ+Cgk8c2Ny aXB0IHR5cGU9J3RleHQvamF2YXNjcmlwdCc+Cgl2YXIgdG9wRWxlbWVudDsKCWZ1bmN0aW9uIHN0 YXJ0VGVzdCgpIHsKCQkKCQl2YXIgdG9wID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3RvcCcp OwoJCXRvcEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKCQl0b3AuYXBw ZW5kQ2hpbGQoIHRvcEVsZW1lbnQgKTsKCQkKCQl0b3AucmVtb3ZlQ2hpbGQoIHRvcEVsZW1lbnQg KTsKCQkKCQkvLyBwdWxsIHRoaXMgbm9kZSBvdXQgb2YgdGhlIHRyZWUsIHRoZW4gd2UnbGwgc3Rh cnQgYWRkaW5nIHRvIGl0LgoJCQoJCXNldEludGVydmFsKCAiYWRkTm9kZVRvT3V0T2ZEb2N1bWVu dFRyZWUoKSIsIDUwMCApOwoJfQoJZnVuY3Rpb24gYWRkTm9kZVRvT3V0T2ZEb2N1bWVudFRyZWUo KSB7CQkKCQl0b3BFbGVtZW50LmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2Rp dicpKTsJCQoJfQoJCgk8L3NjcmlwdD4KCTwvaGVhZD4KCTxib2R5IG9ubG9hZD0nc3RhcnRUZXN0 KCknPgoJCTxkaXYgaWQ9J3RvcCc+VG9wPC9kaXY+Cgk8L2JvZHk+CjwvaHRtbD4KCg== 85320 2011-03-10 07:17:51 -0800 2011-03-11 05:40:12 -0800 Enable reporting of object groups and DOM-related entities to the new heap profiler patch-53659 text/plain 27899 mnaganov ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tayBiL1NvdXJj ZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tawppbmRleCA2MmNjY2Y1Li4wNDg4NmIyIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9BbmRyb2lkLnY4YmluZGluZ3MubWsKKysrIGIvU291 cmNlL1dlYkNvcmUvQW5kcm9pZC52OGJpbmRpbmdzLm1rCkBAIC00NSw2ICs0NSw3IEBAIExPQ0FM X1NSQ19GSUxFUyArPSBcCiAJYmluZGluZ3MvdjgvSURCQmluZGluZ1V0aWxpdGllcy5jcHAgXAog CWJpbmRpbmdzL3Y4L01haW5UaHJlYWRET01EYXRhLmNwcCBcCiAJYmluZGluZ3MvdjgvTlBWOE9i amVjdC5jcHAgXAorCWJpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAgXAogCWJpbmRpbmdz L3Y4L1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIFwKIAliaW5kaW5ncy92OC9TY2hlZHVsZWRB Y3Rpb24uY3BwIFwKIAliaW5kaW5ncy92OC9TY29wZWRET01EYXRhU3RvcmUuY3BwIFwKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCAwYjI3ZTk3Li4zN2Y1NTcyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTMgQEAKKzIw MTEtMDMtMTAgIE1pa2hhaWwgTmFnYW5vdiAgPG1uYWdhbm92QGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbQ2hyb21pdW1dIFJl cG9ydCBvYmplY3QgZ3JvdXBzIGFuZCBzaW5nbGUgRE9NLXJlbGF0ZWQgb2JqZWN0cworICAgICAg ICB0byB0aGUgbmV3IGhlYXAgcHJvZmlsZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01MzY1OQorCisgICAgICAgICogQW5kcm9pZC52OGJpbmRpbmdz Lm1rOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAg ICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JWOC5wbToKKyAgICAgICAgKiBi aW5kaW5ncy92OC9TY3JpcHRQcm9maWxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpnZXRSZXRh aW5lZERPTUluZm8pOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0UHJvZmlsZXI6OmluaXRpYWxp emUpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1NjcmlwdFByb2ZpbGVyLmg6CisgICAgICAgICog YmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWOERP TVdpbmRvd1NoZWxsOjppbml0Q29udGV4dElmTmVlZGVkKToKKyAgICAgICAgKiBiaW5kaW5ncy92 OC9WOEdDQ29udHJvbGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcm91cGVySXRlbTo6R3Jv dXBlckl0ZW0pOgorICAgICAgICAoV2ViQ29yZTo6R3JvdXBlckl0ZW06Omdyb3VwSWQpOgorICAg ICAgICAoV2ViQ29yZTo6R3JvdXBlckl0ZW06OnJvb3QpOgorICAgICAgICAoV2ViQ29yZTo6R3Jv dXBlckl0ZW06OnJvb3ROb2RlKToKKyAgICAgICAgKFdlYkNvcmU6Om1ha2VWOE9iamVjdEdyb3Vw cyk6CisgICAgICAgIChXZWJDb3JlOjpOb2RlR3JvdXBlclZpc2l0b3I6OnZpc2l0RE9NV3JhcHBl cik6CisgICAgICAgIChXZWJDb3JlOjpOb2RlR3JvdXBlclZpc2l0b3I6OmFkZERPTU9iamVjdFRv R3JvdXApOgorICAgICAgICAoV2ViQ29yZTo6RE9NT2JqZWN0R3JvdXBlclZpc2l0b3I6OnZpc2l0 RE9NV3JhcHBlcik6CisgICAgICAgIChXZWJDb3JlOjpET01PYmplY3RHcm91cGVyVmlzaXRvcjo6 YWRkQWxsSXRlbXMpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1dyYXBwZXJUeXBlSW5mby5oOgor ICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdEdyaWROb2Rlcy5q czoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3REaWZmTm9kZSk6CisgICAgICAg IChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUucHJvdG90eXBlLl9jcmVhdGVOb2Rl c1Byb3ZpZGVyLmNyZWF0ZVByb3ZpZGVyKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25h cHNob3REaWZmTm9kZS5wcm90b3R5cGUuX2NyZWF0ZU5vZGVzUHJvdmlkZXIpOgorICAgICAgICAq IGluc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdFZpZXcuanM6CisgICAgICAgIChX ZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZS5zZXRE YXRhU291cmNlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQ YXRoc0xpc3QucHJvdG90eXBlLnJlZnJlc2gpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBT bmFwc2hvdFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5cGUuc2hvd05leHQuc3RhcnRTZWFyY2hp bmcpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFJldGFpbmluZ1BhdGhzTGlz dC5wcm90b3R5cGUuc2hvd05leHQpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hv dFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5cGUuX3NldFJvb3RDaGlsZHJlbkZvckZpbmRlcik6 CisgICAgICAgIChXZWJJbnNwZWN0b3IuRGV0YWlsZWRIZWFwc2hvdFZpZXcucHJvdG90eXBlLl9j aGFuZ2VSZXRhaW5pbmdQYXRoc1Jvb3QpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkRldGFpbGVk SGVhcHNob3RWaWV3LnByb3RvdHlwZS5nZXQgaXNUcmFjaW5nVG9XaW5kb3dPYmplY3RzKToKKyAg ICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL0hlYXBTbmFwc2hvdC5qczoKKyAgICAgICAgKFdl Ykluc3BlY3Rvci5IZWFwU25hcHNob3ROb2RlLnByb3RvdHlwZS5nZXQgY2xhc3NOYW1lKToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3QucHJvdG90eXBlLl9idWlsZEFnZ3JlZ2F0 ZXMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFBhdGhGaW5kZXIucHJvdG90 eXBlLnVwZGF0ZVJvb3RzKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RQYXRo RmluZGVyLnByb3RvdHlwZS5fZmlsbFJvb3RDaGlsZHJlbik6CisgICAgICAgICogaW5zcGVjdG9y L2Zyb250LWVuZC9oZWFwUHJvZmlsZXIuY3NzOgorICAgICAgICAoLmRldGFpbGVkLWhlYXBzaG90 LXZpZXcgLnJldGFpbmluZy1wYXRocy12aWV3IC50aXRsZSA+IHNwYW4pOgorICAgICAgICAoLmRl dGFpbGVkLWhlYXBzaG90LXZpZXcgLnJldGFpbmluZy1wYXRocy10by13aW5kb3dzKToKKwogMjAx MS0wMy0wOSAgUGF2ZWwgUG9kaXZpbG92ICA8cG9kaXZpbG92QGNocm9taXVtLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBQYXZlbCBGZWxkbWFuLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDg3NWQ5 NWUuLjFhOWQyMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysg Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTkxNyw2ICs5MTcsOSBAQAogICAgICAg ICAgICAgJ2JpbmRpbmdzL3Y4L09wdGlvbnNPYmplY3QuY3BwJywKICAgICAgICAgICAgICdiaW5k aW5ncy92OC9PcHRpb25zT2JqZWN0LmgnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L093bkhh bmRsZS5oJywKKyAgICAgICAgICAgICdiaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uaCcsCisg ICAgICAgICAgICAnYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmNwcCcsCisgICAgICAgICAg ICAnYmluZGluZ3MvdjgvUmV0YWluZWRPYmplY3RJbmZvLmgnLAogICAgICAgICAgICAgJ2JpbmRp bmdzL3Y4L1NjaGVkdWxlZEFjdGlvbi5jcHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L1Nj aGVkdWxlZEFjdGlvbi5oJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9TY29wZWRET01EYXRh U3RvcmUuY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUucHJvIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KaW5kZXggMTRhN2QzYi4uNTM4Zjg4ZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8KKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS5wcm8KQEAgLTkwLDYgKzkwLDcgQEAgdjggewogICAgICAgICBiaW5kaW5ncy92OC9ET01EYXRh U3RvcmUuY3BwIFwKICAgICAgICAgYmluZGluZ3MvdjgvTWFpblRocmVhZERPTURhdGEuY3BwIFwK ICAgICAgICAgYmluZGluZ3MvdjgvTlBWOE9iamVjdC5jcHAgXAorICAgICAgICBiaW5kaW5ncy92 OC9SZXRhaW5lZERPTUluZm8uY3BwIFwKICAgICAgICAgYmluZGluZ3MvdjgvU2NoZWR1bGVkQWN0 aW9uLmNwcCBcCiAgICAgICAgIGJpbmRpbmdzL3Y4L1Njb3BlZERPTURhdGFTdG9yZS5jcHAgXAog ICAgICAgICBiaW5kaW5ncy92OC9TY3JpcHRDYWNoZWRGcmFtZURhdGEuY3BwIFwKQEAgLTExOTgs NiArMTE5OSw4IEBAIHY4IHsKICAgICAgICAgYmluZGluZ3MvdjgvbnBydW50aW1lX3ByaXYuaCBc CiAgICAgICAgIGJpbmRpbmdzL3Y4L05QVjhPYmplY3QuaCBcCiAgICAgICAgIGJpbmRpbmdzL3Y4 L093bkhhbmRsZS5oIFwKKyAgICAgICAgYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmggXAor ICAgICAgICBiaW5kaW5ncy92OC9SZXRhaW5lZE9iamVjdEluZm8uaCBcCiAgICAgICAgIGJpbmRp bmdzL3Y4L1NjaGVkdWxlZEFjdGlvbi5oIFwKICAgICAgICAgYmluZGluZ3MvdjgvU2NvcGVkRE9N RGF0YVN0b3JlLmggXAogICAgICAgICBiaW5kaW5ncy92OC9TY3JpcHRDYWNoZWRGcmFtZURhdGEu aCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5l cmF0b3JWOC5wbSBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRv clY4LnBtCmluZGV4IGUyZmUyNzcuLjJjOTgzMWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvclY4LnBtCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvclY4LnBtCkBAIC0yNTA2LDcgKzI1MDYsMTUg QEAgRU5ECiAgICAgfQogCiAgICAgcHVzaChAaW1wbENvbnRlbnQsIDw8RU5EKTsKLSAgICAke2Rv bU1hcEZ1bmN0aW9ufS5zZXQoaW1wbCwgdjg6OlBlcnNpc3RlbnQ8djg6Ok9iamVjdD46Ok5ldyh3 cmFwcGVyKSk7CisgICAgdjg6OlBlcnNpc3RlbnQ8djg6Ok9iamVjdD4gd3JhcHBlckhhbmRsZSA9 IHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+OjpOZXcod3JhcHBlcik7CitFTkQKKyAgICBpZiAo SXNOb2RlU3ViVHlwZSgkZGF0YU5vZGUpKSB7CisgICAgICAgIHB1c2goQGltcGxDb250ZW50LCA8 PEVORCk7CisgICAgd3JhcHBlckhhbmRsZS5TZXRXcmFwcGVyQ2xhc3NJZCh2OERPTVN1YnRyZWVD bGFzc0lkKTsKK0VORAorICAgIH0gICAgCisgICAgcHVzaChAaW1wbENvbnRlbnQsIDw8RU5EKTsK KyAgICAke2RvbU1hcEZ1bmN0aW9ufS5zZXQoaW1wbCwgd3JhcHBlckhhbmRsZSk7CiBFTkQKIAog ICAgIHB1c2goQGltcGxDb250ZW50LCA8PEVORCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9maWxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy92OC9TY3JpcHRQcm9maWxlci5jcHAKaW5kZXggNjE1ZGNmYy4uNmM1Nzk1YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1NjcmlwdFByb2ZpbGVyLmNwcApAQCAtMzIsOSArMzIs MTEgQEAKICNpbmNsdWRlICJTY3JpcHRQcm9maWxlci5oIgogCiAjaW5jbHVkZSAiSW5zcGVjdG9y VmFsdWVzLmgiCisjaW5jbHVkZSAiUmV0YWluZWRET01JbmZvLmgiCisjaW5jbHVkZSAiVjhCaW5k aW5nLmgiCisjaW5jbHVkZSAiV3JhcHBlclR5cGVJbmZvLmgiCiAKICNpbmNsdWRlIDx2OC1wcm9m aWxlci5oPgotI2luY2x1ZGUgPFY4QmluZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK QEAgLTkwLDQgKzkyLDIwIEBAIFBhc3NSZWZQdHI8U2NyaXB0SGVhcFNuYXBzaG90PiBTY3JpcHRQ cm9maWxlcjo6dGFrZUhlYXBTbmFwc2hvdChjb25zdCBTdHJpbmcmIHRpCiAgICAgcmV0dXJuIHNu YXBzaG90ID8gU2NyaXB0SGVhcFNuYXBzaG90OjpjcmVhdGUoc25hcHNob3QpIDogMDsKIH0KIAor c3RhdGljIHY4OjpSZXRhaW5lZE9iamVjdEluZm8qIGdldFJldGFpbmVkRE9NSW5mbyh1aW50MTZf dCBjbGFzc0lkLCB2ODo6SGFuZGxlPHY4OjpWYWx1ZT4gd3JhcHBlcikKK3sKKyAgICBBU1NFUlQo Y2xhc3NJZCA9PSB2OERPTVN1YnRyZWVDbGFzc0lkKTsKKyAgICBpZiAoIXdyYXBwZXItPklzT2Jq ZWN0KCkpCisgICAgICAgIHJldHVybiAwOworICAgIHY4OjpIYW5kbGU8djg6Ok9iamVjdD4gb2Jq ZWN0ID0gd3JhcHBlci5Bczx2ODo6T2JqZWN0PigpOworICAgIE5vZGUqIG5vZGUgPSByZWludGVy cHJldF9jYXN0PE5vZGUqPihvYmplY3QtPkdldFBvaW50ZXJGcm9tSW50ZXJuYWxGaWVsZCh2OERP TVdyYXBwZXJPYmplY3RJbmRleCkpOworICAgIHJldHVybiBub2RlID8gbmV3IFJldGFpbmVkRE9N SW5mbyhub2RlKSA6IDA7Cit9CisKK3ZvaWQgU2NyaXB0UHJvZmlsZXI6OmluaXRpYWxpemUoKQor eworICAgIHY4OjpIZWFwUHJvZmlsZXI6OkRlZmluZVdyYXBwZXJDbGFzcyh2OERPTVN1YnRyZWVD bGFzc0lkLCAmZ2V0UmV0YWluZWRET01JbmZvKTsKK30KKworCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9maWxl ci5oIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIuaAppbmRleCA5 MDE2NjY4Li45NDEwNWY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9T Y3JpcHRQcm9maWxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1NjcmlwdFBy b2ZpbGVyLmgKQEAgLTU2LDYgKzU2LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIHN0YXJ0 KFNjcmlwdFN0YXRlKiBzdGF0ZSwgY29uc3QgU3RyaW5nJiB0aXRsZSk7CiAgICAgc3RhdGljIFBh c3NSZWZQdHI8U2NyaXB0UHJvZmlsZT4gc3RvcChTY3JpcHRTdGF0ZSogc3RhdGUsIGNvbnN0IFN0 cmluZyYgdGl0bGUpOwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNjcmlwdEhlYXBTbmFwc2hvdD4g dGFrZUhlYXBTbmFwc2hvdChjb25zdCBTdHJpbmcmIHRpdGxlLCBIZWFwU25hcHNob3RQcm9ncmVz cyopOworICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemUoKTsKIH07CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4RE9NV2lu ZG93U2hlbGwuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVs bC5jcHAKaW5kZXggNDAzMTJkYS4uYzNhMGNiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHAKQEAgLTQzLDYgKzQzLDcgQEAKICNpbmNsdWRl ICJTY3JpcHRDYWxsU3RhY2suaCIKICNpbmNsdWRlICJTY3JpcHRDYWxsU3RhY2tGYWN0b3J5Lmgi CiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIlNjcmlwdFByb2ZpbGVy LmgiCiAjaW5jbHVkZSAiU3RvcmFnZU5hbWVzcGFjZS5oIgogI2luY2x1ZGUgIlY4QmluZGluZy5o IgogI2luY2x1ZGUgIlY4QmluZGluZ1N0YXRlLmgiCkBAIC0yOTcsNiArMjk4LDggQEAgYm9vbCBW OERPTVdpbmRvd1NoZWxsOjppbml0Q29udGV4dElmTmVlZGVkKCkKIAogICAgICAgICB2ODo6Vjg6 OlNldEZhaWxlZEFjY2Vzc0NoZWNrQ2FsbGJhY2tGdW5jdGlvbihyZXBvcnRVbnNhZmVKYXZhU2Ny aXB0QWNjZXNzKTsKIAorICAgICAgICBTY3JpcHRQcm9maWxlcjo6aW5pdGlhbGl6ZSgpOworICAg ICAgICAKICAgICAgICAgaXNWOEluaXRpYWxpemVkID0gdHJ1ZTsKICAgICB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcAppbmRleCBhMzRkYzI0Li5j ZDhmMzI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9WOEdDQ29udHJv bGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhHQ0NvbnRyb2xsZXIu Y3BwCkBAIC0zOSw2ICszOSw4IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAi TWVzc2FnZVBvcnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUJyaWRnZS5oIgorI2luY2x1ZGUgIlJl dGFpbmVkRE9NSW5mby5oIgorI2luY2x1ZGUgIlJldGFpbmVkT2JqZWN0SW5mby5oIgogI2luY2x1 ZGUgIlNWR0VsZW1lbnQuaCIKICNpbmNsdWRlICJWOEJpbmRpbmcuaCIKICNpbmNsdWRlICJWOENT U0NoYXJzZXRSdWxlLmgiCkBAIC0xNzcsMTggKzE3OSwyOCBAQCBwdWJsaWM6CiAKIGNsYXNzIEdy b3VwZXJJdGVtIHsKIHB1YmxpYzoKLSAgICBHcm91cGVySXRlbSh1aW50cHRyX3QgZ3JvdXBJZCwg djg6OlBlcnNpc3RlbnQ8djg6Ok9iamVjdD4gd3JhcHBlcikgCi0gICAgICAgIDogbV9ncm91cElk KGdyb3VwSWQpCi0gICAgICAgICwgbV93cmFwcGVyKHdyYXBwZXIpIAorICAgIEdyb3VwZXJJdGVt KHZvaWQqIHJvb3QsIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpIAorICAgICAg ICA6IG1fcm9vdChyb290KQorICAgICAgICAsIG1fd3JhcHBlcih3cmFwcGVyKQorICAgICAgICAs IG1faXNEb20oZmFsc2UpCisgICAgICAgIHsKKyAgICAgICAgfQorICAgIEdyb3VwZXJJdGVtKE5v ZGUqIHJvb3QsIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpCisgICAgICAgIDog bV9yb290KHJvb3QpCisgICAgICAgICwgbV93cmFwcGVyKHdyYXBwZXIpCisgICAgICAgICwgbV9p c0RvbSh0cnVlKQogICAgICAgICB7CiAgICAgICAgIH0KIAotICAgIHVpbnRwdHJfdCBncm91cElk KCkgY29uc3QgeyByZXR1cm4gbV9ncm91cElkOyB9CisgICAgdWludHB0cl90IGdyb3VwSWQoKSBj b25zdCB7IHJldHVybiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4obV9yb290KTsgfQorICAg IHZvaWQqIHJvb3QoKSBjb25zdCB7IHJldHVybiBtX3Jvb3Q7IH0KKyAgICBOb2RlKiByb290Tm9k ZSgpIGNvbnN0IHsgcmV0dXJuIG1faXNEb20gPyByZWludGVycHJldF9jYXN0PE5vZGUqPihtX3Jv b3QpIDogMDsgfQogICAgIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIoKSBjb25z dCB7IHJldHVybiBtX3dyYXBwZXI7IH0KIAogcHJpdmF0ZToKLSAgICB1aW50cHRyX3QgbV9ncm91 cElkOworICAgIHZvaWQqIG1fcm9vdDsKICAgICB2ODo6UGVyc2lzdGVudDx2ODo6T2JqZWN0PiBt X3dyYXBwZXI7CisgICAgYm9vbCBtX2lzRG9tOwogfTsKIAogYm9vbCBvcGVyYXRvcjwoY29uc3Qg R3JvdXBlckl0ZW0mIGEsIGNvbnN0IEdyb3VwZXJJdGVtJiBiKQpAQCAtMTk4LDEwICsyMTAsNTAg QEAgYm9vbCBvcGVyYXRvcjwoY29uc3QgR3JvdXBlckl0ZW0mIGEsIGNvbnN0IEdyb3VwZXJJdGVt JiBiKQogCiB0eXBlZGVmIFZlY3RvcjxHcm91cGVySXRlbT4gR3JvdXBlckxpc3Q7CiAKK25hbWVz cGFjZSB7CisKK2NsYXNzIFVuc3BlY2lmaWVkR3JvdXAgOiBwdWJsaWMgUmV0YWluZWRPYmplY3RJ bmZvIHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBVbnNwZWNpZmllZEdyb3VwKHZvaWQqIG9iamVj dCkKKyAgICAgICAgICAgIDogbV9vYmplY3Qob2JqZWN0KQorICAgIHsKKyAgICAgICAgQVNTRVJU KG1fb2JqZWN0KTsKKyAgICB9CisgICAgCisgICAgdmlydHVhbCB2b2lkIERpc3Bvc2UoKSB7IGRl bGV0ZSB0aGlzOyB9CisgIAorICAgIHZpcnR1YWwgYm9vbCBJc0VxdWl2YWxlbnQodjg6OlJldGFp bmVkT2JqZWN0SW5mbyogb3RoZXIpCisgICAgeworICAgICAgICBBU1NFUlQob3RoZXIpOworICAg ICAgICByZXR1cm4gb3RoZXIgPT0gdGhpcworICAgICAgICAgICAgICAgIHx8IHJlaW50ZXJwcmV0 X2Nhc3Q8V2ViQ29yZTo6UmV0YWluZWRPYmplY3RJbmZvKj4ob3RoZXIpLT5HZXRFcXVpdmFsZW5j ZUNsYXNzKCkgPT0gdGhpcy0+R2V0RXF1aXZhbGVuY2VDbGFzcygpOworICAgIH0KKworICAgIHZp cnR1YWwgaW50cHRyX3QgR2V0SGFzaCgpCisgICAgeworICAgICAgICByZXR1cm4gcmVpbnRlcnBy ZXRfY2FzdDxpbnRwdHJfdD4obV9vYmplY3QpOworICAgIH0KKyAgICAKKyAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIEdldExhYmVsKCkKKyAgICB7CisgICAgICAgIHJldHVybiAiT2JqZWN0IGdyb3Vw IjsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGludHB0cl90IEdldEVxdWl2YWxlbmNlQ2xhc3MoKQor ICAgIHsKKyAgICAgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8aW50cHRyX3Q+KG1fb2JqZWN0 KTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgdm9pZCogbV9vYmplY3Q7Cit9OworCit9CisKIHZv aWQgbWFrZVY4T2JqZWN0R3JvdXBzKEdyb3VwZXJMaXN0JiBncm91cGVyKQogewogICAgIC8vIEdy b3VwIGJ5IHNvcnRpbmcgYnkgdGhlIGdyb3VwIGlkLgotICAgIHN0ZDo6c29ydChncm91cGVyLmJl Z2luKCksIGdyb3VwZXIuZW5kKCkpOworICAgIHN0ZDo6c3RhYmxlX3NvcnQoZ3JvdXBlci5iZWdp bigpLCBncm91cGVyLmVuZCgpKTsKIAogICAgIC8vIEZJWE1FIFNob3VsZCBwcm9iYWJseSB3b3Jr IGluIGl0ZXJhdG9ycyBoZXJlLCBidXQgaW5kZXhlcyB3ZXJlIGVhc2llciBmb3IgbXkgc2ltcGxl IG1pbmQuCiAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBncm91cGVyLnNpemUoKTsgKSB7CkBA IC0yMjMsNiArMjc1LDggQEAgdm9pZCBtYWtlVjhPYmplY3RHcm91cHMoR3JvdXBlckxpc3QmIGdy b3VwZXIpCiAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgfQogCisgICAgICAgIHNpemVf dCByb290SW5kZXggPSBpOworCiAgICAgICAgIFZlY3Rvcjx2ODo6UGVyc2lzdGVudDx2ODo6VmFs dWU+ID4gZ3JvdXA7CiAgICAgICAgIGdyb3VwLnJlc2VydmVDYXBhY2l0eShuZXh0S2V5SW5kZXgg LSBpKTsKICAgICAgICAgZm9yICg7IGkgPCBuZXh0S2V5SW5kZXg7ICsraSkgewpAQCAtMjMxLDgg KzI4NSwxMyBAQCB2b2lkIG1ha2VWOE9iamVjdEdyb3VwcyhHcm91cGVyTGlzdCYgZ3JvdXBlcikK ICAgICAgICAgICAgICAgICBncm91cC5hcHBlbmQod3JhcHBlcik7CiAgICAgICAgIH0KIAotICAg ICAgICBpZiAoZ3JvdXAuc2l6ZSgpID4gMSkKLSAgICAgICAgICAgIHY4OjpWODo6QWRkT2JqZWN0 R3JvdXAoJmdyb3VwWzBdLCBncm91cC5zaXplKCkpOworICAgICAgICBpZiAoZ3JvdXAuc2l6ZSgp ID4gMSkgeworICAgICAgICAgICAgTm9kZSogcm9vdE5vZGUgPSBncm91cGVyW3Jvb3RJbmRleF0u cm9vdE5vZGUoKTsKKyAgICAgICAgICAgIGlmIChyb290Tm9kZSkKKyAgICAgICAgICAgICAgICB2 ODo6Vjg6OkFkZE9iamVjdEdyb3VwKCZncm91cFswXSwgZ3JvdXAuc2l6ZSgpLCBuZXcgUmV0YWlu ZWRET01JbmZvKHJvb3ROb2RlKSk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAg djg6OlY4OjpBZGRPYmplY3RHcm91cCgmZ3JvdXBbMF0sIGdyb3VwLnNpemUoKSwgbmV3IFVuc3Bl Y2lmaWVkR3JvdXAoZ3JvdXBlcltyb290SW5kZXhdLnJvb3QoKSkpOworICAgICAgICB9CiAKICAg ICAgICAgQVNTRVJUKGkgPT0gbmV4dEtleUluZGV4KTsKICAgICB9CkBAIC0yNTUsNTkgKzMxNCw1 OCBAQCBwdWJsaWM6CiAgICAgICAgIC8vCiAgICAgICAgIC8vIE90aGVyd2lzZSwgdGhlIG5vZGUg aXMgcHV0IGluIGFuIG9iamVjdCBncm91cCBpZGVudGlmaWVkIGJ5IHRoZSByb290CiAgICAgICAg IC8vIGVsZW1lbnQgb2YgdGhlIHRyZWUgdG8gd2hpY2ggaXQgYmVsb25ncy4KLSAgICAgICAgdWlu dHB0cl90IGdyb3VwSWQ7CisgICAgICAgIE5vZGUqIGdyb3VwUm9vdDsKICAgICAgICAgaWYgKG5v ZGUtPmluRG9jdW1lbnQoKSB8fCAobm9kZS0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OmltZ1RhZykg JiYgIXN0YXRpY19jYXN0PEhUTUxJbWFnZUVsZW1lbnQqPihub2RlKS0+aGF2ZUZpcmVkTG9hZEV2 ZW50KCkpKQotICAgICAgICAgICAgZ3JvdXBJZCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90 Pihub2RlLT5kb2N1bWVudCgpKTsKKyAgICAgICAgICAgIGdyb3VwUm9vdCA9IG5vZGUtPmRvY3Vt ZW50KCk7CiAgICAgICAgIGVsc2UgewotICAgICAgICAgICAgTm9kZSogcm9vdCA9IG5vZGU7Cisg ICAgICAgICAgICBncm91cFJvb3QgPSBub2RlOwogICAgICAgICAgICAgaWYgKG5vZGUtPmlzQXR0 cmlidXRlTm9kZSgpKSB7Ci0gICAgICAgICAgICAgICAgcm9vdCA9IHN0YXRpY19jYXN0PEF0dHIq Pihub2RlKS0+b3duZXJFbGVtZW50KCk7CisgICAgICAgICAgICAgICAgZ3JvdXBSb290ID0gc3Rh dGljX2Nhc3Q8QXR0cio+KG5vZGUpLT5vd25lckVsZW1lbnQoKTsKICAgICAgICAgICAgICAgICAv LyBJZiB0aGUgYXR0cmlidXRlIGhhcyBubyBlbGVtZW50LCBubyBuZWVkIHRvIHB1dCBpdCBpbiB0 aGUgZ3JvdXAsCiAgICAgICAgICAgICAgICAgLy8gYmVjYXVzZSBpdCdsbCBhbHdheXMgYmUgYSBn cm91cCBvZiAxLgotICAgICAgICAgICAgICAgIGlmICghcm9vdCkKKyAgICAgICAgICAgICAgICBp ZiAoIWdyb3VwUm9vdCkKICAgICAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICAg fSBlbHNlIHsKLSAgICAgICAgICAgICAgICB3aGlsZSAocm9vdC0+cGFyZW50Tm9kZSgpKQotICAg ICAgICAgICAgICAgICAgICByb290ID0gcm9vdC0+cGFyZW50Tm9kZSgpOworICAgICAgICAgICAg ICAgIHdoaWxlIChncm91cFJvb3QtPnBhcmVudE5vZGUoKSkKKyAgICAgICAgICAgICAgICAgICAg Z3JvdXBSb290ID0gZ3JvdXBSb290LT5wYXJlbnROb2RlKCk7CiAKICAgICAgICAgICAgICAgICAv LyBJZiB0aGUgbm9kZSBpcyBhbG9uZSBpbiBpdHMgRE9NIHRyZWUgKGRvZXNuJ3QgaGF2ZSBhIHBh cmVudCBvciBhbnkKICAgICAgICAgICAgICAgICAvLyBjaGlsZHJlbikgdGhlbiB0aGUgZ3JvdXAg d2lsbCBiZSBmaWx0ZXJlZCBvdXQgbGF0ZXIgYW55d2F5LgotICAgICAgICAgICAgICAgIGlmIChy b290ID09IG5vZGUgJiYgIW5vZGUtPmhhc0NoaWxkTm9kZXMoKSAmJiAhbm9kZS0+aGFzQXR0cmli dXRlcygpKQorICAgICAgICAgICAgICAgIGlmIChncm91cFJvb3QgPT0gbm9kZSAmJiAhbm9kZS0+ aGFzQ2hpbGROb2RlcygpICYmICFub2RlLT5oYXNBdHRyaWJ1dGVzKCkpCiAgICAgICAgICAgICAg ICAgICAgIHJldHVybjsKICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGdyb3VwSWQgPSByZWlu dGVycHJldF9jYXN0PHVpbnRwdHJfdD4ocm9vdCk7CiAgICAgICAgIH0KLSAgICAgICAgbV9ncm91 cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElkLCB3cmFwcGVyKSk7CisgICAgICAgIG1fZ3Jv dXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBSb290LCB3cmFwcGVyKSk7CiAKICAgICAgICAg Ly8gSWYgdGhlIG5vZGUgaXMgc3R5bGVkIGFuZCB0aGVyZSBpcyBhIHdyYXBwZXIgZm9yIHRoZSBp bmxpbmUKICAgICAgICAgLy8gc3R5bGUgZGVjbGFyYXRpb24sIHdlIG5lZWQgdG8ga2VlcCB0aGF0 IHN0eWxlIGRlY2xhcmF0aW9uCiAgICAgICAgIC8vIHdyYXBwZXIgYWxpdmUgYXMgd2VsbCwgc28g d2UgYWRkIGl0IHRvIHRoZSBvYmplY3QgZ3JvdXAuCiAgICAgICAgIGlmIChub2RlLT5pc1N0eWxl ZEVsZW1lbnQoKSkgewogICAgICAgICAgICAgU3R5bGVkRWxlbWVudCogZWxlbWVudCA9IHJlaW50 ZXJwcmV0X2Nhc3Q8U3R5bGVkRWxlbWVudCo+KG5vZGUpOwotICAgICAgICAgICAgYWRkRE9NT2Jq ZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgZWxlbWVudC0+aW5saW5lU3R5bGVEZWNsKCkpOwor ICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBSb290LCBlbGVtZW50 LT5pbmxpbmVTdHlsZURlY2woKSk7CiAgICAgICAgIH0KIAogICAgICAgICBpZiAobm9kZS0+aXNE b2N1bWVudE5vZGUoKSkgewogICAgICAgICAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gcmVpbnRl cnByZXRfY2FzdDxEb2N1bWVudCo+KG5vZGUpOwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9H cm91cChzdG9yZSwgZ3JvdXBJZCwgZG9jdW1lbnQtPnN0eWxlU2hlZXRzKCkpOwotICAgICAgICAg ICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgZG9jdW1lbnQtPmltcGxlbWVu dGF0aW9uKCkpOworICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBS b290LCBkb2N1bWVudC0+c3R5bGVTaGVldHMoKSk7CisgICAgICAgICAgICBhZGRET01PYmplY3RU b0dyb3VwKHN0b3JlLCBncm91cFJvb3QsIGRvY3VtZW50LT5pbXBsZW1lbnRhdGlvbigpKTsKICAg ICAgICAgfQogCiAgICAgICAgIFdyYXBwZXJUeXBlSW5mbyogdHlwZUluZm8gPSBWOERPTVdyYXBw ZXI6OmRvbVdyYXBwZXJUeXBlKHdyYXBwZXIpOwogCiAgICAgICAgIGlmIChWOEhUTUxMaW5rRWxl bWVudDo6aW5mby5lcXVhbHModHlwZUluZm8pKSB7CiAgICAgICAgICAgICBIVE1MTGlua0VsZW1l bnQqIGh0bWxMaW5rRWxlbWVudCA9IHN0YXRpY19jYXN0PEhUTUxMaW5rRWxlbWVudCo+KG5vZGUp OwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgaHRtbExp bmtFbGVtZW50LT5zaGVldCgpKTsKKyAgICAgICAgICAgIGFkZERPTU9iamVjdFRvR3JvdXAoc3Rv cmUsIGdyb3VwUm9vdCwgaHRtbExpbmtFbGVtZW50LT5zaGVldCgpKTsKICAgICAgICAgfQogCiAg ICAgICAgIGlmIChWOEhUTUxTdHlsZUVsZW1lbnQ6OmluZm8uZXF1YWxzKHR5cGVJbmZvKSkgewog ICAgICAgICAgICAgSFRNTFN0eWxlRWxlbWVudCogaHRtbFN0eWxlRWxlbWVudCA9IHN0YXRpY19j YXN0PEhUTUxTdHlsZUVsZW1lbnQqPihub2RlKTsKLSAgICAgICAgICAgIGFkZERPTU9iamVjdFRv R3JvdXAoc3RvcmUsIGdyb3VwSWQsIGh0bWxTdHlsZUVsZW1lbnQtPnNoZWV0KCkpOworICAgICAg ICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBSb290LCBodG1sU3R5bGVFbGVt ZW50LT5zaGVldCgpKTsKICAgICAgICAgfQogCiAgICAgICAgIGlmIChWOFByb2Nlc3NpbmdJbnN0 cnVjdGlvbjo6aW5mby5lcXVhbHModHlwZUluZm8pKSB7CiAgICAgICAgICAgICBQcm9jZXNzaW5n SW5zdHJ1Y3Rpb24qIHByb2Nlc3NpbmdJbnN0cnVjdGlvbiA9IHN0YXRpY19jYXN0PFByb2Nlc3Np bmdJbnN0cnVjdGlvbio+KG5vZGUpOwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChz dG9yZSwgZ3JvdXBJZCwgcHJvY2Vzc2luZ0luc3RydWN0aW9uLT5zaGVldCgpKTsKKyAgICAgICAg ICAgIGFkZERPTU9iamVjdFRvR3JvdXAoc3RvcmUsIGdyb3VwUm9vdCwgcHJvY2Vzc2luZ0luc3Ry dWN0aW9uLT5zaGVldCgpKTsKICAgICAgICAgfQogICAgIH0KIApAQCAtMzE5LDEzICszNzcsMTMg QEAgcHVibGljOgogcHJpdmF0ZToKICAgICBHcm91cGVyTGlzdCBtX2dyb3VwZXI7CiAKLSAgICB2 b2lkIGFkZERPTU9iamVjdFRvR3JvdXAoRE9NRGF0YVN0b3JlKiBzdG9yZSwgdWludHB0cl90IGdy b3VwSWQsIHZvaWQqIG9iamVjdCkKKyAgICB2b2lkIGFkZERPTU9iamVjdFRvR3JvdXAoRE9NRGF0 YVN0b3JlKiBzdG9yZSwgTm9kZSogZ3JvdXBSb290LCB2b2lkKiBvYmplY3QpCiAgICAgewogICAg ICAgICBpZiAoIW9iamVjdCkKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgdjg6OlBlcnNp c3RlbnQ8djg6Ok9iamVjdD4gd3JhcHBlciA9IHN0b3JlLT5kb21PYmplY3RNYXAoKS5nZXQob2Jq ZWN0KTsKICAgICAgICAgaWYgKCF3cmFwcGVyLklzRW1wdHkoKSkKLSAgICAgICAgICAgIG1fZ3Jv dXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOworICAgICAgICAgICAg bV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cFJvb3QsIHdyYXBwZXIpKTsKICAgICB9 CiB9OwogCkBAIC0zNzAsOSArNDI4LDcgQEAgcHVibGljOgogICAgICAgICAgICAgICAgICAgICBi cmVhazsKICAgICAgICAgICAgICAgICByb290ID0gcGFyZW50OwogICAgICAgICAgICAgfQotICAg ICAgICAgICAgLy8gR3JvdXAgaWQgaXMgYW4gYWRkcmVzcyBvZiB0aGUgcm9vdC4KLSAgICAgICAg ICAgIHVpbnRwdHJfdCBncm91cElkID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KHJvb3Qp OwotICAgICAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElkLCB3cmFw cGVyKSk7CisgICAgICAgICAgICBtX2dyb3VwZXIuYXBwZW5kKEdyb3VwZXJJdGVtKHJvb3QsIHdy YXBwZXIpKTsKIAogICAgICAgICAgICAgaWYgKFY4Q1NTU3R5bGVEZWNsYXJhdGlvbjo6aW5mby5l cXVhbHModHlwZUluZm8pKSB7CiAgICAgICAgICAgICAgICAgQ1NTU3R5bGVEZWNsYXJhdGlvbiog Y3NzU3R5bGVEZWNsYXJhdGlvbiA9IHN0YXRpY19jYXN0PENTU1N0eWxlRGVjbGFyYXRpb24qPihz dHlsZUJhc2UpOwpAQCAtMzgyLDcgKzQzOCw3IEBAIHB1YmxpYzoKICAgICAgICAgICAgICAgICAg ICAgZm9yIChDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbjo6Y29uc3RfaXRlcmF0b3IgaXQgPSBj c3NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbi0+YmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CiAg ICAgICAgICAgICAgICAgICAgICAgICB3cmFwcGVyID0gc3RvcmUtPmRvbU9iamVjdE1hcCgpLmdl dChpdC0+dmFsdWUoKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIXdyYXBwZXIuSXNF bXB0eSgpKQotICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3Jv dXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOworICAgICAgICAgICAgICAgICAgICAgICAgICAg IG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0ocm9vdCwgd3JhcHBlcikpOwogICAgICAgICAg ICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgfQpAQCAtMzk5LDEy ICs0NTUsMTEgQEAgcHJpdmF0ZToKICAgICB0ZW1wbGF0ZSA8Y2xhc3MgQz4KICAgICB2b2lkIGFk ZEFsbEl0ZW1zKERPTURhdGFTdG9yZSogc3RvcmUsIEMqIGNvbGxlY3Rpb24sIHY4OjpQZXJzaXN0 ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpCiAgICAgewotICAgICAgICB1aW50cHRyX3QgZ3JvdXBJ ZCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90Pihjb2xsZWN0aW9uKTsKLSAgICAgICAgbV9n cm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElkLCB3cmFwcGVyKSk7CisgICAgICAgIG1f Z3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oY29sbGVjdGlvbiwgd3JhcHBlcikpOwogICAgICAg ICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY29sbGVjdGlvbi0+bGVuZ3RoKCk7IGkrKykgewog ICAgICAgICAgICAgd3JhcHBlciA9IHN0b3JlLT5kb21PYmplY3RNYXAoKS5nZXQoY29sbGVjdGlv bi0+aXRlbShpKSk7CiAgICAgICAgICAgICBpZiAoIXdyYXBwZXIuSXNFbXB0eSgpKQotICAgICAg ICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikp OworICAgICAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oY29sbGVjdGlv biwgd3JhcHBlcikpOwogICAgICAgICB9CiAgICAgfQogfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL3Y4L1dyYXBwZXJUeXBlSW5mby5oIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvdjgvV3JhcHBlclR5cGVJbmZvLmgKaW5kZXggMWQxY2JmZC4uZTA3YWQwZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvV3JhcHBlclR5cGVJbmZvLmgKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvV3JhcHBlclR5cGVJbmZvLmgKQEAgLTQxLDcgKzQx LDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHN0YXRpYyBjb25zdCBpbnQgdjhET01XcmFw cGVyT2JqZWN0SW5kZXggPSAxOwogICAgIHN0YXRpYyBjb25zdCBpbnQgdjhET01IaWRkZW5SZWZl cmVuY2VBcnJheUluZGV4ID0gMjsKICAgICBzdGF0aWMgY29uc3QgaW50IHY4RGVmYXVsdFdyYXBw ZXJJbnRlcm5hbEZpZWxkQ291bnQgPSAzOwotICAgIAorCisgICAgc3RhdGljIGNvbnN0IHVpbnQx Nl90IHY4RE9NU3VidHJlZUNsYXNzSWQgPSAxOworCiAgICAgdHlwZWRlZiB2ODo6UGVyc2lzdGVu dDx2ODo6RnVuY3Rpb25UZW1wbGF0ZT4gKCpHZXRUZW1wbGF0ZUZ1bmN0aW9uKSgpOwogICAgIHR5 cGVkZWYgdm9pZCAoKkRlcmVmT2JqZWN0RnVuY3Rpb24pKHZvaWQqKTsKICAgICB0eXBlZGVmIEFj dGl2ZURPTU9iamVjdCogKCpUb0FjdGl2ZURPTU9iamVjdEZ1bmN0aW9uKSh2ODo6SGFuZGxlPHY4 OjpPYmplY3Q+KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1l bmQvRGV0YWlsZWRIZWFwc2hvdEdyaWROb2Rlcy5qcyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rv ci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdEdyaWROb2Rlcy5qcwppbmRleCAxNGJhMTQyLi5k ZmQ3YTI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0Rl dGFpbGVkSGVhcHNob3RHcmlkTm9kZXMuanMKKysrIGIvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9y L2Zyb250LWVuZC9EZXRhaWxlZEhlYXBzaG90R3JpZE5vZGVzLmpzCkBAIC00OTgsMTYgKzQ5OCwx NiBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90SXRlcmF0b3JzVHVwbGUucHJvdG90eXBlID0g ewogICAgIH0KIH07CiAKLVdlYkluc3BlY3Rvci5IZWFwU25hcHNob3REaWZmTm9kZSA9IGZ1bmN0 aW9uKHRyZWUsIGNvbnN0cnVjdG9yLCBiYXNlQWdncmVnYXRlLCBhZ2dyZWdhdGUpCitXZWJJbnNw ZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUgPSBmdW5jdGlvbih0cmVlLCBjbGFzc05hbWUsIGJh c2VBZ2dyZWdhdGUsIGFnZ3JlZ2F0ZSkKIHsKICAgICBpZiAoIWJhc2VBZ2dyZWdhdGUpCiAgICAg ICAgIGJhc2VBZ2dyZWdhdGUgPSB7IGNvdW50OiAwLCBzZWxmOiAwLCBtYXhSZXQ6IDAsIHR5cGU6 YWdncmVnYXRlLnR5cGUsIG5hbWU6YWdncmVnYXRlLm5hbWUsIGlkeHM6IFtdIH07CiAgICAgaWYg KCFhZ2dyZWdhdGUpCiAgICAgICAgIGFnZ3JlZ2F0ZSA9IHsgY291bnQ6IDAsIHNlbGY6IDAsIG1h eFJldDogMCwgdHlwZTpiYXNlQWdncmVnYXRlLnR5cGUsIG5hbWU6YmFzZUFnZ3JlZ2F0ZS5uYW1l LCBpZHhzOiBbXSB9OwogICAgIFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RHcmlkTm9kZS5jYWxs KHRoaXMsIHRyZWUsIHRydWUsIDUwKTsKLSAgICB0aGlzLl9uYW1lID0gY29uc3RydWN0b3I7Cisg ICAgdGhpcy5fbmFtZSA9IGNsYXNzTmFtZTsKICAgICB0aGlzLl9jYWxjdWxhdGVEaWZmKHRyZWUu YmFzZVNuYXBzaG90LCB0cmVlLnNuYXBzaG90LCBiYXNlQWdncmVnYXRlLmlkeHMsIGFnZ3JlZ2F0 ZS5pZHhzKTsKLSAgICB0aGlzLl9wcm92aWRlciA9IHRoaXMuX2NyZWF0ZU5vZGVzUHJvdmlkZXIo dHJlZS5iYXNlU25hcHNob3QsIHRyZWUuc25hcHNob3QsIGFnZ3JlZ2F0ZS50eXBlLCBhZ2dyZWdh dGUubmFtZSk7CisgICAgdGhpcy5fcHJvdmlkZXIgPSB0aGlzLl9jcmVhdGVOb2Rlc1Byb3ZpZGVy KHRyZWUuYmFzZVNuYXBzaG90LCB0cmVlLnNuYXBzaG90LCBhZ2dyZWdhdGUudHlwZSwgY2xhc3NO YW1lKTsKIH0KIAogV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdERpZmZOb2RlLnByb3RvdHlwZSA9 IHsKQEAgLTU1OSw3ICs1NTksNyBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUu cHJvdG90eXBlID0gewogICAgICAgICAgICAgcmV0dXJuIG5ldyBXZWJJbnNwZWN0b3IuSGVhcFNu YXBzaG90SW5zdGFuY2VOb2RlKHRoaXMuZGF0YUdyaWQsIHByb3ZpZGVyLnNuYXBzaG90LCBudWxs LCBwcm92aWRlci5pdGVtKTsKICAgICB9LAogCi0gICAgX2NyZWF0ZU5vZGVzUHJvdmlkZXI6IGZ1 bmN0aW9uKGJhc2VTbmFwc2hvdCwgc25hcHNob3QsIG5vZGVUeXBlLCBub2RlTmFtZSkKKyAgICBf Y3JlYXRlTm9kZXNQcm92aWRlcjogZnVuY3Rpb24oYmFzZVNuYXBzaG90LCBzbmFwc2hvdCwgbm9k ZVR5cGUsIG5vZGVDbGFzc05hbWUpCiAgICAgewogICAgICAgICByZXR1cm4gbmV3IFdlYkluc3Bl Y3Rvci5IZWFwU25hcHNob3RJdGVyYXRvcnNUdXBsZSgKICAgICAgICAgICAgIGNyZWF0ZVByb3Zp ZGVyKHNuYXBzaG90LCBiYXNlU25hcHNob3QpLCBjcmVhdGVQcm92aWRlcihiYXNlU25hcHNob3Qs IHNuYXBzaG90KSk7CkBAIC01NzEsNyArNTcxLDcgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hv dERpZmZOb2RlLnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgICAgICBzbmFwc2hvdC5hbGxOb2Rl cywKICAgICAgICAgICAgICAgICBmdW5jdGlvbiAobm9kZSkgewogICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIG5vZGUudHlwZSA9PT0gbm9kZVR5cGUKLSAgICAgICAgICAgICAgICAgICAgICAg ICAmJiAobm9kZU5hbWUgPT09IG51bGwgfHwgbm9kZS5uYW1lID09PSBub2RlTmFtZSkKKyAgICAg ICAgICAgICAgICAgICAgICAgICAmJiAobm9kZUNsYXNzTmFtZSA9PT0gbnVsbCB8fCBub2RlLmNs YXNzTmFtZSA9PT0gbm9kZUNsYXNzTmFtZSkKICAgICAgICAgICAgICAgICAgICAgICAgICAmJiAh KG5vZGUuaWQgaW4gb3RoZXJTbmFwc2hvdC5pZHNNYXApOwogICAgICAgICAgICAgICAgIH0pOwog ICAgICAgICB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5k L0RldGFpbGVkSGVhcHNob3RWaWV3LmpzIGIvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250 LWVuZC9EZXRhaWxlZEhlYXBzaG90Vmlldy5qcwppbmRleCBmZmNlMWRkLi45ZWYyZTg5IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0RldGFpbGVkSGVhcHNo b3RWaWV3LmpzCisrKyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWls ZWRIZWFwc2hvdFZpZXcuanMKQEAgLTI2MywxMSArMjYzLDIxIEBAIFdlYkluc3BlY3Rvci5IZWFw U25hcHNob3RSZXRhaW5pbmdQYXRoc0xpc3QucHJvdG90eXBlID0gewogICAgICAgICAgICAgdGhp cy5zZWFyY2hDYW5jZWxsZWQoKTsKIAogICAgICAgICB0aGlzLnBhdGhGaW5kZXIgPSBuZXcgV2Vi SW5zcGVjdG9yLkhlYXBTbmFwc2hvdFBhdGhGaW5kZXIoc25hcHNob3QsIG5vZGVJbmRleCk7Cisg ICAgICAgIHRoaXMuX3NldFJvb3RDaGlsZHJlbkZvckZpbmRlcigpOwogCiAgICAgICAgIHRoaXMu cmVtb3ZlQ2hpbGRyZW4oKTsKIAogICAgICAgICB0aGlzLl9jb3VudGVyID0gMDsKLSAgICAgICAg dGhpcy5zaG93TmV4dCgxMCk7CisgICAgICAgIHRoaXMuc2hvd05leHQoMTAwKTsKKyAgICB9LAor CisgICAgcmVmcmVzaDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy5yZW1vdmVDaGls ZHJlbigpOworICAgICAgICB0aGlzLl9jb3VudGVyID0gMDsKKyAgICAgICAgZGVsZXRlIHRoaXMu X2NhbmNlbDsKKyAgICAgICAgdGhpcy5fc2V0Um9vdENoaWxkcmVuRm9yRmluZGVyKCk7CisgICAg ICAgIHRoaXMuc2hvd05leHQoMTAwKTsKICAgICB9LAogCiAgICAgc2hvd05leHQ6IGZ1bmN0aW9u KHBhdGhzQ291bnQpCkBAIC0yODMsNyArMjkzLDcgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hv dFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICAgICAgICAgIGlm IChyZXN1bHQgPT09IG51bGwpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIFdlYkluc3BlY3Rv ci5QbGVhc2VXYWl0TWVzc2FnZS5wcm90b3R5cGUuaGlkZSgpOwogICAgICAgICAgICAgICAgICAg ICAgICAgaWYgKCF0aGlzLmNoaWxkcmVuLmxlbmd0aCkKLSAgICAgICAgICAgICAgICAgICAgICAg ICAgICB0aGlzLmFwcGVuZENoaWxkKG5ldyBXZWJJbnNwZWN0b3IuRGF0YUdyaWROb2RlKHtwYXRo OldlYkluc3BlY3Rvci5VSVN0cmluZygiVGhpcyBvYmplY3QgaXMgZWl0aGVyIG9ubHkgYWNjZXNz aWJsZSB2aWEgaGlkZGVuIHByb3BlcnRpZXMsIG9yIGN1cnJlbnQgcGF0aCBzZWFyY2ggZGVwdGgg aXNuJ3QgZW5vdWdoLiIpLCBsZW46IiJ9LCBmYWxzZSkpOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHRoaXMuYXBwZW5kQ2hpbGQobmV3IFdlYkluc3BlY3Rvci5EYXRhR3JpZE5vZGUoe3Bh dGg6V2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJDYW4ndCBmaW5kIGFueSBwYXRocy4iKSwgbGVuOiIi fSwgZmFsc2UpKTsKICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAg ICAgICAgICAgfSBlbHNlIGlmIChyZXN1bHQgIT09IGZhbHNlKSB7CiAgICAgICAgICAgICAgICAg ICAgICAgICBpZiAodGhpcy5fcHJlZml4KQpAQCAtMzExLDYgKzMyMSwxOSBAQCBXZWJJbnNwZWN0 b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZSA9IHsKICAgICAgICAg fQogICAgIH0sCiAKKyAgICBfc2V0Um9vdENoaWxkcmVuRm9yRmluZGVyOiBmdW5jdGlvbigpCisg ICAgeworICAgICAgICBmdW5jdGlvbiBGaWx0ZXJET01XaW5kb3cobm9kZSkKKyAgICAgICAgewor ICAgICAgICAgICAgcmV0dXJuIG5vZGUubmFtZSA9PT0gIkRPTVdpbmRvdyI7CisgICAgICAgIH0K KworICAgICAgICBpZiAodGhpcy5zbmFwc2hvdFZpZXcuaXNUcmFjaW5nVG9XaW5kb3dPYmplY3Rz KQorICAgICAgICAgICAgdGhpcy5wYXRoRmluZGVyLnVwZGF0ZVJvb3RzKEZpbHRlckRPTVdpbmRv dyk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHRoaXMucGF0aEZpbmRlci51cGRhdGVSb290 cygpOworICAgIH0sCisKICAgICBfcGVyZm9ybVNvcnRpbmc6IGZ1bmN0aW9uKHNvcnRGdW5jdGlv bikKICAgICB7CiAgICAgICAgIGZ1bmN0aW9uIERhdGFFeHRyYWN0b3JXcmFwcGVyKG5vZGVBLCBu b2RlQikKQEAgLTM3NCw4ICszOTcsMTggQEAgV2ViSW5zcGVjdG9yLkRldGFpbGVkSGVhcHNob3RW aWV3ID0gZnVuY3Rpb24ocGFyZW50LCBwcm9maWxlKQogICAgIHZhciByZXRhaW5pbmdQYXRoc1Rp dGxlRGl2ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7CiAgICAgcmV0YWluaW5nUGF0 aHNUaXRsZURpdi5jbGFzc05hbWUgPSAidGl0bGUiOwogICAgIHZhciByZXRhaW5pbmdQYXRoc1Rp dGxlID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOwotICAgIHJldGFpbmluZ1BhdGhz VGl0bGUudGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIlJldGFpbmluZyBwYXRo cyBvZiB0aGUgc2VsZWN0ZWQgb2JqZWN0Iik7CisgICAgcmV0YWluaW5nUGF0aHNUaXRsZS50ZXh0 Q29udGVudCA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiUGF0aHMgZnJvbSB0aGUgc2VsZWN0ZWQg b2JqZWN0Iik7CisgICAgdGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3QgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJzZWxlY3QiKTsKKyAgICB0aGlzLnJldGFpbmluZ1BhdGhzUm9vdC5jbGFzc05hbWUg PSAic3RhdHVzLWJhci1pdGVtIjsKKyAgICB0aGlzLnJldGFpbmluZ1BhdGhzUm9vdC5hZGRFdmVu dExpc3RlbmVyKCJjaGFuZ2UiLCB0aGlzLl9jaGFuZ2VSZXRhaW5pbmdQYXRoc1Jvb3QuYmluZCh0 aGlzKSwgZmFsc2UpOworICAgIHZhciB0b0dDUm9vdHNUcmFjZU9wdGlvbiA9IGRvY3VtZW50LmNy ZWF0ZUVsZW1lbnQoIm9wdGlvbiIpOworICAgIHRvR0NSb290c1RyYWNlT3B0aW9uLmxhYmVsID0g V2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJ0byBHQyByb290cyIpOworICAgIHZhciB0b1dpbmRvd09i amVjdHNUcmFjZU9wdGlvbiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoIm9wdGlvbiIpOworICAg IHRvV2luZG93T2JqZWN0c1RyYWNlT3B0aW9uLmxhYmVsID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5n KCJ0byB3aW5kb3cgb2JqZWN0cyIpOworICAgIHRoaXMucmV0YWluaW5nUGF0aHNSb290LmFwcGVu ZENoaWxkKHRvR0NSb290c1RyYWNlT3B0aW9uKTsKKyAgICB0aGlzLnJldGFpbmluZ1BhdGhzUm9v dC5hcHBlbmRDaGlsZCh0b1dpbmRvd09iamVjdHNUcmFjZU9wdGlvbik7CiAgICAgcmV0YWluaW5n UGF0aHNUaXRsZURpdi5hcHBlbmRDaGlsZChyZXRhaW5pbmdQYXRoc1RpdGxlKTsKKyAgICByZXRh aW5pbmdQYXRoc1RpdGxlRGl2LmFwcGVuZENoaWxkKHRoaXMucmV0YWluaW5nUGF0aHNSb290KTsK ICAgICByZXRhaW5tZW50Vmlldy5lbGVtZW50LmFwcGVuZENoaWxkKHJldGFpbmluZ1BhdGhzVGl0 bGVEaXYpOwogICAgIHRoaXMucmV0YWlubWVudERhdGFHcmlkID0gbmV3IFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3RSZXRhaW5pbmdQYXRoc0xpc3QoKTsKICAgICByZXRhaW5tZW50Vmlldy5lbGVt ZW50LmFwcGVuZENoaWxkKHRoaXMucmV0YWlubWVudERhdGFHcmlkLmVsZW1lbnQpOwpAQCAtNzk0 LDYgKzgyNywxOCBAQCBXZWJJbnNwZWN0b3IuRGV0YWlsZWRIZWFwc2hvdFZpZXcucHJvdG90eXBl ID0gewogICAgICAgICB0aGlzLnBlcmZvcm1TZWFyY2godGhpcy5jdXJyZW50UXVlcnksIHRoaXMu X3NlYXJjaEZpbmlzaGVkQ2FsbGJhY2spOwogICAgIH0sCiAKKyAgICBfY2hhbmdlUmV0YWluaW5n UGF0aHNSb290OiBmdW5jdGlvbihldmVudCkKKyAgICB7CisgICAgICAgIGlmICghZXZlbnQpCisg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIHRoaXMucmV0YWlubWVudERhdGFHcmlkLnJlZnJl c2goKTsKKyAgICB9LAorCisgICAgZ2V0IGlzVHJhY2luZ1RvV2luZG93T2JqZWN0cygpCisgICAg eworICAgICAgICByZXR1cm4gdGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3Quc2VsZWN0ZWRJbmRleCA9 PT0gMTsKKyAgICB9LAorCiAgICAgZ2V0IF9pc1Nob3dpbmdBc1BlcmNlbnQoKQogICAgIHsKICAg ICAgICAgcmV0dXJuIHRoaXMuc2hvd0NvdW50QXNQZXJjZW50ICYmIHRoaXMuc2hvd1NoYWxsb3dT aXplQXNQZXJjZW50ICYmIHRoaXMuc2hvd1JldGFpbmVkU2l6ZUFzUGVyY2VudDsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvSGVhcFNuYXBzaG90LmpzIGIv U291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9IZWFwU25hcHNob3QuanMKaW5kZXgg MjE1ZjMxYy4uZWQ1OTJlMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9IZWFwU25hcHNob3QuanMKKysrIGIvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9IZWFwU25hcHNob3QuanMKQEAgLTIxMiw2ICsyMTIsMTAgQEAgV2ViSW5zcGVjdG9y LkhlYXBTbmFwc2hvdE5vZGUucHJvdG90eXBlID0gewogICAgICAgICAgICAgcmV0dXJuIFdlYklu c3BlY3Rvci5VSVN0cmluZygiKHN5c3RlbSkiKTsKICAgICAgICAgY2FzZSAib2JqZWN0IjoKICAg ICAgICAgICAgIHJldHVybiB0aGlzLm5hbWU7CisgICAgICAgIGNhc2UgIm5hdGl2ZSI6IHsKKyAg ICAgICAgICAgIHZhciBlbnRpdGllc0NvdW50UG9zID0gdGhpcy5uYW1lLmluZGV4T2YoIi8iKTsK KyAgICAgICAgICAgIHJldHVybiBlbnRpdGllc0NvdW50UG9zICE9PSAtMSA/IHRoaXMubmFtZS5z dWJzdHJpbmcoMCwgZW50aXRpZXNDb3VudFBvcykudHJpbVJpZ2h0KCkgOiB0aGlzLm5hbWU7Cisg ICAgICAgIH0KICAgICAgICAgY2FzZSAiY29kZSI6CiAgICAgICAgICAgICByZXR1cm4gV2ViSW5z cGVjdG9yLlVJU3RyaW5nKCIoY29tcGlsZWQgY29kZSkiKTsKICAgICAgICAgZGVmYXVsdDoKQEAg LTUyNSw4ICs1MjksOCBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90LnByb3RvdHlwZSA9IHsK ICAgICAgICAgZm9yICh2YXIgaXRlciA9IHRoaXMuYWxsTm9kZXM7IGl0ZXIuaGFzTmV4dCgpOyBp dGVyLm5leHQoKSkgewogICAgICAgICAgICAgdmFyIG5vZGUgPSBpdGVyLm5vZGU7CiAgICAgICAg ICAgICB2YXIgY2xhc3NOYW1lID0gbm9kZS5jbGFzc05hbWU7Ci0gICAgICAgICAgICB2YXIgbmFt ZU1hdHRlcnMgPSBub2RlLnR5cGUgPT09ICJvYmplY3QiOwotICAgICAgICAgICAgaWYgKG5vZGUu c2VsZlNpemUgPT09IDApCisgICAgICAgICAgICB2YXIgbmFtZU1hdHRlcnMgPSBub2RlLnR5cGUg PT09ICJvYmplY3QiIHx8IG5vZGUudHlwZSA9PT0gIm5hdGl2ZSI7CisgICAgICAgICAgICBpZiAo bm9kZS50eXBlICE9PSAibmF0aXZlIiAmJiBub2RlLnNlbGZTaXplID09PSAwKQogICAgICAgICAg ICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICAgaWYgKCEoY2xhc3NOYW1lIGluIHRoaXMuX2Fn Z3JlZ2F0ZXMpKQogICAgICAgICAgICAgICAgIHRoaXMuX2FnZ3JlZ2F0ZXNbY2xhc3NOYW1lXSA9 IHsgY291bnQ6IDAsIHNlbGY6IDAsIG1heFJldDogMCwgdHlwZTogbm9kZS50eXBlLCBuYW1lOiBu YW1lTWF0dGVycyA/IG5vZGUubmFtZSA6IG51bGwsIGlkeHM6IFtdIH07CkBAIC04NDIsMTEgKzg0 NiwxOCBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UGF0aEZpbmRlci5wcm90b3R5cGUgPSB7 CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9LAogCi0gICAgX2ZpbGxSb290Q2hpbGRyZW46 IGZ1bmN0aW9uKCkKKyAgICB1cGRhdGVSb290czogZnVuY3Rpb24oZmlsdGVyKQorICAgIHsKKyAg ICAgICAgdGhpcy5fcm9vdENoaWxkcmVuID0gdGhpcy5fZmlsbFJvb3RDaGlsZHJlbihmaWx0ZXIp OyAgCisgICAgfSwKKworICAgIF9maWxsUm9vdENoaWxkcmVuOiBmdW5jdGlvbihmaWx0ZXIpCiAg ICAgewogICAgICAgICB2YXIgcmVzdWx0ID0gW107Ci0gICAgICAgIGZvciAodmFyIGl0ZXIgPSB0 aGlzLl9zbmFwc2hvdC5yb290Tm9kZS5lZGdlczsgaXRlci5oYXNOZXh0KCk7IGl0ZXIubmV4dCgp KQotICAgICAgICAgICAgcmVzdWx0W2l0ZXIuZWRnZS5ub2RlSW5kZXhdID0gdHJ1ZTsKKyAgICAg ICAgZm9yICh2YXIgaXRlciA9IHRoaXMuX3NuYXBzaG90LnJvb3ROb2RlLmVkZ2VzOyBpdGVyLmhh c05leHQoKTsgaXRlci5uZXh0KCkpIHsKKyAgICAgICAgICAgIGlmICghZmlsdGVyIHx8IGZpbHRl cihpdGVyLmVkZ2Uubm9kZSkpCisgICAgICAgICAgICAgICAgcmVzdWx0W2l0ZXIuZWRnZS5ub2Rl SW5kZXhdID0gdHJ1ZTsKKyAgICAgICAgfQogICAgICAgICByZXR1cm4gcmVzdWx0OwogICAgIH0s CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaGVhcFBy b2ZpbGVyLmNzcyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaGVhcFByb2Zp bGVyLmNzcwppbmRleCBhZGQwMmExLi5mYjg0ODVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2hlYXBQcm9maWxlci5jc3MKKysrIGIvU291cmNlL1dlYkNv cmUvaW5zcGVjdG9yL2Zyb250LWVuZC9oZWFwUHJvZmlsZXIuY3NzCkBAIC0yMjgsOCArMjI4LDE1 IEBACiB9CiAKIC5kZXRhaWxlZC1oZWFwc2hvdC12aWV3IC5yZXRhaW5pbmctcGF0aHMtdmlldyAu dGl0bGUgPiBzcGFuIHsKKyAgICBkaXNwbGF5OiBpbmxpbmUtYmxvY2s7CisgICAgcGFkZGluZy10 b3A6IDNweDsKICAgICB2ZXJ0aWNhbC1hbGlnbjogbWlkZGxlOwogICAgIG1hcmdpbi1sZWZ0OiA0 cHg7CisgICAgbWFyZ2luLXJpZ2h0OiA4cHg7Cit9CisKKy5kZXRhaWxlZC1oZWFwc2hvdC12aWV3 IC5yZXRhaW5pbmctcGF0aHMtdG8td2luZG93cyB7CisgICAgCiB9CiAKIC5oZWFwc2hvdC1oZWxw LXN0YXR1cy1iYXItaXRlbSAuZ2x5cGggewo= 85463 2011-03-11 05:40:12 -0800 2011-03-16 08:24:15 -0700 Comments addressed, merged with antonm's changes, added new files that I forgot to add patch-53659 text/plain 38128 mnaganov ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tayBiL1NvdXJj ZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tawppbmRleCA2MmNjY2Y1Li4wNDg4NmIyIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9BbmRyb2lkLnY4YmluZGluZ3MubWsKKysrIGIvU291 cmNlL1dlYkNvcmUvQW5kcm9pZC52OGJpbmRpbmdzLm1rCkBAIC00NSw2ICs0NSw3IEBAIExPQ0FM X1NSQ19GSUxFUyArPSBcCiAJYmluZGluZ3MvdjgvSURCQmluZGluZ1V0aWxpdGllcy5jcHAgXAog CWJpbmRpbmdzL3Y4L01haW5UaHJlYWRET01EYXRhLmNwcCBcCiAJYmluZGluZ3MvdjgvTlBWOE9i amVjdC5jcHAgXAorCWJpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAgXAogCWJpbmRpbmdz L3Y4L1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIFwKIAliaW5kaW5ncy92OC9TY2hlZHVsZWRB Y3Rpb24uY3BwIFwKIAliaW5kaW5ncy92OC9TY29wZWRET01EYXRhU3RvcmUuY3BwIFwKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCA5YjE5OWZhLi4zMzQyOTdkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTkgQEAKKzIw MTEtMDMtMTEgIE1pa2hhaWwgTmFnYW5vdiAgPG1uYWdhbm92QGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbQ2hyb21pdW1dIFJl cG9ydCBvYmplY3QgZ3JvdXBzIGFuZCBzaW5nbGUgRE9NLXJlbGF0ZWQgb2JqZWN0cworICAgICAg ICB0byB0aGUgbmV3IGhlYXAgcHJvZmlsZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01MzY1OQorCisgICAgICAgICogQW5kcm9pZC52OGJpbmRpbmdz Lm1rOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAg ICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JWOC5wbToKKyAgICAgICAgKiBi aW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uY3BwOiBBZGRlZAorICAgICAgICAqIGJpbmRpbmdz L3Y4L1JldGFpbmVkRE9NSW5mby5oOiBBZGRlZAorICAgICAgICAqIGJpbmRpbmdzL3Y4L1JldGFp bmVkT2JqZWN0SW5mby5oOiBBZGRlZAorICAgICAgICAqIGJpbmRpbmdzL3Y4L1NjcmlwdFByb2Zp bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmdldFJldGFpbmVkRE9NSW5mbyk6CisgICAgICAg IChXZWJDb3JlOjpTY3JpcHRQcm9maWxlcjo6aW5pdGlhbGl6ZSk6CisgICAgICAgICogYmluZGlu Z3MvdjgvU2NyaXB0UHJvZmlsZXIuaDoKKyAgICAgICAgKiBiaW5kaW5ncy92OC9WOERPTVdpbmRv d1NoZWxsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9NV2luZG93U2hlbGw6OmluaXRDb250 ZXh0SWZOZWVkZWQpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6Okdyb3VwZXJJdGVtOjpHcm91cGVySXRlbSk6CisgICAgICAgIChX ZWJDb3JlOjpHcm91cGVySXRlbTo6Z3JvdXBJZCk6CisgICAgICAgIChXZWJDb3JlOjpHcm91cGVy SXRlbTo6cm9vdCk6CisgICAgICAgIChXZWJDb3JlOjpHcm91cGVySXRlbTo6cm9vdE5vZGUpOgor ICAgICAgICAoV2ViQ29yZTo6bWFrZVY4T2JqZWN0R3JvdXBzKToKKyAgICAgICAgKFdlYkNvcmU6 Ok5vZGVHcm91cGVyVmlzaXRvcjo6dmlzaXRET01XcmFwcGVyKToKKyAgICAgICAgKFdlYkNvcmU6 Ok5vZGVHcm91cGVyVmlzaXRvcjo6YWRkRE9NT2JqZWN0VG9Hcm91cCk6CisgICAgICAgIChXZWJD b3JlOjpjYWxjdWxhdGVHcm91cFJvb3QpOgorICAgICAgICAoV2ViQ29yZTo6RE9NT2JqZWN0R3Jv dXBlclZpc2l0b3I6OnZpc2l0RE9NV3JhcHBlcik6CisgICAgICAgIChXZWJDb3JlOjpET01PYmpl Y3RHcm91cGVyVmlzaXRvcjo6YWRkQWxsSXRlbXMpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1dy YXBwZXJUeXBlSW5mby5oOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRI ZWFwc2hvdEdyaWROb2Rlcy5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RD b25zdHJ1Y3Rvck5vZGUpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdENvbnN0 cnVjdG9yTm9kZS5wcm90b3R5cGUuX2NyZWF0ZU5vZGVzUHJvdmlkZXIpOgorICAgICAgICAoV2Vi SW5zcGVjdG9yLkhlYXBTbmFwc2hvdERpZmZOb2RlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3REaWZmTm9kZS5wcm90b3R5cGUuX2NyZWF0ZU5vZGVzUHJvdmlkZXIuY3JlYXRl UHJvdmlkZXIpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdERpZmZOb2RlLnBy b3RvdHlwZS5fY3JlYXRlTm9kZXNQcm92aWRlcik6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250 LWVuZC9EZXRhaWxlZEhlYXBzaG90Vmlldy5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFw U25hcHNob3RSZXRhaW5pbmdQYXRoc0xpc3QucHJvdG90eXBlLnNldERhdGFTb3VyY2UpOgorICAg ICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5 cGUucmVmcmVzaCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5n UGF0aHNMaXN0LnByb3RvdHlwZS5zaG93TmV4dC5zdGFydFNlYXJjaGluZyk6CisgICAgICAgIChX ZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZS5zaG93 TmV4dCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNM aXN0LnByb3RvdHlwZS5fc2V0Um9vdENoaWxkcmVuRm9yRmluZGVyKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5EZXRhaWxlZEhlYXBzaG90Vmlldy5wcm90b3R5cGUuX2NoYW5nZVJldGFpbmluZ1Bh dGhzUm9vdCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuRGV0YWlsZWRIZWFwc2hvdFZpZXcucHJv dG90eXBlLmdldCBpc1RyYWNpbmdUb1dpbmRvd09iamVjdHMpOgorICAgICAgICAqIGluc3BlY3Rv ci9mcm9udC1lbmQvSGVhcFNuYXBzaG90LmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBT bmFwc2hvdE5vZGUucHJvdG90eXBlLmdldCBjbGFzc05hbWUpOgorICAgICAgICAoV2ViSW5zcGVj dG9yLkhlYXBTbmFwc2hvdC5wcm90b3R5cGUuX2J1aWxkQWdncmVnYXRlcyk6CisgICAgICAgIChX ZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UGF0aEZpbmRlci5wcm90b3R5cGUudXBkYXRlUm9vdHMp OgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFBhdGhGaW5kZXIucHJvdG90eXBl Ll9maWxsUm9vdENoaWxkcmVuKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL2hlYXBQ cm9maWxlci5jc3M6CisgICAgICAgICguZGV0YWlsZWQtaGVhcHNob3QtdmlldyAucmV0YWluaW5n LXBhdGhzLXZpZXcgLnRpdGxlID4gc3Bhbik6CisgICAgICAgICguZGV0YWlsZWQtaGVhcHNob3Qt dmlldyAucmV0YWluaW5nLXBhdGhzLXRvLXdpbmRvd3MpOgorCiAyMDExLTAzLTExICBBbnRvbiBN dWhpbiAgPGFudG9ubUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBC YXJ0aC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCAzZmI5NmUwLi5kNDA4MDllIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5n eXBpCkBAIC05MTcsNiArOTE3LDkgQEAKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9PcHRpb25z T2JqZWN0LmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvT3B0aW9uc09iamVjdC5oJywK ICAgICAgICAgICAgICdiaW5kaW5ncy92OC9Pd25IYW5kbGUuaCcsCisgICAgICAgICAgICAnYmlu ZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmgnLAorICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L1Jl dGFpbmVkRE9NSW5mby5jcHAnLAorICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L1JldGFpbmVkT2Jq ZWN0SW5mby5oJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9TY2hlZHVsZWRBY3Rpb24uY3Bw JywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9TY2hlZHVsZWRBY3Rpb24uaCcsCiAgICAgICAg ICAgICAnYmluZGluZ3MvdjgvU2NvcGVkRE9NRGF0YVN0b3JlLmNwcCcsCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLnBybyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUucHJvCmlu ZGV4IDE0YTdkM2IuLjUzOGY4OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu cHJvCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUucHJvCkBAIC05MCw2ICs5MCw3IEBAIHY4 IHsKICAgICAgICAgYmluZGluZ3MvdjgvRE9NRGF0YVN0b3JlLmNwcCBcCiAgICAgICAgIGJpbmRp bmdzL3Y4L01haW5UaHJlYWRET01EYXRhLmNwcCBcCiAgICAgICAgIGJpbmRpbmdzL3Y4L05QVjhP YmplY3QuY3BwIFwKKyAgICAgICAgYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmNwcCBcCiAg ICAgICAgIGJpbmRpbmdzL3Y4L1NjaGVkdWxlZEFjdGlvbi5jcHAgXAogICAgICAgICBiaW5kaW5n cy92OC9TY29wZWRET01EYXRhU3RvcmUuY3BwIFwKICAgICAgICAgYmluZGluZ3MvdjgvU2NyaXB0 Q2FjaGVkRnJhbWVEYXRhLmNwcCBcCkBAIC0xMTk4LDYgKzExOTksOCBAQCB2OCB7CiAgICAgICAg IGJpbmRpbmdzL3Y4L25wcnVudGltZV9wcml2LmggXAogICAgICAgICBiaW5kaW5ncy92OC9OUFY4 T2JqZWN0LmggXAogICAgICAgICBiaW5kaW5ncy92OC9Pd25IYW5kbGUuaCBcCisgICAgICAgIGJp bmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5oIFwKKyAgICAgICAgYmluZGluZ3MvdjgvUmV0YWlu ZWRPYmplY3RJbmZvLmggXAogICAgICAgICBiaW5kaW5ncy92OC9TY2hlZHVsZWRBY3Rpb24uaCBc CiAgICAgICAgIGJpbmRpbmdzL3Y4L1Njb3BlZERPTURhdGFTdG9yZS5oIFwKICAgICAgICAgYmlu ZGluZ3MvdjgvU2NyaXB0Q2FjaGVkRnJhbWVEYXRhLmggXApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yVjgucG0gYi9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JWOC5wbQppbmRleCBlMmZlMjc3Li4yYzk4 MzFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5l cmF0b3JWOC5wbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5l cmF0b3JWOC5wbQpAQCAtMjUwNiw3ICsyNTA2LDE1IEBAIEVORAogICAgIH0KIAogICAgIHB1c2go QGltcGxDb250ZW50LCA8PEVORCk7Ci0gICAgJHtkb21NYXBGdW5jdGlvbn0uc2V0KGltcGwsIHY4 OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+OjpOZXcod3JhcHBlcikpOworICAgIHY4OjpQZXJzaXN0 ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXJIYW5kbGUgPSB2ODo6UGVyc2lzdGVudDx2ODo6T2JqZWN0 Pjo6TmV3KHdyYXBwZXIpOworRU5ECisgICAgaWYgKElzTm9kZVN1YlR5cGUoJGRhdGFOb2RlKSkg eworICAgICAgICBwdXNoKEBpbXBsQ29udGVudCwgPDxFTkQpOworICAgIHdyYXBwZXJIYW5kbGUu U2V0V3JhcHBlckNsYXNzSWQodjhET01TdWJ0cmVlQ2xhc3NJZCk7CitFTkQKKyAgICB9ICAgIAor ICAgIHB1c2goQGltcGxDb250ZW50LCA8PEVORCk7CisgICAgJHtkb21NYXBGdW5jdGlvbn0uc2V0 KGltcGwsIHdyYXBwZXJIYW5kbGUpOwogRU5ECiAKICAgICBwdXNoKEBpbXBsQ29udGVudCwgPDxF TkQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRET01J bmZvLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDcyOWI1MQotLS0gL2Rldi9udWxs CisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAKQEAg LTAsMCArMSw4NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwg cmlnaHRzIHJlc2VydmVkLgorICogCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAq IG1ldDoKKyAqIAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdo dCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5h bWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBt YXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisg KiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9u LgorICogCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9M REVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBB IFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhF IENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwK KyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZXRhaW5lZERP TUluZm8uaCIKKworI2luY2x1ZGUgIk5vZGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitS ZXRhaW5lZERPTUluZm86OlJldGFpbmVkRE9NSW5mbyhOb2RlKiByb290KQorICAgICAgICA6IG1f cm9vdChyb290KQoreworICAgIEFTU0VSVChtX3Jvb3QpOworfQorCitSZXRhaW5lZERPTUluZm86 On5SZXRhaW5lZERPTUluZm8oKQoreworfQorCit2b2lkIFJldGFpbmVkRE9NSW5mbzo6RGlzcG9z ZSgpCit7CisgICAgZGVsZXRlIHRoaXM7Cit9CisKK2Jvb2wgUmV0YWluZWRET01JbmZvOjpJc0Vx dWl2YWxlbnQodjg6OlJldGFpbmVkT2JqZWN0SW5mbyogb3RoZXIpCit7CisgICAgQVNTRVJUKG90 aGVyKTsKKyAgICByZXR1cm4gb3RoZXIgPT0gdGhpcworICAgICAgICAgICAgfHwgcmVpbnRlcnBy ZXRfY2FzdDxXZWJDb3JlOjpSZXRhaW5lZE9iamVjdEluZm8qPihvdGhlciktPkdldEVxdWl2YWxl bmNlQ2xhc3MoKSA9PSB0aGlzLT5HZXRFcXVpdmFsZW5jZUNsYXNzKCk7Cit9CisKK2ludHB0cl90 IFJldGFpbmVkRE9NSW5mbzo6R2V0SGFzaCgpCit7CisgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nh c3Q8aW50cHRyX3Q+KG1fcm9vdCk7Cit9CisgICAgCitjb25zdCBjaGFyKiBSZXRhaW5lZERPTUlu Zm86OkdldExhYmVsKCkKK3sKKyAgICByZXR1cm4gbV9yb290LT5pbkRvY3VtZW50KCkgPyAiRG9j dW1lbnQgRE9NIHRyZWUiIDogIkRldGFjaGVkIERPTSB0cmVlIjsKK30KKworaW50cHRyX3QgUmV0 YWluZWRET01JbmZvOjpHZXRFbGVtZW50Q291bnQoKQoreworICAgIGludHB0cl90IGNvdW50ID0g MTsKKyAgICBOb2RlKiBjdXJyZW50ID0gbV9yb290OworICAgIHdoaWxlIChjdXJyZW50KSB7Cisg ICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT50cmF2ZXJzZU5leHROb2RlKG1fcm9vdCk7CisgICAg ICAgICsrY291bnQ7CisgICAgfQorICAgIHJldHVybiBjb3VudDsKK30KKworaW50cHRyX3QgUmV0 YWluZWRET01JbmZvOjpHZXRFcXVpdmFsZW5jZUNsYXNzKCkKK3sKKyAgICByZXR1cm4gcmVpbnRl cnByZXRfY2FzdDxpbnRwdHJfdD4obV9yb290KTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZv LmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uaApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wZTQyZmI4Ci0tLSAvZGV2L251bGwKKysrIGIv U291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmgKQEAgLTAsMCArMSw1 OSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJl c2VydmVkLgorICogCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAq IAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBi aW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAq IGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29v Z2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNl ZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNv ZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgUmV0YWluZWRET01JbmZvX2gKKyNkZWZpbmUgUmV0YWluZWRET01JbmZv X2gKKworI2luY2x1ZGUgIlJldGFpbmVkT2JqZWN0SW5mby5oIgorCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK2NsYXNzIE5vZGU7CisKK2NsYXNzIFJldGFpbmVkRE9NSW5mbyA6IHB1YmxpYyBSZXRh aW5lZE9iamVjdEluZm8geworcHVibGljOgorICAgIGV4cGxpY2l0IFJldGFpbmVkRE9NSW5mbyhO b2RlKiByb290KTsKKyAgICB2aXJ0dWFsIH5SZXRhaW5lZERPTUluZm8oKTsKKyAgICB2aXJ0dWFs IHZvaWQgRGlzcG9zZSgpOworICAgIHZpcnR1YWwgYm9vbCBJc0VxdWl2YWxlbnQodjg6OlJldGFp bmVkT2JqZWN0SW5mbyogb3RoZXIpOworICAgIHZpcnR1YWwgaW50cHRyX3QgR2V0SGFzaCgpOwor ICAgIHZpcnR1YWwgY29uc3QgY2hhciogR2V0TGFiZWwoKTsKKyAgICB2aXJ0dWFsIGludHB0cl90 IEdldEVsZW1lbnRDb3VudCgpOworICAgIHZpcnR1YWwgaW50cHRyX3QgR2V0RXF1aXZhbGVuY2VD bGFzcygpOworICAgIAorcHJpdmF0ZToKKyAgICAvLyBWOCBndWFyYW50ZWVzIHRvIGtlZXAgUmV0 YWluZWRPYmplY3RJbmZvcyBhbGl2ZSBvbmx5IGR1cmluZyBhIEdDIG9yIGhlYXAgc25hcHNob3R0 aW5nIHJvdW5kLCB3aGVuIHJlbmRlcmVyCisgICAgLy8gZG9lc24ndCBnZXQgY29udHJvbC4gVGhp cyBhbGxvd3MgdXMgdG8gdXNlIHJhdyBwb2ludGVycy4KKyAgICBOb2RlKiBtX3Jvb3Q7Cit9Owor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBSZXRhaW5lZERPTUluZm9faApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRPYmplY3RJbmZv LmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9SZXRhaW5lZE9iamVjdEluZm8uaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMzY4ZmIxCi0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRPYmplY3RJbmZvLmgKQEAgLTAs MCArMSw0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorICogCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1l dDoKKyAqIAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUg b2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0 aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgor ICogCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJ RUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENP UFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAq IERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNpZm5kZWYgUmV0YWluZWRPYmplY3RJbmZvX2gKKyNkZWZpbmUgUmV0YWlu ZWRPYmplY3RJbmZvX2gKKworI2luY2x1ZGUgPHY4LXByb2ZpbGVyLmg+CisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworY2xhc3MgUmV0YWluZWRPYmplY3RJbmZvIDogcHVibGljIHY4OjpSZXRhaW5l ZE9iamVjdEluZm8geworcHVibGljOgorICAgIHZpcnR1YWwgaW50cHRyX3QgR2V0RXF1aXZhbGVu Y2VDbGFzcygpID0gMDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IFJldGFpbmVkT2JqZWN0SW5mb19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy92OC9TY3JpcHRQcm9maWxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3Jp cHRQcm9maWxlci5jcHAKaW5kZXggYzIxMGE1ZC4uNGVlNTQ3OSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL3Y4L1NjcmlwdFByb2ZpbGVyLmNwcApAQCAtMzIsOSArMzIsMTEgQEAKICNp bmNsdWRlICJTY3JpcHRQcm9maWxlci5oIgogCiAjaW5jbHVkZSAiSW5zcGVjdG9yVmFsdWVzLmgi CisjaW5jbHVkZSAiUmV0YWluZWRET01JbmZvLmgiCisjaW5jbHVkZSAiVjhCaW5kaW5nLmgiCisj aW5jbHVkZSAiVjhOb2RlLmgiCiAKICNpbmNsdWRlIDx2OC1wcm9maWxlci5oPgotI2luY2x1ZGUg PFY4QmluZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTk4LDQgKzEwMCwxOSBA QCBQYXNzUmVmUHRyPFNjcmlwdEhlYXBTbmFwc2hvdD4gU2NyaXB0UHJvZmlsZXI6OnRha2VIZWFw U25hcHNob3QoY29uc3QgU3RyaW5nJiB0aQogICAgIHJldHVybiBzbmFwc2hvdCA/IFNjcmlwdEhl YXBTbmFwc2hvdDo6Y3JlYXRlKHNuYXBzaG90KSA6IDA7CiB9CiAKK3N0YXRpYyB2ODo6UmV0YWlu ZWRPYmplY3RJbmZvKiBnZXRSZXRhaW5lZERPTUluZm8odWludDE2X3QgY2xhc3NJZCwgdjg6Okhh bmRsZTx2ODo6VmFsdWU+IHdyYXBwZXIpCit7CisgICAgQVNTRVJUKGNsYXNzSWQgPT0gdjhET01T dWJ0cmVlQ2xhc3NJZCk7CisgICAgaWYgKCF3cmFwcGVyLT5Jc09iamVjdCgpKQorICAgICAgICBy ZXR1cm4gMDsKKyAgICBOb2RlKiBub2RlID0gVjhOb2RlOjp0b05hdGl2ZSh3cmFwcGVyLkFzPHY4 OjpPYmplY3Q+KCkpOworICAgIHJldHVybiBub2RlID8gbmV3IFJldGFpbmVkRE9NSW5mbyhub2Rl KSA6IDA7Cit9CisKK3ZvaWQgU2NyaXB0UHJvZmlsZXI6OmluaXRpYWxpemUoKQoreworICAgIHY4 OjpIZWFwUHJvZmlsZXI6OkRlZmluZVdyYXBwZXJDbGFzcyh2OERPTVN1YnRyZWVDbGFzc0lkLCAm Z2V0UmV0YWluZWRET01JbmZvKTsKK30KKworCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9maWxlci5oIGIvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIuaAppbmRleCA5MTAzZjBjLi45 MmE5ODBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9m aWxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1NjcmlwdFByb2ZpbGVyLmgK QEAgLTU3LDYgKzU3LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lkIHN0YXJ0KFNjcmlwdFN0 YXRlKiBzdGF0ZSwgY29uc3QgU3RyaW5nJiB0aXRsZSk7CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8 U2NyaXB0UHJvZmlsZT4gc3RvcChTY3JpcHRTdGF0ZSogc3RhdGUsIGNvbnN0IFN0cmluZyYgdGl0 bGUpOwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNjcmlwdEhlYXBTbmFwc2hvdD4gdGFrZUhlYXBT bmFwc2hvdChjb25zdCBTdHJpbmcmIHRpdGxlLCBIZWFwU25hcHNob3RQcm9ncmVzcyopOworICAg IHN0YXRpYyB2b2lkIGluaXRpYWxpemUoKTsKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4RE9NV2luZG93U2hlbGwu Y3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHAKaW5k ZXggNDAzMTJkYS4uYzNhMGNiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv djgvVjhET01XaW5kb3dTaGVsbC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvdjgv VjhET01XaW5kb3dTaGVsbC5jcHAKQEAgLTQzLDYgKzQzLDcgQEAKICNpbmNsdWRlICJTY3JpcHRD YWxsU3RhY2suaCIKICNpbmNsdWRlICJTY3JpcHRDYWxsU3RhY2tGYWN0b3J5LmgiCiAjaW5jbHVk ZSAiU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIlNjcmlwdFByb2ZpbGVyLmgiCiAjaW5j bHVkZSAiU3RvcmFnZU5hbWVzcGFjZS5oIgogI2luY2x1ZGUgIlY4QmluZGluZy5oIgogI2luY2x1 ZGUgIlY4QmluZGluZ1N0YXRlLmgiCkBAIC0yOTcsNiArMjk4LDggQEAgYm9vbCBWOERPTVdpbmRv d1NoZWxsOjppbml0Q29udGV4dElmTmVlZGVkKCkKIAogICAgICAgICB2ODo6Vjg6OlNldEZhaWxl ZEFjY2Vzc0NoZWNrQ2FsbGJhY2tGdW5jdGlvbihyZXBvcnRVbnNhZmVKYXZhU2NyaXB0QWNjZXNz KTsKIAorICAgICAgICBTY3JpcHRQcm9maWxlcjo6aW5pdGlhbGl6ZSgpOworICAgICAgICAKICAg ICAgICAgaXNWOEluaXRpYWxpemVkID0gdHJ1ZTsKICAgICB9CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcAppbmRleCA0NGMwZTRlLi4xYzE1MDg2IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9WOEdDQ29udHJvbGxlci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhHQ0NvbnRyb2xsZXIuY3BwCkBAIC0z OSw2ICszOSw4IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiTWVzc2FnZVBv cnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUJyaWRnZS5oIgorI2luY2x1ZGUgIlJldGFpbmVkRE9N SW5mby5oIgorI2luY2x1ZGUgIlJldGFpbmVkT2JqZWN0SW5mby5oIgogI2luY2x1ZGUgIlNWR0Vs ZW1lbnQuaCIKICNpbmNsdWRlICJWOEJpbmRpbmcuaCIKICNpbmNsdWRlICJWOENTU0NoYXJzZXRS dWxlLmgiCkBAIC0xNzcsMTggKzE3OSwyOCBAQCBwdWJsaWM6CiAKIGNsYXNzIEdyb3VwZXJJdGVt IHsKIHB1YmxpYzoKLSAgICBHcm91cGVySXRlbSh1aW50cHRyX3QgZ3JvdXBJZCwgdjg6OlBlcnNp c3RlbnQ8djg6Ok9iamVjdD4gd3JhcHBlcikgCi0gICAgICAgIDogbV9ncm91cElkKGdyb3VwSWQp Ci0gICAgICAgICwgbV93cmFwcGVyKHdyYXBwZXIpIAorICAgIEdyb3VwZXJJdGVtKHZvaWQqIHJv b3QsIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpIAorICAgICAgICA6IG1fcm9v dChyb290KQorICAgICAgICAsIG1fd3JhcHBlcih3cmFwcGVyKQorICAgICAgICAsIG1faXNEb20o ZmFsc2UpCisgICAgICAgIHsKKyAgICAgICAgfQorICAgIEdyb3VwZXJJdGVtKE5vZGUqIHJvb3Qs IHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpCisgICAgICAgIDogbV9yb290KHJv b3QpCisgICAgICAgICwgbV93cmFwcGVyKHdyYXBwZXIpCisgICAgICAgICwgbV9pc0RvbSh0cnVl KQogICAgICAgICB7CiAgICAgICAgIH0KIAotICAgIHVpbnRwdHJfdCBncm91cElkKCkgY29uc3Qg eyByZXR1cm4gbV9ncm91cElkOyB9CisgICAgdWludHB0cl90IGdyb3VwSWQoKSBjb25zdCB7IHJl dHVybiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4obV9yb290KTsgfQorICAgIHZvaWQqIHJv b3QoKSBjb25zdCB7IHJldHVybiBtX3Jvb3Q7IH0KKyAgICBOb2RlKiByb290Tm9kZSgpIGNvbnN0 IHsgcmV0dXJuIG1faXNEb20gPyByZWludGVycHJldF9jYXN0PE5vZGUqPihtX3Jvb3QpIDogMDsg fQogICAgIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIoKSBjb25zdCB7IHJldHVy biBtX3dyYXBwZXI7IH0KIAogcHJpdmF0ZToKLSAgICB1aW50cHRyX3QgbV9ncm91cElkOworICAg IHZvaWQqIG1fcm9vdDsKICAgICB2ODo6UGVyc2lzdGVudDx2ODo6T2JqZWN0PiBtX3dyYXBwZXI7 CisgICAgYm9vbCBtX2lzRG9tOwogfTsKIAogYm9vbCBvcGVyYXRvcjwoY29uc3QgR3JvdXBlckl0 ZW0mIGEsIGNvbnN0IEdyb3VwZXJJdGVtJiBiKQpAQCAtMTk4LDYgKzIxMCw0NiBAQCBib29sIG9w ZXJhdG9yPChjb25zdCBHcm91cGVySXRlbSYgYSwgY29uc3QgR3JvdXBlckl0ZW0mIGIpCiAKIHR5 cGVkZWYgVmVjdG9yPEdyb3VwZXJJdGVtPiBHcm91cGVyTGlzdDsKIAorbmFtZXNwYWNlIHsKKwor Y2xhc3MgVW5zcGVjaWZpZWRHcm91cCA6IHB1YmxpYyBSZXRhaW5lZE9iamVjdEluZm8geworcHVi bGljOgorICAgIGV4cGxpY2l0IFVuc3BlY2lmaWVkR3JvdXAodm9pZCogb2JqZWN0KQorICAgICAg ICAgICAgOiBtX29iamVjdChvYmplY3QpCisgICAgeworICAgICAgICBBU1NFUlQobV9vYmplY3Qp OworICAgIH0KKyAgICAKKyAgICB2aXJ0dWFsIHZvaWQgRGlzcG9zZSgpIHsgZGVsZXRlIHRoaXM7 IH0KKyAgCisgICAgdmlydHVhbCBib29sIElzRXF1aXZhbGVudCh2ODo6UmV0YWluZWRPYmplY3RJ bmZvKiBvdGhlcikKKyAgICB7CisgICAgICAgIEFTU0VSVChvdGhlcik7CisgICAgICAgIHJldHVy biBvdGhlciA9PSB0aGlzCisgICAgICAgICAgICAgICAgfHwgcmVpbnRlcnByZXRfY2FzdDxXZWJD b3JlOjpSZXRhaW5lZE9iamVjdEluZm8qPihvdGhlciktPkdldEVxdWl2YWxlbmNlQ2xhc3MoKSA9 PSB0aGlzLT5HZXRFcXVpdmFsZW5jZUNsYXNzKCk7CisgICAgfQorCisgICAgdmlydHVhbCBpbnRw dHJfdCBHZXRIYXNoKCkKKyAgICB7CisgICAgICAgIHJldHVybiByZWludGVycHJldF9jYXN0PGlu dHB0cl90PihtX29iamVjdCk7CisgICAgfQorICAgIAorICAgIHZpcnR1YWwgY29uc3QgY2hhciog R2V0TGFiZWwoKQorICAgIHsKKyAgICAgICAgcmV0dXJuICJPYmplY3QgZ3JvdXAiOworICAgIH0K KworICAgIHZpcnR1YWwgaW50cHRyX3QgR2V0RXF1aXZhbGVuY2VDbGFzcygpCisgICAgeworICAg ICAgICByZXR1cm4gcmVpbnRlcnByZXRfY2FzdDxpbnRwdHJfdD4obV9vYmplY3QpOworICAgIH0K KworcHJpdmF0ZToKKyAgICB2b2lkKiBtX29iamVjdDsKK307CisKK30KKwogdm9pZCBtYWtlVjhP YmplY3RHcm91cHMoR3JvdXBlckxpc3QmIGdyb3VwZXIpCiB7CiAgICAgLy8gR3JvdXAgYnkgc29y dGluZyBieSB0aGUgZ3JvdXAgaWQuCkBAIC0yMjMsNiArMjc1LDggQEAgdm9pZCBtYWtlVjhPYmpl Y3RHcm91cHMoR3JvdXBlckxpc3QmIGdyb3VwZXIpCiAgICAgICAgICAgICBjb250aW51ZTsKICAg ICAgICAgfQogCisgICAgICAgIHNpemVfdCByb290SW5kZXggPSBpOworCiAgICAgICAgIFZlY3Rv cjx2ODo6UGVyc2lzdGVudDx2ODo6VmFsdWU+ID4gZ3JvdXA7CiAgICAgICAgIGdyb3VwLnJlc2Vy dmVDYXBhY2l0eShuZXh0S2V5SW5kZXggLSBpKTsKICAgICAgICAgZm9yICg7IGkgPCBuZXh0S2V5 SW5kZXg7ICsraSkgewpAQCAtMjMxLDggKzI4NSwxMyBAQCB2b2lkIG1ha2VWOE9iamVjdEdyb3Vw cyhHcm91cGVyTGlzdCYgZ3JvdXBlcikKICAgICAgICAgICAgICAgICBncm91cC5hcHBlbmQod3Jh cHBlcik7CiAgICAgICAgIH0KIAotICAgICAgICBpZiAoZ3JvdXAuc2l6ZSgpID4gMSkKLSAgICAg ICAgICAgIHY4OjpWODo6QWRkT2JqZWN0R3JvdXAoJmdyb3VwWzBdLCBncm91cC5zaXplKCkpOwor ICAgICAgICBpZiAoZ3JvdXAuc2l6ZSgpID4gMSkgeworICAgICAgICAgICAgTm9kZSogcm9vdE5v ZGUgPSBncm91cGVyW3Jvb3RJbmRleF0ucm9vdE5vZGUoKTsKKyAgICAgICAgICAgIGlmIChyb290 Tm9kZSkKKyAgICAgICAgICAgICAgICB2ODo6Vjg6OkFkZE9iamVjdEdyb3VwKCZncm91cFswXSwg Z3JvdXAuc2l6ZSgpLCBuZXcgUmV0YWluZWRET01JbmZvKHJvb3ROb2RlKSk7CisgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgdjg6OlY4OjpBZGRPYmplY3RHcm91cCgmZ3JvdXBbMF0s IGdyb3VwLnNpemUoKSwgbmV3IFVuc3BlY2lmaWVkR3JvdXAoZ3JvdXBlcltyb290SW5kZXhdLnJv b3QoKSkpOworICAgICAgICB9CiAKICAgICAgICAgQVNTRVJUKGkgPT0gbmV4dEtleUluZGV4KTsK ICAgICB9CkBAIC0yNTUsNTkgKzMxNCw1OCBAQCBwdWJsaWM6CiAgICAgICAgIC8vCiAgICAgICAg IC8vIE90aGVyd2lzZSwgdGhlIG5vZGUgaXMgcHV0IGluIGFuIG9iamVjdCBncm91cCBpZGVudGlm aWVkIGJ5IHRoZSByb290CiAgICAgICAgIC8vIGVsZW1lbnQgb2YgdGhlIHRyZWUgdG8gd2hpY2gg aXQgYmVsb25ncy4KLSAgICAgICAgdWludHB0cl90IGdyb3VwSWQ7CisgICAgICAgIE5vZGUqIGdy b3VwUm9vdDsKICAgICAgICAgaWYgKG5vZGUtPmluRG9jdW1lbnQoKSB8fCAobm9kZS0+aGFzVGFn TmFtZShIVE1MTmFtZXM6OmltZ1RhZykgJiYgIXN0YXRpY19jYXN0PEhUTUxJbWFnZUVsZW1lbnQq Pihub2RlKS0+aGF2ZUZpcmVkTG9hZEV2ZW50KCkpKQotICAgICAgICAgICAgZ3JvdXBJZCA9IHJl aW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90Pihub2RlLT5kb2N1bWVudCgpKTsKKyAgICAgICAgICAg IGdyb3VwUm9vdCA9IG5vZGUtPmRvY3VtZW50KCk7CiAgICAgICAgIGVsc2UgewotICAgICAgICAg ICAgTm9kZSogcm9vdCA9IG5vZGU7CisgICAgICAgICAgICBncm91cFJvb3QgPSBub2RlOwogICAg ICAgICAgICAgaWYgKG5vZGUtPmlzQXR0cmlidXRlTm9kZSgpKSB7Ci0gICAgICAgICAgICAgICAg cm9vdCA9IHN0YXRpY19jYXN0PEF0dHIqPihub2RlKS0+b3duZXJFbGVtZW50KCk7CisgICAgICAg ICAgICAgICAgZ3JvdXBSb290ID0gc3RhdGljX2Nhc3Q8QXR0cio+KG5vZGUpLT5vd25lckVsZW1l bnQoKTsKICAgICAgICAgICAgICAgICAvLyBJZiB0aGUgYXR0cmlidXRlIGhhcyBubyBlbGVtZW50 LCBubyBuZWVkIHRvIHB1dCBpdCBpbiB0aGUgZ3JvdXAsCiAgICAgICAgICAgICAgICAgLy8gYmVj YXVzZSBpdCdsbCBhbHdheXMgYmUgYSBncm91cCBvZiAxLgotICAgICAgICAgICAgICAgIGlmICgh cm9vdCkKKyAgICAgICAgICAgICAgICBpZiAoIWdyb3VwUm9vdCkKICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuOwogICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICB3aGlsZSAo cm9vdC0+cGFyZW50Tm9kZSgpKQotICAgICAgICAgICAgICAgICAgICByb290ID0gcm9vdC0+cGFy ZW50Tm9kZSgpOworICAgICAgICAgICAgICAgIHdoaWxlIChncm91cFJvb3QtPnBhcmVudE5vZGUo KSkKKyAgICAgICAgICAgICAgICAgICAgZ3JvdXBSb290ID0gZ3JvdXBSb290LT5wYXJlbnROb2Rl KCk7CiAKICAgICAgICAgICAgICAgICAvLyBJZiB0aGUgbm9kZSBpcyBhbG9uZSBpbiBpdHMgRE9N IHRyZWUgKGRvZXNuJ3QgaGF2ZSBhIHBhcmVudCBvciBhbnkKICAgICAgICAgICAgICAgICAvLyBj aGlsZHJlbikgdGhlbiB0aGUgZ3JvdXAgd2lsbCBiZSBmaWx0ZXJlZCBvdXQgbGF0ZXIgYW55d2F5 LgotICAgICAgICAgICAgICAgIGlmIChyb290ID09IG5vZGUgJiYgIW5vZGUtPmhhc0NoaWxkTm9k ZXMoKSAmJiAhbm9kZS0+aGFzQXR0cmlidXRlcygpKQorICAgICAgICAgICAgICAgIGlmIChncm91 cFJvb3QgPT0gbm9kZSAmJiAhbm9kZS0+aGFzQ2hpbGROb2RlcygpICYmICFub2RlLT5oYXNBdHRy aWJ1dGVzKCkpCiAgICAgICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgIH0KLSAg ICAgICAgICAgIGdyb3VwSWQgPSByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4ocm9vdCk7CiAg ICAgICAgIH0KLSAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElkLCB3 cmFwcGVyKSk7CisgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBSb290 LCB3cmFwcGVyKSk7CiAKICAgICAgICAgLy8gSWYgdGhlIG5vZGUgaXMgc3R5bGVkIGFuZCB0aGVy ZSBpcyBhIHdyYXBwZXIgZm9yIHRoZSBpbmxpbmUKICAgICAgICAgLy8gc3R5bGUgZGVjbGFyYXRp b24sIHdlIG5lZWQgdG8ga2VlcCB0aGF0IHN0eWxlIGRlY2xhcmF0aW9uCiAgICAgICAgIC8vIHdy YXBwZXIgYWxpdmUgYXMgd2VsbCwgc28gd2UgYWRkIGl0IHRvIHRoZSBvYmplY3QgZ3JvdXAuCiAg ICAgICAgIGlmIChub2RlLT5pc1N0eWxlZEVsZW1lbnQoKSkgewogICAgICAgICAgICAgU3R5bGVk RWxlbWVudCogZWxlbWVudCA9IHJlaW50ZXJwcmV0X2Nhc3Q8U3R5bGVkRWxlbWVudCo+KG5vZGUp OwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgZWxlbWVu dC0+aW5saW5lU3R5bGVEZWNsKCkpOworICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChz dG9yZSwgZ3JvdXBSb290LCBlbGVtZW50LT5pbmxpbmVTdHlsZURlY2woKSk7CiAgICAgICAgIH0K IAogICAgICAgICBpZiAobm9kZS0+aXNEb2N1bWVudE5vZGUoKSkgewogICAgICAgICAgICAgRG9j dW1lbnQqIGRvY3VtZW50ID0gcmVpbnRlcnByZXRfY2FzdDxEb2N1bWVudCo+KG5vZGUpOwotICAg ICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgZG9jdW1lbnQtPnN0 eWxlU2hlZXRzKCkpOwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3Jv dXBJZCwgZG9jdW1lbnQtPmltcGxlbWVudGF0aW9uKCkpOworICAgICAgICAgICAgYWRkRE9NT2Jq ZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBSb290LCBkb2N1bWVudC0+c3R5bGVTaGVldHMoKSk7Cisg ICAgICAgICAgICBhZGRET01PYmplY3RUb0dyb3VwKHN0b3JlLCBncm91cFJvb3QsIGRvY3VtZW50 LT5pbXBsZW1lbnRhdGlvbigpKTsKICAgICAgICAgfQogCiAgICAgICAgIFdyYXBwZXJUeXBlSW5m byogdHlwZUluZm8gPSBWOERPTVdyYXBwZXI6OmRvbVdyYXBwZXJUeXBlKHdyYXBwZXIpOwogCiAg ICAgICAgIGlmIChWOEhUTUxMaW5rRWxlbWVudDo6aW5mby5lcXVhbHModHlwZUluZm8pKSB7CiAg ICAgICAgICAgICBIVE1MTGlua0VsZW1lbnQqIGh0bWxMaW5rRWxlbWVudCA9IHN0YXRpY19jYXN0 PEhUTUxMaW5rRWxlbWVudCo+KG5vZGUpOwotICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91 cChzdG9yZSwgZ3JvdXBJZCwgaHRtbExpbmtFbGVtZW50LT5zaGVldCgpKTsKKyAgICAgICAgICAg IGFkZERPTU9iamVjdFRvR3JvdXAoc3RvcmUsIGdyb3VwUm9vdCwgaHRtbExpbmtFbGVtZW50LT5z aGVldCgpKTsKICAgICAgICAgfQogCiAgICAgICAgIGlmIChWOEhUTUxTdHlsZUVsZW1lbnQ6Omlu Zm8uZXF1YWxzKHR5cGVJbmZvKSkgewogICAgICAgICAgICAgSFRNTFN0eWxlRWxlbWVudCogaHRt bFN0eWxlRWxlbWVudCA9IHN0YXRpY19jYXN0PEhUTUxTdHlsZUVsZW1lbnQqPihub2RlKTsKLSAg ICAgICAgICAgIGFkZERPTU9iamVjdFRvR3JvdXAoc3RvcmUsIGdyb3VwSWQsIGh0bWxTdHlsZUVs ZW1lbnQtPnNoZWV0KCkpOworICAgICAgICAgICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwg Z3JvdXBSb290LCBodG1sU3R5bGVFbGVtZW50LT5zaGVldCgpKTsKICAgICAgICAgfQogCiAgICAg ICAgIGlmIChWOFByb2Nlc3NpbmdJbnN0cnVjdGlvbjo6aW5mby5lcXVhbHModHlwZUluZm8pKSB7 CiAgICAgICAgICAgICBQcm9jZXNzaW5nSW5zdHJ1Y3Rpb24qIHByb2Nlc3NpbmdJbnN0cnVjdGlv biA9IHN0YXRpY19jYXN0PFByb2Nlc3NpbmdJbnN0cnVjdGlvbio+KG5vZGUpOwotICAgICAgICAg ICAgYWRkRE9NT2JqZWN0VG9Hcm91cChzdG9yZSwgZ3JvdXBJZCwgcHJvY2Vzc2luZ0luc3RydWN0 aW9uLT5zaGVldCgpKTsKKyAgICAgICAgICAgIGFkZERPTU9iamVjdFRvR3JvdXAoc3RvcmUsIGdy b3VwUm9vdCwgcHJvY2Vzc2luZ0luc3RydWN0aW9uLT5zaGVldCgpKTsKICAgICAgICAgfQogICAg IH0KIApAQCAtMzE5LDE3ICszNzcsMTcgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBHcm91cGVy TGlzdCBtX2dyb3VwZXI7CiAKLSAgICB2b2lkIGFkZERPTU9iamVjdFRvR3JvdXAoRE9NRGF0YVN0 b3JlKiBzdG9yZSwgdWludHB0cl90IGdyb3VwSWQsIHZvaWQqIG9iamVjdCkKKyAgICB2b2lkIGFk ZERPTU9iamVjdFRvR3JvdXAoRE9NRGF0YVN0b3JlKiBzdG9yZSwgTm9kZSogZ3JvdXBSb290LCB2 b2lkKiBvYmplY3QpCiAgICAgewogICAgICAgICBpZiAoIW9iamVjdCkKICAgICAgICAgICAgIHJl dHVybjsKICAgICAgICAgdjg6OlBlcnNpc3RlbnQ8djg6Ok9iamVjdD4gd3JhcHBlciA9IHN0b3Jl LT5kb21PYmplY3RNYXAoKS5nZXQob2JqZWN0KTsKICAgICAgICAgaWYgKCF3cmFwcGVyLklzRW1w dHkoKSkKLSAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwg d3JhcHBlcikpOworICAgICAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91 cFJvb3QsIHdyYXBwZXIpKTsKICAgICB9CiB9OwogCi1zdGF0aWMgdWludHB0cl90IGNhbGN1bGF0 ZUdyb3VwSWQoU3R5bGVCYXNlKiBzdHlsZUJhc2UpCitzdGF0aWMgdm9pZCogY2FsY3VsYXRlR3Jv dXBSb290KFN0eWxlQmFzZSogc3R5bGVCYXNlKQogewogICAgIEFTU0VSVChzdHlsZUJhc2UpOwog ICAgIFN0eWxlQmFzZSogY3VycmVudCA9IHN0eWxlQmFzZTsKQEAgLTM0Myw3ICs0MDEsNyBAQCBz dGF0aWMgdWludHB0cl90IGNhbGN1bGF0ZUdyb3VwSWQoU3R5bGVCYXNlKiBzdHlsZUJhc2UpCiAg ICAgICAgICAgICBpZiAoQ1NTUnVsZSogcGFyZW50UnVsZSA9IGNzc011dGFibGVTdHlsZURlY2xh cmF0aW9uLT5wYXJlbnRSdWxlKCkpCiAgICAgICAgICAgICAgICAgY3VycmVudCA9IHBhcmVudFJ1 bGU7CiAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgcmV0dXJuIHJlaW50ZXJwcmV0 X2Nhc3Q8dWludHB0cl90Pihjc3NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbik7CisgICAgICAgICAg ICAgICAgcmV0dXJuIGNzc011dGFibGVTdHlsZURlY2xhcmF0aW9uOwogICAgICAgICB9CiAKICAg ICAgICAgaWYgKGN1cnJlbnQtPmlzU3R5bGVTaGVldCgpKQpAQCAtMzU2LDkgKzQxNCw5IEBAIHN0 YXRpYyB1aW50cHRyX3QgY2FsY3VsYXRlR3JvdXBJZChTdHlsZUJhc2UqIHN0eWxlQmFzZSkKICAg ICB9CiAKICAgICBpZiAoc3R5bGVTaGVldCkKLSAgICAgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nh c3Q8dWludHB0cl90PihzdHlsZVNoZWV0KTsKKyAgICAgICAgcmV0dXJuIHN0eWxlU2hlZXQ7CiAK LSAgICByZXR1cm4gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KGN1cnJlbnQpOworICAgIHJl dHVybiBjdXJyZW50OwogfQogCiBjbGFzcyBET01PYmplY3RHcm91cGVyVmlzaXRvciA6IHB1Ymxp YyBET01XcmFwcGVyTWFwPHZvaWQ+OjpWaXNpdG9yIHsKQEAgLTM5Miw4ICs0NTAsOCBAQCBwdWJs aWM6CiAgICAgICAgICAgICB8fCBWOENTU01lZGlhUnVsZTo6aW5mby5lcXVhbHModHlwZUluZm8p KSB7CiAgICAgICAgICAgICBTdHlsZUJhc2UqIHN0eWxlQmFzZSA9IHN0YXRpY19jYXN0PFN0eWxl QmFzZSo+KG9iamVjdCk7CiAKLSAgICAgICAgICAgIHVpbnRwdHJfdCBncm91cElkID0gY2FsY3Vs YXRlR3JvdXBJZChzdHlsZUJhc2UpOwotICAgICAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91 cGVySXRlbShncm91cElkLCB3cmFwcGVyKSk7CisgICAgICAgICAgICB2b2lkKiByb290ID0gY2Fs Y3VsYXRlR3JvdXBSb290KHN0eWxlQmFzZSk7CisgICAgICAgICAgICBtX2dyb3VwZXIuYXBwZW5k KEdyb3VwZXJJdGVtKHJvb3QsIHdyYXBwZXIpKTsKIAogICAgICAgICAgICAgaWYgKFY4Q1NTU3R5 bGVEZWNsYXJhdGlvbjo6aW5mby5lcXVhbHModHlwZUluZm8pKSB7CiAgICAgICAgICAgICAgICAg Q1NTU3R5bGVEZWNsYXJhdGlvbiogY3NzU3R5bGVEZWNsYXJhdGlvbiA9IHN0YXRpY19jYXN0PENT U1N0eWxlRGVjbGFyYXRpb24qPihzdHlsZUJhc2UpOwpAQCAtNDAzLDcgKzQ2MSw3IEBAIHB1Ymxp YzoKICAgICAgICAgICAgICAgICAgICAgZm9yIChDU1NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbjo6 Y29uc3RfaXRlcmF0b3IgaXQgPSBjc3NNdXRhYmxlU3R5bGVEZWNsYXJhdGlvbi0+YmVnaW4oKTsg aXQgIT0gZW5kOyArK2l0KSB7CiAgICAgICAgICAgICAgICAgICAgICAgICB3cmFwcGVyID0gc3Rv cmUtPmRvbU9iamVjdE1hcCgpLmdldChpdC0+dmFsdWUoKSk7CiAgICAgICAgICAgICAgICAgICAg ICAgICBpZiAoIXdyYXBwZXIuSXNFbXB0eSgpKQotICAgICAgICAgICAgICAgICAgICAgICAgICAg IG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOworICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0ocm9vdCwg d3JhcHBlcikpOwogICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQogICAg ICAgICAgICAgfQpAQCAtNDIwLDEyICs0NzgsMTEgQEAgcHJpdmF0ZToKICAgICB0ZW1wbGF0ZSA8 Y2xhc3MgQz4KICAgICB2b2lkIGFkZEFsbEl0ZW1zKERPTURhdGFTdG9yZSogc3RvcmUsIEMqIGNv bGxlY3Rpb24sIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpCiAgICAgewotICAg ICAgICB1aW50cHRyX3QgZ3JvdXBJZCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90Pihjb2xs ZWN0aW9uKTsKLSAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElkLCB3 cmFwcGVyKSk7CisgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oY29sbGVjdGlv biwgd3JhcHBlcikpOwogICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY29sbGVjdGlv bi0+bGVuZ3RoKCk7IGkrKykgewogICAgICAgICAgICAgd3JhcHBlciA9IHN0b3JlLT5kb21PYmpl Y3RNYXAoKS5nZXQoY29sbGVjdGlvbi0+aXRlbShpKSk7CiAgICAgICAgICAgICBpZiAoIXdyYXBw ZXIuSXNFbXB0eSgpKQotICAgICAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0 ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOworICAgICAgICAgICAgICAgIG1fZ3JvdXBlci5hcHBlbmQo R3JvdXBlckl0ZW0oY29sbGVjdGlvbiwgd3JhcHBlcikpOwogICAgICAgICB9CiAgICAgfQogfTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1dyYXBwZXJUeXBlSW5mby5o IGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvV3JhcHBlclR5cGVJbmZvLmgKaW5kZXggMWQx Y2JmZC4uZTA3YWQwZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvV3Jh cHBlclR5cGVJbmZvLmgKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvV3JhcHBlclR5 cGVJbmZvLmgKQEAgLTQxLDcgKzQxLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogICAgIHN0YXRp YyBjb25zdCBpbnQgdjhET01XcmFwcGVyT2JqZWN0SW5kZXggPSAxOwogICAgIHN0YXRpYyBjb25z dCBpbnQgdjhET01IaWRkZW5SZWZlcmVuY2VBcnJheUluZGV4ID0gMjsKICAgICBzdGF0aWMgY29u c3QgaW50IHY4RGVmYXVsdFdyYXBwZXJJbnRlcm5hbEZpZWxkQ291bnQgPSAzOwotICAgIAorCisg ICAgc3RhdGljIGNvbnN0IHVpbnQxNl90IHY4RE9NU3VidHJlZUNsYXNzSWQgPSAxOworCiAgICAg dHlwZWRlZiB2ODo6UGVyc2lzdGVudDx2ODo6RnVuY3Rpb25UZW1wbGF0ZT4gKCpHZXRUZW1wbGF0 ZUZ1bmN0aW9uKSgpOwogICAgIHR5cGVkZWYgdm9pZCAoKkRlcmVmT2JqZWN0RnVuY3Rpb24pKHZv aWQqKTsKICAgICB0eXBlZGVmIEFjdGl2ZURPTU9iamVjdCogKCpUb0FjdGl2ZURPTU9iamVjdEZ1 bmN0aW9uKSh2ODo6SGFuZGxlPHY4OjpPYmplY3Q+KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdEdyaWROb2Rlcy5qcyBiL1Nv dXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdEdyaWROb2Rl cy5qcwppbmRleCAxNGJhMTQyLi4yYjNkMTMxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL0RldGFpbGVkSGVhcHNob3RHcmlkTm9kZXMuanMKKysrIGIvU291 cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhlYXBzaG90R3JpZE5vZGVz LmpzCkBAIC0zOTQsMTQgKzM5NCwxNCBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90SW5zdGFu Y2VOb2RlLnByb3RvdHlwZSA9IHsKIAogV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEluc3RhbmNl Tm9kZS5wcm90b3R5cGUuX19wcm90b19fID0gV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEdlbmVy aWNPYmplY3ROb2RlLnByb3RvdHlwZTsKIAotV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdENvbnN0 cnVjdG9yTm9kZSA9IGZ1bmN0aW9uKHRyZWUsIGNvbnN0cnVjdG9yLCBhZ2dyZWdhdGUpCitXZWJJ bnNwZWN0b3IuSGVhcFNuYXBzaG90Q29uc3RydWN0b3JOb2RlID0gZnVuY3Rpb24odHJlZSwgY2xh c3NOYW1lLCBhZ2dyZWdhdGUpCiB7CiAgICAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEdyaWRO b2RlLmNhbGwodGhpcywgdHJlZSwgYWdncmVnYXRlLmNvdW50ID4gMCwgMTAwKTsKLSAgICB0aGlz Ll9uYW1lID0gY29uc3RydWN0b3I7CisgICAgdGhpcy5fbmFtZSA9IGNsYXNzTmFtZTsKICAgICB0 aGlzLl9jb3VudCA9IGFnZ3JlZ2F0ZS5jb3VudDsKICAgICB0aGlzLl9zaGFsbG93U2l6ZSA9IGFn Z3JlZ2F0ZS5zZWxmOwogICAgIHRoaXMuX3JldGFpbmVkU2l6ZSA9IGFnZ3JlZ2F0ZS5tYXhSZXQ7 Ci0gICAgdGhpcy5fcHJvdmlkZXIgPSB0aGlzLl9jcmVhdGVOb2Rlc1Byb3ZpZGVyKHRyZWUuc25h cHNob3QsIGFnZ3JlZ2F0ZS50eXBlLCBhZ2dyZWdhdGUubmFtZSk7CisgICAgdGhpcy5fcHJvdmlk ZXIgPSB0aGlzLl9jcmVhdGVOb2Rlc1Byb3ZpZGVyKHRyZWUuc25hcHNob3QsIGFnZ3JlZ2F0ZS50 eXBlLCBjbGFzc05hbWUpOwogfQogCiBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90Q29uc3RydWN0 b3JOb2RlLnByb3RvdHlwZSA9IHsKQEAgLTQxMCwxNCArNDEwLDE0IEBAIFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3RDb25zdHJ1Y3Rvck5vZGUucHJvdG90eXBlID0gewogICAgICAgICByZXR1cm4g bmV3IFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RJbnN0YW5jZU5vZGUodGhpcy5kYXRhR3JpZCwg bnVsbCwgdGhpcy5kYXRhR3JpZC5zbmFwc2hvdCwgcHJvdmlkZXIuaXRlbSk7CiAgICAgfSwKIAot ICAgIF9jcmVhdGVOb2Rlc1Byb3ZpZGVyOiBmdW5jdGlvbihzbmFwc2hvdCwgbm9kZVR5cGUsIG5v ZGVOYW1lKQorICAgIF9jcmVhdGVOb2Rlc1Byb3ZpZGVyOiBmdW5jdGlvbihzbmFwc2hvdCwgbm9k ZVR5cGUsIG5vZGVDbGFzc05hbWUpCiAgICAgewogICAgICAgICByZXR1cm4gbmV3IFdlYkluc3Bl Y3Rvci5IZWFwU25hcHNob3ROb2Rlc1Byb3ZpZGVyKAogICAgICAgICAgICAgc25hcHNob3QsCiAg ICAgICAgICAgICBzbmFwc2hvdC5hbGxOb2RlcywKICAgICAgICAgICAgIGZ1bmN0aW9uIChub2Rl KSB7CiAgICAgICAgICAgICAgICAgIHJldHVybiBub2RlLnR5cGUgPT09IG5vZGVUeXBlCi0gICAg ICAgICAgICAgICAgICAgICAmJiAobm9kZU5hbWUgPT09IG51bGwgfHwgbm9kZS5uYW1lID09PSBu b2RlTmFtZSk7CisgICAgICAgICAgICAgICAgICAgICYmIChub2RlQ2xhc3NOYW1lID09PSBudWxs IHx8IG5vZGUuY2xhc3NOYW1lID09PSBub2RlQ2xhc3NOYW1lKTsKICAgICAgICAgICAgIH0pOwog ICAgIH0sCiAKQEAgLTQ5OCwxNiArNDk4LDE2IEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RJ dGVyYXRvcnNUdXBsZS5wcm90b3R5cGUgPSB7CiAgICAgfQogfTsKIAotV2ViSW5zcGVjdG9yLkhl YXBTbmFwc2hvdERpZmZOb2RlID0gZnVuY3Rpb24odHJlZSwgY29uc3RydWN0b3IsIGJhc2VBZ2dy ZWdhdGUsIGFnZ3JlZ2F0ZSkKK1dlYkluc3BlY3Rvci5IZWFwU25hcHNob3REaWZmTm9kZSA9IGZ1 bmN0aW9uKHRyZWUsIGNsYXNzTmFtZSwgYmFzZUFnZ3JlZ2F0ZSwgYWdncmVnYXRlKQogewogICAg IGlmICghYmFzZUFnZ3JlZ2F0ZSkKICAgICAgICAgYmFzZUFnZ3JlZ2F0ZSA9IHsgY291bnQ6IDAs IHNlbGY6IDAsIG1heFJldDogMCwgdHlwZTphZ2dyZWdhdGUudHlwZSwgbmFtZTphZ2dyZWdhdGUu bmFtZSwgaWR4czogW10gfTsKICAgICBpZiAoIWFnZ3JlZ2F0ZSkKICAgICAgICAgYWdncmVnYXRl ID0geyBjb3VudDogMCwgc2VsZjogMCwgbWF4UmV0OiAwLCB0eXBlOmJhc2VBZ2dyZWdhdGUudHlw ZSwgbmFtZTpiYXNlQWdncmVnYXRlLm5hbWUsIGlkeHM6IFtdIH07CiAgICAgV2ViSW5zcGVjdG9y LkhlYXBTbmFwc2hvdEdyaWROb2RlLmNhbGwodGhpcywgdHJlZSwgdHJ1ZSwgNTApOwotICAgIHRo aXMuX25hbWUgPSBjb25zdHJ1Y3RvcjsKKyAgICB0aGlzLl9uYW1lID0gY2xhc3NOYW1lOwogICAg IHRoaXMuX2NhbGN1bGF0ZURpZmYodHJlZS5iYXNlU25hcHNob3QsIHRyZWUuc25hcHNob3QsIGJh c2VBZ2dyZWdhdGUuaWR4cywgYWdncmVnYXRlLmlkeHMpOwotICAgIHRoaXMuX3Byb3ZpZGVyID0g dGhpcy5fY3JlYXRlTm9kZXNQcm92aWRlcih0cmVlLmJhc2VTbmFwc2hvdCwgdHJlZS5zbmFwc2hv dCwgYWdncmVnYXRlLnR5cGUsIGFnZ3JlZ2F0ZS5uYW1lKTsKKyAgICB0aGlzLl9wcm92aWRlciA9 IHRoaXMuX2NyZWF0ZU5vZGVzUHJvdmlkZXIodHJlZS5iYXNlU25hcHNob3QsIHRyZWUuc25hcHNo b3QsIGFnZ3JlZ2F0ZS50eXBlLCBjbGFzc05hbWUpOwogfQogCiBXZWJJbnNwZWN0b3IuSGVhcFNu YXBzaG90RGlmZk5vZGUucHJvdG90eXBlID0gewpAQCAtNTU5LDcgKzU1OSw3IEBAIFdlYkluc3Bl Y3Rvci5IZWFwU25hcHNob3REaWZmTm9kZS5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICByZXR1 cm4gbmV3IFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RJbnN0YW5jZU5vZGUodGhpcy5kYXRhR3Jp ZCwgcHJvdmlkZXIuc25hcHNob3QsIG51bGwsIHByb3ZpZGVyLml0ZW0pOwogICAgIH0sCiAKLSAg ICBfY3JlYXRlTm9kZXNQcm92aWRlcjogZnVuY3Rpb24oYmFzZVNuYXBzaG90LCBzbmFwc2hvdCwg bm9kZVR5cGUsIG5vZGVOYW1lKQorICAgIF9jcmVhdGVOb2Rlc1Byb3ZpZGVyOiBmdW5jdGlvbihi YXNlU25hcHNob3QsIHNuYXBzaG90LCBub2RlVHlwZSwgbm9kZUNsYXNzTmFtZSkKICAgICB7CiAg ICAgICAgIHJldHVybiBuZXcgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEl0ZXJhdG9yc1R1cGxl KAogICAgICAgICAgICAgY3JlYXRlUHJvdmlkZXIoc25hcHNob3QsIGJhc2VTbmFwc2hvdCksIGNy ZWF0ZVByb3ZpZGVyKGJhc2VTbmFwc2hvdCwgc25hcHNob3QpKTsKQEAgLTU3MSw3ICs1NzEsNyBA QCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUucHJvdG90eXBlID0gewogICAgICAg ICAgICAgICAgIHNuYXBzaG90LmFsbE5vZGVzLAogICAgICAgICAgICAgICAgIGZ1bmN0aW9uIChu b2RlKSB7CiAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gbm9kZS50eXBlID09PSBub2RlVHlw ZQotICAgICAgICAgICAgICAgICAgICAgICAgICYmIChub2RlTmFtZSA9PT0gbnVsbCB8fCBub2Rl Lm5hbWUgPT09IG5vZGVOYW1lKQorICAgICAgICAgICAgICAgICAgICAgICAgICYmIChub2RlQ2xh c3NOYW1lID09PSBudWxsIHx8IG5vZGUuY2xhc3NOYW1lID09PSBub2RlQ2xhc3NOYW1lKQogICAg ICAgICAgICAgICAgICAgICAgICAgICYmICEobm9kZS5pZCBpbiBvdGhlclNuYXBzaG90Lmlkc01h cCk7CiAgICAgICAgICAgICAgICAgfSk7CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdFZpZXcuanMgYi9Tb3Vy Y2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0RldGFpbGVkSGVhcHNob3RWaWV3LmpzCmlu ZGV4IDNkNTVmMDEuLjU0NTU0YmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rv ci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdFZpZXcuanMKKysrIGIvU291cmNlL1dlYkNvcmUv aW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhlYXBzaG90Vmlldy5qcwpAQCAtMjYzLDExICsy NjMsMjEgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFJldGFpbmluZ1BhdGhzTGlzdC5wcm90 b3R5cGUgPSB7CiAgICAgICAgICAgICB0aGlzLnNlYXJjaENhbmNlbGxlZCgpOwogCiAgICAgICAg IHRoaXMucGF0aEZpbmRlciA9IG5ldyBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UGF0aEZpbmRl cihzbmFwc2hvdCwgbm9kZUluZGV4KTsKKyAgICAgICAgdGhpcy5fc2V0Um9vdENoaWxkcmVuRm9y RmluZGVyKCk7CiAKICAgICAgICAgdGhpcy5yZW1vdmVDaGlsZHJlbigpOwogCiAgICAgICAgIHRo aXMuX2NvdW50ZXIgPSAwOwotICAgICAgICB0aGlzLnNob3dOZXh0KDEwKTsKKyAgICAgICAgdGhp cy5zaG93TmV4dCgxMDApOworICAgIH0sCisKKyAgICByZWZyZXNoOiBmdW5jdGlvbigpCisgICAg eworICAgICAgICB0aGlzLnJlbW92ZUNoaWxkcmVuKCk7CisgICAgICAgIHRoaXMuX2NvdW50ZXIg PSAwOworICAgICAgICBkZWxldGUgdGhpcy5fY2FuY2VsOworICAgICAgICB0aGlzLl9zZXRSb290 Q2hpbGRyZW5Gb3JGaW5kZXIoKTsKKyAgICAgICAgdGhpcy5zaG93TmV4dCgxMDApOwogICAgIH0s CiAKICAgICBzaG93TmV4dDogZnVuY3Rpb24ocGF0aHNDb3VudCkKQEAgLTI4Myw3ICsyOTMsNyBA QCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZSA9 IHsKICAgICAgICAgICAgICAgICAgICAgaWYgKHJlc3VsdCA9PT0gbnVsbCkgewogICAgICAgICAg ICAgICAgICAgICAgICAgV2ViSW5zcGVjdG9yLlBsZWFzZVdhaXRNZXNzYWdlLnByb3RvdHlwZS5o aWRlKCk7CiAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIXRoaXMuY2hpbGRyZW4ubGVuZ3Ro KQotICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMuYXBwZW5kQ2hpbGQobmV3IFdlYklu c3BlY3Rvci5EYXRhR3JpZE5vZGUoe3BhdGg6V2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJUaGlzIG9i amVjdCBpcyBlaXRoZXIgb25seSBhY2Nlc3NpYmxlIHZpYSBoaWRkZW4gcHJvcGVydGllcywgb3Ig Y3VycmVudCBwYXRoIHNlYXJjaCBkZXB0aCBpc24ndCBlbm91Z2guIiksIGxlbjoiIn0sIGZhbHNl KSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5hcHBlbmRDaGlsZChuZXcgV2Vi SW5zcGVjdG9yLkRhdGFHcmlkTm9kZSh7cGF0aDpXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkNhbid0 IGZpbmQgYW55IHBhdGhzLiIpLCBsZW46IiJ9LCBmYWxzZSkpOwogICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuOwogICAgICAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKHJlc3VsdCAhPT0g ZmFsc2UpIHsKICAgICAgICAgICAgICAgICAgICAgICAgIGlmICh0aGlzLl9wcmVmaXgpCkBAIC0z MTEsNiArMzIxLDE5IEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQYXRoc0xp c3QucHJvdG90eXBlID0gewogICAgICAgICB9CiAgICAgfSwKIAorICAgIF9zZXRSb290Q2hpbGRy ZW5Gb3JGaW5kZXI6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIGZ1bmN0aW9uIEZpbHRlckRP TVdpbmRvdyhub2RlKQorICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gbm9kZS5uYW1lID09 PSAiRE9NV2luZG93IjsKKyAgICAgICAgfQorCisgICAgICAgIGlmICh0aGlzLnNuYXBzaG90Vmll dy5pc1RyYWNpbmdUb1dpbmRvd09iamVjdHMpCisgICAgICAgICAgICB0aGlzLnBhdGhGaW5kZXIu dXBkYXRlUm9vdHMoRmlsdGVyRE9NV2luZG93KTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAg dGhpcy5wYXRoRmluZGVyLnVwZGF0ZVJvb3RzKCk7CisgICAgfSwKKwogICAgIF9wZXJmb3JtU29y dGluZzogZnVuY3Rpb24oc29ydEZ1bmN0aW9uKQogICAgIHsKICAgICAgICAgZnVuY3Rpb24gRGF0 YUV4dHJhY3RvcldyYXBwZXIobm9kZUEsIG5vZGVCKQpAQCAtMzc1LDggKzM5OCwxOCBAQCBXZWJJ bnNwZWN0b3IuRGV0YWlsZWRIZWFwc2hvdFZpZXcgPSBmdW5jdGlvbihwYXJlbnQsIHByb2ZpbGUp CiAgICAgdmFyIHJldGFpbmluZ1BhdGhzVGl0bGVEaXYgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJkaXYiKTsKICAgICByZXRhaW5pbmdQYXRoc1RpdGxlRGl2LmNsYXNzTmFtZSA9ICJ0aXRsZSI7 CiAgICAgdmFyIHJldGFpbmluZ1BhdGhzVGl0bGUgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJz cGFuIik7Ci0gICAgcmV0YWluaW5nUGF0aHNUaXRsZS50ZXh0Q29udGVudCA9IFdlYkluc3BlY3Rv ci5VSVN0cmluZygiUmV0YWluaW5nIHBhdGhzIG9mIHRoZSBzZWxlY3RlZCBvYmplY3QiKTsKKyAg ICByZXRhaW5pbmdQYXRoc1RpdGxlLnRleHRDb250ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5n KCJQYXRocyBmcm9tIHRoZSBzZWxlY3RlZCBvYmplY3QiKTsKKyAgICB0aGlzLnJldGFpbmluZ1Bh dGhzUm9vdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNlbGVjdCIpOworICAgIHRoaXMucmV0 YWluaW5nUGF0aHNSb290LmNsYXNzTmFtZSA9ICJzdGF0dXMtYmFyLWl0ZW0iOworICAgIHRoaXMu cmV0YWluaW5nUGF0aHNSb290LmFkZEV2ZW50TGlzdGVuZXIoImNoYW5nZSIsIHRoaXMuX2NoYW5n ZVJldGFpbmluZ1BhdGhzUm9vdC5iaW5kKHRoaXMpLCBmYWxzZSk7CisgICAgdmFyIHRvR0NSb290 c1RyYWNlT3B0aW9uID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgib3B0aW9uIik7CisgICAgdG9H Q1Jvb3RzVHJhY2VPcHRpb24ubGFiZWwgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoInRvIEdDIHJv b3RzIik7CisgICAgdmFyIHRvV2luZG93T2JqZWN0c1RyYWNlT3B0aW9uID0gZG9jdW1lbnQuY3Jl YXRlRWxlbWVudCgib3B0aW9uIik7CisgICAgdG9XaW5kb3dPYmplY3RzVHJhY2VPcHRpb24ubGFi ZWwgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoInRvIHdpbmRvdyBvYmplY3RzIik7CisgICAgdGhp cy5yZXRhaW5pbmdQYXRoc1Jvb3QuYXBwZW5kQ2hpbGQodG9HQ1Jvb3RzVHJhY2VPcHRpb24pOwor ICAgIHRoaXMucmV0YWluaW5nUGF0aHNSb290LmFwcGVuZENoaWxkKHRvV2luZG93T2JqZWN0c1Ry YWNlT3B0aW9uKTsKICAgICByZXRhaW5pbmdQYXRoc1RpdGxlRGl2LmFwcGVuZENoaWxkKHJldGFp bmluZ1BhdGhzVGl0bGUpOworICAgIHJldGFpbmluZ1BhdGhzVGl0bGVEaXYuYXBwZW5kQ2hpbGQo dGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3QpOwogICAgIHJldGFpbm1lbnRWaWV3LmVsZW1lbnQuYXBw ZW5kQ2hpbGQocmV0YWluaW5nUGF0aHNUaXRsZURpdik7CiAgICAgdGhpcy5yZXRhaW5tZW50RGF0 YUdyaWQgPSBuZXcgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdFJldGFpbmluZ1BhdGhzTGlzdCgp OwogICAgIHJldGFpbm1lbnRWaWV3LmVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5yZXRhaW5tZW50 RGF0YUdyaWQuZWxlbWVudCk7CkBAIC03OTUsNiArODI4LDE4IEBAIFdlYkluc3BlY3Rvci5EZXRh aWxlZEhlYXBzaG90Vmlldy5wcm90b3R5cGUgPSB7CiAgICAgICAgIHRoaXMucGVyZm9ybVNlYXJj aCh0aGlzLmN1cnJlbnRRdWVyeSwgdGhpcy5fc2VhcmNoRmluaXNoZWRDYWxsYmFjayk7CiAgICAg fSwKIAorICAgIF9jaGFuZ2VSZXRhaW5pbmdQYXRoc1Jvb3Q6IGZ1bmN0aW9uKGV2ZW50KQorICAg IHsKKyAgICAgICAgaWYgKCFldmVudCkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgdGhp cy5yZXRhaW5tZW50RGF0YUdyaWQucmVmcmVzaCgpOworICAgIH0sCisKKyAgICBnZXQgaXNUcmFj aW5nVG9XaW5kb3dPYmplY3RzKCkKKyAgICB7CisgICAgICAgIHJldHVybiB0aGlzLnJldGFpbmlu Z1BhdGhzUm9vdC5zZWxlY3RlZEluZGV4ID09PSAxOworICAgIH0sCisKICAgICBnZXQgX2lzU2hv d2luZ0FzUGVyY2VudCgpCiAgICAgewogICAgICAgICByZXR1cm4gdGhpcy5zaG93Q291bnRBc1Bl cmNlbnQgJiYgdGhpcy5zaG93U2hhbGxvd1NpemVBc1BlcmNlbnQgJiYgdGhpcy5zaG93UmV0YWlu ZWRTaXplQXNQZXJjZW50OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9IZWFwU25hcHNob3QuanMgYi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQt ZW5kL0hlYXBTbmFwc2hvdC5qcwppbmRleCAyMTVmMzFjLi5lZDU5MmUyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0hlYXBTbmFwc2hvdC5qcworKysgYi9T b3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0hlYXBTbmFwc2hvdC5qcwpAQCAtMjEy LDYgKzIxMiwxMCBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90Tm9kZS5wcm90b3R5cGUgPSB7 CiAgICAgICAgICAgICByZXR1cm4gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCIoc3lzdGVtKSIpOwog ICAgICAgICBjYXNlICJvYmplY3QiOgogICAgICAgICAgICAgcmV0dXJuIHRoaXMubmFtZTsKKyAg ICAgICAgY2FzZSAibmF0aXZlIjogeworICAgICAgICAgICAgdmFyIGVudGl0aWVzQ291bnRQb3Mg PSB0aGlzLm5hbWUuaW5kZXhPZigiLyIpOworICAgICAgICAgICAgcmV0dXJuIGVudGl0aWVzQ291 bnRQb3MgIT09IC0xID8gdGhpcy5uYW1lLnN1YnN0cmluZygwLCBlbnRpdGllc0NvdW50UG9zKS50 cmltUmlnaHQoKSA6IHRoaXMubmFtZTsKKyAgICAgICAgfQogICAgICAgICBjYXNlICJjb2RlIjoK ICAgICAgICAgICAgIHJldHVybiBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIihjb21waWxlZCBjb2Rl KSIpOwogICAgICAgICBkZWZhdWx0OgpAQCAtNTI1LDggKzUyOSw4IEBAIFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3QucHJvdG90eXBlID0gewogICAgICAgICBmb3IgKHZhciBpdGVyID0gdGhpcy5h bGxOb2RlczsgaXRlci5oYXNOZXh0KCk7IGl0ZXIubmV4dCgpKSB7CiAgICAgICAgICAgICB2YXIg bm9kZSA9IGl0ZXIubm9kZTsKICAgICAgICAgICAgIHZhciBjbGFzc05hbWUgPSBub2RlLmNsYXNz TmFtZTsKLSAgICAgICAgICAgIHZhciBuYW1lTWF0dGVycyA9IG5vZGUudHlwZSA9PT0gIm9iamVj dCI7Ci0gICAgICAgICAgICBpZiAobm9kZS5zZWxmU2l6ZSA9PT0gMCkKKyAgICAgICAgICAgIHZh ciBuYW1lTWF0dGVycyA9IG5vZGUudHlwZSA9PT0gIm9iamVjdCIgfHwgbm9kZS50eXBlID09PSAi bmF0aXZlIjsKKyAgICAgICAgICAgIGlmIChub2RlLnR5cGUgIT09ICJuYXRpdmUiICYmIG5vZGUu c2VsZlNpemUgPT09IDApCiAgICAgICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgICAgICBp ZiAoIShjbGFzc05hbWUgaW4gdGhpcy5fYWdncmVnYXRlcykpCiAgICAgICAgICAgICAgICAgdGhp cy5fYWdncmVnYXRlc1tjbGFzc05hbWVdID0geyBjb3VudDogMCwgc2VsZjogMCwgbWF4UmV0OiAw LCB0eXBlOiBub2RlLnR5cGUsIG5hbWU6IG5hbWVNYXR0ZXJzID8gbm9kZS5uYW1lIDogbnVsbCwg aWR4czogW10gfTsKQEAgLTg0MiwxMSArODQ2LDE4IEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNo b3RQYXRoRmluZGVyLnByb3RvdHlwZSA9IHsKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIH0s CiAKLSAgICBfZmlsbFJvb3RDaGlsZHJlbjogZnVuY3Rpb24oKQorICAgIHVwZGF0ZVJvb3RzOiBm dW5jdGlvbihmaWx0ZXIpCisgICAgeworICAgICAgICB0aGlzLl9yb290Q2hpbGRyZW4gPSB0aGlz Ll9maWxsUm9vdENoaWxkcmVuKGZpbHRlcik7ICAKKyAgICB9LAorCisgICAgX2ZpbGxSb290Q2hp bGRyZW46IGZ1bmN0aW9uKGZpbHRlcikKICAgICB7CiAgICAgICAgIHZhciByZXN1bHQgPSBbXTsK LSAgICAgICAgZm9yICh2YXIgaXRlciA9IHRoaXMuX3NuYXBzaG90LnJvb3ROb2RlLmVkZ2VzOyBp dGVyLmhhc05leHQoKTsgaXRlci5uZXh0KCkpCi0gICAgICAgICAgICByZXN1bHRbaXRlci5lZGdl Lm5vZGVJbmRleF0gPSB0cnVlOworICAgICAgICBmb3IgKHZhciBpdGVyID0gdGhpcy5fc25hcHNo b3Qucm9vdE5vZGUuZWRnZXM7IGl0ZXIuaGFzTmV4dCgpOyBpdGVyLm5leHQoKSkgeworICAgICAg ICAgICAgaWYgKCFmaWx0ZXIgfHwgZmlsdGVyKGl0ZXIuZWRnZS5ub2RlKSkKKyAgICAgICAgICAg ICAgICByZXN1bHRbaXRlci5lZGdlLm5vZGVJbmRleF0gPSB0cnVlOworICAgICAgICB9CiAgICAg ICAgIHJldHVybiByZXN1bHQ7CiAgICAgfSwKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aW5zcGVjdG9yL2Zyb250LWVuZC9oZWFwUHJvZmlsZXIuY3NzIGIvU291cmNlL1dlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9oZWFwUHJvZmlsZXIuY3NzCmluZGV4IGFkZDAyYTEuLmZiODQ4NWQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaGVhcFByb2Zp bGVyLmNzcworKysgYi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2hlYXBQcm9m aWxlci5jc3MKQEAgLTIyOCw4ICsyMjgsMTUgQEAKIH0KIAogLmRldGFpbGVkLWhlYXBzaG90LXZp ZXcgLnJldGFpbmluZy1wYXRocy12aWV3IC50aXRsZSA+IHNwYW4geworICAgIGRpc3BsYXk6IGlu bGluZS1ibG9jazsKKyAgICBwYWRkaW5nLXRvcDogM3B4OwogICAgIHZlcnRpY2FsLWFsaWduOiBt aWRkbGU7CiAgICAgbWFyZ2luLWxlZnQ6IDRweDsKKyAgICBtYXJnaW4tcmlnaHQ6IDhweDsKK30K KworLmRldGFpbGVkLWhlYXBzaG90LXZpZXcgLnJldGFpbmluZy1wYXRocy10by13aW5kb3dzIHsK KyAgICAKIH0KIAogLmhlYXBzaG90LWhlbHAtc3RhdHVzLWJhci1pdGVtIC5nbHlwaCB7Cg== 85931 2011-03-16 08:24:15 -0700 2011-03-16 11:13:03 -0700 Again merged with new Anton's change, addressed Adam's comments patch-53659 text/plain 35355 mnaganov ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tayBiL1NvdXJj ZS9XZWJDb3JlL0FuZHJvaWQudjhiaW5kaW5ncy5tawppbmRleCA3MDA4OTBiLi5kODE1NDE3IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9BbmRyb2lkLnY4YmluZGluZ3MubWsKKysrIGIvU291 cmNlL1dlYkNvcmUvQW5kcm9pZC52OGJpbmRpbmdzLm1rCkBAIC00NSw2ICs0NSw3IEBAIExPQ0FM X1NSQ19GSUxFUyArPSBcCiAJYmluZGluZ3MvdjgvSURCQmluZGluZ1V0aWxpdGllcy5jcHAgXAog CWJpbmRpbmdzL3Y4L01haW5UaHJlYWRET01EYXRhLmNwcCBcCiAJYmluZGluZ3MvdjgvTlBWOE9i amVjdC5jcHAgXAorCWJpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAgXAogCWJpbmRpbmdz L3Y4L1J1bnRpbWVFbmFibGVkRmVhdHVyZXMuY3BwIFwKIAliaW5kaW5ncy92OC9TY2hlZHVsZWRB Y3Rpb24uY3BwIFwKIAliaW5kaW5ncy92OC9TY29wZWRET01EYXRhU3RvcmUuY3BwIFwKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCA5ZjUzOTlkLi4wZjFmYmJiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFu Z2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTYgQEAKKzIw MTEtMDMtMTYgIE1pa2hhaWwgTmFnYW5vdiAgPG1uYWdhbm92QGNocm9taXVtLm9yZz4KKworICAg ICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbQ2hyb21pdW1dIFJl cG9ydCBvYmplY3QgZ3JvdXBzIGFuZCBzaW5nbGUgRE9NLXJlbGF0ZWQgb2JqZWN0cworICAgICAg ICB0byB0aGUgbmV3IGhlYXAgcHJvZmlsZXIuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01MzY1OQorCisgICAgICAgICogQW5kcm9pZC52OGJpbmRpbmdz Lm1rOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnBybzoKKyAg ICAgICAgKiBiaW5kaW5ncy9zY3JpcHRzL0NvZGVHZW5lcmF0b3JWOC5wbToKKyAgICAgICAgKiBi aW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OlJldGFpbmVkRE9NSW5mbzo6UmV0YWluZWRET01JbmZvKToKKyAgICAgICAgKiBiaW5kaW5ncy92 OC9SZXRhaW5lZERPTUluZm8uaDogQWRkZWQuCisgICAgICAgICogYmluZGluZ3MvdjgvUmV0YWlu ZWRPYmplY3RJbmZvLmg6IEFkZGVkLgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1NjcmlwdFByb2Zp bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnJldGFpbmVkRE9NSW5mbyk6CisgICAgICAgIChX ZWJDb3JlOjpTY3JpcHRQcm9maWxlcjo6aW5pdGlhbGl6ZSk6CisgICAgICAgICogYmluZGluZ3Mv djgvU2NyaXB0UHJvZmlsZXIuaDoKKyAgICAgICAgKiBiaW5kaW5ncy92OC9WOERPTVdpbmRvd1No ZWxsLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlY4RE9NV2luZG93U2hlbGw6OmluaXRDb250ZXh0 SWZOZWVkZWQpOgorICAgICAgICAqIGJpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6Okdyb3VwSWQ6Okdyb3VwZXJJdGVtOjpHcm91cGVySXRlbSk6CisgICAg ICAgIChXZWJDb3JlOjpHcm91cElkOjpHcm91cGVySXRlbTo6Z3JvdXBJZCk6CisgICAgICAgIChX ZWJDb3JlOjpHcm91cElkOjpHcm91cGVySXRlbTo6Y3JlYXRlUmV0YWluZWRPYmplY3RJbmZvKToK KyAgICAgICAgKFdlYkNvcmU6OmNhbGN1bGF0ZUdyb3VwSWQpOgorICAgICAgICAoV2ViQ29yZTo6 R3JvdXBlclZpc2l0b3I6OnZpc2l0RE9NV3JhcHBlcik6CisgICAgICAgIChXZWJDb3JlOjpHcm91 cGVyVmlzaXRvcjo6YXBwbHlHcm91cGluZyk6CisgICAgICAgICogYmluZGluZ3MvdjgvV3JhcHBl clR5cGVJbmZvLmg6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhlYXBz aG90R3JpZE5vZGVzLmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdENvbnN0 cnVjdG9yTm9kZSk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90Q29uc3RydWN0 b3JOb2RlLnByb3RvdHlwZS5fY3JlYXRlTm9kZXNQcm92aWRlcik6CisgICAgICAgIChXZWJJbnNw ZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBT bmFwc2hvdERpZmZOb2RlLnByb3RvdHlwZS5fY3JlYXRlTm9kZXNQcm92aWRlci5jcmVhdGVQcm92 aWRlcik6CisgICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUucHJvdG90 eXBlLl9jcmVhdGVOb2Rlc1Byb3ZpZGVyKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5k L0RldGFpbGVkSGVhcHNob3RWaWV3LmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkhlYXBTbmFw c2hvdFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5cGUuc2V0RGF0YVNvdXJjZSk6CisgICAgICAg IChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZS5y ZWZyZXNoKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQYXRo c0xpc3QucHJvdG90eXBlLnNob3dOZXh0LnN0YXJ0U2VhcmNoaW5nKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQYXRoc0xpc3QucHJvdG90eXBlLnNob3dOZXh0 KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQYXRoc0xpc3Qu cHJvdG90eXBlLl9zZXRSb290Q2hpbGRyZW5Gb3JGaW5kZXIpOgorICAgICAgICAoV2ViSW5zcGVj dG9yLkRldGFpbGVkSGVhcHNob3RWaWV3LnByb3RvdHlwZS5fY2hhbmdlUmV0YWluaW5nUGF0aHNS b290KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5EZXRhaWxlZEhlYXBzaG90Vmlldy5wcm90b3R5 cGUuZ2V0IGlzVHJhY2luZ1RvV2luZG93T2JqZWN0cyk6CisgICAgICAgICogaW5zcGVjdG9yL2Zy b250LWVuZC9IZWFwU25hcHNob3QuanM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBz aG90Tm9kZS5wcm90b3R5cGUuZ2V0IGNsYXNzTmFtZSk6CisgICAgICAgIChXZWJJbnNwZWN0b3Iu SGVhcFNuYXBzaG90LnByb3RvdHlwZS5fYnVpbGRBZ2dyZWdhdGVzKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5IZWFwU25hcHNob3RQYXRoRmluZGVyLnByb3RvdHlwZS51cGRhdGVSb290cyk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UGF0aEZpbmRlci5wcm90b3R5cGUuX2Zp bGxSb290Q2hpbGRyZW4pOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvaGVhcFByb2Zp bGVyLmNzczoKKyAgICAgICAgKC5kZXRhaWxlZC1oZWFwc2hvdC12aWV3IC5yZXRhaW5pbmctcGF0 aHMtdmlldyAudGl0bGUgPiBzcGFuKToKKyAgICAgICAgKC5kZXRhaWxlZC1oZWFwc2hvdC12aWV3 IC5yZXRhaW5pbmctcGF0aHMtdG8td2luZG93cyk6CisKIDIwMTEtMDMtMTYgIEFuZHJleSBBZGFp a2luICA8YWFuZHJleUBnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFl1cnkgU2Vt aWtoYXRza3kuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggOWYwNDgxNC4uZDlkOGI1YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUuZ3lwaQpAQCAtOTI2LDYgKzkyNiw5IEBACiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvT3B0 aW9uc09iamVjdC5jcHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L09wdGlvbnNPYmplY3Qu aCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvT3duSGFuZGxlLmgnLAorICAgICAgICAgICAg J2JpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5oJywKKyAgICAgICAgICAgICdiaW5kaW5ncy92 OC9SZXRhaW5lZERPTUluZm8uY3BwJywKKyAgICAgICAgICAgICdiaW5kaW5ncy92OC9SZXRhaW5l ZE9iamVjdEluZm8uaCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvU2NoZWR1bGVkQWN0aW9u LmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvU2NoZWR1bGVkQWN0aW9uLmgnLAogICAg ICAgICAgICAgJ2JpbmRpbmdzL3Y4L1Njb3BlZERPTURhdGFTdG9yZS5jcHAnLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5wcm8gYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnBy bwppbmRleCAwYjMyMzkyLi41NGMwMDk5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJD b3JlLnBybworKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnBybwpAQCAtOTAsNiArOTAsNyBA QCB2OCB7CiAgICAgICAgIGJpbmRpbmdzL3Y4L0RPTURhdGFTdG9yZS5jcHAgXAogICAgICAgICBi aW5kaW5ncy92OC9NYWluVGhyZWFkRE9NRGF0YS5jcHAgXAogICAgICAgICBiaW5kaW5ncy92OC9O UFY4T2JqZWN0LmNwcCBcCisgICAgICAgIGJpbmRpbmdzL3Y4L1JldGFpbmVkRE9NSW5mby5jcHAg XAogICAgICAgICBiaW5kaW5ncy92OC9TY2hlZHVsZWRBY3Rpb24uY3BwIFwKICAgICAgICAgYmlu ZGluZ3MvdjgvU2NvcGVkRE9NRGF0YVN0b3JlLmNwcCBcCiAgICAgICAgIGJpbmRpbmdzL3Y4L1Nj cmlwdENhY2hlZEZyYW1lRGF0YS5jcHAgXApAQCAtMTIwNyw2ICsxMjA4LDggQEAgdjggewogICAg ICAgICBiaW5kaW5ncy92OC9ucHJ1bnRpbWVfcHJpdi5oIFwKICAgICAgICAgYmluZGluZ3Mvdjgv TlBWOE9iamVjdC5oIFwKICAgICAgICAgYmluZGluZ3MvdjgvT3duSGFuZGxlLmggXAorICAgICAg ICBiaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uaCBcCisgICAgICAgIGJpbmRpbmdzL3Y4L1Jl dGFpbmVkT2JqZWN0SW5mby5oIFwKICAgICAgICAgYmluZGluZ3MvdjgvU2NoZWR1bGVkQWN0aW9u LmggXAogICAgICAgICBiaW5kaW5ncy92OC9TY29wZWRET01EYXRhU3RvcmUuaCBcCiAgICAgICAg IGJpbmRpbmdzL3Y4L1NjcmlwdENhY2hlZEZyYW1lRGF0YS5oIFwKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL3NjcmlwdHMvQ29kZUdlbmVyYXRvclY4LnBtIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2RlR2VuZXJhdG9yVjgucG0KaW5kZXggOWQ5MDgzZS4u ZjIwMmQ3NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2Rl R2VuZXJhdG9yVjgucG0KKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mvc2NyaXB0cy9Db2Rl R2VuZXJhdG9yVjgucG0KQEAgLTI1MTEsNyArMjUxMSwxNSBAQCBFTkQKICAgICB9CiAKICAgICBw dXNoKEBpbXBsQ29udGVudCwgPDxFTkQpOwotICAgICR7ZG9tTWFwRnVuY3Rpb259LnNldChpbXBs LCB2ODo6UGVyc2lzdGVudDx2ODo6T2JqZWN0Pjo6TmV3KHdyYXBwZXIpKTsKKyAgICB2ODo6UGVy c2lzdGVudDx2ODo6T2JqZWN0PiB3cmFwcGVySGFuZGxlID0gdjg6OlBlcnNpc3RlbnQ8djg6Ok9i amVjdD46Ok5ldyh3cmFwcGVyKTsKK0VORAorICAgIGlmIChJc05vZGVTdWJUeXBlKCRkYXRhTm9k ZSkpIHsKKyAgICAgICAgcHVzaChAaW1wbENvbnRlbnQsIDw8RU5EKTsKKyAgICB3cmFwcGVySGFu ZGxlLlNldFdyYXBwZXJDbGFzc0lkKHY4RE9NU3VidHJlZUNsYXNzSWQpOworRU5ECisgICAgfSAg ICAKKyAgICBwdXNoKEBpbXBsQ29udGVudCwgPDxFTkQpOworICAgICR7ZG9tTWFwRnVuY3Rpb259 LnNldChpbXBsLCB3cmFwcGVySGFuZGxlKTsKIEVORAogCiAgICAgcHVzaChAaW1wbENvbnRlbnQs IDw8RU5EKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1JldGFpbmVk RE9NSW5mby5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8u Y3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJhNjQyNjMKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uY3Bw CkBAIC0wLDAgKzEsODUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTEgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqIAorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJl CisgKiBtZXQ6CisgKiAKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBt dXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5 cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRo ZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRv cnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJv bQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlz c2lvbi4KKyAqIAorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hU IEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgor ICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4g Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICog T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUmV0YWlu ZWRET01JbmZvLmgiCisKKyNpbmNsdWRlICJOb2RlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsK KworUmV0YWluZWRET01JbmZvOjpSZXRhaW5lZERPTUluZm8oTm9kZSogcm9vdCkKKyAgICA6IG1f cm9vdChyb290KQoreworICAgIEFTU0VSVChtX3Jvb3QpOworfQorCitSZXRhaW5lZERPTUluZm86 On5SZXRhaW5lZERPTUluZm8oKQoreworfQorCit2b2lkIFJldGFpbmVkRE9NSW5mbzo6RGlzcG9z ZSgpCit7CisgICAgZGVsZXRlIHRoaXM7Cit9CisKK2Jvb2wgUmV0YWluZWRET01JbmZvOjpJc0Vx dWl2YWxlbnQodjg6OlJldGFpbmVkT2JqZWN0SW5mbyogb3RoZXIpCit7CisgICAgQVNTRVJUKG90 aGVyKTsKKyAgICByZXR1cm4gb3RoZXIgPT0gdGhpcyB8fCBzdGF0aWNfY2FzdDxXZWJDb3JlOjpS ZXRhaW5lZE9iamVjdEluZm8qPihvdGhlciktPkdldEVxdWl2YWxlbmNlQ2xhc3MoKSA9PSB0aGlz LT5HZXRFcXVpdmFsZW5jZUNsYXNzKCk7Cit9CisKK2ludHB0cl90IFJldGFpbmVkRE9NSW5mbzo6 R2V0SGFzaCgpCit7CisgICAgcmV0dXJuIHJlaW50ZXJwcmV0X2Nhc3Q8aW50cHRyX3Q+KG1fcm9v dCk7Cit9CisgICAgCitjb25zdCBjaGFyKiBSZXRhaW5lZERPTUluZm86OkdldExhYmVsKCkKK3sK KyAgICByZXR1cm4gbV9yb290LT5pbkRvY3VtZW50KCkgPyAiRG9jdW1lbnQgRE9NIHRyZWUiIDog IkRldGFjaGVkIERPTSB0cmVlIjsKK30KKworaW50cHRyX3QgUmV0YWluZWRET01JbmZvOjpHZXRF bGVtZW50Q291bnQoKQoreworICAgIGludHB0cl90IGNvdW50ID0gMTsKKyAgICBOb2RlKiBjdXJy ZW50ID0gbV9yb290OworICAgIHdoaWxlIChjdXJyZW50KSB7CisgICAgICAgIGN1cnJlbnQgPSBj dXJyZW50LT50cmF2ZXJzZU5leHROb2RlKG1fcm9vdCk7CisgICAgICAgICsrY291bnQ7CisgICAg fQorICAgIHJldHVybiBjb3VudDsKK30KKworaW50cHRyX3QgUmV0YWluZWRET01JbmZvOjpHZXRF cXVpdmFsZW5jZUNsYXNzKCkKK3sKKyAgICByZXR1cm4gcmVpbnRlcnByZXRfY2FzdDxpbnRwdHJf dD4obV9yb290KTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmggYi9Tb3VyY2UvV2ViQ29y ZS9iaW5kaW5ncy92OC9SZXRhaW5lZERPTUluZm8uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwLi42NzY3Zjc1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvdjgvUmV0YWluZWRET01JbmZvLmgKQEAgLTAsMCArMSw2MCBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICogUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1 dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgUmV0 YWluZWRET01JbmZvX2gKKyNkZWZpbmUgUmV0YWluZWRET01JbmZvX2gKKworI2luY2x1ZGUgIlJl dGFpbmVkT2JqZWN0SW5mby5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIE5vZGU7 CisKKy8vIEltcGxlbWVudHMgdjg6OlJldGFpbmVkT2JqZWN0SW5mby4KK2NsYXNzIFJldGFpbmVk RE9NSW5mbyA6IHB1YmxpYyBSZXRhaW5lZE9iamVjdEluZm8geworcHVibGljOgorICAgIGV4cGxp Y2l0IFJldGFpbmVkRE9NSW5mbyhOb2RlKiByb290KTsKKyAgICB2aXJ0dWFsIH5SZXRhaW5lZERP TUluZm8oKTsKKyAgICB2aXJ0dWFsIHZvaWQgRGlzcG9zZSgpOworICAgIHZpcnR1YWwgYm9vbCBJ c0VxdWl2YWxlbnQodjg6OlJldGFpbmVkT2JqZWN0SW5mbyogb3RoZXIpOworICAgIHZpcnR1YWwg aW50cHRyX3QgR2V0SGFzaCgpOworICAgIHZpcnR1YWwgY29uc3QgY2hhciogR2V0TGFiZWwoKTsK KyAgICB2aXJ0dWFsIGludHB0cl90IEdldEVsZW1lbnRDb3VudCgpOworICAgIHZpcnR1YWwgaW50 cHRyX3QgR2V0RXF1aXZhbGVuY2VDbGFzcygpOworICAgIAorcHJpdmF0ZToKKyAgICAvLyBWOCBn dWFyYW50ZWVzIHRvIGtlZXAgUmV0YWluZWRPYmplY3RJbmZvcyBhbGl2ZSBvbmx5IGR1cmluZyBh IEdDIG9yIGhlYXAgc25hcHNob3R0aW5nIHJvdW5kLCB3aGVuIHJlbmRlcmVyCisgICAgLy8gZG9l c24ndCBnZXQgY29udHJvbC4gVGhpcyBhbGxvd3MgdXMgdG8gdXNlIHJhdyBwb2ludGVycy4KKyAg ICBOb2RlKiBtX3Jvb3Q7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAv LyBSZXRhaW5lZERPTUluZm9faApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv djgvUmV0YWluZWRPYmplY3RJbmZvLmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9SZXRh aW5lZE9iamVjdEluZm8uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMzY4 ZmIxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvUmV0YWlu ZWRPYmplY3RJbmZvLmgKQEAgLTAsMCArMSw0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MSBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICogCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqIAorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICogCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBB TlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4g Tk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFM LCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgUmV0YWluZWRPYmplY3RJ bmZvX2gKKyNkZWZpbmUgUmV0YWluZWRPYmplY3RJbmZvX2gKKworI2luY2x1ZGUgPHY4LXByb2Zp bGVyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgUmV0YWluZWRPYmplY3RJbmZv IDogcHVibGljIHY4OjpSZXRhaW5lZE9iamVjdEluZm8geworcHVibGljOgorICAgIHZpcnR1YWwg aW50cHRyX3QgR2V0RXF1aXZhbGVuY2VDbGFzcygpID0gMDsKK307CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIFJldGFpbmVkT2JqZWN0SW5mb19oCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9maWxlci5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy92OC9TY3JpcHRQcm9maWxlci5jcHAKaW5kZXggYzIxMGE1ZC4uM2ZlNDVh OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1NjcmlwdFByb2ZpbGVyLmNwcApA QCAtMzIsOSArMzIsMTEgQEAKICNpbmNsdWRlICJTY3JpcHRQcm9maWxlci5oIgogCiAjaW5jbHVk ZSAiSW5zcGVjdG9yVmFsdWVzLmgiCisjaW5jbHVkZSAiUmV0YWluZWRET01JbmZvLmgiCisjaW5j bHVkZSAiVjhCaW5kaW5nLmgiCisjaW5jbHVkZSAiVjhOb2RlLmgiCiAKICNpbmNsdWRlIDx2OC1w cm9maWxlci5oPgotI2luY2x1ZGUgPFY4QmluZGluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKQEAgLTk4LDQgKzEwMCwxOSBAQCBQYXNzUmVmUHRyPFNjcmlwdEhlYXBTbmFwc2hvdD4gU2Ny aXB0UHJvZmlsZXI6OnRha2VIZWFwU25hcHNob3QoY29uc3QgU3RyaW5nJiB0aQogICAgIHJldHVy biBzbmFwc2hvdCA/IFNjcmlwdEhlYXBTbmFwc2hvdDo6Y3JlYXRlKHNuYXBzaG90KSA6IDA7CiB9 CiAKK3N0YXRpYyB2ODo6UmV0YWluZWRPYmplY3RJbmZvKiByZXRhaW5lZERPTUluZm8odWludDE2 X3QgY2xhc3NJZCwgdjg6OkhhbmRsZTx2ODo6VmFsdWU+IHdyYXBwZXIpCit7CisgICAgQVNTRVJU KGNsYXNzSWQgPT0gdjhET01TdWJ0cmVlQ2xhc3NJZCk7CisgICAgaWYgKCF3cmFwcGVyLT5Jc09i amVjdCgpKQorICAgICAgICByZXR1cm4gMDsKKyAgICBOb2RlKiBub2RlID0gVjhOb2RlOjp0b05h dGl2ZSh3cmFwcGVyLkFzPHY4OjpPYmplY3Q+KCkpOworICAgIHJldHVybiBub2RlID8gbmV3IFJl dGFpbmVkRE9NSW5mbyhub2RlKSA6IDA7Cit9CisKK3ZvaWQgU2NyaXB0UHJvZmlsZXI6OmluaXRp YWxpemUoKQoreworICAgIHY4OjpIZWFwUHJvZmlsZXI6OkRlZmluZVdyYXBwZXJDbGFzcyh2OERP TVN1YnRyZWVDbGFzc0lkLCAmcmV0YWluZWRET01JbmZvKTsKK30KKworCiB9IC8vIG5hbWVzcGFj ZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9TY3JpcHRQ cm9maWxlci5oIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvU2NyaXB0UHJvZmlsZXIuaApp bmRleCA5MTAzZjBjLi45MmE5ODBiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5n cy92OC9TY3JpcHRQcm9maWxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Nj cmlwdFByb2ZpbGVyLmgKQEAgLTU3LDYgKzU3LDcgQEAgcHVibGljOgogICAgIHN0YXRpYyB2b2lk IHN0YXJ0KFNjcmlwdFN0YXRlKiBzdGF0ZSwgY29uc3QgU3RyaW5nJiB0aXRsZSk7CiAgICAgc3Rh dGljIFBhc3NSZWZQdHI8U2NyaXB0UHJvZmlsZT4gc3RvcChTY3JpcHRTdGF0ZSogc3RhdGUsIGNv bnN0IFN0cmluZyYgdGl0bGUpOwogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFNjcmlwdEhlYXBTbmFw c2hvdD4gdGFrZUhlYXBTbmFwc2hvdChjb25zdCBTdHJpbmcmIHRpdGxlLCBIZWFwU25hcHNob3RQ cm9ncmVzcyopOworICAgIHN0YXRpYyB2b2lkIGluaXRpYWxpemUoKTsKIH07CiAKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4 RE9NV2luZG93U2hlbGwuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhET01XaW5k b3dTaGVsbC5jcHAKaW5kZXggNDAzMTJkYS4uYzNhMGNiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvYmluZGluZ3MvdjgvVjhET01XaW5kb3dTaGVsbC5jcHAKQEAgLTQzLDYgKzQzLDcgQEAKICNp bmNsdWRlICJTY3JpcHRDYWxsU3RhY2suaCIKICNpbmNsdWRlICJTY3JpcHRDYWxsU3RhY2tGYWN0 b3J5LmgiCiAjaW5jbHVkZSAiU2NyaXB0Q29udHJvbGxlci5oIgorI2luY2x1ZGUgIlNjcmlwdFBy b2ZpbGVyLmgiCiAjaW5jbHVkZSAiU3RvcmFnZU5hbWVzcGFjZS5oIgogI2luY2x1ZGUgIlY4Qmlu ZGluZy5oIgogI2luY2x1ZGUgIlY4QmluZGluZ1N0YXRlLmgiCkBAIC0yOTcsNiArMjk4LDggQEAg Ym9vbCBWOERPTVdpbmRvd1NoZWxsOjppbml0Q29udGV4dElmTmVlZGVkKCkKIAogICAgICAgICB2 ODo6Vjg6OlNldEZhaWxlZEFjY2Vzc0NoZWNrQ2FsbGJhY2tGdW5jdGlvbihyZXBvcnRVbnNhZmVK YXZhU2NyaXB0QWNjZXNzKTsKIAorICAgICAgICBTY3JpcHRQcm9maWxlcjo6aW5pdGlhbGl6ZSgp OworICAgICAgICAKICAgICAgICAgaXNWOEluaXRpYWxpemVkID0gdHJ1ZTsKICAgICB9CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcCBi L1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L1Y4R0NDb250cm9sbGVyLmNwcAppbmRleCA0OGNi ZjQ0Li5iNDI4ZTBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9WOEdD Q29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvVjhHQ0NvbnRy b2xsZXIuY3BwCkBAIC0zOSw2ICszOSw4IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5j bHVkZSAiTWVzc2FnZVBvcnQuaCIKICNpbmNsdWRlICJQbGF0Zm9ybUJyaWRnZS5oIgorI2luY2x1 ZGUgIlJldGFpbmVkRE9NSW5mby5oIgorI2luY2x1ZGUgIlJldGFpbmVkT2JqZWN0SW5mby5oIgog I2luY2x1ZGUgIlY4QmluZGluZy5oIgogI2luY2x1ZGUgIlY4Q1NTUnVsZS5oIgogI2luY2x1ZGUg IlY4Q1NTUnVsZUxpc3QuaCIKQEAgLTE2NiwxOSArMTY4LDg4IEBAIHB1YmxpYzoKICAgICB9CiB9 OwogCi1jbGFzcyBHcm91cGVySXRlbSB7CituYW1lc3BhY2UgeworCisvLyBJbXBsZW1lbnRzIHY4 OjpSZXRhaW5lZE9iamVjdEluZm8uCitjbGFzcyBVbnNwZWNpZmllZEdyb3VwIDogcHVibGljIFJl dGFpbmVkT2JqZWN0SW5mbyB7CiBwdWJsaWM6Ci0gICAgR3JvdXBlckl0ZW0odWludHB0cl90IGdy b3VwSWQsIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpIAotICAgICAgICA6IG1f Z3JvdXBJZChncm91cElkKQotICAgICAgICAsIG1fd3JhcHBlcih3cmFwcGVyKSAKLSAgICAgICAg ewotICAgICAgICB9CisgICAgZXhwbGljaXQgVW5zcGVjaWZpZWRHcm91cCh2b2lkKiBvYmplY3Qp CisgICAgICAgIDogbV9vYmplY3Qob2JqZWN0KQorICAgIHsKKyAgICAgICAgQVNTRVJUKG1fb2Jq ZWN0KTsKKyAgICB9CisgICAgCisgICAgdmlydHVhbCB2b2lkIERpc3Bvc2UoKSB7IGRlbGV0ZSB0 aGlzOyB9CisgIAorICAgIHZpcnR1YWwgYm9vbCBJc0VxdWl2YWxlbnQodjg6OlJldGFpbmVkT2Jq ZWN0SW5mbyogb3RoZXIpCisgICAgeworICAgICAgICBBU1NFUlQob3RoZXIpOworICAgICAgICBy ZXR1cm4gb3RoZXIgPT0gdGhpcyB8fCBzdGF0aWNfY2FzdDxXZWJDb3JlOjpSZXRhaW5lZE9iamVj dEluZm8qPihvdGhlciktPkdldEVxdWl2YWxlbmNlQ2xhc3MoKSA9PSB0aGlzLT5HZXRFcXVpdmFs ZW5jZUNsYXNzKCk7CisgICAgfQorCisgICAgdmlydHVhbCBpbnRwdHJfdCBHZXRIYXNoKCkKKyAg ICB7CisgICAgICAgIHJldHVybiByZWludGVycHJldF9jYXN0PGludHB0cl90PihtX29iamVjdCk7 CisgICAgfQorICAgIAorICAgIHZpcnR1YWwgY29uc3QgY2hhciogR2V0TGFiZWwoKQorICAgIHsK KyAgICAgICAgcmV0dXJuICJPYmplY3QgZ3JvdXAiOworICAgIH0KKworICAgIHZpcnR1YWwgaW50 cHRyX3QgR2V0RXF1aXZhbGVuY2VDbGFzcygpCisgICAgeworICAgICAgICByZXR1cm4gcmVpbnRl cnByZXRfY2FzdDxpbnRwdHJfdD4obV9vYmplY3QpOworICAgIH0KIAorcHJpdmF0ZToKKyAgICB2 b2lkKiBtX29iamVjdDsKK307CisKK2NsYXNzIEdyb3VwSWQgeworcHVibGljOgorICAgIEdyb3Vw SWQoKSA6IG1fdHlwZShOdWxsVHlwZSksIG1fZ3JvdXBJZCgwKSB7fQorICAgIEdyb3VwSWQoTm9k ZSogbm9kZSkgOiBtX3R5cGUoTm9kZVR5cGUpLCBtX25vZGUobm9kZSkge30KKyAgICBHcm91cElk KHZvaWQqIG90aGVyKSA6IG1fdHlwZShPdGhlclR5cGUpLCBtX290aGVyKG90aGVyKSB7fQorICAg IGJvb2wgb3BlcmF0b3IhKCkgY29uc3QgeyByZXR1cm4gbV90eXBlID09IE51bGxUeXBlOyB9CiAg ICAgdWludHB0cl90IGdyb3VwSWQoKSBjb25zdCB7IHJldHVybiBtX2dyb3VwSWQ7IH0KKyAgICBS ZXRhaW5lZE9iamVjdEluZm8qIGNyZWF0ZVJldGFpbmVkT2JqZWN0SW5mbygpIGNvbnN0CisgICAg eworICAgICAgICBzd2l0Y2ggKG1fdHlwZSkgeworICAgICAgICBjYXNlIE51bGxUeXBlOgorICAg ICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIGNhc2UgTm9kZVR5cGU6CisgICAgICAgICAgICBy ZXR1cm4gbmV3IFJldGFpbmVkRE9NSW5mbyhtX25vZGUpOworICAgICAgICBjYXNlIE90aGVyVHlw ZToKKyAgICAgICAgICAgIHJldHVybiBuZXcgVW5zcGVjaWZpZWRHcm91cChtX290aGVyKTsKKyAg ICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICB9CisgICAgfQor ICAgIAorcHJpdmF0ZToKKyAgICBlbnVtIFR5cGUgeworICAgICAgICBOdWxsVHlwZSwKKyAgICAg ICAgTm9kZVR5cGUsCisgICAgICAgIE90aGVyVHlwZQorICAgIH07CisgICAgVHlwZSBtX3R5cGU7 CisgICAgdW5pb24geworICAgICAgICB1aW50cHRyX3QgbV9ncm91cElkOworICAgICAgICBOb2Rl KiBtX25vZGU7CisgICAgICAgIHZvaWQqIG1fb3RoZXI7CisgICAgfTsKK307CisKK2NsYXNzIEdy b3VwZXJJdGVtIHsKK3B1YmxpYzoKKyAgICBHcm91cGVySXRlbShHcm91cElkIGdyb3VwSWQsIHY4 OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBwZXIpIDogbV9ncm91cElkKGdyb3VwSWQpLCBt X3dyYXBwZXIod3JhcHBlcikge30KKyAgICB1aW50cHRyX3QgZ3JvdXBJZCgpIGNvbnN0IHsgcmV0 dXJuIG1fZ3JvdXBJZC5ncm91cElkKCk7IH0KKyAgICBSZXRhaW5lZE9iamVjdEluZm8qIGNyZWF0 ZVJldGFpbmVkT2JqZWN0SW5mbygpIGNvbnN0IHsgcmV0dXJuIG1fZ3JvdXBJZC5jcmVhdGVSZXRh aW5lZE9iamVjdEluZm8oKTsgfQogICAgIHY4OjpQZXJzaXN0ZW50PHY4OjpPYmplY3Q+IHdyYXBw ZXIoKSBjb25zdCB7IHJldHVybiBtX3dyYXBwZXI7IH0KIAogcHJpdmF0ZToKLSAgICB1aW50cHRy X3QgbV9ncm91cElkOworICAgIEdyb3VwSWQgbV9ncm91cElkOwogICAgIHY4OjpQZXJzaXN0ZW50 PHY4OjpPYmplY3Q+IG1fd3JhcHBlcjsKIH07CiAKQEAgLTE4OCw2ICsyNTksOCBAQCBib29sIG9w ZXJhdG9yPChjb25zdCBHcm91cGVySXRlbSYgYSwgY29uc3QgR3JvdXBlckl0ZW0mIGIpCiB9CiAK IHR5cGVkZWYgVmVjdG9yPEdyb3VwZXJJdGVtPiBHcm91cGVyTGlzdDsKKyAgICAKK30KIAogLy8g SWYgdGhlIG5vZGUgaXMgaW4gZG9jdW1lbnQsIHB1dCBpdCBpbiB0aGUgb3duZXJEb2N1bWVudCdz IG9iamVjdCBncm91cC4KIC8vCkBAIC0xOTcsMTAgKzI3MCwxMCBAQCB0eXBlZGVmIFZlY3RvcjxH cm91cGVySXRlbT4gR3JvdXBlckxpc3Q7CiAvLwogLy8gT3RoZXJ3aXNlLCB0aGUgbm9kZSBpcyBw dXQgaW4gYW4gb2JqZWN0IGdyb3VwIGlkZW50aWZpZWQgYnkgdGhlIHJvb3QKIC8vIGVsZW1lbnQg b2YgdGhlIHRyZWUgdG8gd2hpY2ggaXQgYmVsb25ncy4KLXN0YXRpYyB1aW50cHRyX3QgY2FsY3Vs YXRlR3JvdXBJZChOb2RlKiBub2RlKQorc3RhdGljIEdyb3VwSWQgY2FsY3VsYXRlR3JvdXBJZChO b2RlKiBub2RlKQogewogICAgIGlmIChub2RlLT5pbkRvY3VtZW50KCkgfHwgKG5vZGUtPmhhc1Rh Z05hbWUoSFRNTE5hbWVzOjppbWdUYWcpICYmICFzdGF0aWNfY2FzdDxIVE1MSW1hZ2VFbGVtZW50 Kj4obm9kZSktPmhhdmVGaXJlZExvYWRFdmVudCgpKSkKLSAgICAgICAgcmV0dXJuIHJlaW50ZXJw cmV0X2Nhc3Q8dWludHB0cl90Pihub2RlLT5kb2N1bWVudCgpKTsKKyAgICAgICAgcmV0dXJuIEdy b3VwSWQobm9kZS0+ZG9jdW1lbnQoKSk7CiAKICAgICBOb2RlKiByb290ID0gbm9kZTsKICAgICBp ZiAobm9kZS0+aXNBdHRyaWJ1dGVOb2RlKCkpIHsKQEAgLTIwOCwxNiArMjgxLDE2IEBAIHN0YXRp YyB1aW50cHRyX3QgY2FsY3VsYXRlR3JvdXBJZChOb2RlKiBub2RlKQogICAgICAgICAvLyBJZiB0 aGUgYXR0cmlidXRlIGhhcyBubyBlbGVtZW50LCBubyBuZWVkIHRvIHB1dCBpdCBpbiB0aGUgZ3Jv dXAsCiAgICAgICAgIC8vIGJlY2F1c2UgaXQnbGwgYWx3YXlzIGJlIGEgZ3JvdXAgb2YgMS4KICAg ICAgICAgaWYgKCFyb290KQotICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgICAgICByZXR1 cm4gR3JvdXBJZCgpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIHdoaWxlIChOb2RlKiBwYXJlbnQg PSByb290LT5wYXJlbnROb2RlKCkpCiAgICAgICAgICAgICByb290ID0gcGFyZW50OwogICAgIH0K IAotICAgIHJldHVybiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4ocm9vdCk7CisgICAgcmV0 dXJuIEdyb3VwSWQocm9vdCk7CiB9CiAKLXN0YXRpYyB1aW50cHRyX3QgY2FsY3VsYXRlR3JvdXBJ ZChTdHlsZUJhc2UqIHN0eWxlQmFzZSkKK3N0YXRpYyBHcm91cElkIGNhbGN1bGF0ZUdyb3VwSWQo U3R5bGVCYXNlKiBzdHlsZUJhc2UpCiB7CiAgICAgQVNTRVJUKHN0eWxlQmFzZSk7CiAgICAgU3R5 bGVCYXNlKiBjdXJyZW50ID0gc3R5bGVCYXNlOwpAQCAtMjQ3LDE3ICszMjAsMTcgQEAgc3RhdGlj IHVpbnRwdHJfdCBjYWxjdWxhdGVHcm91cElkKFN0eWxlQmFzZSogc3R5bGVCYXNlKQogICAgIGlm IChzdHlsZVNoZWV0KSB7CiAgICAgICAgIGlmIChOb2RlKiBvd25lck5vZGUgPSBzdHlsZVNoZWV0 LT5vd25lck5vZGUoKSkKICAgICAgICAgICAgIHJldHVybiBjYWxjdWxhdGVHcm91cElkKG93bmVy Tm9kZSk7Ci0gICAgICAgIHJldHVybiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4oc3R5bGVT aGVldCk7CisgICAgICAgIHJldHVybiBHcm91cElkKHN0eWxlU2hlZXQpOwogICAgIH0KIAotICAg IHJldHVybiByZWludGVycHJldF9jYXN0PHVpbnRwdHJfdD4oY3VycmVudCk7CisgICAgcmV0dXJu IEdyb3VwSWQoY3VycmVudCk7CiB9CiAKIGNsYXNzIEdyb3VwZXJWaXNpdG9yIDogcHVibGljIERP TVdyYXBwZXJNYXA8Tm9kZT46OlZpc2l0b3IsIHB1YmxpYyBET01XcmFwcGVyTWFwPHZvaWQ+OjpW aXNpdG9yIHsKIHB1YmxpYzoKICAgICB2b2lkIHZpc2l0RE9NV3JhcHBlcihET01EYXRhU3RvcmUq IHN0b3JlLCBOb2RlKiBub2RlLCB2ODo6UGVyc2lzdGVudDx2ODo6T2JqZWN0PiB3cmFwcGVyKQog ICAgIHsKLSAgICAgICAgdWludHB0cl90IGdyb3VwSWQgPSBjYWxjdWxhdGVHcm91cElkKG5vZGUp OworICAgICAgICBHcm91cElkIGdyb3VwSWQgPSBjYWxjdWxhdGVHcm91cElkKG5vZGUpOwogICAg ICAgICBpZiAoIWdyb3VwSWQpCiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIG1fZ3JvdXBl ci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOwpAQCAtMjY5LDE2ICszNDIs MTYgQEAgcHVibGljOgogCiAgICAgICAgIGlmICh0eXBlSW5mby0+aXNTdWJjbGFzcygmVjhTdHls ZVNoZWV0TGlzdDo6aW5mbykpIHsKICAgICAgICAgICAgIFN0eWxlU2hlZXRMaXN0KiBzdHlsZVNo ZWV0TGlzdCA9IHN0YXRpY19jYXN0PFN0eWxlU2hlZXRMaXN0Kj4ob2JqZWN0KTsKLSAgICAgICAg ICAgIHVpbnRwdHJfdCBncm91cElkID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KHN0eWxl U2hlZXRMaXN0KTsKKyAgICAgICAgICAgIEdyb3VwSWQgZ3JvdXBJZChzdHlsZVNoZWV0TGlzdCk7 CiAgICAgICAgICAgICBpZiAoRG9jdW1lbnQqIGRvY3VtZW50ID0gc3R5bGVTaGVldExpc3QtPmRv Y3VtZW50KCkpCi0gICAgICAgICAgICAgICAgZ3JvdXBJZCA9IHJlaW50ZXJwcmV0X2Nhc3Q8dWlu dHB0cl90Pihkb2N1bWVudCk7CisgICAgICAgICAgICAgICAgZ3JvdXBJZCA9IEdyb3VwSWQoZG9j dW1lbnQpOwogICAgICAgICAgICAgbV9ncm91cGVyLmFwcGVuZChHcm91cGVySXRlbShncm91cElk LCB3cmFwcGVyKSk7CiAKICAgICAgICAgfSBlbHNlIGlmICh0eXBlSW5mby0+aXNTdWJjbGFzcygm VjhET01JbXBsZW1lbnRhdGlvbjo6aW5mbykpIHsKICAgICAgICAgICAgIERPTUltcGxlbWVudGF0 aW9uKiBkb21JbXBsZW1lbnRhdGlvbiA9IHN0YXRpY19jYXN0PERPTUltcGxlbWVudGF0aW9uKj4o b2JqZWN0KTsKLSAgICAgICAgICAgIHVpbnRwdHJfdCBncm91cElkID0gcmVpbnRlcnByZXRfY2Fz dDx1aW50cHRyX3Q+KGRvbUltcGxlbWVudGF0aW9uKTsKKyAgICAgICAgICAgIEdyb3VwSWQgZ3Jv dXBJZChkb21JbXBsZW1lbnRhdGlvbik7CiAgICAgICAgICAgICBpZiAoRG9jdW1lbnQqIGRvY3Vt ZW50ID0gZG9tSW1wbGVtZW50YXRpb24tPm93bmVyRG9jdW1lbnQoKSkKLSAgICAgICAgICAgICAg ICBncm91cElkID0gcmVpbnRlcnByZXRfY2FzdDx1aW50cHRyX3Q+KGRvY3VtZW50KTsKKyAgICAg ICAgICAgICAgICBncm91cElkID0gR3JvdXBJZChkb2N1bWVudCk7CiAgICAgICAgICAgICBtX2dy b3VwZXIuYXBwZW5kKEdyb3VwZXJJdGVtKGdyb3VwSWQsIHdyYXBwZXIpKTsKIAogICAgICAgICB9 IGVsc2UgaWYgKHR5cGVJbmZvLT5pc1N1YmNsYXNzKCZWOFN0eWxlU2hlZXQ6OmluZm8pIHx8IHR5 cGVJbmZvLT5pc1N1YmNsYXNzKCZWOENTU1J1bGU6OmluZm8pKSB7CkBAIC0yODcsMTIgKzM2MCwx MiBAQCBwdWJsaWM6CiAgICAgICAgIH0gZWxzZSBpZiAodHlwZUluZm8tPmlzU3ViY2xhc3MoJlY4 Q1NTU3R5bGVEZWNsYXJhdGlvbjo6aW5mbykpIHsKICAgICAgICAgICAgIENTU1N0eWxlRGVjbGFy YXRpb24qIGNzc1N0eWxlRGVjbGFyYXRpb24gPSBzdGF0aWNfY2FzdDxDU1NTdHlsZURlY2xhcmF0 aW9uKj4ob2JqZWN0KTsKIAotICAgICAgICAgICAgdWludHB0cl90IGdyb3VwSWQgPSBjYWxjdWxh dGVHcm91cElkKGNzc1N0eWxlRGVjbGFyYXRpb24pOworICAgICAgICAgICAgR3JvdXBJZCBncm91 cElkID0gY2FsY3VsYXRlR3JvdXBJZChjc3NTdHlsZURlY2xhcmF0aW9uKTsKICAgICAgICAgICAg IG1fZ3JvdXBlci5hcHBlbmQoR3JvdXBlckl0ZW0oZ3JvdXBJZCwgd3JhcHBlcikpOwogCiAgICAg ICAgIH0gZWxzZSBpZiAodHlwZUluZm8tPmlzU3ViY2xhc3MoJlY4Q1NTUnVsZUxpc3Q6OmluZm8p KSB7CiAgICAgICAgICAgICBDU1NSdWxlTGlzdCogY3NzUnVsZUxpc3QgPSBzdGF0aWNfY2FzdDxD U1NSdWxlTGlzdCo+KG9iamVjdCk7Ci0gICAgICAgICAgICB1aW50cHRyX3QgZ3JvdXBJZCA9IHJl aW50ZXJwcmV0X2Nhc3Q8dWludHB0cl90Pihjc3NSdWxlTGlzdCk7CisgICAgICAgICAgICBHcm91 cElkIGdyb3VwSWQoY3NzUnVsZUxpc3QpOwogICAgICAgICAgICAgU3R5bGVMaXN0KiBzdHlsZUxp c3QgPSBjc3NSdWxlTGlzdC0+c3R5bGVMaXN0KCk7CiAgICAgICAgICAgICBpZiAoc3R5bGVMaXN0 KQogICAgICAgICAgICAgICAgIGdyb3VwSWQgPSBjYWxjdWxhdGVHcm91cElkKHN0eWxlTGlzdCk7 CkBAIC0zMjQsNiArMzk3LDggQEAgcHVibGljOgogICAgICAgICAgICAgICAgIGNvbnRpbnVlOwog ICAgICAgICAgICAgfQogCisgICAgICAgICAgICBzaXplX3Qgcm9vdEluZGV4ID0gaTsKKyAgICAg ICAgICAgIAogICAgICAgICAgICAgVmVjdG9yPHY4OjpQZXJzaXN0ZW50PHY4OjpWYWx1ZT4gPiBn cm91cDsKICAgICAgICAgICAgIGdyb3VwLnJlc2VydmVDYXBhY2l0eShuZXh0S2V5SW5kZXggLSBp KTsKICAgICAgICAgICAgIGZvciAoOyBpIDwgbmV4dEtleUluZGV4OyArK2kpIHsKQEAgLTMzMyw3 ICs0MDgsNyBAQCBwdWJsaWM6CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIGlmIChncm91 cC5zaXplKCkgPiAxKQotICAgICAgICAgICAgICAgIHY4OjpWODo6QWRkT2JqZWN0R3JvdXAoJmdy b3VwWzBdLCBncm91cC5zaXplKCkpOworICAgICAgICAgICAgICAgIHY4OjpWODo6QWRkT2JqZWN0 R3JvdXAoJmdyb3VwWzBdLCBncm91cC5zaXplKCksIG1fZ3JvdXBlcltyb290SW5kZXhdLmNyZWF0 ZVJldGFpbmVkT2JqZWN0SW5mbygpKTsKIAogICAgICAgICAgICAgQVNTRVJUKGkgPT0gbmV4dEtl eUluZGV4KTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv djgvV3JhcHBlclR5cGVJbmZvLmggYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9XcmFwcGVy VHlwZUluZm8uaAppbmRleCBlZGQ3NDBmLi4xNjZkNjQyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy92OC9XcmFwcGVyVHlwZUluZm8uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy92OC9XcmFwcGVyVHlwZUluZm8uaApAQCAtNDEsNyArNDEsOSBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgc3RhdGljIGNvbnN0IGludCB2OERPTVdyYXBwZXJPYmplY3RJbmRleCA9 IDE7CiAgICAgc3RhdGljIGNvbnN0IGludCB2OERPTUhpZGRlblJlZmVyZW5jZUFycmF5SW5kZXgg PSAyOwogICAgIHN0YXRpYyBjb25zdCBpbnQgdjhEZWZhdWx0V3JhcHBlckludGVybmFsRmllbGRD b3VudCA9IDM7Ci0gICAgCisKKyAgICBzdGF0aWMgY29uc3QgdWludDE2X3QgdjhET01TdWJ0cmVl Q2xhc3NJZCA9IDE7CisKICAgICB0eXBlZGVmIHY4OjpQZXJzaXN0ZW50PHY4OjpGdW5jdGlvblRl bXBsYXRlPiAoKkdldFRlbXBsYXRlRnVuY3Rpb24pKCk7CiAgICAgdHlwZWRlZiB2b2lkICgqRGVy ZWZPYmplY3RGdW5jdGlvbikodm9pZCopOwogICAgIHR5cGVkZWYgQWN0aXZlRE9NT2JqZWN0KiAo KlRvQWN0aXZlRE9NT2JqZWN0RnVuY3Rpb24pKHY4OjpIYW5kbGU8djg6Ok9iamVjdD4pOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhlYXBz aG90R3JpZE5vZGVzLmpzIGIvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRh aWxlZEhlYXBzaG90R3JpZE5vZGVzLmpzCmluZGV4IDE0YmExNDIuLjJiM2QxMzEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWlsZWRIZWFwc2hvdEdy aWROb2Rlcy5qcworKysgYi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0RldGFp bGVkSGVhcHNob3RHcmlkTm9kZXMuanMKQEAgLTM5NCwxNCArMzk0LDE0IEBAIFdlYkluc3BlY3Rv ci5IZWFwU25hcHNob3RJbnN0YW5jZU5vZGUucHJvdG90eXBlID0gewogCiBXZWJJbnNwZWN0b3Iu SGVhcFNuYXBzaG90SW5zdGFuY2VOb2RlLnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJbnNwZWN0 b3IuSGVhcFNuYXBzaG90R2VuZXJpY09iamVjdE5vZGUucHJvdG90eXBlOwogCi1XZWJJbnNwZWN0 b3IuSGVhcFNuYXBzaG90Q29uc3RydWN0b3JOb2RlID0gZnVuY3Rpb24odHJlZSwgY29uc3RydWN0 b3IsIGFnZ3JlZ2F0ZSkKK1dlYkluc3BlY3Rvci5IZWFwU25hcHNob3RDb25zdHJ1Y3Rvck5vZGUg PSBmdW5jdGlvbih0cmVlLCBjbGFzc05hbWUsIGFnZ3JlZ2F0ZSkKIHsKICAgICBXZWJJbnNwZWN0 b3IuSGVhcFNuYXBzaG90R3JpZE5vZGUuY2FsbCh0aGlzLCB0cmVlLCBhZ2dyZWdhdGUuY291bnQg PiAwLCAxMDApOwotICAgIHRoaXMuX25hbWUgPSBjb25zdHJ1Y3RvcjsKKyAgICB0aGlzLl9uYW1l ID0gY2xhc3NOYW1lOwogICAgIHRoaXMuX2NvdW50ID0gYWdncmVnYXRlLmNvdW50OwogICAgIHRo aXMuX3NoYWxsb3dTaXplID0gYWdncmVnYXRlLnNlbGY7CiAgICAgdGhpcy5fcmV0YWluZWRTaXpl ID0gYWdncmVnYXRlLm1heFJldDsKLSAgICB0aGlzLl9wcm92aWRlciA9IHRoaXMuX2NyZWF0ZU5v ZGVzUHJvdmlkZXIodHJlZS5zbmFwc2hvdCwgYWdncmVnYXRlLnR5cGUsIGFnZ3JlZ2F0ZS5uYW1l KTsKKyAgICB0aGlzLl9wcm92aWRlciA9IHRoaXMuX2NyZWF0ZU5vZGVzUHJvdmlkZXIodHJlZS5z bmFwc2hvdCwgYWdncmVnYXRlLnR5cGUsIGNsYXNzTmFtZSk7CiB9CiAKIFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3RDb25zdHJ1Y3Rvck5vZGUucHJvdG90eXBlID0gewpAQCAtNDEwLDE0ICs0MTAs MTQgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdENvbnN0cnVjdG9yTm9kZS5wcm90b3R5cGUg PSB7CiAgICAgICAgIHJldHVybiBuZXcgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEluc3RhbmNl Tm9kZSh0aGlzLmRhdGFHcmlkLCBudWxsLCB0aGlzLmRhdGFHcmlkLnNuYXBzaG90LCBwcm92aWRl ci5pdGVtKTsKICAgICB9LAogCi0gICAgX2NyZWF0ZU5vZGVzUHJvdmlkZXI6IGZ1bmN0aW9uKHNu YXBzaG90LCBub2RlVHlwZSwgbm9kZU5hbWUpCisgICAgX2NyZWF0ZU5vZGVzUHJvdmlkZXI6IGZ1 bmN0aW9uKHNuYXBzaG90LCBub2RlVHlwZSwgbm9kZUNsYXNzTmFtZSkKICAgICB7CiAgICAgICAg IHJldHVybiBuZXcgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdE5vZGVzUHJvdmlkZXIoCiAgICAg ICAgICAgICBzbmFwc2hvdCwKICAgICAgICAgICAgIHNuYXBzaG90LmFsbE5vZGVzLAogICAgICAg ICAgICAgZnVuY3Rpb24gKG5vZGUpIHsKICAgICAgICAgICAgICAgICAgcmV0dXJuIG5vZGUudHlw ZSA9PT0gbm9kZVR5cGUKLSAgICAgICAgICAgICAgICAgICAgICYmIChub2RlTmFtZSA9PT0gbnVs bCB8fCBub2RlLm5hbWUgPT09IG5vZGVOYW1lKTsKKyAgICAgICAgICAgICAgICAgICAgJiYgKG5v ZGVDbGFzc05hbWUgPT09IG51bGwgfHwgbm9kZS5jbGFzc05hbWUgPT09IG5vZGVDbGFzc05hbWUp OwogICAgICAgICAgICAgfSk7CiAgICAgfSwKIApAQCAtNDk4LDE2ICs0OTgsMTYgQEAgV2ViSW5z cGVjdG9yLkhlYXBTbmFwc2hvdEl0ZXJhdG9yc1R1cGxlLnByb3RvdHlwZSA9IHsKICAgICB9CiB9 OwogCi1XZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90RGlmZk5vZGUgPSBmdW5jdGlvbih0cmVlLCBj b25zdHJ1Y3RvciwgYmFzZUFnZ3JlZ2F0ZSwgYWdncmVnYXRlKQorV2ViSW5zcGVjdG9yLkhlYXBT bmFwc2hvdERpZmZOb2RlID0gZnVuY3Rpb24odHJlZSwgY2xhc3NOYW1lLCBiYXNlQWdncmVnYXRl LCBhZ2dyZWdhdGUpCiB7CiAgICAgaWYgKCFiYXNlQWdncmVnYXRlKQogICAgICAgICBiYXNlQWdn cmVnYXRlID0geyBjb3VudDogMCwgc2VsZjogMCwgbWF4UmV0OiAwLCB0eXBlOmFnZ3JlZ2F0ZS50 eXBlLCBuYW1lOmFnZ3JlZ2F0ZS5uYW1lLCBpZHhzOiBbXSB9OwogICAgIGlmICghYWdncmVnYXRl KQogICAgICAgICBhZ2dyZWdhdGUgPSB7IGNvdW50OiAwLCBzZWxmOiAwLCBtYXhSZXQ6IDAsIHR5 cGU6YmFzZUFnZ3JlZ2F0ZS50eXBlLCBuYW1lOmJhc2VBZ2dyZWdhdGUubmFtZSwgaWR4czogW10g fTsKICAgICBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90R3JpZE5vZGUuY2FsbCh0aGlzLCB0cmVl LCB0cnVlLCA1MCk7Ci0gICAgdGhpcy5fbmFtZSA9IGNvbnN0cnVjdG9yOworICAgIHRoaXMuX25h bWUgPSBjbGFzc05hbWU7CiAgICAgdGhpcy5fY2FsY3VsYXRlRGlmZih0cmVlLmJhc2VTbmFwc2hv dCwgdHJlZS5zbmFwc2hvdCwgYmFzZUFnZ3JlZ2F0ZS5pZHhzLCBhZ2dyZWdhdGUuaWR4cyk7Ci0g ICAgdGhpcy5fcHJvdmlkZXIgPSB0aGlzLl9jcmVhdGVOb2Rlc1Byb3ZpZGVyKHRyZWUuYmFzZVNu YXBzaG90LCB0cmVlLnNuYXBzaG90LCBhZ2dyZWdhdGUudHlwZSwgYWdncmVnYXRlLm5hbWUpOwor ICAgIHRoaXMuX3Byb3ZpZGVyID0gdGhpcy5fY3JlYXRlTm9kZXNQcm92aWRlcih0cmVlLmJhc2VT bmFwc2hvdCwgdHJlZS5zbmFwc2hvdCwgYWdncmVnYXRlLnR5cGUsIGNsYXNzTmFtZSk7CiB9CiAK IFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3REaWZmTm9kZS5wcm90b3R5cGUgPSB7CkBAIC01NTks NyArNTU5LDcgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdERpZmZOb2RlLnByb3RvdHlwZSA9 IHsKICAgICAgICAgICAgIHJldHVybiBuZXcgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdEluc3Rh bmNlTm9kZSh0aGlzLmRhdGFHcmlkLCBwcm92aWRlci5zbmFwc2hvdCwgbnVsbCwgcHJvdmlkZXIu aXRlbSk7CiAgICAgfSwKIAotICAgIF9jcmVhdGVOb2Rlc1Byb3ZpZGVyOiBmdW5jdGlvbihiYXNl U25hcHNob3QsIHNuYXBzaG90LCBub2RlVHlwZSwgbm9kZU5hbWUpCisgICAgX2NyZWF0ZU5vZGVz UHJvdmlkZXI6IGZ1bmN0aW9uKGJhc2VTbmFwc2hvdCwgc25hcHNob3QsIG5vZGVUeXBlLCBub2Rl Q2xhc3NOYW1lKQogICAgIHsKICAgICAgICAgcmV0dXJuIG5ldyBXZWJJbnNwZWN0b3IuSGVhcFNu YXBzaG90SXRlcmF0b3JzVHVwbGUoCiAgICAgICAgICAgICBjcmVhdGVQcm92aWRlcihzbmFwc2hv dCwgYmFzZVNuYXBzaG90KSwgY3JlYXRlUHJvdmlkZXIoYmFzZVNuYXBzaG90LCBzbmFwc2hvdCkp OwpAQCAtNTcxLDcgKzU3MSw3IEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3REaWZmTm9kZS5w cm90b3R5cGUgPSB7CiAgICAgICAgICAgICAgICAgc25hcHNob3QuYWxsTm9kZXMsCiAgICAgICAg ICAgICAgICAgZnVuY3Rpb24gKG5vZGUpIHsKICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBu b2RlLnR5cGUgPT09IG5vZGVUeXBlCi0gICAgICAgICAgICAgICAgICAgICAgICAgJiYgKG5vZGVO YW1lID09PSBudWxsIHx8IG5vZGUubmFtZSA9PT0gbm9kZU5hbWUpCisgICAgICAgICAgICAgICAg ICAgICAgICAgJiYgKG5vZGVDbGFzc05hbWUgPT09IG51bGwgfHwgbm9kZS5jbGFzc05hbWUgPT09 IG5vZGVDbGFzc05hbWUpCiAgICAgICAgICAgICAgICAgICAgICAgICAgJiYgIShub2RlLmlkIGlu IG90aGVyU25hcHNob3QuaWRzTWFwKTsKICAgICAgICAgICAgICAgICB9KTsKICAgICAgICAgfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhl YXBzaG90Vmlldy5qcyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvRGV0YWls ZWRIZWFwc2hvdFZpZXcuanMKaW5kZXggM2Q1NWYwMS4uNTQ1NTRiYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9EZXRhaWxlZEhlYXBzaG90Vmlldy5qcwor KysgYi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0RldGFpbGVkSGVhcHNob3RW aWV3LmpzCkBAIC0yNjMsMTEgKzI2MywyMSBAQCBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90UmV0 YWluaW5nUGF0aHNMaXN0LnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIHRoaXMuc2VhcmNoQ2Fu Y2VsbGVkKCk7CiAKICAgICAgICAgdGhpcy5wYXRoRmluZGVyID0gbmV3IFdlYkluc3BlY3Rvci5I ZWFwU25hcHNob3RQYXRoRmluZGVyKHNuYXBzaG90LCBub2RlSW5kZXgpOworICAgICAgICB0aGlz Ll9zZXRSb290Q2hpbGRyZW5Gb3JGaW5kZXIoKTsKIAogICAgICAgICB0aGlzLnJlbW92ZUNoaWxk cmVuKCk7CiAKICAgICAgICAgdGhpcy5fY291bnRlciA9IDA7Ci0gICAgICAgIHRoaXMuc2hvd05l eHQoMTApOworICAgICAgICB0aGlzLnNob3dOZXh0KDEwMCk7CisgICAgfSwKKworICAgIHJlZnJl c2g6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRoaXMucmVtb3ZlQ2hpbGRyZW4oKTsKKyAg ICAgICAgdGhpcy5fY291bnRlciA9IDA7CisgICAgICAgIGRlbGV0ZSB0aGlzLl9jYW5jZWw7Cisg ICAgICAgIHRoaXMuX3NldFJvb3RDaGlsZHJlbkZvckZpbmRlcigpOworICAgICAgICB0aGlzLnNo b3dOZXh0KDEwMCk7CiAgICAgfSwKIAogICAgIHNob3dOZXh0OiBmdW5jdGlvbihwYXRoc0NvdW50 KQpAQCAtMjgzLDcgKzI5Myw3IEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNob3RSZXRhaW5pbmdQ YXRoc0xpc3QucHJvdG90eXBlID0gewogICAgICAgICAgICAgICAgICAgICBpZiAocmVzdWx0ID09 PSBudWxsKSB7CiAgICAgICAgICAgICAgICAgICAgICAgICBXZWJJbnNwZWN0b3IuUGxlYXNlV2Fp dE1lc3NhZ2UucHJvdG90eXBlLmhpZGUoKTsKICAgICAgICAgICAgICAgICAgICAgICAgIGlmICgh dGhpcy5jaGlsZHJlbi5sZW5ndGgpCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5h cHBlbmRDaGlsZChuZXcgV2ViSW5zcGVjdG9yLkRhdGFHcmlkTm9kZSh7cGF0aDpXZWJJbnNwZWN0 b3IuVUlTdHJpbmcoIlRoaXMgb2JqZWN0IGlzIGVpdGhlciBvbmx5IGFjY2Vzc2libGUgdmlhIGhp ZGRlbiBwcm9wZXJ0aWVzLCBvciBjdXJyZW50IHBhdGggc2VhcmNoIGRlcHRoIGlzbid0IGVub3Vn aC4iKSwgbGVuOiIifSwgZmFsc2UpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlz LmFwcGVuZENoaWxkKG5ldyBXZWJJbnNwZWN0b3IuRGF0YUdyaWROb2RlKHtwYXRoOldlYkluc3Bl Y3Rvci5VSVN0cmluZygiQ2FuJ3QgZmluZCBhbnkgcGF0aHMuIiksIGxlbjoiIn0sIGZhbHNlKSk7 CiAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgICAgICAgICAgIH0g ZWxzZSBpZiAocmVzdWx0ICE9PSBmYWxzZSkgewogICAgICAgICAgICAgICAgICAgICAgICAgaWYg KHRoaXMuX3ByZWZpeCkKQEAgLTMxMSw2ICszMjEsMTkgQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFw c2hvdFJldGFpbmluZ1BhdGhzTGlzdC5wcm90b3R5cGUgPSB7CiAgICAgICAgIH0KICAgICB9LAog CisgICAgX3NldFJvb3RDaGlsZHJlbkZvckZpbmRlcjogZnVuY3Rpb24oKQorICAgIHsKKyAgICAg ICAgZnVuY3Rpb24gRmlsdGVyRE9NV2luZG93KG5vZGUpCisgICAgICAgIHsKKyAgICAgICAgICAg IHJldHVybiBub2RlLm5hbWUgPT09ICJET01XaW5kb3ciOworICAgICAgICB9CisKKyAgICAgICAg aWYgKHRoaXMuc25hcHNob3RWaWV3LmlzVHJhY2luZ1RvV2luZG93T2JqZWN0cykKKyAgICAgICAg ICAgIHRoaXMucGF0aEZpbmRlci51cGRhdGVSb290cyhGaWx0ZXJET01XaW5kb3cpOworICAgICAg ICBlbHNlCisgICAgICAgICAgICB0aGlzLnBhdGhGaW5kZXIudXBkYXRlUm9vdHMoKTsKKyAgICB9 LAorCiAgICAgX3BlcmZvcm1Tb3J0aW5nOiBmdW5jdGlvbihzb3J0RnVuY3Rpb24pCiAgICAgewog ICAgICAgICBmdW5jdGlvbiBEYXRhRXh0cmFjdG9yV3JhcHBlcihub2RlQSwgbm9kZUIpCkBAIC0z NzUsOCArMzk4LDE4IEBAIFdlYkluc3BlY3Rvci5EZXRhaWxlZEhlYXBzaG90VmlldyA9IGZ1bmN0 aW9uKHBhcmVudCwgcHJvZmlsZSkKICAgICB2YXIgcmV0YWluaW5nUGF0aHNUaXRsZURpdiA9IGRv Y3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOwogICAgIHJldGFpbmluZ1BhdGhzVGl0bGVEaXYu Y2xhc3NOYW1lID0gInRpdGxlIjsKICAgICB2YXIgcmV0YWluaW5nUGF0aHNUaXRsZSA9IGRvY3Vt ZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4iKTsKLSAgICByZXRhaW5pbmdQYXRoc1RpdGxlLnRleHRD b250ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJSZXRhaW5pbmcgcGF0aHMgb2YgdGhlIHNl bGVjdGVkIG9iamVjdCIpOworICAgIHJldGFpbmluZ1BhdGhzVGl0bGUudGV4dENvbnRlbnQgPSBX ZWJJbnNwZWN0b3IuVUlTdHJpbmcoIlBhdGhzIGZyb20gdGhlIHNlbGVjdGVkIG9iamVjdCIpOwor ICAgIHRoaXMucmV0YWluaW5nUGF0aHNSb290ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic2Vs ZWN0Iik7CisgICAgdGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3QuY2xhc3NOYW1lID0gInN0YXR1cy1i YXItaXRlbSI7CisgICAgdGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3QuYWRkRXZlbnRMaXN0ZW5lcigi Y2hhbmdlIiwgdGhpcy5fY2hhbmdlUmV0YWluaW5nUGF0aHNSb290LmJpbmQodGhpcyksIGZhbHNl KTsKKyAgICB2YXIgdG9HQ1Jvb3RzVHJhY2VPcHRpb24gPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJvcHRpb24iKTsKKyAgICB0b0dDUm9vdHNUcmFjZU9wdGlvbi5sYWJlbCA9IFdlYkluc3BlY3Rv ci5VSVN0cmluZygidG8gR0Mgcm9vdHMiKTsKKyAgICB2YXIgdG9XaW5kb3dPYmplY3RzVHJhY2VP cHRpb24gPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJvcHRpb24iKTsKKyAgICB0b1dpbmRvd09i amVjdHNUcmFjZU9wdGlvbi5sYWJlbCA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygidG8gd2luZG93 IG9iamVjdHMiKTsKKyAgICB0aGlzLnJldGFpbmluZ1BhdGhzUm9vdC5hcHBlbmRDaGlsZCh0b0dD Um9vdHNUcmFjZU9wdGlvbik7CisgICAgdGhpcy5yZXRhaW5pbmdQYXRoc1Jvb3QuYXBwZW5kQ2hp bGQodG9XaW5kb3dPYmplY3RzVHJhY2VPcHRpb24pOwogICAgIHJldGFpbmluZ1BhdGhzVGl0bGVE aXYuYXBwZW5kQ2hpbGQocmV0YWluaW5nUGF0aHNUaXRsZSk7CisgICAgcmV0YWluaW5nUGF0aHNU aXRsZURpdi5hcHBlbmRDaGlsZCh0aGlzLnJldGFpbmluZ1BhdGhzUm9vdCk7CiAgICAgcmV0YWlu bWVudFZpZXcuZWxlbWVudC5hcHBlbmRDaGlsZChyZXRhaW5pbmdQYXRoc1RpdGxlRGl2KTsKICAg ICB0aGlzLnJldGFpbm1lbnREYXRhR3JpZCA9IG5ldyBXZWJJbnNwZWN0b3IuSGVhcFNuYXBzaG90 UmV0YWluaW5nUGF0aHNMaXN0KCk7CiAgICAgcmV0YWlubWVudFZpZXcuZWxlbWVudC5hcHBlbmRD aGlsZCh0aGlzLnJldGFpbm1lbnREYXRhR3JpZC5lbGVtZW50KTsKQEAgLTc5NSw2ICs4MjgsMTgg QEAgV2ViSW5zcGVjdG9yLkRldGFpbGVkSGVhcHNob3RWaWV3LnByb3RvdHlwZSA9IHsKICAgICAg ICAgdGhpcy5wZXJmb3JtU2VhcmNoKHRoaXMuY3VycmVudFF1ZXJ5LCB0aGlzLl9zZWFyY2hGaW5p c2hlZENhbGxiYWNrKTsKICAgICB9LAogCisgICAgX2NoYW5nZVJldGFpbmluZ1BhdGhzUm9vdDog ZnVuY3Rpb24oZXZlbnQpCisgICAgeworICAgICAgICBpZiAoIWV2ZW50KQorICAgICAgICAgICAg cmV0dXJuOworICAgICAgICB0aGlzLnJldGFpbm1lbnREYXRhR3JpZC5yZWZyZXNoKCk7CisgICAg fSwKKworICAgIGdldCBpc1RyYWNpbmdUb1dpbmRvd09iamVjdHMoKQorICAgIHsKKyAgICAgICAg cmV0dXJuIHRoaXMucmV0YWluaW5nUGF0aHNSb290LnNlbGVjdGVkSW5kZXggPT09IDE7CisgICAg fSwKKwogICAgIGdldCBfaXNTaG93aW5nQXNQZXJjZW50KCkKICAgICB7CiAgICAgICAgIHJldHVy biB0aGlzLnNob3dDb3VudEFzUGVyY2VudCAmJiB0aGlzLnNob3dTaGFsbG93U2l6ZUFzUGVyY2Vu dCAmJiB0aGlzLnNob3dSZXRhaW5lZFNpemVBc1BlcmNlbnQ7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0hlYXBTbmFwc2hvdC5qcyBiL1NvdXJjZS9XZWJD b3JlL2luc3BlY3Rvci9mcm9udC1lbmQvSGVhcFNuYXBzaG90LmpzCmluZGV4IDIxNWYzMWMuLmVk NTkyZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvSGVh cFNuYXBzaG90LmpzCisrKyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvSGVh cFNuYXBzaG90LmpzCkBAIC0yMTIsNiArMjEyLDEwIEBAIFdlYkluc3BlY3Rvci5IZWFwU25hcHNo b3ROb2RlLnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIHJldHVybiBXZWJJbnNwZWN0b3IuVUlT dHJpbmcoIihzeXN0ZW0pIik7CiAgICAgICAgIGNhc2UgIm9iamVjdCI6CiAgICAgICAgICAgICBy ZXR1cm4gdGhpcy5uYW1lOworICAgICAgICBjYXNlICJuYXRpdmUiOiB7CisgICAgICAgICAgICB2 YXIgZW50aXRpZXNDb3VudFBvcyA9IHRoaXMubmFtZS5pbmRleE9mKCIvIik7CisgICAgICAgICAg ICByZXR1cm4gZW50aXRpZXNDb3VudFBvcyAhPT0gLTEgPyB0aGlzLm5hbWUuc3Vic3RyaW5nKDAs IGVudGl0aWVzQ291bnRQb3MpLnRyaW1SaWdodCgpIDogdGhpcy5uYW1lOworICAgICAgICB9CiAg ICAgICAgIGNhc2UgImNvZGUiOgogICAgICAgICAgICAgcmV0dXJuIFdlYkluc3BlY3Rvci5VSVN0 cmluZygiKGNvbXBpbGVkIGNvZGUpIik7CiAgICAgICAgIGRlZmF1bHQ6CkBAIC01MjUsOCArNTI5 LDggQEAgV2ViSW5zcGVjdG9yLkhlYXBTbmFwc2hvdC5wcm90b3R5cGUgPSB7CiAgICAgICAgIGZv ciAodmFyIGl0ZXIgPSB0aGlzLmFsbE5vZGVzOyBpdGVyLmhhc05leHQoKTsgaXRlci5uZXh0KCkp IHsKICAgICAgICAgICAgIHZhciBub2RlID0gaXRlci5ub2RlOwogICAgICAgICAgICAgdmFyIGNs YXNzTmFtZSA9IG5vZGUuY2xhc3NOYW1lOwotICAgICAgICAgICAgdmFyIG5hbWVNYXR0ZXJzID0g bm9kZS50eXBlID09PSAib2JqZWN0IjsKLSAgICAgICAgICAgIGlmIChub2RlLnNlbGZTaXplID09 PSAwKQorICAgICAgICAgICAgdmFyIG5hbWVNYXR0ZXJzID0gbm9kZS50eXBlID09PSAib2JqZWN0 IiB8fCBub2RlLnR5cGUgPT09ICJuYXRpdmUiOworICAgICAgICAgICAgaWYgKG5vZGUudHlwZSAh PT0gIm5hdGl2ZSIgJiYgbm9kZS5zZWxmU2l6ZSA9PT0gMCkKICAgICAgICAgICAgICAgICBjb250 aW51ZTsKICAgICAgICAgICAgIGlmICghKGNsYXNzTmFtZSBpbiB0aGlzLl9hZ2dyZWdhdGVzKSkK ICAgICAgICAgICAgICAgICB0aGlzLl9hZ2dyZWdhdGVzW2NsYXNzTmFtZV0gPSB7IGNvdW50OiAw LCBzZWxmOiAwLCBtYXhSZXQ6IDAsIHR5cGU6IG5vZGUudHlwZSwgbmFtZTogbmFtZU1hdHRlcnMg PyBub2RlLm5hbWUgOiBudWxsLCBpZHhzOiBbXSB9OwpAQCAtODQyLDExICs4NDYsMTggQEAgV2Vi SW5zcGVjdG9yLkhlYXBTbmFwc2hvdFBhdGhGaW5kZXIucHJvdG90eXBlID0gewogICAgICAgICBy ZXR1cm4gZmFsc2U7CiAgICAgfSwKIAotICAgIF9maWxsUm9vdENoaWxkcmVuOiBmdW5jdGlvbigp CisgICAgdXBkYXRlUm9vdHM6IGZ1bmN0aW9uKGZpbHRlcikKKyAgICB7CisgICAgICAgIHRoaXMu X3Jvb3RDaGlsZHJlbiA9IHRoaXMuX2ZpbGxSb290Q2hpbGRyZW4oZmlsdGVyKTsgIAorICAgIH0s CisKKyAgICBfZmlsbFJvb3RDaGlsZHJlbjogZnVuY3Rpb24oZmlsdGVyKQogICAgIHsKICAgICAg ICAgdmFyIHJlc3VsdCA9IFtdOwotICAgICAgICBmb3IgKHZhciBpdGVyID0gdGhpcy5fc25hcHNo b3Qucm9vdE5vZGUuZWRnZXM7IGl0ZXIuaGFzTmV4dCgpOyBpdGVyLm5leHQoKSkKLSAgICAgICAg ICAgIHJlc3VsdFtpdGVyLmVkZ2Uubm9kZUluZGV4XSA9IHRydWU7CisgICAgICAgIGZvciAodmFy IGl0ZXIgPSB0aGlzLl9zbmFwc2hvdC5yb290Tm9kZS5lZGdlczsgaXRlci5oYXNOZXh0KCk7IGl0 ZXIubmV4dCgpKSB7CisgICAgICAgICAgICBpZiAoIWZpbHRlciB8fCBmaWx0ZXIoaXRlci5lZGdl Lm5vZGUpKQorICAgICAgICAgICAgICAgIHJlc3VsdFtpdGVyLmVkZ2Uubm9kZUluZGV4XSA9IHRy dWU7CisgICAgICAgIH0KICAgICAgICAgcmV0dXJuIHJlc3VsdDsKICAgICB9LAogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2hlYXBQcm9maWxlci5jc3Mg Yi9Tb3VyY2UvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2hlYXBQcm9maWxlci5jc3MKaW5k ZXggYWRkMDJhMS4uZmI4NDg1ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaW5zcGVjdG9y L2Zyb250LWVuZC9oZWFwUHJvZmlsZXIuY3NzCisrKyBiL1NvdXJjZS9XZWJDb3JlL2luc3BlY3Rv ci9mcm9udC1lbmQvaGVhcFByb2ZpbGVyLmNzcwpAQCAtMjI4LDggKzIyOCwxNSBAQAogfQogCiAu ZGV0YWlsZWQtaGVhcHNob3QtdmlldyAucmV0YWluaW5nLXBhdGhzLXZpZXcgLnRpdGxlID4gc3Bh biB7CisgICAgZGlzcGxheTogaW5saW5lLWJsb2NrOworICAgIHBhZGRpbmctdG9wOiAzcHg7CiAg ICAgdmVydGljYWwtYWxpZ246IG1pZGRsZTsKICAgICBtYXJnaW4tbGVmdDogNHB4OworICAgIG1h cmdpbi1yaWdodDogOHB4OworfQorCisuZGV0YWlsZWQtaGVhcHNob3QtdmlldyAucmV0YWluaW5n LXBhdGhzLXRvLXdpbmRvd3MgeworICAgIAogfQogCiAuaGVhcHNob3QtaGVscC1zdGF0dXMtYmFy LWl0ZW0gLmdseXBoIHsK