11031 2006-09-25 14:36:15 -0700 Another crazy counters bug 2010-01-19 16:09:37 -0800 1 1 1 Unclassified WebKit CSS 420+ Mac OS X 10.4 RESOLVED FIXED http://dbaron.org/css2.1/tests/imported-20050702/t1204-increment-00-c-o.xht P2 Normal --- 4980 31723 31814 32884 33600 33625 1 bdakin carol carol commit-queue darin hamaji mitz pol oldest_to_newest 56465 0 bdakin 2006-09-25 14:36:15 -0700 The attached test case does not render properly. To see the bug, counters need to be implemented (http://bugzilla.opendarwin.org/show_bug.cgi?id=4980), but I have not yet committed that patch, so this bug is not yet present in the nightlies. I am filing it anyway in anticipation. 56466 1 10768 bdakin 2006-09-25 14:37:27 -0700 Created attachment 10768 Test case 56467 2 bdakin 2006-09-25 14:38:01 -0700 http://dbaron.org/css2.1/tests/imported-20050702/t1204-increment-01-c-o.xht might be the same problem? 56468 3 bdakin 2006-09-25 14:38:39 -0700 and http://dbaron.org/css2.1/tests/imported-20050702/t1204-increment-02-c-o.xht ? 160288 4 carol 2009-11-03 18:38:47 -0800 I have a patch that fixes both this bug and 11030. Suggest marking these as duplicate of each other. 160989 5 42605 carol 2009-11-05 15:28:42 -0800 Created attachment 42605 Proposed Patch This patch introduces support for counter update during dynamic DOM changes which is required by CSS2.1 it also fixes a few other obscure bugs in the previous CSS2.1 counter support. 161036 6 42617 carol 2009-11-05 18:46:16 -0800 Created attachment 42617 Proposed Patch - fixed a few style issues. Fixed a few style issues that I detected in my previous patch. 161140 7 42617 mitz 2009-11-06 07:42:27 -0800 Comment on attachment 42617 Proposed Patch - fixed a few style issues. > - virtual bool isEmpty() const { return firstChild() == 0; } > + virtual bool isEmpty() const { return firstChild(); } This doesn’t seem right. 161142 8 carol 2009-11-06 07:46:49 -0800 (In reply to comment #7) > (From update of attachment 42617 [details]) > > - virtual bool isEmpty() const { return firstChild() == 0; } > > + virtual bool isEmpty() const { return firstChild(); } > > This doesn’t seem right. If the reviewer thinks that this is wrong (which I agree with), I'll change it, but WebKit Style Guidelines require that there are no explicit comparisons to 0. 161149 9 mitz 2009-11-06 08:27:23 -0800 (In reply to comment #8) > (In reply to comment #7) > > (From update of attachment 42617 [details] [details]) > > > - virtual bool isEmpty() const { return firstChild() == 0; } > > > + virtual bool isEmpty() const { return firstChild(); } > > > > This doesn’t seem right. > > If the reviewer thinks that this is wrong (which I agree with), I'll change it, > but WebKit Style Guidelines require that there are no explicit comparisons to > 0. The above change reverses the logic. 161150 10 carol 2009-11-06 08:30:30 -0800 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > (From update of attachment 42617 [details] [details] [details]) > > > > - virtual bool isEmpty() const { return firstChild() == 0; } > > > > + virtual bool isEmpty() const { return firstChild(); } > > > > > > This doesn’t seem right. > > > > If the reviewer thinks that this is wrong (which I agree with), I'll change it, > > but WebKit Style Guidelines require that there are no explicit comparisons to > > 0. > > The above change reverses the logic. Ooops. Sorry, my mistake, I'll fix it and submit a new patch. 161155 11 42655 carol 2009-11-06 09:17:38 -0800 Created attachment 42655 Proposed Patch - Fixes error in RenderObject::isEmpty as suggested by Mitz Fixed error discovered by Mitz in the previous patch. 161166 12 42655 darin 2009-11-06 10:17:18 -0800 Comment on attachment 42655 Proposed Patch - Fixes error in RenderObject::isEmpty as suggested by Mitz This patch is huge! I'm not sure I can review the whole thing. Is there any way to do this work in smaller pieces instead of all at once? It seems to me there are definitely many independent changes here, such as the showTreeAndMark change, which are separable from the rest. > + Tests: css2.1/counter-increment-002.html > + css2.1/counter-reset-000.html > + css2.1/counter-reset-002.html New counter tests should go into "fast/css/counters". The directory named "css2.1" is for the CSS 2.1 test suite. Not something invented by the WebKit project, but something imported. Your new test should go in there. Patches should not include svn:mergeinfo. You should remove those with the svn pd command before generating the patch if they have crept in. Many of these tests say "No newline at end of file". Please put a newline at the end of the file. Please make the new tests use dumpAsText if possible. > +void CounterNode::resetRenderer(AtomicStringImpl* identifier) > +{ > + if(m_renderer && !m_renderer->documentBeingDestroyed()) > + if (RenderObjectChildList* children = m_renderer->virtualChildren()) > + children->invalidateCounters(m_renderer, identifier); > +} Coding style mistakes here. There is a missing space after "if" and missing braces. Please read the style guide and/or use the check-webkit-style command to find these issues. In general it is not good to have recursive algorithms that take stack space proportional to the depth of the render tree. And so many of these functions work that way. We need a test case with an extremely deeply nested render tree to see what effect that has. > +void CounterNode::resetRenderers(AtomicStringImpl *identifier) The * here is in the wrong place. Needs to be before the space, not after. > + for(CounterNode* c = m_firstChild; c ; c = c->m_nextSibling) Need a space space here after the "for". Should not have a space after the "c" before the ";". We prefer words rather than letters for local variable names. The word "child" would probably be good. I see other older code in this file that is using the letter "c" and "o" -- sorry, that was older style. > + //Relayout all counters that may be affected by this change Comments should have a space after the "//" and a period at the end of the sentence. > -void CounterNode::insertAfter(CounterNode* newChild, CounterNode* refChild) > +void CounterNode::insertAfter(CounterNode* newChild, > + CounterNode* refChild, AtomicStringImpl *identifier) There's no need to break this into multiple lines. It goes against our usual style. Also, the "*" is in the wrong place. > + RefPtr<AtomicStringImpl> identifierPtr(identifier); > + while (m_lastChild != refChild) { > + RenderCounter::destroyCounterNode(m_lastChild->renderer(), > + identifierPtr); > + } I don't understand the use of RefPtr here. And breaking up the call to destroyCounterNode into two lines seems unhelpful. > -void CounterNode::removeChild(CounterNode* oldChild) > +void CounterNode::removeChild(CounterNode* oldChild, > + AtomicStringImpl* identifier) Same comment about multiple lines. > + fprintf(stderr, "0x%08X %s: %d %d P:0x08%X PS:0x%08X NS:0x08%X\n", > + (int)c, c->isReset() ? "reset" : "increment", c->value(), > + c->countInParent(), c->parent(), c->previousSibling(), > + c->nextSibling()); Normally we would use static_cast, not a C-style cast. > - bool isReset() const { return m_isReset; } > - int value() const { return m_value; } > - int countInParent() const { return m_countInParent; } > - RenderObject* renderer() const { return m_renderer; } > - > - CounterNode* parent() const { return m_parent; } > - CounterNode* previousSibling() const { return m_previousSibling; } > - CounterNode* nextSibling() const { return m_nextSibling; } > - CounterNode* firstChild() const { return m_firstChild; } > - CounterNode* lastChild() const { return m_lastChild; } > - > - void insertAfter(CounterNode* newChild, CounterNode* beforeChild); > - void removeChild(CounterNode*); > + ALWAYS_INLINE bool isReset() const { return m_isReset || !m_parent; } > + ALWAYS_INLINE bool isTypeReset() const { return m_isReset; } > + ALWAYS_INLINE int value() const { return m_value; } > + ALWAYS_INLINE int countInParent() const { return m_countInParent; } > + ALWAYS_INLINE RenderObject* renderer() const { return m_renderer; } > + > + ALWAYS_INLINE CounterNode* parent() const { return m_parent; } > + ALWAYS_INLINE CounterNode* previousSibling() const { return m_previousSibling; } > + ALWAYS_INLINE CounterNode* nextSibling() const { return m_nextSibling; } > + ALWAYS_INLINE CounterNode* firstChild() const { return m_firstChild; } > + ALWAYS_INLINE CounterNode* lastChild() const { return m_lastChild; } Our general rule is to use ALWAYS_INLINE only when we see an actual performance effect and have to use it to get that effect. There are tons of simple accessors like this and we do not plan to mark all the others with ALWAYS_INLINE, so please don't start with these. > + /* identifier must match the identifier of this counter or > + * the renderers affected by this insertion shall not be > + * invalidated. > + */ We use "//" for comments, and sentences with capital letters and periods. > + void insertAfter(CounterNode* newChild, CounterNode* beforeChild, > + AtomicStringImpl* identifier); I think we should consider using const AtomicString& instead of AtomicStringImpl* for all these new functions. > +/* Finds the insertion point for the counter described by counterOwner, isReset and > + * counterName in the CounterNode tree for counterName and sets parent and > + * previousSibling accordingly. > + * The function returns true if the counter whose insertion point is searched is NOT > + * the root of the tree. > + * The root of the tree is a counter reference that is not in the scope of any other > + * counter with the same identifier. > + * All the counter references with the same identifier as this one that are in > + * children or subsequent siblings of the renderer that owns the root of the tree > + * form the rest of of the nodes of the tree. > + * The root of the tree is always a reset type reference. > + * A subtree rooted at any reset node in the tree is equivalent to all counter > + * references that are in the scope of the counter or nested counter defined by that > + * reset node. > + * Non-reset CounterNodes cannot have descendants. > + */ We use // for comments, not /*. It's nice that this comment is complete, but the long comment is hard to read. Maybe you could say less or paragraph it in some way that makes it easier to digest. > +static bool findPlaceForCounter(RenderObject* counterOwner, > + const AtomicString& counterName, > + bool isReset, CounterNode*& parent, > + CounterNode*& previousSibling) We do not line up declarations like this when they span multiple lines. It would be better not to reformat unless we're trying to move the code in that direction. > + && (currentRenderer->parent() == counterOwner->parent())) { I find that including parentheses in common cases like this (&& or || expressions combined with == involved in if statements) makes things less clear rather than more. The idiom comes up so often it is not a source of doubt in any real case. I suggest omitting the parentheses. The tactical comments inside the function were all removed and replaced with a large one at the top. Partly because of that I find the new function harder to follow than the old, even though the total amount of comments is now greater. > + for (CounterMaps::iterator it = counterMaps().begin();it != end; > + ++it) This formatting is unnecessarily ugly. PUtting it all in one line would make it easier to read. Also, please include a space after the ";". Also, need braces around something that's more than one line. > + if (it->first != object) { > + nodeMap = it->second; > + if (CounterNode* node = nodeMap->get(counterName.impl())) { > + if (!node->parent() > + && findPlaceForCounter( > + const_cast<RenderObject*>(it->first), > + counterName, true, newParent, > + newPreviousSibling)) { Need to find a way to do this so things aren't broken into so many lines. We don't do it this way in WebKit code. One way to do this since this just keeps eliminating cases is to use the "early continue" idiom, so the main logic of the loop just continues at the outer level instead of getting more and more deeply nested. if (it->first == object) continue; CounterNode* node = it->second->get(counterName.impl()); if (!node) continue; // etc. > -void RenderCounter::invalidate() > +void RenderCounter::invalidate(AtomicStringImpl *identifier) > { > - m_counterNode = 0; > - setNeedsLayoutAndPrefWidthsRecalc(); > + if (!identifier > + || (m_counter.identifier() == (const char*)identifier->characters())) { > + m_counterNode = 0; > + setNeedsLayoutAndPrefWidthsRecalc(); > + } > } Early return would be easier to read than the nested code here. It is not correct to cast identifier->characters() to const char *, and even if it was correct, you would need to do it with static_cast. To compare two AtomicString instances you just use "==", no casting needed. Patch is too big for me to review the rest at this time. Looking forward to seeing some future iterations, hopefully in some smaller pieces. review- for now 161227 13 carol 2009-11-06 12:38:09 -0800 (In reply to comment #12) > > + Tests: css2.1/counter-increment-002.html > > + css2.1/counter-reset-000.html > > + css2.1/counter-reset-002.html These tests are actually copied from the css2.1 test battery and I maintained the naming convention from there. The only modification to the tests have to do with whitespace and indentation and with making sure that DumpRenderTree waits for the timer to fire before it dumps. Do you still think that these tests need to be moved to fast/css/counters? > Please make the new tests use dumpAsText if possible. Unfortunately dumpAsText does not dumpCounterValues. So I was unable to have the tests work that way. If anybody has an idea how to retrieve Counter values from JS, I would try it that way, as I prefer dumpAsText myself since it is less platform specific. > Coding style mistakes here. There is a missing space after "if" and missing I am sorry for the many style mistakes in this patch. I tried to hunt them down to the best of my abilities and fixed what I found including what check-webkit-style reported. Some of these files have many style errors and I did not want to make the patch more confusing than it already is. I'll do my best to fix the issues. > > + /* identifier must match the identifier of this counter or > > + * the renderers affected by this insertion shall not be > > + * invalidated. > > + */ > > We use "//" for comments, and sentences with capital letters and periods. In a previous submission a reviewer (I believe that it was Tor Arne Vestb?) made me change // to /* for function usage comments, I am not sure what is the right way anymore. > Looking forward to seeing some future iterations, hopefully in some smaller > pieces. It is hard to break this up since most changes depend on each other for proper results, also Eric Seidel wants one patch per bug. I will do the following, though: 1. I shall create a new bug and I shall submit the improvements to the debug function as a separate patch for that bug. 2. I shall remove all code changes that are not affecting functionality, and try to resubmit. Hopefully the patch will not look that big, because except for the tests it should not have more than 100 lines or so. 1. I shall submit 161297 14 ap 2009-11-06 20:13:09 -0800 > Do you still think that these tests need to be moved to fast/css/counters? The idea behind keeping the css2.1/ directory intact is that we could delete everything in it, and import a new version of the test suite one day. > In a previous submission a reviewer (I believe that it was Tor Arne Vestb?) > made me change // to /* for function usage comments Were these headers used in both C++ and plain C files? That's an exception, because some C compilers reject "//". 161576 15 carol 2009-11-09 08:04:39 -0800 (In reply to comment #14) > > In a previous submission a reviewer (I believe that it was Tor Arne Vestb?) > > made me change // to /* for function usage comments > > Were these headers used in both C++ and plain C files? That's an exception, > because some C compilers reject "//". The header contained a class declaration so it would have not compiled in C anyway. 163890 16 hamaji 2009-11-16 01:24:13 -0800 Hmm Carol, it seems you and I are working for the same issue in different bugs, unfortunately :( Let me introduce my current status. I started commenting on Bug 23262, I fixed all css2.1 test suite bugs locally, splitted my patch into several chunks, and posted two patches. One was already landed (see fast/css/counters/t1204-increment-0[01]-c-o), and another was r+ed but blocked by unrelated issue. The patch r+ed is in Bug 30505. When I'm trying to land the second patch, it conflicted and I found another person is working for the same issue. If you want to continue your work on this, I'll leave this work to you and help improving your patch. Of course, if you want to delegate this bug to me, I'm happy to continue working. Three major issues I found: - It seems addChild always traverse subsequent elements and call updateCounter() for them. I think it will make most website, which don't use counters, slow. In Bug 30505, I needed to update counters only when the new child is a counter and not anonymous. - fast/css/counters/invalidate-cached-counter-node is failing after this patch? - Please use layoutTestController.counterValueForElementById(). With this, I think you can tests them with dumpAsText(). 163973 17 hamaji 2009-11-16 06:00:52 -0800 It seems that Carol's patch would still need some more work. For example, Darin suggested me to invalidate subsequent counters instead of creating counter when a render object with counter directives is added, but this patch seems to do the latter way. So, even if we decide to ask Carol to fix this bug, I guess it would make sense to land Bug 30505 first so that reviewers don't need to say the same comments on Carol's patch. What do you think? By the way, I'd like two more issues/requests in the patch: > + if (temp = node->parent()) I cannot compile your patch on my Mac due to this line. This line produces a GCC warning and WebKit is using -Werror on Mac. I think it would be better to have more smaller tests so that we can easily distinguish the cause of failures in future. Specifically, I think this bug can be divided into 4 smaller issues which are related each other: 1. dynamic addition of increment node 2. dynamic deletion of increment node 3. dynamic addition of reset node 4. dynamic deletion of reset node Once these four issues are fixed, I think it's very easy to fix style change case. So, I would like to have four tests. I was planning to fix this bug with 4 steps, and Bug 30505 was the first step. 164001 18 carol 2009-11-16 08:31:03 -0800 (In reply to comment #17) > It seems that Carol's patch would still need some more work. For example, Darin > suggested me to invalidate subsequent counters instead of creating counter when > a render object with counter directives is added, but this patch seems to do > the latter way. So, even if we decide to ask Carol to fix this bug, I guess it > would make sense to land Bug 30505 first so that reviewers don't need to say > the same comments on Carol's patch. What do you think? > > By the way, I'd like two more issues/requests in the patch: > > > + if (temp = node->parent()) > > I cannot compile your patch on my Mac due to this line. This line produces a > GCC warning and WebKit is using -Werror on Mac. > > I think it would be better to have more smaller tests so that we can easily > distinguish the cause of failures in future. Specifically, I think this bug can > be divided into 4 smaller issues which are related each other: > > 1. dynamic addition of increment node > 2. dynamic deletion of increment node > 3. dynamic addition of reset node > 4. dynamic deletion of reset node > > Once these four issues are fixed, I think it's very easy to fix style change > case. So, I would like to have four tests. I was planning to fix this bug with > 4 steps, and Bug 30505 was the first step. I will probably submit my final version of the patch by the end of tomorrow. I in the solution that I am proposing, which handles all cases, the issues are broken down differently on two different axis: A. Cause of change: 1. Changing the DOM tree via adding/removing nodes or subtrees ->This is addressed by changes to RenderObject addChild/removeChild 2. Altering the style of an existing node ->This is addressed by changes to setStyle() B. The effect of change on some counterNodes of the same hierarchy with the counterNodes added/removed by either cause but different than the nodes added/removed: 1. Change in values only 2. Change in location in the hierarchy. While the first case is easily addressable without destroying and recreating the affected counters, the second situation is not. I have briefly looked at Shinichiro Hamaji's patch and I saw that he addresses a very limited number of cases. I will try to sync my patch with the latest entries. I would like to continue working on this issue as I feel that I found a good and fast solution that covers all cases. I am glad to defend any decisions that I made and seem worthwhile. I did not defend my position on recursive traversal of the counter tree not the rendering tree as Darin thought, because I did not find it worthwhile to argue that the counter tree is expected to be shallow ( cannot think of a 9 levels counter hierarchy that would be readable). I am open for suggestions for optimizations as long as the optimized code still covers all cases. I do not yet understand the concern about updateCounters. I am usually available for discussions on #webkit IRC channel on freenonde. 164170 19 43347 hamaji 2009-11-17 00:30:08 -0800 Created attachment 43347 FYI patch FYI, this is the code change I was planning to submit. I'm sorry, but this patch isn't for TOT but for r50717, which is before Carol's change r50960 (btw I think this fix was great, thanks for doing this). I don't want to resolve conflict Carol want to fix this issue and my patch won't be landed. > I have briefly looked at Shinichiro Hamaji's patch and I saw that he > addresses a very limited number of cases. Yes, my patch submitted in Bug 30505 focused the limited cases because I thought submitting a big patch would confuse reviewers. Also, I wanted to create smaller test cases in each steps. That's why I'm splitting my patch. > B. The effect of change on some counterNodes of the same hierarchy with the > counterNodes added/removed by either cause but different than the nodes > added/removed: > 1. Change in values only > 2. Change in location in the hierarchy. > > While the first case is easily addressable without destroying and recreating > the affected counters, the second situation is not. I'm not sure if the B2 can be an issue. I thought changing location requires DOM nodes detach/attach and render objects will be destructed/constructed. Please correct me if my understanding is wrong. It's very nice if you post an HTML where B2 is an issue. Anyway, even if B2 is really an issue, I don't think calling updateCounters() for all add-child is good deal as counter is rarely used. This would make all website, which insert DOM nodes, slower even if they don't use counter at all. 164245 20 carol 2009-11-17 08:41:04 -0800 > I'm not sure if the B2 can be an issue. I thought changing location > requires DOM nodes detach/attach and render objects will be > destructed/constructed. Please correct me if my understanding is > wrong. It's very nice if you post an HTML where B2 is an issue. 1. I am not talking about counters attached to the node being attached or detached but about the other nodes that may be affected. 2. You do not need to attach a node or detach it to cause restructuring of the tree, you just need to change the style of an existing node. See this example on how a counter hierarchy can be change without adding or removing nodes from the dom: http://www.w3.org/Style/CSS/Test/CSS2.1/current/html4/counter-increment-002.htm Note: the setTimeout part is critical. If you directly call run from onLoad, everything works without any changes not even your landed patch is necessary, because the changes to the dom are done before any counters or renderers are created and that case is covered (with some errors) by the previous code. > Anyway, even if B2 is really an issue, I don't think calling > updateCounters() for all add-child is good deal as counter is rarely > used. This would make all website, which insert DOM nodes, slower even > if they don't use counter at all. The real question is how much slower? If there is only one node inserted all updateCounters does is check the node's style for counter directives and verify that the node does not have children and it returns. To me this isn't much overhead. If a hierarchy of nodes is inserted at one time (as it is sometimes the case in the examples from w3.org) updateCounters checks all those nodes for counterDirectives and if none is found it does nothing more. Only if counter directives are found, the algorithm becomes more complex. If anyone has a better idea please state it I am more than happy to use it as long as it works. Right now I have a working solution. The only problem is with the test cases, because despite QtLauncher displaying the proper counter values and DumpRenderTree dumping the proper tree, counterValueForElementById sometimes crashes and some other times returns an empty string instead of the proper counter value. I believe that for the moment I shall submit a patch with the accompanying tests in normal dump mode, and then I shall fix DumpRenderTree in a separate patch. 164454 21 hamaji 2009-11-17 22:08:48 -0800 > 1. I am not talking about counters attached to the node being attached or > detached but about the other nodes that may be affected. Ah, I see. > 2. You do not need to attach a node or detach it to cause restructuring of the > tree, you just need to change the style of an existing node. > See this example on how a counter hierarchy can be change without adding or > removing nodes from the dom: > http://www.w3.org/Style/CSS/Test/CSS2.1/current/html4/counter-increment-002.htm So, I think my "FYI patch" is working. I confirmed my patch is working for all CSS counter tests. > Note: the setTimeout part is critical. If you directly call run from onLoad, > everything works without any changes not even your landed patch is necessary, > because the changes to the dom are done before any counters or renderers are > created and that case is covered (with some errors) by the previous code. Yeah, I know this. I confirmed the test was failing without my patch when I landed the patch. Note that counterValueForElementById calls updateLayout so I didn't need setTimeout. > The real question is how much slower? I think my "FYI patch" is working without traversal. I guess you can add if (!renderer->style()->counterDirectives() || renderer->isAnonymous()) return; into the top of updateCounters so that your patch won't make non-counter-sites slower. 164793 22 carol 2009-11-18 16:03:21 -0800 > > The real question is how much slower? > > I think my "FYI patch" is working without traversal. I guess you can > add I looked at your patch and I did not see how it could possibly handle a case like this <el1> ... <el2 style="counter-reset: c;"> ... </el2> ... </el1> Now let's say that el1's style is changed to "counter-increment: c;" This will cause this counter to be a root counter in a totally new counter tree. Without traversing all children of el1 to verify whether they have counters for c, I do not know how to figure that these counters are now children of the counter on el1. > > if (!renderer->style()->counterDirectives() || renderer->isAnonymous()) > return; > > into the top of updateCounters so that your patch won't make > non-counter-sites slower. This will not work, because I came across a case where a whole tree is attached at once to the document, and the root of the tree has no counters, but one of the children has (I believe the case is <el class="use" /> where use:before is "content-counter: c", so el is inserted in the tree with its child renderers for before. el itself has no counter directives but the before child has and requires update. One can argue that this is done automatically when originalText() is called, but that does not work, because the counter may be created before, when the style was set on the child which appeared attached to the tree, and now it only needs an update. originalText() can not do that. I finally figured out the counterValueFromElementById function and why it crashed on me at some point, so I can submit now proper tests. 164903 23 hamaji 2009-11-18 21:43:52 -0800 > I looked at your patch and I did not see how it could possibly handle a case > like this > <el1> > ... > <el2 style="counter-reset: c;"> > ... > </el2> > ... > </el1> Ah, yes. I forgot about this case. Maybe we could create a global hashmap keyed by counter-identifier and its value is root counter node, but I'm not sure. Thanks for the description. > This will not work, because I came across a case where a whole tree is attached > at once to the document, and the root of the tree has no counters, but one of > the children has (I believe the case is <el class="use" /> where use:before is > "content-counter: c", so el is inserted in the tree with its child renderers > for before. el itself has no counter directives but the before child has and > requires update. I cannot imagine this case, but you may be right. It would be nice if you add a test case to exercise this situation so that we won't introduce regressions in future. > I finally figured out the counterValueFromElementById function and why it > crashed on me at some point, so I can submit now proper tests. Good news! I'm looking forward your next patch. 164905 24 hamaji 2009-11-18 21:45:24 -0800 *** Bug 23262 has been marked as a duplicate of this bug. *** 164911 25 43487 carol 2009-11-18 22:08:00 -0800 Created attachment 43487 Proposed Patch This patch addresses Darin's concerns regarding my previous submission. The patch was broken up in 3 installments of which this is the last. -Changed Comment styles -Changed Code layout and fixed coding style errors (all that I could find). -Explained in detail the findPlaceForCounter algorithm as well as its design. The code is somewhat lengthier than the previous implementation, but it handles a lot more complex cases and it is faster as it shortcuts a good portion of the render tree once it found a predecessor to the counter. If anyone can find a meaningful reduction please let me know. Continuing concerns: - I do not understand why the Renderer to CounterNodes map uses RefPtr<AtomicStringImpl> as the key, instead of AtomicString. Since Darin wanted me to use AtomicString in most code for counter identifiers, there is a lot of conversion going on to and from these map lookups which need RefPtr<AtomicStringImpl>. Regarding the alternative solution that Shinchiro Hamaji proposed, after a brief analysis I found that it fails to address a few concerns that my solution addresses: - When a new counter reference counter is created which comes in preorder before any other reference to a counter with the same id, it may be that some counter node trees must be merged, and previous nodes that were reset nodes become increment nodes, because they were forced to reset by the virtue of not having a reset node come before them. - Sometimes a subtree of renderers is attached to the main tree as a whole and the root of the attached tree does not have a counter but the branches have such a counter. These counters may not be correctly updated by Shichiro's patch, as he does not take any action if the root node does not have a counter with it. - Shinchiro does not address the problems with the findPlaceForCounter algorithm. Also Shinchiro's algorithm raises some performance issues: - Shinchiro's algorithm invalidates counters with all ids when the style of a node changes even if some of the counter directives stay the same. - When a node with a counter is inserted all renders that follow that renderer in the render tree are searched for counters and if the counters are found, they are invalidated. This appears to be much slower than my approach of searching the counters with the same id and find out whether they are affected and doing this only for root counters. 165005 26 darin 2009-11-19 09:52:28 -0800 (In reply to comment #25) > - I do not understand why the Renderer to CounterNodes map uses > RefPtr<AtomicStringImpl> as the key, instead of AtomicString. Since Darin > wanted me to use AtomicString in most code for counter identifiers, there is a > lot of conversion going on to and from these map lookups which need > RefPtr<AtomicStringImpl>. I think it's simply an issue of whether maps with AtomicString keys work efficiently or not. It's cleaner to work at the AtomicString level if we can prove there is no loss of efficiency. It's even possible that at the time the original code was written we couldn't even compile a HasMap with AtomicString keys. 165017 27 43487 darin 2009-11-19 10:24:16 -0800 Comment on attachment 43487 Proposed Patch Patch looks good. Quite a few stylistic issues. I don't know that all of this needs to go in one patch. I'd prefer to see one fix at a time even though it would take a bit longer. There may be some pieces that are interdependent, but many seem not to be. To pick just one example, the change to isReset seems separate from the rest. Similarly, adding comments can be done separate from behavior changes. And some of the refactoring can be done in an initial patch before reusing the refactored code in new ways. For example, destroyCounterNodes could be refactored in a separate patch that does not change behavior at all. > + while (m_lastChild != refChild) { > + RenderCounter::destroyCounterNode(m_lastChild->renderer(), identifier); > + } In WebKit coding style this does not have braces. > - bool isReset() const { return m_isReset; } > + bool isReset() const { return m_isReset || !m_parent; } > + bool isTypeReset() const { return m_isReset; } I don't think these names are clear enough. The one you call isReset could be have a name like shouldTriggerReset. It is not good to have an m_isReset and an isReset function that do not match. At the very least if you think these function names are great and want to keep them you'd have to rename the data member to m_isTypeReset. But also when naming function members remember that we want them to work as a sentence like this: "<object> <functionName>" And "counter is type reset" is not clear. Thus you might end up with a name like hasResetType since "counter has reset type" is not bad. > + // identifier must match the identifier of this counter or > + // the renderers affected by this removal shall not be invalidated. > void removeChild(CounterNode*, const AtomicString& identifier); This comment seems kind of sideways. I think the comment should say what the function does, rather than what the function does not do. If renderers are not invalidated, why is that correct/OK? I think I know the answer but that's what the comment should be talking about, not just the mechanics of the logic in the function. We sometimes use "identifier" and other times "counterName". It would be good to make the terminology as consistent as possible. > +// Finds the insertion point for the counter described by counterOwner, isReset and > +// counterName in the CounterNode tree for counterName and sets parent and > +// previousSibling accordingly. > +// The function returns true if the counter whose insertion point is searched is NOT > +// the root of the tree. > +// The root of the tree is a counter reference that is not in the scope of any other > +// counter with the same identifier. > +// All the counter references with the same identifier as this one that are in > +// children or subsequent siblings of the renderer that owns the root of the tree > +// form the rest of of the nodes of the tree. > +// The root of the tree is always a reset type reference. > +// A subtree rooted at any reset node in the tree is equivalent to all counter > +// references that are in the scope of the counter or nested counter defined by that > +// reset node. > +// Non-reset CounterNodes cannot have descendants. Typically we don't put line breaks after sentences in a comment like this. > -static bool findPlaceForCounter(RenderObject* object, const AtomicString& counterName, > - bool isReset, CounterNode*& parent, CounterNode*& previousSibling) > +static bool findPlaceForCounter(RenderObject* counterOwner, > + const AtomicString& counterName, > + bool isReset, CounterNode*& parent, > + CounterNode*& previousSibling) This kind of formatting, where the subsequent lines are lined up with the "(", is typically frowned upon in WebKit. Sadly the editors push you to do it this way. One of the problems with this is that it complicates later efforts to rename. You have to realign the function. The old version used our formatting style. > + // We may be at the end of our search Comments use sentence style, so typically have a period as well as a capital letter. > + if (currentCounter) { > + // We have a suitable counter on the EndSearchRenderer > + if (previousSibling) { //But we already found another counter that we come after We put spaces after the "//". > + if (currentCounter->isReset()) { > + // We found a reset counter that is on a renderer that is a sibling of ours or a parent > + if (isReset > + && (currentRenderer->parent() == counterOwner->parent())) { We typically don't use parentheses when && and == are involved in a boolean expression. Since this idiom is so common in if statements the order of precedence is clear by convention if nothing else. > + // We are not a reset node or the previous reset must be on an ancestor of our renderer > + // hence we must be a child of that reset counter Another of many examples that lack a period. > + parent = currentCounter; > + ASSERT(previousSibling->parent() == currentCounter); > + return true; > + } // currentCounter is not reset This kind of comment on the ending brace does not seem to make the code clearer. In fact, I find it confusing that it describes the condition on the code above it. These are not giant if statements, so I think the code is clearer without these back-reference comments. Maybe you meant this to be a comment on the code after the brace, in which case it's critical to move it to the next line. > + if (!isReset > + || (currentRenderer->parent() != counterOwner->parent())) { > + // If the node we are placing is not reset or we have found a counter that is attached > + // to an ancestor of the placed counter's renderer we know we are a sibling of that node > + ASSERT(currentCounter->parent() == previousSibling->parent()); > + parent = currentCounter->parent(); > + return true; > + } In the other cases like this just above and below you indented the comment to match the body of the if. Should do that here too. > + if (isReset > + && (currentRenderer->parent() == counterOwner->parent())) { Really seems this expression would read better on one line. And similar ones above and below. The line break makes it harder to read. > + } // We come here if the previous sibling or parent of our renderer had no > + // good counter, or we are a reset node and the counter on the previous sibling > + // of our renderer was not a reset counter. > + // Set a new goal for the end of the search. The comment not be on the same line with the brace. > + // We found a suitable counter ... We definitely do not use "..." like this. People can see the structure from the C++ code, and trying to mirror that with sentence fragments doesn't seem to make the code clearer. > + if ( currentCounter->isReset()) { > + // but this one is reset. The above is a perfect example of a comment that says exactly the same thing as the C++ code. It's important to have comments say the things that the C++ code does not say, rather than repeating what it does say. Comments are good for why the code does something but should rarely be used for what the code does. There are other ways to make clear what the code does, including making well-named local variables and helper functions, that are far more effective. > + for (CounterMaps::iterator it = counterMaps().begin();it != end; > + ++it) Need a space after the semicolon. This should be on one line. > + if (it->first != object) { We often find that early continue makes these things better, rather than nesting the entire loop. > + nodeMap = it->second; > + if (CounterNode* node = nodeMap->get(counterName.impl())) { Same here. > + if (!node->parent() > + && findPlaceForCounter( > + const_cast<RenderObject*>(it->first), > + counterName, true, newParent, > + newPreviousSibling)) { And here too. It's especially poor to write a function call vertically like this. Makes it hard to read. It would be better to have a named variable for it->first casted to the right type and put this on one line. The worst argument here is the "true". That's why we no longer used booleans for this type of thing. Instead we would have an enum with two named values. > + newParent->insertAfter(node, > + newPreviousSibling, counterName.impl()); This should be on one line, not two. Do we still need the impl() call here? > - CounterMap* map = maps.get(object); > + CounterMap* map = maps.get(renderer); > if (!map) > return; > - maps.remove(object); > - > CounterMap::const_iterator end = map->end(); > for (CounterMap::const_iterator it = map->begin(); it != end; ++it) { > - CounterNode* node = it->second; > AtomicString identifier(it->first.get()); > - destroyCounterNodeChildren(identifier, node); > - if (CounterNode* parent = node->parent()) > - parent->removeChild(node, identifier); > - delete node; > + destroyCounterNodeWithoutMapRemoval(identifier, it->second); > } Braces go now that the body has one line. > + maps.remove(renderer); Now that the get and remove function calls are in the same function, it's not good to do double hash table lookup. Instead you should use a find call and check against end to do the "get" part, and call the version of remove that takes an iterator so we can reuse the single hash table lookup. > + CounterMaps& maps = counterMaps(); > + CounterMap* map = maps.get(renderer); Seems unnecessary to put counterMaps() into a local variable in a function that uses it only one. > + if (!map) > + return; > + CounterNode* node = map->get(identifier.impl()); > + if (node) { > + destroyCounterNodeWithoutMapRemoval(identifier, node); > + map->remove(RefPtr<AtomicStringImpl>(identifier.impl())); I do not thing that typecast to RefPtr<AtomicStringImpl> is need. If it is, I am quite surprised! > +// Do not delete map even if empty as the expectation is that soon nodes will be added > +// to the map, or otherwise destroyCounterNodes would have been called instead. > + } This comment is at the wrong nesting level. Also, I think "expectation" is not right here. This comment needs to treat this as guarantee the caller makes, not an expectation, using words like "must". It would be even better if later we can modify the code to ensure this always happens. > +void RenderCounter::createCounterIfNeeded(RenderObject* renderer, > + const AtomicString& identifier) > +{ > + makeCounterNode(renderer, identifier, false); > +} The line before the opening brace is indented wrong, should be only one level. But also, This should just all go on one line. > +void RenderCounter::updateCounters(RenderObject* renderer) > +{ > + updateCounter(renderer); > + for (RenderObject* child = renderer->nextInPreOrder(renderer); child; child = child->nextInPreOrder(renderer)) > + updateCounter(child); > +} The variable child is actually any descendant, so child is not the optimal name. And this can be written like this: for (RenderObject* descendant = renderer; descendant; descendant = descendant->nextInPreOrder(renderer)) updateCounter(descendant); No separate function call outside the loop needed. > + const CounterDirectiveMap* pCounterDirectiveMap = object->style()->counterDirectives(); We don't use "pXXX" names like this in WebKit code. I also think that you can just call this directiveMap since the context of the function means "counter" can often be omitted. It's always a readability/judgement call. > + if ((newParent == node->parent()) && (newPreviousSibling == node->previousSibling())) > + continue; > + if (node->parent()) > + node->parent()->removeChild(node, it->first.get()); Since node->parent() is always used, and used three times, you could consider a local variable for it. I suggest omitting the parentheses in the "==" and "&&" expression. We normally do and I find it slightly harder to read the expression with the additional punctuation. > + static void destroyCounterNodes(RenderObject* renderer); > + static void destroyCounterNode(RenderObject* renderer, const AtomicString& identifier); > + static void updateCounters(RenderObject* renderer); > + static void updateCounter(RenderObject* renderer); > + static void createCounterIfNeeded(RenderObject* renderer, const AtomicString& identifier); The argument name "renderer" adds nothing for a type that is RenderObject*, so I suggest omitting it. If there was some way to make clearer the role of the RenderObject you could include an argument name that did it, but I don't think there is. > + RenderCounter::updateCounters(newChild); Is this extra work that is bad for performance? > - updateFillImages(oldStyle ? oldStyle->backgroundLayers() : 0, m_style ? m_style->backgroundLayers() : 0); > - updateFillImages(oldStyle ? oldStyle->maskLayers() : 0, m_style ? m_style->maskLayers() : 0); > - > - updateImage(oldStyle ? oldStyle->borderImage().image() : 0, m_style ? m_style->borderImage().image() : 0); > - updateImage(oldStyle ? oldStyle->maskBoxImage().image() : 0, m_style ? m_style->maskBoxImage().image() : 0); > + if (oldStyle) { > + if (m_style) { > + if (const CounterDirectiveMap* pCounterDirectiveMap = m_style->counterDirectives()) { > + if (const CounterDirectiveMap* pOldCounterDirectiveMap = oldStyle->counterDirectives()) { > + CounterDirectiveMap::const_iterator end = pCounterDirectiveMap->end(); > + for (CounterDirectiveMap::const_iterator it = pCounterDirectiveMap->begin(); it != end; ++it) { > + if (pOldCounterDirectiveMap->contains(it->first)) { > + if (pOldCounterDirectiveMap->get(it->first) != it->second) > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > + } else { > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > + RenderCounter::createCounterIfNeeded(this, AtomicString(it->first.get())); > + } > + } > + end = pOldCounterDirectiveMap->end(); > + for (CounterDirectiveMap::const_iterator it = pOldCounterDirectiveMap->begin(); it != end; ++it) > + if (!pCounterDirectiveMap->contains(it->first)) > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > + } else { > + RenderCounter::destroyCounterNodes(this); > + RenderCounter::updateCounters(this); > + } > + } else if (m_hasCounterNodeMap) > + RenderCounter::destroyCounterNodes(this); > > - // We need to ensure that view->maximalOutlineSize() is valid for any repaints that happen > - // during styleDidChange (it's used by clippedOverflowRectForRepaint()). > - if (m_style->outlineWidth() > 0 && m_style->outlineSize() > maximalOutlineSize(PaintPhaseOutline)) > - toRenderView(document()->renderer())->setMaximalOutlineSize(m_style->outlineSize()); > + updateFillImages(oldStyle->backgroundLayers(), > + m_style->backgroundLayers()); > + updateFillImages(oldStyle->maskLayers(), m_style->maskLayers()); > + > + updateImage(oldStyle->borderImage().image(), > + m_style->borderImage().image()); > + updateImage(oldStyle->maskBoxImage().image(), > + m_style->maskBoxImage().image()); > + // We need to ensure that view->maximalOutlineSize() is valid for > + // any repaints that happen during styleDidChange (it's used by > + // clippedOverflowRectForRepaint()). > + if (m_style->outlineWidth() > 0 && m_style->outlineSize() > > + maximalOutlineSize(PaintPhaseOutline)) { > + toRenderView(document()->renderer())->setMaximalOutlineSize( > + m_style->outlineSize()); > + } > + } else { > + if (m_hasCounterNodeMap) > + RenderCounter::destroyCounterNodes(this); > + updateFillImages(oldStyle->backgroundLayers(), 0); > + updateFillImages(oldStyle->maskLayers(), 0); > + > + updateImage(oldStyle->borderImage().image(), 0); > + updateImage(oldStyle->maskBoxImage().image(), 0); > + } > + } else if (m_style) { > + RenderCounter::updateCounter(this); > + updateFillImages(0, m_style->backgroundLayers()); > + updateFillImages(0, m_style->maskLayers()); > + > + updateImage(0, m_style->borderImage().image()); > + updateImage(0, m_style->maskBoxImage().image()); > + // We need to ensure that view->maximalOutlineSize() is valid for any repaints that happen > + // during styleDidChange (it's used by clippedOverflowRectForRepaint()). > + if (m_style->outlineWidth() > 0 && m_style->outlineSize() > maximalOutlineSize(PaintPhaseOutline)) > + toRenderView(document()->renderer())->setMaximalOutlineSize(m_style->outlineSize()); > + } This new code is long and hard to read and understand. What's the benefit of putting all the cases in different branches like this? Is there a way we can factor this so it's not so gigantic? Replacing 4 lines of code with 50 needs a really good justification. There's also a lot of code broken into two lines prematurely. We'd prefer to have a moderately long line rather than breaking everything so it fits in an 80-column character. > - virtual bool isEmpty() const { return firstChild() == 0; } > + virtual bool isEmpty() const { return !firstChild(); } > - SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState);; } > + SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState); } These changes, unrelated to the rest of the patch, should go in a separate patch. Given the amount of change, I'm surprised at the small number of new test cases. review- because I want at least some of the style issues fixed. Please consider all my comments. 165346 28 carol 2009-11-20 10:23:22 -0800 (In reply to comment #27) > (From update of attachment 43487 [details]) > Patch looks good. Quite a few stylistic issues. > > I don't know that all of this needs to go in one patch. I'd prefer to see one > fix at a time even though it would take a bit longer. > In WebKit coding style this does not have braces. > > > - bool isReset() const { return m_isReset; } > > + bool isReset() const { return m_isReset || !m_parent; } > > + bool isTypeReset() const { return m_isReset; } > > I don't think these names are clear enough. > > + // identifier must match the identifier of this counter or > > + // the renderers affected by this removal shall not be invalidated. > > void removeChild(CounterNode*, const AtomicString& identifier); > > This comment seems kind of sideways. > We sometimes use "identifier" and other times "counterName". It would be good > to make the terminology as consistent as possible. > Eric Seidel and the commit bot wants one landed patch per bug hence I created bug 31723 (https://bugs.webkit.org/show_bug.cgi?id=31723) which highlights the problems in the findPlaceForCounter algorithm and I created a small fix just around that. I hate pedantic fixes that require bug filings and going through a whole review process just to add comments to code and change variable names which add no benefit to the user, and are beneficial to a developer only in the context of looking at a real user issue, so I put the comments and related fixes in this patch together with this algorithm fix hopefully the reviewer (likely Darin) will not mind that. > > +// Finds the insertion point for the counter described by counterOwner, isReset and > > +// counterName in the CounterNode tree for counterName and sets parent and > > +// previousSibling accordingly. > > +// The function returns true if the counter whose insertion point is searched is NOT > > +// the root of the tree. > > +// The root of the tree is a counter reference that is not in the scope of any other > > +// counter with the same identifier. > > Typically we don't put line breaks after sentences in a comment like this. I found myself struggling to understand the design of CounterNode trees so for the benefit of whoever looks at this code after me I took the opportunity to clarify a few things here that are critical for the implementation of this function beside the boilerplate description of what the function does and what the return values are. Since I had a lot of explaining to do, I used line breaks to separate main ideas, try to make the comment more readable while keeping it pretty condensed. I am sorry if I failed, I tried a new (hopefully better) version in the patch to 31723 (see above). > > CounterMap::const_iterator end = map->end(); > > for (CounterMap::const_iterator it = map->begin(); it != end; ++it) { > > - CounterNode* node = it->second; > > AtomicString identifier(it->first.get()); > > - destroyCounterNodeChildren(identifier, node); > > - if (CounterNode* parent = node->parent()) > > - parent->removeChild(node, identifier); > > - delete node; > > + destroyCounterNodeWithoutMapRemoval(identifier, it->second); > > } > > Braces go now that the body has one line. The body is actually 2 lines: AtomicString identifier(it->first.get()); stays. > > +void RenderCounter::updateCounters(RenderObject* renderer) > > +{ > > + updateCounter(renderer); > > + for (RenderObject* child = renderer->nextInPreOrder(renderer); child; child = child->nextInPreOrder(renderer)) > > + updateCounter(child); > > +} > > The variable child is actually any descendant, so child is not the optimal > name. And this can be written like this: > > for (RenderObject* descendant = renderer; descendant; descendant = > descendant->nextInPreOrder(renderer)) > updateCounter(descendant); > > No separate function call outside the loop needed. I have refactored the code per your comment. You are right about child/descendant, as far as including the initial updateCounter in the loop, I was trying to save an unnecessary comparison, since this function is called for every DOM node insertion I was trying to make it as quick as possible if the node being inserted and its descendants have no counter directives. (See the next item bellow about updateCounters being called unnecessarily). > > + RenderCounter::updateCounters(newChild); > > Is this extra work that is bad for performance? As I explained in my response to Shinchiro Hamaji, this work is usually not that much and is critical for being able to respond to DOM node changes. In the current implementation updateCounters, for most DOM nodes, boils down to: 2 function calls with one pointer arg, plus checking the style of the node for counter directives and the node for the existence of children. I believe this is the bare minimum needed to detect changes to the counter hierarchy that result from addition of DOM nodes. The reason why Shinchiro's "check before the call" solution (which only saves the time to call 2 non virtual functions - pretty much one CPU cycle on processors with long enough instruction pipelines) does not work is that sometimes a whole Renderer subtree is inserted at once in the main tree and sometimes the root node of this renderer tree does not have any counter directive such as in this case: <span style=":before reset-counter c 4;"/> The Renderer for span and for its virtual before child are inserted together in the main tree, but the renderer for span has no counter directives. I found this case in one of the css2.1 tests. > > - updateFillImages(oldStyle ? oldStyle->backgroundLayers() : 0, m_style ? m_style->backgroundLayers() : 0); > > - updateFillImages(oldStyle ? oldStyle->maskLayers() : 0, m_style ? m_style->maskLayers() : 0); > > - > > - updateImage(oldStyle ? oldStyle->borderImage().image() : 0, m_style ? m_style->borderImage().image() : 0); > > - updateImage(oldStyle ? oldStyle->maskBoxImage().image() : 0, m_style ? m_style->maskBoxImage().image() : 0); > > + if (oldStyle) { > > + if (m_style) { > > + if (const CounterDirectiveMap* pCounterDirectiveMap = m_style->counterDirectives()) { > > + if (const CounterDirectiveMap* pOldCounterDirectiveMap = oldStyle->counterDirectives()) { > > + CounterDirectiveMap::const_iterator end = pCounterDirectiveMap->end(); > > + for (CounterDirectiveMap::const_iterator it = pCounterDirectiveMap->begin(); it != end; ++it) { > > + if (pOldCounterDirectiveMap->contains(it->first)) { > > + if (pOldCounterDirectiveMap->get(it->first) != it->second) > > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > > + } else { > > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > > + RenderCounter::createCounterIfNeeded(this, AtomicString(it->first.get())); > > + } > > + } > > + end = pOldCounterDirectiveMap->end(); > > + for (CounterDirectiveMap::const_iterator it = pOldCounterDirectiveMap->begin(); it != end; ++it) > > + if (!pCounterDirectiveMap->contains(it->first)) > > + RenderCounter::destroyCounterNode(this, AtomicString(it->first.get())); > > + } else { > > + RenderCounter::destroyCounterNodes(this); > > + RenderCounter::updateCounters(this); > > + } > > + } else if (m_hasCounterNodeMap) > > + RenderCounter::destroyCounterNodes(this); > > > > - // We need to ensure that view->maximalOutlineSize() is valid for any repaints that happen > > - // during styleDidChange (it's used by clippedOverflowRectForRepaint()). > > - if (m_style->outlineWidth() > 0 && m_style->outlineSize() > maximalOutlineSize(PaintPhaseOutline)) > > - toRenderView(document()->renderer())->setMaximalOutlineSize(m_style->outlineSize()); > > + updateFillImages(oldStyle->backgroundLayers(), > > + m_style->backgroundLayers()); > > + updateFillImages(oldStyle->maskLayers(), m_style->maskLayers()); > > + > > + updateImage(oldStyle->borderImage().image(), > > + m_style->borderImage().image()); > > + updateImage(oldStyle->maskBoxImage().image(), > > + m_style->maskBoxImage().image()); > > + // We need to ensure that view->maximalOutlineSize() is valid for > > + // any repaints that happen during styleDidChange (it's used by > > + // clippedOverflowRectForRepaint()). > > + if (m_style->outlineWidth() > 0 && m_style->outlineSize() > > > + maximalOutlineSize(PaintPhaseOutline)) { > > + toRenderView(document()->renderer())->setMaximalOutlineSize( > > + m_style->outlineSize()); > > + } > > + } else { > > + if (m_hasCounterNodeMap) > > + RenderCounter::destroyCounterNodes(this); > > + updateFillImages(oldStyle->backgroundLayers(), 0); > > + updateFillImages(oldStyle->maskLayers(), 0); > > + > > + updateImage(oldStyle->borderImage().image(), 0); > > + updateImage(oldStyle->maskBoxImage().image(), 0); > > + } > > + } else if (m_style) { > > + RenderCounter::updateCounter(this); > > + updateFillImages(0, m_style->backgroundLayers()); > > + updateFillImages(0, m_style->maskLayers()); > > + > > + updateImage(0, m_style->borderImage().image()); > > + updateImage(0, m_style->maskBoxImage().image()); > > + // We need to ensure that view->maximalOutlineSize() is valid for any repaints that happen > > + // during styleDidChange (it's used by clippedOverflowRectForRepaint()). > > + if (m_style->outlineWidth() > 0 && m_style->outlineSize() > maximalOutlineSize(PaintPhaseOutline)) > > + toRenderView(document()->renderer())->setMaximalOutlineSize(m_style->outlineSize()); > > + } > > This new code is long and hard to read and understand. What's the benefit of > putting all the cases in different branches like this? Is there a way we can > factor this so it's not so gigantic? Replacing 4 lines of code with 50 needs a > really good justification. The code above appears to replace 4 lines, but in reality it adds totally new functionality while optimizing those 4 lines to run faster. The design goal behind the code above which I admit has some readability issues (mainly due to broken lines, which I fixed) is to make the code as fast as possible since it is run for every style change. I read an article in a respected Software Development journal where a guy published a breadth first graph travesal algorithm optimized for the Cell processor. The algorithm had 5000 lines versus the usual about 50. But was running an order of magnitude faster on the same hardware as the vanilla algorithm. My goal in the design of the code above was to minimize unnecessary work. In the original code the 4 or so functions were called whether or not it made sense (i.e. whether or not there was a non-null oldStyle or newStyle). I know from testing that sometimes oldStyle can be null and probably newStyle may be null too. So I separated the code in these 4 cases and I minimized work in each of them. For counters the problem is complicated by the fact that for each style there may or may not be counter directives associated with the style, and the counters may or may not be the same for each directive. Of course there is an easy way out: delete all old counters if any in all cases and create the new ones if any, but this is way less than optimal as creating a counter involves inspecting many renderers. I took your comment to heart though and I shall try to create some helper functions to increase readability and I shall definitely stop breaking those lines. I personally hate breaking the lines but I read somewhere in the style guidelines that long lines are bad and I was trying to comply with that. Darin, Please review my patch for 31723 so that I can come back and submit a smaller better patch for this. Thanks. 165399 29 darin 2009-11-20 12:40:13 -0800 Sounds like you're heading in the right direction. I do have a few thoughts. (In reply to comment #28) > I hate pedantic fixes that require bug filings and going through a whole review > process just to add comments to code and change variable names which add no > benefit to the user, and are beneficial to a developer only in the context of > looking at a real user issue, so I put the comments and related fixes in this > patch together with this algorithm fix hopefully the reviewer (likely Darin) > will not mind that. It's extremely helpful to have bug fixes that have only the bug fix. Separate refactoring patches help achieve that and make the process of fixing bugs much safer and more deliberate. I'm sorry you hate those patches. > Since I had a lot of explaining to do, I used line > breaks to separate main ideas, try to make the comment more readable while > keeping it pretty condensed. I found the formatting of the comment distracting. Starting the new sentences on new lines didn't make it easier for me to understand it. > as far as including the initial updateCounter in the loop, I > was trying to save an unnecessary comparison, since this function is called for > every DOM node insertion I was trying to make it as quick as possible if the > node being inserted and its descendants have no counter directives. If the extra branch at the start of loop is a concern, other possible idioms are a do/while loop or an infinite loop with an explicit break. > As I explained in my response to Shinchiro Hamaji, this work is usually not > that much In a hot function like this, to turn the guess of "usually not that much" into something we can make decisions based on, we'd typically do measurement to see what effect the code change has on performance. Trying with something we think is likely to be the worst case of additional overhead. > The code above appears to replace 4 lines, but in reality it adds totally new > functionality while optimizing those 4 lines to run faster. If you're saying this new structure should be judged as a performance optimization, then it should come by itself in a separate patch, with measurement of the speedup. > I read an article in a respected Software Development journal where a guy > published a breadth first graph travesal algorithm optimized for the Cell > processor. The algorithm had 5000 lines versus the usual about 50. But was > running an order of magnitude faster on the same hardware as the vanilla > algorithm. If you're going to cite this article as evidence that your approach is good, then you'll need to measure actual speedup. The guy in that article did. I did notice the way your patch cut down on work in various cases by reusing the results of if statements. Consider that readability of the code is critical although minimizing the number of lines is not. If we have to make things significantly less readable, then we need a *measurable* speedup to counterbalance that cost. > I read somewhere in the style > guidelines that long lines are bad and I was trying to comply with that. We should fix that guideline; it's not really our WebKit style. Could you cite the specific text? I'd like to correct it. 170279 30 hamaji 2009-12-09 18:32:05 -0800 *** Bug 30505 has been marked as a duplicate of this bug. *** 181973 31 46841 carol 2010-01-18 13:34:00 -0800 Created attachment 46841 Proposed Patch Still testing this patch, but I am almost done. 182036 32 46863 carol 2010-01-18 16:45:03 -0800 Created attachment 46863 Proposed patch; This the final patch to be submitted in the long series that lead to fixing (see blocker bug list) this bug and a dozen similar ones reported in various repositories. 182041 33 darin 2010-01-18 16:52:49 -0800 Are all those explicit AtomicString conversions needed? I’d expect a conversion from AtomicStringImpl* to AtomicString to work without an explicit conversion. 182046 34 46866 carol 2010-01-18 17:07:17 -0800 Created attachment 46866 New Proposed patch. Fixed style issue that I missed in my original submission. Removed explicit conversions from AtomicStringImpl* to AtomicString as they are not needed at least not for g++. 182048 35 carol 2010-01-18 17:10:45 -0800 (In reply to comment #33) > Are all those explicit AtomicString conversions needed? I’d expect a conversion > from AtomicStringImpl* to AtomicString to work without an explicit conversion. The conversions are not needed, but I had a prior problem with converting from RefPtr<AtomicStringImpl*> and once I solved that I left the AtomicString in place, I thought that it does not hurt. If anything it makes the code more portable. Thanks for the quick review. 182049 36 46866 darin 2010-01-18 17:16:01 -0800 Comment on attachment 46866 New Proposed patch. Fixed style issue that I missed in my original submission. > -void RenderObject::styleDidChange(StyleDifference diff, const RenderStyle*) > +void RenderObject::styleDidChange(StyleDifference diff, const RenderStyle*oldStyle) Missing space here. > Index: LayoutTests/ChangeLog > =================================================================== > --- LayoutTests/ChangeLog (revision 53399) > +++ LayoutTests/ChangeLog (working copy) > @@ -1,3 +1,32 @@ > +2010-01-18 Carol Szabo <carol.szabo@nokia.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Another crazy counters bug > + https://bugs.webkit.org/show_bug.cgi?id=11031 > + > + * fast/css/counters/counter-increment-002-expected.txt: Added. > + * fast/css/counters/counter-increment-002.html: Added. > + * fast/css/counters/counter-reset-000-expected.txt: Added. > + * fast/css/counters/counter-reset-000.html: Added. > + * fast/css/counters/counter-reset-002-expected.txt: Added. > + * fast/css/counters/counter-reset-002.html: Added. > + > +2010-01-18 Carol Szabo <carol.szabo@nokia.com> > + > + Reviewed by NOBODY (OOPS!). > + > + Another crazy counters bug > + https://bugs.webkit.org/show_bug.cgi?id=11031 > + Added tests for dynamic DOM changes affecting counters. > + > + * fast/css/counters/counter-increment-002.html: Added. > + * fast/css/counters/counter-reset-000.html: Added. > + * fast/css/counters/counter-reset-002.html: Added. > + * fast/css/counters/counter-increment-002-expected.txt: Added. > + * fast/css/counters/counter-reset-000-expected.txt: Added. > + * fast/css/counters/counter-reset-002-expected.txt: Added. > + Double change log here. You should post another patch without the double change log. 182259 37 46916 carol 2010-01-19 08:41:43 -0800 Created attachment 46916 Proposed patch; Fixes style and ChangeLog error mentioned by Darin. 182492 38 46916 commit-queue 2010-01-19 16:09:26 -0800 Comment on attachment 46916 Proposed patch; Fixes style and ChangeLog error mentioned by Darin. Clearing flags on attachment: 46916 Committed r53506: <http://trac.webkit.org/changeset/53506> 182493 39 commit-queue 2010-01-19 16:09:37 -0800 All reviewed patches have been landed. Closing bug. 10768 2006-09-25 14:37:27 -0700 2006-09-25 14:37:27 -0700 Test case boo4.html text/html 3854 bdakin PCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEvL0VOIiAiaHR0cDov L3d3dy53My5vcmcvVFIvaHRtbDQvc3RyaWN0LmR0ZCI+CjxodG1sPgo8aGVhZD4KICA8bWV0YSBo dHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYt OCI+CiAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0 L2NzcyI+CiAgPHRpdGxlPjwvdGl0bGU+CiAgPG1ldGEgbmFtZT0iR2VuZXJhdG9yIiBjb250ZW50 PSJDb2NvYSBIVE1MIFdyaXRlciI+CiAgPG1ldGEgbmFtZT0iQ29jb2FWZXJzaW9uIiBjb250ZW50 PSI4MjQuNDEiPgogIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CiAgICBwLnAxIHttYXJnaW46IDAu MHB4IDAuMHB4IDAuMHB4IDAuMHB4OyBmb250OiAxMC4wcHggTW9uYWNvfQogICAgcC5wMiB7bWFy Z2luOiAwLjBweCAwLjBweCAwLjBweCAwLjBweDsgZm9udDogMTAuMHB4IE1vbmFjbzsgbWluLWhl aWdodDogMTQuMHB4fQogICAgc3Bhbi5BcHBsZS10YWItc3BhbiB7d2hpdGUtc3BhY2U6cHJlfQog IDwvc3R5bGU+CjwvaGVhZD4KPGJvZHk+CjxwIGNsYXNzPSJwMSI+Jmx0OyFET0NUWVBFIGh0bWwg UFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIv eGh0bWwxMS9EVEQveGh0bWwxMS5kdGQiJmd0OzwvcD4KPHAgY2xhc3M9InAxIj4mbHQ7aHRtbCB4 bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCImZ3Q7PC9wPgo8cCBjbGFzcz0icDEi PjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgPC9zcGFuPiZsdDtoZWFkJmd0 OzwvcD4KPHAgY2xhc3M9InAxIj48c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj7C oCA8L3NwYW4+Jmx0O3RpdGxlJmd0O0NTUyAyLjEgVGVzdCBTdWl0ZTogZHluYW1pYyBjaGFuZ2Vz IHRvICdjb3VudGVyLWluY3JlbWVudCcmbHQ7L3RpdGxlJmd0OzwvcD4KPHAgY2xhc3M9InAxIj48 c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj7CoCA8L3NwYW4+Jmx0O2xpbmsgcmVs PSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI2Nv dW50ZXJzIi8mZ3Q7PC9wPgo8cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0 ZWQtc3BhY2UiPsKgIDwvc3Bhbj4mbHQ7bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cu dzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjcHJvcGRlZi1jb250ZW50Ii8mZ3Q7PC9wPgo8 cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgIDwvc3Bh bj4mbHQ7bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL3N5 bmRhdGEuaHRtbCNjb3VudGVyIi8mZ3Q7PC9wPgo8cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJB cHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgIDwvc3Bhbj4mbHQ7bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiLyZndDs8L3A+CjxwIGNs YXNzPSJwMSI+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+wqAgPC9zcGFuPiZs dDtzdHlsZSB0eXBlPSJ0ZXh0L2NzcyImZ3Q7PC9wPgo8cCBjbGFzcz0icDIiPjxicj48L3A+Cjxw IGNsYXNzPSJwMSI+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+wqAgPC9zcGFu PiN0ZXN0LCAucmVzZXQgeyBjb3VudGVyLXJlc2V0OiBjOyB9PC9wPgo8cCBjbGFzcz0icDEiPjxz cGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgIDwvc3Bhbj4uaW5jcmVtZW50OmJl Zm9yZSB7IGNvbnRlbnQ6IGNvdW50ZXJzKGMsICIuIikgIi0iOyB9PC9wPgo8cCBjbGFzcz0icDEi PjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgIDwvc3Bhbj4uaW5jcmVtZW50 IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH08L3A+CjxwIGNsYXNzPSJwMiI+PGJyPjwvcD4KPHAg Y2xhc3M9InAxIj48c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj7CoCA8L3NwYW4+ Jmx0Oy9zdHlsZSZndDs8L3A+CjxwIGNsYXNzPSJwMSI+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZl cnRlZC1zcGFjZSI+wqAgPC9zcGFuPiZsdDtzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiZn dDs8L3A+CjxwIGNsYXNzPSJwMiI+PGJyPjwvcD4KPHAgY2xhc3M9InAxIj48c3BhbiBjbGFzcz0i QXBwbGUtY29udmVydGVkLXNwYWNlIj7CoCA8L3NwYW4+ZnVuY3Rpb24gcnVuKCkgezwvcD4KPHAg Y2xhc3M9InAxIj48c3BhbiBjbGFzcz0iQXBwbGUtdGFiLXNwYW4iPgk8L3NwYW4+dmFyIHQgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOzwvcD4KPHAgY2xhc3M9InAxIj48c3BhbiBj bGFzcz0iQXBwbGUtdGFiLXNwYW4iPgk8L3NwYW4+dmFyIHMgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJzcGFuIik7PC9wPgo8cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS10YWItc3Bh biI+CTwvc3Bhbj5zLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAiaW5jcmVtZW50Iik7PC9wPgo8cCBj bGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS10YWItc3BhbiI+CTwvc3Bhbj5zLmFwcGVuZENo aWxkKGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKCJuZXctIikpOzwvcD4KPHAgY2xhc3M9InAxIj48 c3BhbiBjbGFzcz0iQXBwbGUtdGFiLXNwYW4iPgk8L3NwYW4+dC5pbnNlcnRCZWZvcmUocywgdC5j aGlsZE5vZGVzLml0ZW0oMSkpOzwvcD4KPHAgY2xhc3M9InAxIj48c3BhbiBjbGFzcz0iQXBwbGUt Y29udmVydGVkLXNwYWNlIj7CoCA8L3NwYW4+fTwvcD4KPHAgY2xhc3M9InAyIj48YnI+PC9wPgo8 cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgIDwvc3Bh bj4mbHQ7L3NjcmlwdCZndDs8L3A+CjxwIGNsYXNzPSJwMSI+PHNwYW4gY2xhc3M9IkFwcGxlLWNv bnZlcnRlZC1zcGFjZSI+wqA8L3NwYW4+Jmx0Oy9oZWFkJmd0OzwvcD4KPHAgY2xhc3M9InAxIj48 c3BhbiBjbGFzcz0iQXBwbGUtY29udmVydGVkLXNwYWNlIj7CoDwvc3Bhbj4mbHQ7Ym9keSBvbmxv YWQ9InNldFRpbWVvdXQoJ3J1bigpJywgMCkiJmd0OzwvcD4KPHAgY2xhc3M9InAyIj48YnI+PC9w Pgo8cCBjbGFzcz0icDEiPjxzcGFuIGNsYXNzPSJBcHBsZS1jb252ZXJ0ZWQtc3BhY2UiPsKgPC9z cGFuPiZsdDtwJmd0O1RoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZTom bHQ7L3AmZ3Q7PC9wPgo8cCBjbGFzcz0icDIiPjxicj48L3A+CjxwIGNsYXNzPSJwMSI+PHNwYW4g Y2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+wqA8L3NwYW4+Jmx0O2RpdiBpZD0idGVzdCIm Z3Q7Jmx0O3NwYW4gY2xhc3M9ImluY3JlbWVudCImZ3Q7Jmx0Oy9zcGFuJmd0OyZsdDtzcGFuIGNs YXNzPSJpbmNyZW1lbnQiJmd0OyZsdDsvc3BhbiZndDsmbHQ7c3BhbiBjbGFzcz0iaW5jcmVtZW50 IiZndDsmbHQ7L3NwYW4mZ3Q7Jmx0Oy9kaXYmZ3Q7PC9wPgo8cCBjbGFzcz0icDIiPjxicj48L3A+ CjxwIGNsYXNzPSJwMSI+PHNwYW4gY2xhc3M9IkFwcGxlLWNvbnZlcnRlZC1zcGFjZSI+wqA8L3Nw YW4+Jmx0O2RpdiBpZD0icmVmZXJlbmNlIiZndDsxLTItbmV3LTMtNC0mbHQ7L2RpdiZndDs8L3A+ CjxwIGNsYXNzPSJwMiI+PGJyPjwvcD4KPHAgY2xhc3M9InAxIj48c3BhbiBjbGFzcz0iQXBwbGUt Y29udmVydGVkLXNwYWNlIj7CoDwvc3Bhbj4mbHQ7L2JvZHkmZ3Q7PC9wPgo8cCBjbGFzcz0icDEi PiZsdDsvaHRtbCZndDs8L3A+CjwvYm9keT4KPC9odG1sPgo= 42605 2009-11-05 15:28:42 -0800 2009-11-05 18:46:51 -0800 Proposed Patch patchFor11031.patch text/plain 50737 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDU3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODIgQEAKKzIwMDktMTEtMDUgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorICAgICAgICBUaGlzIHBhdGNoIGZpeGVzIHRoZSBD U1MyLjEgY291bnRlciBpbXBsZW1lbnRhdGlvbiBzdWNoIHRoYXQgaXQKKyAgICAgICAgY29uZm9y bXMgdG8gdGhlIGxhdGVzdCBzY29waW5nIGFuZCBuZXN0aW5nIHJ1bGVzIGFuZCB1cGRhdGVzCisg ICAgICAgIHRoZSB2YWx1ZXMgb2YgdGhlIGNvdW50ZXJzIHdoZW4gdGhlIERPTSBpcyBjaGFuZ2Vk LgorCisgICAgICAgIFRlc3RzOiBjc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKKyAg ICAgICAgICAgICAgIGNzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCisgICAgICAgICAgICAg ICBjc3MyLjEvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL0Nv dW50ZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpjb21wdXRlQ291 bnRJblBhcmVudCk6CisgICAgICAgIENoYW5nZWQgdG8gdXNlIGlzUmVzZXQoKSBpbnN0ZWFkIG9m IG1faXNSZXNldCBpbiBvcmRlciB0byBiZSBpbnN5bmMKKyAgICAgICAgd2l0aCB0aGUgY2hhbmdl IGluIG1lYW5pbmcgb2YgbV9pc1Jlc2V0IHdoaWNoIG5vdyBtZWFucyB0aGF0IHRoZQorICAgICAg ICBjb3VudGVyIGlzIG9mIHJlc2V0IHR5cGUgYmVjYXVzZSBpdCB3YXMgc3R5bGVkIGFzIHN1Y2gg dmVyc3VzIHRoZQorICAgICAgICBvbGQgbWVhbmluZyB0aGF0IGl0IGlzIHJlc2V0IGVpdGhlciBi ZWNhdXNlIG9mIHRoZSBzdHlsZXNoZWV0IG9yIAorICAgICAgICBiZWNhdXNlIGl0IGlzIHRoZSBm aXJzdCByZWZlcmVuY2UgdG8gdGhpcyBjb3VudGVyIGlkZW50aWZpZXIuCisgICAgICAgIChXZWJD b3JlOjpDb3VudGVyTm9kZTo6cmVzZXRSZW5kZXJlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3Vu dGVyTm9kZTo6cmVzZXRSZW5kZXJlcnMpOgorICAgICAgICBJbnRyb2R1Y2VkIHRvIGVuY2Fwc3Vs YXRlIGNvZGUgdGhhdCBpbnZhbGlkYXRlcyBjb3VudGVyIHJlZmVyZW5jZXMKKyAgICAgICAgaW4g cmVuZGVyZXJzIHdoZW4gYSBjb3VudGVyJ3MgdmFsdWUgbWF5IGNoYW5nZS4KKyAgICAgICAgKFdl YkNvcmU6OkNvdW50ZXJOb2RlOjpyZWNvdW50KToKKyAgICAgICAgQ2hhbmdlIGp1c3QgaW4gbGF5 b3V0LCBubyBmdW5jdGlvbmFsIGNoYW5nZS4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2Rl OjppbnNlcnRBZnRlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVtb3ZlQ2hp bGQpOgorICAgICAgICBDaGFuZ2VkIHRvIHByb3Blcmx5IGludmFsaWRhdGUgdGhlIGNvdW50ZXIg aGllcmFyY2h5IHdoZW4gYSByZXNldAorICAgICAgICBub2RlIGlzIGluc2VydGVkIG9lIHJlbW92 ZWQgaW4vZnJvbSB0aGUgdHJlZS4KKyAgICAgICAgKFdlYkNvcmU6OnNob3dUcmVlQW5kTWFyayk6 CisgICAgICAgIENoYW5nZWQgdG8gZW5yaWNoIHRoZSBsaXN0ZWQgZGVidWdnaW5nIGluZm9ybWF0 aW9uLgorICAgICAgICAqIHJlbmRlcmluZy9Db3VudGVyTm9kZS5oOgorICAgICAgICAoV2ViQ29y ZTo6Q291bnRlck5vZGU6OmlzUmVzZXQpOgorICAgICAgICBDaGFuZ2VkIHRvIGNvdmVyIGJvdGgg Y2FzZXMgd2hlbiBhIGNvdW50ZXIgYWN0cyBhcyBhIHJlc2V0IGNvdW50ZXIuCisgICAgICAgIChX ZWJDb3JlOjpDb3VudGVyTm9kZTo6aXNUeXBlUmVzZXQpOgorICAgICAgICBJbnRyb2R1Y2VkIHRv IGVuYWJsZSBleHRyYWN0aW9uIG9mIHRoZSBjb3VudGVyIHR5cGUgYWNjb3JkaW5nIHRvIHRoZQor ICAgICAgICBzdHlsZSBzaGVldC4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjp2YWx1 ZSk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Y291bnRJblBhcmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVuZGVyZXIpOgorICAgICAgICAoV2ViQ29yZTo6 Q291bnRlck5vZGU6OnBhcmVudCk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cHJl dmlvdXNTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpuZXh0U2libGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Zmlyc3RDaGlsZCk6CisgICAgICAg IChXZWJDb3JlOjpDb3VudGVyTm9kZTo6bGFzdENoaWxkKToKKyAgICAgICAgSnVzdCBmb3JjZWQg aW5saW5lIGZvciBzcGVlZC4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpmaW5kUGxhY2VGb3JDb3VudGVyKToKKyAgICAgICAgQ29tcGxl dGVseSByZXdyaXR0ZW4gdGhlIGFsZ29yaXRobSB0byBhY2NvdW50IGZvciBjdXJyZW50IGNvdW50 ZXIKKyAgICAgICAgc2NvcGluZyBydWxlcyBhbmQgdG8gcHJvcGVybHkgaGFuZGxlIHJhbmRvbSBj b3VudGVyIGluc2VydGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpjb3VudGVyKToKKyAgICAgICAg QWRkZWQgY29kZSB0byByZWV2YWx1YXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB1cG9uIG5ldyBy b290IGNvdW50ZXIKKyAgICAgICAgY3JlYXRpb24sIGFkZGFwdGVkIHRvIG5ldyBpc1Jlc2V0IHNl bWFudGljcy4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUpOgor ICAgICAgICBBZGRlZCBvcHRpb24gdG8gY29uZGl0aW9uYWxseSBpbnZhbGlkYXRlIHRoZSBjb3Vu dGVyIGJ5IGlkLgorICAgICAgICAoV2ViQ29yZTo6ZGVzdHJveUNvdW50ZXJOb2RlV2l0aG91dE1h cFJlbW92YWwpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50 ZXJOb2Rlcyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRl ck5vZGUpOgorICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBzZWxlY3RpdmUgY29udGVyIG5vZGUg ZGVzdHJ1Y3Rpb24uCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpjcmVhdGVDb3Vu dGVySWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291 bnRlcnMpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcik6 CisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBzdXBwb3J0IGR5bmFtaWMgY291bnRlciBoaWVy YXJjaHkgdXBkYXRlIHVwb24gRE9NCisgICAgICAgIGNoYW5nZXMKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRDaGlsZCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnNldFN0eWxlKToKKyAgICAgICAgQWRkZWQgaG9va3MgdG8g dXBkYXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB3aGVuIHRoZSBET00gY2hhbmdlcy4KKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmludmFsaWRhdGVDb3VudGVyc0luQ29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlck9iamVjdENoaWxkTGlzdDo6aW52YWxpZGF0ZUNvdW50ZXJzKToKKyAgICAgICAgQWRkZWQg c3VwcG9ydCBmb3Igc2VsZWN0aXZlIGNvdW50ZXIgaW52YWxpZGF0aW9uIGFuZCBleHRlbmRlZCB0 aGUKKyAgICAgICAgc2NvcGUgb2YgdGhlIGludmFsaWRhdGlvbiB0byB0aGUgY29udGFpbmVyIGl0 c2VsZiBhcyBzb21lIGNvdW50ZXJzCisgICAgICAgIGhhbmcgZGlyZWN0bHkgb2ZmIG9mIGl0Lgor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaDoKKwogMjAwOS0xMS0w NSAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGltaXRyaSBHbGF6a292LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRlck5vZGUu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2 aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTI0LDE2ICsyNCwxMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIkNvdW50ZXJOb2RlLmgiCiAKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVk ZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KIAotLy8gRklYTUU6IFRoZXJl J3MgY3VycmVudGx5IG5vIHN0cmF0ZWd5IGZvciBnZXR0aW5nIHRoZSBjb3VudGVyIHRyZWUgdXBk YXRlZCB3aGVuIG5ldwotLy8gZWxlbWVudHMgd2l0aCBjb3VudGVyLXJlc2V0IGFuZCBjb3VudGVy LWluY3JlbWVudCBzdHlsZXMgYXJlIGFkZGVkIHRvIHRoZSByZW5kZXIgdHJlZS4KLS8vIEFsc28s IHRoZSBjb2RlIGNhbid0IGhhbmRsZSBjaGFuZ2VzIHdoZXJlIGFuIGV4aXN0aW5nIG5vZGUgbmVl ZHMgdG8gY2hhbmdlIGludG8gYQotLy8gInJlc2V0IiBub2RlLCBvciBmcm9tIGEgInJlc2V0IiBu b2RlIGJhY2sgdG8gbm90IGEgInJlc2V0IiBub2RlLiBBcyBvZiB0aGlzIHdyaXRpbmcsCi0vLyBh dCBsZWFzdCBzb21lIG9mIHRoZXNlIHByb2JsZW1zIG1hbmlmZXN0IGFzIGZhaWx1cmVzIGluIHRo ZSB0MTIwNC1pbmNyZW1lbnQgYW5kCi0vLyB0MTIwNC1yZXNldCB0ZXN0cyBpbiB0aGUgQ1NTIDIu MSB0ZXN0IHN1aXRlLgotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIENvdW50ZXJOb2RlOjpDb3Vu dGVyTm9kZShSZW5kZXJPYmplY3QqIG8sIGJvb2wgaXNSZXNldCwgaW50IHZhbHVlKQpAQCAtNTEs MTQgKzQ1LDI4IEBAIENvdW50ZXJOb2RlOjpDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqIG8KIAog aW50IENvdW50ZXJOb2RlOjpjb21wdXRlQ291bnRJblBhcmVudCgpIGNvbnN0CiB7Ci0gICAgaW50 IGluY3JlbWVudCA9IG1faXNSZXNldCA/IDAgOiBtX3ZhbHVlOworICAgIGludCBpbmNyZW1lbnQg PSBpc1Jlc2V0KCkgPyAwIDogbV92YWx1ZTsKICAgICBpZiAobV9wcmV2aW91c1NpYmxpbmcpCiAg ICAgICAgIHJldHVybiBtX3ByZXZpb3VzU2libGluZy0+bV9jb3VudEluUGFyZW50ICsgaW5jcmVt ZW50OwogICAgIEFTU0VSVChtX3BhcmVudC0+bV9maXJzdENoaWxkID09IHRoaXMpOwogICAgIHJl dHVybiBtX3BhcmVudC0+bV92YWx1ZSArIGluY3JlbWVudDsKIH0KIAotdm9pZCBDb3VudGVyTm9k ZTo6cmVjb3VudCgpCit2b2lkIENvdW50ZXJOb2RlOjpyZXNldFJlbmRlcmVyKEF0b21pY1N0cmlu Z0ltcGwqIGlkZW50aWZpZXIpCit7CisgICAgaWYobV9yZW5kZXJlciAmJiAhbV9yZW5kZXJlci0+ ZG9jdW1lbnRCZWluZ0Rlc3Ryb3llZCgpKQorICAgICAgICBpZiAoUmVuZGVyT2JqZWN0Q2hpbGRM aXN0KiBjaGlsZHJlbiA9IG1fcmVuZGVyZXItPnZpcnR1YWxDaGlsZHJlbigpKQorICAgICAgICAg ICAgY2hpbGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhtX3JlbmRlcmVyLCBpZGVudGlmaWVyKTsK K30KKwordm9pZCBDb3VudGVyTm9kZTo6cmVzZXRSZW5kZXJlcnMoQXRvbWljU3RyaW5nSW1wbCAq aWRlbnRpZmllcikKK3sKKyAgICByZXNldFJlbmRlcmVyKGlkZW50aWZpZXIpOworICAgIGZvcihD b3VudGVyTm9kZSogYyA9IG1fZmlyc3RDaGlsZDsgYyA7IGMgPSBjLT5tX25leHRTaWJsaW5nKQor ICAgICAgICBjLT5yZXNldFJlbmRlcmVycyhpZGVudGlmaWVyKTsKK30KKwordm9pZCBDb3VudGVy Tm9kZTo6cmVjb3VudChBdG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKQogewogICAgIGZvciAo Q291bnRlck5vZGUqIGMgPSB0aGlzOyBjOyBjID0gYy0+bV9uZXh0U2libGluZykgewogICAgICAg ICBpbnQgb2xkQ291bnQgPSBjLT5tX2NvdW50SW5QYXJlbnQ7CkBAIC02NiwxOCArNzQsMTMgQEAg dm9pZCBDb3VudGVyTm9kZTo6cmVjb3VudCgpCiAgICAgICAgIGlmIChvbGRDb3VudCA9PSBuZXdD b3VudCkKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjLT5tX2NvdW50SW5QYXJlbnQgPSBu ZXdDb3VudDsKLSAgICAgICAgLy8gbV9yZW5kZXJlciBjb250YWlucyB0aGUgcGFyZW50IG9mIHRo ZSByZW5kZXIgbm9kZQotICAgICAgICAvLyBjb3JyZXNwb25kaW5nIHRvIGEgQ291bnRlck5vZGUu IExldCdzIGZpbmQgdGhlIGNvdW50ZXIKLSAgICAgICAgLy8gY2hpbGQgYW5kIG1ha2UgdGhpcyBy ZS1sYXlvdXQuCi0gICAgICAgIGZvciAoUmVuZGVyT2JqZWN0KiBvID0gYy0+bV9yZW5kZXJlci0+ Zmlyc3RDaGlsZCgpOyBvOyBvID0gby0+bmV4dFNpYmxpbmcoKSkKLSAgICAgICAgICAgIGlmICgh by0+ZG9jdW1lbnRCZWluZ0Rlc3Ryb3llZCgpICYmIG8tPmlzQ291bnRlcigpKSB7Ci0gICAgICAg ICAgICAgICAgby0+c2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7Ci0gICAgICAg ICAgICAgICAgYnJlYWs7Ci0gICAgICAgICAgICB9CisgICAgICAgIC8vUmVsYXlvdXQgYWxsIGNv dW50ZXJzIHRoYXQgbWF5IGJlIGFmZmVjdGVkIGJ5IHRoaXMgY2hhbmdlCisgICAgICAgIGMtPnJl c2V0UmVuZGVyZXJzKGlkZW50aWZpZXIpOwogICAgIH0KIH0KIAotdm9pZCBDb3VudGVyTm9kZTo6 aW5zZXJ0QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSogcmVmQ2hpbGQp Cit2b2lkIENvdW50ZXJOb2RlOjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsCisg ICAgQ291bnRlck5vZGUqIHJlZkNoaWxkLCBBdG9taWNTdHJpbmdJbXBsICppZGVudGlmaWVyKQog ewogICAgIEFTU0VSVChuZXdDaGlsZCk7CiAgICAgQVNTRVJUKCFuZXdDaGlsZC0+bV9wYXJlbnQp OwpAQCAtODUsNiArODgsMTQgQEAgdm9pZCBDb3VudGVyTm9kZTo6aW5zZXJ0QWZ0ZXIoQ291bnRl ck5vZAogICAgIEFTU0VSVCghbmV3Q2hpbGQtPm1fbmV4dFNpYmxpbmcpOwogICAgIEFTU0VSVCgh cmVmQ2hpbGQgfHwgcmVmQ2hpbGQtPm1fcGFyZW50ID09IHRoaXMpOwogCisgICAgaWYgKG5ld0No aWxkLT5pc1R5cGVSZXNldCgpKSB7CisgICAgICAgIFJlZlB0cjxBdG9taWNTdHJpbmdJbXBsPiBp ZGVudGlmaWVyUHRyKGlkZW50aWZpZXIpOworICAgICAgICB3aGlsZSAobV9sYXN0Q2hpbGQgIT0g cmVmQ2hpbGQpIHsKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9k ZShtX2xhc3RDaGlsZC0+cmVuZGVyZXIoKSwKKyAgICAgICAgICAgICAgICBpZGVudGlmaWVyUHRy KTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIENvdW50ZXJOb2RlKiBuZXh0OwogCiAgICAgaWYg KHJlZkNoaWxkKSB7CkBAIC0xMDksMTAgKzEyMCwxMSBAQCB2b2lkIENvdW50ZXJOb2RlOjppbnNl cnRBZnRlcihDb3VudGVyTm9kCiAKICAgICBuZXdDaGlsZC0+bV9jb3VudEluUGFyZW50ID0gbmV3 Q2hpbGQtPmNvbXB1dGVDb3VudEluUGFyZW50KCk7CiAgICAgaWYgKG5leHQpCi0gICAgICAgIG5l eHQtPnJlY291bnQoKTsKKyAgICAgICAgbmV4dC0+cmVjb3VudChpZGVudGlmaWVyKTsKIH0KIAot dm9pZCBDb3VudGVyTm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9sZENoaWxkKQordm9p ZCBDb3VudGVyTm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9sZENoaWxkLAorICAgIEF0 b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpCiB7CiAgICAgQVNTRVJUKG9sZENoaWxkKTsKICAg ICBBU1NFUlQoIW9sZENoaWxkLT5tX2ZpcnN0Q2hpbGQpOwpAQCAtMTM4LDkgKzE1MCw5IEBAIHZv aWQgQ291bnRlck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2QKICAgICAgICAgQVNTRVJUKG1f bGFzdENoaWxkID09IG9sZENoaWxkKTsKICAgICAgICAgbV9sYXN0Q2hpbGQgPSBwcmV2OwogICAg IH0KLSAgICAKKwogICAgIGlmIChuZXh0KQotICAgICAgICBuZXh0LT5yZWNvdW50KCk7CisgICAg ICAgIG5leHQtPnJlY291bnQoaWRlbnRpZmllcik7CiB9CiAKICNpZm5kZWYgTkRFQlVHCkBAIC0x NzIsMTQgKzE4NCwxMyBAQCBzdGF0aWMgdm9pZCBzaG93VHJlZUFuZE1hcmsoY29uc3QgQ291bnRl CiAgICAgICAgIHJvb3QgPSByb290LT5wYXJlbnQoKTsKIAogICAgIGZvciAoY29uc3QgQ291bnRl ck5vZGUqIGMgPSByb290OyBjOyBjID0gbmV4dEluUHJlT3JkZXIoYykpIHsKLSAgICAgICAgaWYg KGMgPT0gbm9kZSkKLSAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiKiIpOworICAgICAgICBm d3JpdGUoKGMgPT0gbm9kZSkgPyAiKiIgOiAiICIsIDEsIDEsIHN0ZGVycik7CiAgICAgICAgIGZv ciAoY29uc3QgQ291bnRlck5vZGUqIGQgPSBjOyBkICYmIGQgIT0gcm9vdDsgZCA9IGQtPnBhcmVu dCgpKQotICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJcdCIpOwotICAgICAgICBpZiAoYy0+ aXNSZXNldCgpKQotICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICJyZXNldDogJWQgJWRcbiIs IGMtPnZhbHVlKCksIGMtPmNvdW50SW5QYXJlbnQoKSk7Ci0gICAgICAgIGVsc2UKLSAgICAgICAg ICAgIGZwcmludGYoc3RkZXJyLCAiaW5jcmVtZW50OiAlZCAlZFxuIiwgYy0+dmFsdWUoKSwgYy0+ Y291bnRJblBhcmVudCgpKTsKKyAgICAgICAgICAgIGZ3cml0ZSgiICAiLCAxLCAyLCBzdGRlcnIp OworICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIjB4JTA4WCAlczogJWQgJWQgUDoweDA4JVggUFM6 MHglMDhYIE5TOjB4MDglWFxuIiwKKyAgICAgICAgICAgIChpbnQpYywgYy0+aXNSZXNldCgpID8g InJlc2V0IiA6ICJpbmNyZW1lbnQiLCBjLT52YWx1ZSgpLAorICAgICAgICAgICAgYy0+Y291bnRJ blBhcmVudCgpLCBjLT5wYXJlbnQoKSwgYy0+cHJldmlvdXNTaWJsaW5nKCksCisgICAgICAgICAg ICBjLT5uZXh0U2libGluZygpKTsKICAgICB9CiB9CiAKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5n L0NvdW50ZXJOb2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRlck5v ZGUuaAkocmV2aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5o CSh3b3JraW5nIGNvcHkpCkBAIC0yMyw2ICsyMyw3IEBACiAjZGVmaW5lIENvdW50ZXJOb2RlX2gK IAogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9BbHdheXNJbmxp bmUuaD4KIAogLy8gVGhpcyBpbXBsZW1lbnRzIGEgY291bnRlciB0cmVlIHRoYXQgaXMgdXNlZCBm b3IgZmluZGluZyBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9va3VwLAogLy8gYW5kIGZvciBwcm9w YWdhdGluZyBjb3VudCBjaGFuZ2VzIHdoZW4gbm9kZXMgYXJlIGFkZGVkIG9yIHJlbW92ZWQuCkBA IC0zNiwyOCArMzcsNTMgQEAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgUmVuZGVyT2Jq ZWN0OworY2xhc3MgQXRvbWljU3RyaW5nSW1wbDsKIAogY2xhc3MgQ291bnRlck5vZGUgOiBwdWJs aWMgTm9uY29weWFibGUgewogcHVibGljOgogICAgIENvdW50ZXJOb2RlKFJlbmRlck9iamVjdCos IGJvb2wgaXNSZXNldCwgaW50IHZhbHVlKTsKIAotICAgIGJvb2wgaXNSZXNldCgpIGNvbnN0IHsg cmV0dXJuIG1faXNSZXNldDsgfQotICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFs dWU7IH0KLSAgICBpbnQgY291bnRJblBhcmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fY291bnRJblBh cmVudDsgfQotICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIoKSBjb25zdCB7IHJldHVybiBtX3Jl bmRlcmVyOyB9Ci0KLSAgICBDb3VudGVyTm9kZSogcGFyZW50KCkgY29uc3QgeyByZXR1cm4gbV9w YXJlbnQ7IH0KLSAgICBDb3VudGVyTm9kZSogcHJldmlvdXNTaWJsaW5nKCkgY29uc3QgeyByZXR1 cm4gbV9wcmV2aW91c1NpYmxpbmc7IH0KLSAgICBDb3VudGVyTm9kZSogbmV4dFNpYmxpbmcoKSBj b25zdCB7IHJldHVybiBtX25leHRTaWJsaW5nOyB9Ci0gICAgQ291bnRlck5vZGUqIGZpcnN0Q2hp bGQoKSBjb25zdCB7IHJldHVybiBtX2ZpcnN0Q2hpbGQ7IH0KLSAgICBDb3VudGVyTm9kZSogbGFz dENoaWxkKCkgY29uc3QgeyByZXR1cm4gbV9sYXN0Q2hpbGQ7IH0KLQotICAgIHZvaWQgaW5zZXJ0 QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSogYmVmb3JlQ2hpbGQpOwot ICAgIHZvaWQgcmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqKTsKKyAgICBBTFdBWVNfSU5MSU5FIGJv b2wgaXNSZXNldCgpIGNvbnN0IHsgcmV0dXJuIG1faXNSZXNldCB8fCAhbV9wYXJlbnQ7IH0KKyAg ICBBTFdBWVNfSU5MSU5FIGJvb2wgaXNUeXBlUmVzZXQoKSBjb25zdCB7IHJldHVybiBtX2lzUmVz ZXQ7IH0KKyAgICBBTFdBWVNfSU5MSU5FIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFs dWU7IH0KKyAgICBBTFdBWVNfSU5MSU5FIGludCBjb3VudEluUGFyZW50KCkgY29uc3QgeyByZXR1 cm4gbV9jb3VudEluUGFyZW50OyB9CisgICAgQUxXQVlTX0lOTElORSBSZW5kZXJPYmplY3QqIHJl bmRlcmVyKCkgY29uc3QgeyByZXR1cm4gbV9yZW5kZXJlcjsgfQorCisgICAgQUxXQVlTX0lOTElO RSBDb3VudGVyTm9kZSogcGFyZW50KCkgY29uc3QgeyByZXR1cm4gbV9wYXJlbnQ7IH0KKyAgICBB TFdBWVNfSU5MSU5FIENvdW50ZXJOb2RlKiBwcmV2aW91c1NpYmxpbmcoKSBjb25zdCB7IHJldHVy biBtX3ByZXZpb3VzU2libGluZzsgfQorICAgIEFMV0FZU19JTkxJTkUgQ291bnRlck5vZGUqIG5l eHRTaWJsaW5nKCkgY29uc3QgeyByZXR1cm4gbV9uZXh0U2libGluZzsgfQorICAgIEFMV0FZU19J TkxJTkUgQ291bnRlck5vZGUqIGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2ZpcnN0Q2hp bGQ7IH0KKyAgICBBTFdBWVNfSU5MSU5FIENvdW50ZXJOb2RlKiBsYXN0Q2hpbGQoKSBjb25zdCB7 IHJldHVybiBtX2xhc3RDaGlsZDsgfQorCisgICAgLyogaWRlbnRpZmllciBtdXN0IG1hdGNoIHRo ZSBpZGVudGlmaWVyIG9mIHRoaXMgY291bnRlciBvcgorICAgICAqIHRoZSByZW5kZXJlcnMgYWZm ZWN0ZWQgYnkgdGhpcyBpbnNlcnRpb24gc2hhbGwgbm90IGJlCisgICAgICogaW52YWxpZGF0ZWQu CisgICAgICovCisgICAgdm9pZCBpbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENv dW50ZXJOb2RlKiBiZWZvcmVDaGlsZCwKKyAgICAgICAgQXRvbWljU3RyaW5nSW1wbCogaWRlbnRp Zmllcik7CisKKyAgICAvKiBpZGVudGlmaWVyIG11c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgb2Yg dGhpcyBjb3VudGVyIG9yCisgICAgICogdGhlIHJlbmRlcmVycyBhZmZlY3RlZCBieSB0aGlzIHJl bW92YWwgc2hhbGwgbm90IGJlIGludmFsaWRhdGVkLgorICAgICAqLworICAgIHZvaWQgcmVtb3Zl Q2hpbGQoQ291bnRlck5vZGUqLCBBdG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsKKyAgICAv KiBJbnZhbGlkYXRlcyB0aGUgdGV4dCBpbiB0aGUgcmVuZGVyZXIgb2YgdGhpcyBjb3VudGVyLCBp ZiBhbnkKKyAgICAgKiBpZGVudGlmaWVyIG11c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgZm9yIHRo aXMgY291bnRlci4KKyAgICAgKi8KKyAgICB2b2lkIHJlc2V0UmVuZGVyZXIoQXRvbWljU3RyaW5n SW1wbCogaWRlbnRpZmllcik7CisKKyAgICAvKiBJbnZhbGlkYXRlcyB0aGUgdGV4dCBpbiB0aGUg cmVuZGVyZXIgb2YgdGhpcyBjb3VudGVyLCBpZiBhbnkKKyAgICAgKiBhbmQgaW4gdGhlIHJlbmRl cmVycyBvZiBhbGwgZGVzY2VuZGFudHMsIGlmIGFueQorICAgICAqIGlkZW50aWZpZXIgbXVzdCBt YXRjaCB0aGUgaWRlbnRpZmllciBmb3IgdGhpcyBjb3VudGVyLgorICAgICAqLworICAgIHZvaWQg cmVzZXRSZW5kZXJlcnMoQXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllcik7CiAKIHByaXZhdGU6 CiAgICAgaW50IGNvbXB1dGVDb3VudEluUGFyZW50KCkgY29uc3Q7Ci0gICAgdm9pZCByZWNvdW50 KCk7CisKKyAgICAvKiBpZGVudGlmaWVyIG11c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgb2YgdGhp cyBjb3VudGVyIG9yCisgICAgICogdGhlIHJlbmRlcmVycyBhZmZlY3RlZCBieSB0aGlzIHJlY291 bnQgc2hhbGwgbm90IGJlIGludmFsaWRhdGVkLgorICAgICAqLworICAgIHZvaWQgcmVjb3VudChB dG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsKIAogICAgIGJvb2wgbV9pc1Jlc2V0OwogICAg IGludCBtX3ZhbHVlOwpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlz aW9uIDUwNTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTEzMyw1NSArMTMzLDgwIEBAIHN0YXRpYyBib29sIHBsYW5Db3VudGVyKFJl bmRlck9iamVjdCogb2IKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKLXN0YXRpYyBib29sIGZpbmRQ bGFjZUZvckNvdW50ZXIoUmVuZGVyT2JqZWN0KiBvYmplY3QsIGNvbnN0IEF0b21pY1N0cmluZyYg Y291bnRlck5hbWUsCi0gICAgYm9vbCBpc1Jlc2V0LCBDb3VudGVyTm9kZSomIHBhcmVudCwgQ291 bnRlck5vZGUqJiBwcmV2aW91c1NpYmxpbmcpCisvKiBGaW5kcyB0aGUgaW5zZXJ0aW9uIHBvaW50 IGZvciB0aGUgY291bnRlciBkZXNjcmliZWQgYnkgY291bnRlck93bmVyLCBpc1Jlc2V0IGFuZCAK KyAqIGNvdW50ZXJOYW1lIGluIHRoZSBDb3VudGVyTm9kZSB0cmVlIGZvciBjb3VudGVyTmFtZSBh bmQgc2V0cyBwYXJlbnQgYW5kCisgKiBwcmV2aW91c1NpYmxpbmcgYWNjb3JkaW5nbHkuCisgKiBU aGUgZnVuY3Rpb24gcmV0dXJucyB0cnVlIGlmIHRoZSBjb3VudGVyIHdob3NlIGluc2VydGlvbiBw b2ludCBpcyBzZWFyY2hlZCBpcyBOT1QKKyAqIHRoZSByb290IG9mIHRoZSB0cmVlLgorICogVGhl IHJvb3Qgb2YgdGhlIHRyZWUgaXMgYSBjb3VudGVyIHJlZmVyZW5jZSB0aGF0IGlzIG5vdCBpbiB0 aGUgc2NvcGUgb2YgYW55IG90aGVyCisgKiBjb3VudGVyIHdpdGggdGhlIHNhbWUgaWRlbnRpZmll ci4KKyAqIEFsbCB0aGUgY291bnRlciByZWZlcmVuY2VzIHdpdGggdGhlIHNhbWUgaWRlbnRpZmll ciBhcyB0aGlzIG9uZSB0aGF0IGFyZSBpbgorICogY2hpbGRyZW4gb3Igc3Vic2VxdWVudCBzaWJs aW5ncyBvZiB0aGUgcmVuZGVyZXIgdGhhdCBvd25zIHRoZSByb290IG9mIHRoZSB0cmVlCisgKiBm b3JtIHRoZSByZXN0IG9mIG9mIHRoZSBub2RlcyBvZiB0aGUgdHJlZS4KKyAqIFRoZSByb290IG9m IHRoZSB0cmVlIGlzIGFsd2F5cyBhIHJlc2V0IHR5cGUgcmVmZXJlbmNlLgorICogQSBzdWJ0cmVl IHJvb3RlZCBhdCBhbnkgcmVzZXQgbm9kZSBpbiB0aGUgdHJlZSBpcyBlcXVpdmFsZW50IHRvIGFs bCBjb3VudGVyIAorICogcmVmZXJlbmNlcyB0aGF0IGFyZSBpbiB0aGUgc2NvcGUgb2YgdGhlIGNv dW50ZXIgb3IgbmVzdGVkIGNvdW50ZXIgZGVmaW5lZCBieSB0aGF0CisgKiByZXNldCBub2RlLgor ICogTm9uLXJlc2V0IENvdW50ZXJOb2RlcyBjYW5ub3QgaGF2ZSBkZXNjZW5kYW50cy4KKyAqLwor c3RhdGljIGJvb2wgZmluZFBsYWNlRm9yQ291bnRlcihSZW5kZXJPYmplY3QqIGNvdW50ZXJPd25l ciwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBj b3VudGVyTmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCBpc1Jlc2V0 LCBDb3VudGVyTm9kZSomIHBhcmVudCwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IENvdW50ZXJOb2RlKiYgcHJldmlvdXNTaWJsaW5nKQogewotICAgIC8vIEZpbmQgdGhlIGFwcHJv cHJpYXRlIHByZXZpb3VzIHNpYmxpbmcgZm9yIGluc2VydGlvbiBpbnRvIHRoZSBwYXJlbnQgbm9k ZQotICAgIC8vIGJ5IHNlYXJjaGluZyBpbiByZW5kZXIgdHJlZSBvcmRlciBmb3IgYSBjaGlsZCBv ZiB0aGUgY291bnRlci4KLSAgICBwYXJlbnQgPSAwOworICAgIFJlbmRlck9iamVjdCogc2VhcmNo RW5kUmVuZGVyZXIgPSBwcmV2aW91c1NpYmxpbmdPclBhcmVudChjb3VudGVyT3duZXIpOworICAg IFJlbmRlck9iamVjdCogY3VycmVudFJlbmRlcmVyID0gY291bnRlck93bmVyLT5wcmV2aW91c0lu UHJlT3JkZXIoKTsKICAgICBwcmV2aW91c1NpYmxpbmcgPSAwOwotICAgIFJlbmRlck9iamVjdCog cmVzZXRDYW5kaWRhdGUgPSBpc1Jlc2V0ID8gb2JqZWN0LT5wYXJlbnQoKSA6IHByZXZpb3VzU2li bGluZ09yUGFyZW50KG9iamVjdCk7Ci0gICAgUmVuZGVyT2JqZWN0KiBwcmV2Q291bnRlckNhbmRp ZGF0ZSA9IG9iamVjdDsKLSAgICBDb3VudGVyTm9kZSogY2FuZGlkYXRlQ291bnRlciA9IDA7Ci0g ICAgLy8gV2hlbiBhIHJlc2V0IGNvdW50ZXIgaXMgY2hvc2VuIGFzIGNhbmRpZGF0ZUNvdW50ZXIs IHdlJ2xsCi0gICAgLy8gZGVjaWRlIHRoZSBuZXcgbm9kZSBzaG91bGQgYmUgYSBjaGlsZCBvZiB0 aGUgcmVzZXQgbm9kZSBvciBhCi0gICAgLy8gc2libGluZyBvciB0aGUgcmVzZXQgbm9kZS4gVGhp cyBmbGFnIGNvbnRyb2xzIGl0LgotICAgIGJvb2wgY3JlYXRlQ2hpbGRGb3JSZXNldCA9IHRydWU7 Ci0gICAgd2hpbGUgKChwcmV2Q291bnRlckNhbmRpZGF0ZSA9IHByZXZDb3VudGVyQ2FuZGlkYXRl LT5wcmV2aW91c0luUHJlT3JkZXIoKSkpIHsKLSAgICAgICAgQ291bnRlck5vZGUqIGMgPSBjb3Vu dGVyKHByZXZDb3VudGVyQ2FuZGlkYXRlLCBjb3VudGVyTmFtZSwgZmFsc2UpOwotICAgICAgICBp ZiAocHJldkNvdW50ZXJDYW5kaWRhdGUgPT0gcmVzZXRDYW5kaWRhdGUpIHsKLSAgICAgICAgICAg IGlmICghY2FuZGlkYXRlQ291bnRlcikgewotICAgICAgICAgICAgICAgIGNhbmRpZGF0ZUNvdW50 ZXIgPSBjOwotICAgICAgICAgICAgICAgIGNyZWF0ZUNoaWxkRm9yUmVzZXQgPSB0cnVlOwotICAg ICAgICAgICAgfQotICAgICAgICAgICAgaWYgKGNhbmRpZGF0ZUNvdW50ZXIpIHsKLSAgICAgICAg ICAgICAgICBpZiAoY3JlYXRlQ2hpbGRGb3JSZXNldCAmJiBjYW5kaWRhdGVDb3VudGVyLT5pc1Jl c2V0KCkpIHsKLSAgICAgICAgICAgICAgICAgICAgcGFyZW50ID0gY2FuZGlkYXRlQ291bnRlcjsK LSAgICAgICAgICAgICAgICAgICAgcHJldmlvdXNTaWJsaW5nID0gMDsKKyAgICB3aGlsZSAoY3Vy cmVudFJlbmRlcmVyKSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBjdXJyZW50Q291bnRlciA9IGNv dW50ZXIoY3VycmVudFJlbmRlcmVyLCBjb3VudGVyTmFtZSwgZmFsc2UpOworICAgICAgICBpZiAo c2VhcmNoRW5kUmVuZGVyZXIgPT0gY3VycmVudFJlbmRlcmVyKSB7CisgICAgICAgICAgICBpZihj dXJyZW50Q291bnRlcikgeworICAgICAgICAgICAgICAgIGlmIChwcmV2aW91c1NpYmxpbmcpIHsK KyAgICAgICAgICAgICAgICAgICAgaWYoY3VycmVudENvdW50ZXItPmlzUmVzZXQoKSkgeworICAg ICAgICAgICAgICAgICAgICAgICAgaWYgKGlzUmVzZXQKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAmJiAoY3VycmVudFJlbmRlcmVyLT5wYXJlbnQoKSA9PSBjb3VudGVyT3duZXItPnBhcmVu dCgpKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3Vu dGVyLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxp bmcgPSBjdXJyZW50Q291bnRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4g cGFyZW50OworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAg ICAgcGFyZW50ID0gY3VycmVudENvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgICAgICBBU1NF UlQocHJldmlvdXNTaWJsaW5nLT5wYXJlbnQoKSA9PSBjdXJyZW50Q291bnRlcik7CisgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICBpZiAoIWlzUmVzZXQKKyAgICAgICAgICAgICAgICAgICAgICAgIHx8 IChjdXJyZW50UmVuZGVyZXItPnBhcmVudCgpICE9IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7 CisgICAgICAgICAgICAgICAgICAgICAgICBBU1NFUlQoY3VycmVudENvdW50ZXItPnBhcmVudCgp ID09IHByZXZpb3VzU2libGluZy0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICAgICAg cGFyZW50ID0gY3VycmVudENvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICB9 IGVsc2UgewotICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjYW5kaWRhdGVDb3VudGVyLT5w YXJlbnQoKTsKLSAgICAgICAgICAgICAgICAgICAgcHJldmlvdXNTaWJsaW5nID0gY2FuZGlkYXRl Q291bnRlcjsKKyAgICAgICAgICAgICAgICAgICAgaWYoY3VycmVudENvdW50ZXItPmlzUmVzZXQo KSkgeworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGlzUmVzZXQKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAmJiAoY3VycmVudFJlbmRlcmVyLT5wYXJlbnQoKSA9PSBjb3VudGVyT3du ZXItPnBhcmVudCgpKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1 cnJlbnRDb3VudGVyLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcmV2 aW91c1NpYmxpbmcgPSBjdXJyZW50Q291bnRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZXR1cm4gcGFyZW50OworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg ICAgICAgICAgICAgcGFyZW50ID0gY3VycmVudENvdW50ZXI7CisgICAgICAgICAgICAgICAgICAg ICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAg ICAgICBpZiAoIWlzUmVzZXQKKyAgICAgICAgICAgICAgICAgICAgICAgIHx8IChjdXJyZW50UmVu ZGVyZXItPnBhcmVudCgpICE9IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAg ICAgICAgICAgICAgICBwYXJlbnQgPSBjdXJyZW50Q291bnRlci0+cGFyZW50KCk7CisgICAgICAg ICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSBjdXJyZW50Q291bnRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRDb3VudGVyOwogICAg ICAgICAgICAgICAgIH0KLSAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICAgICAgICAg IH0KLSAgICAgICAgICAgIHJlc2V0Q2FuZGlkYXRlID0gcHJldmlvdXNTaWJsaW5nT3JQYXJlbnQo cmVzZXRDYW5kaWRhdGUpOwotICAgICAgICB9IGVsc2UgaWYgKGMpIHsKLSAgICAgICAgICAgIGlm IChjLT5pc1Jlc2V0KCkpIHsKLSAgICAgICAgICAgICAgICBpZiAoYy0+cGFyZW50KCkpIHsKLSAg ICAgICAgICAgICAgICAgICAgLy8gVGhlIG5ldyBub2RlIG1heSBiZSB0aGUgbmV4dCBzaWJsaW5n IG9mIHRoaXMgcmVzZXQgbm9kZS4KLSAgICAgICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JS ZXNldCA9IGZhbHNlOwotICAgICAgICAgICAgICAgICAgICBjYW5kaWRhdGVDb3VudGVyID0gYzsK LSAgICAgICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgICAgICAgICBjcmVhdGVDaGls ZEZvclJlc2V0ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICAgICAgY2FuZGlkYXRlQ291bnRlciA9 IDA7Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgfSBlbHNlIGlmICghY2FuZGlkYXRl Q291bnRlcikgewotICAgICAgICAgICAgICAgIGNyZWF0ZUNoaWxkRm9yUmVzZXQgPSB0cnVlOwot ICAgICAgICAgICAgICAgIGNhbmRpZGF0ZUNvdW50ZXIgPSBjOwotICAgICAgICAgICAgfQotICAg ICAgICB9CisgICAgICAgICAgICBzZWFyY2hFbmRSZW5kZXJlciA9IHByZXZpb3VzU2libGluZ09y UGFyZW50KGN1cnJlbnRSZW5kZXJlcik7CisgICAgICAgIH0gZWxzZSBpZiAoY3VycmVudENvdW50 ZXIgJiYgKCFwcmV2aW91c1NpYmxpbmcgfHwgY3VycmVudENvdW50ZXItPmlzUmVzZXQoKSkpCisg ICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSBjdXJyZW50Q291bnRlcjsKKyAgICAgICAgaWYo cHJldmlvdXNTaWJsaW5nKQorICAgICAgICAgICAgY3VycmVudFJlbmRlcmVyID0gcHJldmlvdXNT aWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAgZWxzZQorICAgICAgICAg ICAgY3VycmVudFJlbmRlcmVyID0gY3VycmVudFJlbmRlcmVyLT5wcmV2aW91c0luUHJlT3JkZXIo KTsKICAgICB9Ci0KICAgICByZXR1cm4gZmFsc2U7CiB9CiAKQEAgLTIwMSwxNSArMjI2LDkgQEAg c3RhdGljIENvdW50ZXJOb2RlKiBjb3VudGVyKFJlbmRlck9iamVjdAogCiAgICAgQ291bnRlck5v ZGUqIG5ld1BhcmVudCA9IDA7CiAgICAgQ291bnRlck5vZGUqIG5ld1ByZXZpb3VzU2libGluZyA9 IDA7Ci0gICAgQ291bnRlck5vZGUqIG5ld05vZGU7Ci0gICAgaWYgKGZpbmRQbGFjZUZvckNvdW50 ZXIob2JqZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50LCBuZXdQcmV2aW91c1Np YmxpbmcpKSB7Ci0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUob2JqZWN0LCBpc1Jl c2V0LCB2YWx1ZSk7Ci0gICAgICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbmV3 UHJldmlvdXNTaWJsaW5nKTsKLSAgICB9IGVsc2UgewotICAgICAgICAvLyBNYWtlIGEgcmVzZXQg bm9kZSBmb3IgY291bnRlcnMgdGhhdCBhcmVuJ3QgaW5zaWRlIGFuIGV4aXN0aW5nIHJlc2V0IG5v ZGUuCi0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUob2JqZWN0LCB0cnVlLCB2YWx1 ZSk7Ci0gICAgfQotCisgICAgQ291bnRlck5vZGUqIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUo b2JqZWN0LCBpc1Jlc2V0LCB2YWx1ZSk7CisgICAgaWYgKGZpbmRQbGFjZUZvckNvdW50ZXIob2Jq ZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50LCBuZXdQcmV2aW91c1NpYmxpbmcp KQorICAgICAgICBuZXdQYXJlbnQtPmluc2VydEFmdGVyKG5ld05vZGUsIG5ld1ByZXZpb3VzU2li bGluZywgY291bnRlck5hbWUuaW1wbCgpKTsKICAgICBDb3VudGVyTWFwKiBub2RlTWFwOwogICAg IGlmIChvYmplY3QtPm1faGFzQ291bnRlck5vZGVNYXApCiAgICAgICAgIG5vZGVNYXAgPSBjb3Vu dGVyTWFwcygpLmdldChvYmplY3QpOwpAQCAtMjE5LDcgKzIzOCwyNyBAQCBzdGF0aWMgQ291bnRl ck5vZGUqIGNvdW50ZXIoUmVuZGVyT2JqZWN0CiAgICAgICAgIG9iamVjdC0+bV9oYXNDb3VudGVy Tm9kZU1hcCA9IHRydWU7CiAgICAgfQogICAgIG5vZGVNYXAtPnNldChjb3VudGVyTmFtZS5pbXBs KCksIG5ld05vZGUpOwotCisgICAgaWYgKG5ld05vZGUtPnBhcmVudCgpIHx8ICFvYmplY3QtPm5l eHRJblByZU9yZGVyKG9iamVjdC0+cGFyZW50KCkpKQorICAgICAgICByZXR1cm4gbmV3Tm9kZTsK KyAgICAvLyBTZWUgaWYgc29tZSBub2RlcyB0aGF0IHdlcmUgcHJldmlvdXNseSBjb3VudGVyIHRy ZWUgcm9vdCBub2RlcworICAgIC8vIHNob3VsZCBiZWNvbWUgY2hpbGRyZW4gb2YgdGhpcyBub2Rl IG5vdy4KKyAgICBDb3VudGVyTWFwczo6aXRlcmF0b3IgZW5kPWNvdW50ZXJNYXBzKCkuZW5kKCk7 CisgICAgZm9yIChDb3VudGVyTWFwczo6aXRlcmF0b3IgaXQgPSBjb3VudGVyTWFwcygpLmJlZ2lu KCk7aXQgIT0gZW5kOworICAgICAgICArK2l0KQorICAgICAgICBpZiAoaXQtPmZpcnN0ICE9IG9i amVjdCkgeworICAgICAgICAgICAgbm9kZU1hcCA9IGl0LT5zZWNvbmQ7CisgICAgICAgICAgICBp ZiAoQ291bnRlck5vZGUqIG5vZGU9bm9kZU1hcC0+Z2V0KGNvdW50ZXJOYW1lLmltcGwoKSkpIHsK KyAgICAgICAgICAgICAgICBpZiAoIW5vZGUtPnBhcmVudCgpCisgICAgICAgICAgICAgICAgICAg ICYmIGZpbmRQbGFjZUZvckNvdW50ZXIoCisgICAgICAgICAgICAgICAgICAgICAgICBjb25zdF9j YXN0PFJlbmRlck9iamVjdCo+KGl0LT5maXJzdCksCisgICAgICAgICAgICAgICAgICAgICAgICBj b3VudGVyTmFtZSwgdHJ1ZSwgbmV3UGFyZW50LAorICAgICAgICAgICAgICAgICAgICAgICAgbmV3 UHJldmlvdXNTaWJsaW5nKSkgeworICAgICAgICAgICAgICAgICAgICBBU1NFUlQobmV3UGFyZW50 ID09IG5ld05vZGUpOworICAgICAgICAgICAgICAgICAgICBuZXdQYXJlbnQtPmluc2VydEFmdGVy KG5vZGUsCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdQcmV2aW91c1NpYmxpbmcsIGNvdW50 ZXJOYW1lLmltcGwoKSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAg ICB9CiAgICAgcmV0dXJuIG5ld05vZGU7CiB9CiAKQEAgLTI3Miw0NyArMzExLDExNiBAQCB2b2lk IFJlbmRlckNvdW50ZXI6OmNhbGNQcmVmV2lkdGhzKGludCBsCiAgICAgUmVuZGVyVGV4dDo6Y2Fs Y1ByZWZXaWR0aHMobGVhZCk7CiB9CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6aW52YWxpZGF0ZSgp Cit2b2lkIFJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUoQXRvbWljU3RyaW5nSW1wbCAqaWRlbnRp ZmllcikKIHsKLSAgICBtX2NvdW50ZXJOb2RlID0gMDsKLSAgICBzZXROZWVkc0xheW91dEFuZFBy ZWZXaWR0aHNSZWNhbGMoKTsKKyAgICBpZiAoIWlkZW50aWZpZXIKKyAgICAgICAgfHwgKG1fY291 bnRlci5pZGVudGlmaWVyKCkgPT0gKGNvbnN0IGNoYXIqKWlkZW50aWZpZXItPmNoYXJhY3RlcnMo KSkpIHsKKyAgICAgICAgbV9jb3VudGVyTm9kZSA9IDA7CisgICAgICAgIHNldE5lZWRzTGF5b3V0 QW5kUHJlZldpZHRoc1JlY2FsYygpOworICAgIH0KIH0KIAotc3RhdGljIHZvaWQgZGVzdHJveUNv dW50ZXJOb2RlQ2hpbGRyZW4oQXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllciwgQ291bnRlck5v ZGUqIG5vZGUpCitzdGF0aWMgdm9pZCBkZXN0cm95Q291bnRlck5vZGVXaXRob3V0TWFwUmVtb3Zh bCgKKyAgICBjb25zdCBSZWZQdHI8QXRvbWljU3RyaW5nSW1wbD4gJmlkZW50aWZpZXIsIENvdW50 ZXJOb2RlKiBub2RlKQogewotICAgIENvdW50ZXJOb2RlKiBwcmV2aW91czsKLSAgICBmb3IgKENv dW50ZXJOb2RlKiBjaGlsZCA9IGxhc3REZXNjZW5kYW50KG5vZGUpOyBjaGlsZCAmJiBjaGlsZCAh PSBub2RlOyBjaGlsZCA9IHByZXZpb3VzKSB7Ci0gICAgICAgIHByZXZpb3VzID0gcHJldmlvdXNJ blByZU9yZGVyKGNoaWxkKTsKLSAgICAgICAgY2hpbGQtPnBhcmVudCgpLT5yZW1vdmVDaGlsZChj aGlsZCk7CisgICAgQ291bnRlck5vZGUqIHRlbXA7CisgICAgZm9yIChDb3VudGVyTm9kZSogY2hp bGQgPSBsYXN0RGVzY2VuZGFudChub2RlKTsgY2hpbGQgJiYgY2hpbGQgIT0gbm9kZTsgY2hpbGQg PSB0ZW1wKSB7CisgICAgICAgIHRlbXAgPSBwcmV2aW91c0luUHJlT3JkZXIoY2hpbGQpOworICAg ICAgICBjaGlsZC0+cGFyZW50KCktPnJlbW92ZUNoaWxkKGNoaWxkLCBpZGVudGlmaWVyLmdldCgp KTsKICAgICAgICAgQVNTRVJUKGNvdW50ZXJNYXBzKCkuZ2V0KGNoaWxkLT5yZW5kZXJlcigpKS0+ Z2V0KGlkZW50aWZpZXIpID09IGNoaWxkKTsKICAgICAgICAgY291bnRlck1hcHMoKS5nZXQoY2hp bGQtPnJlbmRlcmVyKCkpLT5yZW1vdmUoaWRlbnRpZmllcik7CiAgICAgICAgIGlmICghY2hpbGQt PnJlbmRlcmVyKCktPmRvY3VtZW50QmVpbmdEZXN0cm95ZWQoKSkgewogICAgICAgICAgICAgUmVu ZGVyT2JqZWN0Q2hpbGRMaXN0KiBjaGlsZHJlbiA9IGNoaWxkLT5yZW5kZXJlcigpLT52aXJ0dWFs Q2hpbGRyZW4oKTsKICAgICAgICAgICAgIGlmIChjaGlsZHJlbikKLSAgICAgICAgICAgICAgICBj aGlsZHJlbi0+aW52YWxpZGF0ZUNvdW50ZXJzKGNoaWxkLT5yZW5kZXJlcigpKTsKKyAgICAgICAg ICAgICAgICBjaGlsZHJlbi0+aW52YWxpZGF0ZUNvdW50ZXJzKGNoaWxkLT5yZW5kZXJlcigpLCBp ZGVudGlmaWVyLmdldCgpKTsKICAgICAgICAgfQogICAgICAgICBkZWxldGUgY2hpbGQ7CiAgICAg fQorICAgIFJlbmRlck9iamVjdCAqcmVuZGVyZXIgPSBub2RlLT5yZW5kZXJlcigpOworICAgIGlm ICghcmVuZGVyZXItPmRvY3VtZW50QmVpbmdEZXN0cm95ZWQoKSkgeworICAgICAgICBpZiAoUmVu ZGVyT2JqZWN0Q2hpbGRMaXN0KiBjaGlsZHJlbiA9IHJlbmRlcmVyLT52aXJ0dWFsQ2hpbGRyZW4o KSkKKyAgICAgICAgICAgIGNoaWxkcmVuLT5pbnZhbGlkYXRlQ291bnRlcnMocmVuZGVyZXIsIGlk ZW50aWZpZXIuZ2V0KCkpOworICAgIH0KKyAgICBpZiAodGVtcCA9IG5vZGUtPnBhcmVudCgpKQor ICAgICAgICB0ZW1wLT5yZW1vdmVDaGlsZChub2RlLCBpZGVudGlmaWVyLmdldCgpKTsKKyAgICBk ZWxldGUgbm9kZTsKIH0KIAotdm9pZCBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGVz KFJlbmRlck9iamVjdCogb2JqZWN0KQordm9pZCBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRl ck5vZGVzKFJlbmRlck9iamVjdCogcmVuZGVyZXIpCiB7CiAgICAgQ291bnRlck1hcHMmIG1hcHMg PSBjb3VudGVyTWFwcygpOwotICAgIENvdW50ZXJNYXAqIG1hcCA9IG1hcHMuZ2V0KG9iamVjdCk7 CisgICAgQ291bnRlck1hcCogbWFwID0gbWFwcy5nZXQocmVuZGVyZXIpOwogICAgIGlmICghbWFw KQogICAgICAgICByZXR1cm47Ci0gICAgbWFwcy5yZW1vdmUob2JqZWN0KTsKLQogICAgIENvdW50 ZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IG1hcC0+ZW5kKCk7Ci0gICAgZm9yIChDb3VudGVy TWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IG1hcC0+YmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7 Ci0gICAgICAgIENvdW50ZXJOb2RlKiBub2RlID0gaXQtPnNlY29uZDsKLSAgICAgICAgZGVzdHJv eUNvdW50ZXJOb2RlQ2hpbGRyZW4oaXQtPmZpcnN0LmdldCgpLCBub2RlKTsKLSAgICAgICAgaWYg KENvdW50ZXJOb2RlKiBwYXJlbnQgPSBub2RlLT5wYXJlbnQoKSkKLSAgICAgICAgICAgIHBhcmVu dC0+cmVtb3ZlQ2hpbGQobm9kZSk7Ci0gICAgICAgIGRlbGV0ZSBub2RlOwotICAgIH0KKyAgICBm b3IgKENvdW50ZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbWFwLT5iZWdpbigpO2l0ICE9IGVu ZDsrK2l0KQorICAgICAgICBkZXN0cm95Q291bnRlck5vZGVXaXRob3V0TWFwUmVtb3ZhbChpdC0+ Zmlyc3QsIGl0LT5zZWNvbmQpOwogCisgICAgbWFwcy5yZW1vdmUocmVuZGVyZXIpOwogICAgIGRl bGV0ZSBtYXA7CisgICAgcmVuZGVyZXItPm1faGFzQ291bnRlck5vZGVNYXA9ZmFsc2U7CiB9CiAK K3ZvaWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCogcmVu ZGVyZXIsCisgICAgY29uc3QgUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+JiBpZGVudGlmaWVyKQor eworICAgIENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1hcHMoKTsKKyAgICBDb3VudGVyTWFw KiBtYXAgPSBtYXBzLmdldChyZW5kZXJlcik7CisgICAgaWYgKCFtYXApCisgICAgICAgIHJldHVy bjsKKyAgICBDb3VudGVyTm9kZSogbm9kZSA9IG1hcC0+Z2V0KGlkZW50aWZpZXIpOworICAgIGlm IChub2RlKSB7CisgICAgICAgIGRlc3Ryb3lDb3VudGVyTm9kZVdpdGhvdXRNYXBSZW1vdmFsKGlk ZW50aWZpZXIsIG5vZGUpOworICAgICAgICBtYXAtPnJlbW92ZShpZGVudGlmaWVyKTsKKy8vIERv IG5vdCBkZWxldGUgbWFwIGV2ZW4gaWYgZW1wdHkgYXMgdGhlIGV4cGVjdGF0aW9uIGlzIHRoYXQg c29vbiBub2RlcyB3aWxsIGJlIGFkZGVkCisvLyB0byB0aGUgbWFwLCBvciBvdGhlcndpc2UgZGVz dHJveUNvdW50ZXJOb2RlcyB3b3VsZCBoYXZlIGJlZW4gY2FsbGVkIGluc3RlYWQuCisgICAgfQor fQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmNyZWF0ZUNvdW50ZXJJZk5lZWRlZChSZW5kZXJPYmpl Y3QqIHJlbmRlcmVyLAorICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpCit7 CisgICAgY291bnRlcihyZW5kZXJlciwgaWRlbnRpZmllciwgZmFsc2UpOworfQorCit2b2lkIFJl bmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKFJlbmRlck9iamVjdCogcmVuZGVyZXIpCit7Cisg ICAgdXBkYXRlQ291bnRlcihyZW5kZXJlcik7CisgICAgZm9yIChSZW5kZXJPYmplY3QqIGNoaWxk ID0gcmVuZGVyZXItPm5leHRJblByZU9yZGVyKHJlbmRlcmVyKTsKKyAgICAgICAgY2hpbGQ7IGNo aWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyKHJlbmRlcmVyKSkKKyAgICAgICAgdXBkYXRlQ291 bnRlcihjaGlsZCk7Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcihSZW5k ZXJPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQob2JqZWN0LT5zdHlsZSgpKTsKKyAgICBp ZiAoIW9iamVjdC0+cGFyZW50KCkgJiYgIW9iamVjdC0+bmV4dEluUHJlT3JkZXIoKSkKKyAgICAg ICAgcmV0dXJuOworICAgIGlmIChjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBwQ291bnRlckRp cmVjdGl2ZU1hcCA9CisgICAgICAgIG9iamVjdC0+c3R5bGUoKS0+Y291bnRlckRpcmVjdGl2ZXMo KSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPQor ICAgICAgICAgICAgcENvdW50ZXJEaXJlY3RpdmVNYXAtPmVuZCgpOworICAgICAgICBDb3VudGVy TWFwKiBjb3VudGVyTWFwID0gY291bnRlck1hcHMoKS5nZXQob2JqZWN0KTsKKyAgICAgICAgZm9y IChDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IHBDb3VudGVyRGlyZWN0 aXZlTWFwLT5iZWdpbigpOworICAgICAgICAgICAgaXQgIT0gZW5kOyArK2l0KQorICAgICAgICAg ICAgaWYgKGNvdW50ZXJNYXApCisgICAgICAgICAgICAgICAgaWYoQ291bnRlck5vZGUgKm5vZGUg PSBjb3VudGVyTWFwLT5nZXQoaXQtPmZpcnN0LmdldCgpKSkgeworICAgICAgICAgICAgICAgICAg ICBDb3VudGVyTm9kZSogbmV3UGFyZW50PTA7CisgICAgICAgICAgICAgICAgICAgIENvdW50ZXJO b2RlKiBuZXdQcmV2aW91c1NpYmxpbmc7CisgICAgICAgICAgICAgICAgICAgIGZpbmRQbGFjZUZv ckNvdW50ZXIob2JqZWN0LAorICAgICAgICAgICAgICAgICAgICAgICAgQXRvbWljU3RyaW5nKGl0 LT5maXJzdC5nZXQoKSksIG5vZGUtPmlzVHlwZVJlc2V0KCksCisgICAgICAgICAgICAgICAgICAg ICAgICBuZXdQYXJlbnQsIG5ld1ByZXZpb3VzU2libGluZyk7CisgICAgICAgICAgICAgICAgICAg IGlmICgobmV3UGFyZW50ICE9IG5vZGUtPnBhcmVudCgpKQorICAgICAgICAgICAgICAgICAgICAg ICAgfHwgKG5ld1ByZXZpb3VzU2libGluZyAhPSBub2RlLT5wcmV2aW91c1NpYmxpbmcoKSkpIHsK KyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChub2RlLT5wYXJlbnQoKSkKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICBub2RlLT5wYXJlbnQoKS0+cmVtb3ZlQ2hpbGQobm9kZSwgaXQtPmZp cnN0LmdldCgpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0 ZXIobm9kZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBuZXdQcmV2aW91c1NpYmxpbmcs IGl0LT5maXJzdC5nZXQoKSk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICB9IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgY291bnRlcihvYmplY3QsIEF0b21pY1N0cmlu ZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxzZSk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgICAgY291bnRlcihvYmplY3QsIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxz ZSk7CisgICAgfQorfQogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckNvdW50ZXIuaAkocmV2aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJDb3VudGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTMzLDEwICszMyw0MiBAQCBjbGFzcyBSZW5k ZXJDb3VudGVyIDogcHVibGljIFJlbmRlclRleHQgCiBwdWJsaWM6CiAgICAgUmVuZGVyQ291bnRl cihEb2N1bWVudCosIGNvbnN0IENvdW50ZXJDb250ZW50Jik7CiAKLSAgICB2b2lkIGludmFsaWRh dGUoKTsKLQorICAgIC8qIEludmFsaWRhdGVzIHRoZSBjb3VudGVyIGlmIGl0IGhhcyB0aGUgZ2l2 ZW4gaWRlbnRpZmllci4KKyAgICAgKiBJZiB0aGUgZ2l2ZW4gaWRlbnRpZmllciBpcyBOVUxMIGl0 IGludmFsaWRhdGVzIHRoZSAKKyAgICAgKiBjb3VudGVyIHVuY29uZGl0aW9uYWxseS4KKyAgICAg Ki8KKyAgICB2b2lkIGludmFsaWRhdGUoQXRvbWljU3RyaW5nSW1wbCAqaWRlbnRpZmllciA9IDAp OworCisgICAgLyogRGVzdHJveXMgYWxsIENvdW50ZXJOb2RlcyBhc3NvY2lhdGVkIHdpdGggdGhl IHJlbmRlcmVyIHBhc3NlZCBhcyAKKyAgICAgKiBhcmd1bWVudCBhbmQgYWxsIHRoZSBjaGlsZCBu b2RlcyBvZiB0aG9zZSBub2RlcworICAgICAqLwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3Vu dGVyTm9kZXMoUmVuZGVyT2JqZWN0Kik7CiAKKyAgICAvKiBEZXN0cm95cyB0aGUgQ291bnRlck5v ZGUgd2l0aCB0aGUgZ2l2ZW4gaWRlbnRpZmllciBhc3NvY2lhdGVkIHdpdGggdGhlIAorICAgICAq IHJlbmRlcmVyIHBhc3NlZCBhcyB0aGUgZmlyc3QgYXJndW1lbnQgYW5kIGFsbCB0aGUgY2hpbGQg bm9kZXMgb2YgdGhhdCAKKyAgICAgKiBub2RlLgorICAgICAqLworICAgIHN0YXRpYyB2b2lkIGRl c3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBjb25zdAorICAgICAgICBSZWZQdHI8QXRv bWljU3RyaW5nSW1wbD4mIGlkZW50aWZpZXIpOworCisgICAgLyogQ3JlYXRlcyBhIG5ldyBjb3Vu dGVyIGF0dGFjaGVkIHRvIHRoZSByZW5kZXJlciBwYXNzZWQgaW4KKyAgICAgKiBmb3IgdGhlIGlk ZW50aWZpZXIgcGFzc2VkIGluIGlmIGl0IGRvZXMgbm90IGFscmVhZHkgZXhpc3QgYW5kCisgICAg ICogaXQgaXMgZGVmaW5lZCBieSB0aGUgcmVuZGVyZXIncyBzdHlsZS4KKyAgICAgKi8KKyAgICBz dGF0aWMgdm9pZCBjcmVhdGVDb3VudGVySWZOZWVkZWQoUmVuZGVyT2JqZWN0KiwKKyAgICAgICAg Y29uc3QgQXRvbWljU3RyaW5nJik7CisKKyAgICAvKiBVcGRhdGVzIHRoZSBjb3VudGVycyBhdHRh Y2hlZCB0byB0aGUgcmVuZGVyZXIgcGFzc2VkIGluIGFuZAorICAgICAqIHRob3NlIGF0dGFjaGVk IHRvIGl0cyBkZXNjZW5kYW50cy4KKyAgICAgKi8KKyAgICBzdGF0aWMgdm9pZCB1cGRhdGVDb3Vu dGVycyhSZW5kZXJPYmplY3QqKTsKKworICAgIC8qIFVwZGF0ZXMgdGhlIGNvdW50ZXJzIGF0dGFj aGVkIHRvIHRoZSByZW5kZXJlciBwYXNzZWQgaW4gd2hvc2UKKyAgICAgKiBuYW1lcyBhcHBlYXIg aW4gdGhlIGNvdW50ZXIgZGlyZWN0aXZlcyBvZiB0aGUgc3R5bGUKKyAgICAgKiBvZiB0aGUgcmVu ZGVyZXIuCisgICAgICovCisgICAgc3RhdGljIHZvaWQgdXBkYXRlQ291bnRlcihSZW5kZXJPYmpl Y3QqKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUoKSBj b25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3Q7CkluZGV4OiBXZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVy aW5nL1JlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDUwNTIyKQorKysgV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzA0LDcgKzMwNCw3IEBAIHZv aWQgUmVuZGVyT2JqZWN0OjphZGRDaGlsZChSZW5kZXJPYmplY3QKICAgICAgICAgLy8gSnVzdCBh ZGQgaXQuLi4KICAgICAgICAgY2hpbGRyZW4tPmluc2VydENoaWxkTm9kZSh0aGlzLCBuZXdDaGls ZCwgYmVmb3JlQ2hpbGQpOwogICAgIH0KLSAgICAKKyAgICBSZW5kZXJDb3VudGVyOjp1cGRhdGVD b3VudGVycyhuZXdDaGlsZCk7CiAgICAgaWYgKG5ld0NoaWxkLT5pc1RleHQoKSAmJiBuZXdDaGls ZC0+c3R5bGUoKS0+dGV4dFRyYW5zZm9ybSgpID09IENBUElUQUxJWkUpIHsKICAgICAgICAgUmVm UHRyPFN0cmluZ0ltcGw+IHRleHRUb1RyYW5zZm9ybSA9IHRvUmVuZGVyVGV4dChuZXdDaGlsZCkt Pm9yaWdpbmFsVGV4dCgpOwogICAgICAgICBpZiAodGV4dFRvVHJhbnNmb3JtKQpAQCAtMTQ4Niwy MCArMTQ4Niw4MiBAQCB2b2lkIFJlbmRlck9iamVjdDo6c2V0U3R5bGUoUGFzc1JlZlB0cjxSCiAg ICAgZGlmZiA9IGFkanVzdFN0eWxlRGlmZmVyZW5jZShkaWZmLCBjb250ZXh0U2Vuc2l0aXZlUHJv cGVydGllcyk7CiAKICAgICBzdHlsZVdpbGxDaGFuZ2UoZGlmZiwgc3R5bGUuZ2V0KCkpOwotICAg IAorCiAgICAgUmVmUHRyPFJlbmRlclN0eWxlPiBvbGRTdHlsZSA9IG1fc3R5bGUucmVsZWFzZSgp OwogICAgIG1fc3R5bGUgPSBzdHlsZTsKIAotICAgIHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUg PyBvbGRTdHlsZS0+YmFja2dyb3VuZExheWVycygpIDogMCwgbV9zdHlsZSA/IG1fc3R5bGUtPmJh Y2tncm91bmRMYXllcnMoKSA6IDApOwotICAgIHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUgPyBv bGRTdHlsZS0+bWFza0xheWVycygpIDogMCwgbV9zdHlsZSA/IG1fc3R5bGUtPm1hc2tMYXllcnMo KSA6IDApOwotCi0gICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUgPyBvbGRTdHlsZS0+Ym9yZGVySW1h Z2UoKS5pbWFnZSgpIDogMCwgbV9zdHlsZSA/IG1fc3R5bGUtPmJvcmRlckltYWdlKCkuaW1hZ2Uo KSA6IDApOwotICAgIHVwZGF0ZUltYWdlKG9sZFN0eWxlID8gb2xkU3R5bGUtPm1hc2tCb3hJbWFn ZSgpLmltYWdlKCkgOiAwLCBtX3N0eWxlID8gbV9zdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2Uo KSA6IDApOworICAgIGlmIChvbGRTdHlsZSkgeworICAgICAgICBpZiAobV9zdHlsZSkgeworICAg ICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJEaXJlY3RpdmVNYXAqIHBDb3VudGVyRGlyZWN0aXZl TWFwID0KKyAgICAgICAgICAgICAgICBtX3N0eWxlLT5jb3VudGVyRGlyZWN0aXZlcygpKSB7Cisg ICAgICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJEaXJlY3RpdmVNYXAqIHBPbGRDb3VudGVy RGlyZWN0aXZlTWFwCisgICAgICAgICAgICAgICAgICAgID1vbGRTdHlsZS0+Y291bnRlckRpcmVj dGl2ZXMoKSkgeworICAgICAgICAgICAgICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25z dF9pdGVyYXRvciBlbmQgPQorICAgICAgICAgICAgICAgICAgICAgICAgcENvdW50ZXJEaXJlY3Rp dmVNYXAtPmVuZCgpOworICAgICAgICAgICAgICAgICAgICBmb3IgKENvdW50ZXJEaXJlY3RpdmVN YXA6OmNvbnN0X2l0ZXJhdG9yIGl0ICAgICAgICAgICAgICAgICA9IHBDb3VudGVyRGlyZWN0aXZl TWFwLT5iZWdpbigpOworICAgICAgICAgICAgICAgICAgICAgICAgaXQgIT0gZW5kOyArK2l0KSB7 CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAocE9sZENvdW50ZXJEaXJlY3RpdmVNYXAtPmNv bnRhaW5zKGl0LT5maXJzdCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAocE9s ZENvdW50ZXJEaXJlY3RpdmVNYXAtPmdldChpdC0+Zmlyc3QpCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICE9IGl0LT5zZWNvbmQpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZSh0aGlzLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgaXQtPmZpcnN0KTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6 ZGVzdHJveUNvdW50ZXJOb2RlKHRoaXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGl0LT5maXJzdCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6 Y3JlYXRlQ291bnRlcklmTmVlZGVkKHRoaXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkpKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICBlbmQgPSBw T2xkQ291bnRlckRpcmVjdGl2ZU1hcC0+ZW5kKCk7CisgICAgICAgICAgICAgICAgICAgIGZvciAo Q291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQKKyAgICAgICAgICAgICAgICAg ICAgICAgID0gcE9sZENvdW50ZXJEaXJlY3RpdmVNYXAtPmJlZ2luKCk7CisgICAgICAgICAgICAg ICAgICAgICAgICBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAo IXBDb3VudGVyRGlyZWN0aXZlTWFwLT5jb250YWlucyhpdC0+Zmlyc3QpKQorICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZSh0aGlzLCBp dC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAg IFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZXModGhpcyk7CisgICAgICAgICAgICAg ICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKHRoaXMpOworICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAobV9oYXNDb3VudGVyTm9kZU1hcCkKKyAgICAg ICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGVzKHRoaXMpOwogCi0g ICAgLy8gV2UgbmVlZCB0byBlbnN1cmUgdGhhdCB2aWV3LT5tYXhpbWFsT3V0bGluZVNpemUoKSBp cyB2YWxpZCBmb3IgYW55IHJlcGFpbnRzIHRoYXQgaGFwcGVuCi0gICAgLy8gZHVyaW5nIHN0eWxl RGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92ZXJmbG93UmVjdEZvclJlcGFpbnQoKSku Ci0gICAgaWYgKG1fc3R5bGUtPm91dGxpbmVXaWR0aCgpID4gMCAmJiBtX3N0eWxlLT5vdXRsaW5l U2l6ZSgpID4gbWF4aW1hbE91dGxpbmVTaXplKFBhaW50UGhhc2VPdXRsaW5lKSkKLSAgICAgICAg dG9SZW5kZXJWaWV3KGRvY3VtZW50KCktPnJlbmRlcmVyKCkpLT5zZXRNYXhpbWFsT3V0bGluZVNp emUobV9zdHlsZS0+b3V0bGluZVNpemUoKSk7CisgICAgICAgICAgICB1cGRhdGVGaWxsSW1hZ2Vz KG9sZFN0eWxlLT5iYWNrZ3JvdW5kTGF5ZXJzKCksCisgICAgICAgICAgICAgICAgbV9zdHlsZS0+ YmFja2dyb3VuZExheWVycygpKTsKKyAgICAgICAgICAgIHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5 bGUtPm1hc2tMYXllcnMoKSwgbV9zdHlsZS0+bWFza0xheWVycygpKTsKKworICAgICAgICAgICAg dXBkYXRlSW1hZ2Uob2xkU3R5bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSwKKyAgICAgICAgICAg ICAgICBtX3N0eWxlLT5ib3JkZXJJbWFnZSgpLmltYWdlKCkpOworICAgICAgICAgICAgdXBkYXRl SW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCksCisgICAgICAgICAgICAgICAg bV9zdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSk7CisgICAgICAgICAgICAvLyBXZSBuZWVk IHRvIGVuc3VyZSB0aGF0IHZpZXctPm1heGltYWxPdXRsaW5lU2l6ZSgpIGlzIHZhbGlkIGZvciAK KyAgICAgICAgICAgIC8vIGFueSByZXBhaW50cyB0aGF0IGhhcHBlbiBkdXJpbmcgc3R5bGVEaWRD aGFuZ2UgKGl0J3MgdXNlZCBieQorICAgICAgICAgICAgLy8gY2xpcHBlZE92ZXJmbG93UmVjdEZv clJlcGFpbnQoKSkuCisgICAgICAgICAgICBpZiAobV9zdHlsZS0+b3V0bGluZVdpZHRoKCkgPiAw ICYmIG1fc3R5bGUtPm91dGxpbmVTaXplKCkgPgorICAgICAgICAgICAgICAgIG1heGltYWxPdXRs aW5lU2l6ZShQYWludFBoYXNlT3V0bGluZSkpIHsKKyAgICAgICAgICAgICAgICB0b1JlbmRlclZp ZXcoZG9jdW1lbnQoKS0+cmVuZGVyZXIoKSktPnNldE1heGltYWxPdXRsaW5lU2l6ZSgKKyAgICAg ICAgICAgICAgICAgICAgbV9zdHlsZS0+b3V0bGluZVNpemUoKSk7CisgICAgICAgICAgICB9Cisg ICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBpZiAobV9oYXNDb3VudGVyTm9kZU1hcCkKKyAg ICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGVzKHRoaXMpOwor ICAgICAgICAgICAgdXBkYXRlRmlsbEltYWdlcyhvbGRTdHlsZS0+YmFja2dyb3VuZExheWVycygp LCAwKTsKKyAgICAgICAgICAgIHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUtPm1hc2tMYXllcnMo KSwgMCk7CisKKyAgICAgICAgICAgIHVwZGF0ZUltYWdlKG9sZFN0eWxlLT5ib3JkZXJJbWFnZSgp LmltYWdlKCksIDApOworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJ bWFnZSgpLmltYWdlKCksIDApOworICAgICAgICB9CisgICAgfSBlbHNlIGlmIChtX3N0eWxlKSB7 CisgICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXIodGhpcyk7CisgICAgICAgIHVw ZGF0ZUZpbGxJbWFnZXMoMCwgbV9zdHlsZS0+YmFja2dyb3VuZExheWVycygpKTsKKyAgICAgICAg dXBkYXRlRmlsbEltYWdlcygwLCBtX3N0eWxlLT5tYXNrTGF5ZXJzKCkpOworCisgICAgICAgIHVw ZGF0ZUltYWdlKDAsIG1fc3R5bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSk7CisgICAgICAgIHVw ZGF0ZUltYWdlKDAsIG1fc3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCkpOworICAgICAgICAv LyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1heGltYWxPdXRsaW5lU2l6ZSgpIGlzIHZh bGlkIGZvciBhbnkgcmVwYWludHMgdGhhdCBoYXBwZW4KKyAgICAgICAgLy8gZHVyaW5nIHN0eWxl RGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92ZXJmbG93UmVjdEZvclJlcGFpbnQoKSku CisgICAgICAgIGlmIChtX3N0eWxlLT5vdXRsaW5lV2lkdGgoKSA+IDAgJiYgbV9zdHlsZS0+b3V0 bGluZVNpemUoKSA+IG1heGltYWxPdXRsaW5lU2l6ZShQYWludFBoYXNlT3V0bGluZSkpCisgICAg ICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+cmVuZGVyZXIoKSktPnNldE1heGltYWxP dXRsaW5lU2l6ZShtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpKTsKKyAgICB9CiAKICAgICBzdHlsZURp ZENoYW5nZShkaWZmLCBvbGRTdHlsZS5nZXQoKSk7CiAKQEAgLTE2MDgsNyArMTY3MCw3IEBAIHZv aWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShTdHlsZUQKIAogICAgIGlmICghbV9wYXJl bnQpCiAgICAgICAgIHJldHVybjsKLSAgICAKKwogICAgIGlmIChkaWZmID09IFN0eWxlRGlmZmVy ZW5jZUxheW91dCkKICAgICAgICAgc2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7 CiAgICAgZWxzZSBpZiAoZGlmZiA9PSBTdHlsZURpZmZlcmVuY2VMYXlvdXRQb3NpdGlvbmVkTW92 ZW1lbnRPbmx5KQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0 LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExp c3QuY3BwCShyZXZpc2lvbiA1MDUyMikKKysrIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVj dENoaWxkTGlzdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI3MSwyNCArMjcxLDI5IEBAIHN0YXRp YyBSZW5kZXJPYmplY3QqIGZpbmRCZWZvcmVBZnRlclBhcmUKICAgICByZXR1cm4gYmVmb3JlQWZ0 ZXJQYXJlbnQ7CiB9CiAKLXN0YXRpYyB2b2lkIGludmFsaWRhdGVDb3VudGVyc0luQ29udGFpbmVy KFJlbmRlck9iamVjdCogY29udGFpbmVyKQorc3RhdGljIHZvaWQgaW52YWxpZGF0ZUNvdW50ZXJz SW5Db250YWluZXIoUmVuZGVyT2JqZWN0KiBjb250YWluZXIsIEF0b21pY1N0cmluZ0ltcGwqIGlk ZW50aWZpZXIpCiB7CiAgICAgaWYgKCFjb250YWluZXIpCiAgICAgICAgIHJldHVybjsKICAgICBj b250YWluZXIgPSBmaW5kQmVmb3JlQWZ0ZXJQYXJlbnQoY29udGFpbmVyKTsKICAgICBpZiAoIWNv bnRhaW5lcikKICAgICAgICAgcmV0dXJuOworICAgLy9Tb21ldGltZXMgdGhlIGNvdW50ZXIgaXMg YXR0YWNoZWQgZGlyZWN0bHkgb24gdGhlIGNvbnRhaW5lci4KKyAgICBpZiAoY29udGFpbmVyLT5p c0NvdW50ZXIoKSkgeworICAgICAgICB0b1JlbmRlckNvdW50ZXIoY29udGFpbmVyKS0+aW52YWxp ZGF0ZShpZGVudGlmaWVyKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KICAgICBmb3IgKFJlbmRl ck9iamVjdCogY29udGVudCA9IGNvbnRhaW5lci0+Zmlyc3RDaGlsZCgpOyBjb250ZW50OyBjb250 ZW50ID0gY29udGVudC0+bmV4dFNpYmxpbmcoKSkgewogICAgICAgICBpZiAoY29udGVudC0+aXND b3VudGVyKCkpCi0gICAgICAgICAgICB0b1JlbmRlckNvdW50ZXIoY29udGVudCktPmludmFsaWRh dGUoKTsKKyAgICAgICAgICAgIHRvUmVuZGVyQ291bnRlcihjb250ZW50KS0+aW52YWxpZGF0ZShp ZGVudGlmaWVyKTsKICAgICB9CiB9CiAKLXZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnZh bGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lcikKK3ZvaWQgUmVuZGVyT2JqZWN0Q2hp bGRMaXN0OjppbnZhbGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lciwgQXRvbWljU3Ry aW5nSW1wbCogaWRlbnRpZmllcikKIHsKICAgICBBU1NFUlQoIW93bmVyLT5kb2N1bWVudEJlaW5n RGVzdHJveWVkKCkpOwotICAgIGludmFsaWRhdGVDb3VudGVyc0luQ29udGFpbmVyKGJlZm9yZUFm dGVyQ29udGFpbmVyKG93bmVyLCBCRUZPUkUpKTsKLSAgICBpbnZhbGlkYXRlQ291bnRlcnNJbkNv bnRhaW5lcihiZWZvcmVBZnRlckNvbnRhaW5lcihvd25lciwgQUZURVIpKTsKKyAgICBpbnZhbGlk YXRlQ291bnRlcnNJbkNvbnRhaW5lcihiZWZvcmVBZnRlckNvbnRhaW5lcihvd25lciwgQkVGT1JF KSwgaWRlbnRpZmllcik7CisgICAgaW52YWxpZGF0ZUNvdW50ZXJzSW5Db250YWluZXIoYmVmb3Jl QWZ0ZXJDb250YWluZXIob3duZXIsIEFGVEVSKSwgaWRlbnRpZmllcik7CiB9CiAKIHZvaWQgUmVu ZGVyT2JqZWN0Q2hpbGRMaXN0Ojp1cGRhdGVCZWZvcmVBZnRlckNvbnRlbnQoUmVuZGVyT2JqZWN0 KiBvd25lciwgUHNldWRvSWQgdHlwZSwgUmVuZGVyT2JqZWN0KiBzdHlsZWRPYmplY3QpCkluZGV4 OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaAkocmV2aXNpb24gNTA1 MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaAkod29ya2lu ZyBjb3B5KQpAQCAtMzEsNiArMzEsNyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBS ZW5kZXJPYmplY3Q7CitjbGFzcyBBdG9taWNTdHJpbmdJbXBsOwogCiBjbGFzcyBSZW5kZXJPYmpl Y3RDaGlsZExpc3QgewogcHVibGljOgpAQCAtNTUsNyArNTYsMTEgQEAgcHVibGljOgogICAgIHZv aWQgaW5zZXJ0Q2hpbGROb2RlKFJlbmRlck9iamVjdCogb3duZXIsIFJlbmRlck9iamVjdCogY2hp bGQsIFJlbmRlck9iamVjdCogYmVmb3JlLCBib29sIGZ1bGxJbnNlcnQgPSB0cnVlKTsKIAogICAg IHZvaWQgdXBkYXRlQmVmb3JlQWZ0ZXJDb250ZW50KFJlbmRlck9iamVjdCogb3duZXIsIFBzZXVk b0lkIHR5cGUsIFJlbmRlck9iamVjdCogc3R5bGVkT2JqZWN0ID0gMCk7Ci0gICAgdm9pZCBpbnZh bGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lcik7CisKKyAgICAvKiBJbnZhbGlkYXRl cyBhbGwgY291bnRlcnMgd2l0aCB0aGUgZ2l2ZW4gaWRlbnRpZmllciBpbiBjaGlsZHJlbiBvZiBv d25lci4KKyAgICAgKiBJZiBpZGVudGlmaWVyIGlzIE5VTEwgKGRlZmF1bHQpIGFsbCBjb3VudGVy cyBhcmUgaW52YWxpZGF0ZWQKKyAgICAgKi8KKyAgICB2b2lkIGludmFsaWRhdGVDb3VudGVycyhS ZW5kZXJPYmplY3QqIG93bmVyLCBBdG9taWNTdHJpbmdJbXBsICppZGVudGlmaWVyID0gMCk7CiAK IHByaXZhdGU6CiAgICAgUmVuZGVyT2JqZWN0KiBtX2ZpcnN0Q2hpbGQ7CkluZGV4OiBMYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZp c2lvbiA1MDU3OSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAt MSwzICsxLDE4IEBACisyMDA5LTExLTA1ICBDYXJvbCBTemFibyAgPGNhcm9sLnN6YWJvQG5va2lh LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB bm90aGVyIGNyYXp5IGNvdW50ZXJzIGJ1ZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTEwMzEKKyAgICAgICAgQWRkZWQgdGVzdHMgZm9yIGR5bmFtaWMg RE9NIGNoYW5nZXMgYWZmZWN0aW5nIGNvdW50ZXJzLgorCisgICAgICAgICogY3NzMi4xL2NvdW50 ZXItaW5jcmVtZW50LTAwMi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBjc3MyLjEvY291bnRlci1y ZXNldC0wMDAuaHRtbDogQWRkZWQuCisgICAgICAgICogY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAy Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLWluY3Jl bWVudC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9xdC9jc3My LjEvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0 Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKwog MjAwOS0xMS0wNSAgU2h1IENoYW5nICA8Q2hhbmcuU2h1QG5va2lhLmNvbT4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGVsZSBQZXRlcnNvbi4KSW5kZXg6IExheW91dFRlc3RzL2NzczIuMS9jb3Vu dGVyLWluY3JlbWVudC0wMDIuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9jc3MyLjEv Y291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9j c3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs MzQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+ Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRl bnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5h bWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVs PSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9u Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIx L2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0 cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgor ICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3lu ZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3Mi PgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4 dC9jc3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRl bnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAg ICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7 IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUsIC51c2U6YmVm b3JlIHsgY29udGVudDogY291bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVu dCB7IGNvdW50ZXItaW5jcmVtZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7 CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoIm9uZSIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAgICAgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgImluY3Jl bWVudCIpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRocmVlIikuc2V0 QXR0cmlidXRlKCJzdHlsZSIsICJjb3VudGVyLWluY3JlbWVudDogYyIpOworICAgICAgICAgICAg aWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgIH0KKyAgICA8L3NjcmlwdD4KKzwv aGVhZD48Ym9keSBvbmxvYWQ9InNldFRpbWVvdXQoJ3J1bigpJywgMCkiPgorICAgIDxwPlRoZSBm b2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZTo8L3A+CisgICAgPGRpdiBpZD0i dGVzdCI+PHNwYW4gaWQ9Im9uZSI+PC9zcGFuPjxzcGFuPjxzcGFuIGNsYXNzPSJyZXNldCI+PHNw YW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiIGlkPSJ0 d28iPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjxzcGFuIHN0eWxlPSJjb3VudGVyLWluY3JlbWVudDog YzsiIGNsYXNzPSJ1c2UiIGlkPSJ0aHJlZSI+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQi Pjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZlcmVuY2UiPjAuMS0wLjItMS0yLTwvZGl2 PgorPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCgpQcm9wZXJ0eSBj aGFuZ2VzIG9uOiBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5kZXg6IExheW91dFRlc3RzL2NzczIu MS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2NzczIu MS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvY3Nz Mi4xL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzQgQEAK KzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRt bD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRl eHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNo YW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRo b3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAg ICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVy YXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3 dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxs aW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5o dG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAg IDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2 YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdo aXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVz ZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhj LCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7 IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAg ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworICAgICAgICBmdW5jdGlvbiBydW4o KSB7CisgICAgICAgICAgICB2YXIgdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0Iik7 CisgICAgICAgICAgICB2YXIgcyA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4iKTsKKyAg ICAgICAgICAgIHMuc2V0QXR0cmlidXRlKCJjbGFzcyIsICJyZXNldCIpOworICAgICAgICAgICAg dC5pbnNlcnRCZWZvcmUocywgdC5jaGlsZE5vZGVzLml0ZW0oMSkpOworICAgICAgICAgICAgaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9o ZWFkPjxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgncnVuKCknLCAwKSI+CisgICAgPHA+VGhlIGZv bGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1lOjwvcD4KKyAgICA8ZGl2IGlkPSJ0 ZXN0Ij48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gY2xhc3M9InJlc2V0Ij48 L3NwYW4+PHNwYW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNyZW1l bnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZlcmVuY2UiPjEtMS4xLTEuMi08L2Rp dj4KKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQoKUHJvcGVydHkg Y2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5kZXg6IExheW91dFRlc3RzL2NzczIuMS9j b3VudGVyLXJlc2V0LTAwMi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2NzczIuMS9j b3VudGVyLXJlc2V0LTAwMi5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvY3NzMi4x L2NvdW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzIgQEAKKzwh RE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48 aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQv aHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5n ZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3Ii IGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8 bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRl Lmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53 My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5r IHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1s I2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxt ZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNj cmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRl LXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6 IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAi LiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0K KyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAg ICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworICAgICAgICBmdW5jdGlvbiBydW4oKSB7 CisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgib25lIikuc2V0QXR0cmlidXRl KCJjbGFzcyIsICJyZXNldCIpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InR3byIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAgICAgICAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkg b25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3 byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3QiPjxzcGFu IGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3Bhbj48c3BhbiBjbGFzcz0icmVzZXQiIGlkPSJv bmUiPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjxzcGFuIGNs YXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3Bhbj48c3BhbiBpZD0idHdvIj48c3BhbiBjbGFzcz0i aW5jcmVtZW50Ij48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48 L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4xLTEuMS0yLTMtNC08L2Rpdj4K KzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQoKUHJvcGVydHkgY2hh bmdlcyBvbjogTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3F0 L2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDItZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvY3NzMi4x L2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsMzkgQEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgw LDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4MTAzCisgIFJlbmRlckJs b2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHgxMDMKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBh dCAoOCwxNikgc2l6ZSA3ODR4NzkKKyAgICAgIFJlbmRlckJsb2NrIHtQfSBhdCAoMCwwKSBzaXpl IDc4NHgyMQorICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSAzMTB4MjEK KyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCAzMTA6ICJUaGUgZm9sbG93aW5nIHR3 byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6IgorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQg KDAsMzcpIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkg c2l6ZSAweDAKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDU0eDIx CisgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDU0eDIxCisgICAg ICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAg ICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAg ICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICgwLDApIHNpemUgMjJ4MjEKKyAgICAgICAgICAg ICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDIyOiAiMC4xIgorICAgICAgICAgICAgICAg IFJlbmRlclRleHQgYXQgKDIyLDApIHNpemUgNXgyMQorICAgICAgICAgICAgICAgICAgdGV4dCBy dW4gYXQgKDIyLDApIHdpZHRoIDU6ICItIgorICAgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFO fSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJh dGVkKSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlciBh dCAoMjcsMCkgc2l6ZSAyMngyMQorICAgICAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDI3LDAp IHdpZHRoIDIyOiAiMC4yIgorICAgICAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDQ5LDApIHNp emUgNXgyMQorICAgICAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDQ5LDApIHdpZHRoIDU6ICIt IgorICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAg ICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkgYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAg ICAgICAgUmVuZGVyQ291bnRlciBhdCAoNTQsMCkgc2l6ZSA5eDIxCisgICAgICAgICAgICAgIHRl eHQgcnVuIGF0ICg1NCwwKSB3aWR0aCA5OiAiMSIKKyAgICAgICAgICAgIFJlbmRlclRleHQgYXQg KDYzLDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNjMsMCkgd2lkdGgg NTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAxNHgyMQor ICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDE0eDIxCisg ICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg2OCwwKSBzaXplIDl4MjEKKyAgICAgICAgICAg ICAgdGV4dCBydW4gYXQgKDY4LDApIHdpZHRoIDk6ICIyIgorICAgICAgICAgICAgUmVuZGVyVGV4 dCBhdCAoNzcsMCkgc2l6ZSA1eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg3NywwKSB3 aWR0aCA1OiAiLSIKKyAgICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDU4KSBzaXplIDc4NHgy MQorICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA4MngyMQorICAgICAg ICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDgyOiAiMC4xLTAuMi0xLTItIgpJbmRleDogTGF5 b3V0VGVzdHMvcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4 dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1y ZXNldC0wMDAtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvcGxhdGZv cm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSwzMiBAQAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlclZp ZXcgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCitsYXllciBhdCAoMCwwKSBzaXplIDgwMHgxMDMKKyAg UmVuZGVyQmxvY2sge0hUTUx9IGF0ICgwLDApIHNpemUgODAweDEwMworICAgIFJlbmRlckJvZHkg e0JPRFl9IGF0ICg4LDE2KSBzaXplIDc4NHg3OQorICAgICAgUmVuZGVyQmxvY2sge1B9IGF0ICgw LDApIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXpl IDMxMHgyMQorICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDMxMDogIlRoZSBmb2xs b3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZToiCisgICAgICBSZW5kZXJCbG9jayB7 RElWfSBhdCAoMCwzNykgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBh dCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0 ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIgYXQgKDAsMCkgc2l6 ZSA5eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDk6ICIxIgorICAg ICAgICAgICAgUmVuZGVyVGV4dCBhdCAoOSwwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgdGV4 dCBydW4gYXQgKDksMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0g YXQgKDAsMCkgc2l6ZSAweDIxCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkg c2l6ZSAweDIxCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAyN3gy MQorICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDI3eDIx CisgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICgxNCwwKSBzaXplIDIyeDIxCisgICAgICAg ICAgICAgIHRleHQgcnVuIGF0ICgxNCwwKSB3aWR0aCAyMjogIjEuMSIKKyAgICAgICAgICAgIFJl bmRlclRleHQgYXQgKDM2LDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAo MzYsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkg c2l6ZSAyN3gyMQorICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBz aXplIDI3eDIxCisgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg0MSwwKSBzaXplIDIyeDIx CisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg0MSwwKSB3aWR0aCAyMjogIjEuMiIKKyAgICAg ICAgICAgIFJlbmRlclRleHQgYXQgKDYzLDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0ZXh0 IHJ1biBhdCAoNjMsMCkgd2lkdGggNTogIi0iCisgICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAo MCw1OCkgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNp emUgNjh4MjEKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCA2ODogIjEtMS4xLTEu Mi0iCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0w MDItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3BsYXRmb3JtL3F0L2Nz czIuMS9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQ2IEBACitsYXllciBhdCAoMCwwKSBzaXplIDgwMHg2 MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0ICgwLDApIHNp emUgODAweDEwMworICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4MDB4MTAzCisg ICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsMTYpIHNpemUgNzg0eDc5CisgICAgICBSZW5kZXJC bG9jayB7UH0gYXQgKDAsMCkgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9 IGF0ICgwLDApIHNpemUgMzEweDIxCisgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGgg MzEwOiAiVGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1lOiIKKyAgICAg IFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDM3KSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJJ bmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUg KGdlbmVyYXRlZCkgYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRl ciBhdCAoMCwwKSBzaXplIDl4MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lk dGggOTogIjEiCisgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICg5LDApIHNpemUgNXgyMQorICAg ICAgICAgICAgICB0ZXh0IHJ1biBhdCAoOSwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAgUmVuZGVy SW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgUmVuZGVySW5saW5l IHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICBSZW5kZXJJbmxpbmUge1NQ QU59IGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5l cmF0ZWQpIGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVy IGF0ICgxNCwwKSBzaXplIDIyeDIxCisgICAgICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTQs MCkgd2lkdGggMjI6ICIxLjEiCisgICAgICAgICAgICAgICAgUmVuZGVyVGV4dCBhdCAoMzYsMCkg c2l6ZSA1eDIxCisgICAgICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMzYsMCkgd2lkdGggNTog Ii0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAg ICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAg ICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg0MSwwKSBzaXplIDl4MjEKKyAgICAgICAgICAgICAg dGV4dCBydW4gYXQgKDQxLDApIHdpZHRoIDk6ICIyIgorICAgICAgICAgICAgUmVuZGVyVGV4dCBh dCAoNTAsMCkgc2l6ZSA1eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg1MCwwKSB3aWR0 aCA1OiAiLSIKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDE0eDIx CisgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAg ICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAg ICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAg ICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg1NSwwKSBzaXplIDl4MjEKKyAgICAgICAgICAg ICAgICAgIHRleHQgcnVuIGF0ICg1NSwwKSB3aWR0aCA5OiAiMyIKKyAgICAgICAgICAgICAgICBS ZW5kZXJUZXh0IGF0ICg2NCwwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgICAgIHRleHQgcnVu IGF0ICg2NCwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAo MCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgw LDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIgYXQgKDY5LDApIHNpemUg OXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNjksMCkgd2lkdGggOTogIjQiCisgICAg ICAgICAgICBSZW5kZXJUZXh0IGF0ICg3OCwwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgdGV4 dCBydW4gYXQgKDc4LDApIHdpZHRoIDU6ICItIgorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQg KDAsNTgpIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBz aXplIDgzeDIxCisgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggODM6ICIxLTEuMS0y LTMtNC0iCg== 42617 2009-11-05 18:46:16 -0800 2009-11-06 09:17:38 -0800 Proposed Patch - fixed a few style issues. patchFor11031-2.patch text/plain 51841 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDU3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODIgQEAKKzIwMDktMTEtMDUgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorICAgICAgICBUaGlzIHBhdGNoIGZpeGVzIHRoZSBD U1MyLjEgY291bnRlciBpbXBsZW1lbnRhdGlvbiBzdWNoIHRoYXQgaXQKKyAgICAgICAgY29uZm9y bXMgdG8gdGhlIGxhdGVzdCBzY29waW5nIGFuZCBuZXN0aW5nIHJ1bGVzIGFuZCB1cGRhdGVzCisg ICAgICAgIHRoZSB2YWx1ZXMgb2YgdGhlIGNvdW50ZXJzIHdoZW4gdGhlIERPTSBpcyBjaGFuZ2Vk LgorCisgICAgICAgIFRlc3RzOiBjc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKKyAg ICAgICAgICAgICAgIGNzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCisgICAgICAgICAgICAg ICBjc3MyLjEvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL0Nv dW50ZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpjb21wdXRlQ291 bnRJblBhcmVudCk6CisgICAgICAgIENoYW5nZWQgdG8gdXNlIGlzUmVzZXQoKSBpbnN0ZWFkIG9m IG1faXNSZXNldCBpbiBvcmRlciB0byBiZSBpbnN5bmMKKyAgICAgICAgd2l0aCB0aGUgY2hhbmdl IGluIG1lYW5pbmcgb2YgbV9pc1Jlc2V0IHdoaWNoIG5vdyBtZWFucyB0aGF0IHRoZQorICAgICAg ICBjb3VudGVyIGlzIG9mIHJlc2V0IHR5cGUgYmVjYXVzZSBpdCB3YXMgc3R5bGVkIGFzIHN1Y2gg dmVyc3VzIHRoZQorICAgICAgICBvbGQgbWVhbmluZyB0aGF0IGl0IGlzIHJlc2V0IGVpdGhlciBi ZWNhdXNlIG9mIHRoZSBzdHlsZXNoZWV0IG9yIAorICAgICAgICBiZWNhdXNlIGl0IGlzIHRoZSBm aXJzdCByZWZlcmVuY2UgdG8gdGhpcyBjb3VudGVyIGlkZW50aWZpZXIuCisgICAgICAgIChXZWJD b3JlOjpDb3VudGVyTm9kZTo6cmVzZXRSZW5kZXJlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3Vu dGVyTm9kZTo6cmVzZXRSZW5kZXJlcnMpOgorICAgICAgICBJbnRyb2R1Y2VkIHRvIGVuY2Fwc3Vs YXRlIGNvZGUgdGhhdCBpbnZhbGlkYXRlcyBjb3VudGVyIHJlZmVyZW5jZXMKKyAgICAgICAgaW4g cmVuZGVyZXJzIHdoZW4gYSBjb3VudGVyJ3MgdmFsdWUgbWF5IGNoYW5nZS4KKyAgICAgICAgKFdl YkNvcmU6OkNvdW50ZXJOb2RlOjpyZWNvdW50KToKKyAgICAgICAgQ2hhbmdlIGp1c3QgaW4gbGF5 b3V0LCBubyBmdW5jdGlvbmFsIGNoYW5nZS4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2Rl OjppbnNlcnRBZnRlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVtb3ZlQ2hp bGQpOgorICAgICAgICBDaGFuZ2VkIHRvIHByb3Blcmx5IGludmFsaWRhdGUgdGhlIGNvdW50ZXIg aGllcmFyY2h5IHdoZW4gYSByZXNldAorICAgICAgICBub2RlIGlzIGluc2VydGVkIG9lIHJlbW92 ZWQgaW4vZnJvbSB0aGUgdHJlZS4KKyAgICAgICAgKFdlYkNvcmU6OnNob3dUcmVlQW5kTWFyayk6 CisgICAgICAgIENoYW5nZWQgdG8gZW5yaWNoIHRoZSBsaXN0ZWQgZGVidWdnaW5nIGluZm9ybWF0 aW9uLgorICAgICAgICAqIHJlbmRlcmluZy9Db3VudGVyTm9kZS5oOgorICAgICAgICAoV2ViQ29y ZTo6Q291bnRlck5vZGU6OmlzUmVzZXQpOgorICAgICAgICBDaGFuZ2VkIHRvIGNvdmVyIGJvdGgg Y2FzZXMgd2hlbiBhIGNvdW50ZXIgYWN0cyBhcyBhIHJlc2V0IGNvdW50ZXIuCisgICAgICAgIChX ZWJDb3JlOjpDb3VudGVyTm9kZTo6aXNUeXBlUmVzZXQpOgorICAgICAgICBJbnRyb2R1Y2VkIHRv IGVuYWJsZSBleHRyYWN0aW9uIG9mIHRoZSBjb3VudGVyIHR5cGUgYWNjb3JkaW5nIHRvIHRoZQor ICAgICAgICBzdHlsZSBzaGVldC4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjp2YWx1 ZSk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Y291bnRJblBhcmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVuZGVyZXIpOgorICAgICAgICAoV2ViQ29yZTo6 Q291bnRlck5vZGU6OnBhcmVudCk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cHJl dmlvdXNTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpuZXh0U2libGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Zmlyc3RDaGlsZCk6CisgICAgICAg IChXZWJDb3JlOjpDb3VudGVyTm9kZTo6bGFzdENoaWxkKToKKyAgICAgICAgSnVzdCBmb3JjZWQg aW5saW5lIGZvciBzcGVlZC4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpmaW5kUGxhY2VGb3JDb3VudGVyKToKKyAgICAgICAgQ29tcGxl dGVseSByZXdyaXR0ZW4gdGhlIGFsZ29yaXRobSB0byBhY2NvdW50IGZvciBjdXJyZW50IGNvdW50 ZXIKKyAgICAgICAgc2NvcGluZyBydWxlcyBhbmQgdG8gcHJvcGVybHkgaGFuZGxlIHJhbmRvbSBj b3VudGVyIGluc2VydGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpjb3VudGVyKToKKyAgICAgICAg QWRkZWQgY29kZSB0byByZWV2YWx1YXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB1cG9uIG5ldyBy b290IGNvdW50ZXIKKyAgICAgICAgY3JlYXRpb24sIGFkZGFwdGVkIHRvIG5ldyBpc1Jlc2V0IHNl bWFudGljcy4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUpOgor ICAgICAgICBBZGRlZCBvcHRpb24gdG8gY29uZGl0aW9uYWxseSBpbnZhbGlkYXRlIHRoZSBjb3Vu dGVyIGJ5IGlkLgorICAgICAgICAoV2ViQ29yZTo6ZGVzdHJveUNvdW50ZXJOb2RlV2l0aG91dE1h cFJlbW92YWwpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50 ZXJOb2Rlcyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRl ck5vZGUpOgorICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBzZWxlY3RpdmUgY29udGVyIG5vZGUg ZGVzdHJ1Y3Rpb24uCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpjcmVhdGVDb3Vu dGVySWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291 bnRlcnMpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcik6 CisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBzdXBwb3J0IGR5bmFtaWMgY291bnRlciBoaWVy YXJjaHkgdXBkYXRlIHVwb24gRE9NCisgICAgICAgIGNoYW5nZXMKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRDaGlsZCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnNldFN0eWxlKToKKyAgICAgICAgQWRkZWQgaG9va3MgdG8g dXBkYXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB3aGVuIHRoZSBET00gY2hhbmdlcy4KKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmludmFsaWRhdGVDb3VudGVyc0luQ29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlck9iamVjdENoaWxkTGlzdDo6aW52YWxpZGF0ZUNvdW50ZXJzKToKKyAgICAgICAgQWRkZWQg c3VwcG9ydCBmb3Igc2VsZWN0aXZlIGNvdW50ZXIgaW52YWxpZGF0aW9uIGFuZCBleHRlbmRlZCB0 aGUKKyAgICAgICAgc2NvcGUgb2YgdGhlIGludmFsaWRhdGlvbiB0byB0aGUgY29udGFpbmVyIGl0 c2VsZiBhcyBzb21lIGNvdW50ZXJzCisgICAgICAgIGhhbmcgZGlyZWN0bHkgb2ZmIG9mIGl0Lgor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaDoKKwogMjAwOS0xMS0w NSAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGltaXRyaSBHbGF6a292LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRlck5vZGUu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2 aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTI0LDE2ICsyNCwxMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIkNvdW50ZXJOb2RlLmgiCiAKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVk ZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KIAotLy8gRklYTUU6IFRoZXJl J3MgY3VycmVudGx5IG5vIHN0cmF0ZWd5IGZvciBnZXR0aW5nIHRoZSBjb3VudGVyIHRyZWUgdXBk YXRlZCB3aGVuIG5ldwotLy8gZWxlbWVudHMgd2l0aCBjb3VudGVyLXJlc2V0IGFuZCBjb3VudGVy LWluY3JlbWVudCBzdHlsZXMgYXJlIGFkZGVkIHRvIHRoZSByZW5kZXIgdHJlZS4KLS8vIEFsc28s IHRoZSBjb2RlIGNhbid0IGhhbmRsZSBjaGFuZ2VzIHdoZXJlIGFuIGV4aXN0aW5nIG5vZGUgbmVl ZHMgdG8gY2hhbmdlIGludG8gYQotLy8gInJlc2V0IiBub2RlLCBvciBmcm9tIGEgInJlc2V0IiBu b2RlIGJhY2sgdG8gbm90IGEgInJlc2V0IiBub2RlLiBBcyBvZiB0aGlzIHdyaXRpbmcsCi0vLyBh dCBsZWFzdCBzb21lIG9mIHRoZXNlIHByb2JsZW1zIG1hbmlmZXN0IGFzIGZhaWx1cmVzIGluIHRo ZSB0MTIwNC1pbmNyZW1lbnQgYW5kCi0vLyB0MTIwNC1yZXNldCB0ZXN0cyBpbiB0aGUgQ1NTIDIu MSB0ZXN0IHN1aXRlLgotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIENvdW50ZXJOb2RlOjpDb3Vu dGVyTm9kZShSZW5kZXJPYmplY3QqIG8sIGJvb2wgaXNSZXNldCwgaW50IHZhbHVlKQpAQCAtNTEs MTQgKzQ1LDI4IEBAIENvdW50ZXJOb2RlOjpDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqIG8KIAog aW50IENvdW50ZXJOb2RlOjpjb21wdXRlQ291bnRJblBhcmVudCgpIGNvbnN0CiB7Ci0gICAgaW50 IGluY3JlbWVudCA9IG1faXNSZXNldCA/IDAgOiBtX3ZhbHVlOworICAgIGludCBpbmNyZW1lbnQg PSBpc1Jlc2V0KCkgPyAwIDogbV92YWx1ZTsKICAgICBpZiAobV9wcmV2aW91c1NpYmxpbmcpCiAg ICAgICAgIHJldHVybiBtX3ByZXZpb3VzU2libGluZy0+bV9jb3VudEluUGFyZW50ICsgaW5jcmVt ZW50OwogICAgIEFTU0VSVChtX3BhcmVudC0+bV9maXJzdENoaWxkID09IHRoaXMpOwogICAgIHJl dHVybiBtX3BhcmVudC0+bV92YWx1ZSArIGluY3JlbWVudDsKIH0KIAotdm9pZCBDb3VudGVyTm9k ZTo6cmVjb3VudCgpCit2b2lkIENvdW50ZXJOb2RlOjpyZXNldFJlbmRlcmVyKEF0b21pY1N0cmlu Z0ltcGwqIGlkZW50aWZpZXIpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgIW1fcmVuZGVyZXIt PmRvY3VtZW50QmVpbmdEZXN0cm95ZWQoKSkKKyAgICAgICAgaWYgKFJlbmRlck9iamVjdENoaWxk TGlzdCogY2hpbGRyZW4gPSBtX3JlbmRlcmVyLT52aXJ0dWFsQ2hpbGRyZW4oKSkKKyAgICAgICAg ICAgIGNoaWxkcmVuLT5pbnZhbGlkYXRlQ291bnRlcnMobV9yZW5kZXJlciwgaWRlbnRpZmllcik7 Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlc2V0UmVuZGVyZXJzKEF0b21pY1N0cmluZ0ltcGwg KmlkZW50aWZpZXIpCit7CisgICAgcmVzZXRSZW5kZXJlcihpZGVudGlmaWVyKTsKKyAgICBmb3Ig KENvdW50ZXJOb2RlKiBjID0gbV9maXJzdENoaWxkOyBjIDsgYyA9IGMtPm1fbmV4dFNpYmxpbmcp CisgICAgICAgIGMtPnJlc2V0UmVuZGVyZXJzKGlkZW50aWZpZXIpOworfQorCit2b2lkIENvdW50 ZXJOb2RlOjpyZWNvdW50KEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpCiB7CiAgICAgZm9y IChDb3VudGVyTm9kZSogYyA9IHRoaXM7IGM7IGMgPSBjLT5tX25leHRTaWJsaW5nKSB7CiAgICAg ICAgIGludCBvbGRDb3VudCA9IGMtPm1fY291bnRJblBhcmVudDsKQEAgLTY2LDE4ICs3NCwxMyBA QCB2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50KCkKICAgICAgICAgaWYgKG9sZENvdW50ID09IG5l d0NvdW50KQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGMtPm1fY291bnRJblBhcmVudCA9 IG5ld0NvdW50OwotICAgICAgICAvLyBtX3JlbmRlcmVyIGNvbnRhaW5zIHRoZSBwYXJlbnQgb2Yg dGhlIHJlbmRlciBub2RlCi0gICAgICAgIC8vIGNvcnJlc3BvbmRpbmcgdG8gYSBDb3VudGVyTm9k ZS4gTGV0J3MgZmluZCB0aGUgY291bnRlcgotICAgICAgICAvLyBjaGlsZCBhbmQgbWFrZSB0aGlz IHJlLWxheW91dC4KLSAgICAgICAgZm9yIChSZW5kZXJPYmplY3QqIG8gPSBjLT5tX3JlbmRlcmVy LT5maXJzdENoaWxkKCk7IG87IG8gPSBvLT5uZXh0U2libGluZygpKQotICAgICAgICAgICAgaWYg KCFvLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkgJiYgby0+aXNDb3VudGVyKCkpIHsKLSAgICAg ICAgICAgICAgICBvLT5zZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKLSAgICAg ICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgIH0KKyAgICAgICAgLy9SZWxheW91dCBhbGwg Y291bnRlcnMgdGhhdCBtYXkgYmUgYWZmZWN0ZWQgYnkgdGhpcyBjaGFuZ2UKKyAgICAgICAgYy0+ cmVzZXRSZW5kZXJlcnMoaWRlbnRpZmllcik7CiAgICAgfQogfQogCi12b2lkIENvdW50ZXJOb2Rl OjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGls ZCkKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwK KyAgICBDb3VudGVyTm9kZSogcmVmQ2hpbGQsIEF0b21pY1N0cmluZ0ltcGwgKmlkZW50aWZpZXIp CiB7CiAgICAgQVNTRVJUKG5ld0NoaWxkKTsKICAgICBBU1NFUlQoIW5ld0NoaWxkLT5tX3BhcmVu dCk7CkBAIC04NSw2ICs4OCwxNCBAQCB2b2lkIENvdW50ZXJOb2RlOjppbnNlcnRBZnRlcihDb3Vu dGVyTm9kCiAgICAgQVNTRVJUKCFuZXdDaGlsZC0+bV9uZXh0U2libGluZyk7CiAgICAgQVNTRVJU KCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+bV9wYXJlbnQgPT0gdGhpcyk7CiAKKyAgICBpZiAobmV3 Q2hpbGQtPmlzVHlwZVJlc2V0KCkpIHsKKyAgICAgICAgUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+ IGlkZW50aWZpZXJQdHIoaWRlbnRpZmllcik7CisgICAgICAgIHdoaWxlIChtX2xhc3RDaGlsZCAh PSByZWZDaGlsZCkgeworICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJO b2RlKG1fbGFzdENoaWxkLT5yZW5kZXJlcigpLAorICAgICAgICAgICAgICAgIGlkZW50aWZpZXJQ dHIpOworICAgICAgICB9CisgICAgfQorCiAgICAgQ291bnRlck5vZGUqIG5leHQ7CiAKICAgICBp ZiAocmVmQ2hpbGQpIHsKQEAgLTEwOSwxMCArMTIwLDExIEBAIHZvaWQgQ291bnRlck5vZGU6Omlu c2VydEFmdGVyKENvdW50ZXJOb2QKIAogICAgIG5ld0NoaWxkLT5tX2NvdW50SW5QYXJlbnQgPSBu ZXdDaGlsZC0+Y29tcHV0ZUNvdW50SW5QYXJlbnQoKTsKICAgICBpZiAobmV4dCkKLSAgICAgICAg bmV4dC0+cmVjb3VudCgpOworICAgICAgICBuZXh0LT5yZWNvdW50KGlkZW50aWZpZXIpOwogfQog Ci12b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQpCit2 b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQsCisgICAg QXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllcikKIHsKICAgICBBU1NFUlQob2xkQ2hpbGQpOwog ICAgIEFTU0VSVCghb2xkQ2hpbGQtPm1fZmlyc3RDaGlsZCk7CkBAIC0xMzgsOSArMTUwLDkgQEAg dm9pZCBDb3VudGVyTm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZAogICAgICAgICBBU1NFUlQo bV9sYXN0Q2hpbGQgPT0gb2xkQ2hpbGQpOwogICAgICAgICBtX2xhc3RDaGlsZCA9IHByZXY7CiAg ICAgfQotICAgIAorCiAgICAgaWYgKG5leHQpCi0gICAgICAgIG5leHQtPnJlY291bnQoKTsKKyAg ICAgICAgbmV4dC0+cmVjb3VudChpZGVudGlmaWVyKTsKIH0KIAogI2lmbmRlZiBOREVCVUcKQEAg LTE3MiwxNCArMTg0LDEzIEBAIHN0YXRpYyB2b2lkIHNob3dUcmVlQW5kTWFyayhjb25zdCBDb3Vu dGUKICAgICAgICAgcm9vdCA9IHJvb3QtPnBhcmVudCgpOwogCiAgICAgZm9yIChjb25zdCBDb3Vu dGVyTm9kZSogYyA9IHJvb3Q7IGM7IGMgPSBuZXh0SW5QcmVPcmRlcihjKSkgewotICAgICAgICBp ZiAoYyA9PSBub2RlKQotICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICIqIik7CisgICAgICAg IGZ3cml0ZSgoYyA9PSBub2RlKSA/ICIqIiA6ICIgIiwgMSwgMSwgc3RkZXJyKTsKICAgICAgICAg Zm9yIChjb25zdCBDb3VudGVyTm9kZSogZCA9IGM7IGQgJiYgZCAhPSByb290OyBkID0gZC0+cGFy ZW50KCkpCi0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlx0Iik7Ci0gICAgICAgIGlmIChj LT5pc1Jlc2V0KCkpCi0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgInJlc2V0OiAlZCAlZFxu IiwgYy0+dmFsdWUoKSwgYy0+Y291bnRJblBhcmVudCgpKTsKLSAgICAgICAgZWxzZQotICAgICAg ICAgICAgZnByaW50ZihzdGRlcnIsICJpbmNyZW1lbnQ6ICVkICVkXG4iLCBjLT52YWx1ZSgpLCBj LT5jb3VudEluUGFyZW50KCkpOworICAgICAgICAgICAgZndyaXRlKCIgICIsIDEsIDIsIHN0ZGVy cik7CisgICAgICAgIGZwcmludGYoc3RkZXJyLCAiMHglMDhYICVzOiAlZCAlZCBQOjB4MDglWCBQ UzoweCUwOFggTlM6MHgwOCVYXG4iLAorICAgICAgICAgICAgKGludCljLCBjLT5pc1Jlc2V0KCkg PyAicmVzZXQiIDogImluY3JlbWVudCIsIGMtPnZhbHVlKCksCisgICAgICAgICAgICBjLT5jb3Vu dEluUGFyZW50KCksIGMtPnBhcmVudCgpLCBjLT5wcmV2aW91c1NpYmxpbmcoKSwKKyAgICAgICAg ICAgIGMtPm5leHRTaWJsaW5nKCkpOwogICAgIH0KIH0KIApJbmRleDogV2ViQ29yZS9yZW5kZXJp bmcvQ291bnRlck5vZGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVy Tm9kZS5oCShyZXZpc2lvbiA1MDUyMikKKysrIFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2Rl LmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDYgKzIyLDcgQEAKICNpZm5kZWYgQ291bnRlck5vZGVf aAogI2RlZmluZSBDb3VudGVyTm9kZV9oCiAKKyNpbmNsdWRlIDx3dGYvQWx3YXlzSW5saW5lLmg+ CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKIC8vIFRoaXMgaW1wbGVtZW50cyBhIGNv dW50ZXIgdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgcGFyZW50cyBpbiBjb3VudGVycygp IGxvb2t1cCwKQEAgLTM2LDI4ICszNyw1MyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFz cyBSZW5kZXJPYmplY3Q7CitjbGFzcyBBdG9taWNTdHJpbmdJbXBsOwogCiBjbGFzcyBDb3VudGVy Tm9kZSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgQ291bnRlck5vZGUoUmVu ZGVyT2JqZWN0KiwgYm9vbCBpc1Jlc2V0LCBpbnQgdmFsdWUpOwogCi0gICAgYm9vbCBpc1Jlc2V0 KCkgY29uc3QgeyByZXR1cm4gbV9pc1Jlc2V0OyB9Ci0gICAgaW50IHZhbHVlKCkgY29uc3QgeyBy ZXR1cm4gbV92YWx1ZTsgfQotICAgIGludCBjb3VudEluUGFyZW50KCkgY29uc3QgeyByZXR1cm4g bV9jb3VudEluUGFyZW50OyB9Ci0gICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlcigpIGNvbnN0IHsg cmV0dXJuIG1fcmVuZGVyZXI7IH0KLQotICAgIENvdW50ZXJOb2RlKiBwYXJlbnQoKSBjb25zdCB7 IHJldHVybiBtX3BhcmVudDsgfQotICAgIENvdW50ZXJOb2RlKiBwcmV2aW91c1NpYmxpbmcoKSBj b25zdCB7IHJldHVybiBtX3ByZXZpb3VzU2libGluZzsgfQotICAgIENvdW50ZXJOb2RlKiBuZXh0 U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dFNpYmxpbmc7IH0KLSAgICBDb3VudGVyTm9k ZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlyc3RDaGlsZDsgfQotICAgIENvdW50 ZXJOb2RlKiBsYXN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2xhc3RDaGlsZDsgfQotCi0gICAg dm9pZCBpbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiBiZWZv cmVDaGlsZCk7Ci0gICAgdm9pZCByZW1vdmVDaGlsZChDb3VudGVyTm9kZSopOworICAgIEFMV0FZ U19JTkxJTkUgYm9vbCBpc1Jlc2V0KCkgY29uc3QgeyByZXR1cm4gbV9pc1Jlc2V0IHx8ICFtX3Bh cmVudDsgfQorICAgIEFMV0FZU19JTkxJTkUgYm9vbCBpc1R5cGVSZXNldCgpIGNvbnN0IHsgcmV0 dXJuIG1faXNSZXNldDsgfQorICAgIEFMV0FZU19JTkxJTkUgaW50IHZhbHVlKCkgY29uc3QgeyBy ZXR1cm4gbV92YWx1ZTsgfQorICAgIEFMV0FZU19JTkxJTkUgaW50IGNvdW50SW5QYXJlbnQoKSBj b25zdCB7IHJldHVybiBtX2NvdW50SW5QYXJlbnQ7IH0KKyAgICBBTFdBWVNfSU5MSU5FIFJlbmRl ck9iamVjdCogcmVuZGVyZXIoKSBjb25zdCB7IHJldHVybiBtX3JlbmRlcmVyOyB9CisKKyAgICBB TFdBWVNfSU5MSU5FIENvdW50ZXJOb2RlKiBwYXJlbnQoKSBjb25zdCB7IHJldHVybiBtX3BhcmVu dDsgfQorICAgIEFMV0FZU19JTkxJTkUgQ291bnRlck5vZGUqIHByZXZpb3VzU2libGluZygpIGNv bnN0IHsgcmV0dXJuIG1fcHJldmlvdXNTaWJsaW5nOyB9CisgICAgQUxXQVlTX0lOTElORSBDb3Vu dGVyTm9kZSogbmV4dFNpYmxpbmcoKSBjb25zdCB7IHJldHVybiBtX25leHRTaWJsaW5nOyB9Cisg ICAgQUxXQVlTX0lOTElORSBDb3VudGVyTm9kZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJu IG1fZmlyc3RDaGlsZDsgfQorICAgIEFMV0FZU19JTkxJTkUgQ291bnRlck5vZGUqIGxhc3RDaGls ZCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdENoaWxkOyB9CisKKyAgICAvKiBpZGVudGlmaWVyIG11 c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgb2YgdGhpcyBjb3VudGVyIG9yCisgICAgICogdGhlIHJl bmRlcmVycyBhZmZlY3RlZCBieSB0aGlzIGluc2VydGlvbiBzaGFsbCBub3QgYmUKKyAgICAgKiBp bnZhbGlkYXRlZC4KKyAgICAgKi8KKyAgICB2b2lkIGluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBu ZXdDaGlsZCwgQ291bnRlck5vZGUqIGJlZm9yZUNoaWxkLAorICAgICAgICBBdG9taWNTdHJpbmdJ bXBsKiBpZGVudGlmaWVyKTsKKworICAgIC8qIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRl bnRpZmllciBvZiB0aGlzIGNvdW50ZXIgb3IKKyAgICAgKiB0aGUgcmVuZGVyZXJzIGFmZmVjdGVk IGJ5IHRoaXMgcmVtb3ZhbCBzaGFsbCBub3QgYmUgaW52YWxpZGF0ZWQuCisgICAgICovCisgICAg dm9pZCByZW1vdmVDaGlsZChDb3VudGVyTm9kZSosIEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZp ZXIpOworICAgIC8qIEludmFsaWRhdGVzIHRoZSB0ZXh0IGluIHRoZSByZW5kZXJlciBvZiB0aGlz IGNvdW50ZXIsIGlmIGFueQorICAgICAqIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRlbnRp ZmllciBmb3IgdGhpcyBjb3VudGVyLgorICAgICAqLworICAgIHZvaWQgcmVzZXRSZW5kZXJlcihB dG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsKKworICAgIC8qIEludmFsaWRhdGVzIHRoZSB0 ZXh0IGluIHRoZSByZW5kZXJlciBvZiB0aGlzIGNvdW50ZXIsIGlmIGFueQorICAgICAqIGFuZCBp biB0aGUgcmVuZGVyZXJzIG9mIGFsbCBkZXNjZW5kYW50cywgaWYgYW55CisgICAgICogaWRlbnRp ZmllciBtdXN0IG1hdGNoIHRoZSBpZGVudGlmaWVyIGZvciB0aGlzIGNvdW50ZXIuCisgICAgICov CisgICAgdm9pZCByZXNldFJlbmRlcmVycyhBdG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsK IAogcHJpdmF0ZToKICAgICBpbnQgY29tcHV0ZUNvdW50SW5QYXJlbnQoKSBjb25zdDsKLSAgICB2 b2lkIHJlY291bnQoKTsKKworICAgIC8qIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRlbnRp ZmllciBvZiB0aGlzIGNvdW50ZXIgb3IKKyAgICAgKiB0aGUgcmVuZGVyZXJzIGFmZmVjdGVkIGJ5 IHRoaXMgcmVjb3VudCBzaGFsbCBub3QgYmUgaW52YWxpZGF0ZWQuCisgICAgICovCisgICAgdm9p ZCByZWNvdW50KEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpOwogCiAgICAgYm9vbCBtX2lz UmVzZXQ7CiAgICAgaW50IG1fdmFsdWU7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJD b3VudGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVy LmNwcAkocmV2aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVy LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMzLDU1ICsxMzMsODAgQEAgc3RhdGljIGJvb2wgcGxh bkNvdW50ZXIoUmVuZGVyT2JqZWN0KiBvYgogICAgIHJldHVybiBmYWxzZTsKIH0KIAotc3RhdGlj IGJvb2wgZmluZFBsYWNlRm9yQ291bnRlcihSZW5kZXJPYmplY3QqIG9iamVjdCwgY29uc3QgQXRv bWljU3RyaW5nJiBjb3VudGVyTmFtZSwKLSAgICBib29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYg cGFyZW50LCBDb3VudGVyTm9kZSomIHByZXZpb3VzU2libGluZykKKy8qIEZpbmRzIHRoZSBpbnNl cnRpb24gcG9pbnQgZm9yIHRoZSBjb3VudGVyIGRlc2NyaWJlZCBieSBjb3VudGVyT3duZXIsIGlz UmVzZXQgYW5kIAorICogY291bnRlck5hbWUgaW4gdGhlIENvdW50ZXJOb2RlIHRyZWUgZm9yIGNv dW50ZXJOYW1lIGFuZCBzZXRzIHBhcmVudCBhbmQKKyAqIHByZXZpb3VzU2libGluZyBhY2NvcmRp bmdseS4KKyAqIFRoZSBmdW5jdGlvbiByZXR1cm5zIHRydWUgaWYgdGhlIGNvdW50ZXIgd2hvc2Ug aW5zZXJ0aW9uIHBvaW50IGlzIHNlYXJjaGVkIGlzIE5PVAorICogdGhlIHJvb3Qgb2YgdGhlIHRy ZWUuCisgKiBUaGUgcm9vdCBvZiB0aGUgdHJlZSBpcyBhIGNvdW50ZXIgcmVmZXJlbmNlIHRoYXQg aXMgbm90IGluIHRoZSBzY29wZSBvZiBhbnkgb3RoZXIKKyAqIGNvdW50ZXIgd2l0aCB0aGUgc2Ft ZSBpZGVudGlmaWVyLgorICogQWxsIHRoZSBjb3VudGVyIHJlZmVyZW5jZXMgd2l0aCB0aGUgc2Ft ZSBpZGVudGlmaWVyIGFzIHRoaXMgb25lIHRoYXQgYXJlIGluCisgKiBjaGlsZHJlbiBvciBzdWJz ZXF1ZW50IHNpYmxpbmdzIG9mIHRoZSByZW5kZXJlciB0aGF0IG93bnMgdGhlIHJvb3Qgb2YgdGhl IHRyZWUKKyAqIGZvcm0gdGhlIHJlc3Qgb2Ygb2YgdGhlIG5vZGVzIG9mIHRoZSB0cmVlLgorICog VGhlIHJvb3Qgb2YgdGhlIHRyZWUgaXMgYWx3YXlzIGEgcmVzZXQgdHlwZSByZWZlcmVuY2UuCisg KiBBIHN1YnRyZWUgcm9vdGVkIGF0IGFueSByZXNldCBub2RlIGluIHRoZSB0cmVlIGlzIGVxdWl2 YWxlbnQgdG8gYWxsIGNvdW50ZXIgCisgKiByZWZlcmVuY2VzIHRoYXQgYXJlIGluIHRoZSBzY29w ZSBvZiB0aGUgY291bnRlciBvciBuZXN0ZWQgY291bnRlciBkZWZpbmVkIGJ5IHRoYXQKKyAqIHJl c2V0IG5vZGUuCisgKiBOb24tcmVzZXQgQ291bnRlck5vZGVzIGNhbm5vdCBoYXZlIGRlc2NlbmRh bnRzLgorICovCitzdGF0aWMgYm9vbCBmaW5kUGxhY2VGb3JDb3VudGVyKFJlbmRlck9iamVjdCog Y291bnRlck93bmVyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBBdG9t aWNTdHJpbmcmIGNvdW50ZXJOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBi b29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYgcGFyZW50LCAKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgQ291bnRlck5vZGUqJiBwcmV2aW91c1NpYmxpbmcpCiB7Ci0gICAgLy8gRmlu ZCB0aGUgYXBwcm9wcmlhdGUgcHJldmlvdXMgc2libGluZyBmb3IgaW5zZXJ0aW9uIGludG8gdGhl IHBhcmVudCBub2RlCi0gICAgLy8gYnkgc2VhcmNoaW5nIGluIHJlbmRlciB0cmVlIG9yZGVyIGZv ciBhIGNoaWxkIG9mIHRoZSBjb3VudGVyLgotICAgIHBhcmVudCA9IDA7CisgICAgUmVuZGVyT2Jq ZWN0KiBzZWFyY2hFbmRSZW5kZXJlciA9IHByZXZpb3VzU2libGluZ09yUGFyZW50KGNvdW50ZXJP d25lcik7CisgICAgUmVuZGVyT2JqZWN0KiBjdXJyZW50UmVuZGVyZXIgPSBjb3VudGVyT3duZXIt PnByZXZpb3VzSW5QcmVPcmRlcigpOwogICAgIHByZXZpb3VzU2libGluZyA9IDA7Ci0gICAgUmVu ZGVyT2JqZWN0KiByZXNldENhbmRpZGF0ZSA9IGlzUmVzZXQgPyBvYmplY3QtPnBhcmVudCgpIDog cHJldmlvdXNTaWJsaW5nT3JQYXJlbnQob2JqZWN0KTsKLSAgICBSZW5kZXJPYmplY3QqIHByZXZD b3VudGVyQ2FuZGlkYXRlID0gb2JqZWN0OwotICAgIENvdW50ZXJOb2RlKiBjYW5kaWRhdGVDb3Vu dGVyID0gMDsKLSAgICAvLyBXaGVuIGEgcmVzZXQgY291bnRlciBpcyBjaG9zZW4gYXMgY2FuZGlk YXRlQ291bnRlciwgd2UnbGwKLSAgICAvLyBkZWNpZGUgdGhlIG5ldyBub2RlIHNob3VsZCBiZSBh IGNoaWxkIG9mIHRoZSByZXNldCBub2RlIG9yIGEKLSAgICAvLyBzaWJsaW5nIG9yIHRoZSByZXNl dCBub2RlLiBUaGlzIGZsYWcgY29udHJvbHMgaXQuCi0gICAgYm9vbCBjcmVhdGVDaGlsZEZvclJl c2V0ID0gdHJ1ZTsKLSAgICB3aGlsZSAoKHByZXZDb3VudGVyQ2FuZGlkYXRlID0gcHJldkNvdW50 ZXJDYW5kaWRhdGUtPnByZXZpb3VzSW5QcmVPcmRlcigpKSkgewotICAgICAgICBDb3VudGVyTm9k ZSogYyA9IGNvdW50ZXIocHJldkNvdW50ZXJDYW5kaWRhdGUsIGNvdW50ZXJOYW1lLCBmYWxzZSk7 Ci0gICAgICAgIGlmIChwcmV2Q291bnRlckNhbmRpZGF0ZSA9PSByZXNldENhbmRpZGF0ZSkgewot ICAgICAgICAgICAgaWYgKCFjYW5kaWRhdGVDb3VudGVyKSB7Ci0gICAgICAgICAgICAgICAgY2Fu ZGlkYXRlQ291bnRlciA9IGM7Ci0gICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JSZXNldCA9 IHRydWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBpZiAoY2FuZGlkYXRlQ291bnRlcikg ewotICAgICAgICAgICAgICAgIGlmIChjcmVhdGVDaGlsZEZvclJlc2V0ICYmIGNhbmRpZGF0ZUNv dW50ZXItPmlzUmVzZXQoKSkgewotICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjYW5kaWRh dGVDb3VudGVyOwotICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSAwOworICAg IHdoaWxlIChjdXJyZW50UmVuZGVyZXIpIHsKKyAgICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnRD b3VudGVyID0gY291bnRlcihjdXJyZW50UmVuZGVyZXIsIGNvdW50ZXJOYW1lLCBmYWxzZSk7Cisg ICAgICAgIGlmIChzZWFyY2hFbmRSZW5kZXJlciA9PSBjdXJyZW50UmVuZGVyZXIpIHsKKyAgICAg ICAgICAgIGlmIChjdXJyZW50Q291bnRlcikgeworICAgICAgICAgICAgICAgIGlmIChwcmV2aW91 c1NpYmxpbmcpIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRDb3VudGVyLT5pc1Jl c2V0KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChpc1Jlc2V0CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgJiYgKGN1cnJlbnRSZW5kZXJlci0+cGFyZW50KCkgPT0gY291bnRl ck93bmVyLT5wYXJlbnQoKSkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQg PSBjdXJyZW50Q291bnRlci0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cHJldmlvdXNTaWJsaW5nID0gY3VycmVudENvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIHBhcmVudDsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgQVNTRVJUKHByZXZpb3VzU2libGluZy0+cGFyZW50KCkgPT0gY3VycmVudENvdW50 ZXIpOworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgaWYgKCFpc1Jlc2V0CisgICAgICAgICAgICAg ICAgICAgICAgICB8fCAoY3VycmVudFJlbmRlcmVyLT5wYXJlbnQoKSAhPSBjb3VudGVyT3duZXIt PnBhcmVudCgpKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgQVNTRVJUKGN1cnJlbnRDb3Vu dGVyLT5wYXJlbnQoKSA9PSBwcmV2aW91c1NpYmxpbmctPnBhcmVudCgpKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyLT5wYXJlbnQoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9CiAgICAg ICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICAgICAgcGFyZW50ID0gY2FuZGlk YXRlQ291bnRlci0+cGFyZW50KCk7Ci0gICAgICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGlu ZyA9IGNhbmRpZGF0ZUNvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgIGlmIChjdXJyZW50Q291 bnRlci0+aXNSZXNldCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoaXNSZXNldAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICYmIChjdXJyZW50UmVuZGVyZXItPnBhcmVudCgp ID09IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcGFyZW50ID0gY3VycmVudENvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRDb3VudGVyOworICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiBwYXJlbnQ7CisgICAgICAgICAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjdXJyZW50Q291bnRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgICAgIGlmICghaXNSZXNldAorICAgICAgICAgICAgICAgICAgICAgICAg fHwgKGN1cnJlbnRSZW5kZXJlci0+cGFyZW50KCkgIT0gY291bnRlck93bmVyLT5wYXJlbnQoKSkp IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyLT5wYXJl bnQoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRD b3VudGVyOworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgcHJldmlvdXNTaWJsaW5nID0gY3VycmVu dENvdW50ZXI7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIHJldHVybiB0cnVl OwogICAgICAgICAgICAgfQotICAgICAgICAgICAgcmVzZXRDYW5kaWRhdGUgPSBwcmV2aW91c1Np YmxpbmdPclBhcmVudChyZXNldENhbmRpZGF0ZSk7Ci0gICAgICAgIH0gZWxzZSBpZiAoYykgewot ICAgICAgICAgICAgaWYgKGMtPmlzUmVzZXQoKSkgewotICAgICAgICAgICAgICAgIGlmIChjLT5w YXJlbnQoKSkgewotICAgICAgICAgICAgICAgICAgICAvLyBUaGUgbmV3IG5vZGUgbWF5IGJlIHRo ZSBuZXh0IHNpYmxpbmcgb2YgdGhpcyByZXNldCBub2RlLgotICAgICAgICAgICAgICAgICAgICBj cmVhdGVDaGlsZEZvclJlc2V0ID0gZmFsc2U7Ci0gICAgICAgICAgICAgICAgICAgIGNhbmRpZGF0 ZUNvdW50ZXIgPSBjOwotICAgICAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAgICAg ICAgIGNyZWF0ZUNoaWxkRm9yUmVzZXQgPSB0cnVlOwotICAgICAgICAgICAgICAgICAgICBjYW5k aWRhdGVDb3VudGVyID0gMDsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICB9IGVsc2Ug aWYgKCFjYW5kaWRhdGVDb3VudGVyKSB7Ci0gICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JS ZXNldCA9IHRydWU7Ci0gICAgICAgICAgICAgICAgY2FuZGlkYXRlQ291bnRlciA9IGM7Ci0gICAg ICAgICAgICB9Ci0gICAgICAgIH0KKyAgICAgICAgICAgIHNlYXJjaEVuZFJlbmRlcmVyID0gcHJl dmlvdXNTaWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAgfSBlbHNlIGlm IChjdXJyZW50Q291bnRlciAmJiAoIXByZXZpb3VzU2libGluZyB8fCBjdXJyZW50Q291bnRlci0+ aXNSZXNldCgpKSkKKyAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRDb3VudGVy OworICAgICAgICBpZiAocHJldmlvdXNTaWJsaW5nKQorICAgICAgICAgICAgY3VycmVudFJlbmRl cmVyID0gcHJldmlvdXNTaWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAg ZWxzZQorICAgICAgICAgICAgY3VycmVudFJlbmRlcmVyID0gY3VycmVudFJlbmRlcmVyLT5wcmV2 aW91c0luUHJlT3JkZXIoKTsKICAgICB9Ci0KICAgICByZXR1cm4gZmFsc2U7CiB9CiAKQEAgLTIw MSwxNSArMjI2LDkgQEAgc3RhdGljIENvdW50ZXJOb2RlKiBjb3VudGVyKFJlbmRlck9iamVjdAog CiAgICAgQ291bnRlck5vZGUqIG5ld1BhcmVudCA9IDA7CiAgICAgQ291bnRlck5vZGUqIG5ld1By ZXZpb3VzU2libGluZyA9IDA7Ci0gICAgQ291bnRlck5vZGUqIG5ld05vZGU7Ci0gICAgaWYgKGZp bmRQbGFjZUZvckNvdW50ZXIob2JqZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50 LCBuZXdQcmV2aW91c1NpYmxpbmcpKSB7Ci0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5v ZGUob2JqZWN0LCBpc1Jlc2V0LCB2YWx1ZSk7Ci0gICAgICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0 ZXIobmV3Tm9kZSwgbmV3UHJldmlvdXNTaWJsaW5nKTsKLSAgICB9IGVsc2UgewotICAgICAgICAv LyBNYWtlIGEgcmVzZXQgbm9kZSBmb3IgY291bnRlcnMgdGhhdCBhcmVuJ3QgaW5zaWRlIGFuIGV4 aXN0aW5nIHJlc2V0IG5vZGUuCi0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUob2Jq ZWN0LCB0cnVlLCB2YWx1ZSk7Ci0gICAgfQotCisgICAgQ291bnRlck5vZGUqIG5ld05vZGUgPSBu ZXcgQ291bnRlck5vZGUob2JqZWN0LCBpc1Jlc2V0LCB2YWx1ZSk7CisgICAgaWYgKGZpbmRQbGFj ZUZvckNvdW50ZXIob2JqZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50LCBuZXdQ cmV2aW91c1NpYmxpbmcpKQorICAgICAgICBuZXdQYXJlbnQtPmluc2VydEFmdGVyKG5ld05vZGUs IG5ld1ByZXZpb3VzU2libGluZywgY291bnRlck5hbWUuaW1wbCgpKTsKICAgICBDb3VudGVyTWFw KiBub2RlTWFwOwogICAgIGlmIChvYmplY3QtPm1faGFzQ291bnRlck5vZGVNYXApCiAgICAgICAg IG5vZGVNYXAgPSBjb3VudGVyTWFwcygpLmdldChvYmplY3QpOwpAQCAtMjE5LDcgKzIzOCwyNyBA QCBzdGF0aWMgQ291bnRlck5vZGUqIGNvdW50ZXIoUmVuZGVyT2JqZWN0CiAgICAgICAgIG9iamVj dC0+bV9oYXNDb3VudGVyTm9kZU1hcCA9IHRydWU7CiAgICAgfQogICAgIG5vZGVNYXAtPnNldChj b3VudGVyTmFtZS5pbXBsKCksIG5ld05vZGUpOwotCisgICAgaWYgKG5ld05vZGUtPnBhcmVudCgp IHx8ICFvYmplY3QtPm5leHRJblByZU9yZGVyKG9iamVjdC0+cGFyZW50KCkpKQorICAgICAgICBy ZXR1cm4gbmV3Tm9kZTsKKyAgICAvLyBTZWUgaWYgc29tZSBub2RlcyB0aGF0IHdlcmUgcHJldmlv dXNseSBjb3VudGVyIHRyZWUgcm9vdCBub2RlcworICAgIC8vIHNob3VsZCBiZWNvbWUgY2hpbGRy ZW4gb2YgdGhpcyBub2RlIG5vdy4KKyAgICBDb3VudGVyTWFwczo6aXRlcmF0b3IgZW5kID0gY291 bnRlck1hcHMoKS5lbmQoKTsKKyAgICBmb3IgKENvdW50ZXJNYXBzOjppdGVyYXRvciBpdCA9IGNv dW50ZXJNYXBzKCkuYmVnaW4oKTtpdCAhPSBlbmQ7CisgICAgICAgICsraXQpCisgICAgICAgIGlm IChpdC0+Zmlyc3QgIT0gb2JqZWN0KSB7CisgICAgICAgICAgICBub2RlTWFwID0gaXQtPnNlY29u ZDsKKyAgICAgICAgICAgIGlmIChDb3VudGVyTm9kZSogbm9kZSA9IG5vZGVNYXAtPmdldChjb3Vu dGVyTmFtZS5pbXBsKCkpKSB7CisgICAgICAgICAgICAgICAgaWYgKCFub2RlLT5wYXJlbnQoKQor ICAgICAgICAgICAgICAgICAgICAmJiBmaW5kUGxhY2VGb3JDb3VudGVyKAorICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3RfY2FzdDxSZW5kZXJPYmplY3QqPihpdC0+Zmlyc3QpLAorICAgICAg ICAgICAgICAgICAgICAgICAgY291bnRlck5hbWUsIHRydWUsIG5ld1BhcmVudCwKKyAgICAgICAg ICAgICAgICAgICAgICAgIG5ld1ByZXZpb3VzU2libGluZykpIHsKKyAgICAgICAgICAgICAgICAg ICAgQVNTRVJUKG5ld1BhcmVudCA9PSBuZXdOb2RlKTsKKyAgICAgICAgICAgICAgICAgICAgbmV3 UGFyZW50LT5pbnNlcnRBZnRlcihub2RlLAorICAgICAgICAgICAgICAgICAgICAgICAgbmV3UHJl dmlvdXNTaWJsaW5nLCBjb3VudGVyTmFtZS5pbXBsKCkpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQogICAgIHJldHVybiBuZXdOb2RlOwogfQogCkBAIC0yNzIs NDcgKzMxMSwxMTYgQEAgdm9pZCBSZW5kZXJDb3VudGVyOjpjYWxjUHJlZldpZHRocyhpbnQgbAog ICAgIFJlbmRlclRleHQ6OmNhbGNQcmVmV2lkdGhzKGxlYWQpOwogfQogCi12b2lkIFJlbmRlckNv dW50ZXI6OmludmFsaWRhdGUoKQordm9pZCBSZW5kZXJDb3VudGVyOjppbnZhbGlkYXRlKEF0b21p Y1N0cmluZ0ltcGwgKmlkZW50aWZpZXIpCiB7Ci0gICAgbV9jb3VudGVyTm9kZSA9IDA7Ci0gICAg c2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7CisgICAgaWYgKCFpZGVudGlmaWVy CisgICAgICAgIHx8IChtX2NvdW50ZXIuaWRlbnRpZmllcigpID09IChjb25zdCBjaGFyKilpZGVu dGlmaWVyLT5jaGFyYWN0ZXJzKCkpKSB7CisgICAgICAgIG1fY291bnRlck5vZGUgPSAwOworICAg ICAgICBzZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKKyAgICB9CiB9CiAKLXN0 YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZUNoaWxkcmVuKEF0b21pY1N0cmluZ0ltcGwqIGlk ZW50aWZpZXIsIENvdW50ZXJOb2RlKiBub2RlKQorc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJO b2RlV2l0aG91dE1hcFJlbW92YWwoCisgICAgY29uc3QgUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+ ICZpZGVudGlmaWVyLCBDb3VudGVyTm9kZSogbm9kZSkKIHsKLSAgICBDb3VudGVyTm9kZSogcHJl dmlvdXM7Ci0gICAgZm9yIChDb3VudGVyTm9kZSogY2hpbGQgPSBsYXN0RGVzY2VuZGFudChub2Rl KTsgY2hpbGQgJiYgY2hpbGQgIT0gbm9kZTsgY2hpbGQgPSBwcmV2aW91cykgewotICAgICAgICBw cmV2aW91cyA9IHByZXZpb3VzSW5QcmVPcmRlcihjaGlsZCk7Ci0gICAgICAgIGNoaWxkLT5wYXJl bnQoKS0+cmVtb3ZlQ2hpbGQoY2hpbGQpOworICAgIENvdW50ZXJOb2RlKiB0ZW1wOworICAgIGZv ciAoQ291bnRlck5vZGUqIGNoaWxkID0gbGFzdERlc2NlbmRhbnQobm9kZSk7IGNoaWxkICYmIGNo aWxkICE9IG5vZGU7IGNoaWxkID0gdGVtcCkgeworICAgICAgICB0ZW1wID0gcHJldmlvdXNJblBy ZU9yZGVyKGNoaWxkKTsKKyAgICAgICAgY2hpbGQtPnBhcmVudCgpLT5yZW1vdmVDaGlsZChjaGls ZCwgaWRlbnRpZmllci5nZXQoKSk7CiAgICAgICAgIEFTU0VSVChjb3VudGVyTWFwcygpLmdldChj aGlsZC0+cmVuZGVyZXIoKSktPmdldChpZGVudGlmaWVyKSA9PSBjaGlsZCk7CiAgICAgICAgIGNv dW50ZXJNYXBzKCkuZ2V0KGNoaWxkLT5yZW5kZXJlcigpKS0+cmVtb3ZlKGlkZW50aWZpZXIpOwog ICAgICAgICBpZiAoIWNoaWxkLT5yZW5kZXJlcigpLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkp IHsKICAgICAgICAgICAgIFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSBjaGlsZC0+ cmVuZGVyZXIoKS0+dmlydHVhbENoaWxkcmVuKCk7CiAgICAgICAgICAgICBpZiAoY2hpbGRyZW4p Ci0gICAgICAgICAgICAgICAgY2hpbGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhjaGlsZC0+cmVu ZGVyZXIoKSk7CisgICAgICAgICAgICAgICAgY2hpbGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhj aGlsZC0+cmVuZGVyZXIoKSwgaWRlbnRpZmllci5nZXQoKSk7CiAgICAgICAgIH0KICAgICAgICAg ZGVsZXRlIGNoaWxkOwogICAgIH0KKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbm9kZS0+ cmVuZGVyZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkp IHsKKyAgICAgICAgaWYgKFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSByZW5kZXJl ci0+dmlydHVhbENoaWxkcmVuKCkpCisgICAgICAgICAgICBjaGlsZHJlbi0+aW52YWxpZGF0ZUNv dW50ZXJzKHJlbmRlcmVyLCBpZGVudGlmaWVyLmdldCgpKTsKKyAgICB9CisgICAgaWYgKHRlbXAg PSBub2RlLT5wYXJlbnQoKSkKKyAgICAgICAgdGVtcC0+cmVtb3ZlQ2hpbGQobm9kZSwgaWRlbnRp Zmllci5nZXQoKSk7CisgICAgZGVsZXRlIG5vZGU7CiB9CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6 ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqIG9iamVjdCkKK3ZvaWQgUmVuZGVyQ291 bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewogICAg IENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1hcHMoKTsKLSAgICBDb3VudGVyTWFwKiBtYXAg PSBtYXBzLmdldChvYmplY3QpOworICAgIENvdW50ZXJNYXAqIG1hcCA9IG1hcHMuZ2V0KHJlbmRl cmVyKTsKICAgICBpZiAoIW1hcCkKICAgICAgICAgcmV0dXJuOwotICAgIG1hcHMucmVtb3ZlKG9i amVjdCk7Ci0KICAgICBDb3VudGVyTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBtYXAtPmVuZCgp OwotICAgIGZvciAoQ291bnRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtYXAtPmJlZ2luKCk7 IGl0ICE9IGVuZDsgKytpdCkgewotICAgICAgICBDb3VudGVyTm9kZSogbm9kZSA9IGl0LT5zZWNv bmQ7Ci0gICAgICAgIGRlc3Ryb3lDb3VudGVyTm9kZUNoaWxkcmVuKGl0LT5maXJzdC5nZXQoKSwg bm9kZSk7Ci0gICAgICAgIGlmIChDb3VudGVyTm9kZSogcGFyZW50ID0gbm9kZS0+cGFyZW50KCkp Ci0gICAgICAgICAgICBwYXJlbnQtPnJlbW92ZUNoaWxkKG5vZGUpOwotICAgICAgICBkZWxldGUg bm9kZTsKLSAgICB9CisgICAgZm9yIChDb3VudGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IG1h cC0+YmVnaW4oKTtpdCAhPSBlbmQ7KytpdCkKKyAgICAgICAgZGVzdHJveUNvdW50ZXJOb2RlV2l0 aG91dE1hcFJlbW92YWwoaXQtPmZpcnN0LCBpdC0+c2Vjb25kKTsKIAorICAgIG1hcHMucmVtb3Zl KHJlbmRlcmVyKTsKICAgICBkZWxldGUgbWFwOworICAgIHJlbmRlcmVyLT5tX2hhc0NvdW50ZXJO b2RlTWFwID0gZmFsc2U7CiB9CiAKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJO b2RlKFJlbmRlck9iamVjdCogcmVuZGVyZXIsCisgICAgY29uc3QgUmVmUHRyPEF0b21pY1N0cmlu Z0ltcGw+JiBpZGVudGlmaWVyKQoreworICAgIENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1h cHMoKTsKKyAgICBDb3VudGVyTWFwKiBtYXAgPSBtYXBzLmdldChyZW5kZXJlcik7CisgICAgaWYg KCFtYXApCisgICAgICAgIHJldHVybjsKKyAgICBDb3VudGVyTm9kZSogbm9kZSA9IG1hcC0+Z2V0 KGlkZW50aWZpZXIpOworICAgIGlmIChub2RlKSB7CisgICAgICAgIGRlc3Ryb3lDb3VudGVyTm9k ZVdpdGhvdXRNYXBSZW1vdmFsKGlkZW50aWZpZXIsIG5vZGUpOworICAgICAgICBtYXAtPnJlbW92 ZShpZGVudGlmaWVyKTsKKy8vIERvIG5vdCBkZWxldGUgbWFwIGV2ZW4gaWYgZW1wdHkgYXMgdGhl IGV4cGVjdGF0aW9uIGlzIHRoYXQgc29vbiBub2RlcyB3aWxsIGJlIGFkZGVkCisvLyB0byB0aGUg bWFwLCBvciBvdGhlcndpc2UgZGVzdHJveUNvdW50ZXJOb2RlcyB3b3VsZCBoYXZlIGJlZW4gY2Fs bGVkIGluc3RlYWQuCisgICAgfQorfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmNyZWF0ZUNvdW50 ZXJJZk5lZWRlZChSZW5kZXJPYmplY3QqIHJlbmRlcmVyLAorICAgICAgICBjb25zdCBBdG9taWNT dHJpbmcmIGlkZW50aWZpZXIpCit7CisgICAgY291bnRlcihyZW5kZXJlciwgaWRlbnRpZmllciwg ZmFsc2UpOworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKFJlbmRlck9i amVjdCogcmVuZGVyZXIpCit7CisgICAgdXBkYXRlQ291bnRlcihyZW5kZXJlcik7CisgICAgZm9y IChSZW5kZXJPYmplY3QqIGNoaWxkID0gcmVuZGVyZXItPm5leHRJblByZU9yZGVyKHJlbmRlcmVy KTsKKyAgICAgICAgY2hpbGQ7IGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyKHJlbmRlcmVy KSkKKyAgICAgICAgdXBkYXRlQ291bnRlcihjaGlsZCk7Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRl cjo6dXBkYXRlQ291bnRlcihSZW5kZXJPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQob2Jq ZWN0LT5zdHlsZSgpKTsKKyAgICBpZiAoIW9iamVjdC0+cGFyZW50KCkgJiYgIW9iamVjdC0+bmV4 dEluUHJlT3JkZXIoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmIChjb25zdCBDb3VudGVyRGly ZWN0aXZlTWFwKiBwQ291bnRlckRpcmVjdGl2ZU1hcCA9CisgICAgICAgIG9iamVjdC0+c3R5bGUo KS0+Y291bnRlckRpcmVjdGl2ZXMoKSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpj b25zdF9pdGVyYXRvciBlbmQgPQorICAgICAgICAgICAgcENvdW50ZXJEaXJlY3RpdmVNYXAtPmVu ZCgpOworICAgICAgICBDb3VudGVyTWFwKiBjb3VudGVyTWFwID0gY291bnRlck1hcHMoKS5nZXQo b2JqZWN0KTsKKyAgICAgICAgZm9yIChDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRv ciBpdCA9IHBDb3VudGVyRGlyZWN0aXZlTWFwLT5iZWdpbigpOworICAgICAgICAgICAgaXQgIT0g ZW5kOyArK2l0KQorICAgICAgICAgICAgaWYgKGNvdW50ZXJNYXApCisgICAgICAgICAgICAgICAg aWYgKENvdW50ZXJOb2RlICpub2RlID0gY291bnRlck1hcC0+Z2V0KGl0LT5maXJzdC5nZXQoKSkp IHsKKyAgICAgICAgICAgICAgICAgICAgQ291bnRlck5vZGUqIG5ld1BhcmVudCA9IDA7CisgICAg ICAgICAgICAgICAgICAgIENvdW50ZXJOb2RlKiBuZXdQcmV2aW91c1NpYmxpbmc7CisgICAgICAg ICAgICAgICAgICAgIGZpbmRQbGFjZUZvckNvdW50ZXIob2JqZWN0LAorICAgICAgICAgICAgICAg ICAgICAgICAgQXRvbWljU3RyaW5nKGl0LT5maXJzdC5nZXQoKSksIG5vZGUtPmlzVHlwZVJlc2V0 KCksCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdQYXJlbnQsIG5ld1ByZXZpb3VzU2libGlu Zyk7CisgICAgICAgICAgICAgICAgICAgIGlmICgobmV3UGFyZW50ICE9IG5vZGUtPnBhcmVudCgp KQorICAgICAgICAgICAgICAgICAgICAgICAgfHwgKG5ld1ByZXZpb3VzU2libGluZyAhPSBub2Rl LT5wcmV2aW91c1NpYmxpbmcoKSkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChub2Rl LT5wYXJlbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBub2RlLT5wYXJlbnQoKS0+ cmVtb3ZlQ2hpbGQobm9kZSwgaXQtPmZpcnN0LmdldCgpKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0ZXIobm9kZSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICBuZXdQcmV2aW91c1NpYmxpbmcsIGl0LT5maXJzdC5nZXQoKSk7CisgICAgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgY291 bnRlcihvYmplY3QsIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxzZSk7CisgICAg ICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgY291bnRlcihvYmplY3QsIEF0b21pY1N0cmlu ZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxzZSk7CisgICAgfQorfQogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gNTA1MjIpCisr KyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTMz LDEwICszMyw0MiBAQCBjbGFzcyBSZW5kZXJDb3VudGVyIDogcHVibGljIFJlbmRlclRleHQgCiBw dWJsaWM6CiAgICAgUmVuZGVyQ291bnRlcihEb2N1bWVudCosIGNvbnN0IENvdW50ZXJDb250ZW50 Jik7CiAKLSAgICB2b2lkIGludmFsaWRhdGUoKTsKLQorICAgIC8qIEludmFsaWRhdGVzIHRoZSBj b3VudGVyIGlmIGl0IGhhcyB0aGUgZ2l2ZW4gaWRlbnRpZmllci4KKyAgICAgKiBJZiB0aGUgZ2l2 ZW4gaWRlbnRpZmllciBpcyBOVUxMIGl0IGludmFsaWRhdGVzIHRoZSAKKyAgICAgKiBjb3VudGVy IHVuY29uZGl0aW9uYWxseS4KKyAgICAgKi8KKyAgICB2b2lkIGludmFsaWRhdGUoQXRvbWljU3Ry aW5nSW1wbCAqaWRlbnRpZmllciA9IDApOworCisgICAgLyogRGVzdHJveXMgYWxsIENvdW50ZXJO b2RlcyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlbmRlcmVyIHBhc3NlZCBhcyAKKyAgICAgKiBhcmd1 bWVudCBhbmQgYWxsIHRoZSBjaGlsZCBub2RlcyBvZiB0aG9zZSBub2RlcworICAgICAqLwogICAg IHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZXMoUmVuZGVyT2JqZWN0Kik7CiAKKyAgICAv KiBEZXN0cm95cyB0aGUgQ291bnRlck5vZGUgd2l0aCB0aGUgZ2l2ZW4gaWRlbnRpZmllciBhc3Nv Y2lhdGVkIHdpdGggdGhlIAorICAgICAqIHJlbmRlcmVyIHBhc3NlZCBhcyB0aGUgZmlyc3QgYXJn dW1lbnQgYW5kIGFsbCB0aGUgY2hpbGQgbm9kZXMgb2YgdGhhdCAKKyAgICAgKiBub2RlLgorICAg ICAqLworICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBj b25zdAorICAgICAgICBSZWZQdHI8QXRvbWljU3RyaW5nSW1wbD4mIGlkZW50aWZpZXIpOworCisg ICAgLyogQ3JlYXRlcyBhIG5ldyBjb3VudGVyIGF0dGFjaGVkIHRvIHRoZSByZW5kZXJlciBwYXNz ZWQgaW4KKyAgICAgKiBmb3IgdGhlIGlkZW50aWZpZXIgcGFzc2VkIGluIGlmIGl0IGRvZXMgbm90 IGFscmVhZHkgZXhpc3QgYW5kCisgICAgICogaXQgaXMgZGVmaW5lZCBieSB0aGUgcmVuZGVyZXIn cyBzdHlsZS4KKyAgICAgKi8KKyAgICBzdGF0aWMgdm9pZCBjcmVhdGVDb3VudGVySWZOZWVkZWQo UmVuZGVyT2JqZWN0KiwKKyAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJik7CisKKyAgICAvKiBV cGRhdGVzIHRoZSBjb3VudGVycyBhdHRhY2hlZCB0byB0aGUgcmVuZGVyZXIgcGFzc2VkIGluIGFu ZAorICAgICAqIHRob3NlIGF0dGFjaGVkIHRvIGl0cyBkZXNjZW5kYW50cy4KKyAgICAgKi8KKyAg ICBzdGF0aWMgdm9pZCB1cGRhdGVDb3VudGVycyhSZW5kZXJPYmplY3QqKTsKKworICAgIC8qIFVw ZGF0ZXMgdGhlIGNvdW50ZXJzIGF0dGFjaGVkIHRvIHRoZSByZW5kZXJlciBwYXNzZWQgaW4gd2hv c2UKKyAgICAgKiBuYW1lcyBhcHBlYXIgaW4gdGhlIGNvdW50ZXIgZGlyZWN0aXZlcyBvZiB0aGUg c3R5bGUKKyAgICAgKiBvZiB0aGUgcmVuZGVyZXIuCisgICAgICovCisgICAgc3RhdGljIHZvaWQg dXBkYXRlQ291bnRlcihSZW5kZXJPYmplY3QqKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVy KCkgY29uc3Q7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDUw NTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMzA0LDcgKzMwNCw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjphZGRDaGlsZChSZW5kZXJP YmplY3QKICAgICAgICAgLy8gSnVzdCBhZGQgaXQuLi4KICAgICAgICAgY2hpbGRyZW4tPmluc2Vy dENoaWxkTm9kZSh0aGlzLCBuZXdDaGlsZCwgYmVmb3JlQ2hpbGQpOwogICAgIH0KLSAgICAKKyAg ICBSZW5kZXJDb3VudGVyOjp1cGRhdGVDb3VudGVycyhuZXdDaGlsZCk7CiAgICAgaWYgKG5ld0No aWxkLT5pc1RleHQoKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+dGV4dFRyYW5zZm9ybSgpID09IENB UElUQUxJWkUpIHsKICAgICAgICAgUmVmUHRyPFN0cmluZ0ltcGw+IHRleHRUb1RyYW5zZm9ybSA9 IHRvUmVuZGVyVGV4dChuZXdDaGlsZCktPm9yaWdpbmFsVGV4dCgpOwogICAgICAgICBpZiAodGV4 dFRvVHJhbnNmb3JtKQpAQCAtMTQ4NiwyMCArMTQ4Niw4MiBAQCB2b2lkIFJlbmRlck9iamVjdDo6 c2V0U3R5bGUoUGFzc1JlZlB0cjxSCiAgICAgZGlmZiA9IGFkanVzdFN0eWxlRGlmZmVyZW5jZShk aWZmLCBjb250ZXh0U2Vuc2l0aXZlUHJvcGVydGllcyk7CiAKICAgICBzdHlsZVdpbGxDaGFuZ2Uo ZGlmZiwgc3R5bGUuZ2V0KCkpOwotICAgIAorCiAgICAgUmVmUHRyPFJlbmRlclN0eWxlPiBvbGRT dHlsZSA9IG1fc3R5bGUucmVsZWFzZSgpOwogICAgIG1fc3R5bGUgPSBzdHlsZTsKIAotICAgIHVw ZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+YmFja2dyb3VuZExheWVycygpIDog MCwgbV9zdHlsZSA/IG1fc3R5bGUtPmJhY2tncm91bmRMYXllcnMoKSA6IDApOwotICAgIHVwZGF0 ZUZpbGxJbWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+bWFza0xheWVycygpIDogMCwgbV9zdHls ZSA/IG1fc3R5bGUtPm1hc2tMYXllcnMoKSA6IDApOwotCi0gICAgdXBkYXRlSW1hZ2Uob2xkU3R5 bGUgPyBvbGRTdHlsZS0+Ym9yZGVySW1hZ2UoKS5pbWFnZSgpIDogMCwgbV9zdHlsZSA/IG1fc3R5 bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSA6IDApOwotICAgIHVwZGF0ZUltYWdlKG9sZFN0eWxl ID8gb2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCkgOiAwLCBtX3N0eWxlID8gbV9zdHls ZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSA6IDApOworICAgIGlmIChvbGRTdHlsZSkgeworICAg ICAgICBpZiAobV9zdHlsZSkgeworICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJEaXJlY3Rp dmVNYXAqIHBDb3VudGVyRGlyZWN0aXZlTWFwID0KKyAgICAgICAgICAgICAgICBtX3N0eWxlLT5j b3VudGVyRGlyZWN0aXZlcygpKSB7CisgICAgICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJE aXJlY3RpdmVNYXAqIHBPbGRDb3VudGVyRGlyZWN0aXZlTWFwCisgICAgICAgICAgICAgICAgICAg ID1vbGRTdHlsZS0+Y291bnRlckRpcmVjdGl2ZXMoKSkgeworICAgICAgICAgICAgICAgICAgICBD b3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPQorICAgICAgICAgICAgICAg ICAgICAgICAgcENvdW50ZXJEaXJlY3RpdmVNYXAtPmVuZCgpOworICAgICAgICAgICAgICAgICAg ICBmb3IgKENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ICAgICAgICAgICAg ICAgICA9IHBDb3VudGVyRGlyZWN0aXZlTWFwLT5iZWdpbigpOworICAgICAgICAgICAgICAgICAg ICAgICAgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAocE9s ZENvdW50ZXJEaXJlY3RpdmVNYXAtPmNvbnRhaW5zKGl0LT5maXJzdCkpIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICBpZiAocE9sZENvdW50ZXJEaXJlY3RpdmVNYXAtPmdldChpdC0+Zmly c3QpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICE9IGl0LT5zZWNvbmQpCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVy Tm9kZSh0aGlzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXQtPmZpcnN0 KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKHRoaXMsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGl0LT5maXJzdCk7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyQ291bnRlcjo6Y3JlYXRlQ291bnRlcklmTmVlZGVkKHRoaXMsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkp KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICBlbmQgPSBwT2xkQ291bnRlckRpcmVjdGl2ZU1hcC0+ZW5kKCk7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0 b3IgaXQKKyAgICAgICAgICAgICAgICAgICAgICAgID0gcE9sZENvdW50ZXJEaXJlY3RpdmVNYXAt PmJlZ2luKCk7CisgICAgICAgICAgICAgICAgICAgICAgICBpdCAhPSBlbmQ7ICsraXQpCisgICAg ICAgICAgICAgICAgICAgICAgICBpZiAoIXBDb3VudGVyRGlyZWN0aXZlTWFwLT5jb250YWlucyhp dC0+Zmlyc3QpKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRl c3Ryb3lDb3VudGVyTm9kZSh0aGlzLCBpdC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9k ZXModGhpcyk7CisgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50 ZXJzKHRoaXMpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAobV9o YXNDb3VudGVyTm9kZU1hcCkKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95 Q291bnRlck5vZGVzKHRoaXMpOwogCi0gICAgLy8gV2UgbmVlZCB0byBlbnN1cmUgdGhhdCB2aWV3 LT5tYXhpbWFsT3V0bGluZVNpemUoKSBpcyB2YWxpZCBmb3IgYW55IHJlcGFpbnRzIHRoYXQgaGFw cGVuCi0gICAgLy8gZHVyaW5nIHN0eWxlRGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92 ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCi0gICAgaWYgKG1fc3R5bGUtPm91dGxpbmVXaWR0aCgp ID4gMCAmJiBtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpID4gbWF4aW1hbE91dGxpbmVTaXplKFBhaW50 UGhhc2VPdXRsaW5lKSkKLSAgICAgICAgdG9SZW5kZXJWaWV3KGRvY3VtZW50KCktPnJlbmRlcmVy KCkpLT5zZXRNYXhpbWFsT3V0bGluZVNpemUobV9zdHlsZS0+b3V0bGluZVNpemUoKSk7CisgICAg ICAgICAgICB1cGRhdGVGaWxsSW1hZ2VzKG9sZFN0eWxlLT5iYWNrZ3JvdW5kTGF5ZXJzKCksCisg ICAgICAgICAgICAgICAgbV9zdHlsZS0+YmFja2dyb3VuZExheWVycygpKTsKKyAgICAgICAgICAg IHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUtPm1hc2tMYXllcnMoKSwgbV9zdHlsZS0+bWFza0xh eWVycygpKTsKKworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUtPmJvcmRlckltYWdl KCkuaW1hZ2UoKSwKKyAgICAgICAgICAgICAgICBtX3N0eWxlLT5ib3JkZXJJbWFnZSgpLmltYWdl KCkpOworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmlt YWdlKCksCisgICAgICAgICAgICAgICAgbV9zdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSk7 CisgICAgICAgICAgICAvLyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1heGltYWxPdXRs aW5lU2l6ZSgpIGlzIHZhbGlkIGZvciAKKyAgICAgICAgICAgIC8vIGFueSByZXBhaW50cyB0aGF0 IGhhcHBlbiBkdXJpbmcgc3R5bGVEaWRDaGFuZ2UgKGl0J3MgdXNlZCBieQorICAgICAgICAgICAg Ly8gY2xpcHBlZE92ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCisgICAgICAgICAgICBpZiAobV9z dHlsZS0+b3V0bGluZVdpZHRoKCkgPiAwICYmIG1fc3R5bGUtPm91dGxpbmVTaXplKCkgPgorICAg ICAgICAgICAgICAgIG1heGltYWxPdXRsaW5lU2l6ZShQYWludFBoYXNlT3V0bGluZSkpIHsKKyAg ICAgICAgICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+cmVuZGVyZXIoKSktPnNldE1h eGltYWxPdXRsaW5lU2l6ZSgKKyAgICAgICAgICAgICAgICAgICAgbV9zdHlsZS0+b3V0bGluZVNp emUoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBpZiAo bV9oYXNDb3VudGVyTm9kZU1hcCkKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0 cm95Q291bnRlck5vZGVzKHRoaXMpOworICAgICAgICAgICAgdXBkYXRlRmlsbEltYWdlcyhvbGRT dHlsZS0+YmFja2dyb3VuZExheWVycygpLCAwKTsKKyAgICAgICAgICAgIHVwZGF0ZUZpbGxJbWFn ZXMob2xkU3R5bGUtPm1hc2tMYXllcnMoKSwgMCk7CisKKyAgICAgICAgICAgIHVwZGF0ZUltYWdl KG9sZFN0eWxlLT5ib3JkZXJJbWFnZSgpLmltYWdlKCksIDApOworICAgICAgICAgICAgdXBkYXRl SW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCksIDApOworICAgICAgICB9Cisg ICAgfSBlbHNlIGlmIChtX3N0eWxlKSB7CisgICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNv dW50ZXIodGhpcyk7CisgICAgICAgIHVwZGF0ZUZpbGxJbWFnZXMoMCwgbV9zdHlsZS0+YmFja2dy b3VuZExheWVycygpKTsKKyAgICAgICAgdXBkYXRlRmlsbEltYWdlcygwLCBtX3N0eWxlLT5tYXNr TGF5ZXJzKCkpOworCisgICAgICAgIHVwZGF0ZUltYWdlKDAsIG1fc3R5bGUtPmJvcmRlckltYWdl KCkuaW1hZ2UoKSk7CisgICAgICAgIHVwZGF0ZUltYWdlKDAsIG1fc3R5bGUtPm1hc2tCb3hJbWFn ZSgpLmltYWdlKCkpOworICAgICAgICAvLyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1h eGltYWxPdXRsaW5lU2l6ZSgpIGlzIHZhbGlkIGZvciBhbnkgcmVwYWludHMgdGhhdCBoYXBwZW4K KyAgICAgICAgLy8gZHVyaW5nIHN0eWxlRGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92 ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCisgICAgICAgIGlmIChtX3N0eWxlLT5vdXRsaW5lV2lk dGgoKSA+IDAgJiYgbV9zdHlsZS0+b3V0bGluZVNpemUoKSA+IG1heGltYWxPdXRsaW5lU2l6ZShQ YWludFBoYXNlT3V0bGluZSkpCisgICAgICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+ cmVuZGVyZXIoKSktPnNldE1heGltYWxPdXRsaW5lU2l6ZShtX3N0eWxlLT5vdXRsaW5lU2l6ZSgp KTsKKyAgICB9CiAKICAgICBzdHlsZURpZENoYW5nZShkaWZmLCBvbGRTdHlsZS5nZXQoKSk7CiAK QEAgLTE2MDgsNyArMTY3MCw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShT dHlsZUQKIAogICAgIGlmICghbV9wYXJlbnQpCiAgICAgICAgIHJldHVybjsKLSAgICAKKwogICAg IGlmIChkaWZmID09IFN0eWxlRGlmZmVyZW5jZUxheW91dCkKICAgICAgICAgc2V0TmVlZHNMYXlv dXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7CiAgICAgZWxzZSBpZiAoZGlmZiA9PSBTdHlsZURpZmZl cmVuY2VMYXlvdXRQb3NpdGlvbmVkTW92ZW1lbnRPbmx5KQpJbmRleDogV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmgJKHJldmlzaW9uIDUwNTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE4Nyw3ICsxODcsNyBAQCBwdWJsaWM6CiAgICAgLy8g Q29udmVuaWVuY2UgZnVuY3Rpb24gZm9yIGdldHRpbmcgdG8gdGhlIG5lYXJlc3QgZW5jbG9zaW5n IGJveCBvZiBhIFJlbmRlck9iamVjdC4KICAgICBSZW5kZXJCb3gqIGVuY2xvc2luZ0JveCgpIGNv bnN0OwogICAgIAotICAgIHZpcnR1YWwgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gZmly c3RDaGlsZCgpID09IDA7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0 dXJuIGZpcnN0Q2hpbGQoKTsgfQogCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgc2V0SGFzQVhP YmplY3QoYm9vbCBmbGFnKSB7IG1faGFzQVhPYmplY3QgPSBmbGFnOyB9CkBAIC02NDcsNyArNjQ3 LDcgQEAgcHVibGljOgogCiAgICAgLy8gVGhlIGN1cnJlbnQgc2VsZWN0aW9uIHN0YXRlIGZvciBh biBvYmplY3QuICBGb3IgYmxvY2tzLCB0aGUgc3RhdGUgcmVmZXJzIHRvIHRoZSBzdGF0ZSBvZiB0 aGUgbGVhZgogICAgIC8vIGRlc2NlbmRhbnRzIChhcyBkZXNjcmliZWQgYWJvdmUgaW4gdGhlIFNl bGVjdGlvblN0YXRlIGVudW0gZGVjbGFyYXRpb24pLgotICAgIFNlbGVjdGlvblN0YXRlIHNlbGVj dGlvblN0YXRlKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8U2VsZWN0aW9uU3RhdGU+KG1f c2VsZWN0aW9uU3RhdGUpOzsgfQorICAgIFNlbGVjdGlvblN0YXRlIHNlbGVjdGlvblN0YXRlKCkg Y29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8U2VsZWN0aW9uU3RhdGU+KG1fc2VsZWN0aW9uU3Rh dGUpOyB9CiAKICAgICAvLyBTZXRzIHRoZSBzZWxlY3Rpb24gc3RhdGUgZm9yIGFuIG9iamVjdC4K ICAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZWN0aW9uU3RhdGUoU2VsZWN0aW9uU3RhdGUgc3RhdGUp IHsgbV9zZWxlY3Rpb25TdGF0ZSA9IHN0YXRlOyB9CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5n L1JlbmRlck9iamVjdENoaWxkTGlzdC5jcHAJKHJldmlzaW9uIDUwNTIyKQorKysgV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjcx LDI0ICsyNzEsMjkgQEAgc3RhdGljIFJlbmRlck9iamVjdCogZmluZEJlZm9yZUFmdGVyUGFyZQog ICAgIHJldHVybiBiZWZvcmVBZnRlclBhcmVudDsKIH0KIAotc3RhdGljIHZvaWQgaW52YWxpZGF0 ZUNvdW50ZXJzSW5Db250YWluZXIoUmVuZGVyT2JqZWN0KiBjb250YWluZXIpCitzdGF0aWMgdm9p ZCBpbnZhbGlkYXRlQ291bnRlcnNJbkNvbnRhaW5lcihSZW5kZXJPYmplY3QqIGNvbnRhaW5lciwg QXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllcikKIHsKICAgICBpZiAoIWNvbnRhaW5lcikKICAg ICAgICAgcmV0dXJuOwogICAgIGNvbnRhaW5lciA9IGZpbmRCZWZvcmVBZnRlclBhcmVudChjb250 YWluZXIpOwogICAgIGlmICghY29udGFpbmVyKQogICAgICAgICByZXR1cm47CisgICAgLy9Tb21l dGltZXMgdGhlIGNvdW50ZXIgaXMgYXR0YWNoZWQgZGlyZWN0bHkgb24gdGhlIGNvbnRhaW5lci4K KyAgICBpZiAoY29udGFpbmVyLT5pc0NvdW50ZXIoKSkgeworICAgICAgICB0b1JlbmRlckNvdW50 ZXIoY29udGFpbmVyKS0+aW52YWxpZGF0ZShpZGVudGlmaWVyKTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KICAgICBmb3IgKFJlbmRlck9iamVjdCogY29udGVudCA9IGNvbnRhaW5lci0+Zmlyc3RD aGlsZCgpOyBjb250ZW50OyBjb250ZW50ID0gY29udGVudC0+bmV4dFNpYmxpbmcoKSkgewogICAg ICAgICBpZiAoY29udGVudC0+aXNDb3VudGVyKCkpCi0gICAgICAgICAgICB0b1JlbmRlckNvdW50 ZXIoY29udGVudCktPmludmFsaWRhdGUoKTsKKyAgICAgICAgICAgIHRvUmVuZGVyQ291bnRlcihj b250ZW50KS0+aW52YWxpZGF0ZShpZGVudGlmaWVyKTsKICAgICB9CiB9CiAKLXZvaWQgUmVuZGVy T2JqZWN0Q2hpbGRMaXN0OjppbnZhbGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lcikK K3ZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0OjppbnZhbGlkYXRlQ291bnRlcnMoUmVuZGVyT2Jq ZWN0KiBvd25lciwgQXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllcikKIHsKICAgICBBU1NFUlQo IW93bmVyLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkpOwotICAgIGludmFsaWRhdGVDb3VudGVy c0luQ29udGFpbmVyKGJlZm9yZUFmdGVyQ29udGFpbmVyKG93bmVyLCBCRUZPUkUpKTsKLSAgICBp bnZhbGlkYXRlQ291bnRlcnNJbkNvbnRhaW5lcihiZWZvcmVBZnRlckNvbnRhaW5lcihvd25lciwg QUZURVIpKTsKKyAgICBpbnZhbGlkYXRlQ291bnRlcnNJbkNvbnRhaW5lcihiZWZvcmVBZnRlckNv bnRhaW5lcihvd25lciwgQkVGT1JFKSwgaWRlbnRpZmllcik7CisgICAgaW52YWxpZGF0ZUNvdW50 ZXJzSW5Db250YWluZXIoYmVmb3JlQWZ0ZXJDb250YWluZXIob3duZXIsIEFGVEVSKSwgaWRlbnRp Zmllcik7CiB9CiAKIHZvaWQgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0Ojp1cGRhdGVCZWZvcmVBZnRl ckNvbnRlbnQoUmVuZGVyT2JqZWN0KiBvd25lciwgUHNldWRvSWQgdHlwZSwgUmVuZGVyT2JqZWN0 KiBzdHlsZWRPYmplY3QpCkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGls ZExpc3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3RDaGls ZExpc3QuaAkocmV2aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3RDaGlsZExpc3QuaAkod29ya2luZyBjb3B5KQpAQCAtMzEsNiArMzEsNyBAQAogbmFtZXNwYWNl IFdlYkNvcmUgewogCiBjbGFzcyBSZW5kZXJPYmplY3Q7CitjbGFzcyBBdG9taWNTdHJpbmdJbXBs OwogCiBjbGFzcyBSZW5kZXJPYmplY3RDaGlsZExpc3QgewogcHVibGljOgpAQCAtNTUsNyArNTYs MTEgQEAgcHVibGljOgogICAgIHZvaWQgaW5zZXJ0Q2hpbGROb2RlKFJlbmRlck9iamVjdCogb3du ZXIsIFJlbmRlck9iamVjdCogY2hpbGQsIFJlbmRlck9iamVjdCogYmVmb3JlLCBib29sIGZ1bGxJ bnNlcnQgPSB0cnVlKTsKIAogICAgIHZvaWQgdXBkYXRlQmVmb3JlQWZ0ZXJDb250ZW50KFJlbmRl ck9iamVjdCogb3duZXIsIFBzZXVkb0lkIHR5cGUsIFJlbmRlck9iamVjdCogc3R5bGVkT2JqZWN0 ID0gMCk7Ci0gICAgdm9pZCBpbnZhbGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lcik7 CisKKyAgICAvKiBJbnZhbGlkYXRlcyBhbGwgY291bnRlcnMgd2l0aCB0aGUgZ2l2ZW4gaWRlbnRp ZmllciBpbiBjaGlsZHJlbiBvZiBvd25lci4KKyAgICAgKiBJZiBpZGVudGlmaWVyIGlzIE5VTEwg KGRlZmF1bHQpIGFsbCBjb3VudGVycyBhcmUgaW52YWxpZGF0ZWQKKyAgICAgKi8KKyAgICB2b2lk IGludmFsaWRhdGVDb3VudGVycyhSZW5kZXJPYmplY3QqIG93bmVyLCBBdG9taWNTdHJpbmdJbXBs ICppZGVudGlmaWVyID0gMCk7CiAKIHByaXZhdGU6CiAgICAgUmVuZGVyT2JqZWN0KiBtX2ZpcnN0 Q2hpbGQ7CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1MDU3OSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDA5LTExLTA1ICBDYXJvbCBTemFi byAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBbm90aGVyIGNyYXp5IGNvdW50ZXJzIGJ1ZworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEwMzEKKyAgICAgICAgQWRk ZWQgdGVzdHMgZm9yIGR5bmFtaWMgRE9NIGNoYW5nZXMgYWZmZWN0aW5nIGNvdW50ZXJzLgorCisg ICAgICAgICogY3NzMi4xL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBjc3MyLjEvY291bnRlci1yZXNldC0wMDAuaHRtbDogQWRkZWQuCisgICAgICAgICogY3Nz Mi4xL2NvdW50ZXItcmVzZXQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL3F0 L2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAg ICAgKiBwbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDItZXhw ZWN0ZWQudHh0OiBBZGRlZC4KKwogMjAwOS0xMS0wNSAgU2h1IENoYW5nICA8Q2hhbmcuU2h1QG5v a2lhLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGVsZSBQZXRlcnNvbi4KSW5kZXg6IExh eW91dFRlc3RzL2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzND Ly9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2 PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAg PHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50Jzwv dGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIg dGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6 Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5r IHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRt bCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3 dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRl bnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU3R5 bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRl bnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5 cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAg ICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3Jl bWVudDpiZWZvcmUsIC51c2U6YmVmb3JlIHsgY29udGVudDogY291bnRlcnMoYywgIi4iKSAiLSI7 IH0KKyAgICAgICAgLmluY3JlbWVudCB7IGNvdW50ZXItaW5jcmVtZW50OiBjOyB9CisgICAgPC9z dHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CisgICAgICAgIGlmICh3 aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJv bGxlci53YWl0VW50aWxEb25lKCk7CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAg ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9uZSIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xh c3MiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5zZXRBdHRy aWJ1dGUoImNsYXNzIiwgImluY3JlbWVudCIpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInRocmVlIikuc2V0QXR0cmlidXRlKCJzdHlsZSIsICJjb3VudGVyLWluY3JlbWVu dDogYyIpOworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAg ICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAg IH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD48Ym9keSBvbmxvYWQ9InNldFRpbWVvdXQoJ3J1bigp JywgMCkiPgorICAgIDxwPlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2Ft ZTo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+PHNwYW4gaWQ9Im9uZSI+PC9zcGFuPjxzcGFuPjxz cGFuIGNsYXNzPSJyZXNldCI+PHNwYW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGNs YXNzPSJpbmNyZW1lbnQiIGlkPSJ0d28iPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjxzcGFuIHN0eWxl PSJjb3VudGVyLWluY3JlbWVudDogYzsiIGNsYXNzPSJ1c2UiIGlkPSJ0aHJlZSI+PC9zcGFuPjxz cGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZlcmVu Y2UiPjAuMS0wLjItMS0yLTwvZGl2PgorPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVu ZCBvZiBmaWxlCgpQcm9wZXJ0eSBjaGFuZ2VzIG9uOiBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRl ci1pbmNyZW1lbnQtMDAyLmh0bWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5k ZXg6IExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQg SFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxl PkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+ CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9 IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cu dzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0i aGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9w ZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5v cmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRv bSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5 cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3Nz Ij4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3Qs IC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUg eyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsg Y291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0i dGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKwor ICAgICAgICBmdW5jdGlvbiBydW4oKSB7CisgICAgICAgICAgICB2YXIgdCA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCJ0ZXN0Iik7CisgICAgICAgICAgICB2YXIgcyA9IGRvY3VtZW50LmNyZWF0 ZUVsZW1lbnQoInNwYW4iKTsKKyAgICAgICAgICAgIHMuc2V0QXR0cmlidXRlKCJjbGFzcyIsICJy ZXNldCIpOworICAgICAgICAgICAgdC5pbnNlcnRCZWZvcmUocywgdC5jaGlsZE5vZGVzLml0ZW0o MSkpOworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAg fQorICAgIDwvc2NyaXB0PgorPC9oZWFkPjxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgncnVuKCkn LCAwKSI+CisgICAgPHA+VGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1l OjwvcD4KKyAgICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+ PHNwYW4gY2xhc3M9InJlc2V0Ij48L3NwYW4+PHNwYW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFu PjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZl cmVuY2UiPjEtMS4xLTEuMi08L2Rpdj4KKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50 ZXItcmVzZXQtMDAwLmh0bWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5kZXg6 IExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMi5odG1sCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMi5odG1sCShyZXZpc2lvbiAwKQor KysgTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMzIgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRN TCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50 LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNT UyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+Cisg ICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9Ikwu IERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMu b3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVs cCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVm LWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcv VFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIg bmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUi IGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4K KyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5y ZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBj b250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291 bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4 dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKworICAg ICAgICBmdW5jdGlvbiBydW4oKSB7CisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgib25lIikuc2V0QXR0cmlidXRlKCJjbGFzcyIsICJyZXNldCIpOworICAgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInR3byIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAg ICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICB9CisgICAgPC9z Y3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAg ICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAg IDxkaXYgaWQ9InRlc3QiPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3Bhbj48c3Bh biBjbGFzcz0icmVzZXQiIGlkPSJvbmUiPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48 L3NwYW4+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3Bhbj48c3BhbiBp ZD0idHdvIj48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3Bh biBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNl Ij4xLTEuMS0yLTMtNC08L2Rpdj4KKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQg b2YgZmlsZQoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXIt cmVzZXQtMDAyLmh0bWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOm1lcmdlaW5mbwoKSW5kZXg6IExh eW91dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0 ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3Vu dGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzkgQEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYw MAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6 ZSA4MDB4MTAzCisgIFJlbmRlckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHgxMDMKKyAg ICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCwxNikgc2l6ZSA3ODR4NzkKKyAgICAgIFJlbmRlckJs b2NrIHtQfSBhdCAoMCwwKSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0g YXQgKDAsMCkgc2l6ZSAzMTB4MjEKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCAz MTA6ICJUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6IgorICAgICAg UmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMzcpIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlcklu bGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAweDAKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFO fSBhdCAoMCwwKSBzaXplIDU0eDIxCisgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAo MCwwKSBzaXplIDU0eDIxCisgICAgICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDAp IHNpemUgMjd4MjEKKyAgICAgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgw LDApIHNpemUgMjd4MjEKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICgwLDApIHNp emUgMjJ4MjEKKyAgICAgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDIyOiAi MC4xIgorICAgICAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDIyLDApIHNpemUgNXgyMQorICAg ICAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDIyLDApIHdpZHRoIDU6ICItIgorICAgICAgICAg ICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICAg IFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAg ICAgICAgUmVuZGVyQ291bnRlciBhdCAoMjcsMCkgc2l6ZSAyMngyMQorICAgICAgICAgICAgICAg ICAgdGV4dCBydW4gYXQgKDI3LDApIHdpZHRoIDIyOiAiMC4yIgorICAgICAgICAgICAgICAgIFJl bmRlclRleHQgYXQgKDQ5LDApIHNpemUgNXgyMQorICAgICAgICAgICAgICAgICAgdGV4dCBydW4g YXQgKDQ5LDApIHdpZHRoIDU6ICItIgorICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgw LDApIHNpemUgMTR4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkgYXQgKDAs MCkgc2l6ZSAxNHgyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoNTQsMCkgc2l6ZSA5 eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg1NCwwKSB3aWR0aCA5OiAiMSIKKyAgICAg ICAgICAgIFJlbmRlclRleHQgYXQgKDYzLDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0ZXh0 IHJ1biBhdCAoNjMsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0g YXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBh dCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg2OCwwKSBz aXplIDl4MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDY4LDApIHdpZHRoIDk6ICIyIgor ICAgICAgICAgICAgUmVuZGVyVGV4dCBhdCAoNzcsMCkgc2l6ZSA1eDIxCisgICAgICAgICAgICAg IHRleHQgcnVuIGF0ICg3NywwKSB3aWR0aCA1OiAiLSIKKyAgICAgIFJlbmRlckJsb2NrIHtESVZ9 IGF0ICgwLDU4KSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJUZXh0IHsjdGV4dH0gYXQgKDAs MCkgc2l6ZSA4MngyMQorICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDgyOiAiMC4x LTAuMi0xLTItIgpJbmRleDogTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXIt cmVzZXQtMDAwLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9y bS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQor KysgTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMiBAQAorbGF5ZXIgYXQgKDAsMCkgc2l6 ZSA4MDB4NjAwCisgIFJlbmRlclZpZXcgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCitsYXllciBhdCAo MCwwKSBzaXplIDgwMHgxMDMKKyAgUmVuZGVyQmxvY2sge0hUTUx9IGF0ICgwLDApIHNpemUgODAw eDEwMworICAgIFJlbmRlckJvZHkge0JPRFl9IGF0ICg4LDE2KSBzaXplIDc4NHg3OQorICAgICAg UmVuZGVyQmxvY2sge1B9IGF0ICgwLDApIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlclRleHQg eyN0ZXh0fSBhdCAoMCwwKSBzaXplIDMxMHgyMQorICAgICAgICAgIHRleHQgcnVuIGF0ICgwLDAp IHdpZHRoIDMxMDogIlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZToi CisgICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAoMCwzNykgc2l6ZSA3ODR4MjEKKyAgICAgICAg UmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVy SW5saW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgIFJlbmRl ckNvdW50ZXIgYXQgKDAsMCkgc2l6ZSA5eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICgw LDApIHdpZHRoIDk6ICIxIgorICAgICAgICAgICAgUmVuZGVyVGV4dCBhdCAoOSwwKSBzaXplIDV4 MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDksMCkgd2lkdGggNTogIi0iCisgICAgICAg IFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAweDIxCisgICAgICAgIFJlbmRlcklu bGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAweDIxCisgICAgICAgIFJlbmRlcklubGluZSB7U1BB Tn0gYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVk KSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICgxNCww KSBzaXplIDIyeDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICgxNCwwKSB3aWR0aCAyMjog IjEuMSIKKyAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDM2LDApIHNpemUgNXgyMQorICAgICAg ICAgICAgICB0ZXh0IHJ1biBhdCAoMzYsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklu bGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAgIFJlbmRlcklubGluZSAo Z2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICBSZW5kZXJDb3VudGVy IGF0ICg0MSwwKSBzaXplIDIyeDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg0MSwwKSB3 aWR0aCAyMjogIjEuMiIKKyAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDYzLDApIHNpemUgNXgy MQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNjMsMCkgd2lkdGggNTogIi0iCisgICAgICBS ZW5kZXJCbG9jayB7RElWfSBhdCAoMCw1OCkgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVyVGV4 dCB7I3RleHR9IGF0ICgwLDApIHNpemUgNjh4MjEKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCww KSB3aWR0aCA2ODogIjEtMS4xLTEuMi0iCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9j c3MyLjEvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1y ZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQ2IEBACitsYXll ciBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2 MDAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDEwMworICBSZW5kZXJCbG9jayB7SFRNTH0gYXQg KDAsMCkgc2l6ZSA4MDB4MTAzCisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsMTYpIHNpemUg Nzg0eDc5CisgICAgICBSZW5kZXJCbG9jayB7UH0gYXQgKDAsMCkgc2l6ZSA3ODR4MjEKKyAgICAg ICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgMzEweDIxCisgICAgICAgICAgdGV4 dCBydW4gYXQgKDAsMCkgd2lkdGggMzEwOiAiVGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxk IGJlIHRoZSBzYW1lOiIKKyAgICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDM3KSBzaXplIDc4 NHgyMQorICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMTR4MjEKKyAg ICAgICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkgYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAg ICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoMCwwKSBzaXplIDl4MjEKKyAgICAgICAgICAgICAg dGV4dCBydW4gYXQgKDAsMCkgd2lkdGggOTogIjEiCisgICAgICAgICAgICBSZW5kZXJUZXh0IGF0 ICg5LDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoOSwwKSB3aWR0aCA1 OiAiLSIKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisg ICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAg ICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAgICAg ICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAg ICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICgxNCwwKSBzaXplIDIyeDIxCisgICAgICAgICAgICAg ICAgICB0ZXh0IHJ1biBhdCAoMTQsMCkgd2lkdGggMjI6ICIxLjEiCisgICAgICAgICAgICAgICAg UmVuZGVyVGV4dCBhdCAoMzYsMCkgc2l6ZSA1eDIxCisgICAgICAgICAgICAgICAgICB0ZXh0IHJ1 biBhdCAoMzYsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQg KDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAo MCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg0MSwwKSBzaXpl IDl4MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDQxLDApIHdpZHRoIDk6ICIyIgorICAg ICAgICAgICAgUmVuZGVyVGV4dCBhdCAoNTAsMCkgc2l6ZSA1eDIxCisgICAgICAgICAgICAgIHRl eHQgcnVuIGF0ICg1MCwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFO fSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAo MCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDAp IHNpemUgMTR4MjEKKyAgICAgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgw LDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyIGF0ICg1NSwwKSBz aXplIDl4MjEKKyAgICAgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg1NSwwKSB3aWR0aCA5OiAi MyIKKyAgICAgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICg2NCwwKSBzaXplIDV4MjEKKyAgICAg ICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg2NCwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAgUmVu ZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVySW5s aW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgIFJlbmRlckNv dW50ZXIgYXQgKDY5LDApIHNpemUgOXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNjks MCkgd2lkdGggOTogIjQiCisgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICg3OCwwKSBzaXplIDV4 MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDc4LDApIHdpZHRoIDU6ICItIgorICAgICAg UmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsNTgpIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlclRl eHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDgzeDIxCisgICAgICAgICAgdGV4dCBydW4gYXQgKDAs MCkgd2lkdGggODM6ICIxLTEuMS0yLTMtNC0iCg== 42655 2009-11-06 09:17:38 -0800 2009-11-18 22:08:00 -0800 Proposed Patch - Fixes error in RenderObject::isEmpty as suggested by Mitz patchFor11031-3.patch text/plain 51842 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MDU3OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODIgQEAKKzIwMDktMTEtMDUgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorICAgICAgICBUaGlzIHBhdGNoIGZpeGVzIHRoZSBD U1MyLjEgY291bnRlciBpbXBsZW1lbnRhdGlvbiBzdWNoIHRoYXQgaXQKKyAgICAgICAgY29uZm9y bXMgdG8gdGhlIGxhdGVzdCBzY29waW5nIGFuZCBuZXN0aW5nIHJ1bGVzIGFuZCB1cGRhdGVzCisg ICAgICAgIHRoZSB2YWx1ZXMgb2YgdGhlIGNvdW50ZXJzIHdoZW4gdGhlIERPTSBpcyBjaGFuZ2Vk LgorCisgICAgICAgIFRlc3RzOiBjc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKKyAg ICAgICAgICAgICAgIGNzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCisgICAgICAgICAgICAg ICBjc3MyLjEvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL0Nv dW50ZXJOb2RlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpjb21wdXRlQ291 bnRJblBhcmVudCk6CisgICAgICAgIENoYW5nZWQgdG8gdXNlIGlzUmVzZXQoKSBpbnN0ZWFkIG9m IG1faXNSZXNldCBpbiBvcmRlciB0byBiZSBpbnN5bmMKKyAgICAgICAgd2l0aCB0aGUgY2hhbmdl IGluIG1lYW5pbmcgb2YgbV9pc1Jlc2V0IHdoaWNoIG5vdyBtZWFucyB0aGF0IHRoZQorICAgICAg ICBjb3VudGVyIGlzIG9mIHJlc2V0IHR5cGUgYmVjYXVzZSBpdCB3YXMgc3R5bGVkIGFzIHN1Y2gg dmVyc3VzIHRoZQorICAgICAgICBvbGQgbWVhbmluZyB0aGF0IGl0IGlzIHJlc2V0IGVpdGhlciBi ZWNhdXNlIG9mIHRoZSBzdHlsZXNoZWV0IG9yIAorICAgICAgICBiZWNhdXNlIGl0IGlzIHRoZSBm aXJzdCByZWZlcmVuY2UgdG8gdGhpcyBjb3VudGVyIGlkZW50aWZpZXIuCisgICAgICAgIChXZWJD b3JlOjpDb3VudGVyTm9kZTo6cmVzZXRSZW5kZXJlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3Vu dGVyTm9kZTo6cmVzZXRSZW5kZXJlcnMpOgorICAgICAgICBJbnRyb2R1Y2VkIHRvIGVuY2Fwc3Vs YXRlIGNvZGUgdGhhdCBpbnZhbGlkYXRlcyBjb3VudGVyIHJlZmVyZW5jZXMKKyAgICAgICAgaW4g cmVuZGVyZXJzIHdoZW4gYSBjb3VudGVyJ3MgdmFsdWUgbWF5IGNoYW5nZS4KKyAgICAgICAgKFdl YkNvcmU6OkNvdW50ZXJOb2RlOjpyZWNvdW50KToKKyAgICAgICAgQ2hhbmdlIGp1c3QgaW4gbGF5 b3V0LCBubyBmdW5jdGlvbmFsIGNoYW5nZS4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2Rl OjppbnNlcnRBZnRlcik6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVtb3ZlQ2hp bGQpOgorICAgICAgICBDaGFuZ2VkIHRvIHByb3Blcmx5IGludmFsaWRhdGUgdGhlIGNvdW50ZXIg aGllcmFyY2h5IHdoZW4gYSByZXNldAorICAgICAgICBub2RlIGlzIGluc2VydGVkIG9lIHJlbW92 ZWQgaW4vZnJvbSB0aGUgdHJlZS4KKyAgICAgICAgKFdlYkNvcmU6OnNob3dUcmVlQW5kTWFyayk6 CisgICAgICAgIENoYW5nZWQgdG8gZW5yaWNoIHRoZSBsaXN0ZWQgZGVidWdnaW5nIGluZm9ybWF0 aW9uLgorICAgICAgICAqIHJlbmRlcmluZy9Db3VudGVyTm9kZS5oOgorICAgICAgICAoV2ViQ29y ZTo6Q291bnRlck5vZGU6OmlzUmVzZXQpOgorICAgICAgICBDaGFuZ2VkIHRvIGNvdmVyIGJvdGgg Y2FzZXMgd2hlbiBhIGNvdW50ZXIgYWN0cyBhcyBhIHJlc2V0IGNvdW50ZXIuCisgICAgICAgIChX ZWJDb3JlOjpDb3VudGVyTm9kZTo6aXNUeXBlUmVzZXQpOgorICAgICAgICBJbnRyb2R1Y2VkIHRv IGVuYWJsZSBleHRyYWN0aW9uIG9mIHRoZSBjb3VudGVyIHR5cGUgYWNjb3JkaW5nIHRvIHRoZQor ICAgICAgICBzdHlsZSBzaGVldC4KKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjp2YWx1 ZSk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Y291bnRJblBhcmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cmVuZGVyZXIpOgorICAgICAgICAoV2ViQ29yZTo6 Q291bnRlck5vZGU6OnBhcmVudCk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6cHJl dmlvdXNTaWJsaW5nKToKKyAgICAgICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpuZXh0U2libGlu Zyk6CisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6Zmlyc3RDaGlsZCk6CisgICAgICAg IChXZWJDb3JlOjpDb3VudGVyTm9kZTo6bGFzdENoaWxkKToKKyAgICAgICAgSnVzdCBmb3JjZWQg aW5saW5lIGZvciBzcGVlZC4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpmaW5kUGxhY2VGb3JDb3VudGVyKToKKyAgICAgICAgQ29tcGxl dGVseSByZXdyaXR0ZW4gdGhlIGFsZ29yaXRobSB0byBhY2NvdW50IGZvciBjdXJyZW50IGNvdW50 ZXIKKyAgICAgICAgc2NvcGluZyBydWxlcyBhbmQgdG8gcHJvcGVybHkgaGFuZGxlIHJhbmRvbSBj b3VudGVyIGluc2VydGlvbnMuCisgICAgICAgIChXZWJDb3JlOjpjb3VudGVyKToKKyAgICAgICAg QWRkZWQgY29kZSB0byByZWV2YWx1YXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB1cG9uIG5ldyBy b290IGNvdW50ZXIKKyAgICAgICAgY3JlYXRpb24sIGFkZGFwdGVkIHRvIG5ldyBpc1Jlc2V0IHNl bWFudGljcy4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNvdW50ZXI6OmludmFsaWRhdGUpOgor ICAgICAgICBBZGRlZCBvcHRpb24gdG8gY29uZGl0aW9uYWxseSBpbnZhbGlkYXRlIHRoZSBjb3Vu dGVyIGJ5IGlkLgorICAgICAgICAoV2ViQ29yZTo6ZGVzdHJveUNvdW50ZXJOb2RlV2l0aG91dE1h cFJlbW92YWwpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50 ZXJOb2Rlcyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRl ck5vZGUpOgorICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBzZWxlY3RpdmUgY29udGVyIG5vZGUg ZGVzdHJ1Y3Rpb24uCisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJDb3VudGVyOjpjcmVhdGVDb3Vu dGVySWZOZWVkZWQpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291 bnRlcnMpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcik6 CisgICAgICAgIE5ldyBmdW5jdGlvbnMgdGhhdCBzdXBwb3J0IGR5bmFtaWMgY291bnRlciBoaWVy YXJjaHkgdXBkYXRlIHVwb24gRE9NCisgICAgICAgIGNoYW5nZXMKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVyQ291bnRlci5oOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRDaGlsZCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnNldFN0eWxlKToKKyAgICAgICAgQWRkZWQgaG9va3MgdG8g dXBkYXRlIHRoZSBjb3VudGVyIGhpZXJhcmNoeSB3aGVuIHRoZSBET00gY2hhbmdlcy4KKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OmludmFsaWRhdGVDb3VudGVyc0luQ29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlck9iamVjdENoaWxkTGlzdDo6aW52YWxpZGF0ZUNvdW50ZXJzKToKKyAgICAgICAgQWRkZWQg c3VwcG9ydCBmb3Igc2VsZWN0aXZlIGNvdW50ZXIgaW52YWxpZGF0aW9uIGFuZCBleHRlbmRlZCB0 aGUKKyAgICAgICAgc2NvcGUgb2YgdGhlIGludmFsaWRhdGlvbiB0byB0aGUgY29udGFpbmVyIGl0 c2VsZiBhcyBzb21lIGNvdW50ZXJzCisgICAgICAgIGhhbmcgZGlyZWN0bHkgb2ZmIG9mIGl0Lgor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3RDaGlsZExpc3QuaDoKKwogMjAwOS0xMS0w NSAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgRGltaXRyaSBHbGF6a292LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRlck5vZGUu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2 aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTI0LDE2ICsyNCwxMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIkNvdW50ZXJOb2RlLmgiCiAKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVk ZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSA8c3RkaW8uaD4KIAotLy8gRklYTUU6IFRoZXJl J3MgY3VycmVudGx5IG5vIHN0cmF0ZWd5IGZvciBnZXR0aW5nIHRoZSBjb3VudGVyIHRyZWUgdXBk YXRlZCB3aGVuIG5ldwotLy8gZWxlbWVudHMgd2l0aCBjb3VudGVyLXJlc2V0IGFuZCBjb3VudGVy LWluY3JlbWVudCBzdHlsZXMgYXJlIGFkZGVkIHRvIHRoZSByZW5kZXIgdHJlZS4KLS8vIEFsc28s IHRoZSBjb2RlIGNhbid0IGhhbmRsZSBjaGFuZ2VzIHdoZXJlIGFuIGV4aXN0aW5nIG5vZGUgbmVl ZHMgdG8gY2hhbmdlIGludG8gYQotLy8gInJlc2V0IiBub2RlLCBvciBmcm9tIGEgInJlc2V0IiBu b2RlIGJhY2sgdG8gbm90IGEgInJlc2V0IiBub2RlLiBBcyBvZiB0aGlzIHdyaXRpbmcsCi0vLyBh dCBsZWFzdCBzb21lIG9mIHRoZXNlIHByb2JsZW1zIG1hbmlmZXN0IGFzIGZhaWx1cmVzIGluIHRo ZSB0MTIwNC1pbmNyZW1lbnQgYW5kCi0vLyB0MTIwNC1yZXNldCB0ZXN0cyBpbiB0aGUgQ1NTIDIu MSB0ZXN0IHN1aXRlLgotCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIENvdW50ZXJOb2RlOjpDb3Vu dGVyTm9kZShSZW5kZXJPYmplY3QqIG8sIGJvb2wgaXNSZXNldCwgaW50IHZhbHVlKQpAQCAtNTEs MTQgKzQ1LDI4IEBAIENvdW50ZXJOb2RlOjpDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqIG8KIAog aW50IENvdW50ZXJOb2RlOjpjb21wdXRlQ291bnRJblBhcmVudCgpIGNvbnN0CiB7Ci0gICAgaW50 IGluY3JlbWVudCA9IG1faXNSZXNldCA/IDAgOiBtX3ZhbHVlOworICAgIGludCBpbmNyZW1lbnQg PSBpc1Jlc2V0KCkgPyAwIDogbV92YWx1ZTsKICAgICBpZiAobV9wcmV2aW91c1NpYmxpbmcpCiAg ICAgICAgIHJldHVybiBtX3ByZXZpb3VzU2libGluZy0+bV9jb3VudEluUGFyZW50ICsgaW5jcmVt ZW50OwogICAgIEFTU0VSVChtX3BhcmVudC0+bV9maXJzdENoaWxkID09IHRoaXMpOwogICAgIHJl dHVybiBtX3BhcmVudC0+bV92YWx1ZSArIGluY3JlbWVudDsKIH0KIAotdm9pZCBDb3VudGVyTm9k ZTo6cmVjb3VudCgpCit2b2lkIENvdW50ZXJOb2RlOjpyZXNldFJlbmRlcmVyKEF0b21pY1N0cmlu Z0ltcGwqIGlkZW50aWZpZXIpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgIW1fcmVuZGVyZXIt PmRvY3VtZW50QmVpbmdEZXN0cm95ZWQoKSkKKyAgICAgICAgaWYgKFJlbmRlck9iamVjdENoaWxk TGlzdCogY2hpbGRyZW4gPSBtX3JlbmRlcmVyLT52aXJ0dWFsQ2hpbGRyZW4oKSkKKyAgICAgICAg ICAgIGNoaWxkcmVuLT5pbnZhbGlkYXRlQ291bnRlcnMobV9yZW5kZXJlciwgaWRlbnRpZmllcik7 Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlc2V0UmVuZGVyZXJzKEF0b21pY1N0cmluZ0ltcGwg KmlkZW50aWZpZXIpCit7CisgICAgcmVzZXRSZW5kZXJlcihpZGVudGlmaWVyKTsKKyAgICBmb3Ig KENvdW50ZXJOb2RlKiBjID0gbV9maXJzdENoaWxkOyBjIDsgYyA9IGMtPm1fbmV4dFNpYmxpbmcp CisgICAgICAgIGMtPnJlc2V0UmVuZGVyZXJzKGlkZW50aWZpZXIpOworfQorCit2b2lkIENvdW50 ZXJOb2RlOjpyZWNvdW50KEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpCiB7CiAgICAgZm9y IChDb3VudGVyTm9kZSogYyA9IHRoaXM7IGM7IGMgPSBjLT5tX25leHRTaWJsaW5nKSB7CiAgICAg ICAgIGludCBvbGRDb3VudCA9IGMtPm1fY291bnRJblBhcmVudDsKQEAgLTY2LDE4ICs3NCwxMyBA QCB2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50KCkKICAgICAgICAgaWYgKG9sZENvdW50ID09IG5l d0NvdW50KQogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGMtPm1fY291bnRJblBhcmVudCA9 IG5ld0NvdW50OwotICAgICAgICAvLyBtX3JlbmRlcmVyIGNvbnRhaW5zIHRoZSBwYXJlbnQgb2Yg dGhlIHJlbmRlciBub2RlCi0gICAgICAgIC8vIGNvcnJlc3BvbmRpbmcgdG8gYSBDb3VudGVyTm9k ZS4gTGV0J3MgZmluZCB0aGUgY291bnRlcgotICAgICAgICAvLyBjaGlsZCBhbmQgbWFrZSB0aGlz IHJlLWxheW91dC4KLSAgICAgICAgZm9yIChSZW5kZXJPYmplY3QqIG8gPSBjLT5tX3JlbmRlcmVy LT5maXJzdENoaWxkKCk7IG87IG8gPSBvLT5uZXh0U2libGluZygpKQotICAgICAgICAgICAgaWYg KCFvLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkgJiYgby0+aXNDb3VudGVyKCkpIHsKLSAgICAg ICAgICAgICAgICBvLT5zZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKLSAgICAg ICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgIH0KKyAgICAgICAgLy9SZWxheW91dCBhbGwg Y291bnRlcnMgdGhhdCBtYXkgYmUgYWZmZWN0ZWQgYnkgdGhpcyBjaGFuZ2UKKyAgICAgICAgYy0+ cmVzZXRSZW5kZXJlcnMoaWRlbnRpZmllcik7CiAgICAgfQogfQogCi12b2lkIENvdW50ZXJOb2Rl OjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGls ZCkKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwK KyAgICBDb3VudGVyTm9kZSogcmVmQ2hpbGQsIEF0b21pY1N0cmluZ0ltcGwgKmlkZW50aWZpZXIp CiB7CiAgICAgQVNTRVJUKG5ld0NoaWxkKTsKICAgICBBU1NFUlQoIW5ld0NoaWxkLT5tX3BhcmVu dCk7CkBAIC04NSw2ICs4OCwxNCBAQCB2b2lkIENvdW50ZXJOb2RlOjppbnNlcnRBZnRlcihDb3Vu dGVyTm9kCiAgICAgQVNTRVJUKCFuZXdDaGlsZC0+bV9uZXh0U2libGluZyk7CiAgICAgQVNTRVJU KCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+bV9wYXJlbnQgPT0gdGhpcyk7CiAKKyAgICBpZiAobmV3 Q2hpbGQtPmlzVHlwZVJlc2V0KCkpIHsKKyAgICAgICAgUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+ IGlkZW50aWZpZXJQdHIoaWRlbnRpZmllcik7CisgICAgICAgIHdoaWxlIChtX2xhc3RDaGlsZCAh PSByZWZDaGlsZCkgeworICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJO b2RlKG1fbGFzdENoaWxkLT5yZW5kZXJlcigpLAorICAgICAgICAgICAgICAgIGlkZW50aWZpZXJQ dHIpOworICAgICAgICB9CisgICAgfQorCiAgICAgQ291bnRlck5vZGUqIG5leHQ7CiAKICAgICBp ZiAocmVmQ2hpbGQpIHsKQEAgLTEwOSwxMCArMTIwLDExIEBAIHZvaWQgQ291bnRlck5vZGU6Omlu c2VydEFmdGVyKENvdW50ZXJOb2QKIAogICAgIG5ld0NoaWxkLT5tX2NvdW50SW5QYXJlbnQgPSBu ZXdDaGlsZC0+Y29tcHV0ZUNvdW50SW5QYXJlbnQoKTsKICAgICBpZiAobmV4dCkKLSAgICAgICAg bmV4dC0+cmVjb3VudCgpOworICAgICAgICBuZXh0LT5yZWNvdW50KGlkZW50aWZpZXIpOwogfQog Ci12b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQpCit2 b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQsCisgICAg QXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllcikKIHsKICAgICBBU1NFUlQob2xkQ2hpbGQpOwog ICAgIEFTU0VSVCghb2xkQ2hpbGQtPm1fZmlyc3RDaGlsZCk7CkBAIC0xMzgsOSArMTUwLDkgQEAg dm9pZCBDb3VudGVyTm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZAogICAgICAgICBBU1NFUlQo bV9sYXN0Q2hpbGQgPT0gb2xkQ2hpbGQpOwogICAgICAgICBtX2xhc3RDaGlsZCA9IHByZXY7CiAg ICAgfQotICAgIAorCiAgICAgaWYgKG5leHQpCi0gICAgICAgIG5leHQtPnJlY291bnQoKTsKKyAg ICAgICAgbmV4dC0+cmVjb3VudChpZGVudGlmaWVyKTsKIH0KIAogI2lmbmRlZiBOREVCVUcKQEAg LTE3MiwxNCArMTg0LDEzIEBAIHN0YXRpYyB2b2lkIHNob3dUcmVlQW5kTWFyayhjb25zdCBDb3Vu dGUKICAgICAgICAgcm9vdCA9IHJvb3QtPnBhcmVudCgpOwogCiAgICAgZm9yIChjb25zdCBDb3Vu dGVyTm9kZSogYyA9IHJvb3Q7IGM7IGMgPSBuZXh0SW5QcmVPcmRlcihjKSkgewotICAgICAgICBp ZiAoYyA9PSBub2RlKQotICAgICAgICAgICAgZnByaW50ZihzdGRlcnIsICIqIik7CisgICAgICAg IGZ3cml0ZSgoYyA9PSBub2RlKSA/ICIqIiA6ICIgIiwgMSwgMSwgc3RkZXJyKTsKICAgICAgICAg Zm9yIChjb25zdCBDb3VudGVyTm9kZSogZCA9IGM7IGQgJiYgZCAhPSByb290OyBkID0gZC0+cGFy ZW50KCkpCi0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgIlx0Iik7Ci0gICAgICAgIGlmIChj LT5pc1Jlc2V0KCkpCi0gICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgInJlc2V0OiAlZCAlZFxu IiwgYy0+dmFsdWUoKSwgYy0+Y291bnRJblBhcmVudCgpKTsKLSAgICAgICAgZWxzZQotICAgICAg ICAgICAgZnByaW50ZihzdGRlcnIsICJpbmNyZW1lbnQ6ICVkICVkXG4iLCBjLT52YWx1ZSgpLCBj LT5jb3VudEluUGFyZW50KCkpOworICAgICAgICAgICAgZndyaXRlKCIgICIsIDEsIDIsIHN0ZGVy cik7CisgICAgICAgIGZwcmludGYoc3RkZXJyLCAiMHglMDhYICVzOiAlZCAlZCBQOjB4MDglWCBQ UzoweCUwOFggTlM6MHgwOCVYXG4iLAorICAgICAgICAgICAgKGludCljLCBjLT5pc1Jlc2V0KCkg PyAicmVzZXQiIDogImluY3JlbWVudCIsIGMtPnZhbHVlKCksCisgICAgICAgICAgICBjLT5jb3Vu dEluUGFyZW50KCksIGMtPnBhcmVudCgpLCBjLT5wcmV2aW91c1NpYmxpbmcoKSwKKyAgICAgICAg ICAgIGMtPm5leHRTaWJsaW5nKCkpOwogICAgIH0KIH0KIApJbmRleDogV2ViQ29yZS9yZW5kZXJp bmcvQ291bnRlck5vZGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVy Tm9kZS5oCShyZXZpc2lvbiA1MDUyMikKKysrIFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2Rl LmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDYgKzIyLDcgQEAKICNpZm5kZWYgQ291bnRlck5vZGVf aAogI2RlZmluZSBDb3VudGVyTm9kZV9oCiAKKyNpbmNsdWRlIDx3dGYvQWx3YXlzSW5saW5lLmg+ CiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAKIC8vIFRoaXMgaW1wbGVtZW50cyBhIGNv dW50ZXIgdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgcGFyZW50cyBpbiBjb3VudGVycygp IGxvb2t1cCwKQEAgLTM2LDI4ICszNyw1MyBAQAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFz cyBSZW5kZXJPYmplY3Q7CitjbGFzcyBBdG9taWNTdHJpbmdJbXBsOwogCiBjbGFzcyBDb3VudGVy Tm9kZSA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgQ291bnRlck5vZGUoUmVu ZGVyT2JqZWN0KiwgYm9vbCBpc1Jlc2V0LCBpbnQgdmFsdWUpOwogCi0gICAgYm9vbCBpc1Jlc2V0 KCkgY29uc3QgeyByZXR1cm4gbV9pc1Jlc2V0OyB9Ci0gICAgaW50IHZhbHVlKCkgY29uc3QgeyBy ZXR1cm4gbV92YWx1ZTsgfQotICAgIGludCBjb3VudEluUGFyZW50KCkgY29uc3QgeyByZXR1cm4g bV9jb3VudEluUGFyZW50OyB9Ci0gICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlcigpIGNvbnN0IHsg cmV0dXJuIG1fcmVuZGVyZXI7IH0KLQotICAgIENvdW50ZXJOb2RlKiBwYXJlbnQoKSBjb25zdCB7 IHJldHVybiBtX3BhcmVudDsgfQotICAgIENvdW50ZXJOb2RlKiBwcmV2aW91c1NpYmxpbmcoKSBj b25zdCB7IHJldHVybiBtX3ByZXZpb3VzU2libGluZzsgfQotICAgIENvdW50ZXJOb2RlKiBuZXh0 U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dFNpYmxpbmc7IH0KLSAgICBDb3VudGVyTm9k ZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlyc3RDaGlsZDsgfQotICAgIENvdW50 ZXJOb2RlKiBsYXN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2xhc3RDaGlsZDsgfQotCi0gICAg dm9pZCBpbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiBiZWZv cmVDaGlsZCk7Ci0gICAgdm9pZCByZW1vdmVDaGlsZChDb3VudGVyTm9kZSopOworICAgIEFMV0FZ U19JTkxJTkUgYm9vbCBpc1Jlc2V0KCkgY29uc3QgeyByZXR1cm4gbV9pc1Jlc2V0IHx8ICFtX3Bh cmVudDsgfQorICAgIEFMV0FZU19JTkxJTkUgYm9vbCBpc1R5cGVSZXNldCgpIGNvbnN0IHsgcmV0 dXJuIG1faXNSZXNldDsgfQorICAgIEFMV0FZU19JTkxJTkUgaW50IHZhbHVlKCkgY29uc3QgeyBy ZXR1cm4gbV92YWx1ZTsgfQorICAgIEFMV0FZU19JTkxJTkUgaW50IGNvdW50SW5QYXJlbnQoKSBj b25zdCB7IHJldHVybiBtX2NvdW50SW5QYXJlbnQ7IH0KKyAgICBBTFdBWVNfSU5MSU5FIFJlbmRl ck9iamVjdCogcmVuZGVyZXIoKSBjb25zdCB7IHJldHVybiBtX3JlbmRlcmVyOyB9CisKKyAgICBB TFdBWVNfSU5MSU5FIENvdW50ZXJOb2RlKiBwYXJlbnQoKSBjb25zdCB7IHJldHVybiBtX3BhcmVu dDsgfQorICAgIEFMV0FZU19JTkxJTkUgQ291bnRlck5vZGUqIHByZXZpb3VzU2libGluZygpIGNv bnN0IHsgcmV0dXJuIG1fcHJldmlvdXNTaWJsaW5nOyB9CisgICAgQUxXQVlTX0lOTElORSBDb3Vu dGVyTm9kZSogbmV4dFNpYmxpbmcoKSBjb25zdCB7IHJldHVybiBtX25leHRTaWJsaW5nOyB9Cisg ICAgQUxXQVlTX0lOTElORSBDb3VudGVyTm9kZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJu IG1fZmlyc3RDaGlsZDsgfQorICAgIEFMV0FZU19JTkxJTkUgQ291bnRlck5vZGUqIGxhc3RDaGls ZCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdENoaWxkOyB9CisKKyAgICAvKiBpZGVudGlmaWVyIG11 c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgb2YgdGhpcyBjb3VudGVyIG9yCisgICAgICogdGhlIHJl bmRlcmVycyBhZmZlY3RlZCBieSB0aGlzIGluc2VydGlvbiBzaGFsbCBub3QgYmUKKyAgICAgKiBp bnZhbGlkYXRlZC4KKyAgICAgKi8KKyAgICB2b2lkIGluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBu ZXdDaGlsZCwgQ291bnRlck5vZGUqIGJlZm9yZUNoaWxkLAorICAgICAgICBBdG9taWNTdHJpbmdJ bXBsKiBpZGVudGlmaWVyKTsKKworICAgIC8qIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRl bnRpZmllciBvZiB0aGlzIGNvdW50ZXIgb3IKKyAgICAgKiB0aGUgcmVuZGVyZXJzIGFmZmVjdGVk IGJ5IHRoaXMgcmVtb3ZhbCBzaGFsbCBub3QgYmUgaW52YWxpZGF0ZWQuCisgICAgICovCisgICAg dm9pZCByZW1vdmVDaGlsZChDb3VudGVyTm9kZSosIEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZp ZXIpOworICAgIC8qIEludmFsaWRhdGVzIHRoZSB0ZXh0IGluIHRoZSByZW5kZXJlciBvZiB0aGlz IGNvdW50ZXIsIGlmIGFueQorICAgICAqIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRlbnRp ZmllciBmb3IgdGhpcyBjb3VudGVyLgorICAgICAqLworICAgIHZvaWQgcmVzZXRSZW5kZXJlcihB dG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsKKworICAgIC8qIEludmFsaWRhdGVzIHRoZSB0 ZXh0IGluIHRoZSByZW5kZXJlciBvZiB0aGlzIGNvdW50ZXIsIGlmIGFueQorICAgICAqIGFuZCBp biB0aGUgcmVuZGVyZXJzIG9mIGFsbCBkZXNjZW5kYW50cywgaWYgYW55CisgICAgICogaWRlbnRp ZmllciBtdXN0IG1hdGNoIHRoZSBpZGVudGlmaWVyIGZvciB0aGlzIGNvdW50ZXIuCisgICAgICov CisgICAgdm9pZCByZXNldFJlbmRlcmVycyhBdG9taWNTdHJpbmdJbXBsKiBpZGVudGlmaWVyKTsK IAogcHJpdmF0ZToKICAgICBpbnQgY29tcHV0ZUNvdW50SW5QYXJlbnQoKSBjb25zdDsKLSAgICB2 b2lkIHJlY291bnQoKTsKKworICAgIC8qIGlkZW50aWZpZXIgbXVzdCBtYXRjaCB0aGUgaWRlbnRp ZmllciBvZiB0aGlzIGNvdW50ZXIgb3IKKyAgICAgKiB0aGUgcmVuZGVyZXJzIGFmZmVjdGVkIGJ5 IHRoaXMgcmVjb3VudCBzaGFsbCBub3QgYmUgaW52YWxpZGF0ZWQuCisgICAgICovCisgICAgdm9p ZCByZWNvdW50KEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpOwogCiAgICAgYm9vbCBtX2lz UmVzZXQ7CiAgICAgaW50IG1fdmFsdWU7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJD b3VudGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVy LmNwcAkocmV2aXNpb24gNTA1MjIpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVy LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTMzLDU1ICsxMzMsODAgQEAgc3RhdGljIGJvb2wgcGxh bkNvdW50ZXIoUmVuZGVyT2JqZWN0KiBvYgogICAgIHJldHVybiBmYWxzZTsKIH0KIAotc3RhdGlj IGJvb2wgZmluZFBsYWNlRm9yQ291bnRlcihSZW5kZXJPYmplY3QqIG9iamVjdCwgY29uc3QgQXRv bWljU3RyaW5nJiBjb3VudGVyTmFtZSwKLSAgICBib29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYg cGFyZW50LCBDb3VudGVyTm9kZSomIHByZXZpb3VzU2libGluZykKKy8qIEZpbmRzIHRoZSBpbnNl cnRpb24gcG9pbnQgZm9yIHRoZSBjb3VudGVyIGRlc2NyaWJlZCBieSBjb3VudGVyT3duZXIsIGlz UmVzZXQgYW5kIAorICogY291bnRlck5hbWUgaW4gdGhlIENvdW50ZXJOb2RlIHRyZWUgZm9yIGNv dW50ZXJOYW1lIGFuZCBzZXRzIHBhcmVudCBhbmQKKyAqIHByZXZpb3VzU2libGluZyBhY2NvcmRp bmdseS4KKyAqIFRoZSBmdW5jdGlvbiByZXR1cm5zIHRydWUgaWYgdGhlIGNvdW50ZXIgd2hvc2Ug aW5zZXJ0aW9uIHBvaW50IGlzIHNlYXJjaGVkIGlzIE5PVAorICogdGhlIHJvb3Qgb2YgdGhlIHRy ZWUuCisgKiBUaGUgcm9vdCBvZiB0aGUgdHJlZSBpcyBhIGNvdW50ZXIgcmVmZXJlbmNlIHRoYXQg aXMgbm90IGluIHRoZSBzY29wZSBvZiBhbnkgb3RoZXIKKyAqIGNvdW50ZXIgd2l0aCB0aGUgc2Ft ZSBpZGVudGlmaWVyLgorICogQWxsIHRoZSBjb3VudGVyIHJlZmVyZW5jZXMgd2l0aCB0aGUgc2Ft ZSBpZGVudGlmaWVyIGFzIHRoaXMgb25lIHRoYXQgYXJlIGluCisgKiBjaGlsZHJlbiBvciBzdWJz ZXF1ZW50IHNpYmxpbmdzIG9mIHRoZSByZW5kZXJlciB0aGF0IG93bnMgdGhlIHJvb3Qgb2YgdGhl IHRyZWUKKyAqIGZvcm0gdGhlIHJlc3Qgb2Ygb2YgdGhlIG5vZGVzIG9mIHRoZSB0cmVlLgorICog VGhlIHJvb3Qgb2YgdGhlIHRyZWUgaXMgYWx3YXlzIGEgcmVzZXQgdHlwZSByZWZlcmVuY2UuCisg KiBBIHN1YnRyZWUgcm9vdGVkIGF0IGFueSByZXNldCBub2RlIGluIHRoZSB0cmVlIGlzIGVxdWl2 YWxlbnQgdG8gYWxsIGNvdW50ZXIgCisgKiByZWZlcmVuY2VzIHRoYXQgYXJlIGluIHRoZSBzY29w ZSBvZiB0aGUgY291bnRlciBvciBuZXN0ZWQgY291bnRlciBkZWZpbmVkIGJ5IHRoYXQKKyAqIHJl c2V0IG5vZGUuCisgKiBOb24tcmVzZXQgQ291bnRlck5vZGVzIGNhbm5vdCBoYXZlIGRlc2NlbmRh bnRzLgorICovCitzdGF0aWMgYm9vbCBmaW5kUGxhY2VGb3JDb3VudGVyKFJlbmRlck9iamVjdCog Y291bnRlck93bmVyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBBdG9t aWNTdHJpbmcmIGNvdW50ZXJOYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBi b29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYgcGFyZW50LCAKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgQ291bnRlck5vZGUqJiBwcmV2aW91c1NpYmxpbmcpCiB7Ci0gICAgLy8gRmlu ZCB0aGUgYXBwcm9wcmlhdGUgcHJldmlvdXMgc2libGluZyBmb3IgaW5zZXJ0aW9uIGludG8gdGhl IHBhcmVudCBub2RlCi0gICAgLy8gYnkgc2VhcmNoaW5nIGluIHJlbmRlciB0cmVlIG9yZGVyIGZv ciBhIGNoaWxkIG9mIHRoZSBjb3VudGVyLgotICAgIHBhcmVudCA9IDA7CisgICAgUmVuZGVyT2Jq ZWN0KiBzZWFyY2hFbmRSZW5kZXJlciA9IHByZXZpb3VzU2libGluZ09yUGFyZW50KGNvdW50ZXJP d25lcik7CisgICAgUmVuZGVyT2JqZWN0KiBjdXJyZW50UmVuZGVyZXIgPSBjb3VudGVyT3duZXIt PnByZXZpb3VzSW5QcmVPcmRlcigpOwogICAgIHByZXZpb3VzU2libGluZyA9IDA7Ci0gICAgUmVu ZGVyT2JqZWN0KiByZXNldENhbmRpZGF0ZSA9IGlzUmVzZXQgPyBvYmplY3QtPnBhcmVudCgpIDog cHJldmlvdXNTaWJsaW5nT3JQYXJlbnQob2JqZWN0KTsKLSAgICBSZW5kZXJPYmplY3QqIHByZXZD b3VudGVyQ2FuZGlkYXRlID0gb2JqZWN0OwotICAgIENvdW50ZXJOb2RlKiBjYW5kaWRhdGVDb3Vu dGVyID0gMDsKLSAgICAvLyBXaGVuIGEgcmVzZXQgY291bnRlciBpcyBjaG9zZW4gYXMgY2FuZGlk YXRlQ291bnRlciwgd2UnbGwKLSAgICAvLyBkZWNpZGUgdGhlIG5ldyBub2RlIHNob3VsZCBiZSBh IGNoaWxkIG9mIHRoZSByZXNldCBub2RlIG9yIGEKLSAgICAvLyBzaWJsaW5nIG9yIHRoZSByZXNl dCBub2RlLiBUaGlzIGZsYWcgY29udHJvbHMgaXQuCi0gICAgYm9vbCBjcmVhdGVDaGlsZEZvclJl c2V0ID0gdHJ1ZTsKLSAgICB3aGlsZSAoKHByZXZDb3VudGVyQ2FuZGlkYXRlID0gcHJldkNvdW50 ZXJDYW5kaWRhdGUtPnByZXZpb3VzSW5QcmVPcmRlcigpKSkgewotICAgICAgICBDb3VudGVyTm9k ZSogYyA9IGNvdW50ZXIocHJldkNvdW50ZXJDYW5kaWRhdGUsIGNvdW50ZXJOYW1lLCBmYWxzZSk7 Ci0gICAgICAgIGlmIChwcmV2Q291bnRlckNhbmRpZGF0ZSA9PSByZXNldENhbmRpZGF0ZSkgewot ICAgICAgICAgICAgaWYgKCFjYW5kaWRhdGVDb3VudGVyKSB7Ci0gICAgICAgICAgICAgICAgY2Fu ZGlkYXRlQ291bnRlciA9IGM7Ci0gICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JSZXNldCA9 IHRydWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBpZiAoY2FuZGlkYXRlQ291bnRlcikg ewotICAgICAgICAgICAgICAgIGlmIChjcmVhdGVDaGlsZEZvclJlc2V0ICYmIGNhbmRpZGF0ZUNv dW50ZXItPmlzUmVzZXQoKSkgewotICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjYW5kaWRh dGVDb3VudGVyOwotICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSAwOworICAg IHdoaWxlIChjdXJyZW50UmVuZGVyZXIpIHsKKyAgICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnRD b3VudGVyID0gY291bnRlcihjdXJyZW50UmVuZGVyZXIsIGNvdW50ZXJOYW1lLCBmYWxzZSk7Cisg ICAgICAgIGlmIChzZWFyY2hFbmRSZW5kZXJlciA9PSBjdXJyZW50UmVuZGVyZXIpIHsKKyAgICAg ICAgICAgIGlmIChjdXJyZW50Q291bnRlcikgeworICAgICAgICAgICAgICAgIGlmIChwcmV2aW91 c1NpYmxpbmcpIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnRDb3VudGVyLT5pc1Jl c2V0KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChpc1Jlc2V0CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgJiYgKGN1cnJlbnRSZW5kZXJlci0+cGFyZW50KCkgPT0gY291bnRl ck93bmVyLT5wYXJlbnQoKSkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQg PSBjdXJyZW50Q291bnRlci0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg cHJldmlvdXNTaWJsaW5nID0gY3VycmVudENvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmV0dXJuIHBhcmVudDsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyOworICAgICAgICAgICAgICAg ICAgICAgICAgQVNTRVJUKHByZXZpb3VzU2libGluZy0+cGFyZW50KCkgPT0gY3VycmVudENvdW50 ZXIpOworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgaWYgKCFpc1Jlc2V0CisgICAgICAgICAgICAg ICAgICAgICAgICB8fCAoY3VycmVudFJlbmRlcmVyLT5wYXJlbnQoKSAhPSBjb3VudGVyT3duZXIt PnBhcmVudCgpKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgQVNTRVJUKGN1cnJlbnRDb3Vu dGVyLT5wYXJlbnQoKSA9PSBwcmV2aW91c1NpYmxpbmctPnBhcmVudCgpKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyLT5wYXJlbnQoKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9CiAgICAg ICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAgICAgICAgcGFyZW50ID0gY2FuZGlk YXRlQ291bnRlci0+cGFyZW50KCk7Ci0gICAgICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGlu ZyA9IGNhbmRpZGF0ZUNvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgIGlmIChjdXJyZW50Q291 bnRlci0+aXNSZXNldCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoaXNSZXNldAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICYmIChjdXJyZW50UmVuZGVyZXItPnBhcmVudCgp ID09IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcGFyZW50ID0gY3VycmVudENvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRDb3VudGVyOworICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiBwYXJlbnQ7CisgICAgICAgICAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjdXJyZW50Q291bnRlcjsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgICAgIGlmICghaXNSZXNldAorICAgICAgICAgICAgICAgICAgICAgICAg fHwgKGN1cnJlbnRSZW5kZXJlci0+cGFyZW50KCkgIT0gY291bnRlck93bmVyLT5wYXJlbnQoKSkp IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyLT5wYXJl bnQoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRD b3VudGVyOworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgcHJldmlvdXNTaWJsaW5nID0gY3VycmVu dENvdW50ZXI7CiAgICAgICAgICAgICAgICAgfQotICAgICAgICAgICAgICAgIHJldHVybiB0cnVl OwogICAgICAgICAgICAgfQotICAgICAgICAgICAgcmVzZXRDYW5kaWRhdGUgPSBwcmV2aW91c1Np YmxpbmdPclBhcmVudChyZXNldENhbmRpZGF0ZSk7Ci0gICAgICAgIH0gZWxzZSBpZiAoYykgewot ICAgICAgICAgICAgaWYgKGMtPmlzUmVzZXQoKSkgewotICAgICAgICAgICAgICAgIGlmIChjLT5w YXJlbnQoKSkgewotICAgICAgICAgICAgICAgICAgICAvLyBUaGUgbmV3IG5vZGUgbWF5IGJlIHRo ZSBuZXh0IHNpYmxpbmcgb2YgdGhpcyByZXNldCBub2RlLgotICAgICAgICAgICAgICAgICAgICBj cmVhdGVDaGlsZEZvclJlc2V0ID0gZmFsc2U7Ci0gICAgICAgICAgICAgICAgICAgIGNhbmRpZGF0 ZUNvdW50ZXIgPSBjOwotICAgICAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICAgICAg ICAgIGNyZWF0ZUNoaWxkRm9yUmVzZXQgPSB0cnVlOwotICAgICAgICAgICAgICAgICAgICBjYW5k aWRhdGVDb3VudGVyID0gMDsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICB9IGVsc2Ug aWYgKCFjYW5kaWRhdGVDb3VudGVyKSB7Ci0gICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JS ZXNldCA9IHRydWU7Ci0gICAgICAgICAgICAgICAgY2FuZGlkYXRlQ291bnRlciA9IGM7Ci0gICAg ICAgICAgICB9Ci0gICAgICAgIH0KKyAgICAgICAgICAgIHNlYXJjaEVuZFJlbmRlcmVyID0gcHJl dmlvdXNTaWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAgfSBlbHNlIGlm IChjdXJyZW50Q291bnRlciAmJiAoIXByZXZpb3VzU2libGluZyB8fCBjdXJyZW50Q291bnRlci0+ aXNSZXNldCgpKSkKKyAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IGN1cnJlbnRDb3VudGVy OworICAgICAgICBpZiAocHJldmlvdXNTaWJsaW5nKQorICAgICAgICAgICAgY3VycmVudFJlbmRl cmVyID0gcHJldmlvdXNTaWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAg ZWxzZQorICAgICAgICAgICAgY3VycmVudFJlbmRlcmVyID0gY3VycmVudFJlbmRlcmVyLT5wcmV2 aW91c0luUHJlT3JkZXIoKTsKICAgICB9Ci0KICAgICByZXR1cm4gZmFsc2U7CiB9CiAKQEAgLTIw MSwxNSArMjI2LDkgQEAgc3RhdGljIENvdW50ZXJOb2RlKiBjb3VudGVyKFJlbmRlck9iamVjdAog CiAgICAgQ291bnRlck5vZGUqIG5ld1BhcmVudCA9IDA7CiAgICAgQ291bnRlck5vZGUqIG5ld1By ZXZpb3VzU2libGluZyA9IDA7Ci0gICAgQ291bnRlck5vZGUqIG5ld05vZGU7Ci0gICAgaWYgKGZp bmRQbGFjZUZvckNvdW50ZXIob2JqZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50 LCBuZXdQcmV2aW91c1NpYmxpbmcpKSB7Ci0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5v ZGUob2JqZWN0LCBpc1Jlc2V0LCB2YWx1ZSk7Ci0gICAgICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0 ZXIobmV3Tm9kZSwgbmV3UHJldmlvdXNTaWJsaW5nKTsKLSAgICB9IGVsc2UgewotICAgICAgICAv LyBNYWtlIGEgcmVzZXQgbm9kZSBmb3IgY291bnRlcnMgdGhhdCBhcmVuJ3QgaW5zaWRlIGFuIGV4 aXN0aW5nIHJlc2V0IG5vZGUuCi0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUob2Jq ZWN0LCB0cnVlLCB2YWx1ZSk7Ci0gICAgfQotCisgICAgQ291bnRlck5vZGUqIG5ld05vZGUgPSBu ZXcgQ291bnRlck5vZGUob2JqZWN0LCBpc1Jlc2V0LCB2YWx1ZSk7CisgICAgaWYgKGZpbmRQbGFj ZUZvckNvdW50ZXIob2JqZWN0LCBjb3VudGVyTmFtZSwgaXNSZXNldCwgbmV3UGFyZW50LCBuZXdQ cmV2aW91c1NpYmxpbmcpKQorICAgICAgICBuZXdQYXJlbnQtPmluc2VydEFmdGVyKG5ld05vZGUs IG5ld1ByZXZpb3VzU2libGluZywgY291bnRlck5hbWUuaW1wbCgpKTsKICAgICBDb3VudGVyTWFw KiBub2RlTWFwOwogICAgIGlmIChvYmplY3QtPm1faGFzQ291bnRlck5vZGVNYXApCiAgICAgICAg IG5vZGVNYXAgPSBjb3VudGVyTWFwcygpLmdldChvYmplY3QpOwpAQCAtMjE5LDcgKzIzOCwyNyBA QCBzdGF0aWMgQ291bnRlck5vZGUqIGNvdW50ZXIoUmVuZGVyT2JqZWN0CiAgICAgICAgIG9iamVj dC0+bV9oYXNDb3VudGVyTm9kZU1hcCA9IHRydWU7CiAgICAgfQogICAgIG5vZGVNYXAtPnNldChj b3VudGVyTmFtZS5pbXBsKCksIG5ld05vZGUpOwotCisgICAgaWYgKG5ld05vZGUtPnBhcmVudCgp IHx8ICFvYmplY3QtPm5leHRJblByZU9yZGVyKG9iamVjdC0+cGFyZW50KCkpKQorICAgICAgICBy ZXR1cm4gbmV3Tm9kZTsKKyAgICAvLyBTZWUgaWYgc29tZSBub2RlcyB0aGF0IHdlcmUgcHJldmlv dXNseSBjb3VudGVyIHRyZWUgcm9vdCBub2RlcworICAgIC8vIHNob3VsZCBiZWNvbWUgY2hpbGRy ZW4gb2YgdGhpcyBub2RlIG5vdy4KKyAgICBDb3VudGVyTWFwczo6aXRlcmF0b3IgZW5kID0gY291 bnRlck1hcHMoKS5lbmQoKTsKKyAgICBmb3IgKENvdW50ZXJNYXBzOjppdGVyYXRvciBpdCA9IGNv dW50ZXJNYXBzKCkuYmVnaW4oKTtpdCAhPSBlbmQ7CisgICAgICAgICsraXQpCisgICAgICAgIGlm IChpdC0+Zmlyc3QgIT0gb2JqZWN0KSB7CisgICAgICAgICAgICBub2RlTWFwID0gaXQtPnNlY29u ZDsKKyAgICAgICAgICAgIGlmIChDb3VudGVyTm9kZSogbm9kZSA9IG5vZGVNYXAtPmdldChjb3Vu dGVyTmFtZS5pbXBsKCkpKSB7CisgICAgICAgICAgICAgICAgaWYgKCFub2RlLT5wYXJlbnQoKQor ICAgICAgICAgICAgICAgICAgICAmJiBmaW5kUGxhY2VGb3JDb3VudGVyKAorICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3RfY2FzdDxSZW5kZXJPYmplY3QqPihpdC0+Zmlyc3QpLAorICAgICAg ICAgICAgICAgICAgICAgICAgY291bnRlck5hbWUsIHRydWUsIG5ld1BhcmVudCwKKyAgICAgICAg ICAgICAgICAgICAgICAgIG5ld1ByZXZpb3VzU2libGluZykpIHsKKyAgICAgICAgICAgICAgICAg ICAgQVNTRVJUKG5ld1BhcmVudCA9PSBuZXdOb2RlKTsKKyAgICAgICAgICAgICAgICAgICAgbmV3 UGFyZW50LT5pbnNlcnRBZnRlcihub2RlLAorICAgICAgICAgICAgICAgICAgICAgICAgbmV3UHJl dmlvdXNTaWJsaW5nLCBjb3VudGVyTmFtZS5pbXBsKCkpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQogICAgIHJldHVybiBuZXdOb2RlOwogfQogCkBAIC0yNzIs NDcgKzMxMSwxMTYgQEAgdm9pZCBSZW5kZXJDb3VudGVyOjpjYWxjUHJlZldpZHRocyhpbnQgbAog ICAgIFJlbmRlclRleHQ6OmNhbGNQcmVmV2lkdGhzKGxlYWQpOwogfQogCi12b2lkIFJlbmRlckNv dW50ZXI6OmludmFsaWRhdGUoKQordm9pZCBSZW5kZXJDb3VudGVyOjppbnZhbGlkYXRlKEF0b21p Y1N0cmluZ0ltcGwgKmlkZW50aWZpZXIpCiB7Ci0gICAgbV9jb3VudGVyTm9kZSA9IDA7Ci0gICAg c2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7CisgICAgaWYgKCFpZGVudGlmaWVy CisgICAgICAgIHx8IChtX2NvdW50ZXIuaWRlbnRpZmllcigpID09IChjb25zdCBjaGFyKilpZGVu dGlmaWVyLT5jaGFyYWN0ZXJzKCkpKSB7CisgICAgICAgIG1fY291bnRlck5vZGUgPSAwOworICAg ICAgICBzZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKKyAgICB9CiB9CiAKLXN0 YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZUNoaWxkcmVuKEF0b21pY1N0cmluZ0ltcGwqIGlk ZW50aWZpZXIsIENvdW50ZXJOb2RlKiBub2RlKQorc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJO b2RlV2l0aG91dE1hcFJlbW92YWwoCisgICAgY29uc3QgUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+ ICZpZGVudGlmaWVyLCBDb3VudGVyTm9kZSogbm9kZSkKIHsKLSAgICBDb3VudGVyTm9kZSogcHJl dmlvdXM7Ci0gICAgZm9yIChDb3VudGVyTm9kZSogY2hpbGQgPSBsYXN0RGVzY2VuZGFudChub2Rl KTsgY2hpbGQgJiYgY2hpbGQgIT0gbm9kZTsgY2hpbGQgPSBwcmV2aW91cykgewotICAgICAgICBw cmV2aW91cyA9IHByZXZpb3VzSW5QcmVPcmRlcihjaGlsZCk7Ci0gICAgICAgIGNoaWxkLT5wYXJl bnQoKS0+cmVtb3ZlQ2hpbGQoY2hpbGQpOworICAgIENvdW50ZXJOb2RlKiB0ZW1wOworICAgIGZv ciAoQ291bnRlck5vZGUqIGNoaWxkID0gbGFzdERlc2NlbmRhbnQobm9kZSk7IGNoaWxkICYmIGNo aWxkICE9IG5vZGU7IGNoaWxkID0gdGVtcCkgeworICAgICAgICB0ZW1wID0gcHJldmlvdXNJblBy ZU9yZGVyKGNoaWxkKTsKKyAgICAgICAgY2hpbGQtPnBhcmVudCgpLT5yZW1vdmVDaGlsZChjaGls ZCwgaWRlbnRpZmllci5nZXQoKSk7CiAgICAgICAgIEFTU0VSVChjb3VudGVyTWFwcygpLmdldChj aGlsZC0+cmVuZGVyZXIoKSktPmdldChpZGVudGlmaWVyKSA9PSBjaGlsZCk7CiAgICAgICAgIGNv dW50ZXJNYXBzKCkuZ2V0KGNoaWxkLT5yZW5kZXJlcigpKS0+cmVtb3ZlKGlkZW50aWZpZXIpOwog ICAgICAgICBpZiAoIWNoaWxkLT5yZW5kZXJlcigpLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkp IHsKICAgICAgICAgICAgIFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSBjaGlsZC0+ cmVuZGVyZXIoKS0+dmlydHVhbENoaWxkcmVuKCk7CiAgICAgICAgICAgICBpZiAoY2hpbGRyZW4p Ci0gICAgICAgICAgICAgICAgY2hpbGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhjaGlsZC0+cmVu ZGVyZXIoKSk7CisgICAgICAgICAgICAgICAgY2hpbGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhj aGlsZC0+cmVuZGVyZXIoKSwgaWRlbnRpZmllci5nZXQoKSk7CiAgICAgICAgIH0KICAgICAgICAg ZGVsZXRlIGNoaWxkOwogICAgIH0KKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbm9kZS0+ cmVuZGVyZXIoKTsKKyAgICBpZiAoIXJlbmRlcmVyLT5kb2N1bWVudEJlaW5nRGVzdHJveWVkKCkp IHsKKyAgICAgICAgaWYgKFJlbmRlck9iamVjdENoaWxkTGlzdCogY2hpbGRyZW4gPSByZW5kZXJl ci0+dmlydHVhbENoaWxkcmVuKCkpCisgICAgICAgICAgICBjaGlsZHJlbi0+aW52YWxpZGF0ZUNv dW50ZXJzKHJlbmRlcmVyLCBpZGVudGlmaWVyLmdldCgpKTsKKyAgICB9CisgICAgaWYgKHRlbXAg PSBub2RlLT5wYXJlbnQoKSkKKyAgICAgICAgdGVtcC0+cmVtb3ZlQ2hpbGQobm9kZSwgaWRlbnRp Zmllci5nZXQoKSk7CisgICAgZGVsZXRlIG5vZGU7CiB9CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6 ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqIG9iamVjdCkKK3ZvaWQgUmVuZGVyQ291 bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewogICAg IENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1hcHMoKTsKLSAgICBDb3VudGVyTWFwKiBtYXAg PSBtYXBzLmdldChvYmplY3QpOworICAgIENvdW50ZXJNYXAqIG1hcCA9IG1hcHMuZ2V0KHJlbmRl cmVyKTsKICAgICBpZiAoIW1hcCkKICAgICAgICAgcmV0dXJuOwotICAgIG1hcHMucmVtb3ZlKG9i amVjdCk7Ci0KICAgICBDb3VudGVyTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBtYXAtPmVuZCgp OwotICAgIGZvciAoQ291bnRlck1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtYXAtPmJlZ2luKCk7 IGl0ICE9IGVuZDsgKytpdCkgewotICAgICAgICBDb3VudGVyTm9kZSogbm9kZSA9IGl0LT5zZWNv bmQ7Ci0gICAgICAgIGRlc3Ryb3lDb3VudGVyTm9kZUNoaWxkcmVuKGl0LT5maXJzdC5nZXQoKSwg bm9kZSk7Ci0gICAgICAgIGlmIChDb3VudGVyTm9kZSogcGFyZW50ID0gbm9kZS0+cGFyZW50KCkp Ci0gICAgICAgICAgICBwYXJlbnQtPnJlbW92ZUNoaWxkKG5vZGUpOwotICAgICAgICBkZWxldGUg bm9kZTsKLSAgICB9CisgICAgZm9yIChDb3VudGVyTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IG1h cC0+YmVnaW4oKTtpdCAhPSBlbmQ7KytpdCkKKyAgICAgICAgZGVzdHJveUNvdW50ZXJOb2RlV2l0 aG91dE1hcFJlbW92YWwoaXQtPmZpcnN0LCBpdC0+c2Vjb25kKTsKIAorICAgIG1hcHMucmVtb3Zl KHJlbmRlcmVyKTsKICAgICBkZWxldGUgbWFwOworICAgIHJlbmRlcmVyLT5tX2hhc0NvdW50ZXJO b2RlTWFwID0gZmFsc2U7CiB9CiAKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJO b2RlKFJlbmRlck9iamVjdCogcmVuZGVyZXIsCisgICAgY29uc3QgUmVmUHRyPEF0b21pY1N0cmlu Z0ltcGw+JiBpZGVudGlmaWVyKQoreworICAgIENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1h cHMoKTsKKyAgICBDb3VudGVyTWFwKiBtYXAgPSBtYXBzLmdldChyZW5kZXJlcik7CisgICAgaWYg KCFtYXApCisgICAgICAgIHJldHVybjsKKyAgICBDb3VudGVyTm9kZSogbm9kZSA9IG1hcC0+Z2V0 KGlkZW50aWZpZXIpOworICAgIGlmIChub2RlKSB7CisgICAgICAgIGRlc3Ryb3lDb3VudGVyTm9k ZVdpdGhvdXRNYXBSZW1vdmFsKGlkZW50aWZpZXIsIG5vZGUpOworICAgICAgICBtYXAtPnJlbW92 ZShpZGVudGlmaWVyKTsKKy8vIERvIG5vdCBkZWxldGUgbWFwIGV2ZW4gaWYgZW1wdHkgYXMgdGhl IGV4cGVjdGF0aW9uIGlzIHRoYXQgc29vbiBub2RlcyB3aWxsIGJlIGFkZGVkCisvLyB0byB0aGUg bWFwLCBvciBvdGhlcndpc2UgZGVzdHJveUNvdW50ZXJOb2RlcyB3b3VsZCBoYXZlIGJlZW4gY2Fs bGVkIGluc3RlYWQuCisgICAgfQorfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmNyZWF0ZUNvdW50 ZXJJZk5lZWRlZChSZW5kZXJPYmplY3QqIHJlbmRlcmVyLAorICAgICAgICBjb25zdCBBdG9taWNT dHJpbmcmIGlkZW50aWZpZXIpCit7CisgICAgY291bnRlcihyZW5kZXJlciwgaWRlbnRpZmllciwg ZmFsc2UpOworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKFJlbmRlck9i amVjdCogcmVuZGVyZXIpCit7CisgICAgdXBkYXRlQ291bnRlcihyZW5kZXJlcik7CisgICAgZm9y IChSZW5kZXJPYmplY3QqIGNoaWxkID0gcmVuZGVyZXItPm5leHRJblByZU9yZGVyKHJlbmRlcmVy KTsKKyAgICAgICAgY2hpbGQ7IGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyKHJlbmRlcmVy KSkKKyAgICAgICAgdXBkYXRlQ291bnRlcihjaGlsZCk7Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRl cjo6dXBkYXRlQ291bnRlcihSZW5kZXJPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQob2Jq ZWN0LT5zdHlsZSgpKTsKKyAgICBpZiAoIW9iamVjdC0+cGFyZW50KCkgJiYgIW9iamVjdC0+bmV4 dEluUHJlT3JkZXIoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmIChjb25zdCBDb3VudGVyRGly ZWN0aXZlTWFwKiBwQ291bnRlckRpcmVjdGl2ZU1hcCA9CisgICAgICAgIG9iamVjdC0+c3R5bGUo KS0+Y291bnRlckRpcmVjdGl2ZXMoKSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpj b25zdF9pdGVyYXRvciBlbmQgPQorICAgICAgICAgICAgcENvdW50ZXJEaXJlY3RpdmVNYXAtPmVu ZCgpOworICAgICAgICBDb3VudGVyTWFwKiBjb3VudGVyTWFwID0gY291bnRlck1hcHMoKS5nZXQo b2JqZWN0KTsKKyAgICAgICAgZm9yIChDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRv ciBpdCA9IHBDb3VudGVyRGlyZWN0aXZlTWFwLT5iZWdpbigpOworICAgICAgICAgICAgaXQgIT0g ZW5kOyArK2l0KQorICAgICAgICAgICAgaWYgKGNvdW50ZXJNYXApCisgICAgICAgICAgICAgICAg aWYgKENvdW50ZXJOb2RlICpub2RlID0gY291bnRlck1hcC0+Z2V0KGl0LT5maXJzdC5nZXQoKSkp IHsKKyAgICAgICAgICAgICAgICAgICAgQ291bnRlck5vZGUqIG5ld1BhcmVudCA9IDA7CisgICAg ICAgICAgICAgICAgICAgIENvdW50ZXJOb2RlKiBuZXdQcmV2aW91c1NpYmxpbmc7CisgICAgICAg ICAgICAgICAgICAgIGZpbmRQbGFjZUZvckNvdW50ZXIob2JqZWN0LAorICAgICAgICAgICAgICAg ICAgICAgICAgQXRvbWljU3RyaW5nKGl0LT5maXJzdC5nZXQoKSksIG5vZGUtPmlzVHlwZVJlc2V0 KCksCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdQYXJlbnQsIG5ld1ByZXZpb3VzU2libGlu Zyk7CisgICAgICAgICAgICAgICAgICAgIGlmICgobmV3UGFyZW50ICE9IG5vZGUtPnBhcmVudCgp KQorICAgICAgICAgICAgICAgICAgICAgICAgfHwgKG5ld1ByZXZpb3VzU2libGluZyAhPSBub2Rl LT5wcmV2aW91c1NpYmxpbmcoKSkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChub2Rl LT5wYXJlbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBub2RlLT5wYXJlbnQoKS0+ cmVtb3ZlQ2hpbGQobm9kZSwgaXQtPmZpcnN0LmdldCgpKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0ZXIobm9kZSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICBuZXdQcmV2aW91c1NpYmxpbmcsIGl0LT5maXJzdC5nZXQoKSk7CisgICAgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgY291 bnRlcihvYmplY3QsIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxzZSk7CisgICAg ICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgY291bnRlcihvYmplY3QsIEF0b21pY1N0cmlu ZyhpdC0+Zmlyc3QuZ2V0KCkpLCBmYWxzZSk7CisgICAgfQorfQogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gNTA1MjIpCisr KyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTMz LDEwICszMyw0MiBAQCBjbGFzcyBSZW5kZXJDb3VudGVyIDogcHVibGljIFJlbmRlclRleHQgCiBw dWJsaWM6CiAgICAgUmVuZGVyQ291bnRlcihEb2N1bWVudCosIGNvbnN0IENvdW50ZXJDb250ZW50 Jik7CiAKLSAgICB2b2lkIGludmFsaWRhdGUoKTsKLQorICAgIC8qIEludmFsaWRhdGVzIHRoZSBj b3VudGVyIGlmIGl0IGhhcyB0aGUgZ2l2ZW4gaWRlbnRpZmllci4KKyAgICAgKiBJZiB0aGUgZ2l2 ZW4gaWRlbnRpZmllciBpcyBOVUxMIGl0IGludmFsaWRhdGVzIHRoZSAKKyAgICAgKiBjb3VudGVy IHVuY29uZGl0aW9uYWxseS4KKyAgICAgKi8KKyAgICB2b2lkIGludmFsaWRhdGUoQXRvbWljU3Ry aW5nSW1wbCAqaWRlbnRpZmllciA9IDApOworCisgICAgLyogRGVzdHJveXMgYWxsIENvdW50ZXJO b2RlcyBhc3NvY2lhdGVkIHdpdGggdGhlIHJlbmRlcmVyIHBhc3NlZCBhcyAKKyAgICAgKiBhcmd1 bWVudCBhbmQgYWxsIHRoZSBjaGlsZCBub2RlcyBvZiB0aG9zZSBub2RlcworICAgICAqLwogICAg IHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZXMoUmVuZGVyT2JqZWN0Kik7CiAKKyAgICAv KiBEZXN0cm95cyB0aGUgQ291bnRlck5vZGUgd2l0aCB0aGUgZ2l2ZW4gaWRlbnRpZmllciBhc3Nv Y2lhdGVkIHdpdGggdGhlIAorICAgICAqIHJlbmRlcmVyIHBhc3NlZCBhcyB0aGUgZmlyc3QgYXJn dW1lbnQgYW5kIGFsbCB0aGUgY2hpbGQgbm9kZXMgb2YgdGhhdCAKKyAgICAgKiBub2RlLgorICAg ICAqLworICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBj b25zdAorICAgICAgICBSZWZQdHI8QXRvbWljU3RyaW5nSW1wbD4mIGlkZW50aWZpZXIpOworCisg ICAgLyogQ3JlYXRlcyBhIG5ldyBjb3VudGVyIGF0dGFjaGVkIHRvIHRoZSByZW5kZXJlciBwYXNz ZWQgaW4KKyAgICAgKiBmb3IgdGhlIGlkZW50aWZpZXIgcGFzc2VkIGluIGlmIGl0IGRvZXMgbm90 IGFscmVhZHkgZXhpc3QgYW5kCisgICAgICogaXQgaXMgZGVmaW5lZCBieSB0aGUgcmVuZGVyZXIn cyBzdHlsZS4KKyAgICAgKi8KKyAgICBzdGF0aWMgdm9pZCBjcmVhdGVDb3VudGVySWZOZWVkZWQo UmVuZGVyT2JqZWN0KiwKKyAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJik7CisKKyAgICAvKiBV cGRhdGVzIHRoZSBjb3VudGVycyBhdHRhY2hlZCB0byB0aGUgcmVuZGVyZXIgcGFzc2VkIGluIGFu ZAorICAgICAqIHRob3NlIGF0dGFjaGVkIHRvIGl0cyBkZXNjZW5kYW50cy4KKyAgICAgKi8KKyAg ICBzdGF0aWMgdm9pZCB1cGRhdGVDb3VudGVycyhSZW5kZXJPYmplY3QqKTsKKworICAgIC8qIFVw ZGF0ZXMgdGhlIGNvdW50ZXJzIGF0dGFjaGVkIHRvIHRoZSByZW5kZXJlciBwYXNzZWQgaW4gd2hv c2UKKyAgICAgKiBuYW1lcyBhcHBlYXIgaW4gdGhlIGNvdW50ZXIgZGlyZWN0aXZlcyBvZiB0aGUg c3R5bGUKKyAgICAgKiBvZiB0aGUgcmVuZGVyZXIuCisgICAgICovCisgICAgc3RhdGljIHZvaWQg dXBkYXRlQ291bnRlcihSZW5kZXJPYmplY3QqKTsKKwogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVy KCkgY29uc3Q7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDUw NTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtMzA0LDcgKzMwNCw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjphZGRDaGlsZChSZW5kZXJP YmplY3QKICAgICAgICAgLy8gSnVzdCBhZGQgaXQuLi4KICAgICAgICAgY2hpbGRyZW4tPmluc2Vy dENoaWxkTm9kZSh0aGlzLCBuZXdDaGlsZCwgYmVmb3JlQ2hpbGQpOwogICAgIH0KLSAgICAKKyAg ICBSZW5kZXJDb3VudGVyOjp1cGRhdGVDb3VudGVycyhuZXdDaGlsZCk7CiAgICAgaWYgKG5ld0No aWxkLT5pc1RleHQoKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+dGV4dFRyYW5zZm9ybSgpID09IENB UElUQUxJWkUpIHsKICAgICAgICAgUmVmUHRyPFN0cmluZ0ltcGw+IHRleHRUb1RyYW5zZm9ybSA9 IHRvUmVuZGVyVGV4dChuZXdDaGlsZCktPm9yaWdpbmFsVGV4dCgpOwogICAgICAgICBpZiAodGV4 dFRvVHJhbnNmb3JtKQpAQCAtMTQ4NiwyMCArMTQ4Niw4MiBAQCB2b2lkIFJlbmRlck9iamVjdDo6 c2V0U3R5bGUoUGFzc1JlZlB0cjxSCiAgICAgZGlmZiA9IGFkanVzdFN0eWxlRGlmZmVyZW5jZShk aWZmLCBjb250ZXh0U2Vuc2l0aXZlUHJvcGVydGllcyk7CiAKICAgICBzdHlsZVdpbGxDaGFuZ2Uo ZGlmZiwgc3R5bGUuZ2V0KCkpOwotICAgIAorCiAgICAgUmVmUHRyPFJlbmRlclN0eWxlPiBvbGRT dHlsZSA9IG1fc3R5bGUucmVsZWFzZSgpOwogICAgIG1fc3R5bGUgPSBzdHlsZTsKIAotICAgIHVw ZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+YmFja2dyb3VuZExheWVycygpIDog MCwgbV9zdHlsZSA/IG1fc3R5bGUtPmJhY2tncm91bmRMYXllcnMoKSA6IDApOwotICAgIHVwZGF0 ZUZpbGxJbWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+bWFza0xheWVycygpIDogMCwgbV9zdHls ZSA/IG1fc3R5bGUtPm1hc2tMYXllcnMoKSA6IDApOwotCi0gICAgdXBkYXRlSW1hZ2Uob2xkU3R5 bGUgPyBvbGRTdHlsZS0+Ym9yZGVySW1hZ2UoKS5pbWFnZSgpIDogMCwgbV9zdHlsZSA/IG1fc3R5 bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSA6IDApOwotICAgIHVwZGF0ZUltYWdlKG9sZFN0eWxl ID8gb2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCkgOiAwLCBtX3N0eWxlID8gbV9zdHls ZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSA6IDApOworICAgIGlmIChvbGRTdHlsZSkgeworICAg ICAgICBpZiAobV9zdHlsZSkgeworICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJEaXJlY3Rp dmVNYXAqIHBDb3VudGVyRGlyZWN0aXZlTWFwID0KKyAgICAgICAgICAgICAgICBtX3N0eWxlLT5j b3VudGVyRGlyZWN0aXZlcygpKSB7CisgICAgICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJE aXJlY3RpdmVNYXAqIHBPbGRDb3VudGVyRGlyZWN0aXZlTWFwCisgICAgICAgICAgICAgICAgICAg ID1vbGRTdHlsZS0+Y291bnRlckRpcmVjdGl2ZXMoKSkgeworICAgICAgICAgICAgICAgICAgICBD b3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPQorICAgICAgICAgICAgICAg ICAgICAgICAgcENvdW50ZXJEaXJlY3RpdmVNYXAtPmVuZCgpOworICAgICAgICAgICAgICAgICAg ICBmb3IgKENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ICAgICAgICAgICAg ICAgICA9IHBDb3VudGVyRGlyZWN0aXZlTWFwLT5iZWdpbigpOworICAgICAgICAgICAgICAgICAg ICAgICAgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAocE9s ZENvdW50ZXJEaXJlY3RpdmVNYXAtPmNvbnRhaW5zKGl0LT5maXJzdCkpIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICBpZiAocE9sZENvdW50ZXJEaXJlY3RpdmVNYXAtPmdldChpdC0+Zmly c3QpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICE9IGl0LT5zZWNvbmQpCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVy Tm9kZSh0aGlzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXQtPmZpcnN0 KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKHRoaXMsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGl0LT5maXJzdCk7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyQ291bnRlcjo6Y3JlYXRlQ291bnRlcklmTmVlZGVkKHRoaXMsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkp KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICBlbmQgPSBwT2xkQ291bnRlckRpcmVjdGl2ZU1hcC0+ZW5kKCk7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0 b3IgaXQKKyAgICAgICAgICAgICAgICAgICAgICAgID0gcE9sZENvdW50ZXJEaXJlY3RpdmVNYXAt PmJlZ2luKCk7CisgICAgICAgICAgICAgICAgICAgICAgICBpdCAhPSBlbmQ7ICsraXQpCisgICAg ICAgICAgICAgICAgICAgICAgICBpZiAoIXBDb3VudGVyRGlyZWN0aXZlTWFwLT5jb250YWlucyhp dC0+Zmlyc3QpKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRl c3Ryb3lDb3VudGVyTm9kZSh0aGlzLCBpdC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9k ZXModGhpcyk7CisgICAgICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50 ZXJzKHRoaXMpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAobV9o YXNDb3VudGVyTm9kZU1hcCkKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95 Q291bnRlck5vZGVzKHRoaXMpOwogCi0gICAgLy8gV2UgbmVlZCB0byBlbnN1cmUgdGhhdCB2aWV3 LT5tYXhpbWFsT3V0bGluZVNpemUoKSBpcyB2YWxpZCBmb3IgYW55IHJlcGFpbnRzIHRoYXQgaGFw cGVuCi0gICAgLy8gZHVyaW5nIHN0eWxlRGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92 ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCi0gICAgaWYgKG1fc3R5bGUtPm91dGxpbmVXaWR0aCgp ID4gMCAmJiBtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpID4gbWF4aW1hbE91dGxpbmVTaXplKFBhaW50 UGhhc2VPdXRsaW5lKSkKLSAgICAgICAgdG9SZW5kZXJWaWV3KGRvY3VtZW50KCktPnJlbmRlcmVy KCkpLT5zZXRNYXhpbWFsT3V0bGluZVNpemUobV9zdHlsZS0+b3V0bGluZVNpemUoKSk7CisgICAg ICAgICAgICB1cGRhdGVGaWxsSW1hZ2VzKG9sZFN0eWxlLT5iYWNrZ3JvdW5kTGF5ZXJzKCksCisg ICAgICAgICAgICAgICAgbV9zdHlsZS0+YmFja2dyb3VuZExheWVycygpKTsKKyAgICAgICAgICAg IHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUtPm1hc2tMYXllcnMoKSwgbV9zdHlsZS0+bWFza0xh eWVycygpKTsKKworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUtPmJvcmRlckltYWdl KCkuaW1hZ2UoKSwKKyAgICAgICAgICAgICAgICBtX3N0eWxlLT5ib3JkZXJJbWFnZSgpLmltYWdl KCkpOworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmlt YWdlKCksCisgICAgICAgICAgICAgICAgbV9zdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSk7 CisgICAgICAgICAgICAvLyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1heGltYWxPdXRs aW5lU2l6ZSgpIGlzIHZhbGlkIGZvciAKKyAgICAgICAgICAgIC8vIGFueSByZXBhaW50cyB0aGF0 IGhhcHBlbiBkdXJpbmcgc3R5bGVEaWRDaGFuZ2UgKGl0J3MgdXNlZCBieQorICAgICAgICAgICAg Ly8gY2xpcHBlZE92ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCisgICAgICAgICAgICBpZiAobV9z dHlsZS0+b3V0bGluZVdpZHRoKCkgPiAwICYmIG1fc3R5bGUtPm91dGxpbmVTaXplKCkgPgorICAg ICAgICAgICAgICAgIG1heGltYWxPdXRsaW5lU2l6ZShQYWludFBoYXNlT3V0bGluZSkpIHsKKyAg ICAgICAgICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+cmVuZGVyZXIoKSktPnNldE1h eGltYWxPdXRsaW5lU2l6ZSgKKyAgICAgICAgICAgICAgICAgICAgbV9zdHlsZS0+b3V0bGluZVNp emUoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBpZiAo bV9oYXNDb3VudGVyTm9kZU1hcCkKKyAgICAgICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0 cm95Q291bnRlck5vZGVzKHRoaXMpOworICAgICAgICAgICAgdXBkYXRlRmlsbEltYWdlcyhvbGRT dHlsZS0+YmFja2dyb3VuZExheWVycygpLCAwKTsKKyAgICAgICAgICAgIHVwZGF0ZUZpbGxJbWFn ZXMob2xkU3R5bGUtPm1hc2tMYXllcnMoKSwgMCk7CisKKyAgICAgICAgICAgIHVwZGF0ZUltYWdl KG9sZFN0eWxlLT5ib3JkZXJJbWFnZSgpLmltYWdlKCksIDApOworICAgICAgICAgICAgdXBkYXRl SW1hZ2Uob2xkU3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCksIDApOworICAgICAgICB9Cisg ICAgfSBlbHNlIGlmIChtX3N0eWxlKSB7CisgICAgICAgIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNv dW50ZXIodGhpcyk7CisgICAgICAgIHVwZGF0ZUZpbGxJbWFnZXMoMCwgbV9zdHlsZS0+YmFja2dy b3VuZExheWVycygpKTsKKyAgICAgICAgdXBkYXRlRmlsbEltYWdlcygwLCBtX3N0eWxlLT5tYXNr TGF5ZXJzKCkpOworCisgICAgICAgIHVwZGF0ZUltYWdlKDAsIG1fc3R5bGUtPmJvcmRlckltYWdl KCkuaW1hZ2UoKSk7CisgICAgICAgIHVwZGF0ZUltYWdlKDAsIG1fc3R5bGUtPm1hc2tCb3hJbWFn ZSgpLmltYWdlKCkpOworICAgICAgICAvLyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1h eGltYWxPdXRsaW5lU2l6ZSgpIGlzIHZhbGlkIGZvciBhbnkgcmVwYWludHMgdGhhdCBoYXBwZW4K KyAgICAgICAgLy8gZHVyaW5nIHN0eWxlRGlkQ2hhbmdlIChpdCdzIHVzZWQgYnkgY2xpcHBlZE92 ZXJmbG93UmVjdEZvclJlcGFpbnQoKSkuCisgICAgICAgIGlmIChtX3N0eWxlLT5vdXRsaW5lV2lk dGgoKSA+IDAgJiYgbV9zdHlsZS0+b3V0bGluZVNpemUoKSA+IG1heGltYWxPdXRsaW5lU2l6ZShQ YWludFBoYXNlT3V0bGluZSkpCisgICAgICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+ cmVuZGVyZXIoKSktPnNldE1heGltYWxPdXRsaW5lU2l6ZShtX3N0eWxlLT5vdXRsaW5lU2l6ZSgp KTsKKyAgICB9CiAKICAgICBzdHlsZURpZENoYW5nZShkaWZmLCBvbGRTdHlsZS5nZXQoKSk7CiAK QEAgLTE2MDgsNyArMTY3MCw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShT dHlsZUQKIAogICAgIGlmICghbV9wYXJlbnQpCiAgICAgICAgIHJldHVybjsKLSAgICAKKwogICAg IGlmIChkaWZmID09IFN0eWxlRGlmZmVyZW5jZUxheW91dCkKICAgICAgICAgc2V0TmVlZHNMYXlv dXRBbmRQcmVmV2lkdGhzUmVjYWxjKCk7CiAgICAgZWxzZSBpZiAoZGlmZiA9PSBTdHlsZURpZmZl cmVuY2VMYXlvdXRQb3NpdGlvbmVkTW92ZW1lbnRPbmx5KQpJbmRleDogV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmgJKHJldmlzaW9uIDUwNTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTE4Nyw3ICsxODcsNyBAQCBwdWJsaWM6CiAgICAgLy8g Q29udmVuaWVuY2UgZnVuY3Rpb24gZm9yIGdldHRpbmcgdG8gdGhlIG5lYXJlc3QgZW5jbG9zaW5n IGJveCBvZiBhIFJlbmRlck9iamVjdC4KICAgICBSZW5kZXJCb3gqIGVuY2xvc2luZ0JveCgpIGNv bnN0OwogICAgIAotICAgIHZpcnR1YWwgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gZmly c3RDaGlsZCgpID09IDA7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNFbXB0eSgpIGNvbnN0IHsgcmV0 dXJuICFmaXJzdENoaWxkKCk7IH0KIAogI2lmbmRlZiBOREVCVUcKICAgICB2b2lkIHNldEhhc0FY T2JqZWN0KGJvb2wgZmxhZykgeyBtX2hhc0FYT2JqZWN0ID0gZmxhZzsgfQpAQCAtNjQ3LDcgKzY0 Nyw3IEBAIHB1YmxpYzoKIAogICAgIC8vIFRoZSBjdXJyZW50IHNlbGVjdGlvbiBzdGF0ZSBmb3Ig YW4gb2JqZWN0LiAgRm9yIGJsb2NrcywgdGhlIHN0YXRlIHJlZmVycyB0byB0aGUgc3RhdGUgb2Yg dGhlIGxlYWYKICAgICAvLyBkZXNjZW5kYW50cyAoYXMgZGVzY3JpYmVkIGFib3ZlIGluIHRoZSBT ZWxlY3Rpb25TdGF0ZSBlbnVtIGRlY2xhcmF0aW9uKS4KLSAgICBTZWxlY3Rpb25TdGF0ZSBzZWxl Y3Rpb25TdGF0ZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PFNlbGVjdGlvblN0YXRlPiht X3NlbGVjdGlvblN0YXRlKTs7IH0KKyAgICBTZWxlY3Rpb25TdGF0ZSBzZWxlY3Rpb25TdGF0ZSgp IGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PFNlbGVjdGlvblN0YXRlPihtX3NlbGVjdGlvblN0 YXRlKTsgfQogCiAgICAgLy8gU2V0cyB0aGUgc2VsZWN0aW9uIHN0YXRlIGZvciBhbiBvYmplY3Qu CiAgICAgdmlydHVhbCB2b2lkIHNldFNlbGVjdGlvblN0YXRlKFNlbGVjdGlvblN0YXRlIHN0YXRl KSB7IG1fc2VsZWN0aW9uU3RhdGUgPSBzdGF0ZTsgfQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0Q2hpbGRMaXN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3RDaGlsZExpc3QuY3BwCShyZXZpc2lvbiA1MDUyMikKKysrIFdlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdENoaWxkTGlzdC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI3 MSwyNCArMjcxLDI5IEBAIHN0YXRpYyBSZW5kZXJPYmplY3QqIGZpbmRCZWZvcmVBZnRlclBhcmUK ICAgICByZXR1cm4gYmVmb3JlQWZ0ZXJQYXJlbnQ7CiB9CiAKLXN0YXRpYyB2b2lkIGludmFsaWRh dGVDb3VudGVyc0luQ29udGFpbmVyKFJlbmRlck9iamVjdCogY29udGFpbmVyKQorc3RhdGljIHZv aWQgaW52YWxpZGF0ZUNvdW50ZXJzSW5Db250YWluZXIoUmVuZGVyT2JqZWN0KiBjb250YWluZXIs IEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpCiB7CiAgICAgaWYgKCFjb250YWluZXIpCiAg ICAgICAgIHJldHVybjsKICAgICBjb250YWluZXIgPSBmaW5kQmVmb3JlQWZ0ZXJQYXJlbnQoY29u dGFpbmVyKTsKICAgICBpZiAoIWNvbnRhaW5lcikKICAgICAgICAgcmV0dXJuOworICAgIC8vU29t ZXRpbWVzIHRoZSBjb3VudGVyIGlzIGF0dGFjaGVkIGRpcmVjdGx5IG9uIHRoZSBjb250YWluZXIu CisgICAgaWYgKGNvbnRhaW5lci0+aXNDb3VudGVyKCkpIHsKKyAgICAgICAgdG9SZW5kZXJDb3Vu dGVyKGNvbnRhaW5lciktPmludmFsaWRhdGUoaWRlbnRpZmllcik7CisgICAgICAgIHJldHVybjsK KyAgICB9CiAgICAgZm9yIChSZW5kZXJPYmplY3QqIGNvbnRlbnQgPSBjb250YWluZXItPmZpcnN0 Q2hpbGQoKTsgY29udGVudDsgY29udGVudCA9IGNvbnRlbnQtPm5leHRTaWJsaW5nKCkpIHsKICAg ICAgICAgaWYgKGNvbnRlbnQtPmlzQ291bnRlcigpKQotICAgICAgICAgICAgdG9SZW5kZXJDb3Vu dGVyKGNvbnRlbnQpLT5pbnZhbGlkYXRlKCk7CisgICAgICAgICAgICB0b1JlbmRlckNvdW50ZXIo Y29udGVudCktPmludmFsaWRhdGUoaWRlbnRpZmllcik7CiAgICAgfQogfQogCi12b2lkIFJlbmRl ck9iamVjdENoaWxkTGlzdDo6aW52YWxpZGF0ZUNvdW50ZXJzKFJlbmRlck9iamVjdCogb3duZXIp Cit2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6aW52YWxpZGF0ZUNvdW50ZXJzKFJlbmRlck9i amVjdCogb3duZXIsIEF0b21pY1N0cmluZ0ltcGwqIGlkZW50aWZpZXIpCiB7CiAgICAgQVNTRVJU KCFvd25lci0+ZG9jdW1lbnRCZWluZ0Rlc3Ryb3llZCgpKTsKLSAgICBpbnZhbGlkYXRlQ291bnRl cnNJbkNvbnRhaW5lcihiZWZvcmVBZnRlckNvbnRhaW5lcihvd25lciwgQkVGT1JFKSk7Ci0gICAg aW52YWxpZGF0ZUNvdW50ZXJzSW5Db250YWluZXIoYmVmb3JlQWZ0ZXJDb250YWluZXIob3duZXIs IEFGVEVSKSk7CisgICAgaW52YWxpZGF0ZUNvdW50ZXJzSW5Db250YWluZXIoYmVmb3JlQWZ0ZXJD b250YWluZXIob3duZXIsIEJFRk9SRSksIGlkZW50aWZpZXIpOworICAgIGludmFsaWRhdGVDb3Vu dGVyc0luQ29udGFpbmVyKGJlZm9yZUFmdGVyQ29udGFpbmVyKG93bmVyLCBBRlRFUiksIGlkZW50 aWZpZXIpOwogfQogCiB2b2lkIFJlbmRlck9iamVjdENoaWxkTGlzdDo6dXBkYXRlQmVmb3JlQWZ0 ZXJDb250ZW50KFJlbmRlck9iamVjdCogb3duZXIsIFBzZXVkb0lkIHR5cGUsIFJlbmRlck9iamVj dCogc3R5bGVkT2JqZWN0KQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hp bGRMaXN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0Q2hp bGRMaXN0LmgJKHJldmlzaW9uIDUwNTIyKQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0Q2hpbGRMaXN0LmgJKHdvcmtpbmcgY29weSkKQEAgLTMxLDYgKzMxLDcgQEAKIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIAogY2xhc3MgUmVuZGVyT2JqZWN0OworY2xhc3MgQXRvbWljU3RyaW5nSW1w bDsKIAogY2xhc3MgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0IHsKIHB1YmxpYzoKQEAgLTU1LDcgKzU2 LDExIEBAIHB1YmxpYzoKICAgICB2b2lkIGluc2VydENoaWxkTm9kZShSZW5kZXJPYmplY3QqIG93 bmVyLCBSZW5kZXJPYmplY3QqIGNoaWxkLCBSZW5kZXJPYmplY3QqIGJlZm9yZSwgYm9vbCBmdWxs SW5zZXJ0ID0gdHJ1ZSk7CiAKICAgICB2b2lkIHVwZGF0ZUJlZm9yZUFmdGVyQ29udGVudChSZW5k ZXJPYmplY3QqIG93bmVyLCBQc2V1ZG9JZCB0eXBlLCBSZW5kZXJPYmplY3QqIHN0eWxlZE9iamVj dCA9IDApOwotICAgIHZvaWQgaW52YWxpZGF0ZUNvdW50ZXJzKFJlbmRlck9iamVjdCogb3duZXIp OworCisgICAgLyogSW52YWxpZGF0ZXMgYWxsIGNvdW50ZXJzIHdpdGggdGhlIGdpdmVuIGlkZW50 aWZpZXIgaW4gY2hpbGRyZW4gb2Ygb3duZXIuCisgICAgICogSWYgaWRlbnRpZmllciBpcyBOVUxM IChkZWZhdWx0KSBhbGwgY291bnRlcnMgYXJlIGludmFsaWRhdGVkCisgICAgICovCisgICAgdm9p ZCBpbnZhbGlkYXRlQ291bnRlcnMoUmVuZGVyT2JqZWN0KiBvd25lciwgQXRvbWljU3RyaW5nSW1w bCAqaWRlbnRpZmllciA9IDApOwogCiBwcml2YXRlOgogICAgIFJlbmRlck9iamVjdCogbV9maXJz dENoaWxkOwpJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNTA1NzkpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VM b2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxOCBAQAorMjAwOS0xMS0wNSAgQ2Fyb2wgU3ph Ym8gIDxjYXJvbC5zemFib0Bub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQW5vdGhlciBjcmF6eSBjb3VudGVycyBidWcKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExMDMxCisgICAgICAgIEFk ZGVkIHRlc3RzIGZvciBkeW5hbWljIERPTSBjaGFuZ2VzIGFmZmVjdGluZyBjb3VudGVycy4KKwor ICAgICAgICAqIGNzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDIuaHRtbDogQWRkZWQuCisgICAg ICAgICogY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGNz czIuMS9jb3VudGVyLXJlc2V0LTAwMi5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9x dC9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAyLWV4 cGVjdGVkLnR4dDogQWRkZWQuCisKIDIwMDktMTEtMDUgIFNodSBDaGFuZyAgPENoYW5nLlNodUBu b2tpYS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgQWRlbGUgUGV0ZXJzb24uCkluZGV4OiBM YXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1sCShyZXZpc2lv biAwKQorKysgTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1sCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1cz Qy8vRFREIEhUTUwgNC4wMS8vRU4iPgorPGh0bWw+PGhlYWQ+CisgICAgPG1ldGEgaHR0cC1lcXVp dj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgorICAg IDx0aXRsZT5DU1MgVGVzdDogZHluYW1pYyBjaGFuZ2VzIHRvICdjb3VudGVyLWluY3JlbWVudCc8 L3RpdGxlPgorICAgIDxsaW5rIHJlbD0iYXV0aG9yIiBocmVmPSJodHRwOi8vZGJhcm9uLm9yZy8i IHRpdGxlPSJMLiBEYXZpZCBCYXJvbiI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRw Oi8vd3d3LnczLm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI2NvdW50ZXJzIj4KKyAgICA8bGlu ayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0 bWwjcHJvcGRlZi1jb250ZW50Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93 d3cudzMub3JnL1RSL0NTUzIxL3N5bmRhdGEuaHRtbCNjb3VudGVyIj4KKyAgICA8bWV0YSBjb250 ZW50PSJkb20iIG5hbWU9ImZsYWdzIj4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVN0 eWxlLVR5cGUiIGNvbnRlbnQ9InRleHQvY3NzIj4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiPgorICAgIDxzdHlsZSB0 eXBlPSJ0ZXh0L2NzcyI+CisgICAgICAgIGJvZHkgeyB3aGl0ZS1zcGFjZTogbm93cmFwOyB9Cisg ICAgICAgICN0ZXN0LCAucmVzZXQgeyBjb3VudGVyLXJlc2V0OiBjOyB9CisgICAgICAgIC5pbmNy ZW1lbnQ6YmVmb3JlLCAudXNlOmJlZm9yZSB7IGNvbnRlbnQ6IGNvdW50ZXJzKGMsICIuIikgIi0i OyB9CisgICAgICAgIC5pbmNyZW1lbnQgeyBjb3VudGVyLWluY3JlbWVudDogYzsgfQorICAgIDwv c3R5bGU+CisgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorICAgICAgICBpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIud2FpdFVudGlsRG9uZSgpOworCisgICAgICAgIGZ1bmN0aW9uIHJ1bigpIHsKKyAgICAg ICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJvbmUiKS5yZW1vdmVBdHRyaWJ1dGUoImNs YXNzIik7CisgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidHdvIikuc2V0QXR0 cmlidXRlKCJjbGFzcyIsICJpbmNyZW1lbnQiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJ0aHJlZSIpLnNldEF0dHJpYnV0ZSgic3R5bGUiLCAiY291bnRlci1pbmNyZW1l bnQ6IGMiKTsKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisg ICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAg ICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4o KScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNh bWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3QiPjxzcGFuIGlkPSJvbmUiPjwvc3Bhbj48c3Bhbj48 c3BhbiBjbGFzcz0icmVzZXQiPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3BhbiBj bGFzcz0iaW5jcmVtZW50IiBpZD0idHdvIj48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3BhbiBzdHls ZT0iY291bnRlci1pbmNyZW1lbnQ6IGM7IiBjbGFzcz0idXNlIiBpZD0idGhyZWUiPjwvc3Bhbj48 c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJl bmNlIj4wLjEtMC4yLTEtMi08L2Rpdj4KKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBl bmQgb2YgZmlsZQoKUHJvcGVydHkgY2hhbmdlcyBvbjogTGF5b3V0VGVzdHMvY3NzMi4xL2NvdW50 ZXItaW5jcmVtZW50LTAwMi5odG1sCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjptZXJnZWluZm8KCklu ZGV4OiBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1yZXNldC0wMDAuaHRtbAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1yZXNldC0wMDAuaHRtbAkocmV2aXNpb24g MCkKKysrIExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMC5odG1sCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDM0IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFRE IEhUTUwgNC4wMS8vRU4iPgorPGh0bWw+PGhlYWQ+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29u dGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgorICAgIDx0aXRs ZT5DU1MgVGVzdDogZHluYW1pYyBjaGFuZ2VzIHRvICdjb3VudGVyLWluY3JlbWVudCc8L3RpdGxl PgorICAgIDxsaW5rIHJlbD0iYXV0aG9yIiBocmVmPSJodHRwOi8vZGJhcm9uLm9yZy8iIHRpdGxl PSJMLiBEYXZpZCBCYXJvbiI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3 LnczLm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI2NvdW50ZXJzIj4KKyAgICA8bGluayByZWw9 ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjcHJv cGRlZi1jb250ZW50Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMu b3JnL1RSL0NTUzIxL3N5bmRhdGEuaHRtbCNjb3VudGVyIj4KKyAgICA8bWV0YSBjb250ZW50PSJk b20iIG5hbWU9ImZsYWdzIj4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1U eXBlIiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiPgorICAgIDxzdHlsZSB0eXBlPSJ0ZXh0L2Nz cyI+CisgICAgICAgIGJvZHkgeyB3aGl0ZS1zcGFjZTogbm93cmFwOyB9CisgICAgICAgICN0ZXN0 LCAucmVzZXQgeyBjb3VudGVyLXJlc2V0OiBjOyB9CisgICAgICAgIC5pbmNyZW1lbnQ6YmVmb3Jl IHsgY29udGVudDogY291bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVudCB7 IGNvdW50ZXItaW5jcmVtZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9 InRleHQvamF2YXNjcmlwdCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xs ZXIpCisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisK KyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgdmFyIHQgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgdmFyIHMgPSBkb2N1bWVudC5jcmVh dGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICBzLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAi cmVzZXQiKTsKKyAgICAgICAgICAgIHQuaW5zZXJ0QmVmb3JlKHMsIHQuY2hpbGROb2Rlcy5pdGVt KDEpKTsKKyAgICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAg ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAg IH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD48Ym9keSBvbmxvYWQ9InNldFRpbWVvdXQoJ3J1bigp JywgMCkiPgorICAgIDxwPlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2Ft ZTo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+PHNwYW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFu PjxzcGFuIGNsYXNzPSJyZXNldCI+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bh bj48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVm ZXJlbmNlIj4xLTEuMS0xLjItPC9kaXY+Cis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQg ZW5kIG9mIGZpbGUKClByb3BlcnR5IGNoYW5nZXMgb246IExheW91dFRlc3RzL2NzczIuMS9jb3Vu dGVyLXJlc2V0LTAwMC5odG1sCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjptZXJnZWluZm8KCkluZGV4 OiBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1yZXNldC0wMDIuaHRtbAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9jc3MyLjEvY291bnRlci1yZXNldC0wMDIuaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMi5odG1sCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhU TUwgNC4wMS8vRU4iPgorPGh0bWw+PGhlYWQ+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVu dC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgorICAgIDx0aXRsZT5D U1MgVGVzdDogZHluYW1pYyBjaGFuZ2VzIHRvICdjb3VudGVyLWluY3JlbWVudCc8L3RpdGxlPgor ICAgIDxsaW5rIHJlbD0iYXV0aG9yIiBocmVmPSJodHRwOi8vZGJhcm9uLm9yZy8iIHRpdGxlPSJM LiBEYXZpZCBCYXJvbiI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3Lncz Lm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI2NvdW50ZXJzIj4KKyAgICA8bGluayByZWw9Imhl bHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjcHJvcGRl Zi1jb250ZW50Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3Jn L1RSL0NTUzIxL3N5bmRhdGEuaHRtbCNjb3VudGVyIj4KKyAgICA8bWV0YSBjb250ZW50PSJkb20i IG5hbWU9ImZsYWdzIj4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBl IiBjb250ZW50PSJ0ZXh0L2phdmFzY3JpcHQiPgorICAgIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+ CisgICAgICAgIGJvZHkgeyB3aGl0ZS1zcGFjZTogbm93cmFwOyB9CisgICAgICAgICN0ZXN0LCAu cmVzZXQgeyBjb3VudGVyLXJlc2V0OiBjOyB9CisgICAgICAgIC5pbmNyZW1lbnQ6YmVmb3JlIHsg Y29udGVudDogY291bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVudCB7IGNv dW50ZXItaW5jcmVtZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9InRl eHQvamF2YXNjcmlwdCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIp CisgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci53YWl0VW50aWxEb25lKCk7CisKKyAg ICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoIm9uZSIpLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5yZW1vdmVBdHRyaWJ1dGUoImNsYXNzIik7Cisg ICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgfQorICAgIDwv c2NyaXB0PgorPC9oZWFkPjxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgncnVuKCknLCAwKSI+Cisg ICAgPHA+VGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1lOjwvcD4KKyAg ICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4+PHNw YW4gY2xhc3M9InJlc2V0IiBpZD0ib25lIj48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+ PC9zcGFuPjwvc3Bhbj48c3BhbiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4+PHNwYW4g aWQ9InR3byI+PHNwYW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNw YW4gY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvZGl2PgorICAgIDxkaXYgaWQ9InJlZmVyZW5j ZSI+MS0xLjEtMi0zLTQtPC9kaXY+Cis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5k IG9mIGZpbGUKClByb3BlcnR5IGNoYW5nZXMgb246IExheW91dFRlc3RzL2NzczIuMS9jb3VudGVy LXJlc2V0LTAwMi5odG1sCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KQWRkZWQ6IHN2bjptZXJnZWluZm8KCkluZGV4OiBM YXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291 bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRl c3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDM5IEBACitsYXllciBhdCAoMCwwKSBzaXplIDgwMHg2 MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0ICgwLDApIHNp emUgODAweDEwMworICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4MDB4MTAzCisg ICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsMTYpIHNpemUgNzg0eDc5CisgICAgICBSZW5kZXJC bG9jayB7UH0gYXQgKDAsMCkgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9 IGF0ICgwLDApIHNpemUgMzEweDIxCisgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGgg MzEwOiAiVGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1lOiIKKyAgICAg IFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDM3KSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJJ bmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMHgwCisgICAgICAgIFJlbmRlcklubGluZSB7U1BB Tn0gYXQgKDAsMCkgc2l6ZSA1NHgyMQorICAgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQg KDAsMCkgc2l6ZSA1NHgyMQorICAgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCww KSBzaXplIDI3eDIxCisgICAgICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAo MCwwKSBzaXplIDI3eDIxCisgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoMCwwKSBz aXplIDIyeDIxCisgICAgICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCAyMjog IjAuMSIKKyAgICAgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICgyMiwwKSBzaXplIDV4MjEKKyAg ICAgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICgyMiwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAg ICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAgICAg ICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkgYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAg ICAgICAgIFJlbmRlckNvdW50ZXIgYXQgKDI3LDApIHNpemUgMjJ4MjEKKyAgICAgICAgICAgICAg ICAgIHRleHQgcnVuIGF0ICgyNywwKSB3aWR0aCAyMjogIjAuMiIKKyAgICAgICAgICAgICAgICBS ZW5kZXJUZXh0IGF0ICg0OSwwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgICAgIHRleHQgcnVu IGF0ICg0OSwwKSB3aWR0aCA1OiAiLSIKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAo MCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgw LDApIHNpemUgMTR4MjEKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIgYXQgKDU0LDApIHNpemUg OXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNTQsMCkgd2lkdGggOTogIjEiCisgICAg ICAgICAgICBSZW5kZXJUZXh0IGF0ICg2MywwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgdGV4 dCBydW4gYXQgKDYzLDApIHdpZHRoIDU6ICItIgorICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59 IGF0ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkg YXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoNjgsMCkg c2l6ZSA5eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg2OCwwKSB3aWR0aCA5OiAiMiIK KyAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDc3LDApIHNpemUgNXgyMQorICAgICAgICAgICAg ICB0ZXh0IHJ1biBhdCAoNzcsMCkgd2lkdGggNTogIi0iCisgICAgICBSZW5kZXJCbG9jayB7RElW fSBhdCAoMCw1OCkgc2l6ZSA3ODR4MjEKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgw LDApIHNpemUgODJ4MjEKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCwwKSB3aWR0aCA4MjogIjAu MS0wLjItMS0yLSIKSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVy LXJlc2V0LTAwMC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZv cm0vcXQvY3NzMi4xL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL3BsYXRmb3JtL3F0L2NzczIuMS9jb3VudGVyLXJlc2V0LTAwMC1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzIgQEAKK2xheWVyIGF0ICgwLDApIHNp emUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQg KDAsMCkgc2l6ZSA4MDB4MTAzCisgIFJlbmRlckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgw MHgxMDMKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCwxNikgc2l6ZSA3ODR4NzkKKyAgICAg IFJlbmRlckJsb2NrIHtQfSBhdCAoMCwwKSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJUZXh0 IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSAzMTB4MjEKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMCww KSB3aWR0aCAzMTA6ICJUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6 IgorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMzcpIHNpemUgNzg0eDIxCisgICAgICAg IFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgIFJlbmRl cklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICBSZW5k ZXJDb3VudGVyIGF0ICgwLDApIHNpemUgOXgyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAo MCwwKSB3aWR0aCA5OiAiMSIKKyAgICAgICAgICAgIFJlbmRlclRleHQgYXQgKDksMCkgc2l6ZSA1 eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg5LDApIHdpZHRoIDU6ICItIgorICAgICAg ICBSZW5kZXJJbmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMHgyMQorICAgICAgICBSZW5kZXJJ bmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMHgyMQorICAgICAgICBSZW5kZXJJbmxpbmUge1NQ QU59IGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRl ZCkgYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoMTQs MCkgc2l6ZSAyMngyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTQsMCkgd2lkdGggMjI6 ICIxLjEiCisgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICgzNiwwKSBzaXplIDV4MjEKKyAgICAg ICAgICAgICAgdGV4dCBydW4gYXQgKDM2LDApIHdpZHRoIDU6ICItIgorICAgICAgICBSZW5kZXJJ bmxpbmUge1NQQU59IGF0ICgwLDApIHNpemUgMjd4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUg KGdlbmVyYXRlZCkgYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRl ciBhdCAoNDEsMCkgc2l6ZSAyMngyMQorICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNDEsMCkg d2lkdGggMjI6ICIxLjIiCisgICAgICAgICAgICBSZW5kZXJUZXh0IGF0ICg2MywwKSBzaXplIDV4 MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDYzLDApIHdpZHRoIDU6ICItIgorICAgICAg UmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsNTgpIHNpemUgNzg0eDIxCisgICAgICAgIFJlbmRlclRl eHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDY4eDIxCisgICAgICAgICAgdGV4dCBydW4gYXQgKDAs MCkgd2lkdGggNjg6ICIxLTEuMS0xLjItIgpJbmRleDogTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQv Y3NzMi4xL2NvdW50ZXItcmVzZXQtMDAyLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9wbGF0Zm9ybS9xdC9jc3MyLjEvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvY3NzMi4xL2NvdW50ZXIt cmVzZXQtMDAyLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0NiBAQAorbGF5 ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlclZpZXcgYXQgKDAsMCkgc2l6ZSA4MDB4 NjAwCitsYXllciBhdCAoMCwwKSBzaXplIDgwMHgxMDMKKyAgUmVuZGVyQmxvY2sge0hUTUx9IGF0 ICgwLDApIHNpemUgODAweDEwMworICAgIFJlbmRlckJvZHkge0JPRFl9IGF0ICg4LDE2KSBzaXpl IDc4NHg3OQorICAgICAgUmVuZGVyQmxvY2sge1B9IGF0ICgwLDApIHNpemUgNzg0eDIxCisgICAg ICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDMxMHgyMQorICAgICAgICAgIHRl eHQgcnVuIGF0ICgwLDApIHdpZHRoIDMxMDogIlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3Vs ZCBiZSB0aGUgc2FtZToiCisgICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAoMCwzNykgc2l6ZSA3 ODR4MjEKKyAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDE0eDIxCisg ICAgICAgICAgUmVuZGVySW5saW5lIChnZW5lcmF0ZWQpIGF0ICgwLDApIHNpemUgMTR4MjEKKyAg ICAgICAgICAgIFJlbmRlckNvdW50ZXIgYXQgKDAsMCkgc2l6ZSA5eDIxCisgICAgICAgICAgICAg IHRleHQgcnVuIGF0ICgwLDApIHdpZHRoIDk6ICIxIgorICAgICAgICAgICAgUmVuZGVyVGV4dCBh dCAoOSwwKSBzaXplIDV4MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDksMCkgd2lkdGgg NTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAyN3gyMQor ICAgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAyN3gyMQorICAgICAg ICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAgICAg ICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDI3eDIxCisgICAgICAg ICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoMTQsMCkgc2l6ZSAyMngyMQorICAgICAgICAgICAg ICAgICAgdGV4dCBydW4gYXQgKDE0LDApIHdpZHRoIDIyOiAiMS4xIgorICAgICAgICAgICAgICAg IFJlbmRlclRleHQgYXQgKDM2LDApIHNpemUgNXgyMQorICAgICAgICAgICAgICAgICAgdGV4dCBy dW4gYXQgKDM2LDApIHdpZHRoIDU6ICItIgorICAgICAgICBSZW5kZXJJbmxpbmUge1NQQU59IGF0 ICgwLDApIHNpemUgMTR4MjEKKyAgICAgICAgICBSZW5kZXJJbmxpbmUgKGdlbmVyYXRlZCkgYXQg KDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoNDEsMCkgc2l6 ZSA5eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg0MSwwKSB3aWR0aCA5OiAiMiIKKyAg ICAgICAgICAgIFJlbmRlclRleHQgYXQgKDUwLDApIHNpemUgNXgyMQorICAgICAgICAgICAgICB0 ZXh0IHJ1biBhdCAoNTAsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJlbmRlcklubGluZSB7U1BB Tn0gYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgIFJlbmRlcklubGluZSB7U1BBTn0gYXQg KDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgICAgUmVuZGVySW5saW5lIHtTUEFOfSBhdCAoMCww KSBzaXplIDE0eDIxCisgICAgICAgICAgICAgIFJlbmRlcklubGluZSAoZ2VuZXJhdGVkKSBhdCAo MCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlciBhdCAoNTUsMCkg c2l6ZSA5eDIxCisgICAgICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNTUsMCkgd2lkdGggOTog IjMiCisgICAgICAgICAgICAgICAgUmVuZGVyVGV4dCBhdCAoNjQsMCkgc2l6ZSA1eDIxCisgICAg ICAgICAgICAgICAgICB0ZXh0IHJ1biBhdCAoNjQsMCkgd2lkdGggNTogIi0iCisgICAgICAgIFJl bmRlcklubGluZSB7U1BBTn0gYXQgKDAsMCkgc2l6ZSAxNHgyMQorICAgICAgICAgIFJlbmRlcklu bGluZSAoZ2VuZXJhdGVkKSBhdCAoMCwwKSBzaXplIDE0eDIxCisgICAgICAgICAgICBSZW5kZXJD b3VudGVyIGF0ICg2OSwwKSBzaXplIDl4MjEKKyAgICAgICAgICAgICAgdGV4dCBydW4gYXQgKDY5 LDApIHdpZHRoIDk6ICI0IgorICAgICAgICAgICAgUmVuZGVyVGV4dCBhdCAoNzgsMCkgc2l6ZSA1 eDIxCisgICAgICAgICAgICAgIHRleHQgcnVuIGF0ICg3OCwwKSB3aWR0aCA1OiAiLSIKKyAgICAg IFJlbmRlckJsb2NrIHtESVZ9IGF0ICgwLDU4KSBzaXplIDc4NHgyMQorICAgICAgICBSZW5kZXJU ZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSA4M3gyMQorICAgICAgICAgIHRleHQgcnVuIGF0ICgw LDApIHdpZHRoIDgzOiAiMS0xLjEtMi0zLTQtIgo= 43347 2009-11-17 00:30:08 -0800 2009-11-17 00:30:08 -0800 FYI patch p text/plain 11109 hamaji ZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcCBiL1dlYkNvcmUv cmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAppbmRleCAwYjRhZmM5Li5jNmY2ZjQ4IDEwMDY0NAot LS0gYS9XZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAKKysrIGIvV2ViQ29yZS9yZW5k ZXJpbmcvQ291bnRlck5vZGUuY3BwCkBAIC01NiwxMyArNTYsMTUgQEAgaW50IENvdW50ZXJOb2Rl Ojpjb21wdXRlQ291bnRJblBhcmVudCgpIGNvbnN0CiAgICAgcmV0dXJuIG1fcGFyZW50LT5tX3Zh bHVlICsgaW5jcmVtZW50OwogfQogCi12b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50KCkKK3ZvaWQg Q291bnRlck5vZGU6OnJlY291bnQoYm9vbCByZWNvdW50QWxsKQogewogICAgIGZvciAoQ291bnRl ck5vZGUqIGMgPSB0aGlzOyBjOyBjID0gYy0+bV9uZXh0U2libGluZykgewotICAgICAgICBpbnQg b2xkQ291bnQgPSBjLT5tX2NvdW50SW5QYXJlbnQ7CiAgICAgICAgIGludCBuZXdDb3VudCA9IGMt PmNvbXB1dGVDb3VudEluUGFyZW50KCk7Ci0gICAgICAgIGlmIChvbGRDb3VudCA9PSBuZXdDb3Vu dCkKLSAgICAgICAgICAgIGJyZWFrOworICAgICAgICBpZiAoIXJlY291bnRBbGwpIHsKKyAgICAg ICAgICAgIGludCBvbGRDb3VudCA9IGMtPm1fY291bnRJblBhcmVudDsKKyAgICAgICAgICAgIGlm IChvbGRDb3VudCA9PSBuZXdDb3VudCkKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAg fQogICAgICAgICBjLT5tX2NvdW50SW5QYXJlbnQgPSBuZXdDb3VudDsKICAgICAgICAgLy8gbV9y ZW5kZXJlciBjb250YWlucyB0aGUgcGFyZW50IG9mIHRoZSByZW5kZXIgbm9kZQogICAgICAgICAv LyBjb3JyZXNwb25kaW5nIHRvIGEgQ291bnRlck5vZGUuIExldCdzIGZpbmQgdGhlIGNvdW50ZXIK QEAgLTcyLDYgKzc0LDEyIEBAIHZvaWQgQ291bnRlck5vZGU6OnJlY291bnQoKQogICAgICAgICAg ICAgICAgIG8tPnNldE5lZWRzTGF5b3V0QW5kUHJlZldpZHRoc1JlY2FsYygpOwogICAgICAgICAg ICAgICAgIGJyZWFrOwogICAgICAgICAgICAgfQorCisgICAgICAgIGlmIChjLT5maXJzdENoaWxk KCkpIHsKKyAgICAgICAgICAgIC8vIFdoZW4gdGhlIHZhbHVlIG9mIHJlc2V0IG5vZGUgaXMgY2hh bmdlZCwgd2Ugc2hvdWxkIHJlY291bnQKKyAgICAgICAgICAgIC8vIGFsbCBkZXNjZW5kYW50cyBz byB0aGF0IHRoZXkgd2lsbCBiZSByZS1sYXlvdXRlZC4KKyAgICAgICAgICAgIGMtPmZpcnN0Q2hp bGQoKS0+cmVjb3VudCh0cnVlKTsKKyAgICAgICAgfQogICAgIH0KIH0KIApAQCAtMTAzLDE4ICsx MTEsNTkgQEAgdm9pZCBDb3VudGVyTm9kZTo6aW5zZXJ0QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0No aWxkLCBDb3VudGVyTm9kZSogcmVmQ2hpbGQpCiAKICAgICBuZXdDaGlsZC0+bV9wYXJlbnQgPSB0 aGlzOwogICAgIG5ld0NoaWxkLT5tX3ByZXZpb3VzU2libGluZyA9IHJlZkNoaWxkOworICAgIGlm IChuZXdDaGlsZC0+bV9pc1Jlc2V0ICYmIG5leHQpIHsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiBv ID0gbmV3Q2hpbGQtPm1fcmVuZGVyZXI7CisgICAgICAgIFJlbmRlck9iamVjdCogZW5kID0gbmV3 Q2hpbGQtPm1fcmVuZGVyZXItPnBhcmVudCgpLT5uZXh0U2libGluZygpOworICAgICAgICBDb3Vu dGVyTm9kZSogYyA9IG5leHQ7CisgICAgICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgICAgICB3 aGlsZSAobyAhPSBlbmQgJiYgbyAhPSBjLT5tX3JlbmRlcmVyKQorICAgICAgICAgICAgICAgIG8g PSBvLT5uZXh0SW5QcmVPcmRlcigpOworICAgICAgICAgICAgaWYgKG8gPT0gZW5kIHx8IChjLT5t X2lzUmVzZXQgJiYgby0+cGFyZW50KCkgPT0gbmV3Q2hpbGQtPm1fcmVuZGVyZXItPnBhcmVudCgp KSkgeworICAgICAgICAgICAgICAgIGlmIChDb3VudGVyTm9kZSogcHJldiA9IGMtPm1fcHJldmlv dXNTaWJsaW5nKQorICAgICAgICAgICAgICAgICAgICBwcmV2LT5tX25leHRTaWJsaW5nID0gMDsK KyAgICAgICAgICAgICAgICBjLT5tX3ByZXZpb3VzU2libGluZyA9IG5ld0NoaWxkOworICAgICAg ICAgICAgICAgIG5leHQgPSBjOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAg fQorCisgICAgICAgICAgICBpZiAoYyA9PSBuZXh0KSB7CisgICAgICAgICAgICAgICAgYy0+bV9w cmV2aW91c1NpYmxpbmcgPSAwOworICAgICAgICAgICAgICAgIG5ld0NoaWxkLT5tX2ZpcnN0Q2hp bGQgPSBjOworICAgICAgICAgICAgfQorICAgICAgICAgICAgbmV3Q2hpbGQtPm1fbGFzdENoaWxk ID0gYzsKKyAgICAgICAgICAgIGMtPm1fcGFyZW50ID0gbmV3Q2hpbGQ7CisKKyAgICAgICAgICAg IGMgPSBjLT5tX25leHRTaWJsaW5nOworICAgICAgICAgICAgaWYgKCFjKSB7CisgICAgICAgICAg ICAgICAgbV9sYXN0Q2hpbGQgPSBuZXdDaGlsZDsKKyAgICAgICAgICAgICAgICBuZXh0ID0gMDsK KyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0K KwogICAgIG5ld0NoaWxkLT5tX25leHRTaWJsaW5nID0gbmV4dDsKIAogICAgIG5ld0NoaWxkLT5t X2NvdW50SW5QYXJlbnQgPSBuZXdDaGlsZC0+Y29tcHV0ZUNvdW50SW5QYXJlbnQoKTsKKyAgICBp ZiAobmV3Q2hpbGQtPm1fZmlyc3RDaGlsZCkKKyAgICAgICAgbmV3Q2hpbGQtPm1fZmlyc3RDaGls ZC0+cmVjb3VudCh0cnVlKTsKICAgICBpZiAobmV4dCkKICAgICAgICAgbmV4dC0+cmVjb3VudCgp OworCisgICAgaWYgKG5ld0NoaWxkLT5tX2ZpcnN0Q2hpbGQpIHsKKyAgICAgICAgQVNTRVJUKG5l d0NoaWxkLT5tX2ZpcnN0Q2hpbGQtPm1fcGFyZW50ID09IG5ld0NoaWxkKTsKKyAgICAgICAgQVNT RVJUKG5ld0NoaWxkLT5tX2xhc3RDaGlsZCk7CisgICAgICAgIEFTU0VSVChuZXdDaGlsZC0+bV9s YXN0Q2hpbGQtPm1fcGFyZW50ID09IG5ld0NoaWxkKTsKKyAgICB9CisgICAgaWYgKG5ld0NoaWxk LT5tX25leHRTaWJsaW5nKQorICAgICAgICBBU1NFUlQobmV3Q2hpbGQtPm1fbmV4dFNpYmxpbmct Pm1fcHJldmlvdXNTaWJsaW5nID09IG5ld0NoaWxkKTsKKyAgICBpZiAobmV3Q2hpbGQtPm1fcHJl dmlvdXNTaWJsaW5nKQorICAgICAgICBBU1NFUlQobmV3Q2hpbGQtPm1fcHJldmlvdXNTaWJsaW5n LT5tX25leHRTaWJsaW5nID09IG5ld0NoaWxkKTsKIH0KIAogdm9pZCBDb3VudGVyTm9kZTo6cmVt b3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9sZENoaWxkKQogewogICAgIEFTU0VSVChvbGRDaGlsZCk7 Ci0gICAgQVNTRVJUKCFvbGRDaGlsZC0+bV9maXJzdENoaWxkKTsKLSAgICBBU1NFUlQoIW9sZENo aWxkLT5tX2xhc3RDaGlsZCk7CiAKICAgICBDb3VudGVyTm9kZSogbmV4dCA9IG9sZENoaWxkLT5t X25leHRTaWJsaW5nOwogICAgIENvdW50ZXJOb2RlKiBwcmV2ID0gb2xkQ2hpbGQtPm1fcHJldmlv dXNTaWJsaW5nOwpAQCAtMTI5LDcgKzE3OCw0MCBAQCB2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVD aGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQpCiAgICAgICAgIEFTU0VSVChtX2ZpcnN0Q2hpbGQg PT0gb2xkQ2hpbGQpOwogICAgICAgICBtX2ZpcnN0Q2hpbGQgPSBuZXh0OwogICAgIH0KLSAgICAK KworICAgIGJvb2wgcmVjb3VudEFsbCA9IGZhbHNlOworICAgIGlmIChwcmV2ICYmIHByZXYtPm1f aXNSZXNldCkgeworICAgICAgICBmb3IgKENvdW50ZXJOb2RlKiBjID0gb2xkQ2hpbGQtPm1fZmly c3RDaGlsZDsgYzsgYyA9IGMtPm1fbmV4dFNpYmxpbmcpCisgICAgICAgICAgICBjLT5tX3BhcmVu dCA9IHByZXY7CisgICAgICAgIGlmICghcHJldi0+bV9maXJzdENoaWxkKQorICAgICAgICAgICAg cHJldi0+bV9maXJzdENoaWxkID0gb2xkQ2hpbGQtPm1fZmlyc3RDaGlsZDsKKyAgICAgICAgaWYg KHByZXYtPm1fbGFzdENoaWxkKSB7CisgICAgICAgICAgICBpZiAob2xkQ2hpbGQtPm1fZmlyc3RD aGlsZCkgeworICAgICAgICAgICAgICAgIHByZXYtPm1fbGFzdENoaWxkLT5tX25leHRTaWJsaW5n ID0gb2xkQ2hpbGQtPm1fZmlyc3RDaGlsZDsKKyAgICAgICAgICAgICAgICBvbGRDaGlsZC0+bV9m aXJzdENoaWxkLT5tX3ByZXZpb3VzU2libGluZyA9IHByZXYtPm1fbGFzdENoaWxkOworICAgICAg ICAgICAgfQorICAgICAgICB9CisgICAgICAgIGlmIChvbGRDaGlsZC0+bV9sYXN0Q2hpbGQpCisg ICAgICAgICAgICBwcmV2LT5tX2xhc3RDaGlsZCA9IG9sZENoaWxkLT5tX2xhc3RDaGlsZDsKKyAg ICB9IGVsc2UgeworICAgICAgICAvLyBBZGQgb2xkQ2hpbGQncyBjaGlsZHJlbiBiZWZvcmUgbmV4 dC4KKyAgICAgICAgZm9yIChDb3VudGVyTm9kZSogYyA9IG9sZENoaWxkLT5tX2xhc3RDaGlsZDsg YzsgYyA9IGMtPm1fcHJldmlvdXNTaWJsaW5nKSB7CisgICAgICAgICAgICBjLT5tX25leHRTaWJs aW5nID0gbmV4dDsKKyAgICAgICAgICAgIGMtPm1fcGFyZW50ID0gdGhpczsKKyAgICAgICAgICAg IGlmIChwcmV2KQorICAgICAgICAgICAgICAgIHByZXYtPm1fbmV4dFNpYmxpbmcgPSBjOworICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIG1fZmlyc3RDaGlsZCA9IGM7CisKKyAgICAg ICAgICAgIGlmIChuZXh0KQorICAgICAgICAgICAgICAgIG5leHQtPm1fcHJldmlvdXNTaWJsaW5n ID0gYzsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBtX2xhc3RDaGlsZCA9IGM7 CisgICAgICAgICAgICBuZXh0ID0gYzsKKyAgICAgICAgICAgIHJlY291bnRBbGwgPSB0cnVlOwor ICAgICAgICB9CisgICAgfQorCiAgICAgaWYgKG5leHQpCiAgICAgICAgIG5leHQtPm1fcHJldmlv dXNTaWJsaW5nID0gcHJldjsKICAgICBlbHNlIHsKQEAgLTEzOCw3ICsyMjAsNyBAQCB2b2lkIENv dW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hpbGQpCiAgICAgfQogICAg IAogICAgIGlmIChuZXh0KQotICAgICAgICBuZXh0LT5yZWNvdW50KCk7CisgICAgICAgIG5leHQt PnJlY291bnQocmVjb3VudEFsbCk7CiB9CiAKICNpZm5kZWYgTkRFQlVHCmRpZmYgLS1naXQgYS9X ZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5oIGIvV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRl ck5vZGUuaAppbmRleCBiNDMyZTFkLi5hYmYyY2NjIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRl cmluZy9Db3VudGVyTm9kZS5oCisrKyBiL1dlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgK QEAgLTU1LDkgKzU1LDExIEBAIHB1YmxpYzoKICAgICB2b2lkIGluc2VydEFmdGVyKENvdW50ZXJO b2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIGJlZm9yZUNoaWxkKTsKICAgICB2b2lkIHJlbW92 ZUNoaWxkKENvdW50ZXJOb2RlKik7CiAKKyAgICB2b2lkIHNldFBhcmVudChDb3VudGVyTm9kZSog bmV3UGFyZW50KSB7IG1fcGFyZW50ID0gbmV3UGFyZW50OyB9CisKIHByaXZhdGU6CiAgICAgaW50 IGNvbXB1dGVDb3VudEluUGFyZW50KCkgY29uc3Q7Ci0gICAgdm9pZCByZWNvdW50KCk7CisgICAg dm9pZCByZWNvdW50KGJvb2wgcmVjb3VudEFsbCA9IGZhbHNlKTsKIAogICAgIGJvb2wgbV9pc1Jl c2V0OwogICAgIGludCBtX3ZhbHVlOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQ291bnRlci5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAppbmRl eCAxN2M2ZGFkLi43MjczNzIyIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJD b3VudGVyLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcApAQCAt Mjk1LDI0ICsyOTUsNjAgQEAgc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJOb2RlQ2hpbGRyZW4o QXRvbWljU3RyaW5nSW1wbCogaWRlbnRpZmllciwgQ291bnRlck5vZGUKICAgICB9CiB9CiAKLXZv aWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqIG9iamVj dCkKK3N0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZXNJbk1hcChDb3VudGVyTWFwKiBtYXAp Cit7CisgICAgQ291bnRlck1hcDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gbWFwLT5lbmQoKTsKKyAg ICBmb3IgKENvdW50ZXJNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbWFwLT5iZWdpbigpOyBpdCAh PSBlbmQ7ICsraXQpIHsKKyAgICAgICAgQ291bnRlck5vZGUqIG5vZGUgPSBpdC0+c2Vjb25kOwor ICAgICAgICBkZXN0cm95Q291bnRlck5vZGVDaGlsZHJlbihpdC0+Zmlyc3QuZ2V0KCksIG5vZGUp OworICAgICAgICBpZiAoQ291bnRlck5vZGUqIHBhcmVudCA9IG5vZGUtPnBhcmVudCgpKQorICAg ICAgICAgICAgcGFyZW50LT5yZW1vdmVDaGlsZChub2RlKTsKKyAgICAgICAgZGVsZXRlIG5vZGU7 CisgICAgfQorfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmludmFsaWRhdGVTdWJzZXF1ZW50Q291 bnRlck5vZGVzKFJlbmRlck9iamVjdCogb2JqZWN0KQoreworICAgIENvdW50ZXJNYXBzJiBtYXBz ID0gY291bnRlck1hcHMoKTsKKyAgICBmb3IgKG9iamVjdC0+bmV4dEluUHJlT3JkZXIoKTsgb2Jq ZWN0OyBvYmplY3QgPSBvYmplY3QtPm5leHRJblByZU9yZGVyKCkpIHsKKyAgICAgICAgaWYgKG9i amVjdC0+aXNDb3VudGVyKCkpCisgICAgICAgICAgICB0b1JlbmRlckNvdW50ZXIob2JqZWN0KS0+ aW52YWxpZGF0ZSgpOworCisgICAgICAgIENvdW50ZXJNYXAqIG1hcCA9IG1hcHMuZ2V0KG9iamVj dCk7CisgICAgICAgIGlmICghbWFwKQorICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIGRl c3Ryb3lDb3VudGVyTm9kZXNJbk1hcChtYXApOworICAgICAgICBtYXAtPmNsZWFyKCk7CisgICAg fQorfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZXMoUmVuZGVyT2Jq ZWN0KiBvYmplY3QsIGJvb2wgZGVzdHJveUNoaWxkcmVuKQogewogICAgIENvdW50ZXJNYXBzJiBt YXBzID0gY291bnRlck1hcHMoKTsKLSAgICBDb3VudGVyTWFwKiBtYXAgPSBtYXBzLmdldChvYmpl Y3QpOworICAgIENvdW50ZXJNYXBzOjppdGVyYXRvciBmb3VuZCA9IG1hcHMuZmluZChvYmplY3Qp OworICAgIENvdW50ZXJNYXAqIG1hcCA9IGZvdW5kLT5zZWNvbmQ7CiAgICAgaWYgKCFtYXApCiAg ICAgICAgIHJldHVybjsKLSAgICBtYXBzLnJlbW92ZShvYmplY3QpOwogCiAgICAgQ291bnRlck1h cDo6Y29uc3RfaXRlcmF0b3IgZW5kID0gbWFwLT5lbmQoKTsKICAgICBmb3IgKENvdW50ZXJNYXA6 OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbWFwLT5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKICAg ICAgICAgQ291bnRlck5vZGUqIG5vZGUgPSBpdC0+c2Vjb25kOwogICAgICAgICBkZXN0cm95Q291 bnRlck5vZGVDaGlsZHJlbihpdC0+Zmlyc3QuZ2V0KCksIG5vZGUpOworICAgICAgICBpZiAoZGVz dHJveUNoaWxkcmVuKQorICAgICAgICAgICAgZGVzdHJveUNvdW50ZXJOb2RlQ2hpbGRyZW4oaXQt PmZpcnN0LmdldCgpLCBub2RlKTsKICAgICAgICAgaWYgKENvdW50ZXJOb2RlKiBwYXJlbnQgPSBu b2RlLT5wYXJlbnQoKSkKICAgICAgICAgICAgIHBhcmVudC0+cmVtb3ZlQ2hpbGQobm9kZSk7Cisg ICAgICAgIGVsc2UgaWYgKCFkZXN0cm95Q2hpbGRyZW4pCisgICAgICAgICAgICAvLyBUaGUgcm9v dCBub2RlIHdhcyBnb25lLiBNYWtlIGNoaWxkcmVuIHJvb3QuCisgICAgICAgICAgICBmb3IgKENv dW50ZXJOb2RlKiBjID0gbm9kZS0+Zmlyc3RDaGlsZCgpOyBjOyBjID0gYy0+bmV4dFNpYmxpbmco KSkKKyAgICAgICAgICAgICAgICBjLT5zZXRQYXJlbnQoMCk7CiAgICAgICAgIGRlbGV0ZSBub2Rl OwogICAgIH0KIAogICAgIGRlbGV0ZSBtYXA7CisgICAgbWFwcy5yZW1vdmUoZm91bmQpOworCisg ICAgb2JqZWN0LT5tX2hhc0NvdW50ZXJOb2RlTWFwID0gZmFsc2U7CiB9CiAKIH0gLy8gbmFtZXNw YWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAppbmRleCA5NjE5NjhlLi41NzIx Yzk5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgKKysrIGIv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCkBAIC0zNSw3ICszNSw4IEBAIHB1Ymxp YzoKIAogICAgIHZvaWQgaW52YWxpZGF0ZSgpOwogCi0gICAgc3RhdGljIHZvaWQgZGVzdHJveUNv dW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqKTsKKyAgICBzdGF0aWMgdm9pZCBpbnZhbGlkYXRlU3Vi c2VxdWVudENvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqKTsKKyAgICBzdGF0aWMgdm9pZCBkZXN0 cm95Q291bnRlck5vZGVzKFJlbmRlck9iamVjdCosIGJvb2wgZGVzdHJveUNoaWxkcmVuKTsKIAog cHJpdmF0ZToKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmluZGV4IDNkYzU2NWMuLmIzZWVlYTIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtMzEwLDYgKzMxMCwxNSBAQCB2b2lkIFJlbmRlck9i amVjdDo6YWRkQ2hpbGQoUmVuZGVyT2JqZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZv cmVDaGlsZCkKICAgICAgICAgaWYgKHRleHRUb1RyYW5zZm9ybSkKICAgICAgICAgICAgIHRvUmVu ZGVyVGV4dChuZXdDaGlsZCktPnNldFRleHQodGV4dFRvVHJhbnNmb3JtLnJlbGVhc2UoKSwgdHJ1 ZSk7CiAgICAgfQorCisgICAgLy8gSWYgbmV3Q2hpbGQgaGFzIGNvdW50ZXIgZGlyZWN0aXZlcyBh bmQgaXMgYW5vbnltb3VzLCB0aGlzIG1lYW5zCisgICAgLy8gbmV3Q2hpbGQgaXMgOmJlZm9yZSBv ciA6YWZ0ZXIuIEFzIHRoZXNlIG5vZGVzIGFyZW4ndCBjb25uZWN0ZWQKKyAgICAvLyB0byB0aGUg cmVuZGVyIHRyZWUgeWV0LCB3ZSBjYW5ub3QgY2FsY3VsYXRlIHRoZWlyIHZhbHVlCisgICAgLy8g Y29ycmVjdGx5IGhlcmUuIEFueXdheSwgZm9yIHRoaXMgY2FzZSwgd2UgZG9uJ3QgbmVlZCB0bwor ICAgIC8vIHJlZ2lzdGVyIGEgY291bnRlciBub3cgYmVjYXVzZSB0aGUgdmFsdWUgb2YgbmV3Q2hp bGQgd2lsbCBiZQorICAgIC8vIGNhbGN1bGF0ZWQgaW4gb3JpZ2luYWxUZXh0KCkuCisgICAgaWYg KG5ld0NoaWxkLT5zdHlsZSgpLT5jb3VudGVyRGlyZWN0aXZlcygpICYmICFuZXdDaGlsZC0+aXNB bm9ueW1vdXMoKSkKKyAgICAgICAgUmVuZGVyQ291bnRlcjo6aW52YWxpZGF0ZVN1YnNlcXVlbnRD b3VudGVyTm9kZXMobmV3Q2hpbGQpOwogfQogCiB2b2lkIFJlbmRlck9iamVjdDo6cmVtb3ZlQ2hp bGQoUmVuZGVyT2JqZWN0KiBvbGRDaGlsZCkKQEAgLTE2MDEsMTYgKzE2MTAsMjkgQEAgdm9pZCBS ZW5kZXJPYmplY3Q6OnN0eWxlV2lsbENoYW5nZShTdHlsZURpZmZlcmVuY2UgZGlmZiwgY29uc3Qg UmVuZGVyU3R5bGUqIG5ld1MKICAgICB9CiB9CiAKLXZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURp ZENoYW5nZShTdHlsZURpZmZlcmVuY2UgZGlmZiwgY29uc3QgUmVuZGVyU3R5bGUqKQordm9pZCBS ZW5kZXJPYmplY3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxlRGlmZmVyZW5jZSBkaWZmLCBjb25zdCBS ZW5kZXJTdHlsZSogb2xkU3R5bGUpCiB7CiAgICAgaWYgKHNfYWZmZWN0c1BhcmVudEJsb2NrKQog ICAgICAgICBoYW5kbGVEeW5hbWljRmxvYXRQb3NpdGlvbkNoYW5nZSgpOwogCiAgICAgaWYgKCFt X3BhcmVudCkKICAgICAgICAgcmV0dXJuOwotICAgIAotICAgIGlmIChkaWZmID09IFN0eWxlRGlm ZmVyZW5jZUxheW91dCkKKworICAgIGlmIChkaWZmID09IFN0eWxlRGlmZmVyZW5jZUxheW91dCkg ewogICAgICAgICBzZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKKworICAgICAg ICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBuZXdDb3VudGVyRGlyZWN0aXZlcyA9IHN0eWxl KCktPmNvdW50ZXJEaXJlY3RpdmVzKCk7CisgICAgICAgIGNvbnN0IENvdW50ZXJEaXJlY3RpdmVN YXAqIG9sZENvdW50ZXJEaXJlY3RpdmVzID0gb2xkU3R5bGUtPmNvdW50ZXJEaXJlY3RpdmVzKCk7 CisgICAgICAgIGlmICghaXNBbm9ueW1vdXMoKSAmJiBuZXdDb3VudGVyRGlyZWN0aXZlcyAmJiBv bGRDb3VudGVyRGlyZWN0aXZlcykgeworICAgICAgICAgICAgaWYgKCpuZXdDb3VudGVyRGlyZWN0 aXZlcyAhPSAqb2xkQ291bnRlckRpcmVjdGl2ZXMpIHsKKyAgICAgICAgICAgICAgICBSZW5kZXJD b3VudGVyOjpkZXN0cm95Q291bnRlck5vZGVzKHRoaXMsIGZhbHNlKTsKKyAgICAgICAgICAgICAg ICBSZW5kZXJDb3VudGVyOjppbnZhbGlkYXRlU3Vic2VxdWVudENvdW50ZXJOb2Rlcyh0aGlzKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIGlmIChuZXdDb3VudGVyRGlyZWN0aXZlcykK KyAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmludmFsaWRhdGVTdWJzZXF1ZW50Q291bnRlck5v ZGVzKHRoaXMpOworICAgICAgICBlbHNlIGlmIChvbGRDb3VudGVyRGlyZWN0aXZlcykKKyAgICAg ICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZXModGhpcywgZmFsc2UpOwor ICAgIH0KICAgICBlbHNlIGlmIChkaWZmID09IFN0eWxlRGlmZmVyZW5jZUxheW91dFBvc2l0aW9u ZWRNb3ZlbWVudE9ubHkpCiAgICAgICAgIHNldE5lZWRzUG9zaXRpb25lZE1vdmVtZW50TGF5b3V0 KCk7CiAKQEAgLTE4NzMsNyArMTg5NSw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjpkZXN0cm95KCkK ICAgICAgICAgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ZXZlbnRIYW5kbGVyKCktPnN0b3BBdXRvc2Ny b2xsVGltZXIodHJ1ZSk7CiAKICAgICBpZiAobV9oYXNDb3VudGVyTm9kZU1hcCkKLSAgICAgICAg UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2Rlcyh0aGlzKTsKKyAgICAgICAgUmVuZGVy Q291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2Rlcyh0aGlzLCB0cnVlKTsKIAogICAgIGlmIChBWE9i amVjdENhY2hlOjphY2Nlc3NpYmlsaXR5RW5hYmxlZCgpKSB7CiAgICAgICAgIGRvY3VtZW50KCkt PmF4T2JqZWN0Q2FjaGUoKS0+Y2hpbGRyZW5DaGFuZ2VkKHRoaXMtPnBhcmVudCgpKTsK 43487 2009-11-18 22:08:00 -0800 2010-01-18 13:34:00 -0800 Proposed Patch patchFor11031-4.patch text/plain 41222 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MTA0MCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTggQEAKKzIwMDktMTEtMTQgIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorICAgICAgICBUaGlzIHBhdGNoIGZpeGVzIHRoZSBD U1MyLjEgY291bnRlciBpbXBsZW1lbnRhdGlvbiBzdWNoIHRoYXQgaXQKKyAgICAgICAgY29uZm9y bXMgdG8gdGhlIGxhdGVzdCBzY29waW5nIGFuZCBuZXN0aW5nIHJ1bGVzIGFuZCB1cGRhdGVzCisg ICAgICAgIHRoZSB2YWx1ZXMgb2YgdGhlIGNvdW50ZXJzIHdoZW4gdGhlIERPTSBpcyBjaGFuZ2Vk LgorCisgICAgICAgIFRlc3RzOiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0w MDIuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0w MDAuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0w MDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkNvdW50ZXJOb2RlOjpjb21wdXRlQ291bnRJblBhcmVudCk6CisgICAgICAgIENo YW5nZWQgdG8gdXNlIGlzUmVzZXQoKSBpbnN0ZWFkIG9mIG1faXNSZXNldCBpbiBvcmRlciB0byBi ZSBpbnN5bmMKKyAgICAgICAgd2l0aCB0aGUgY2hhbmdlIGluIG1lYW5pbmcgb2YgbV9pc1Jlc2V0 IHdoaWNoIG5vdyBtZWFucyB0aGF0IHRoZQorICAgICAgICBjb3VudGVyIGlzIG9mIHJlc2V0IHR5 cGUgYmVjYXVzZSBpdCB3YXMgc3R5bGVkIGFzIHN1Y2ggdmVyc3VzIHRoZQorICAgICAgICBvbGQg bWVhbmluZyB0aGF0IGl0IGlzIHJlc2V0IGVpdGhlciBiZWNhdXNlIG9mIHRoZSBzdHlsZXNoZWV0 IG9yIAorICAgICAgICBiZWNhdXNlIGl0IGlzIHRoZSBmaXJzdCByZWZlcmVuY2UgdG8gdGhpcyBj b3VudGVyIGlkZW50aWZpZXIuCisgICAgICAgIChXZWJDb3JlOjpDb3VudGVyTm9kZTo6aW5zZXJ0 QWZ0ZXIpOgorICAgICAgICBDaGFuZ2VkIHRvIHByb3Blcmx5IGludmFsaWRhdGUgdGhlIGNvdW50 ZXIgaGllcmFyY2h5IHdoZW4gYSByZXNldAorICAgICAgICBub2RlIGlzIGluc2VydGVkIGFzIHNv bWUgb2YgdGhlIHN1YnNlcXVlbnQgbm9kZXMgb24gdGhlIHRyZWUgbWF5IGJlCisgICAgICAgIHJl YXJyYW5nZWQuCisgICAgICAgICogcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmg6CisgICAgICAgIChX ZWJDb3JlOjpDb3VudGVyTm9kZTo6aXNSZXNldCk6CisgICAgICAgIENoYW5nZWQgdG8gY292ZXIg Ym90aCBjYXNlcyB3aGVuIGEgY291bnRlciBhY3RzIGFzIGEgcmVzZXQgY291bnRlci4KKyAgICAg ICAgKFdlYkNvcmU6OkNvdW50ZXJOb2RlOjppc1R5cGVSZXNldCk6CisgICAgICAgIEludHJvZHVj ZWQgdG8gZW5hYmxlIGV4dHJhY3Rpb24gb2YgdGhlIGNvdW50ZXIgdHlwZSBhY2NvcmRpbmcgdG8g dGhlCisgICAgICAgIHN0eWxlIHNoZWV0LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJDb3Vu dGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmZpbmRQbGFjZUZvckNvdW50ZXIpOgorICAgICAg ICBDb21wbGV0ZWx5IHJld3JpdHRlbiB0aGUgYWxnb3JpdGhtIHRvIGFjY291bnQgZm9yIGN1cnJl bnQgY291bnRlcgorICAgICAgICBzY29waW5nIHJ1bGVzIGFuZCB0byBwcm9wZXJseSBoYW5kbGUg cmFuZG9tIGNvdW50ZXIgaW5zZXJ0aW9ucy4KKyAgICAgICAgKFdlYkNvcmU6Om1ha2VDb3VudGVy Tm9kZSk6CisgICAgICAgIEFkZGVkIGNvZGUgdG8gcmVldmFsdWF0ZSB0aGUgY291bnRlciBoaWVy YXJjaHkgdXBvbiBuZXcgcm9vdCBjb3VudGVyCisgICAgICAgIGNyZWF0aW9uLCBhZGFwdGVkIHRv IG5ldyBpc1Jlc2V0IHNlbWFudGljcy4KKyAgICAgICAgKFdlYkNvcmU6OmRlc3Ryb3lDb3VudGVy Tm9kZVdpdGhvdXRNYXBSZW1vdmFsKToKKyAgICAgICAgUmVmYWN0b3JlZCBkZXN0cm95Q291bnRl ck5vZGVDaGlsZHJlbiB0byBjb250YWluIG1vcmUgb2YgdGhlIHNoYXJlZCAKKyAgICAgICAgY29k ZSBiZXR3ZWVuIHRoZSBuZXh0IDIgZnVuY3Rpb25zLgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVy Q291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2Rlcyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJD b3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUpOgorICAgICAgICBBZGRlZCBzdXBwb3J0IGZvciBz ZWxlY3RpdmUgY291bnRlciBub2RlIGRlc3RydWN0aW9uLgorICAgICAgICAoV2ViQ29yZTo6UmVu ZGVyQ291bnRlcjo6Y3JlYXRlQ291bnRlcklmTmVlZGVkKToKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckNv dW50ZXI6OnVwZGF0ZUNvdW50ZXIpOgorICAgICAgICBOZXcgZnVuY3Rpb25zIHRoYXQgc3VwcG9y dCBkeW5hbWljIGNvdW50ZXIgaGllcmFyY2h5IHVwZGF0ZSB1cG9uIERPTQorICAgICAgICBjaGFu Z2VzCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaDoKKyAgICAgICAgKiByZW5k ZXJpbmcvUmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6 YWRkQ2hpbGQpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjpzZXRTdHlsZSk6Cisg ICAgICAgIEFkZGVkIGhvb2tzIHRvIHVwZGF0ZSB0aGUgY291bnRlciBoaWVyYXJjaHkgd2hlbiB0 aGUgRE9NIGNoYW5nZXMuCisKIDIwMDktMTEtMTYgIEFsZXhleSBQcm9za3VyeWFrb3YgIDxhcEBh cHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJD b3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5k ZXJpbmcvQ291bnRlck5vZGUuY3BwCShyZXZpc2lvbiA1MTA0MCkKKysrIFdlYkNvcmUvcmVuZGVy aW5nL0NvdW50ZXJOb2RlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjIsMTYgKzIyLDEwIEBACiAj aW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKIAorI2luY2x1ZGUg IlJlbmRlckNvdW50ZXIuaCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKICNpbmNsdWRlIDxz dGRpby5oPgogCi0vLyBGSVhNRTogVGhlcmUncyBjdXJyZW50bHkgbm8gc3RyYXRlZ3kgZm9yIGdl dHRpbmcgdGhlIGNvdW50ZXIgdHJlZSB1cGRhdGVkIHdoZW4gbmV3Ci0vLyBlbGVtZW50cyB3aXRo IGNvdW50ZXItcmVzZXQgYW5kIGNvdW50ZXItaW5jcmVtZW50IHN0eWxlcyBhcmUgYWRkZWQgdG8g dGhlIHJlbmRlciB0cmVlLgotLy8gQWxzbywgdGhlIGNvZGUgY2FuJ3QgaGFuZGxlIGNoYW5nZXMg d2hlcmUgYW4gZXhpc3Rpbmcgbm9kZSBuZWVkcyB0byBjaGFuZ2UgaW50byBhCi0vLyAicmVzZXQi IG5vZGUsIG9yIGZyb20gYSAicmVzZXQiIG5vZGUgYmFjayB0byBub3QgYSAicmVzZXQiIG5vZGUu IEFzIG9mIHRoaXMgd3JpdGluZywKLS8vIGF0IGxlYXN0IHNvbWUgb2YgdGhlc2UgcHJvYmxlbXMg bWFuaWZlc3QgYXMgZmFpbHVyZXMgaW4gdGhlIHQxMjA0LWluY3JlbWVudCBhbmQKLS8vIHQxMjA0 LXJlc2V0IHRlc3RzIGluIHRoZSBDU1MgMi4xIHRlc3Qgc3VpdGUuCi0KIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogQ291bnRlck5vZGU6OkNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCogbywgYm9vbCBp c1Jlc2V0LCBpbnQgdmFsdWUpCkBAIC0xMDAsMTQgKzk0LDEzIEBAIENvdW50ZXJOb2RlKiBDb3Vu dGVyTm9kZTo6cHJldmlvdXNJblByZU8KIAogaW50IENvdW50ZXJOb2RlOjpjb21wdXRlQ291bnRJ blBhcmVudCgpIGNvbnN0CiB7Ci0gICAgaW50IGluY3JlbWVudCA9IG1faXNSZXNldCA/IDAgOiBt X3ZhbHVlOworICAgIGludCBpbmNyZW1lbnQgPSBpc1Jlc2V0KCkgPyAwIDogbV92YWx1ZTsKICAg ICBpZiAobV9wcmV2aW91c1NpYmxpbmcpCiAgICAgICAgIHJldHVybiBtX3ByZXZpb3VzU2libGlu Zy0+bV9jb3VudEluUGFyZW50ICsgaW5jcmVtZW50OwogICAgIEFTU0VSVChtX3BhcmVudC0+bV9m aXJzdENoaWxkID09IHRoaXMpOwogICAgIHJldHVybiBtX3BhcmVudC0+bV92YWx1ZSArIGluY3Jl bWVudDsKIH0KIAotCiB2b2lkIENvdW50ZXJOb2RlOjpyZXNldFJlbmRlcmVyKGNvbnN0IEF0b21p Y1N0cmluZyYgaWRlbnRpZmllcikgY29uc3QKIHsKICAgICBpZiAoIW1fcmVuZGVyZXIgfHwgbV9y ZW5kZXJlci0+ZG9jdW1lbnRCZWluZ0Rlc3Ryb3llZCgpKQpAQCAtMTQ1LDYgKzEzOCwxMiBAQCB2 b2lkIENvdW50ZXJOb2RlOjppbnNlcnRBZnRlcihDb3VudGVyTm9kCiAgICAgQVNTRVJUKCFuZXdD aGlsZC0+bV9uZXh0U2libGluZyk7CiAgICAgQVNTRVJUKCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+ bV9wYXJlbnQgPT0gdGhpcyk7CiAKKyAgICBpZiAobmV3Q2hpbGQtPmlzVHlwZVJlc2V0KCkpIHsK KyAgICAgICAgd2hpbGUgKG1fbGFzdENoaWxkICE9IHJlZkNoaWxkKSB7CisgICAgICAgICAgICBS ZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUobV9sYXN0Q2hpbGQtPnJlbmRlcmVyKCks IGlkZW50aWZpZXIpOworICAgICAgICB9CisgICAgfQorCiAgICAgQ291bnRlck5vZGUqIG5leHQ7 CiAKICAgICBpZiAocmVmQ2hpbGQpIHsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL0NvdW50ZXJO b2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2 aXNpb24gNTEwNDApCisrKyBXZWJDb3JlL3JlbmRlcmluZy9Db3VudGVyTm9kZS5oCSh3b3JraW5n IGNvcHkpCkBAIC00Miw3ICs0Miw4IEBAIGNsYXNzIENvdW50ZXJOb2RlIDogcHVibGljIE5vbmNv cHlhYmxlIHsKIHB1YmxpYzoKICAgICBDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBib29sIGlz UmVzZXQsIGludCB2YWx1ZSk7CiAKLSAgICBib29sIGlzUmVzZXQoKSBjb25zdCB7IHJldHVybiBt X2lzUmVzZXQ7IH0KKyAgICBib29sIGlzUmVzZXQoKSBjb25zdCB7IHJldHVybiBtX2lzUmVzZXQg fHwgIW1fcGFyZW50OyB9CisgICAgYm9vbCBpc1R5cGVSZXNldCgpIGNvbnN0IHsgcmV0dXJuIG1f aXNSZXNldDsgfQogICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFsdWU7IH0KICAg ICBpbnQgY291bnRJblBhcmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fY291bnRJblBhcmVudDsgfQog ICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIoKSBjb25zdCB7IHJldHVybiBtX3JlbmRlcmVyOyB9 CkBAIC01OCwxMiArNTksMjIgQEAgcHVibGljOgogICAgIENvdW50ZXJOb2RlKiBuZXh0SW5QcmVP cmRlckFmdGVyQ2hpbGRyZW4oY29uc3QgQ291bnRlck5vZGUqIHN0YXlXaXRoaW4gPSAwKSBjb25z dDsKIAogICAgIHZvaWQgaW5zZXJ0QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVy Tm9kZSogYmVmb3JlQ2hpbGQsIGNvbnN0IEF0b21pY1N0cmluZyYgaWRlbnRpZmllcik7CisKKyAg ICAvLyBpZGVudGlmaWVyIG11c3QgbWF0Y2ggdGhlIGlkZW50aWZpZXIgb2YgdGhpcyBjb3VudGVy IG9yCisgICAgLy8gdGhlIHJlbmRlcmVycyBhZmZlY3RlZCBieSB0aGlzIHJlbW92YWwgc2hhbGwg bm90IGJlIGludmFsaWRhdGVkLgogICAgIHZvaWQgcmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqLCBj b25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpOwogCiBwcml2YXRlOgogICAgIGludCBjb21w dXRlQ291bnRJblBhcmVudCgpIGNvbnN0OwogICAgIHZvaWQgcmVjb3VudChjb25zdCBBdG9taWNT dHJpbmcmIGlkZW50aWZpZXIpOworCisgICAgLy8gSW52YWxpZGF0ZXMgdGhlIHRleHQgaW4gdGhl IHJlbmRlcmVyIG9mIHRoaXMgY291bnRlciwgaWYgYW55LgorICAgIC8vIGlkZW50aWZpZXIgbXVz dCBtYXRjaCB0aGUgaWRlbnRpZmllciBmb3IgdGhpcyBjb3VudGVyLgogICAgIHZvaWQgcmVzZXRS ZW5kZXJlcihjb25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpIGNvbnN0OworCisgICAgLy8g SW52YWxpZGF0ZXMgdGhlIHRleHQgaW4gdGhlIHJlbmRlcmVyIG9mIHRoaXMgY291bnRlciwgaWYg YW55LAorICAgIC8vIGFuZCBpbiB0aGUgcmVuZGVyZXJzIG9mIGFsbCBkZXNjZW5kYW50cyBvZiB0 aGlzIGNvdW50ZXIsIGlmIGFueS4KKyAgICAvLyBpZGVudGlmaWVyIG11c3QgbWF0Y2ggdGhlIGlk ZW50aWZpZXIgZm9yIHRoaXMgY291bnRlci4KICAgICB2b2lkIHJlc2V0UmVuZGVyZXJzKGNvbnN0 IEF0b21pY1N0cmluZyYgaWRlbnRpZmllcikgY29uc3Q7CiAKICAgICBib29sIG1faXNSZXNldDsK SW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCShyZXZpc2lvbiA1MTA0MCkKKysr IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0x MDksNTUgKzEwOSwxMjQgQEAgc3RhdGljIGJvb2wgcGxhbkNvdW50ZXIoUmVuZGVyT2JqZWN0KiBv YgogICAgIHJldHVybiBmYWxzZTsKIH0KIAotc3RhdGljIGJvb2wgZmluZFBsYWNlRm9yQ291bnRl cihSZW5kZXJPYmplY3QqIG9iamVjdCwgY29uc3QgQXRvbWljU3RyaW5nJiBjb3VudGVyTmFtZSwK LSAgICBib29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYgcGFyZW50LCBDb3VudGVyTm9kZSomIHBy ZXZpb3VzU2libGluZykKKy8vIEZpbmRzIHRoZSBpbnNlcnRpb24gcG9pbnQgZm9yIHRoZSBjb3Vu dGVyIGRlc2NyaWJlZCBieSBjb3VudGVyT3duZXIsIGlzUmVzZXQgYW5kIAorLy8gY291bnRlck5h bWUgaW4gdGhlIENvdW50ZXJOb2RlIHRyZWUgZm9yIGNvdW50ZXJOYW1lIGFuZCBzZXRzIHBhcmVu dCBhbmQKKy8vIHByZXZpb3VzU2libGluZyBhY2NvcmRpbmdseS4KKy8vIFRoZSBmdW5jdGlvbiBy ZXR1cm5zIHRydWUgaWYgdGhlIGNvdW50ZXIgd2hvc2UgaW5zZXJ0aW9uIHBvaW50IGlzIHNlYXJj aGVkIGlzIE5PVAorLy8gdGhlIHJvb3Qgb2YgdGhlIHRyZWUuCisvLyBUaGUgcm9vdCBvZiB0aGUg dHJlZSBpcyBhIGNvdW50ZXIgcmVmZXJlbmNlIHRoYXQgaXMgbm90IGluIHRoZSBzY29wZSBvZiBh bnkgb3RoZXIKKy8vIGNvdW50ZXIgd2l0aCB0aGUgc2FtZSBpZGVudGlmaWVyLgorLy8gQWxsIHRo ZSBjb3VudGVyIHJlZmVyZW5jZXMgd2l0aCB0aGUgc2FtZSBpZGVudGlmaWVyIGFzIHRoaXMgb25l IHRoYXQgYXJlIGluCisvLyBjaGlsZHJlbiBvciBzdWJzZXF1ZW50IHNpYmxpbmdzIG9mIHRoZSBy ZW5kZXJlciB0aGF0IG93bnMgdGhlIHJvb3Qgb2YgdGhlIHRyZWUKKy8vIGZvcm0gdGhlIHJlc3Qg b2Ygb2YgdGhlIG5vZGVzIG9mIHRoZSB0cmVlLgorLy8gVGhlIHJvb3Qgb2YgdGhlIHRyZWUgaXMg YWx3YXlzIGEgcmVzZXQgdHlwZSByZWZlcmVuY2UuCisvLyBBIHN1YnRyZWUgcm9vdGVkIGF0IGFu eSByZXNldCBub2RlIGluIHRoZSB0cmVlIGlzIGVxdWl2YWxlbnQgdG8gYWxsIGNvdW50ZXIgCisv LyByZWZlcmVuY2VzIHRoYXQgYXJlIGluIHRoZSBzY29wZSBvZiB0aGUgY291bnRlciBvciBuZXN0 ZWQgY291bnRlciBkZWZpbmVkIGJ5IHRoYXQKKy8vIHJlc2V0IG5vZGUuCisvLyBOb24tcmVzZXQg Q291bnRlck5vZGVzIGNhbm5vdCBoYXZlIGRlc2NlbmRhbnRzLgorCitzdGF0aWMgYm9vbCBmaW5k UGxhY2VGb3JDb3VudGVyKFJlbmRlck9iamVjdCogY291bnRlck93bmVyLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBBdG9taWNTdHJpbmcmIGNvdW50ZXJOYW1lLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBib29sIGlzUmVzZXQsIENvdW50ZXJOb2RlKiYg cGFyZW50LCAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ291bnRlck5vZGUqJiBw cmV2aW91c1NpYmxpbmcpCiB7Ci0gICAgLy8gRmluZCB0aGUgYXBwcm9wcmlhdGUgcHJldmlvdXMg c2libGluZyBmb3IgaW5zZXJ0aW9uIGludG8gdGhlIHBhcmVudCBub2RlCi0gICAgLy8gYnkgc2Vh cmNoaW5nIGluIHJlbmRlciB0cmVlIG9yZGVyIGZvciBhIGNoaWxkIG9mIHRoZSBjb3VudGVyLgot ICAgIHBhcmVudCA9IDA7CisgICAgLy8gV2UgY2Fubm90IHN0b3Agc2VhcmNoaW5nIGZvciBjb3Vu dGVycyB3aXRoIHRoZSBzYW1lIGNvdW50ZXJOYW1lIGJlZm9yZSB3ZSBhbHNvCisgICAgLy8gY2hl Y2sgdGhpcyByZW5kZXJlciwgYmVjYXVzZSBpdCBtYXkgYWZmZWN0IHRoZSBwb3NpdGlvbmluZyBp biB0aGUgdHJlZSBvZiBvdXIgY291bnRlcgorICAgIFJlbmRlck9iamVjdCogc2VhcmNoRW5kUmVu ZGVyZXIgPSBwcmV2aW91c1NpYmxpbmdPclBhcmVudChjb3VudGVyT3duZXIpOworICAgIC8vIFdl IGNoZWNrIHJlbmRlcmVycyBpbiBwcmVPcmRlciBmcm9tIHRoZSByZW5kZXJlciB0aGF0IG91ciBj b3VudGVyIGlzIGF0dGFjaGVkIHRvCisgICAgLy8gdG93YXJkcyB0aGUgYmVnaW5pbmcgb2YgdGhl IGRvY3VtZW50IGZvciBjb3VudGVycyB3aXRoIHRoZSBzYW1lIG5hbWUgYXMgdGhlIG9uZQorICAg IC8vIHdlIGFyZSB0cnlpbmcgdG8gZmluZCBhIHBsYWNlIGZvci4gVGhpcyBpcyB0aGUgbmV4dCBy ZW5kZXJlciB0byBiZSBjaGVja2VkLgorICAgIFJlbmRlck9iamVjdCogY3VycmVudFJlbmRlcmVy ID0gY291bnRlck93bmVyLT5wcmV2aW91c0luUHJlT3JkZXIoKTsKICAgICBwcmV2aW91c1NpYmxp bmcgPSAwOwotICAgIFJlbmRlck9iamVjdCogcmVzZXRDYW5kaWRhdGUgPSBpc1Jlc2V0ID8gb2Jq ZWN0LT5wYXJlbnQoKSA6IHByZXZpb3VzU2libGluZ09yUGFyZW50KG9iamVjdCk7Ci0gICAgUmVu ZGVyT2JqZWN0KiBwcmV2Q291bnRlckNhbmRpZGF0ZSA9IG9iamVjdDsKLSAgICBDb3VudGVyTm9k ZSogY2FuZGlkYXRlQ291bnRlciA9IDA7Ci0gICAgLy8gV2hlbiBhIHJlc2V0IGNvdW50ZXIgaXMg Y2hvc2VuIGFzIGNhbmRpZGF0ZUNvdW50ZXIsIHdlJ2xsCi0gICAgLy8gZGVjaWRlIHRoZSBuZXcg bm9kZSBzaG91bGQgYmUgYSBjaGlsZCBvZiB0aGUgcmVzZXQgbm9kZSBvciBhCi0gICAgLy8gc2li bGluZyBvciB0aGUgcmVzZXQgbm9kZS4gVGhpcyBmbGFnIGNvbnRyb2xzIGl0LgotICAgIGJvb2wg Y3JlYXRlQ2hpbGRGb3JSZXNldCA9IHRydWU7Ci0gICAgd2hpbGUgKChwcmV2Q291bnRlckNhbmRp ZGF0ZSA9IHByZXZDb3VudGVyQ2FuZGlkYXRlLT5wcmV2aW91c0luUHJlT3JkZXIoKSkpIHsKLSAg ICAgICAgQ291bnRlck5vZGUqIGMgPSBtYWtlQ291bnRlck5vZGUocHJldkNvdW50ZXJDYW5kaWRh dGUsIGNvdW50ZXJOYW1lLCBmYWxzZSk7Ci0gICAgICAgIGlmIChwcmV2Q291bnRlckNhbmRpZGF0 ZSA9PSByZXNldENhbmRpZGF0ZSkgewotICAgICAgICAgICAgaWYgKCFjYW5kaWRhdGVDb3VudGVy KSB7Ci0gICAgICAgICAgICAgICAgY2FuZGlkYXRlQ291bnRlciA9IGM7Ci0gICAgICAgICAgICAg ICAgY3JlYXRlQ2hpbGRGb3JSZXNldCA9IHRydWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAg ICBpZiAoY2FuZGlkYXRlQ291bnRlcikgewotICAgICAgICAgICAgICAgIGlmIChjcmVhdGVDaGls ZEZvclJlc2V0ICYmIGNhbmRpZGF0ZUNvdW50ZXItPmlzUmVzZXQoKSkgewotICAgICAgICAgICAg ICAgICAgICBwYXJlbnQgPSBjYW5kaWRhdGVDb3VudGVyOwotICAgICAgICAgICAgICAgICAgICBw cmV2aW91c1NpYmxpbmcgPSAwOwotICAgICAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAg ICAgICAgICAgIHBhcmVudCA9IGNhbmRpZGF0ZUNvdW50ZXItPnBhcmVudCgpOwotICAgICAgICAg ICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSBjYW5kaWRhdGVDb3VudGVyOwotICAgICAgICAg ICAgICAgIH0KLSAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICAgICAgICAgIH0KLSAg ICAgICAgICAgIHJlc2V0Q2FuZGlkYXRlID0gcHJldmlvdXNTaWJsaW5nT3JQYXJlbnQocmVzZXRD YW5kaWRhdGUpOwotICAgICAgICB9IGVsc2UgaWYgKGMpIHsKLSAgICAgICAgICAgIGlmIChjLT5p c1Jlc2V0KCkpIHsKLSAgICAgICAgICAgICAgICBpZiAoYy0+cGFyZW50KCkpIHsKLSAgICAgICAg ICAgICAgICAgICAgLy8gVGhlIG5ldyBub2RlIG1heSBiZSB0aGUgbmV4dCBzaWJsaW5nIG9mIHRo aXMgcmVzZXQgbm9kZS4KLSAgICAgICAgICAgICAgICAgICAgY3JlYXRlQ2hpbGRGb3JSZXNldCA9 IGZhbHNlOwotICAgICAgICAgICAgICAgICAgICBjYW5kaWRhdGVDb3VudGVyID0gYzsKLSAgICAg ICAgICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgICAgICAgICBjcmVhdGVDaGlsZEZvclJl c2V0ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICAgICAgY2FuZGlkYXRlQ291bnRlciA9IDA7Cisg ICAgd2hpbGUgKGN1cnJlbnRSZW5kZXJlcikgeworICAgICAgICBDb3VudGVyTm9kZSogY3VycmVu dENvdW50ZXIgPSBtYWtlQ291bnRlck5vZGUoY3VycmVudFJlbmRlcmVyLCBjb3VudGVyTmFtZSwg ZmFsc2UpOworICAgICAgICBpZiAoc2VhcmNoRW5kUmVuZGVyZXIgPT0gY3VycmVudFJlbmRlcmVy KSB7CisgICAgICAgICAgICAvLyBXZSBtYXkgYmUgYXQgdGhlIGVuZCBvZiBvdXIgc2VhcmNoCisg ICAgICAgICAgICBpZiAoY3VycmVudENvdW50ZXIpIHsKKyAgICAgICAgICAgICAgICAvLyBXZSBo YXZlIGEgc3VpdGFibGUgY291bnRlciBvbiB0aGUgRW5kU2VhcmNoUmVuZGVyZXIKKyAgICAgICAg ICAgICAgICBpZiAocHJldmlvdXNTaWJsaW5nKSB7IC8vQnV0IHdlIGFscmVhZHkgZm91bmQgYW5v dGhlciBjb3VudGVyIHRoYXQgd2UgY29tZSBhZnRlcgorICAgICAgICAgICAgICAgICAgICBpZiAo Y3VycmVudENvdW50ZXItPmlzUmVzZXQoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgLy8g V2UgZm91bmQgYSByZXNldCBjb3VudGVyIHRoYXQgaXMgb24gYSByZW5kZXJlciB0aGF0IGlzIGEg c2libGluZyBvZiBvdXJzIG9yIGEgcGFyZW50CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAo aXNSZXNldAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICYmIChjdXJyZW50UmVuZGVyZXIt PnBhcmVudCgpID09IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAgICAgICAg ICAgICAgICAvLyBXZSBhcmUgYWxzbyBhIHJlc2V0IGNvdW50ZXIgYW5kIHRoZSBwcmV2aW91cyBy ZXNldCB3YXMgb24gYSBzaWJsaW5nIHJlbmRlcmVyCisgICAgICAgICAgICAgICAgICAgICAgICAv LyBoZW5jZSB3ZSBhcmUgdGhlIG5leHQgc2libGluZyBvZiB0aGF0IGNvdW50ZXIgaWYgdGhhdCBy ZXNldCBpcyBub3QgYSByb290IG9yCisgICAgICAgICAgICAgICAgICAgICAgICAvLyB3ZSBhcmUg YSByb290IG5vZGUgaWYgdGhhdCByZXNldCBpcyBhIHJvb3QuCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcGFyZW50ID0gY3VycmVudENvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHByZXZpb3VzU2libGluZyA9IHBhcmVudCA/IGN1cnJlbnRDb3VudGVy IDogMDsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gcGFyZW50OworICAgICAg ICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgLy8gV2UgYXJlIG5v dCBhIHJlc2V0IG5vZGUgb3IgdGhlIHByZXZpb3VzIHJlc2V0IG11c3QgYmUgb24gYW4gYW5jZXN0 b3Igb2Ygb3VyIHJlbmRlcmVyCisgICAgICAgICAgICAgICAgICAgICAgICAvLyBoZW5jZSB3ZSBt dXN0IGJlIGEgY2hpbGQgb2YgdGhhdCByZXNldCBjb3VudGVyCisgICAgICAgICAgICAgICAgICAg ICAgICBwYXJlbnQgPSBjdXJyZW50Q291bnRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgIEFT U0VSVChwcmV2aW91c1NpYmxpbmctPnBhcmVudCgpID09IGN1cnJlbnRDb3VudGVyKTsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICAgICAgICAgICAgICB9IC8v IGN1cnJlbnRDb3VudGVyIGlzIG5vdCByZXNldAorICAgICAgICAgICAgICAgICAgICBpZiAoIWlz UmVzZXQKKyAgICAgICAgICAgICAgICAgICAgICAgIHx8IChjdXJyZW50UmVuZGVyZXItPnBhcmVu dCgpICE9IGNvdW50ZXJPd25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAgICAgICAgICAgIC8v IElmIHRoZSBub2RlIHdlIGFyZSBwbGFjaW5nIGlzIG5vdCByZXNldCBvciB3ZSBoYXZlIGZvdW5k IGEgY291bnRlciB0aGF0IGlzIGF0dGFjaGVkCisgICAgICAgICAgICAgICAgICAgIC8vIHRvIGFu IGFuY2VzdG9yIG9mIHRoZSBwbGFjZWQgY291bnRlcidzIHJlbmRlcmVyIHdlIGtub3cgd2UgYXJl IGEgc2libGluZyBvZiB0aGF0IG5vZGUKKyAgICAgICAgICAgICAgICAgICAgICAgIEFTU0VSVChj dXJyZW50Q291bnRlci0+cGFyZW50KCkgPT0gcHJldmlvdXNTaWJsaW5nLT5wYXJlbnQoKSk7Cisg ICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjdXJyZW50Q291bnRlci0+cGFyZW50KCk7 CisgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgICAgIH0gZWxzZSB7IC8vIFdlIGFyZSBhdCB0aGUgcG90ZW50aWFs IGVuZCBvZiB0aGUgc2VhcmNoLCBidXQgd2UgaGFkIG5vIHByZXZpb3VzIHNpYmxpbmcgY2FuZGlk YXRlCisgICAgICAgICAgICAgICAgICAgIC8vIEluIHRoaXMgY2FzZSB3ZSBmb2xsb3cgcHJldHR5 IG11Y2ggdGhlIHNhbWUgbG9naWMgYXMgYWJvdmUgYnV0IG5vIEFTU0VSVHMgYWJvdXQgCisgICAg ICAgICAgICAgICAgICAgIC8vIHByZXZpb3VzU2libGluZywgYW5kIHdoZW4gd2UgYXJlIGEgc2li bGluZyBvZiB0aGUgZW5kIGNvdW50ZXIgd2UgbXVzdCBzZXQgcHJldmlvdXNTaWJsaW5nCisgICAg ICAgICAgICAgICAgICAgIC8vIHRvIGN1cnJlbnRDb3VudGVyLgorICAgICAgICAgICAgICAgICAg ICBpZiAoY3VycmVudENvdW50ZXItPmlzUmVzZXQoKSkgeworICAgICAgICAgICAgICAgICAgICAg ICAgaWYgKGlzUmVzZXQKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAmJiAoY3VycmVudFJl bmRlcmVyLT5wYXJlbnQoKSA9PSBjb3VudGVyT3duZXItPnBhcmVudCgpKSkgeworICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHBhcmVudCA9IGN1cnJlbnRDb3VudGVyLT5wYXJlbnQoKTsKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSBjdXJyZW50Q291bnRl cjsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gcGFyZW50OworICAgICAgICAg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAgICAgcGFyZW50ID0gY3VycmVu dENvdW50ZXI7CisgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICBpZiAoIWlzUmVzZXQKKyAgICAgICAg ICAgICAgICAgICAgICAgIHx8IChjdXJyZW50UmVuZGVyZXItPnBhcmVudCgpICE9IGNvdW50ZXJP d25lci0+cGFyZW50KCkpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICBwYXJlbnQgPSBjdXJy ZW50Q291bnRlci0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1Np YmxpbmcgPSBjdXJyZW50Q291bnRlcjsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB0 cnVlOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIHByZXZpb3Vz U2libGluZyA9IGN1cnJlbnRDb3VudGVyOwogICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAg IH0gZWxzZSBpZiAoIWNhbmRpZGF0ZUNvdW50ZXIpIHsKLSAgICAgICAgICAgICAgICBjcmVhdGVD aGlsZEZvclJlc2V0ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICBjYW5kaWRhdGVDb3VudGVyID0g YzsKLSAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gLy8gV2UgY29tZSBoZXJlIGlmIHRoZSBw cmV2aW91cyBzaWJsaW5nIG9yIHBhcmVudCBvZiBvdXIgcmVuZGVyZXIgaGFkIG5vIAorICAgICAg ICAgICAgLy8gZ29vZCBjb3VudGVyLCBvciB3ZSBhcmUgYSByZXNldCBub2RlIGFuZCB0aGUgY291 bnRlciBvbiB0aGUgcHJldmlvdXMgc2libGluZworICAgICAgICAgICAgLy8gb2Ygb3VyIHJlbmRl cmVyIHdhcyBub3QgYSByZXNldCBjb3VudGVyLgorICAgICAgICAgICAgLy8gU2V0IGEgbmV3IGdv YWwgZm9yIHRoZSBlbmQgb2YgdGhlIHNlYXJjaC4KKyAgICAgICAgICAgIHNlYXJjaEVuZFJlbmRl cmVyID0gcHJldmlvdXNTaWJsaW5nT3JQYXJlbnQoY3VycmVudFJlbmRlcmVyKTsKKyAgICAgICAg fSBlbHNlIHsKKyAgICAgICAgICAgIC8vIFdlIGFyZSBzZWFyY2hpbmcgZGVzY2VuZGFudHMgb2Yg YSBwcmV2aW91cyBzaWJsaW5nIG9mIHRoZSByZW5kZXJlciB0aGF0IHRoZQorICAgICAgICAgICAg Ly8gY291bnRlciBiZWluZyBwbGFjZWQgaXMgYXR0YWNoZWQgdG8uCisgICAgICAgICAgICBpZiAo Y3VycmVudENvdW50ZXIpIHsKKyAgICAgICAgICAgICAgICAvLyBXZSBmb3VuZCBhIHN1aXRhYmxl IGNvdW50ZXIgLi4uCisgICAgICAgICAgICAgICAgaWYgKHByZXZpb3VzU2libGluZykgeworICAg ICAgICAgICAgICAgICAgICAvLyBidXQgd2UgaGFkIG9uZSBiZWZvcmUgLi4uCisgICAgICAgICAg ICAgICAgICAgIGlmICggY3VycmVudENvdW50ZXItPmlzUmVzZXQoKSkgeworICAgICAgICAgICAg ICAgICAgICAgICAgLy8gYnV0IHRoaXMgb25lIGlzIHJlc2V0LgorICAgICAgICAgICAgICAgICAg ICAgICAgcHJldmlvdXNTaWJsaW5nID0gY3VycmVudENvdW50ZXI7CisgICAgICAgICAgICAgICAg ICAgICAgICAvLyBXZSBhcmUgbm8gbG9uZ2VyIGludGVyZXN0ZWQgaW4gcHJldmlvdXMgc2libGlu Z3Mgb2YgdGhlIGN1cnJlbnRSZW5kZXJlciBvciB0aGVpciBjaGlsZHJlbgorICAgICAgICAgICAg ICAgICAgICAgICAgLy8gYXMgY291bnRlcnMgdGhleSBtYXkgaGF2ZSBhdHRhY2hlZCBjYW5ub3Qg YmUgdGhlIHByZXZpb3VzIHNpYmxpbmcgb2YgdGhlIGNvdW50ZXIgd2UgYXJlIHBsYWNpbmcKKyAg ICAgICAgICAgICAgICAgICAgICAgIGN1cnJlbnRSZW5kZXJlciA9IGN1cnJlbnRSZW5kZXJlci0+ cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAg ICAgICAgICAgfSAvLyBpZiB0aGUgZm91bmQgY291bnRlciB3YXMgbm90IHJlc2V0IHRoZSBjdXJy ZW50IHByZXZpb3VzU2libGluZyBpcyB0aGUgYmVzdCBjYW5kaWRhdGUgZm9yIHRoZSBwb3NpdGlv bgorICAgICAgICAgICAgICAgIH0gZWxzZSAvLyBUaGlzIGlzIHRoZSBiZXN0IGNhbmRpZGF0ZSB3 ZSBoYXZlIHNvIGZhcgorICAgICAgICAgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcgPSBjdXJy ZW50Q291bnRlcjsKKyAgICAgICAgICAgICAgICBjdXJyZW50UmVuZGVyZXIgPSBwcmV2aW91c1Np YmxpbmdPclBhcmVudChjdXJyZW50UmVuZGVyZXIpOworICAgICAgICAgICAgICAgIGNvbnRpbnVl OworICAgICAgICAgICAgfSAgLy9ObyBzdWl0YWJsZSBjb3VudGVyIGZvdW5kIG9uIHRoZSBjdXJy ZW50UmVuZGVyZXIKICAgICAgICAgfQorICAgICAgICAvLyBUaGlzIGZ1bmN0aW9uIGlzIGRlc2ln bmVkIHNvIHRoYXQgdGhlIHNhbWUgdGVzdCBpcyBub3QgZG9uZSB0d2ljZSBpbiBhbiBpdGVyYXRp b24sIGV4Y2VwdCBmb3IgdGhpcyBvbmUKKyAgICAgICAgLy8gd2hpY2ggbWF5IGJlIGRvbmUgdHdp Y2UgaW4gc29tZSBjYXNlcy4gUmVhcnJhbmdpbmcgdGhlIGRlY2lzaW9uIHBvaW50cyB0aG91Z2gs IHRvIGFjY29tbW9kYXRlIHRoaXMgCisgICAgICAgIC8vIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50 IHdvdWxkIGNyZWF0ZSBtb3JlIGNvZGUgZHVwbGljYXRpb24gdGhhbiBpcyB3b3J0aHdoaWxlIGlu IG15IG9wcGluaW9uIGFuZCBtYXkgZnVydGhlcgorICAgICAgICAvLyBpbXBlZGUgdGhlIHJlYWRh YmlsaXR5IG9mIHRoaXMgYWxyZWFkeSBjb21wbGV4IGFsZ29yaXRobS4KKyAgICAgICAgaWYgKHBy ZXZpb3VzU2libGluZykKKyAgICAgICAgICAgIGN1cnJlbnRSZW5kZXJlciA9IHByZXZpb3VzU2li bGluZ09yUGFyZW50KGN1cnJlbnRSZW5kZXJlcik7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAg IGN1cnJlbnRSZW5kZXJlciA9IGN1cnJlbnRSZW5kZXJlci0+cHJldmlvdXNJblByZU9yZGVyKCk7 CiAgICAgfQotCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCkBAIC0xNzcsMTUgKzI0Niw5IEBAIHN0 YXRpYyBDb3VudGVyTm9kZSogbWFrZUNvdW50ZXJOb2RlKFJlbmQKIAogICAgIENvdW50ZXJOb2Rl KiBuZXdQYXJlbnQgPSAwOwogICAgIENvdW50ZXJOb2RlKiBuZXdQcmV2aW91c1NpYmxpbmcgPSAw OwotICAgIENvdW50ZXJOb2RlKiBuZXdOb2RlOwotICAgIGlmIChmaW5kUGxhY2VGb3JDb3VudGVy KG9iamVjdCwgY291bnRlck5hbWUsIGlzUmVzZXQsIG5ld1BhcmVudCwgbmV3UHJldmlvdXNTaWJs aW5nKSkgewotICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKG9iamVjdCwgaXNSZXNl dCwgdmFsdWUpOworICAgIENvdW50ZXJOb2RlKiBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKG9i amVjdCwgaXNSZXNldCwgdmFsdWUpOworICAgIGlmIChmaW5kUGxhY2VGb3JDb3VudGVyKG9iamVj dCwgY291bnRlck5hbWUsIGlzUmVzZXQsIG5ld1BhcmVudCwgbmV3UHJldmlvdXNTaWJsaW5nKSkK ICAgICAgICAgbmV3UGFyZW50LT5pbnNlcnRBZnRlcihuZXdOb2RlLCBuZXdQcmV2aW91c1NpYmxp bmcsIGNvdW50ZXJOYW1lKTsKLSAgICB9IGVsc2UgewotICAgICAgICAvLyBNYWtlIGEgcmVzZXQg bm9kZSBmb3IgY291bnRlcnMgdGhhdCBhcmVuJ3QgaW5zaWRlIGFuIGV4aXN0aW5nIHJlc2V0IG5v ZGUuCi0gICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUob2JqZWN0LCB0cnVlLCB2YWx1 ZSk7Ci0gICAgfQotCiAgICAgQ291bnRlck1hcCogbm9kZU1hcDsKICAgICBpZiAob2JqZWN0LT5t X2hhc0NvdW50ZXJOb2RlTWFwKQogICAgICAgICBub2RlTWFwID0gY291bnRlck1hcHMoKS5nZXQo b2JqZWN0KTsKQEAgLTE5NSw3ICsyNTgsMjcgQEAgc3RhdGljIENvdW50ZXJOb2RlKiBtYWtlQ291 bnRlck5vZGUoUmVuZAogICAgICAgICBvYmplY3QtPm1faGFzQ291bnRlck5vZGVNYXAgPSB0cnVl OwogICAgIH0KICAgICBub2RlTWFwLT5zZXQoY291bnRlck5hbWUuaW1wbCgpLCBuZXdOb2RlKTsK LQorICAgIGlmIChuZXdOb2RlLT5wYXJlbnQoKSB8fCAhb2JqZWN0LT5uZXh0SW5QcmVPcmRlcihv YmplY3QtPnBhcmVudCgpKSkKKyAgICAgICAgcmV0dXJuIG5ld05vZGU7CisgICAgLy8gU2VlIGlm IHNvbWUgbm9kZXMgdGhhdCB3ZXJlIHByZXZpb3VzbHkgY291bnRlciB0cmVlIHJvb3Qgbm9kZXMK KyAgICAvLyBzaG91bGQgYmVjb21lIGNoaWxkcmVuIG9mIHRoaXMgbm9kZSBub3cuCisgICAgQ291 bnRlck1hcHM6Oml0ZXJhdG9yIGVuZCA9IGNvdW50ZXJNYXBzKCkuZW5kKCk7CisgICAgZm9yIChD b3VudGVyTWFwczo6aXRlcmF0b3IgaXQgPSBjb3VudGVyTWFwcygpLmJlZ2luKCk7aXQgIT0gZW5k OworICAgICAgICArK2l0KQorICAgICAgICBpZiAoaXQtPmZpcnN0ICE9IG9iamVjdCkgeworICAg ICAgICAgICAgbm9kZU1hcCA9IGl0LT5zZWNvbmQ7CisgICAgICAgICAgICBpZiAoQ291bnRlck5v ZGUqIG5vZGUgPSBub2RlTWFwLT5nZXQoY291bnRlck5hbWUuaW1wbCgpKSkgeworICAgICAgICAg ICAgICAgIGlmICghbm9kZS0+cGFyZW50KCkKKyAgICAgICAgICAgICAgICAgICAgJiYgZmluZFBs YWNlRm9yQ291bnRlcigKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0X2Nhc3Q8UmVuZGVy T2JqZWN0Kj4oaXQtPmZpcnN0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvdW50ZXJOYW1l LCB0cnVlLCBuZXdQYXJlbnQsCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdQcmV2aW91c1Np YmxpbmcpKSB7CisgICAgICAgICAgICAgICAgICAgIEFTU0VSVChuZXdQYXJlbnQgPT0gbmV3Tm9k ZSk7CisgICAgICAgICAgICAgICAgICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0ZXIobm9kZSwKKyAg ICAgICAgICAgICAgICAgICAgICAgIG5ld1ByZXZpb3VzU2libGluZywgY291bnRlck5hbWUuaW1w bCgpKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KICAgICBy ZXR1cm4gbmV3Tm9kZTsKIH0KIApAQCAtMjU2LDcgKzMzOSw3IEBAIHZvaWQgUmVuZGVyQ291bnRl cjo6aW52YWxpZGF0ZShjb25zdCBBdG8KICAgICBzZXROZWVkc0xheW91dEFuZFByZWZXaWR0aHNS ZWNhbGMoKTsKIH0KIAotc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJOb2RlQ2hpbGRyZW4oY29u c3QgQXRvbWljU3RyaW5nJiBpZGVudGlmaWVyLCBDb3VudGVyTm9kZSogbm9kZSkKK3N0YXRpYyB2 b2lkIGRlc3Ryb3lDb3VudGVyTm9kZVdpdGhvdXRNYXBSZW1vdmFsKGNvbnN0IEF0b21pY1N0cmlu ZyYgaWRlbnRpZmllciwgQ291bnRlck5vZGUqIG5vZGUpCiB7CiAgICAgQ291bnRlck5vZGUqIHBy ZXZpb3VzOwogICAgIGZvciAoQ291bnRlck5vZGUqIGNoaWxkID0gbm9kZS0+bGFzdERlc2NlbmRh bnQoKTsgY2hpbGQgJiYgY2hpbGQgIT0gbm9kZTsgY2hpbGQgPSBwcmV2aW91cykgewpAQCAtMjcx LDI3ICszNTQsODkgQEAgc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJOb2RlQ2hpbGRyZW4oYwog ICAgICAgICB9CiAgICAgICAgIGRlbGV0ZSBjaGlsZDsKICAgICB9CisgICAgUmVuZGVyT2JqZWN0 KiByZW5kZXJlciA9IG5vZGUtPnJlbmRlcmVyKCk7CisgICAgaWYgKCFyZW5kZXJlci0+ZG9jdW1l bnRCZWluZ0Rlc3Ryb3llZCgpKSB7CisgICAgICAgIGlmIChSZW5kZXJPYmplY3RDaGlsZExpc3Qq IGNoaWxkcmVuID0gcmVuZGVyZXItPnZpcnR1YWxDaGlsZHJlbigpKQorICAgICAgICAgICAgY2hp bGRyZW4tPmludmFsaWRhdGVDb3VudGVycyhyZW5kZXJlciwgaWRlbnRpZmllcik7CisgICAgfQor ICAgIGlmIChDb3VudGVyTm9kZSogcGFyZW50ID0gbm9kZS0+cGFyZW50KCkpCisgICAgICAgIHBh cmVudC0+cmVtb3ZlQ2hpbGQobm9kZSwgaWRlbnRpZmllcik7CisgICAgZGVsZXRlIG5vZGU7CiB9 CiAKLXZvaWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3Qq IG9iamVjdCkKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJP YmplY3QqIHJlbmRlcmVyKQogewogICAgIENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1hcHMo KTsKLSAgICBDb3VudGVyTWFwKiBtYXAgPSBtYXBzLmdldChvYmplY3QpOworICAgIENvdW50ZXJN YXAqIG1hcCA9IG1hcHMuZ2V0KHJlbmRlcmVyKTsKICAgICBpZiAoIW1hcCkKICAgICAgICAgcmV0 dXJuOwotICAgIG1hcHMucmVtb3ZlKG9iamVjdCk7Ci0KICAgICBDb3VudGVyTWFwOjpjb25zdF9p dGVyYXRvciBlbmQgPSBtYXAtPmVuZCgpOwogICAgIGZvciAoQ291bnRlck1hcDo6Y29uc3RfaXRl cmF0b3IgaXQgPSBtYXAtPmJlZ2luKCk7IGl0ICE9IGVuZDsgKytpdCkgewotICAgICAgICBDb3Vu dGVyTm9kZSogbm9kZSA9IGl0LT5zZWNvbmQ7CiAgICAgICAgIEF0b21pY1N0cmluZyBpZGVudGlm aWVyKGl0LT5maXJzdC5nZXQoKSk7Ci0gICAgICAgIGRlc3Ryb3lDb3VudGVyTm9kZUNoaWxkcmVu KGlkZW50aWZpZXIsIG5vZGUpOwotICAgICAgICBpZiAoQ291bnRlck5vZGUqIHBhcmVudCA9IG5v ZGUtPnBhcmVudCgpKQotICAgICAgICAgICAgcGFyZW50LT5yZW1vdmVDaGlsZChub2RlLCBpZGVu dGlmaWVyKTsKLSAgICAgICAgZGVsZXRlIG5vZGU7CisgICAgICAgIGRlc3Ryb3lDb3VudGVyTm9k ZVdpdGhvdXRNYXBSZW1vdmFsKGlkZW50aWZpZXIsIGl0LT5zZWNvbmQpOwogICAgIH0KLQorICAg IG1hcHMucmVtb3ZlKHJlbmRlcmVyKTsKICAgICBkZWxldGUgbWFwOworICAgIHJlbmRlcmVyLT5t X2hhc0NvdW50ZXJOb2RlTWFwID0gZmFsc2U7Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6ZGVz dHJveUNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCogcmVuZGVyZXIsCisgICAgY29uc3QgQXRvbWlj U3RyaW5nJiBpZGVudGlmaWVyKQoreworICAgIENvdW50ZXJNYXBzJiBtYXBzID0gY291bnRlck1h cHMoKTsKKyAgICBDb3VudGVyTWFwKiBtYXAgPSBtYXBzLmdldChyZW5kZXJlcik7CisgICAgaWYg KCFtYXApCisgICAgICAgIHJldHVybjsKKyAgICBDb3VudGVyTm9kZSogbm9kZSA9IG1hcC0+Z2V0 KGlkZW50aWZpZXIuaW1wbCgpKTsKKyAgICBpZiAobm9kZSkgeworICAgICAgICBkZXN0cm95Q291 bnRlck5vZGVXaXRob3V0TWFwUmVtb3ZhbChpZGVudGlmaWVyLCBub2RlKTsKKyAgICAgICAgbWFw LT5yZW1vdmUoUmVmUHRyPEF0b21pY1N0cmluZ0ltcGw+KGlkZW50aWZpZXIuaW1wbCgpKSk7Cisv LyBEbyBub3QgZGVsZXRlIG1hcCBldmVuIGlmIGVtcHR5IGFzIHRoZSBleHBlY3RhdGlvbiBpcyB0 aGF0IHNvb24gbm9kZXMgd2lsbCBiZSBhZGRlZAorLy8gdG8gdGhlIG1hcCwgb3Igb3RoZXJ3aXNl IGRlc3Ryb3lDb3VudGVyTm9kZXMgd291bGQgaGF2ZSBiZWVuIGNhbGxlZCBpbnN0ZWFkLgorICAg IH0KIH0KIAordm9pZCBSZW5kZXJDb3VudGVyOjpjcmVhdGVDb3VudGVySWZOZWVkZWQoUmVuZGVy T2JqZWN0KiByZW5kZXJlciwKKyAgICAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBpZGVudGlmaWVy KQoreworICAgIG1ha2VDb3VudGVyTm9kZShyZW5kZXJlciwgaWRlbnRpZmllciwgZmFsc2UpOwor fQorCit2b2lkIFJlbmRlckNvdW50ZXI6OnVwZGF0ZUNvdW50ZXJzKFJlbmRlck9iamVjdCogcmVu ZGVyZXIpCit7CisgICAgdXBkYXRlQ291bnRlcihyZW5kZXJlcik7CisgICAgZm9yIChSZW5kZXJP YmplY3QqIGNoaWxkID0gcmVuZGVyZXItPm5leHRJblByZU9yZGVyKHJlbmRlcmVyKTsgY2hpbGQ7 IGNoaWxkID0gY2hpbGQtPm5leHRJblByZU9yZGVyKHJlbmRlcmVyKSkKKyAgICAgICAgdXBkYXRl Q291bnRlcihjaGlsZCk7Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcihS ZW5kZXJPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQob2JqZWN0LT5zdHlsZSgpKTsKKyAg ICBpZiAoIW9iamVjdC0+cGFyZW50KCkgJiYgIW9iamVjdC0+bmV4dEluUHJlT3JkZXIoKSkKKyAg ICAgICAgcmV0dXJuOworICAgIGNvbnN0IENvdW50ZXJEaXJlY3RpdmVNYXAqIHBDb3VudGVyRGly ZWN0aXZlTWFwID0gb2JqZWN0LT5zdHlsZSgpLT5jb3VudGVyRGlyZWN0aXZlcygpOworICAgIGlm ICghcENvdW50ZXJEaXJlY3RpdmVNYXApCisgICAgICAgIHJldHVybjsKKyAgICBDb3VudGVyRGly ZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQgPSBwQ291bnRlckRpcmVjdGl2ZU1hcC0+ZW5k KCk7CisgICAgQ291bnRlck1hcCogY291bnRlck1hcCA9IGNvdW50ZXJNYXBzKCkuZ2V0KG9iamVj dCk7CisgICAgZm9yIChDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IHBD b3VudGVyRGlyZWN0aXZlTWFwLT5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAg aWYgKCFjb3VudGVyTWFwKSB7CisgICAgICAgICAgICBtYWtlQ291bnRlck5vZGUob2JqZWN0LCBB dG9taWNTdHJpbmcoaXQtPmZpcnN0LmdldCgpKSwgZmFsc2UpOworICAgICAgICAgICAgY29udGlu dWU7CisgICAgICAgIH0KKyAgICAgICAgQ291bnRlck5vZGUgKm5vZGUgPSBjb3VudGVyTWFwLT5n ZXQoaXQtPmZpcnN0LmdldCgpKTsKKyAgICAgICAgaWYgKCFub2RlKSB7CisgICAgICAgICAgICBt YWtlQ291bnRlck5vZGUob2JqZWN0LCBBdG9taWNTdHJpbmcoaXQtPmZpcnN0LmdldCgpKSwgZmFs c2UpOworICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIH0KKyAgICAgICAgQ291bnRlck5v ZGUqIG5ld1BhcmVudCA9IDA7CisgICAgICAgIENvdW50ZXJOb2RlKiBuZXdQcmV2aW91c1NpYmxp bmc7CisgICAgICAgIGZpbmRQbGFjZUZvckNvdW50ZXIob2JqZWN0LCBBdG9taWNTdHJpbmcoaXQt PmZpcnN0LmdldCgpKSwgbm9kZS0+aXNUeXBlUmVzZXQoKSwgbmV3UGFyZW50LCBuZXdQcmV2aW91 c1NpYmxpbmcpOworICAgICAgICBpZiAoKG5ld1BhcmVudCA9PSBub2RlLT5wYXJlbnQoKSkgJiYg KG5ld1ByZXZpb3VzU2libGluZyA9PSBub2RlLT5wcmV2aW91c1NpYmxpbmcoKSkpCisgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgaWYgKG5vZGUtPnBhcmVudCgpKQorICAgICAgICAgICAg bm9kZS0+cGFyZW50KCktPnJlbW92ZUNoaWxkKG5vZGUsIGl0LT5maXJzdC5nZXQoKSk7CisgICAg ICAgIG5ld1BhcmVudC0+aW5zZXJ0QWZ0ZXIobm9kZSwgbmV3UHJldmlvdXNTaWJsaW5nLCBpdC0+ Zmlyc3QuZ2V0KCkpOworICAgIH0KK30KIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDUxMDQwKQorKysgV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0zOSw3ICszOSwxMSBAQCBw dWJsaWM6CiAgICAgLy8gdHJlZSBmb3IgaWRlbnRpZmllciBjaGFuZ2VzLgogICAgIHZvaWQgaW52 YWxpZGF0ZShjb25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpOwogCi0gICAgc3RhdGljIHZv aWQgZGVzdHJveUNvdW50ZXJOb2RlcyhSZW5kZXJPYmplY3QqKTsKKyAgICBzdGF0aWMgdm9pZCBk ZXN0cm95Q291bnRlck5vZGVzKFJlbmRlck9iamVjdCogcmVuZGVyZXIpOworICAgIHN0YXRpYyB2 b2lkIGRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBjb25zdCBBdG9t aWNTdHJpbmcmIGlkZW50aWZpZXIpOworICAgIHN0YXRpYyB2b2lkIHVwZGF0ZUNvdW50ZXJzKFJl bmRlck9iamVjdCogcmVuZGVyZXIpOworICAgIHN0YXRpYyB2b2lkIHVwZGF0ZUNvdW50ZXIoUmVu ZGVyT2JqZWN0KiByZW5kZXJlcik7CisgICAgc3RhdGljIHZvaWQgY3JlYXRlQ291bnRlcklmTmVl ZGVkKFJlbmRlck9iamVjdCogcmVuZGVyZXIsIGNvbnN0IEF0b21pY1N0cmluZyYgaWRlbnRpZmll cik7CiAKIHByaXZhdGU6CiAgICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29u c3Q7CkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDUxMDQwKQor KysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5KQpAQCAt MzA0LDcgKzMwNCw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjphZGRDaGlsZChSZW5kZXJPYmplY3QK ICAgICAgICAgLy8gSnVzdCBhZGQgaXQuLi4KICAgICAgICAgY2hpbGRyZW4tPmluc2VydENoaWxk Tm9kZSh0aGlzLCBuZXdDaGlsZCwgYmVmb3JlQ2hpbGQpOwogICAgIH0KLSAgICAKKyAgICBSZW5k ZXJDb3VudGVyOjp1cGRhdGVDb3VudGVycyhuZXdDaGlsZCk7CiAgICAgaWYgKG5ld0NoaWxkLT5p c1RleHQoKSAmJiBuZXdDaGlsZC0+c3R5bGUoKS0+dGV4dFRyYW5zZm9ybSgpID09IENBUElUQUxJ WkUpIHsKICAgICAgICAgUmVmUHRyPFN0cmluZ0ltcGw+IHRleHRUb1RyYW5zZm9ybSA9IHRvUmVu ZGVyVGV4dChuZXdDaGlsZCktPm9yaWdpbmFsVGV4dCgpOwogICAgICAgICBpZiAodGV4dFRvVHJh bnNmb3JtKQpAQCAtMTQ4NiwyMCArMTQ4Niw3MiBAQCB2b2lkIFJlbmRlck9iamVjdDo6c2V0U3R5 bGUoUGFzc1JlZlB0cjxSCiAgICAgZGlmZiA9IGFkanVzdFN0eWxlRGlmZmVyZW5jZShkaWZmLCBj b250ZXh0U2Vuc2l0aXZlUHJvcGVydGllcyk7CiAKICAgICBzdHlsZVdpbGxDaGFuZ2UoZGlmZiwg c3R5bGUuZ2V0KCkpOwotICAgIAorCiAgICAgUmVmUHRyPFJlbmRlclN0eWxlPiBvbGRTdHlsZSA9 IG1fc3R5bGUucmVsZWFzZSgpOwogICAgIG1fc3R5bGUgPSBzdHlsZTsKIAotICAgIHVwZGF0ZUZp bGxJbWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+YmFja2dyb3VuZExheWVycygpIDogMCwgbV9z dHlsZSA/IG1fc3R5bGUtPmJhY2tncm91bmRMYXllcnMoKSA6IDApOwotICAgIHVwZGF0ZUZpbGxJ bWFnZXMob2xkU3R5bGUgPyBvbGRTdHlsZS0+bWFza0xheWVycygpIDogMCwgbV9zdHlsZSA/IG1f c3R5bGUtPm1hc2tMYXllcnMoKSA6IDApOwotCi0gICAgdXBkYXRlSW1hZ2Uob2xkU3R5bGUgPyBv bGRTdHlsZS0+Ym9yZGVySW1hZ2UoKS5pbWFnZSgpIDogMCwgbV9zdHlsZSA/IG1fc3R5bGUtPmJv cmRlckltYWdlKCkuaW1hZ2UoKSA6IDApOwotICAgIHVwZGF0ZUltYWdlKG9sZFN0eWxlID8gb2xk U3R5bGUtPm1hc2tCb3hJbWFnZSgpLmltYWdlKCkgOiAwLCBtX3N0eWxlID8gbV9zdHlsZS0+bWFz a0JveEltYWdlKCkuaW1hZ2UoKSA6IDApOworICAgIGlmIChvbGRTdHlsZSkgeworICAgICAgICBp ZiAobV9zdHlsZSkgeworICAgICAgICAgICAgaWYgKGNvbnN0IENvdW50ZXJEaXJlY3RpdmVNYXAq IHBDb3VudGVyRGlyZWN0aXZlTWFwID0gbV9zdHlsZS0+Y291bnRlckRpcmVjdGl2ZXMoKSkgewor ICAgICAgICAgICAgICAgIGlmIChjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBwT2xkQ291bnRl ckRpcmVjdGl2ZU1hcCA9IG9sZFN0eWxlLT5jb3VudGVyRGlyZWN0aXZlcygpKSB7CisgICAgICAg ICAgICAgICAgICAgIENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IHBD b3VudGVyRGlyZWN0aXZlTWFwLT5lbmQoKTsKKyAgICAgICAgICAgICAgICAgICAgZm9yIChDb3Vu dGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IHBDb3VudGVyRGlyZWN0aXZlTWFw LT5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGlm IChwT2xkQ291bnRlckRpcmVjdGl2ZU1hcC0+Y29udGFpbnMoaXQtPmZpcnN0KSkgeworICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGlmIChwT2xkQ291bnRlckRpcmVjdGl2ZU1hcC0+Z2V0KGl0 LT5maXJzdCkgIT0gaXQtPnNlY29uZCkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKHRoaXMsIEF0b21pY1N0cmluZyhpdC0+ Zmlyc3QuZ2V0KCkpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKHRo aXMsIEF0b21pY1N0cmluZyhpdC0+Zmlyc3QuZ2V0KCkpKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICBSZW5kZXJDb3VudGVyOjpjcmVhdGVDb3VudGVySWZOZWVkZWQodGhpcywgQXRvbWlj U3RyaW5nKGl0LT5maXJzdC5nZXQoKSkpOworICAgICAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIGVuZCA9IHBPbGRDb3VudGVy RGlyZWN0aXZlTWFwLT5lbmQoKTsKKyAgICAgICAgICAgICAgICAgICAgZm9yIChDb3VudGVyRGly ZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBpdCA9IHBPbGRDb3VudGVyRGlyZWN0aXZlTWFwLT5i ZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIXBD b3VudGVyRGlyZWN0aXZlTWFwLT5jb250YWlucyhpdC0+Zmlyc3QpKQorICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZSh0aGlzLCBBdG9t aWNTdHJpbmcoaXQtPmZpcnN0LmdldCgpKSk7CisgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAg ICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2Rlcyh0aGlz KTsKKyAgICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcnModGhp cyk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIGlmIChtX2hhc0NvdW50 ZXJOb2RlTWFwKQorICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVy Tm9kZXModGhpcyk7CiAKLSAgICAvLyBXZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHZpZXctPm1heGlt YWxPdXRsaW5lU2l6ZSgpIGlzIHZhbGlkIGZvciBhbnkgcmVwYWludHMgdGhhdCBoYXBwZW4KLSAg ICAvLyBkdXJpbmcgc3R5bGVEaWRDaGFuZ2UgKGl0J3MgdXNlZCBieSBjbGlwcGVkT3ZlcmZsb3dS ZWN0Rm9yUmVwYWludCgpKS4KLSAgICBpZiAobV9zdHlsZS0+b3V0bGluZVdpZHRoKCkgPiAwICYm IG1fc3R5bGUtPm91dGxpbmVTaXplKCkgPiBtYXhpbWFsT3V0bGluZVNpemUoUGFpbnRQaGFzZU91 dGxpbmUpKQotICAgICAgICB0b1JlbmRlclZpZXcoZG9jdW1lbnQoKS0+cmVuZGVyZXIoKSktPnNl dE1heGltYWxPdXRsaW5lU2l6ZShtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpKTsKKyAgICAgICAgICAg IHVwZGF0ZUZpbGxJbWFnZXMob2xkU3R5bGUtPmJhY2tncm91bmRMYXllcnMoKSwKKyAgICAgICAg ICAgICAgICBtX3N0eWxlLT5iYWNrZ3JvdW5kTGF5ZXJzKCkpOworICAgICAgICAgICAgdXBkYXRl RmlsbEltYWdlcyhvbGRTdHlsZS0+bWFza0xheWVycygpLCBtX3N0eWxlLT5tYXNrTGF5ZXJzKCkp OworCisgICAgICAgICAgICB1cGRhdGVJbWFnZShvbGRTdHlsZS0+Ym9yZGVySW1hZ2UoKS5pbWFn ZSgpLAorICAgICAgICAgICAgICAgIG1fc3R5bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSk7Cisg ICAgICAgICAgICB1cGRhdGVJbWFnZShvbGRTdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSwK KyAgICAgICAgICAgICAgICBtX3N0eWxlLT5tYXNrQm94SW1hZ2UoKS5pbWFnZSgpKTsKKyAgICAg ICAgICAgIC8vIFdlIG5lZWQgdG8gZW5zdXJlIHRoYXQgdmlldy0+bWF4aW1hbE91dGxpbmVTaXpl KCkgaXMgdmFsaWQgZm9yIAorICAgICAgICAgICAgLy8gYW55IHJlcGFpbnRzIHRoYXQgaGFwcGVu IGR1cmluZyBzdHlsZURpZENoYW5nZSAoaXQncyB1c2VkIGJ5CisgICAgICAgICAgICAvLyBjbGlw cGVkT3ZlcmZsb3dSZWN0Rm9yUmVwYWludCgpKS4KKyAgICAgICAgICAgIGlmIChtX3N0eWxlLT5v dXRsaW5lV2lkdGgoKSA+IDAgJiYgbV9zdHlsZS0+b3V0bGluZVNpemUoKSA+CisgICAgICAgICAg ICAgICAgbWF4aW1hbE91dGxpbmVTaXplKFBhaW50UGhhc2VPdXRsaW5lKSkgeworICAgICAgICAg ICAgICAgIHRvUmVuZGVyVmlldyhkb2N1bWVudCgpLT5yZW5kZXJlcigpKS0+c2V0TWF4aW1hbE91 dGxpbmVTaXplKAorICAgICAgICAgICAgICAgICAgICBtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGlmIChtX2hhc0Nv dW50ZXJOb2RlTWFwKQorICAgICAgICAgICAgICAgIFJlbmRlckNvdW50ZXI6OmRlc3Ryb3lDb3Vu dGVyTm9kZXModGhpcyk7CisgICAgICAgICAgICB1cGRhdGVGaWxsSW1hZ2VzKG9sZFN0eWxlLT5i YWNrZ3JvdW5kTGF5ZXJzKCksIDApOworICAgICAgICAgICAgdXBkYXRlRmlsbEltYWdlcyhvbGRT dHlsZS0+bWFza0xheWVycygpLCAwKTsKKworICAgICAgICAgICAgdXBkYXRlSW1hZ2Uob2xkU3R5 bGUtPmJvcmRlckltYWdlKCkuaW1hZ2UoKSwgMCk7CisgICAgICAgICAgICB1cGRhdGVJbWFnZShv bGRTdHlsZS0+bWFza0JveEltYWdlKCkuaW1hZ2UoKSwgMCk7CisgICAgICAgIH0KKyAgICB9IGVs c2UgaWYgKG1fc3R5bGUpIHsKKyAgICAgICAgUmVuZGVyQ291bnRlcjo6dXBkYXRlQ291bnRlcih0 aGlzKTsKKyAgICAgICAgdXBkYXRlRmlsbEltYWdlcygwLCBtX3N0eWxlLT5iYWNrZ3JvdW5kTGF5 ZXJzKCkpOworICAgICAgICB1cGRhdGVGaWxsSW1hZ2VzKDAsIG1fc3R5bGUtPm1hc2tMYXllcnMo KSk7CisKKyAgICAgICAgdXBkYXRlSW1hZ2UoMCwgbV9zdHlsZS0+Ym9yZGVySW1hZ2UoKS5pbWFn ZSgpKTsKKyAgICAgICAgdXBkYXRlSW1hZ2UoMCwgbV9zdHlsZS0+bWFza0JveEltYWdlKCkuaW1h Z2UoKSk7CisgICAgICAgIC8vIFdlIG5lZWQgdG8gZW5zdXJlIHRoYXQgdmlldy0+bWF4aW1hbE91 dGxpbmVTaXplKCkgaXMgdmFsaWQgZm9yIGFueSByZXBhaW50cyB0aGF0IGhhcHBlbgorICAgICAg ICAvLyBkdXJpbmcgc3R5bGVEaWRDaGFuZ2UgKGl0J3MgdXNlZCBieSBjbGlwcGVkT3ZlcmZsb3dS ZWN0Rm9yUmVwYWludCgpKS4KKyAgICAgICAgaWYgKG1fc3R5bGUtPm91dGxpbmVXaWR0aCgpID4g MCAmJiBtX3N0eWxlLT5vdXRsaW5lU2l6ZSgpID4gbWF4aW1hbE91dGxpbmVTaXplKFBhaW50UGhh c2VPdXRsaW5lKSkKKyAgICAgICAgICAgIHRvUmVuZGVyVmlldyhkb2N1bWVudCgpLT5yZW5kZXJl cigpKS0+c2V0TWF4aW1hbE91dGxpbmVTaXplKG1fc3R5bGUtPm91dGxpbmVTaXplKCkpOworICAg IH0KIAogICAgIHN0eWxlRGlkQ2hhbmdlKGRpZmYsIG9sZFN0eWxlLmdldCgpKTsKIApAQCAtMTYw OCw3ICsxNjYwLDcgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxlRAog CiAgICAgaWYgKCFtX3BhcmVudCkKICAgICAgICAgcmV0dXJuOwotICAgIAorCiAgICAgaWYgKGRp ZmYgPT0gU3R5bGVEaWZmZXJlbmNlTGF5b3V0KQogICAgICAgICBzZXROZWVkc0xheW91dEFuZFBy ZWZXaWR0aHNSZWNhbGMoKTsKICAgICBlbHNlIGlmIChkaWZmID09IFN0eWxlRGlmZmVyZW5jZUxh eW91dFBvc2l0aW9uZWRNb3ZlbWVudE9ubHkpCkluZGV4OiBXZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3Qu aAkocmV2aXNpb24gNTEwNDApCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAko d29ya2luZyBjb3B5KQpAQCAtMTg3LDcgKzE4Nyw3IEBAIHB1YmxpYzoKICAgICAvLyBDb252ZW5p ZW5jZSBmdW5jdGlvbiBmb3IgZ2V0dGluZyB0byB0aGUgbmVhcmVzdCBlbmNsb3NpbmcgYm94IG9m IGEgUmVuZGVyT2JqZWN0LgogICAgIFJlbmRlckJveCogZW5jbG9zaW5nQm94KCkgY29uc3Q7CiAg ICAgCi0gICAgdmlydHVhbCBib29sIGlzRW1wdHkoKSBjb25zdCB7IHJldHVybiBmaXJzdENoaWxk KCkgPT0gMDsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0VtcHR5KCkgY29uc3QgeyByZXR1cm4gIWZp cnN0Q2hpbGQoKTsgfQogCiAjaWZuZGVmIE5ERUJVRwogICAgIHZvaWQgc2V0SGFzQVhPYmplY3Qo Ym9vbCBmbGFnKSB7IG1faGFzQVhPYmplY3QgPSBmbGFnOyB9CkBAIC02NDgsNyArNjQ4LDcgQEAg cHVibGljOgogCiAgICAgLy8gVGhlIGN1cnJlbnQgc2VsZWN0aW9uIHN0YXRlIGZvciBhbiBvYmpl Y3QuICBGb3IgYmxvY2tzLCB0aGUgc3RhdGUgcmVmZXJzIHRvIHRoZSBzdGF0ZSBvZiB0aGUgbGVh ZgogICAgIC8vIGRlc2NlbmRhbnRzIChhcyBkZXNjcmliZWQgYWJvdmUgaW4gdGhlIFNlbGVjdGlv blN0YXRlIGVudW0gZGVjbGFyYXRpb24pLgotICAgIFNlbGVjdGlvblN0YXRlIHNlbGVjdGlvblN0 YXRlKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8U2VsZWN0aW9uU3RhdGU+KG1fc2VsZWN0 aW9uU3RhdGUpOzsgfQorICAgIFNlbGVjdGlvblN0YXRlIHNlbGVjdGlvblN0YXRlKCkgY29uc3Qg eyByZXR1cm4gc3RhdGljX2Nhc3Q8U2VsZWN0aW9uU3RhdGU+KG1fc2VsZWN0aW9uU3RhdGUpOyB9 CiAKICAgICAvLyBTZXRzIHRoZSBzZWxlY3Rpb24gc3RhdGUgZm9yIGFuIG9iamVjdC4KICAgICB2 aXJ0dWFsIHZvaWQgc2V0U2VsZWN0aW9uU3RhdGUoU2VsZWN0aW9uU3RhdGUgc3RhdGUpIHsgbV9z ZWxlY3Rpb25TdGF0ZSA9IHN0YXRlOyB9CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1MTA0MCkKKysrIExh eW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDA5 LTExLTA1ICBDYXJvbCBTemFibyAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbm90aGVyIGNyYXp5IGNvdW50 ZXJzIGJ1ZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTEwMzEKKyAgICAgICAgQWRkZWQgdGVzdHMgZm9yIGR5bmFtaWMgRE9NIGNoYW5nZXMgYWZmZWN0 aW5nIGNvdW50ZXJzLgorCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNy ZW1lbnQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50 ZXItcmVzZXQtMDAwLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2Nv dW50ZXItcmVzZXQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJz L2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZh c3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKwogMjAwOS0xMS0xNCAgQW50b25pbyBHb21lcyAgPHRvbmlraXRvb0B3ZWJraXQu b3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFudHRpIEtvaXZpc3RvLgpJbmRleDogTGF5b3V0 VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4 dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWlu Y3JlbWVudC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw0IEBACitUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgaGF2 ZSB0aGUgc2FtZSBjb250ZW50OgorCiswLjEtMC4yLTEtMi0KKzAuMS0wLjItMS0yLQpJbmRleDog TGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNy ZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3Vu dGVycy9jb3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1 MCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEvL0VOIj4K KzxodG1sPjxoZWFkPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVu dD0idGV4dC9odG1sOyBjaGFyc2V0PVVURi04Ij4KKyAgICA8dGl0bGU+Q1NTIFRlc3Q6IGR5bmFt aWMgY2hhbmdlcyB0byAnY291bnRlci1pbmNyZW1lbnQnPC90aXRsZT4KKyAgICA8bGluayByZWw9 ImF1dGhvciIgaHJlZj0iaHR0cDovL2RiYXJvbi5vcmcvIiB0aXRsZT0iTC4gRGF2aWQgQmFyb24i PgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEv Z2VuZXJhdGUuaHRtbCNjb3VudGVycyI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRw Oi8vd3d3LnczLm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI3Byb3BkZWYtY29udGVudCI+Cisg ICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1MyMS9zeW5k YXRhLmh0bWwjY291bnRlciI+CisgICAgPG1ldGEgY29udGVudD0iZG9tIiBuYW1lPSJmbGFncyI+ CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0 L2NzcyI+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVu dD0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICA8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICAgICAg ICBib2R5IHsgd2hpdGUtc3BhY2U6IG5vd3JhcDsgfQorICAgICAgICAjdGVzdCwgLnJlc2V0IHsg Y291bnRlci1yZXNldDogYzsgfQorICAgICAgICAuaW5jcmVtZW50OmJlZm9yZSwgLnVzZTpiZWZv cmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50 IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlw ZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwor ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAg ICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoIm9uZSIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAgICAgICAgICAg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgImlu Y3JlbWVudCIpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRocmVlIiku c2V0QXR0cmlidXRlKCJzdHlsZSIsICJjb3VudGVyLWluY3JlbWVudDogYyIpOworICAgICAgICAg ICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgIHRl c3RFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAgICAg ICAgICBjb25zb2xlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKTsKKyAgICAg ICAgICAgICAgICBzcGFuTGlzdCA9IHRlc3RFbGVtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJz cGFuIikKKyAgICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc3Bhbkxpc3QubGVuZ3RoOyAr K2kgKSB7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50ID0gZG9jdW1lbnQuY3Jl YXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5p bm5lclRleHQgPQorICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5jb3Vu dGVyVmFsdWVGb3JFbGVtZW50QnlJZChzcGFuTGlzdC5pdGVtKGkpLmdldEF0dHJpYnV0ZSgiaWQi KSk7CisgICAgICAgICAgICAgICAgICAgIGlmIChuZXdTcGFuRWxlbWVudC5pbm5lclRleHQubGVu Z3RoKQorICAgICAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ID0g bmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ICsgIi0iOworICAgICAgICAgICAgICAgICAgICBjb25z b2xlLmFwcGVuZENoaWxkKG5ld1NwYW5FbGVtZW50KTsKKyAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAg ICAgfQorICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRU aW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91 bGQgaGF2ZSB0aGUgc2FtZSBjb250ZW50OjwvcD4KKyAgICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBp ZD0ib25lIj48L3NwYW4+PHNwYW4gaWQ9InBhcmVudCI+PHNwYW4gaWQ9InJlc2V0IiBjbGFzcz0i cmVzZXQiPjxzcGFuIGlkPSJyZXNldGNoaWxkIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNw YW4gY2xhc3M9ImluY3JlbWVudCIgaWQ9InR3byI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4g c3R5bGU9ImNvdW50ZXItaW5jcmVtZW50OiBjOyIgY2xhc3M9InVzZSIgaWQ9InRocmVlIj48L3Nw YW4+PHNwYW4gaWQ9InVwcGVyaW5jcmVtZW50IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9k aXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4wLjEtMC4yLTEtMi08L2Rpdj4KKyAgICA8aHI+ CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8L2JvZHk+PC9odG1sPgpJbmRleDogTGF5 b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0 Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVz ZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw0IEBACitUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6 CisKKzEtMS4xLTEuMi0KKzEtMS4xLTEuMi0KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2Nv dW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv ZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDAuaHRtbAkocmV2aXNpb24gMCkKKysr IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsNTEgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzND Ly9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2 PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAg PHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50Jzwv dGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIg dGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6 Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5r IHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRt bCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3 dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRl bnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2Ny aXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRl eHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAg I3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpi ZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVt ZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQg dHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29u dHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OyAgIAorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOwor ICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgdmFyIHQg PSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgdmFyIHMgPSBk b2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICBzLnNldEF0dHJpYnV0 ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAgICAgICAgIHMuc2V0QXR0cmlidXRlKCJpZCIsICJu ZXdTcGFuIik7CisgICAgICAgICAgICB0Lmluc2VydEJlZm9yZShzLCB0LmNoaWxkTm9kZXMuaXRl bSgxKSk7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICAgICAgdGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVz dCIpOworICAgICAgICAgICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi Y29uc29sZSIpOworICAgICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxl bWVudHNCeVRhZ05hbWUoInNwYW4iKQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBz cGFuTGlzdC5sZW5ndGg7ICsraSApIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1l bnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAg IG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSku Z2V0QXR0cmlidXRlKCJpZCIpKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVt ZW50LmlubmVyVGV4dC5sZW5ndGgpCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxl bWVudC5pbm5lclRleHQgPSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSIKKyAgICAgICAg ICAgICAgICAgICAgY29uc29sZS5hcHBlbmRDaGlsZChuZXdTcGFuRWxlbWVudCk7CisgICAgICAg ICAgICAgICAgfQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+ PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93 aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3Qi PjxzcGFuIGlkPSJzcGFuMSIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGlkPSJzcGFu MiIgY2xhc3M9InJlc2V0Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4zIiBjbGFzcz0iaW5jcmVtZW50 Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW40IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+ CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4xLTEuMS0xLjItPC9kaXY+CisgICAgPGhyPgorICAg IDxkaXYgaWQ9ImNvbnNvbGUiLz4KKzwvYm9keT48L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9m YXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMv Y291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQg QEAKK1RoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZToKKworMS0xLjEt Mi0zLTQtCisxLTEuMS0yLTMtNC0KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJz L2NvdW50ZXItcmVzZXQtMDAyLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9j c3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDIuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsNDcgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQg SFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250 ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxl PkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+ CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9 IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cu dzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0i aGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9w ZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5v cmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRv bSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5 cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3Nz Ij4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3Qs IC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUg eyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsg Y291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0i dGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyAgIAor ICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAg ICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoIm9uZSIpLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAg ICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5yZW1vdmVBdHRyaWJ1dGUoImNs YXNzIik7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7Cisg ICAgICAgICAgICAgICAgdGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVz dCIpOworICAgICAgICAgICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi Y29uc29sZSIpOworICAgICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxl bWVudHNCeVRhZ05hbWUoInNwYW4iKQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBz cGFuTGlzdC5sZW5ndGg7ICsraSApIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1l bnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAg IG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRl c3RDb250cm9sbGVyLmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSku Z2V0QXR0cmlidXRlKCJpZCIpKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVt ZW50LmlubmVyVGV4dC5sZW5ndGgpCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxl bWVudC5pbm5lclRleHQgPSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSI7CisgICAgICAg ICAgICAgICAgICAgIGNvbnNvbGUuYXBwZW5kQ2hpbGQobmV3U3BhbkVsZW1lbnQpOworICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlE b25lKCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD48 Ym9keSBvbmxvYWQ9InNldFRpbWVvdXQoJ3J1bigpJywgMCkiPgorICAgIDxwPlRoZSBmb2xsb3dp bmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZTo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+ PHNwYW4gaWQ9InNwYW4xIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4y Ij48c3BhbiBjbGFzcz0icmVzZXQiIGlkPSJvbmUiPjxzcGFuIGlkPSJzcGFuNCIgY2xhc3M9Imlu Y3JlbWVudCI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4gaWQ9InNwYW41IiBjbGFzcz0iaW5j cmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW42Ij48c3BhbiBpZD0idHdvIj48c3BhbiBpZD0i c3BhbjciICBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3BhbiBpZD0i c3BhbjgiIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZl cmVuY2UiPjEtMS4xLTItMy00LTwvZGl2PgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiIC8+Cis8L2Jv ZHk+PC9odG1sPgo= 46841 2010-01-18 13:34:00 -0800 2010-01-18 16:45:03 -0800 Proposed Patch patchFor11031-8.patch text/plain 16412 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzQxNSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDEtMTggIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorCisgICAgICAgIFRoaXMgcGF0Y2ggYWN0dWFsbHkg cHJvdmlkZXMgZm9yIGNvdW50ZXIgdXBkYXRpbmcgd2hlbiB0aGUgc3R5bGUKKyAgICAgICAgb2Yg YSByZW5kZXJlciBjaGFuZ2VzLgorCisgICAgICAgIFRlc3RzOiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDAuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHls ZUNoYW5nZWQpOgorICAgICAgICBUaGlzIGZ1bmN0aW9uIGlzIGFkZGVkIHRvIHVwZGF0ZSB0aGUg Y291bnRlciBoaWVyYXJjaHkgaW4gCisgICAgICAgIHJlc3BvbnNlIHRvIGNoYW5nZXMgdG8gdGhl IHN0eWxlIG9mIGEgcmVuZGVyZXIuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlck9iamVjdDo6c3R5bGVEaWRDaGFuZ2UpOgorICAgICAgICBGb3IgY2hhbmdlcyB0 aGF0IG1heSBpbmNsdWRlIHRoZSBjb3VudGVyIGRpcmVjdGl2ZXMgYWRkZWQgYQorICAgICAgICBj YWxsIHRvIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2VkLgorCiAyMDEwLTAxLTE4 ICBDaHJpcyBNYXJyaW4gIDxjbWFycmluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBi eSBEYXJpbiBBZGxlci4KSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCShyZXZp c2lvbiA1MzQxMSkKKysrIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC00NDAsNCArNDQwLDM0IEBAIHZvaWQgUmVuZGVyQ291bnRlcjo6cmVuZGVy ZXJTdWJ0cmVlQXR0YWMKICAgICAgICAgdXBkYXRlQ291bnRlcnMoZGVzY2VuZGFudCk7CiB9CiAK K3ZvaWQgUmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHlsZUNoYW5nZWQoUmVuZGVyT2JqZWN0KiBy ZW5kZXJlciwgY29uc3QgUmVuZGVyU3R5bGUqIG9sZFN0eWxlLCBjb25zdCBSZW5kZXJTdHlsZSog bmV3U3R5bGUpCit7CisgICAgY29uc3QgQ291bnRlckRpcmVjdGl2ZU1hcCogbmV3Q291bnRlckRp cmVjdGl2ZXM7CisgICAgY29uc3QgQ291bnRlckRpcmVjdGl2ZU1hcCogb2xkQ291bnRlckRpcmVj dGl2ZXM7CisgICAgaWYgKG9sZFN0eWxlICYmIChvbGRDb3VudGVyRGlyZWN0aXZlcyA9IG9sZFN0 eWxlLT5jb3VudGVyRGlyZWN0aXZlcygpKSkgeworICAgICAgICBpZiAobmV3U3R5bGUgJiYgKG5l d0NvdW50ZXJEaXJlY3RpdmVzID0gbmV3U3R5bGUtPmNvdW50ZXJEaXJlY3RpdmVzKCkpKSB7Cisg ICAgICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRvciBuZXdNYXBFbmQg PSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+ZW5kKCk7CisgICAgICAgICAgICBDb3VudGVyRGlyZWN0 aXZlTWFwOjpjb25zdF9pdGVyYXRvciBvbGRNYXBFbmQgPSBvbGRDb3VudGVyRGlyZWN0aXZlcy0+ ZW5kKCk7CisgICAgICAgICAgICBmb3IgKENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJh dG9yIGl0ID0gbmV3Q291bnRlckRpcmVjdGl2ZXMtPmJlZ2luKCk7IGl0ICE9IG5ld01hcEVuZDsg KytpdCkgeworICAgICAgICAgICAgICAgIENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJh dG9yIG9sZE1hcEl0ID0gb2xkQ291bnRlckRpcmVjdGl2ZXMtPmZpbmQoaXQtPmZpcnN0KTsKKyAg ICAgICAgICAgICAgICBpZiAob2xkTWFwSXQgPT0gb2xkTWFwRW5kIHx8IG9sZE1hcEl0LT5zZWNv bmQgIT0gaXQtPnNlY29uZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBEZXN0cm95aW5nIG9s ZCBjb3VudGVyLiBMZWF2aW5nIHRoZSBjcmVhdGlvbiBvZiB0aGUKKyAgICAgICAgICAgICAgICAg ICAgLy8gbmV3IG9uZSB0byB0aGUgbmV4dCBsYXlvdXQuCisgICAgICAgICAgICAgICAgICAgIFJl bmRlckNvdW50ZXI6OmRlc3Ryb3lDb3VudGVyTm9kZShyZW5kZXJlciwgQXRvbWljU3RyaW5nKGl0 LT5maXJzdC5nZXQoKSkpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIC8vIERlc3Ryb3lpbmcgb2xkIGNvdW50ZXJzIHRoYXQgZG8gbm90IGV4aXN0IGluIHRo ZSBuZXcgY291bnRlckRpcmVjdGl2ZSBtYXAuCisgICAgICAgICAgICBmb3IgKENvdW50ZXJEaXJl Y3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ID0gb2xkQ291bnRlckRpcmVjdGl2ZXMtPmJlZ2lu KCk7IGl0ICE9b2xkTWFwRW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgaWYgKCFuZXdDb3Vu dGVyRGlyZWN0aXZlcy0+Y29udGFpbnMoaXQtPmZpcnN0KSkKKyAgICAgICAgICAgICAgICAgICAg UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlKHJlbmRlcmVyLCBBdG9taWNTdHJpbmco aXQtPmZpcnN0LmdldCgpKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAg ICAgICAgICBpZiAocmVuZGVyZXItPm1faGFzQ291bnRlck5vZGVNYXApCisgICAgICAgICAgICAg ICAgUmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhyZW5kZXJlcik7CisgICAgICAg IH0KKyAgICB9CisgICAgLy8gSWYgdGhlIG9sZFN0eWxlIGhhZCBubyBjb3VudGVycyB0aGUgbmV3 IG9uZXMgd2lsbCBiZSBjcmVhdGVkIG9uIHRoZSBuZXh0CisgICAgLy8gbGF5b3V0IGlmIG5lZWRl ZC4KK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuaAkocmV2aXNpb24gNTM0MTEpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJDb3Vu dGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYgKzQyLDcgQEAgcHVibGljOgogICAgIHN0YXRp YyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZXMoUmVuZGVyT2JqZWN0Kik7CiAgICAgc3RhdGljIHZv aWQgZGVzdHJveUNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCosIGNvbnN0IEF0b21pY1N0cmluZyYg aWRlbnRpZmllcik7CiAgICAgc3RhdGljIHZvaWQgcmVuZGVyZXJTdWJ0cmVlQXR0YWNoZWQoUmVu ZGVyT2JqZWN0Kik7CisgICAgc3RhdGljIHZvaWQgcmVuZGVyZXJTdHlsZUNoYW5nZWQoUmVuZGVy T2JqZWN0KiwgY29uc3QgUmVuZGVyU3R5bGUqIG9sZFN0eWxlLCBjb25zdCBSZW5kZXJTdHlsZSog bmV3U3R5bGUpOwogCiBwcml2YXRlOgogICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFt ZSgpIGNvbnN0OwpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiA1 MzQxMSkKKysrIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTE2NjEsNyArMTY2MSw3IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZVdpbGxDaGFu Z2UoU3R5bGUKICAgICB9CiB9CiAKLXZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShT dHlsZURpZmZlcmVuY2UgZGlmZiwgY29uc3QgUmVuZGVyU3R5bGUqKQordm9pZCBSZW5kZXJPYmpl Y3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxlRGlmZmVyZW5jZSBkaWZmLCBjb25zdCBSZW5kZXJTdHls ZSpvbGRTdHlsZSkKIHsKICAgICBpZiAoc19hZmZlY3RzUGFyZW50QmxvY2spCiAgICAgICAgIGhh bmRsZUR5bmFtaWNGbG9hdFBvc2l0aW9uQ2hhbmdlKCk7CkBAIC0xNjY5LDggKzE2NjksMTAgQEAg dm9pZCBSZW5kZXJPYmplY3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxlRAogICAgIGlmICghbV9wYXJl bnQpCiAgICAgICAgIHJldHVybjsKICAgICAKLSAgICBpZiAoZGlmZiA9PSBTdHlsZURpZmZlcmVu Y2VMYXlvdXQpCisgICAgaWYgKGRpZmYgPT0gU3R5bGVEaWZmZXJlbmNlTGF5b3V0KSB7CisgICAg ICAgIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2VkKHRoaXMsIG9sZFN0eWxlLCBt X3N0eWxlLmdldCgpKTsKICAgICAgICAgc2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVjYWxj KCk7CisgICAgfQogICAgIGVsc2UgaWYgKGRpZmYgPT0gU3R5bGVEaWZmZXJlbmNlTGF5b3V0UG9z aXRpb25lZE1vdmVtZW50T25seSkKICAgICAgICAgc2V0TmVlZHNQb3NpdGlvbmVkTW92ZW1lbnRM YXlvdXQoKTsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNTM0MTUpCisrKyBMYXlvdXRUZXN0cy9DaGFu Z2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMiBAQAorMjAxMC0wMS0xOCAgQ2Fyb2wg U3phYm8gIDxjYXJvbC5zemFib0Bub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgQW5vdGhlciBjcmF6eSBjb3VudGVycyBidWcKKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExMDMxCisKKyAgICAg ICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0w MDIuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNl dC0wMDAtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLXJlc2V0LTAwMC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVy cy9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv Y3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWw6IEFkZGVkLgorCisyMDEwLTAxLTE4 ICBDYXJvbCBTemFibyAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbm90aGVyIGNyYXp5IGNvdW50ZXJzIGJ1 ZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEwMzEK KyAgICAgICAgQWRkZWQgdGVzdHMgZm9yIGR5bmFtaWMgRE9NIGNoYW5nZXMgYWZmZWN0aW5nIGNv dW50ZXJzLgorCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQt MDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVz ZXQtMDAwLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXIt cmVzZXQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50 ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0OiBBZGRl ZC4KKwogMjAxMC0wMS0xOCAgRGFuaWVsIENoZW5nICA8ZGNoZW5nQGdvb2dsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBSb2JlbgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3Mv Y291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0wMDItZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMv Y291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSw0IEBACitUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgaGF2ZSB0aGUgc2FtZSBjb250 ZW50OgorCiswLjEtMC4yLTEtMi0KKzAuMS0wLjItMS0yLQpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJ KHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWlu Y3JlbWVudC0wMDIuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1MCBAQAorPCFET0NUWVBF IEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEvL0VOIj4KKzxodG1sPjxoZWFkPgor ICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBj aGFyc2V0PVVURi04Ij4KKyAgICA8dGl0bGU+Q1NTIFRlc3Q6IGR5bmFtaWMgY2hhbmdlcyB0byAn Y291bnRlci1pbmNyZW1lbnQnPC90aXRsZT4KKyAgICA8bGluayByZWw9ImF1dGhvciIgaHJlZj0i aHR0cDovL2RiYXJvbi5vcmcvIiB0aXRsZT0iTC4gRGF2aWQgQmFyb24iPgorICAgIDxsaW5rIHJl bD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNj b3VudGVycyI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9U Ui9DU1MyMS9nZW5lcmF0ZS5odG1sI3Byb3BkZWYtY29udGVudCI+CisgICAgPGxpbmsgcmVsPSJo ZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1MyMS9zeW5kYXRhLmh0bWwjY291bnRl ciI+CisgICAgPG1ldGEgY29udGVudD0iZG9tIiBuYW1lPSJmbGFncyI+CisgICAgPG1ldGEgaHR0 cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyI+CisgICAgPG1l dGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2Ny aXB0Ij4KKyAgICA8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICAgICAgICBib2R5IHsgd2hpdGUt c3BhY2U6IG5vd3JhcDsgfQorICAgICAgICAjdGVzdCwgLnJlc2V0IHsgY291bnRlci1yZXNldDog YzsgfQorICAgICAgICAuaW5jcmVtZW50OmJlZm9yZSwgLnVzZTpiZWZvcmUgeyBjb250ZW50OiBj b3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNy ZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2Ny aXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAg ICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAg ZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9u ZSIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJ0d28iKS5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgImluY3JlbWVudCIpOworICAg ICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRocmVlIikuc2V0QXR0cmlidXRlKCJz dHlsZSIsICJjb3VudGVyLWluY3JlbWVudDogYyIpOworICAgICAgICAgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgIHRlc3RFbGVtZW50ID0gZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAgICAgICAgICBjb25zb2xlID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKTsKKyAgICAgICAgICAgICAgICBzcGFu TGlzdCA9IHRlc3RFbGVtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJzcGFuIikKKyAgICAgICAg ICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc3Bhbkxpc3QubGVuZ3RoOyArK2kgKSB7CisgICAgICAg ICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3Bh biIpOworICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPQorICAg ICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5jb3VudGVyVmFsdWVGb3JFbGVt ZW50QnlJZChzcGFuTGlzdC5pdGVtKGkpLmdldEF0dHJpYnV0ZSgiaWQiKSk7CisgICAgICAgICAg ICAgICAgICAgIGlmIChuZXdTcGFuRWxlbWVudC5pbm5lclRleHQubGVuZ3RoKQorICAgICAgICAg ICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ID0gbmV3U3BhbkVsZW1lbnQu aW5uZXJUZXh0ICsgIi0iOworICAgICAgICAgICAgICAgICAgICBjb25zb2xlLmFwcGVuZENoaWxk KG5ld1NwYW5FbGVtZW50KTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgfQorICAgICAgICB9 CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScs IDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgaGF2ZSB0aGUgc2Ft ZSBjb250ZW50OjwvcD4KKyAgICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBpZD0ib25lIj48L3NwYW4+ PHNwYW4gaWQ9InBhcmVudCI+PHNwYW4gaWQ9InJlc2V0IiBjbGFzcz0icmVzZXQiPjxzcGFuIGlk PSJyZXNldGNoaWxkIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gY2xhc3M9ImluY3Jl bWVudCIgaWQ9InR3byI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4gc3R5bGU9ImNvdW50ZXIt aW5jcmVtZW50OiBjOyIgY2xhc3M9InVzZSIgaWQ9InRocmVlIj48L3NwYW4+PHNwYW4gaWQ9InVw cGVyaW5jcmVtZW50IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBp ZD0icmVmZXJlbmNlIj4wLjEtMC4yLTEtMi08L2Rpdj4KKyAgICA8aHI+CisgICAgPGRpdiBpZD0i Y29uc29sZSI+PC9kaXY+Cis8L2JvZHk+PC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9j c3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVk LnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50 ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBACitU aGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6CisKKzEtMS4xLTEuMi0K KzEtMS4xLTEuMi0KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXIt cmVzZXQtMDAwLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDAuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zh c3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsNTEgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAx Ly9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUi IGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0 OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxp bmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlk IEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RS L0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJl Zj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRl bnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NT MjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0i ZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRl bnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAg ICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7 IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50 OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1p bmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZh c2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAg ICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyAgIAorICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAg ICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgdmFyIHQgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgdmFyIHMgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICBzLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVz ZXQiKTsKKyAgICAgICAgICAgIHMuc2V0QXR0cmlidXRlKCJpZCIsICJuZXdTcGFuIik7CisgICAg ICAgICAgICB0Lmluc2VydEJlZm9yZShzLCB0LmNoaWxkTm9kZXMuaXRlbSgxKSk7CisgICAgICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAg dGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAg ICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAg ICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUo InNwYW4iKQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7 ICsraSApIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50 LmlubmVyVGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNv dW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJp ZCIpKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5s ZW5ndGgpCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQg PSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSIKKyAgICAgICAgICAgICAgICAgICAgY29u c29sZS5hcHBlbmRDaGlsZChuZXdTcGFuRWxlbWVudCk7CisgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJz ZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBz aG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3QiPjxzcGFuIGlkPSJzcGFu MSIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGlkPSJzcGFuMiIgY2xhc3M9InJlc2V0 Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4zIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4g aWQ9InNwYW40IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0i cmVmZXJlbmNlIj4xLTEuMS0xLjItPC9kaXY+CisgICAgPGhyPgorICAgIDxkaXYgaWQ9ImNvbnNv bGUiLz4KKzwvYm9keT48L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVy cy9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZp c2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0w MDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQgQEAKK1RoZSBmb2xsb3dp bmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZToKKworMS0xLjEtMi0zLTQtCisxLTEuMS0y LTMtNC0KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQt MDAyLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291 bnRlci1yZXNldC0wMDIuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs NDcgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+ Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRl bnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5h bWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVs PSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9u Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIx L2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0 cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgor ICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3lu ZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3Mi PgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRl eHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9k eSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50 ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3Vu dGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1l bnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0 Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyAgIAorICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAg ZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9u ZSIpLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAgICAgICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5yZW1vdmVBdHRyaWJ1dGUoImNsYXNzIik7CisgICAgICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAg dGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAg ICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAg ICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUo InNwYW4iKQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7 ICsraSApIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50 LmlubmVyVGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNv dW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJp ZCIpKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5s ZW5ndGgpCisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQg PSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSI7CisgICAgICAgICAgICAgICAgICAgIGNv bnNvbGUuYXBwZW5kQ2hpbGQobmV3U3BhbkVsZW1lbnQpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAg ICAgICB9CisgICAgICAgIH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD48Ym9keSBvbmxvYWQ9InNl dFRpbWVvdXQoJ3J1bigpJywgMCkiPgorICAgIDxwPlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNo b3VsZCBiZSB0aGUgc2FtZTo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+PHNwYW4gaWQ9InNwYW4x IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4yIj48c3BhbiBjbGFzcz0i cmVzZXQiIGlkPSJvbmUiPjxzcGFuIGlkPSJzcGFuNCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFu Pjwvc3Bhbj48L3NwYW4+PHNwYW4gaWQ9InNwYW41IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+ PHNwYW4gaWQ9InNwYW42Ij48c3BhbiBpZD0idHdvIj48c3BhbiBpZD0ic3BhbjciICBjbGFzcz0i aW5jcmVtZW50Ij48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3BhbiBpZD0ic3BhbjgiIGNsYXNzPSJp bmNyZW1lbnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZlcmVuY2UiPjEtMS4xLTIt My00LTwvZGl2PgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiIC8+Cis8L2JvZHk+PC9odG1sPgo= 46863 2010-01-18 16:45:03 -0800 2010-01-18 17:07:17 -0800 Proposed patch; patchFor11031-9.patch text/plain 17297 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzM5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDEtMTggIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorCisgICAgICAgIFRoaXMgcGF0Y2ggYWN0dWFsbHkg cHJvdmlkZXMgZm9yIGNvdW50ZXIgdXBkYXRpbmcgd2hlbiB0aGUgc3R5bGUKKyAgICAgICAgb2Yg YSByZW5kZXJlciBjaGFuZ2VzLgorCisgICAgICAgIFRlc3RzOiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDAuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHls ZUNoYW5nZWQpOgorICAgICAgICBUaGlzIGZ1bmN0aW9uIGlzIGFkZGVkIHRvIHVwZGF0ZSB0aGUg Y291bnRlciBoaWVyYXJjaHkgaW4gCisgICAgICAgIHJlc3BvbnNlIHRvIGNoYW5nZXMgdG8gdGhl IHN0eWxlIG9mIGEgcmVuZGVyZXIuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlck9iamVjdDo6c3R5bGVEaWRDaGFuZ2UpOgorICAgICAgICBGb3IgY2hhbmdlcyB0 aGF0IG1heSBpbmNsdWRlIHRoZSBjb3VudGVyIGRpcmVjdGl2ZXMgYWRkZWQgYQorICAgICAgICBj YWxsIHRvIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2VkLgorCiAyMDEwLTAxLTE4 ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5uQG5va2lhLmNvbT4KIAogICAgICAgICBV bnJldmlld2VkIFN5bWJpYW4gYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQ291bnRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHJldmlzaW9uIDUzMzk5KQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0MCw0ICs0NDAsNDQgQEAgdm9pZCBSZW5kZXJD b3VudGVyOjpyZW5kZXJlclN1YnRyZWVBdHRhYwogICAgICAgICB1cGRhdGVDb3VudGVycyhkZXNj ZW5kYW50KTsKIH0KIAordm9pZCBSZW5kZXJDb3VudGVyOjpyZW5kZXJlclN0eWxlQ2hhbmdlZChS ZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBjb25zdCBSZW5kZXJTdHlsZSogb2xkU3R5bGUsIGNvbnN0 IFJlbmRlclN0eWxlKiBuZXdTdHlsZSkKK3sKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFw KiBuZXdDb3VudGVyRGlyZWN0aXZlczsKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBv bGRDb3VudGVyRGlyZWN0aXZlczsKKyAgICBpZiAob2xkU3R5bGUgJiYgKG9sZENvdW50ZXJEaXJl Y3RpdmVzID0gb2xkU3R5bGUtPmNvdW50ZXJEaXJlY3RpdmVzKCkpKSB7CisgICAgICAgIGlmIChu ZXdTdHlsZSAmJiAobmV3Q291bnRlckRpcmVjdGl2ZXMgPSBuZXdTdHlsZS0+Y291bnRlckRpcmVj dGl2ZXMoKSkpIHsKKyAgICAgICAgICAgIENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJh dG9yIG5ld01hcEVuZCA9IG5ld0NvdW50ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAg IENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIG9sZE1hcEVuZCA9IG9sZENvdW50 ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+YmVnaW4oKTsgaXQg IT0gbmV3TWFwRW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3Igb2xkTWFwSXQgPSBvbGRDb3VudGVyRGlyZWN0aXZlcy0+ZmluZChp dC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIGlmIChvbGRNYXBJdCAhPSBvbGRNYXBFbmQpIHsK KyAgICAgICAgICAgICAgICAgICAgaWYgKG9sZE1hcEl0LT5zZWNvbmQgPT0gaXQtPnNlY29uZCkK KyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBS ZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUocmVuZGVyZXIsIEF0b21pY1N0cmluZyhp dC0+Zmlyc3QuZ2V0KCkpKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgLy8g V2UgbXVzdCBjcmVhdGUgdGhpcyBub2RlIGhlcmUsIGJlY2F1c2UgdGhlIGNoYW5nZWQgbm9kZSBt YXkgYmUgYSBub2RlIHdpdGggbm8gZGlzcGxheSBzdWNoIGFzCisgICAgICAgICAgICAgICAgLy8g YXMgdGhvc2UgY3JlYXRlZCBieSB0aGUgaW5jcmVtZW50IG9yIHJlc2V0IGRpcmVjdGl2ZXMgYW5k IHRoZSByZS1sYXlvdXQgdGhhdCB3aWxsIGhhcHBlbiB3aWxsCisgICAgICAgICAgICAgICAgLy8g bm90IGNhdGNoIHRoZSBjaGFuZ2UgaWYgdGhlIG5vZGUgaGFkIG5vIGNoaWxkcmVuLgorICAgICAg ICAgICAgICAgIG1ha2VDb3VudGVyTm9kZShyZW5kZXJlciwgQXRvbWljU3RyaW5nKGl0LT5maXJz dC5nZXQoKSksIGZhbHNlKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIC8vIERlc3Ryb3lp bmcgb2xkIGNvdW50ZXJzIHRoYXQgZG8gbm90IGV4aXN0IGluIHRoZSBuZXcgY291bnRlckRpcmVj dGl2ZSBtYXAuCisgICAgICAgICAgICBmb3IgKENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0 ZXJhdG9yIGl0ID0gb2xkQ291bnRlckRpcmVjdGl2ZXMtPmJlZ2luKCk7IGl0ICE9b2xkTWFwRW5k OyArK2l0KSB7CisgICAgICAgICAgICAgICAgaWYgKCFuZXdDb3VudGVyRGlyZWN0aXZlcy0+Y29u dGFpbnMoaXQtPmZpcnN0KSkKKyAgICAgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6ZGVz dHJveUNvdW50ZXJOb2RlKHJlbmRlcmVyLCBBdG9taWNTdHJpbmcoaXQtPmZpcnN0LmdldCgpKSk7 CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBpZiAocmVuZGVy ZXItPm1faGFzQ291bnRlck5vZGVNYXApCisgICAgICAgICAgICAgICAgUmVuZGVyQ291bnRlcjo6 ZGVzdHJveUNvdW50ZXJOb2RlcyhyZW5kZXJlcik7CisgICAgICAgIH0KKyAgICB9IGVsc2UgaWYg KG5ld1N0eWxlICYmIChuZXdDb3VudGVyRGlyZWN0aXZlcyA9IG5ld1N0eWxlLT5jb3VudGVyRGly ZWN0aXZlcygpKSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFwOjpjb25zdF9pdGVyYXRv ciBuZXdNYXBFbmQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+ZW5kKCk7CisgICAgICAgIGZvciAo Q291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBuZXdDb3VudGVyRGlyZWN0 aXZlcy0+YmVnaW4oKTsgaXQgIT0gbmV3TWFwRW5kOyArK2l0KSB7CisgICAgICAgICAgICAvLyBX ZSBtdXN0IGNyZWF0ZSB0aGlzIG5vZGUgaGVyZSwgYmVjYXVzZSB0aGUgYWRkZWQgbm9kZSBtYXkg YmUgYSBub2RlIHdpdGggbm8gZGlzcGxheSBzdWNoIGFzCisgICAgICAgICAgICAvLyBhcyB0aG9z ZSBjcmVhdGVkIGJ5IHRoZSBpbmNyZW1lbnQgb3IgcmVzZXQgZGlyZWN0aXZlcyBhbmQgdGhlIHJl LWxheW91dCB0aGF0IHdpbGwgaGFwcGVuIHdpbGwKKyAgICAgICAgICAgIC8vIG5vdCBjYXRjaCB0 aGUgY2hhbmdlIGlmIHRoZSBub2RlIGhhZCBubyBjaGlsZHJlbi4KKyAgICAgICAgICAgIG1ha2VD b3VudGVyTm9kZShyZW5kZXJlciwgQXRvbWljU3RyaW5nKGl0LT5maXJzdC5nZXQoKSksIGZhbHNl KTsKKyAgICAgICAgfQorICAgIH0KK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDog V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gNTMzOTkpCisrKyBXZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQyLDYgKzQyLDcgQEAg cHVibGljOgogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZXMoUmVuZGVyT2JqZWN0 Kik7CiAgICAgc3RhdGljIHZvaWQgZGVzdHJveUNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCosIGNv bnN0IEF0b21pY1N0cmluZyYgaWRlbnRpZmllcik7CiAgICAgc3RhdGljIHZvaWQgcmVuZGVyZXJT dWJ0cmVlQXR0YWNoZWQoUmVuZGVyT2JqZWN0Kik7CisgICAgc3RhdGljIHZvaWQgcmVuZGVyZXJT dHlsZUNoYW5nZWQoUmVuZGVyT2JqZWN0KiwgY29uc3QgUmVuZGVyU3R5bGUqIG9sZFN0eWxlLCBj b25zdCBSZW5kZXJTdHlsZSogbmV3U3R5bGUpOwogCiBwcml2YXRlOgogICAgIHZpcnR1YWwgY29u c3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0OwpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3QuY3BwCShyZXZpc2lvbiA1MzM5OSkKKysrIFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVj dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE2NjEsNyArMTY2MSw3IEBAIHZvaWQgUmVuZGVyT2Jq ZWN0OjpzdHlsZVdpbGxDaGFuZ2UoU3R5bGUKICAgICB9CiB9CiAKLXZvaWQgUmVuZGVyT2JqZWN0 OjpzdHlsZURpZENoYW5nZShTdHlsZURpZmZlcmVuY2UgZGlmZiwgY29uc3QgUmVuZGVyU3R5bGUq KQordm9pZCBSZW5kZXJPYmplY3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxlRGlmZmVyZW5jZSBkaWZm LCBjb25zdCBSZW5kZXJTdHlsZSpvbGRTdHlsZSkKIHsKICAgICBpZiAoc19hZmZlY3RzUGFyZW50 QmxvY2spCiAgICAgICAgIGhhbmRsZUR5bmFtaWNGbG9hdFBvc2l0aW9uQ2hhbmdlKCk7CkBAIC0x NjY5LDggKzE2NjksMTAgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OnN0eWxlRGlkQ2hhbmdlKFN0eWxl RAogICAgIGlmICghbV9wYXJlbnQpCiAgICAgICAgIHJldHVybjsKICAgICAKLSAgICBpZiAoZGlm ZiA9PSBTdHlsZURpZmZlcmVuY2VMYXlvdXQpCisgICAgaWYgKGRpZmYgPT0gU3R5bGVEaWZmZXJl bmNlTGF5b3V0KSB7CisgICAgICAgIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2Vk KHRoaXMsIG9sZFN0eWxlLCBtX3N0eWxlLmdldCgpKTsKICAgICAgICAgc2V0TmVlZHNMYXlvdXRB bmRQcmVmV2lkdGhzUmVjYWxjKCk7CisgICAgfQogICAgIGVsc2UgaWYgKGRpZmYgPT0gU3R5bGVE aWZmZXJlbmNlTGF5b3V0UG9zaXRpb25lZE1vdmVtZW50T25seSkKICAgICAgICAgc2V0TmVlZHNQ b3NpdGlvbmVkTW92ZW1lbnRMYXlvdXQoKTsKIApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9n Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24gNTMzOTkpCisr KyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwzMiBAQAor MjAxMC0wMS0xOCAgQ2Fyb2wgU3phYm8gIDxjYXJvbC5zemFib0Bub2tpYS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQW5vdGhlciBjcmF6eSBj b3VudGVycyBidWcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTExMDMxCisKKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVu dC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLWluY3JlbWVudC0wMDIuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291 bnRlcnMvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBm YXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQ6IEFkZGVk LgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWw6IEFk ZGVkLgorCisyMDEwLTAxLTE4ICBDYXJvbCBTemFibyAgPGNhcm9sLnN6YWJvQG5va2lhLmNvbT4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBbm90aGVy IGNyYXp5IGNvdW50ZXJzIGJ1ZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTEwMzEKKyAgICAgICAgQWRkZWQgdGVzdHMgZm9yIGR5bmFtaWMgRE9NIGNo YW5nZXMgYWZmZWN0aW5nIGNvdW50ZXJzLgorCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMv Y291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2Nv dW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv Y3NzL2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDIt ZXhwZWN0ZWQudHh0OiBBZGRlZC4KKwogMjAxMC0wMS0xNyAgQ3NhYmEgT3N6dHJvZ29uw6FjICA8 b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJ1YmJlci1zdGFtcGVkIGJ5IEVyaWMgU2VpZGVs LgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQt MDAyLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3Vu dGVycy9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysg TGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVj dGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBACitUaGUgZm9sbG93aW5nIHR3byBs aW5lcyBzaG91bGQgaGF2ZSB0aGUgc2FtZSBjb250ZW50OgorCiswLjEtMC4yLTEtMi0KKzAuMS0w LjItMS0yLQpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNy ZW1lbnQtMDAyLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw1MCBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBI VE1MIDQuMDEvL0VOIj4KKzxodG1sPjxoZWFkPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRl bnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PVVURi04Ij4KKyAgICA8dGl0bGU+ Q1NTIFRlc3Q6IGR5bmFtaWMgY2hhbmdlcyB0byAnY291bnRlci1pbmNyZW1lbnQnPC90aXRsZT4K KyAgICA8bGluayByZWw9ImF1dGhvciIgaHJlZj0iaHR0cDovL2RiYXJvbi5vcmcvIiB0aXRsZT0i TC4gRGF2aWQgQmFyb24iPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53 My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNjb3VudGVycyI+CisgICAgPGxpbmsgcmVsPSJo ZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1MyMS9nZW5lcmF0ZS5odG1sI3Byb3Bk ZWYtY29udGVudCI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9y Zy9UUi9DU1MyMS9zeW5kYXRhLmh0bWwjY291bnRlciI+CisgICAgPG1ldGEgY29udGVudD0iZG9t IiBuYW1lPSJmbGFncyI+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TdHlsZS1UeXBl IiBjb250ZW50PSJ0ZXh0L2NzcyI+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1TY3Jp cHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICA8c3R5bGUgdHlwZT0idGV4 dC9jc3MiPgorICAgICAgICBib2R5IHsgd2hpdGUtc3BhY2U6IG5vd3JhcDsgfQorICAgICAgICAj dGVzdCwgLnJlc2V0IHsgY291bnRlci1yZXNldDogYzsgfQorICAgICAgICAuaW5jcmVtZW50OmJl Zm9yZSwgLnVzZTpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAg ICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgor ICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5s YXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIu ZHVtcEFzVGV4dCgpOworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9uZSIpLnJlbW92ZUF0dHJpYnV0ZSgiY2xhc3Mi KTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5zZXRBdHRyaWJ1 dGUoImNsYXNzIiwgImluY3JlbWVudCIpOworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoInRocmVlIikuc2V0QXR0cmlidXRlKCJzdHlsZSIsICJjb3VudGVyLWluY3JlbWVudDog YyIpOworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAg ICAgICAgICAgICAgIHRlc3RFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3Qi KTsKKyAgICAgICAgICAgICAgICBjb25zb2xlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNv bnNvbGUiKTsKKyAgICAgICAgICAgICAgICBzcGFuTGlzdCA9IHRlc3RFbGVtZW50LmdldEVsZW1l bnRzQnlUYWdOYW1lKCJzcGFuIikKKyAgICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc3Bh bkxpc3QubGVuZ3RoOyArK2kgKSB7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50 ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICAgICAgICAgICAgICBu ZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPQorICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5jb3VudGVyVmFsdWVGb3JFbGVtZW50QnlJZChzcGFuTGlzdC5pdGVtKGkpLmdl dEF0dHJpYnV0ZSgiaWQiKSk7CisgICAgICAgICAgICAgICAgICAgIGlmIChuZXdTcGFuRWxlbWVu dC5pbm5lclRleHQubGVuZ3RoKQorICAgICAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1l bnQuaW5uZXJUZXh0ID0gbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ICsgIi0iOworICAgICAgICAg ICAgICAgICAgICBjb25zb2xlLmFwcGVuZENoaWxkKG5ld1NwYW5FbGVtZW50KTsKKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9u ZSgpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJv ZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5n IHR3byBsaW5lcyBzaG91bGQgaGF2ZSB0aGUgc2FtZSBjb250ZW50OjwvcD4KKyAgICA8ZGl2IGlk PSJ0ZXN0Ij48c3BhbiBpZD0ib25lIj48L3NwYW4+PHNwYW4gaWQ9InBhcmVudCI+PHNwYW4gaWQ9 InJlc2V0IiBjbGFzcz0icmVzZXQiPjxzcGFuIGlkPSJyZXNldGNoaWxkIiBjbGFzcz0iaW5jcmVt ZW50Ij48L3NwYW4+PHNwYW4gY2xhc3M9ImluY3JlbWVudCIgaWQ9InR3byI+PC9zcGFuPjwvc3Bh bj48L3NwYW4+PHNwYW4gc3R5bGU9ImNvdW50ZXItaW5jcmVtZW50OiBjOyIgY2xhc3M9InVzZSIg aWQ9InRocmVlIj48L3NwYW4+PHNwYW4gaWQ9InVwcGVyaW5jcmVtZW50IiBjbGFzcz0iaW5jcmVt ZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4wLjEtMC4yLTEtMi08 L2Rpdj4KKyAgICA8aHI+CisgICAgPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8L2JvZHk+PC9o dG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0w MDAtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50 ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBACitUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91 bGQgYmUgdGhlIHNhbWU6CisKKzEtMS4xLTEuMi0KKzEtMS4xLTEuMi0KSW5kZXg6IExheW91dFRl c3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDAuaHRtbAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVz ZXQtMDAwLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTEgQEAKKzwhRE9DVFlQRSBIVE1M IFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8 bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNl dD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50 ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6 Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9Imhl bHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRl cnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NT MjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIg aHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgor ICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1 aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAg PHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dy YXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAg ICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQor ICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxl PgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xs ZXIuZHVtcEFzVGV4dCgpOyAgIAorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2Fp dFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAg ICAgICAgICAgdmFyIHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAg ICAgICAgdmFyIHMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgICAg ICBzLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAgICAgICAgIHMuc2V0QXR0 cmlidXRlKCJpZCIsICJuZXdTcGFuIik7CisgICAgICAgICAgICB0Lmluc2VydEJlZm9yZShzLCB0 LmNoaWxkTm9kZXMuaXRlbSgxKSk7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAgdGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAgICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVz dEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInNwYW4iKQorICAgICAgICAgICAgICAgIGZv ciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7ICsraSApIHsKKyAgICAgICAgICAgICAgICAg ICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAg ICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dCA9CisgICAgICAgICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNw YW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJpZCIpKTsKKyAgICAgICAgICAgICAgICAgICAg aWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5sZW5ndGgpCisgICAgICAgICAgICAgICAgICAg ICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQg KyAiLSIKKyAgICAgICAgICAgICAgICAgICAgY29uc29sZS5hcHBlbmRDaGlsZChuZXdTcGFuRWxl bWVudCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250 cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICB9CisgICAgPC9z Y3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAg ICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAg IDxkaXYgaWQ9InRlc3QiPjxzcGFuIGlkPSJzcGFuMSIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFu PjxzcGFuIGlkPSJzcGFuMiIgY2xhc3M9InJlc2V0Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4zIiBj bGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW40IiBjbGFzcz0iaW5jcmVtZW50 Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4xLTEuMS0xLjItPC9kaXY+ CisgICAgPGhyPgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiLz4KKzwvYm9keT48L2h0bWw+CkluZGV4 OiBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMi1leHBlY3Rl ZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRl ci1yZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFz dC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDQgQEAKK1RoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUg c2FtZToKKworMS0xLjEtMi0zLTQtCisxLTEuMS0yLTMtNC0KSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDIuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAy Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDcgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJ QyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBo dHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYt OCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5j cmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFy b24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhy ZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgor ICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2Vu ZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0i aHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxt ZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNv bnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxl IHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0K KyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmlu Y3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhjLCAiLiIpICItIjsgfQorICAgICAg ICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAg IDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVt cEFzVGV4dCgpOyAgIAorICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9uZSIpLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAi cmVzZXQiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0d28iKS5yZW1v dmVBdHRyaWJ1dGUoImNsYXNzIik7CisgICAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RD b250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAgdGVzdEVsZW1lbnQgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgICAgIGNvbnNvbGUgPSBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAgICAgICAgICAgICAgIHNwYW5MaXN0ID0gdGVz dEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInNwYW4iKQorICAgICAgICAgICAgICAgIGZv ciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7ICsraSApIHsKKyAgICAgICAgICAgICAgICAg ICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAg ICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dCA9CisgICAgICAgICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNvdW50ZXJWYWx1ZUZvckVsZW1lbnRCeUlkKHNw YW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJpZCIpKTsKKyAgICAgICAgICAgICAgICAgICAg aWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5sZW5ndGgpCisgICAgICAgICAgICAgICAgICAg ICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPSBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQg KyAiLSI7CisgICAgICAgICAgICAgICAgICAgIGNvbnNvbGUuYXBwZW5kQ2hpbGQobmV3U3BhbkVs ZW1lbnQpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICA8L3Nj cmlwdD4KKzwvaGVhZD48Ym9keSBvbmxvYWQ9InNldFRpbWVvdXQoJ3J1bigpJywgMCkiPgorICAg IDxwPlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZTo8L3A+CisgICAg PGRpdiBpZD0idGVzdCI+PHNwYW4gaWQ9InNwYW4xIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+ PHNwYW4gaWQ9InNwYW4yIj48c3BhbiBjbGFzcz0icmVzZXQiIGlkPSJvbmUiPjxzcGFuIGlkPSJz cGFuNCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4gaWQ9InNw YW41IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW42Ij48c3BhbiBpZD0i dHdvIj48c3BhbiBpZD0ic3BhbjciICBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9zcGFuPjwv c3Bhbj48c3BhbiBpZD0ic3BhbjgiIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48L2Rpdj4KKyAg ICA8ZGl2IGlkPSJyZWZlcmVuY2UiPjEtMS4xLTItMy00LTwvZGl2PgorICAgIDxkaXYgaWQ9ImNv bnNvbGUiIC8+Cis8L2JvZHk+PC9odG1sPgo= 46866 2010-01-18 17:07:17 -0800 2010-01-19 08:41:43 -0800 New Proposed patch. Fixed style issue that I missed in my original submission. patchFor11031-11.patch text/plain 17382 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzM5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDEtMTggIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorCisgICAgICAgIFRoaXMgcGF0Y2ggYWN0dWFsbHkg cHJvdmlkZXMgZm9yIGNvdW50ZXIgdXBkYXRpbmcgd2hlbiB0aGUgc3R5bGUKKyAgICAgICAgb2Yg YSByZW5kZXJlciBjaGFuZ2VzLgorCisgICAgICAgIFRlc3RzOiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDAuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHls ZUNoYW5nZWQpOgorICAgICAgICBUaGlzIGZ1bmN0aW9uIGlzIGFkZGVkIHRvIHVwZGF0ZSB0aGUg Y291bnRlciBoaWVyYXJjaHkgaW4gCisgICAgICAgIHJlc3BvbnNlIHRvIGNoYW5nZXMgdG8gdGhl IHN0eWxlIG9mIGEgcmVuZGVyZXIuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlck9iamVjdDo6c3R5bGVEaWRDaGFuZ2UpOgorICAgICAgICBGb3IgY2hhbmdlcyB0 aGF0IG1heSBpbmNsdWRlIHRoZSBjb3VudGVyIGRpcmVjdGl2ZXMgYWRkZWQgYQorICAgICAgICBj YWxsIHRvIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2VkLgorCiAyMDEwLTAxLTE4 ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5uQG5va2lhLmNvbT4KIAogICAgICAgICBV bnJldmlld2VkIFN5bWJpYW4gYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQ291bnRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHJldmlzaW9uIDUzMzk5KQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0MCw0ICs0NDAsNDQgQEAgdm9pZCBSZW5kZXJD b3VudGVyOjpyZW5kZXJlclN1YnRyZWVBdHRhYwogICAgICAgICB1cGRhdGVDb3VudGVycyhkZXNj ZW5kYW50KTsKIH0KIAordm9pZCBSZW5kZXJDb3VudGVyOjpyZW5kZXJlclN0eWxlQ2hhbmdlZChS ZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBjb25zdCBSZW5kZXJTdHlsZSogb2xkU3R5bGUsIGNvbnN0 IFJlbmRlclN0eWxlKiBuZXdTdHlsZSkKK3sKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFw KiBuZXdDb3VudGVyRGlyZWN0aXZlczsKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBv bGRDb3VudGVyRGlyZWN0aXZlczsKKyAgICBpZiAob2xkU3R5bGUgJiYgKG9sZENvdW50ZXJEaXJl Y3RpdmVzID0gb2xkU3R5bGUtPmNvdW50ZXJEaXJlY3RpdmVzKCkpKSB7CisgICAgICAgIGlmIChu ZXdTdHlsZSAmJiAobmV3Q291bnRlckRpcmVjdGl2ZXMgPSBuZXdTdHlsZS0+Y291bnRlckRpcmVj dGl2ZXMoKSkpIHsKKyAgICAgICAgICAgIENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJh dG9yIG5ld01hcEVuZCA9IG5ld0NvdW50ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAg IENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIG9sZE1hcEVuZCA9IG9sZENvdW50 ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+YmVnaW4oKTsgaXQg IT0gbmV3TWFwRW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3Igb2xkTWFwSXQgPSBvbGRDb3VudGVyRGlyZWN0aXZlcy0+ZmluZChp dC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIGlmIChvbGRNYXBJdCAhPSBvbGRNYXBFbmQpIHsK KyAgICAgICAgICAgICAgICAgICAgaWYgKG9sZE1hcEl0LT5zZWNvbmQgPT0gaXQtPnNlY29uZCkK KyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBS ZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUocmVuZGVyZXIsIGl0LT5maXJzdC5nZXQo KSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIC8vIFdlIG11c3QgY3JlYXRl IHRoaXMgbm9kZSBoZXJlLCBiZWNhdXNlIHRoZSBjaGFuZ2VkIG5vZGUgbWF5IGJlIGEgbm9kZSB3 aXRoIG5vIGRpc3BsYXkgc3VjaCBhcworICAgICAgICAgICAgICAgIC8vIGFzIHRob3NlIGNyZWF0 ZWQgYnkgdGhlIGluY3JlbWVudCBvciByZXNldCBkaXJlY3RpdmVzIGFuZCB0aGUgcmUtbGF5b3V0 IHRoYXQgd2lsbCBoYXBwZW4gd2lsbAorICAgICAgICAgICAgICAgIC8vIG5vdCBjYXRjaCB0aGUg Y2hhbmdlIGlmIHRoZSBub2RlIGhhZCBubyBjaGlsZHJlbi4KKyAgICAgICAgICAgICAgICBtYWtl Q291bnRlck5vZGUocmVuZGVyZXIsIGl0LT5maXJzdC5nZXQoKSwgZmFsc2UpOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgLy8gRGVzdHJveWluZyBvbGQgY291bnRlcnMgdGhhdCBkbyBub3Qg ZXhpc3QgaW4gdGhlIG5ldyBjb3VudGVyRGlyZWN0aXZlIG1hcC4KKyAgICAgICAgICAgIGZvciAo Q291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBvbGRDb3VudGVyRGlyZWN0 aXZlcy0+YmVnaW4oKTsgaXQgIT1vbGRNYXBFbmQ7ICsraXQpIHsKKyAgICAgICAgICAgICAgICBp ZiAoIW5ld0NvdW50ZXJEaXJlY3RpdmVzLT5jb250YWlucyhpdC0+Zmlyc3QpKQorICAgICAgICAg ICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUocmVuZGVyZXIsIGl0 LT5maXJzdC5nZXQoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICBpZiAocmVuZGVyZXItPm1faGFzQ291bnRlck5vZGVNYXApCisgICAgICAgICAgICAgICAg UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhyZW5kZXJlcik7CisgICAgICAgIH0K KyAgICB9IGVsc2UgaWYgKG5ld1N0eWxlICYmIChuZXdDb3VudGVyRGlyZWN0aXZlcyA9IG5ld1N0 eWxlLT5jb3VudGVyRGlyZWN0aXZlcygpKSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFw Ojpjb25zdF9pdGVyYXRvciBuZXdNYXBFbmQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+ZW5kKCk7 CisgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBu ZXdDb3VudGVyRGlyZWN0aXZlcy0+YmVnaW4oKTsgaXQgIT0gbmV3TWFwRW5kOyArK2l0KSB7Cisg ICAgICAgICAgICAvLyBXZSBtdXN0IGNyZWF0ZSB0aGlzIG5vZGUgaGVyZSwgYmVjYXVzZSB0aGUg YWRkZWQgbm9kZSBtYXkgYmUgYSBub2RlIHdpdGggbm8gZGlzcGxheSBzdWNoIGFzCisgICAgICAg ICAgICAvLyBhcyB0aG9zZSBjcmVhdGVkIGJ5IHRoZSBpbmNyZW1lbnQgb3IgcmVzZXQgZGlyZWN0 aXZlcyBhbmQgdGhlIHJlLWxheW91dCB0aGF0IHdpbGwgaGFwcGVuIHdpbGwKKyAgICAgICAgICAg IC8vIG5vdCBjYXRjaCB0aGUgY2hhbmdlIGlmIHRoZSBub2RlIGhhZCBubyBjaGlsZHJlbi4KKyAg ICAgICAgICAgIG1ha2VDb3VudGVyTm9kZShyZW5kZXJlciwgaXQtPmZpcnN0LmdldCgpLCBmYWxz ZSk7CisgICAgICAgIH0KKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6 IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDUzMzk5KQorKysgV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBA IHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95Q291bnRlck5vZGVzKFJlbmRlck9iamVj dCopOwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBj b25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpOwogICAgIHN0YXRpYyB2b2lkIHJlbmRlcmVy U3VidHJlZUF0dGFjaGVkKFJlbmRlck9iamVjdCopOworICAgIHN0YXRpYyB2b2lkIHJlbmRlcmVy U3R5bGVDaGFuZ2VkKFJlbmRlck9iamVjdCosIGNvbnN0IFJlbmRlclN0eWxlKiBvbGRTdHlsZSwg Y29uc3QgUmVuZGVyU3R5bGUqIG5ld1N0eWxlKTsKIAogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmNwcAkocmV2aXNpb24gNTMzOTkpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNjYxLDcgKzE2NjEsNyBAQCB2b2lkIFJlbmRlck9i amVjdDo6c3R5bGVXaWxsQ2hhbmdlKFN0eWxlCiAgICAgfQogfQogCi12b2lkIFJlbmRlck9iamVj dDo6c3R5bGVEaWRDaGFuZ2UoU3R5bGVEaWZmZXJlbmNlIGRpZmYsIGNvbnN0IFJlbmRlclN0eWxl KikKK3ZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShTdHlsZURpZmZlcmVuY2UgZGlm ZiwgY29uc3QgUmVuZGVyU3R5bGUqb2xkU3R5bGUpCiB7CiAgICAgaWYgKHNfYWZmZWN0c1BhcmVu dEJsb2NrKQogICAgICAgICBoYW5kbGVEeW5hbWljRmxvYXRQb3NpdGlvbkNoYW5nZSgpOwpAQCAt MTY2OSw5ICsxNjY5LDEwIEBAIHZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShTdHls ZUQKICAgICBpZiAoIW1fcGFyZW50KQogICAgICAgICByZXR1cm47CiAgICAgCi0gICAgaWYgKGRp ZmYgPT0gU3R5bGVEaWZmZXJlbmNlTGF5b3V0KQorICAgIGlmIChkaWZmID09IFN0eWxlRGlmZmVy ZW5jZUxheW91dCkgeworICAgICAgICBSZW5kZXJDb3VudGVyOjpyZW5kZXJlclN0eWxlQ2hhbmdl ZCh0aGlzLCBvbGRTdHlsZSwgbV9zdHlsZS5nZXQoKSk7CiAgICAgICAgIHNldE5lZWRzTGF5b3V0 QW5kUHJlZldpZHRoc1JlY2FsYygpOwotICAgIGVsc2UgaWYgKGRpZmYgPT0gU3R5bGVEaWZmZXJl bmNlTGF5b3V0UG9zaXRpb25lZE1vdmVtZW50T25seSkKKyAgICB9IGVsc2UgaWYgKGRpZmYgPT0g U3R5bGVEaWZmZXJlbmNlTGF5b3V0UG9zaXRpb25lZE1vdmVtZW50T25seSkKICAgICAgICAgc2V0 TmVlZHNQb3NpdGlvbmVkTW92ZW1lbnRMYXlvdXQoKTsKIAogICAgIC8vIERvbid0IGNoZWNrIGZv ciByZXBhaW50IGhlcmU7IHdlIG5lZWQgdG8gd2FpdCB1bnRpbCB0aGUgbGF5ZXIgaGFzIGJlZW4K SW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9D aGFuZ2VMb2cJKHJldmlzaW9uIDUzMzk5KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3Jr aW5nIGNvcHkpCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTAtMDEtMTggIENhcm9sIFN6YWJvICA8Y2Fy b2wuc3phYm9Abm9raWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorCisgICAgICAgICogZmFzdC9j c3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisg ICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVj dGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNl dC0wMDAuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1y ZXNldC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVy cy9jb3VudGVyLXJlc2V0LTAwMi5odG1sOiBBZGRlZC4KKworMjAxMC0wMS0xOCAgQ2Fyb2wgU3ph Ym8gIDxjYXJvbC5zemFib0Bub2tpYS5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQW5vdGhlciBjcmF6eSBjb3VudGVycyBidWcKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTExMDMxCisgICAgICAgIEFk ZGVkIHRlc3RzIGZvciBkeW5hbWljIERPTSBjaGFuZ2VzIGFmZmVjdGluZyBjb3VudGVycy4KKwor ICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMC5odG1s OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMi5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVu dC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLXJlc2V0LTAwMC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLWV4cGVjdGVkLnR4dDogQWRkZWQuCisKIDIwMTAt MDEtMTcgIENzYWJhIE9zenRyb2dvbsOhYyAgPG9zc3lAd2Via2l0Lm9yZz4KIAogICAgICAgICBS dWJiZXItc3RhbXBlZCBieSBFcmljIFNlaWRlbC4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4 cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJz L2NvdW50ZXItaW5jcmVtZW50LTAwMi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNCBAQAorVGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGhhdmUgdGhlIHNhbWUgY29u dGVudDoKKworMC4xLTAuMi0xLTItCiswLjEtMC4yLTEtMi0KSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1sCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi5odG1s CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1p bmNyZW1lbnQtMDAyLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTAgQEAKKzwhRE9DVFlQ RSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRtbD48aGVhZD4K KyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsg Y2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNoYW5nZXMgdG8g J2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRob3IiIGhyZWY9 Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAgICA8bGluayBy ZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwj Y291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcv VFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxsaW5rIHJlbD0i aGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5odG1sI2NvdW50 ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAgIDxtZXRhIGh0 dHAtZXF1aXY9IkNvbnRlbnQtU3R5bGUtVHlwZSIgY29udGVudD0idGV4dC9jc3MiPgorICAgIDxt ZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2YXNj cmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdoaXRl LXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVzZXQ6 IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUsIC51c2U6YmVmb3JlIHsgY29udGVudDog Y291bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVudCB7IGNvdW50ZXItaW5j cmVtZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNj cmlwdCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKyAgICAgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgfQorCisgICAgICAg IGZ1bmN0aW9uIHJ1bigpIHsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJv bmUiKS5yZW1vdmVBdHRyaWJ1dGUoImNsYXNzIik7CisgICAgICAgICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgidHdvIikuc2V0QXR0cmlidXRlKCJjbGFzcyIsICJpbmNyZW1lbnQiKTsKKyAg ICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0aHJlZSIpLnNldEF0dHJpYnV0ZSgi c3R5bGUiLCAiY291bnRlci1pbmNyZW1lbnQ6IGMiKTsKKyAgICAgICAgICAgIGlmICh3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAgICAgICAgICB0ZXN0RWxlbWVudCA9IGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0Iik7CisgICAgICAgICAgICAgICAgY29uc29sZSA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb25zb2xlIik7CisgICAgICAgICAgICAgICAgc3Bh bkxpc3QgPSB0ZXN0RWxlbWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgic3BhbiIpCisgICAgICAg ICAgICAgICAgZm9yIChpID0gMDsgaSA8IHNwYW5MaXN0Lmxlbmd0aDsgKytpICkgeworICAgICAg ICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNw YW4iKTsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ID0KKyAg ICAgICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuY291bnRlclZhbHVlRm9yRWxl bWVudEJ5SWQoc3Bhbkxpc3QuaXRlbShpKS5nZXRBdHRyaWJ1dGUoImlkIikpOworICAgICAgICAg ICAgICAgICAgICBpZiAobmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0Lmxlbmd0aCkKKyAgICAgICAg ICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dCA9IG5ld1NwYW5FbGVtZW50 LmlubmVyVGV4dCArICItIjsKKyAgICAgICAgICAgICAgICAgICAgY29uc29sZS5hcHBlbmRDaGls ZChuZXdTcGFuRWxlbWVudCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgIDwvc2NyaXB0PgorPC9oZWFkPjxib2R5IG9ubG9hZD0ic2V0VGltZW91dCgncnVuKCkn LCAwKSI+CisgICAgPHA+VGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGhhdmUgdGhlIHNh bWUgY29udGVudDo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+PHNwYW4gaWQ9Im9uZSI+PC9zcGFu PjxzcGFuIGlkPSJwYXJlbnQiPjxzcGFuIGlkPSJyZXNldCIgY2xhc3M9InJlc2V0Ij48c3BhbiBp ZD0icmVzZXRjaGlsZCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGNsYXNzPSJpbmNy ZW1lbnQiIGlkPSJ0d28iPjwvc3Bhbj48L3NwYW4+PC9zcGFuPjxzcGFuIHN0eWxlPSJjb3VudGVy LWluY3JlbWVudDogYzsiIGNsYXNzPSJ1c2UiIGlkPSJ0aHJlZSI+PC9zcGFuPjxzcGFuIGlkPSJ1 cHBlcmluY3JlbWVudCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvZGl2PgorICAgIDxkaXYg aWQ9InJlZmVyZW5jZSI+MC4xLTAuMi0xLTItPC9kaXY+CisgICAgPGhyPgorICAgIDxkaXYgaWQ9 ImNvbnNvbGUiPjwvZGl2PgorPC9ib2R5PjwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL2Zhc3Qv Y3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMC1leHBlY3Rl ZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3Vu dGVyLXJlc2V0LTAwMC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNCBAQAor VGhlIGZvbGxvd2luZyB0d28gbGluZXMgc2hvdWxkIGJlIHRoZSBzYW1lOgorCisxLTEuMS0xLjIt CisxLTEuMS0xLjItCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVy LXJlc2V0LTAwMC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50 ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9m YXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMC5odG1sCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDUxIEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4w MS8vRU4iPgorPGh0bWw+PGhlYWQ+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBl IiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgorICAgIDx0aXRsZT5DU1MgVGVz dDogZHluYW1pYyBjaGFuZ2VzIHRvICdjb3VudGVyLWluY3JlbWVudCc8L3RpdGxlPgorICAgIDxs aW5rIHJlbD0iYXV0aG9yIiBocmVmPSJodHRwOi8vZGJhcm9uLm9yZy8iIHRpdGxlPSJMLiBEYXZp ZCBCYXJvbiI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9U Ui9DU1MyMS9nZW5lcmF0ZS5odG1sI2NvdW50ZXJzIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhy ZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjcHJvcGRlZi1jb250 ZW50Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NT UzIxL3N5bmRhdGEuaHRtbCNjb3VudGVyIj4KKyAgICA8bWV0YSBjb250ZW50PSJkb20iIG5hbWU9 ImZsYWdzIj4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250 ZW50PSJ0ZXh0L2phdmFzY3JpcHQiPgorICAgIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CisgICAg ICAgIGJvZHkgeyB3aGl0ZS1zcGFjZTogbm93cmFwOyB9CisgICAgICAgICN0ZXN0LCAucmVzZXQg eyBjb3VudGVyLXJlc2V0OiBjOyB9CisgICAgICAgIC5pbmNyZW1lbnQ6YmVmb3JlIHsgY29udGVu dDogY291bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVudCB7IGNvdW50ZXIt aW5jcmVtZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAg ICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsgICAKKyAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgfQorCisg ICAgICAgIGZ1bmN0aW9uIHJ1bigpIHsKKyAgICAgICAgICAgIHZhciB0ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAgICAgIHZhciBzID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgic3BhbiIpOworICAgICAgICAgICAgcy5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgInJl c2V0Iik7CisgICAgICAgICAgICBzLnNldEF0dHJpYnV0ZSgiaWQiLCAibmV3U3BhbiIpOworICAg ICAgICAgICAgdC5pbnNlcnRCZWZvcmUocywgdC5jaGlsZE5vZGVzLml0ZW0oMSkpOworICAgICAg ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAg IHRlc3RFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAg ICAgICAgICBjb25zb2xlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKTsKKyAg ICAgICAgICAgICAgICBzcGFuTGlzdCA9IHRlc3RFbGVtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1l KCJzcGFuIikKKyAgICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc3Bhbkxpc3QubGVuZ3Ro OyArK2kgKSB7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50ID0gZG9jdW1lbnQu Y3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVu dC5pbm5lclRleHQgPQorICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5j b3VudGVyVmFsdWVGb3JFbGVtZW50QnlJZChzcGFuTGlzdC5pdGVtKGkpLmdldEF0dHJpYnV0ZSgi aWQiKSk7CisgICAgICAgICAgICAgICAgICAgIGlmIChuZXdTcGFuRWxlbWVudC5pbm5lclRleHQu bGVuZ3RoKQorICAgICAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0 ID0gbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ICsgIi0iCisgICAgICAgICAgICAgICAgICAgIGNv bnNvbGUuYXBwZW5kQ2hpbGQobmV3U3BhbkVsZW1lbnQpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAg ICAgICB9CisgICAgICAgICAgfQorICAgIDwvc2NyaXB0PgorPC9oZWFkPjxib2R5IG9ubG9hZD0i c2V0VGltZW91dCgncnVuKCknLCAwKSI+CisgICAgPHA+VGhlIGZvbGxvd2luZyB0d28gbGluZXMg c2hvdWxkIGJlIHRoZSBzYW1lOjwvcD4KKyAgICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBpZD0ic3Bh bjEiIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bhbj48c3BhbiBpZD0ic3BhbjIiIGNsYXNzPSJyZXNl dCI+PC9zcGFuPjxzcGFuIGlkPSJzcGFuMyIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFu IGlkPSJzcGFuNCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvZGl2PgorICAgIDxkaXYgaWQ9 InJlZmVyZW5jZSI+MS0xLjEtMS4yLTwvZGl2PgorICAgIDxocj4KKyAgICA8ZGl2IGlkPSJjb25z b2xlIi8+Cis8L2JvZHk+PC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRl c3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQt MDAyLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBACitUaGUgZm9sbG93 aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6CisKKzEtMS4xLTItMy00LQorMS0xLjEt Mi0zLTQtCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLXJlc2V0 LTAwMi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2Nv dW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Nz cy9jb3VudGVycy9jb3VudGVyLXJlc2V0LTAwMi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDQ3IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wMS8vRU4i PgorPGh0bWw+PGhlYWQ+CisgICAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250 ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgiPgorICAgIDx0aXRsZT5DU1MgVGVzdDogZHlu YW1pYyBjaGFuZ2VzIHRvICdjb3VudGVyLWluY3JlbWVudCc8L3RpdGxlPgorICAgIDxsaW5rIHJl bD0iYXV0aG9yIiBocmVmPSJodHRwOi8vZGJhcm9uLm9yZy8iIHRpdGxlPSJMLiBEYXZpZCBCYXJv biI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1My MS9nZW5lcmF0ZS5odG1sI2NvdW50ZXJzIj4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0 dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVyYXRlLmh0bWwjcHJvcGRlZi1jb250ZW50Ij4K KyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL3N5 bmRhdGEuaHRtbCNjb3VudGVyIj4KKyAgICA8bWV0YSBjb250ZW50PSJkb20iIG5hbWU9ImZsYWdz Ij4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVNjcmlwdC1UeXBlIiBjb250ZW50PSJ0 ZXh0L2phdmFzY3JpcHQiPgorICAgIDxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CisgICAgICAgIGJv ZHkgeyB3aGl0ZS1zcGFjZTogbm93cmFwOyB9CisgICAgICAgICN0ZXN0LCAucmVzZXQgeyBjb3Vu dGVyLXJlc2V0OiBjOyB9CisgICAgICAgIC5pbmNyZW1lbnQ6YmVmb3JlIHsgY29udGVudDogY291 bnRlcnMoYywgIi4iKSAiLSI7IH0KKyAgICAgICAgLmluY3JlbWVudCB7IGNvdW50ZXItaW5jcmVt ZW50OiBjOyB9CisgICAgPC9zdHlsZT4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlw dCI+CisgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpIHsKKyAgICAgICAg ICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsgICAKKyAgICAgICAgICAgIGxh eW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKKyAgICAgICAgfQorCisgICAgICAg IGZ1bmN0aW9uIHJ1bigpIHsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJv bmUiKS5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgInJlc2V0Iik7CisgICAgICAgICAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgidHdvIikucmVtb3ZlQXR0cmlidXRlKCJjbGFzcyIpOworICAgICAg ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAg IHRlc3RFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAg ICAgICAgICBjb25zb2xlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKTsKKyAg ICAgICAgICAgICAgICBzcGFuTGlzdCA9IHRlc3RFbGVtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1l KCJzcGFuIikKKyAgICAgICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgc3Bhbkxpc3QubGVuZ3Ro OyArK2kgKSB7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50ID0gZG9jdW1lbnQu Y3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVu dC5pbm5lclRleHQgPQorICAgICAgICAgICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5j b3VudGVyVmFsdWVGb3JFbGVtZW50QnlJZChzcGFuTGlzdC5pdGVtKGkpLmdldEF0dHJpYnV0ZSgi aWQiKSk7CisgICAgICAgICAgICAgICAgICAgIGlmIChuZXdTcGFuRWxlbWVudC5pbm5lclRleHQu bGVuZ3RoKQorICAgICAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0 ID0gbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ICsgIi0iOworICAgICAgICAgICAgICAgICAgICBj b25zb2xlLmFwcGVuZENoaWxkKG5ld1NwYW5FbGVtZW50KTsKKyAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAg ICAgICAgfQorICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJz ZXRUaW1lb3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBz aG91bGQgYmUgdGhlIHNhbWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3QiPjxzcGFuIGlkPSJzcGFu MSIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGlkPSJzcGFuMiI+PHNwYW4gY2xhc3M9 InJlc2V0IiBpZD0ib25lIj48c3BhbiBpZD0ic3BhbjQiIGNsYXNzPSJpbmNyZW1lbnQiPjwvc3Bh bj48L3NwYW4+PC9zcGFuPjxzcGFuIGlkPSJzcGFuNSIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFu PjxzcGFuIGlkPSJzcGFuNiI+PHNwYW4gaWQ9InR3byI+PHNwYW4gaWQ9InNwYW43IiAgY2xhc3M9 ImluY3JlbWVudCI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4gaWQ9InNwYW44IiBjbGFzcz0i aW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJlbmNlIj4xLTEuMS0y LTMtNC08L2Rpdj4KKyAgICA8ZGl2IGlkPSJjb25zb2xlIiAvPgorPC9ib2R5PjwvaHRtbD4K 46916 2010-01-19 08:41:43 -0800 2010-01-19 16:09:25 -0800 Proposed patch; Fixes style and ChangeLog error mentioned by Darin. patchFor11031-12.patch text/plain 16805 carol SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1MzM5OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDEtMTggIENhcm9sIFN6YWJvICA8Y2Fyb2wuc3phYm9Abm9r aWEuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IEFub3RoZXIgY3JhenkgY291bnRlcnMgYnVnCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xMTAzMQorCisgICAgICAgIFRoaXMgcGF0Y2ggYWN0dWFsbHkg cHJvdmlkZXMgZm9yIGNvdW50ZXIgdXBkYXRpbmcgd2hlbiB0aGUgc3R5bGUKKyAgICAgICAgb2Yg YSByZW5kZXJlciBjaGFuZ2VzLgorCisgICAgICAgIFRlc3RzOiBmYXN0L2Nzcy9jb3VudGVycy9j b3VudGVyLWluY3JlbWVudC0wMDIuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDAuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDIuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNv dW50ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHls ZUNoYW5nZWQpOgorICAgICAgICBUaGlzIGZ1bmN0aW9uIGlzIGFkZGVkIHRvIHVwZGF0ZSB0aGUg Y291bnRlciBoaWVyYXJjaHkgaW4gCisgICAgICAgIHJlc3BvbnNlIHRvIGNoYW5nZXMgdG8gdGhl IHN0eWxlIG9mIGEgcmVuZGVyZXIuCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aDoKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlck9iamVjdDo6c3R5bGVEaWRDaGFuZ2UpOgorICAgICAgICBGb3IgY2hhbmdlcyB0 aGF0IG1heSBpbmNsdWRlIHRoZSBjb3VudGVyIGRpcmVjdGl2ZXMgYWRkZWQgYQorICAgICAgICBj YWxsIHRvIFJlbmRlckNvdW50ZXI6OnJlbmRlcmVyU3R5bGVDaGFuZ2VkLgorCiAyMDEwLTAxLTE4 ICBTaW1vbiBIYXVzbWFubiAgPHNpbW9uLmhhdXNtYW5uQG5va2lhLmNvbT4KIAogICAgICAgICBV bnJldmlld2VkIFN5bWJpYW4gYnVpbGQgZml4LgpJbmRleDogV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQ291bnRlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHJldmlzaW9uIDUzMzk5KQorKysgV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0MCw0ICs0NDAsNDQgQEAgdm9pZCBSZW5kZXJD b3VudGVyOjpyZW5kZXJlclN1YnRyZWVBdHRhYwogICAgICAgICB1cGRhdGVDb3VudGVycyhkZXNj ZW5kYW50KTsKIH0KIAordm9pZCBSZW5kZXJDb3VudGVyOjpyZW5kZXJlclN0eWxlQ2hhbmdlZChS ZW5kZXJPYmplY3QqIHJlbmRlcmVyLCBjb25zdCBSZW5kZXJTdHlsZSogb2xkU3R5bGUsIGNvbnN0 IFJlbmRlclN0eWxlKiBuZXdTdHlsZSkKK3sKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFw KiBuZXdDb3VudGVyRGlyZWN0aXZlczsKKyAgICBjb25zdCBDb3VudGVyRGlyZWN0aXZlTWFwKiBv bGRDb3VudGVyRGlyZWN0aXZlczsKKyAgICBpZiAob2xkU3R5bGUgJiYgKG9sZENvdW50ZXJEaXJl Y3RpdmVzID0gb2xkU3R5bGUtPmNvdW50ZXJEaXJlY3RpdmVzKCkpKSB7CisgICAgICAgIGlmIChu ZXdTdHlsZSAmJiAobmV3Q291bnRlckRpcmVjdGl2ZXMgPSBuZXdTdHlsZS0+Y291bnRlckRpcmVj dGl2ZXMoKSkpIHsKKyAgICAgICAgICAgIENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJh dG9yIG5ld01hcEVuZCA9IG5ld0NvdW50ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAg IENvdW50ZXJEaXJlY3RpdmVNYXA6OmNvbnN0X2l0ZXJhdG9yIG9sZE1hcEVuZCA9IG9sZENvdW50 ZXJEaXJlY3RpdmVzLT5lbmQoKTsKKyAgICAgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+YmVnaW4oKTsgaXQg IT0gbmV3TWFwRW5kOyArK2l0KSB7CisgICAgICAgICAgICAgICAgQ291bnRlckRpcmVjdGl2ZU1h cDo6Y29uc3RfaXRlcmF0b3Igb2xkTWFwSXQgPSBvbGRDb3VudGVyRGlyZWN0aXZlcy0+ZmluZChp dC0+Zmlyc3QpOworICAgICAgICAgICAgICAgIGlmIChvbGRNYXBJdCAhPSBvbGRNYXBFbmQpIHsK KyAgICAgICAgICAgICAgICAgICAgaWYgKG9sZE1hcEl0LT5zZWNvbmQgPT0gaXQtPnNlY29uZCkK KyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBS ZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUocmVuZGVyZXIsIGl0LT5maXJzdC5nZXQo KSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIC8vIFdlIG11c3QgY3JlYXRl IHRoaXMgbm9kZSBoZXJlLCBiZWNhdXNlIHRoZSBjaGFuZ2VkIG5vZGUgbWF5IGJlIGEgbm9kZSB3 aXRoIG5vIGRpc3BsYXkgc3VjaCBhcworICAgICAgICAgICAgICAgIC8vIGFzIHRob3NlIGNyZWF0 ZWQgYnkgdGhlIGluY3JlbWVudCBvciByZXNldCBkaXJlY3RpdmVzIGFuZCB0aGUgcmUtbGF5b3V0 IHRoYXQgd2lsbCBoYXBwZW4gd2lsbAorICAgICAgICAgICAgICAgIC8vIG5vdCBjYXRjaCB0aGUg Y2hhbmdlIGlmIHRoZSBub2RlIGhhZCBubyBjaGlsZHJlbi4KKyAgICAgICAgICAgICAgICBtYWtl Q291bnRlck5vZGUocmVuZGVyZXIsIGl0LT5maXJzdC5nZXQoKSwgZmFsc2UpOworICAgICAgICAg ICAgfQorICAgICAgICAgICAgLy8gRGVzdHJveWluZyBvbGQgY291bnRlcnMgdGhhdCBkbyBub3Qg ZXhpc3QgaW4gdGhlIG5ldyBjb3VudGVyRGlyZWN0aXZlIG1hcC4KKyAgICAgICAgICAgIGZvciAo Q291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBvbGRDb3VudGVyRGlyZWN0 aXZlcy0+YmVnaW4oKTsgaXQgIT1vbGRNYXBFbmQ7ICsraXQpIHsKKyAgICAgICAgICAgICAgICBp ZiAoIW5ld0NvdW50ZXJEaXJlY3RpdmVzLT5jb250YWlucyhpdC0+Zmlyc3QpKQorICAgICAgICAg ICAgICAgICAgICBSZW5kZXJDb3VudGVyOjpkZXN0cm95Q291bnRlck5vZGUocmVuZGVyZXIsIGl0 LT5maXJzdC5nZXQoKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSB7CisgICAgICAg ICAgICBpZiAocmVuZGVyZXItPm1faGFzQ291bnRlck5vZGVNYXApCisgICAgICAgICAgICAgICAg UmVuZGVyQ291bnRlcjo6ZGVzdHJveUNvdW50ZXJOb2RlcyhyZW5kZXJlcik7CisgICAgICAgIH0K KyAgICB9IGVsc2UgaWYgKG5ld1N0eWxlICYmIChuZXdDb3VudGVyRGlyZWN0aXZlcyA9IG5ld1N0 eWxlLT5jb3VudGVyRGlyZWN0aXZlcygpKSkgeworICAgICAgICBDb3VudGVyRGlyZWN0aXZlTWFw Ojpjb25zdF9pdGVyYXRvciBuZXdNYXBFbmQgPSBuZXdDb3VudGVyRGlyZWN0aXZlcy0+ZW5kKCk7 CisgICAgICAgIGZvciAoQ291bnRlckRpcmVjdGl2ZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBu ZXdDb3VudGVyRGlyZWN0aXZlcy0+YmVnaW4oKTsgaXQgIT0gbmV3TWFwRW5kOyArK2l0KSB7Cisg ICAgICAgICAgICAvLyBXZSBtdXN0IGNyZWF0ZSB0aGlzIG5vZGUgaGVyZSwgYmVjYXVzZSB0aGUg YWRkZWQgbm9kZSBtYXkgYmUgYSBub2RlIHdpdGggbm8gZGlzcGxheSBzdWNoIGFzCisgICAgICAg ICAgICAvLyBhcyB0aG9zZSBjcmVhdGVkIGJ5IHRoZSBpbmNyZW1lbnQgb3IgcmVzZXQgZGlyZWN0 aXZlcyBhbmQgdGhlIHJlLWxheW91dCB0aGF0IHdpbGwgaGFwcGVuIHdpbGwKKyAgICAgICAgICAg IC8vIG5vdCBjYXRjaCB0aGUgY2hhbmdlIGlmIHRoZSBub2RlIGhhZCBubyBjaGlsZHJlbi4KKyAg ICAgICAgICAgIG1ha2VDb3VudGVyTm9kZShyZW5kZXJlciwgaXQtPmZpcnN0LmdldCgpLCBmYWxz ZSk7CisgICAgICAgIH0KKyAgICB9Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6 IFdlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDUzMzk5KQorKysgV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC00Miw2ICs0Miw3IEBA IHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCBkZXN0cm95Q291bnRlck5vZGVzKFJlbmRlck9iamVj dCopOwogICAgIHN0YXRpYyB2b2lkIGRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqLCBj b25zdCBBdG9taWNTdHJpbmcmIGlkZW50aWZpZXIpOwogICAgIHN0YXRpYyB2b2lkIHJlbmRlcmVy U3VidHJlZUF0dGFjaGVkKFJlbmRlck9iamVjdCopOworICAgIHN0YXRpYyB2b2lkIHJlbmRlcmVy U3R5bGVDaGFuZ2VkKFJlbmRlck9iamVjdCosIGNvbnN0IFJlbmRlclN0eWxlKiBvbGRTdHlsZSwg Y29uc3QgUmVuZGVyU3R5bGUqIG5ld1N0eWxlKTsKIAogcHJpdmF0ZToKICAgICB2aXJ0dWFsIGNv bnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdDsKSW5kZXg6IFdlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmNwcAkocmV2aXNpb24gNTMzOTkpCisrKyBXZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNjYxLDcgKzE2NjEsNyBAQCB2b2lkIFJlbmRlck9i amVjdDo6c3R5bGVXaWxsQ2hhbmdlKFN0eWxlCiAgICAgfQogfQogCi12b2lkIFJlbmRlck9iamVj dDo6c3R5bGVEaWRDaGFuZ2UoU3R5bGVEaWZmZXJlbmNlIGRpZmYsIGNvbnN0IFJlbmRlclN0eWxl KikKK3ZvaWQgUmVuZGVyT2JqZWN0OjpzdHlsZURpZENoYW5nZShTdHlsZURpZmZlcmVuY2UgZGlm ZiwgY29uc3QgUmVuZGVyU3R5bGUqIG9sZFN0eWxlKQogewogICAgIGlmIChzX2FmZmVjdHNQYXJl bnRCbG9jaykKICAgICAgICAgaGFuZGxlRHluYW1pY0Zsb2F0UG9zaXRpb25DaGFuZ2UoKTsKQEAg LTE2NjksOSArMTY2OSwxMCBAQCB2b2lkIFJlbmRlck9iamVjdDo6c3R5bGVEaWRDaGFuZ2UoU3R5 bGVECiAgICAgaWYgKCFtX3BhcmVudCkKICAgICAgICAgcmV0dXJuOwogICAgIAotICAgIGlmIChk aWZmID09IFN0eWxlRGlmZmVyZW5jZUxheW91dCkKKyAgICBpZiAoZGlmZiA9PSBTdHlsZURpZmZl cmVuY2VMYXlvdXQpIHsKKyAgICAgICAgUmVuZGVyQ291bnRlcjo6cmVuZGVyZXJTdHlsZUNoYW5n ZWQodGhpcywgb2xkU3R5bGUsIG1fc3R5bGUuZ2V0KCkpOwogICAgICAgICBzZXROZWVkc0xheW91 dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKLSAgICBlbHNlIGlmIChkaWZmID09IFN0eWxlRGlmZmVy ZW5jZUxheW91dFBvc2l0aW9uZWRNb3ZlbWVudE9ubHkpCisgICAgfSBlbHNlIGlmIChkaWZmID09 IFN0eWxlRGlmZmVyZW5jZUxheW91dFBvc2l0aW9uZWRNb3ZlbWVudE9ubHkpCiAgICAgICAgIHNl dE5lZWRzUG9zaXRpb25lZE1vdmVtZW50TGF5b3V0KCk7CiAKICAgICAvLyBEb24ndCBjaGVjayBm b3IgcmVwYWludCBoZXJlOyB3ZSBuZWVkIHRvIHdhaXQgdW50aWwgdGhlIGxheWVyIGhhcyBiZWVu CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCShyZXZpc2lvbiA1MzM5OSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDE4IEBACisyMDEwLTAxLTE4ICBDYXJvbCBTemFibyAgPGNh cm9sLnN6YWJvQG5va2lhLmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBBbm90aGVyIGNyYXp5IGNvdW50ZXJzIGJ1ZworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTEwMzEKKyAgICAgICAgQWRkZWQgdGVz dHMgZm9yIGR5bmFtaWMgRE9NIGNoYW5nZXMgYWZmZWN0aW5nIGNvdW50ZXJzLgorCisgICAgICAg ICogZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWw6IEFkZGVk LgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItaW5jcmVtZW50LTAwMi1l eHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXIt cmVzZXQtMDAwLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0OiBBZGRlZC4KKwogMjAxMC0wMS0xNyAg Q3NhYmEgT3N6dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJ1YmJlci1z dGFtcGVkIGJ5IEVyaWMgU2VpZGVsLgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRl cnMvY291bnRlci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVudC0wMDItZXhwZWN0ZWQu dHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRl ci1pbmNyZW1lbnQtMDAyLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBA CitUaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgaGF2ZSB0aGUgc2FtZSBjb250ZW50Ogor CiswLjEtMC4yLTEtMi0KKzAuMS0wLjItMS0yLQpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3Mv Y291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0 VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1pbmNyZW1lbnQtMDAyLmh0bWwJKHJldmlz aW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3VudGVyLWluY3JlbWVu dC0wMDIuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1MCBAQAorPCFET0NUWVBFIEhUTUwg UFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEvL0VOIj4KKzxodG1sPjxoZWFkPgorICAgIDxt ZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0 PVVURi04Ij4KKyAgICA8dGl0bGU+Q1NTIFRlc3Q6IGR5bmFtaWMgY2hhbmdlcyB0byAnY291bnRl ci1pbmNyZW1lbnQnPC90aXRsZT4KKyAgICA8bGluayByZWw9ImF1dGhvciIgaHJlZj0iaHR0cDov L2RiYXJvbi5vcmcvIiB0aXRsZT0iTC4gRGF2aWQgQmFyb24iPgorICAgIDxsaW5rIHJlbD0iaGVs cCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNjb3VudGVy cyI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBocmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1My MS9nZW5lcmF0ZS5odG1sI3Byb3BkZWYtY29udGVudCI+CisgICAgPGxpbmsgcmVsPSJoZWxwIiBo cmVmPSJodHRwOi8vd3d3LnczLm9yZy9UUi9DU1MyMS9zeW5kYXRhLmh0bWwjY291bnRlciI+Cisg ICAgPG1ldGEgY29udGVudD0iZG9tIiBuYW1lPSJmbGFncyI+CisgICAgPG1ldGEgaHR0cC1lcXVp dj0iQ29udGVudC1TdHlsZS1UeXBlIiBjb250ZW50PSJ0ZXh0L2NzcyI+CisgICAgPG1ldGEgaHR0 cC1lcXVpdj0iQ29udGVudC1TY3JpcHQtVHlwZSIgY29udGVudD0idGV4dC9qYXZhc2NyaXB0Ij4K KyAgICA8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICAgICAgICBib2R5IHsgd2hpdGUtc3BhY2U6 IG5vd3JhcDsgfQorICAgICAgICAjdGVzdCwgLnJlc2V0IHsgY291bnRlci1yZXNldDogYzsgfQor ICAgICAgICAuaW5jcmVtZW50OmJlZm9yZSwgLnVzZTpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVy cyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6 IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4K KyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAg bGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworICAgICAgICAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rp b24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9uZSIpLnJl bW92ZUF0dHJpYnV0ZSgiY2xhc3MiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJ0d28iKS5zZXRBdHRyaWJ1dGUoImNsYXNzIiwgImluY3JlbWVudCIpOworICAgICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRocmVlIikuc2V0QXR0cmlidXRlKCJzdHlsZSIs ICJjb3VudGVyLWluY3JlbWVudDogYyIpOworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgICAgIHRlc3RFbGVtZW50ID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInRlc3QiKTsKKyAgICAgICAgICAgICAgICBjb25zb2xlID0gZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoImNvbnNvbGUiKTsKKyAgICAgICAgICAgICAgICBzcGFuTGlzdCA9 IHRlc3RFbGVtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJzcGFuIikKKyAgICAgICAgICAgICAg ICBmb3IgKGkgPSAwOyBpIDwgc3Bhbkxpc3QubGVuZ3RoOyArK2kgKSB7CisgICAgICAgICAgICAg ICAgICAgIG5ld1NwYW5FbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOwor ICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPQorICAgICAgICAg ICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5jb3VudGVyVmFsdWVGb3JFbGVtZW50QnlJ ZChzcGFuTGlzdC5pdGVtKGkpLmdldEF0dHJpYnV0ZSgiaWQiKSk7CisgICAgICAgICAgICAgICAg ICAgIGlmIChuZXdTcGFuRWxlbWVudC5pbm5lclRleHQubGVuZ3RoKQorICAgICAgICAgICAgICAg ICAgICAgICAgbmV3U3BhbkVsZW1lbnQuaW5uZXJUZXh0ID0gbmV3U3BhbkVsZW1lbnQuaW5uZXJU ZXh0ICsgIi0iOworICAgICAgICAgICAgICAgICAgICBjb25zb2xlLmFwcGVuZENoaWxkKG5ld1Nw YW5FbGVtZW50KTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAg PC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1lb3V0KCdydW4oKScsIDApIj4K KyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQgaGF2ZSB0aGUgc2FtZSBjb250 ZW50OjwvcD4KKyAgICA8ZGl2IGlkPSJ0ZXN0Ij48c3BhbiBpZD0ib25lIj48L3NwYW4+PHNwYW4g aWQ9InBhcmVudCI+PHNwYW4gaWQ9InJlc2V0IiBjbGFzcz0icmVzZXQiPjxzcGFuIGlkPSJyZXNl dGNoaWxkIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gY2xhc3M9ImluY3JlbWVudCIg aWQ9InR3byI+PC9zcGFuPjwvc3Bhbj48L3NwYW4+PHNwYW4gc3R5bGU9ImNvdW50ZXItaW5jcmVt ZW50OiBjOyIgY2xhc3M9InVzZSIgaWQ9InRocmVlIj48L3NwYW4+PHNwYW4gaWQ9InVwcGVyaW5j cmVtZW50IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVm ZXJlbmNlIj4wLjEtMC4yLTEtMi08L2Rpdj4KKyAgICA8aHI+CisgICAgPGRpdiBpZD0iY29uc29s ZSI+PC9kaXY+Cis8L2JvZHk+PC9odG1sPgpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291 bnRlcnMvY291bnRlci1yZXNldC0wMDAtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91 dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLWV4cGVjdGVkLnR4dAko cmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVz ZXQtMDAwLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0IEBACitUaGUgZm9s bG93aW5nIHR3byBsaW5lcyBzaG91bGQgYmUgdGhlIHNhbWU6CisKKzEtMS4xLTEuMi0KKzEtMS4x LTEuMi0KSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQt MDAwLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291 bnRlci1yZXNldC0wMDAuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3Nz L2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAwLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs NTEgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+ Cis8aHRtbD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRl bnQ9InRleHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5h bWljIGNoYW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVs PSJhdXRob3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9u Ij4KKyAgICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIx L2dlbmVyYXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0 cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgor ICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3lu ZGF0YS5odG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3Mi PgorICAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRl eHQvamF2YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9k eSB7IHdoaXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50 ZXItcmVzZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3Vu dGVycyhjLCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1l bnQ6IGM7IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0 Ij4KKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAg ICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyAgIAorICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAg ZnVuY3Rpb24gcnVuKCkgeworICAgICAgICAgICAgdmFyIHQgPSBkb2N1bWVudC5nZXRFbGVtZW50 QnlJZCgidGVzdCIpOworICAgICAgICAgICAgdmFyIHMgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJzcGFuIik7CisgICAgICAgICAgICBzLnNldEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsK KyAgICAgICAgICAgIHMuc2V0QXR0cmlidXRlKCJpZCIsICJuZXdTcGFuIik7CisgICAgICAgICAg ICB0Lmluc2VydEJlZm9yZShzLCB0LmNoaWxkTm9kZXMuaXRlbSgxKSk7CisgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAgdGVzdEVs ZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgICAg IGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAgICAgICAg ICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInNwYW4i KQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7ICsraSAp IHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50LmlubmVy VGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNvdW50ZXJW YWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJpZCIpKTsK KyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5sZW5ndGgp CisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPSBuZXdT cGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSIKKyAgICAgICAgICAgICAgICAgICAgY29uc29sZS5h cHBlbmRDaGlsZChuZXdTcGFuRWxlbWVudCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICAgIH0K KyAgICAgICAgICB9CisgICAgPC9zY3JpcHQ+Cis8L2hlYWQ+PGJvZHkgb25sb2FkPSJzZXRUaW1l b3V0KCdydW4oKScsIDApIj4KKyAgICA8cD5UaGUgZm9sbG93aW5nIHR3byBsaW5lcyBzaG91bGQg YmUgdGhlIHNhbWU6PC9wPgorICAgIDxkaXYgaWQ9InRlc3QiPjxzcGFuIGlkPSJzcGFuMSIgY2xh c3M9ImluY3JlbWVudCI+PC9zcGFuPjxzcGFuIGlkPSJzcGFuMiIgY2xhc3M9InJlc2V0Ij48L3Nw YW4+PHNwYW4gaWQ9InNwYW4zIiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNw YW40IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PC9kaXY+CisgICAgPGRpdiBpZD0icmVmZXJl bmNlIj4xLTEuMS0xLjItPC9kaXY+CisgICAgPGhyPgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiLz4K KzwvYm9keT48L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2Nzcy9jb3VudGVycy9jb3Vu dGVyLXJlc2V0LTAwMi1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFz dC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAw KQorKysgTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1yZXNldC0wMDItZXhw ZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDQgQEAKK1RoZSBmb2xsb3dpbmcgdHdv IGxpbmVzIHNob3VsZCBiZSB0aGUgc2FtZToKKworMS0xLjEtMi0zLTQtCisxLTEuMS0yLTMtNC0K SW5kZXg6IExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0 bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9jc3MvY291bnRlcnMvY291bnRlci1y ZXNldC0wMDIuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvY3NzL2NvdW50 ZXJzL2NvdW50ZXItcmVzZXQtMDAyLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDcgQEAK KzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAxLy9FTiI+Cis8aHRt bD48aGVhZD4KKyAgICA8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRl eHQvaHRtbDsgY2hhcnNldD1VVEYtOCI+CisgICAgPHRpdGxlPkNTUyBUZXN0OiBkeW5hbWljIGNo YW5nZXMgdG8gJ2NvdW50ZXItaW5jcmVtZW50JzwvdGl0bGU+CisgICAgPGxpbmsgcmVsPSJhdXRo b3IiIGhyZWY9Imh0dHA6Ly9kYmFyb24ub3JnLyIgdGl0bGU9IkwuIERhdmlkIEJhcm9uIj4KKyAg ICA8bGluayByZWw9ImhlbHAiIGhyZWY9Imh0dHA6Ly93d3cudzMub3JnL1RSL0NTUzIxL2dlbmVy YXRlLmh0bWwjY291bnRlcnMiPgorICAgIDxsaW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3 dy53My5vcmcvVFIvQ1NTMjEvZ2VuZXJhdGUuaHRtbCNwcm9wZGVmLWNvbnRlbnQiPgorICAgIDxs aW5rIHJlbD0iaGVscCIgaHJlZj0iaHR0cDovL3d3dy53My5vcmcvVFIvQ1NTMjEvc3luZGF0YS5o dG1sI2NvdW50ZXIiPgorICAgIDxtZXRhIGNvbnRlbnQ9ImRvbSIgbmFtZT0iZmxhZ3MiPgorICAg IDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtU2NyaXB0LVR5cGUiIGNvbnRlbnQ9InRleHQvamF2 YXNjcmlwdCI+CisgICAgPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgICAgICAgYm9keSB7IHdo aXRlLXNwYWNlOiBub3dyYXA7IH0KKyAgICAgICAgI3Rlc3QsIC5yZXNldCB7IGNvdW50ZXItcmVz ZXQ6IGM7IH0KKyAgICAgICAgLmluY3JlbWVudDpiZWZvcmUgeyBjb250ZW50OiBjb3VudGVycyhj LCAiLiIpICItIjsgfQorICAgICAgICAuaW5jcmVtZW50IHsgY291bnRlci1pbmNyZW1lbnQ6IGM7 IH0KKyAgICA8L3N0eWxlPgorICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKyAg ICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgeworICAgICAgICAgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOyAgIAorICAgICAgICAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOworICAgICAgICB9CisKKyAgICAgICAgZnVuY3Rp b24gcnVuKCkgeworICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoIm9uZSIpLnNl dEF0dHJpYnV0ZSgiY2xhc3MiLCAicmVzZXQiKTsKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCJ0d28iKS5yZW1vdmVBdHRyaWJ1dGUoImNsYXNzIik7CisgICAgICAgICAgICBp ZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKSB7CisgICAgICAgICAgICAgICAgdGVzdEVs ZW1lbnQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgidGVzdCIpOworICAgICAgICAgICAgICAg IGNvbnNvbGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiY29uc29sZSIpOworICAgICAgICAg ICAgICAgIHNwYW5MaXN0ID0gdGVzdEVsZW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInNwYW4i KQorICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBzcGFuTGlzdC5sZW5ndGg7ICsraSAp IHsKKyAgICAgICAgICAgICAgICAgICAgbmV3U3BhbkVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJzcGFuIik7CisgICAgICAgICAgICAgICAgICAgIG5ld1NwYW5FbGVtZW50LmlubmVy VGV4dCA9CisgICAgICAgICAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmNvdW50ZXJW YWx1ZUZvckVsZW1lbnRCeUlkKHNwYW5MaXN0Lml0ZW0oaSkuZ2V0QXR0cmlidXRlKCJpZCIpKTsK KyAgICAgICAgICAgICAgICAgICAgaWYgKG5ld1NwYW5FbGVtZW50LmlubmVyVGV4dC5sZW5ndGgp CisgICAgICAgICAgICAgICAgICAgICAgICBuZXdTcGFuRWxlbWVudC5pbm5lclRleHQgPSBuZXdT cGFuRWxlbWVudC5pbm5lclRleHQgKyAiLSI7CisgICAgICAgICAgICAgICAgICAgIGNvbnNvbGUu YXBwZW5kQ2hpbGQobmV3U3BhbkVsZW1lbnQpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICB9 CisgICAgICAgIH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD48Ym9keSBvbmxvYWQ9InNldFRpbWVv dXQoJ3J1bigpJywgMCkiPgorICAgIDxwPlRoZSBmb2xsb3dpbmcgdHdvIGxpbmVzIHNob3VsZCBi ZSB0aGUgc2FtZTo8L3A+CisgICAgPGRpdiBpZD0idGVzdCI+PHNwYW4gaWQ9InNwYW4xIiBjbGFz cz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4gaWQ9InNwYW4yIj48c3BhbiBjbGFzcz0icmVzZXQi IGlkPSJvbmUiPjxzcGFuIGlkPSJzcGFuNCIgY2xhc3M9ImluY3JlbWVudCI+PC9zcGFuPjwvc3Bh bj48L3NwYW4+PHNwYW4gaWQ9InNwYW41IiBjbGFzcz0iaW5jcmVtZW50Ij48L3NwYW4+PHNwYW4g aWQ9InNwYW42Ij48c3BhbiBpZD0idHdvIj48c3BhbiBpZD0ic3BhbjciICBjbGFzcz0iaW5jcmVt ZW50Ij48L3NwYW4+PC9zcGFuPjwvc3Bhbj48c3BhbiBpZD0ic3BhbjgiIGNsYXNzPSJpbmNyZW1l bnQiPjwvc3Bhbj48L2Rpdj4KKyAgICA8ZGl2IGlkPSJyZWZlcmVuY2UiPjEtMS4xLTItMy00LTwv ZGl2PgorICAgIDxkaXYgaWQ9ImNvbnNvbGUiIC8+Cis8L2JvZHk+PC9odG1sPgo=