4980 2005-09-14 03:42:59 -0700 CSS2: Counters not supported 2006-10-02 17:51:35 -0700 1 1 1 Unclassified WebKit CSS 420+ Mac OS X 10.4 RESOLVED FIXED HasReduction P3 Normal --- 11032 11035 11028 11029 11030 11031 11033 11034 11036 1 macrulez bdakin bdakin ian mitz nickshanks robburns1 oldest_to_newest 19626 0 macrulez 2005-09-14 03:42:59 -0700 test case: ul#bookmarksbar li:after { float: right; content: "\2318" counter(cmdkey, decimal); counter-increment: cmdkey; } expected behaviour: the li has the place of interest sign followed by a number after it. current behaviour: the li has nothing after it. work-around: remove the counter. any content: not including a counter works. 19627 1 macrulez 2005-09-14 03:43:45 -0700 (oops, meant to set the priority to P3, sorry) 19628 2 macrulez 2005-09-14 03:44:53 -0700 OK, I think I finally have this bug set up correctly now. sorry about all the email :) 19657 3 macrulez 2005-09-15 01:23:07 -0700 confirmed in CVS as of end-of-day, 2005-09-15, PDT. 27146 4 joost 2005-12-29 07:31:42 -0800 Confirmed, adding testcase in a sec. Reassigning to webkit-unassigned 27147 5 5354 joost 2005-12-29 07:32:26 -0800 Created attachment 5354 Testcase 56262 6 10717 bdakin 2006-09-22 14:26:00 -0700 Created attachment 10717 Preliminary counter implementation Here is a patch to implement counters. It is based largely on the KHTML implementation. A few things about this patch: 1. There are definitely still bugs with counters. There are a bunch of great counters test cases at http://dbaron.org/css2.1/tests/imported-20050702/ I plan to check in a bunch of them as layout tests, and file bugs on all of the ones that don't yet work. 2. List items should be re-written to be rendered with counters. KHTML does this, and I have a patch that would make them switch over. I do not want to switch them over yet, though, because of the bugs that still exist in this counters patch (see above!). I will file an additional bug for this switch. It doesn't seem worth it to do the switch now and introduce regressions into lists when we can just switch it later when counters are more robust. 3. I don't think the test case attached to this bug is valid. Unless I am mis-reading the spec, of course. Anyway, as I mentioned before, there are lots of great tests at http://dbaron.org/css2.1/tests/imported-20050702/ 56273 7 hyatt 2006-09-22 20:53:31 -0700 I definitely think switching lists over to counters can be a post-Leopard thing. :) 56293 8 10717 darin 2006-09-23 09:27:25 -0700 Comment on attachment 10717 Preliminary counter implementation The part of this where we add 4 specific functions to the base class Node to distinguish ordered list, unordered list, menu, and directory elements seems wrong to me. Instead I think these functions should be higher level, and not on Node (perhaps on HTMLElement or Element). When I say higher level I mean a function like resetsCounter(). If all we want to do is check the type of element, we can use hasTagName(olTag) which is the style used in all the rest of the code. In the code for the ordered list element, we should be using the HTMLOListElement::start() function instead of calling getAttribute. I haven't reviewed other aspects of this patch yet, but this is an immediately-obvious design mistake. 56403 9 hyatt 2006-09-24 23:01:33 -0700 Need to implement getComputedStyle stuff for counters it looks like. 56447 10 10763 bdakin 2006-09-25 13:04:43 -0700 Created attachment 10763 Patch with minor adjustments Here is a patch that addresses Darin's comments. It also adds computed style information for counter-increment and counter-reset. I didn't do anything for actual counters since they are a part of the content property, and we have not yet done anything to compute style for the content property. Seems like taking care of the whole content property may be out of the scope of this bug, but if anyone disagrees, I am happy to take care of it. 56488 11 bdakin 2006-09-25 15:08:54 -0700 Okay, I filed a whole bunch of bugs for the test cases that still fail. Specifically, http://bugzilla.opendarwin.org/show_bug.cgi?id=11028 http://bugzilla.opendarwin.org/show_bug.cgi?id=11029 http://bugzilla.opendarwin.org/show_bug.cgi?id=11030 http://bugzilla.opendarwin.org/show_bug.cgi?id=11031 http://bugzilla.opendarwin.org/show_bug.cgi?id=11032 http://bugzilla.opendarwin.org/show_bug.cgi?id=11033 http://bugzilla.opendarwin.org/show_bug.cgi?id=11034 http://bugzilla.opendarwin.org/show_bug.cgi?id=11035 http://bugzilla.opendarwin.org/show_bug.cgi?id=11036 56536 12 10763 darin 2006-09-26 07:44:29 -0700 Comment on attachment 10763 Patch with minor adjustments + CounterNode *newNode = lookupCounter(counter); Need to move the * on that one. The function named getCounter I would name findCounter. I find it very difficult to understand the "view" and "counters" parameters to that function. Perhaps they need different names. I don't understand why a linked list is a good data structure for something we are looking up by name. The function destroyCounters walks the linked list in what seems to be a slightly obfuscated way. The class CounterList is not well named for a linked list node. I think it should be named CounterListNode perhaps. Why does CounterList have one member named m_counterNode and two others named counter and next. It's a brand new class so its members should be named consistently. Why does this brand new code use DeprecatedString? Performance will be better if it doesn't. + RenderCounter(Node* node, CounterData* counter); + CounterResetNode(RenderObject* o); We omit parameter names in cases like this. +#ifndef _Counter_Reset_Node_h_ Names with a leading underscore like this are reserved for the implementation. Please leave it off. + virtual void insertAfter (CounterNode* newChild, CounterNode* refChild); + virtual void removeChild (CounterNode* oldChild); We don't put spaces before parentheses like this. In RenderCounter.h: +#include "config.h" +#include "CounterNode.h" +#include "CounterResetNode.h" +#include "RenderCounter.h" +#include "RenderStyle.h" We put the include of the file's own header first to make sure it compiles standalone. So RenderCounter.h needs to be first before the other headers. +using namespace WebCore; The entire file implements something in namespace WebCore, so it should be inside a namespace WebCore declaration (with braces), not after a "using" declaration. +// ------------------------------------------------------------------------- I don't think this long line adds anything. +CounterNode::CounterNode(RenderObject *o) + : m_hasCounters(false), m_isVisual(false), + m_value(0), m_count(0), m_parent(0), m_previous(0), m_next(0), + m_renderer(o) {} Strange formatting here. I think the counter nodes and counter list nodes should be arena-allocated like the rest of the render tree. + String v = static_cast<Element*>(element())->getAttribute("value"); + if (!v.isEmpty()) { The above code is unnecessarily inefficient. Instead it should use const AtomicString& for v. \ No newline at end of file Should not have any of those. + if(!value->isValueList()) I see a lot of if statements without spaces after the "if" like this one. Sorry, I didn't get through every last bit of the patch, but those are my comments so far. 56577 13 10788 bdakin 2006-09-26 17:21:16 -0700 Created attachment 10788 Patch the addresses Darin's comments, but leaks So here is a patch that, I believe, addressess all of Darin's comments. However, I am leaking CounterNodes all over the place. I think that I need to do something to make the HashMap clean them up correctly. Since there is so much other stuff in this patch too, I thought I'd post it anyway while I am working on that. 56593 14 10793 bdakin 2006-09-26 23:43:24 -0700 Created attachment 10793 better This should take care of the leaking... 56615 15 10793 darin 2006-09-27 09:29:11 -0700 Comment on attachment 10793 better Another round of comments: Is counter support really worth 4 bytes in every single RenderObject? Perhaps we could put the counters into a per-document hash table (maybe in the RenderView object) and save the space in the RenderObject instances at the cost of a hash table lookup to find the counter. The main cost here would be time in the RenderObject destruction code to look for a counter entry in the hash table. That cost can be offset either by making sure it doesn't run when the entire tree is destroyed (the "document being destroyed" optimization) or by devoting a bit to "has an entry in the per-document hash table". A bit is probably more affordable than the 32 bits we are spending on it in this patch. + CSSValueList* counterResetList; + CSSValueList* counterIncrementList; Can we afford these 8 bytes in every RenderStyle? Are there any alternatives? My suggestion to arena-allocate CounterNode objects is incompatible with the use of deleteAllValues in the RenderObject destructor, so either we have to back off on the arena allocation or write our own code to delete all the values that uses arenaDelete. Since the hash map itself won't be in the arena, I think the use of a hash might eliminate the need for use of arena allocation. + virtual ~RenderCounter() {}; No semicolon is needed for a function like this. But more importantly there's no reason to explicitly declare a destructor if it's just going to be empty in the header. That's the same behavior you get if you just leave out the explicit destructor definition altogether. +class RenderCounter : public RenderText +{ We put the brace on the same line as the class declaration, not its own line. +protected: We should always use private rather than protected, unless we have a derived class that needs access to some of these fields. + String toListStyleType(int value, int total, EListStyleType type); I think we could come up with a better name for this function. For one thing, it doesn't produce a "list style type". I think we need a verb here or a name that describes the result. Also no need for the name "type" in the declaration, since EListStyleType speaks for itself. + virtual void recount(bool first = false); It's quite unclear what the "first" boolean means. We need to give this parameter a better name. CounterListItem.h includes RenderListItem.h, but it shouldn't. It should include CounterNode.h. + : RenderText(node,0), m_counter(counter), m_counterNode(0) Need a space after the comma. +const int cMarkerPadding = 7; I think constants should be at the top of the file, not amidst the functions. + c = UChar(digits[d]); + roman.insert(String(&c, 1), 0); No need for the conversion to UChar here; in fact we don't need the local variable "c" at all since digits[d] is already a UChar. I'd like to see insert overloaded to take a UChar so we don't have to contruct a string every time. This function is going to be really slow the way it's written, in fact, so we might want to think about the idiom for building up a String. For example, we could build a Vector<UChar> and then reverse it before making the string to avoid the expensive prepend operation. +static String toLetterString(int number, int letterA) The "letterA" parameter should be a UChar not an int. + c = UChar(1511 + 3); + c = UChar(0x2022); Most of the UChar casts are unnecessary. A plain integer an be assigned to a UChar without a cast. + letter += String(&c, 1); There's an append on String that takes a UChar already -- we should use that instead of constructing a string. + // ### unsupported, we use decimal instead The "###" is the KDE way of doing what we do with FIXME. Lets use FIXME. + bool counters; + counters = !m_counter->separator().isNull(); Should merge these into one line. +struct CounterData { + CounterData() {} + CounterData(String i, int l, String sep) :ident(i), ls(l), s(sep) {} + ~CounterData() {} The parameters should be const String&, not String. There's no need to explicitly define the destructor. And given that the list style enum is defined in this same file, there's no justification for using "int" here. It should be EListStyleType instead. + String identifier() { return ident; } There's no point in having these accessor functions for a struct where the data members are also public. Either we should make the data members private or omit the accessor functions. +CounterNode::~CounterNode() {}; Should omit this bogus semicolon and possibly the entire destructor definition. +CounterNode::CounterNode(RenderObject *o) I'd like to see member initialization syntax used here instead of assignment statements. CounterNode::setHasCounters and CounterNode::recount use recursive implementations instead of iterative. We should use iterative implementations instead for brand new code like this. + short counterIncrement; //ok, so these are not visual mode spesific + short counterReset; //can't go to inherited, since these are not inherited May as well fix the comment formatting (no spaces after //) as long as you're touching these lines. And also fix the spelling. + void setContent(CounterData* c, bool add = false); + bool counterDataEquivalent(RenderStyle* otherStyle); + void setCounterReset(CSSValueList* v); + void setCounterIncrement(CSSValueList* v); + void addCounterReset(CSSPrimitiveValue* c); + void addCounterIncrement(CSSPrimitiveValue* c); + bool hasCounterReset(const String& c) const; + bool hasCounterIncrement(const String& c) const; + short counterReset(const String& c) const; + short counterIncrement(const String& c) const; Should omit most of these variable names, although for some of the ones named "c" it would be helpful to use a name like "counterName". I'm disappointed that we're writing yet another tree implementation for CounterNode. Functions like CounterResetNode::removeChild are tricky to write correctly and we've had buts in such functions in the past. I wonder if there's an alternative. Do we really need the efficient removal you get by using a tree? Could we consider using vectors of children instead? Those are more efficient for most other operations. + CounterNode* n = firstChild(); + for(; n; n = n->nextSibling()) + n->setParentDirty(); That should be written with the variable inside the for loop, not just before it. But this is another example of a recursive algorithm where I'd like to see iterative ones. In RenderContainer.cpp I can't figure out of the style leaks in some code paths. Are you sure it doesn't? As far as I can tell, there is no use of the functions that remove elements from the counter tree. Is that right? If so, can we omit this dead code? + bool isRoot() { return m_renderer && m_renderer->isRoot(); }; This should be const. + bool m_hasCounters : 1; + bool m_isVisual : 1; I'm not sure using bit fields here is the right tradeoff. + int value() const { return m_value; } + int count() const { return m_count; } Why do these return int when the member itself is a short? In general, I'm concerned when I see short that there's an issue with values that fit in an int and don't fit in a short. Does this code handle that right? I don't understand the RenderStyle copy constructor. Why is it OK to just copy things like the content, counterResetList, and counterIncrementList pointers without making a copy or doing some sort of ref counting. I think that works only if they're always 0? Don't counterResetList and counterIncrementList have to be looked at in functions like RenderStyle::diff? Why doesn't ContentData::clearContent need to do something with the old counter like it does with text? Who owns the counter object? + // ### Should we compare content? Again, we use FIXME for this rather than ###. I'd also like a more intelligent comment about this. + total += (short)counterValue->getFloatValue(); Where's the guarantee this won't just overflow? Why aren't we using RefPtr for counterResetList and counterIncrementList? Also, setCounterReset and setCounterIncrement should take PassRefPtr parameters. I think it's very confusing that setCounterIncrement takes a list and addCounterIncrement adds a counter to that list. What's the list's name and what is the names of the items in that list? We should consider that when naming these functions. Same for setCounterReset and addCounterReset. + bool parseCounter(int propId, bool increment, bool important); I don't think a bool is very good here, because it's unclear what false means. I think the name "increment" here is also unclear because it's a verb! + CounterData counter = CounterData(counterValue->identifier(), + counterValue->listStyleNumber(), counterValue->separator()); Should probably use constructor syntax here instead of assignment to avoid repeating the type name twice. + CSSValueList* list = static_cast<CSSValueList *>(value); + style->setCounterIncrement(list); Merging this into one line would be clearer, I think, and avoid the need for braces around the code. Since Counter has no classes derived from it, I don't think it needs a virtual destructor. The code generated will be more efficient if there are no virtual functions in the class. + String identifier() const { return m_identifier.get() ? m_identifier.get()->getStringValue() : String(); } I think there's too much get here. Does it compile like this? + String identifier() const { return m_identifier ? m_identifier->getStringValue() : String(); } If so, please do that. + delete identifier; + delete separator; + delete listStyle; + delete counterName; + delete numValue; + delete list; These are wrong. The objects are reference-counted, and deleting them is not the correct way to deal with those. Instead the variables should be RefPtr and we can get rid of "goto invalid" and change those sites to instead say "return 0". Since parseCounterContent returns a new object, it should return a PassRefPtr<CSSValue> instead of a CSSValue*. + if (counters || (args->size() != 1 && args->size() != 3)) + if (!counters || (args->size() != 3 && args->size() != 5)) + goto invalid; This is twisted logic, and args->size() can be really expensive to compute. Lets rewrite this to be human-readable and not call args->size() over and over again. + i = (short)val->fValue; What about values that don't fit in a short? 56705 16 10821 bdakin 2006-09-28 02:14:23 -0700 Created attachment 10821 Patch for Darin's most recent comments Here is a patch that addresses nearly all of Darin's most recent comments. I may have missed a few, but I will take a cleaner pass at it in the morning. One thing I know for sure is that I haven't yet addressed any of the potential overflow issues. I am hoping to talk with Darin about that in person since I am not sure how best to deal with it. Also, instead of adding a HashMap to the RenderView that keeps track of all of the objects and their CounterNodeMaps, I made a static map in RenderObject. This seems more intuitive to me. Anywaym here is what I got. 56718 17 10821 darin 2006-09-28 09:04:15 -0700 Comment on attachment 10821 Patch for Darin's most recent comments Looks good. Here's a new round of comments: To get the performance boost from String::insert we really need to implement a StringImpl::insert too, but that can wait until another patch. + static RenderObjectsToCounterNodeMaps* _renderObjectsToCounterNodeMaps; No need for an underscore here. It's a local variable so it can have a nice simple name. Also, since it's a local it can just be a HashMap instead of a pointer to a HashMap, simplifying the function. Should also have a space between the typedefs and the functions. I still think that the "view" and "counters" parameters of findCounter are hard to understand. Maybe we could change their names. I think the counter parameters to hasCounter and findCounter should be counterName instead. +class CounterResetNode : public CounterNode +{ We put braces on the same line. + virtual void insertAfter (CounterNode* newChild, CounterNode* refChild); No space needed after the function name. + virtual bool isReset() { return true; }; I think isReset() should be a const member function. + str = new StringImpl((static_cast<String>(m_item)).characters(), m_item.length()); Do we need that static_cast? I think this can be str = m_item.impl().copy() instead. But is the copy() even needed? If CounterData has all private members, then I think it should be marked class instead of struct (just a minor style issue). Also, the members should have nice names like m_identifier, m_listStyle, m_separator instead of ident, ls, s. + PassRefPtr<CSSValueList> counterResetValueList() { return counterResetList; } + PassRefPtr<CSSValueList> counterIncrementValueList() { return counterIncrementList; } These two should not return PassRefPtr because they return a list that's owned by the object returning. They are not trying to pass ownership to the caller. On the other hand, the setters are correctly using PassRefPtr to express the fact that the callee takes ownership from the caller. +CounterResetNode::CounterResetNode(RenderObject* o) : CounterNode(o), m_total(0), m_first(0), m_last(0) {} +CounterResetNode::~CounterResetNode() {}; Should make this normal formatting instead of wacky formatting and consider removing the destructor declaration since I believe it's redundant. There are only two reason to have an empty destructor declaration in a .cpp file: 1) In cases where some data member can't be destroyed without including additional headers. For example, if I have a RefPtr<Node> in a class but don't want to require clients to include "Node.h" the destructor has to be in the .cpp file because otherwise clients trying to destroy will get errors or have to include "Node.h". 2) If you want to be able to add code there later without recompiling all the files that include this one. I don't think either of these apply to CounterResetNode. If we had it to do all over again, we might do this tree using vectors for the lists of children. I'm not sure a next/prev/parent/child tree is best for this. But I don't think that's worth reworking all the code for. I'm still not sure the use of "short" in CounterNode makes sense. It just saves a few bytes per node and we've had trouble in the past with short vs. int issues. + ASSERT(pair && counterName); + ASSERT(pair && counterName && counterValue); These should be broken up int separate assertions. That's true of any ASSERT that has a simple && in it -- it's better to know which failed. + int totalInt = total + counterValue->getFloatValue(); + if (totalInt < SHRT_MAX && totalInt > SHRT_MIN) Seems to me that this still could overflow an int. If we want to safely check for overflow I think we need to use a floating point type. Also, this doesn't check if getFloatValue itself overflows a short, which could happen even if the sum doesn't overflow a short. I'd also like to see at least one overflow test case. + PassRefPtr<CSSValue> parseCounterContent(ValueList *args, bool counters); Star should be next to ValueList*. I don't understand what a boolean "counters" means here. Better name? + void setContent(CounterData*, bool add = false); This should take a PassRefPtr<CounterData> I believe. I still don't see how the CounterData object gets deallocated when the RenderStyle is deallocated. I'd like to understand who owns that object. I see it being created in cssstyleselector.cpp and I can't see who's responsible for deallocating it. + CounterData counter(counterValue->identifier() + ,(EListStyleType)counterValue->listStyleNumber() + ,counterValue->separator()); + CounterData* c = new CounterData(counter); These should be merged into a single statement like this: CounterData* c = new CounterData(counterValue->identifier(), counterValue->listStyleNumber(), counterValue->separator()); But also you should almost never put a new object into a raw pointer. This should either be passed directly to a function taking a PassRefPtr or perhaps put into a local RefPtr and then passed to a function taking a PassRefPtr (and in that case you can do a release() for efficiency too). + // ### add list-style and separator Please use FIXME, not ###. + int listStyleNumber() const { return m_listStyle.get() ? (int) m_listStyle.get()->getFloatValue() : 0; } Why is this an int? What guarantees it will be a valid list style number? No need for .get() here. + RefPtr<CSSPrimitiveValue> m_identifier; //string + RefPtr<CSSPrimitiveValue> m_listStyle; //int + RefPtr<CSSPrimitiveValue> m_separator; //string Lets put spaces after the "//" to match our usual style. #include "CSSBorderImageValue.h" +#include "Counter.h" #include "CSSImageValue.h" Would be better to put this in alphabetical order (I usually use case-sensitive alphabetical order because that's what Xcode does with the Sort Selection menu item). + case CSS_PROP_COUNTER_RESET: // [ <identifier> <integer>? ]+ | none | inherit + if (id == CSS_VAL_NONE) + valid_primitive = true; + else + return parseCounter(propId, 0, important); case CSS_PROP_FONT_FAMILY: There's a "break" missing here so we'll end up falling into the font family code. I suggest formatting this differently to make that easier to see. Maybe: case CSS_PROP_COUNTER_RESET: // [ <identifier> <integer>? ]+ | none | inherit if (id != CSS_VAL_NONE) return parseCounter(propId, 0, important); valid_primitive = true; break; + Value *a = args->current(); The * should be next to Value, not a. + parsedValue = parseCounterContent(args, false).get(); + parsedValue = parseCounterContent(args, true).get(); The .get() here is wrong and using it creates unnecessary ref-count churn; PassRefPtr will pass to a RefPtr without a ref/deref, but by doing get() we prevent that. + if (!parsedValue) return false; Lets break these up into two lines using the traditional formatting. + } else + if (fname == "counter(") { + } else + if (fname == "counters(") { Strange "else" formatting here. Please fix. + addProperty(propId, values.get(), important); CSSParser::addProperty's value parameter should be changed to a PassRefPtr. That would obviate this get() and be cleaner that what we have today. + RefPtr<CSSPrimitiveValue> identifier; You can make the code better and more efficient by declaring this where it's initialized. It's also better style, I think. + RefPtr<CSSPrimitiveValue> separator; + RefPtr<CSSPrimitiveValue> listStyle; And these can be moved down to just before where they're set up (before the if statements). + Counter* counter = new Counter(identifier.get(), listStyle.get(), separator.get()); + return new CSSPrimitiveValue(counter); The constructor for Counter should take PassRefPtr and then you should call release() instead of get() here. Also, it's not great style to have a new object in a raw pointer. I think merging this into a single statement would be best. + Value* val; This should be declared where it's initialized, not outside the loop. + RefPtr<CSSPrimitiveValue> numValue; Same here. + Pair* pair = new Pair(counterName.get(), numValue.get()); Again, we don't want to use get() here because it creates unnecessary ref-count churn. Instead we should call release() on both of these. And again it's not good to have a new object that gets put into a raw pointer. Merging into one big statement would be better. I think with the right formatting you could get rid of the numValue local variable too and it would look fine: list->append(new CSSPrimitiveValue(new Pair(counterName.release(), new CSSPrimitiveValue(i, CSSPrimitiveValue::CSS_NUMBER)))); + i = (short)val->fValue; The cast to short, and I'm not clear on why it's OK to discard bits if the value is outside the short range. + addProperty(propId, list.get(), important); Another case of get() where what we want is release(). 56745 18 10831 bdakin 2006-09-29 00:05:36 -0700 Created attachment 10831 another round This patch addresses Darin's last round of comments. I am pretty sure that I have addressed everything, thought I could be wrong. In Counter.h, I left the listStyle as an integer because I check to make sure it is a valid list style number from within the parser. Perhaps that is insufficient, though? What do you think? (Oh, and Darin, just so you know, I fixed that crazy crasher that I showed to you earlier today, so that is all set. It was utterly bizarre; I will tell you about it later.) 56788 19 bdakin 2006-09-29 09:50:05 -0700 Eep! I just realized I forgot to finish taking care of the overflow stuff. Investigating now. 56789 20 bdakin 2006-09-29 09:53:07 -0700 Hmm...looks like Firefox just lets everything overflow and gives totally bogus values. I wonder what behavior we want... 56852 21 10831 darin 2006-09-30 14:24:19 -0700 Comment on attachment 10831 another round Looking good! I checked, and every use of RenderObject::hasCounter is immediately followed by a call to RenderObject::findCounter. Perhaps we should just add yet another boolean parameter to findCounter to determine whether or not it should create a counter if it doesn't already exist. Then we could eliminate hasCounter entirely. Is there a way to avoid recounting everything in the tree as the tree is initially parsed and when the tree is destroyed and the entire document is going away? I'm worried that there's too much recounting. + if (pos >= m_length) { + append(*str); + return; + } That needs to be append(str, length), not append(*str), which will append only the first character! + int newlen = m_length + length; newlen should be a size_t rather than an int. +static RenderObjectsToCounterNodeMaps* getRenderObjectsToCounterNodeMaps() This could return a reference instead of a pointer. Either way is OK. + counterNode->remove(); + delete counterNode; + counterNode = 0; 1) No reason to set counterNode to 0. 2) Why doesn't the CounterNode destructor handle the counterNode->remove() part? If it did, we could go back to writing this more simply using deleteAllValues. + int val = 0; + RenderObjectsToCounterNodeMaps* objectsMap = getRenderObjectsToCounterNodeMaps(); The definition of "val" should really be moved down to just before it's first used. I also think it would read beter if the values of the nodes were set where they are allocated as needed instead of sharing a single call to setValue(). + CounterNodeMap* counterNodesMap = objectsMap->get(this); + if (counterNodesMap) + newNode = counterNodesMap->get(counterName); In general, I like putting the definition inside the if statement in all the cases like this, but it's an arguably matter of style. + objectsMap->set(this, nodeMap); This line should go inside the if statement. It's only needed for a newly-created node map. + RenderObject* n = !isListItem() && previousSibling() ? + previousSibling()->previousSibling() : previousSibling(); I think this reads better with the ? on the start of the second line. + while (n) { + if (n->hasCounter(counterName)) { + current = n->findCounter(counterName); + break; + } else + n = n->previousSibling(); + } I would have written this as a for loop: for (; n; n = n->previousSibling()) if (n->hasCounter(counterName)) { current = n->findCounter(counterName); break; } I think that makes it a little easier to see what's going on. + bool counters = !m_counter->separator().isNull(); This local variable needs a better name. I can't see how a boolean could be named "counters"! + // Found render-sibling, now search for later counter-siblings among its render-children I suspect that the loop below this comment could be written much more simply by using previousInPreOrder or a similar function. Not sure though. I noticed this comment: // note: do not add unnecessary bitflags, we have 32 bit already! You should remove it -- it's inaccurate! + m_item = convertValueToType(value, total, (EListStyleType)m_counter->listStyle()); + m_item = convertValueToType(value, total, (EListStyleType)m_counter->listStyle()) You should remove the typecasts since they're not needed any more. + m_item = convertValueToType(value, total, (EListStyleType)m_counter->listStyle()) + + m_counter->separator() + m_item; How about a += here instead of an =? Does this handle the overflow case? Is that needed? + str = new StringImpl(m_item.characters(), m_item.length()); Can this be str = m_item.impl()->copy() instead? + , m_next (0) Stray space here. The CounterNode::recountAndGetNext does not seem to handle overflow. Is that OK? + assert(newChild->m_next->m_previous == refChild); Should use ASSERT, not asssert. + assert (m_last == refChild); Should use ASSERT and omit the extra space. +// Implementation of counter-increment and counter-content What good is that comment? + bool hasSeparator() const { return m_hasSeparator; }; + bool willNeedLayout() const { return m_willNeedLayout; }; + void setWillNeedLayout() { m_willNeedLayout = true; }; + void setRenderer(RenderObject* o) { m_renderer = o; }; + RenderObject* renderer() const { return m_renderer; }; Remove incorrect trailing semicolons here, please. + ASSERT(pair); Should move this up one line so we assert before we dereference pair (two places in RenderStyle). + RefPtr<CSSValue> parsedValue; Why not put parsedValue back inside the loop where it used to be? Is there a reason to move it out? To avoid a tiny bit of reference count churn, the code below this should be append(parsedValue.release()) instead of just append(parsedValue). Same with the call to addProperty, which should pass values.release() instead of values. These comments are all about optional cleanup and obscure edge case questions except for the append(*str) mistake, but I need to do a review- because of that mistake. 56885 22 10857 bdakin 2006-10-01 16:07:19 -0700 Created attachment 10857 Most newest...est Okay here is a new patch. A few comments on things I did NOT address: 1. I decided not to address overflow at all. I even removed a few lines of code that I had previously added to RenderStyle.cpp to address it. It seems like we don't really gain anything by addressing overflow with counters. Even if we give 0 or 1 instead of some ridiculous number, it will still be incorrect. Firefox doesn't do anything to handle overflow. In general, it seems like we would have to patch this code in a lot of places to really make sure we were always returning 0/1 in the overflow case, and for very little gain. It's not that I mind putting in the effort (I am happy to if anyone disagrees), it's that checking for overflow in all of these places sort of clutters up the code making it harder to read, etc. In the end it just doesn't seem like we gain much. 2. Darin, I did not address your first comment about hadCounter()/findCounter() because I was confused and don't think I understand what you mean. We can talk about this in person if you want me to do it still. 3. I ran into a bunch of crashes when I had the CounterNode destructor handle removing the nodes. It would crash most often in deletAllValues(). I am not entirely sure why, and it wasn't consistent. It seems to be timing-related, so I just left the removal in RenderObject::destroy() 4. I did not do this: + m_item = convertValueToType(value, total, (EListStyleType)m_counter->listStyle()) + + m_counter->separator() + m_item; How about a += here instead of an =? Does this handle the overflow case? Is that needed? because += makes things be in the wrong order. Okay, I think that's all I wanted to mention... 56936 23 10857 darin 2006-10-02 08:36:11 -0700 Comment on attachment 10857 Most newest...est + append(new StringImpl(str, length)); This is no good. It leaks a StringImpl! Instead, append(str, length) should work fine. 56937 24 darin 2006-10-02 08:38:24 -0700 (In reply to comment #22) > 4. I did not do this: > > + m_item = convertValueToType(value, total, > (EListStyleType)m_counter->listStyle()) > + + m_counter->separator() + m_item; > > How about a += here instead of an =? > > because += makes things be in the wrong order. If you're relying on the order, then you may need separate statements. In an assignment statement there's no guarantee that the different parameters to the + are evaluated from left to right. I don't see any ordering guarantees you'd get from + that you wouldn't get from += so I don't understand the comment. Anyway, not a big issue. The only thing that needs fixing is that append and then I think you can land. 56952 25 10869 bdakin 2006-10-02 11:59:03 -0700 Created attachment 10869 Yet another patch Fixed the bug in StringImpl...will fix it better after I check in. Did some additional clean-up. 56953 26 10869 bdakin 2006-10-02 12:02:34 -0700 Comment on attachment 10869 Yet another patch Wait! Ignore this patch! It crashes! BRB! 56955 27 10870 bdakin 2006-10-02 12:11:03 -0700 Created attachment 10870 Okay, this one! Okay, fixed the crash from the last one. This one should be good. 56974 28 10870 darin 2006-10-02 15:47:34 -0700 Comment on attachment 10870 Okay, this one! r=me 56977 29 bdakin 2006-10-02 17:51:35 -0700 I committed this with r16721 5354 2005-12-29 07:32:26 -0800 2005-12-29 07:32:26 -0800 Testcase 4980-li-after-counter.html text/html 223 joost PGh0bWw+PGhlYWQ+CgoKCTxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CgkJdWwgbGk6YWZ0ZXIgeyAK CQlmbG9hdDogcmlnaHQ7IAoJCWNvbnRlbnQ6ICJcMjMxOCIgY291bnRlcihjbWRrZXksIGRlY2lt YWwpOyAKCQljb3VudGVyLWluY3JlbWVudDogY21ka2V5OyAKCQl9Cgk8L3N0eWxlPjwvaGVhZD48 Ym9keT4KCgk8dWw+CgkJPGxpPlRlc3Q8L2xpPgoJPC91bD4KCgo8L2JvZHk+PC9odG1sPg== 10717 2006-09-22 14:26:00 -0700 2006-09-25 13:04:43 -0700 Preliminary counter implementation posting.txt text/plain 69106 bdakin SW5kZXg6IGh0bWwvSFRNTERpcmVjdG9yeUVsZW1lbnQuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBodG1sL0hU TUxEaXJlY3RvcnlFbGVtZW50LmgJKHJldmlzaW9uIDE2NTI4KQorKysgaHRtbC9IVE1MRGlyZWN0 b3J5RWxlbWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNSw2ICszNSw3IEBACiAKICAgICB2aXJ0 dWFsIEhUTUxUYWdTdGF0dXMgZW5kVGFnUmVxdWlyZW1lbnQoKSBjb25zdCB7IHJldHVybiBUYWdT dGF0dXNSZXF1aXJlZDsgfQogICAgIHZpcnR1YWwgaW50IHRhZ1ByaW9yaXR5KCkgY29uc3QgeyBy ZXR1cm4gNTsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0RpcmVjdG9yeUVsZW1lbnQoKSBjb25zdCB7 IHJldHVybiB0cnVlOyB9CiAKICAgICBib29sIGNvbXBhY3QoKSBjb25zdDsKICAgICB2b2lkIHNl dENvbXBhY3QoYm9vbCk7CkluZGV4OiBodG1sL0hUTUxNZW51RWxlbWVudC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGh0bWwvSFRNTE1lbnVFbGVtZW50LmgJKHJldmlzaW9uIDE2NTI4KQorKysgaHRtbC9IVE1M TWVudUVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsNyBAQAogICAgIAogICAg IHZpcnR1YWwgSFRNTFRhZ1N0YXR1cyBlbmRUYWdSZXF1aXJlbWVudCgpIGNvbnN0IHsgcmV0dXJu IFRhZ1N0YXR1c1JlcXVpcmVkOyB9CiAgICAgdmlydHVhbCBpbnQgdGFnUHJpb3JpdHkoKSBjb25z dCB7IHJldHVybiA1OyB9CisgICAgdmlydHVhbCBib29sIGlzTWVudUVsZW1lbnQoKSBjb25zdCB7 IHJldHVybiB0cnVlOyB9CiAKICAgICBib29sIGNvbXBhY3QoKSBjb25zdDsKICAgICB2b2lkIHNl dENvbXBhY3QoYm9vbCk7CkluZGV4OiBodG1sL0hUTUxVTGlzdEVsZW1lbnQuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBodG1sL0hUTUxVTGlzdEVsZW1lbnQuaAkocmV2aXNpb24gMTY1MjgpCisrKyBodG1sL0hU TUxVTGlzdEVsZW1lbnQuaAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiArMzgsNyBAQAogCiAgICAg dmlydHVhbCBib29sIG1hcFRvRW50cnkoY29uc3QgUXVhbGlmaWVkTmFtZSYsIE1hcHBlZEF0dHJp YnV0ZUVudHJ5JikgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHBhcnNlTWFwcGVkQXR0cmlidXRl KE1hcHBlZEF0dHJpYnV0ZSopOworICAgIHZpcnR1YWwgYm9vbCBpc1Vub3JkZXJlZExpc3RFbGVt ZW50KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQogCiAgICAgYm9vbCBjb21wYWN0KCkgY29uc3Q7 CiAgICAgdm9pZCBzZXRDb21wYWN0KGJvb2wpOwpJbmRleDogaHRtbC9IVE1MT0xpc3RFbGVtZW50 LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gaHRtbC9IVE1MT0xpc3RFbGVtZW50LmgJKHJldmlzaW9uIDE2NTI4 KQorKysgaHRtbC9IVE1MT0xpc3RFbGVtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTM4LDYgKzM4 LDcgQEAKIAogICAgIHZpcnR1YWwgYm9vbCBtYXBUb0VudHJ5KGNvbnN0IFF1YWxpZmllZE5hbWUm LCBNYXBwZWRBdHRyaWJ1dGVFbnRyeSYpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBwYXJzZU1h cHBlZEF0dHJpYnV0ZShNYXBwZWRBdHRyaWJ1dGUqKTsKKyAgICB2aXJ0dWFsIGJvb2wgaXNPcmRl cmVkTGlzdEVsZW1lbnQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CiAKICAgICBib29sIGNvbXBh Y3QoKSBjb25zdDsKICAgICB2b2lkIHNldENvbXBhY3QoYm9vbCk7CkluZGV4OiByZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNw cAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xs IChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChr b2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVl bGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNl biAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiBB cHBsZSBDb21wdXRlciwgSW5jLgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTI5LDYgKzMwLDggQEAKICNpbmNs dWRlICJBWE9iamVjdENhY2hlLmgiIAogI2luY2x1ZGUgIkFmZmluZVRyYW5zZm9ybS5oIgogI2lu Y2x1ZGUgIkNhY2hlZEltYWdlLmgiCisjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKKyNpbmNsdWRl ICJDb3VudGVyUmVzZXROb2RlLmgiCiAjaW5jbHVkZSAiRGVjb2Rlci5oIgogI2luY2x1ZGUgIkRv Y3VtZW50LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgpAQCAtMTU5LDYgKzE2Miw3IEBACiBtX3Bh cmVudCggMCApLAogbV9wcmV2aW91cyggMCApLAogbV9uZXh0KCAwICksCittX2NvdW50ZXJMaXN0 KCAwICksCiBtX3ZlcnRpY2FsUG9zaXRpb24oIFBvc2l0aW9uVW5kZWZpbmVkICksCiBtX25lZWRz TGF5b3V0KCBmYWxzZSApLAogbV9ub3JtYWxDaGlsZE5lZWRzTGF5b3V0KCBmYWxzZSApLApAQCAt MjM5NSw2ICsyMzk5LDggQEAKIAogdm9pZCBSZW5kZXJPYmplY3Q6OmRlc3Ryb3koKQogeworICAg IGRlc3Ryb3lDb3VudGVycygpOworICAgIAogICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUo KS0+cmVtb3ZlKHRoaXMpOwogCiAgICAgLy8gQnkgZGVmYXVsdCBubyByZWYtY291bnRpbmcuIFJl bmRlcldpZGdldDo6ZGVzdHJveSgpIGRvZXNuJ3QgY2FsbApAQCAtMjgzNyw2ICsyODQzLDE3NCBA QAogICAgIHJldHVybiAoYXZvaWRzRmxvYXRzKCkgJiYgKHN0eWxlKCktPndpZHRoKCkuaXNBdXRv KCkgfHwgaXNIUigpIHx8IChzdHlsZSgpLT5odG1sSGFja3MoKSAmJiAhaXNUYWJsZSgpKSkpOwog fQogCitib29sIFJlbmRlck9iamVjdDo6aGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGNvdW50ZXIp IGNvbnN0Cit7CisgICAgaWYgKHN0eWxlKCkpCisgICAgICAgIGlmIChsb29rdXBDb3VudGVyKGNv dW50ZXIpIHx8IHN0eWxlKCktPmhhc0NvdW50ZXJSZXNldChjb3VudGVyKSB8fCAKKyAgICAgICAg ICAgICAgICBzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50ZXIpKQorICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgaWYgKGNvdW50ZXIgPT0gImxpc3QtaXRlbSIpCisg ICAgICAgIGlmIChpc0xpc3RJdGVtKCkgfHwgKGVsZW1lbnQoKSAmJiAoCisgICAgICAgICAgICAg ICAgZWxlbWVudCgpLT5pc09yZGVyZWRMaXN0RWxlbWVudCgpIHx8CisgICAgICAgICAgICAgICAg ZWxlbWVudCgpLT5pc1Vub3JkZXJlZExpc3RFbGVtZW50KCkgfHwKKyAgICAgICAgICAgICAgICBl bGVtZW50KCktPmlzTWVudUVsZW1lbnQoKSB8fAorICAgICAgICAgICAgICAgIGVsZW1lbnQoKS0+ aXNEaXJlY3RvcnlFbGVtZW50KCkpKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAg cmV0dXJuIGZhbHNlOworfQorCitDb3VudGVyTm9kZSogUmVuZGVyT2JqZWN0OjpnZXRDb3VudGVy KGNvbnN0IFN0cmluZyYgY291bnRlciwgYm9vbCB2aWV3LCBib29sIGNvdW50ZXJzKQoreworICAg IGlmICghc3R5bGUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBpbnQgdmFsID0gMDsKKyAg ICBDb3VudGVyTm9kZSAqbmV3Tm9kZSA9IGxvb2t1cENvdW50ZXIoY291bnRlcik7CisgICAgaWYg KG5ld05vZGUpCisgICAgICAgIHJldHVybiBuZXdOb2RlOworCisgICAgaWYgKHN0eWxlKCktPmhh c0NvdW50ZXJSZXNldChjb3VudGVyKSB8fCBpc1Jvb3QoKSkgeworICAgICAgICBuZXdOb2RlID0g bmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgIHZhbCA9IHN0eWxlKCktPmNvdW50 ZXJSZXNldChjb3VudGVyKTsKKyAgICAgICAgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1l bnQoY291bnRlcikpCisgICAgICAgICAgICB2YWwgKz0gc3R5bGUoKS0+Y291bnRlckluY3JlbWVu dChjb3VudGVyKTsKKyAgICB9IGVsc2UgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQo Y291bnRlcikpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAg ICAgICAgdmFsICs9IHN0eWxlKCktPmNvdW50ZXJJbmNyZW1lbnQoY291bnRlcik7CisgICAgfSBl bHNlIGlmIChjb3VudGVyID09ICJsaXN0LWl0ZW0iKSB7CisgICAgICAgIGlmIChpc0xpc3RJdGVt KCkpIHsKKyAgICAgICAgICAgIGlmIChlbGVtZW50KCkpIHsKKyAgICAgICAgICAgICAgICBTdHJp bmcgdiA9IHN0YXRpY19jYXN0PEVsZW1lbnQqPihlbGVtZW50KCkpLT5nZXRBdHRyaWJ1dGUoInZh bHVlIik7CisgICAgICAgICAgICAgICAgaWYgKCF2LmlzRW1wdHkoKSkgeworICAgICAgICAgICAg ICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAg ICAgICAgICAgIHZhbCA9IHYudG9JbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICB9IAorICAgICAgICAgICAgCisgICAgICAgICAgICBpZiAoIW5ld05vZGUpIHsKKyAgICAgICAg ICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKHRoaXMpOworICAgICAgICAgICAgICAg IHZhbCA9IDE7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoZWxlbWVudCgpICYm IGVsZW1lbnQoKS0+aXNPcmRlcmVkTGlzdEVsZW1lbnQoKSkgeworICAgICAgICAgICAgbmV3Tm9k ZSA9IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgU3RyaW5nIHYgPSBz dGF0aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0QXR0cmlidXRlKCJzdGFydCIpOwor ICAgICAgICAgICAgaWYgKCF2LmlzRW1wdHkoKSkKKyAgICAgICAgICAgICAgICB2YWwgPSB2LnRv SW50KCkgLSAxOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHZhbCA9IDA7Cisg ICAgICAgIH0gZWxzZSBpZiAoZWxlbWVudCgpICYmCisgICAgICAgICAgICAoZWxlbWVudCgpLT5p c1Vub3JkZXJlZExpc3RFbGVtZW50KCkgfHwKKyAgICAgICAgICAgICBlbGVtZW50KCktPmlzTWVu dUVsZW1lbnQoKSB8fAorICAgICAgICAgICAgIGVsZW1lbnQoKS0+aXNEaXJlY3RvcnlFbGVtZW50 KCkpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7 CisgICAgICAgICAgICB2YWwgPSAwOworICAgICAgICB9CisgICAgfSAKKyAgICAKKyAgICBpZiAo IW5ld05vZGUpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAg ICAgICAgdmFsID0gMDsKKyAgICB9CisgICAgCisgICAgbmV3Tm9kZS0+c2V0VmFsdWUodmFsKTsK KyAgICBpZiAodmlldykKKyAgICAgICAgbmV3Tm9kZS0+c2V0SXNWaXN1YWwoKTsKKyAgICBpZiAo Y291bnRlcnMpCisgICAgICAgIG5ld05vZGUtPnNldEhhc0NvdW50ZXJzKCk7CisKKyAgICBpbnNl cnRDb3VudGVyKGNvdW50ZXIsIG5ld05vZGUpOworCisgICAgaWYgKCFpc1Jvb3QoKSkgeworICAg ICAgICBDb3VudGVyTm9kZSogbGFzdCA9IDA7CisgICAgICAgIENvdW50ZXJOb2RlKiBjdXJyZW50 ID0gMDsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiBuID0gIWlzTGlzdEl0ZW0oKSAmJiBwcmV2aW91 c1NpYmxpbmcoKSA/IAorICAgICAgICAgICAgcHJldmlvdXNTaWJsaW5nKCktPnByZXZpb3VzU2li bGluZygpIDogcHJldmlvdXNTaWJsaW5nKCk7CisKKyAgICAgICAgd2hpbGUgKG4pIHsKKyAgICAg ICAgICAgIGlmIChuLT5oYXNDb3VudGVyKGNvdW50ZXIpKSB7CisgICAgICAgICAgICAgICAgY3Vy cmVudCA9IG4tPmdldENvdW50ZXIoY291bnRlcik7CisgICAgICAgICAgICAgICAgYnJlYWs7Cisg ICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBuID0gbi0+cHJldmlvdXNTaWJsaW5n KCk7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAg ICBDb3VudGVyTm9kZSogc2libGluZyA9IGN1cnJlbnQ7CisgICAgICAgIGlmIChsYXN0ICYmICFu ZXdOb2RlLT5pc1Jlc2V0KCkpIHsKKyAgICAgICAgICAgIC8vIEZvdW5kIHJlbmRlci1zaWJsaW5n LCBub3cgc2VhcmNoIGZvciBsYXRlciBjb3VudGVyLXNpYmxpbmdzIGFtb25nIGl0cyByZW5kZXIt Y2hpbGRyZW4KKyAgICAgICAgICAgIG4gPSBuLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgIHdo aWxlIChuKSB7CisgICAgICAgICAgICAgICAgaWYgKG4tPmhhc0NvdW50ZXIoY291bnRlcikpIHsK KyAgICAgICAgICAgICAgICAgICAgY3VycmVudCA9IG4tPmdldENvdW50ZXIoY291bnRlcik7Cisg ICAgICAgICAgICAgICAgICAgIGlmIChsYXN0LT5wYXJlbnQoKSA9PSBjdXJyZW50LT5wYXJlbnQo KSB8fCBzaWJsaW5nID09IGN1cnJlbnQtPnBhcmVudCgpKSB7CisgICAgICAgICAgICAgICAgICAg ICAgICBsYXN0ID0gY3VycmVudDsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIElmIHRoZSBj dXJyZW50IGNvdW50ZXIgaXMgbm90IHRoZSBsYXN0LCBzZWFyY2ggZGVlcGVyCisgICAgICAgICAg ICAgICAgICAgICAgICBpZiAoY3VycmVudC0+bmV4dFNpYmxpbmcoKSkgeworICAgICAgICAgICAg ICAgICAgICAgICAgICAgIG4gPSBuLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICAgICAgICAgIH0gZWxzZQorICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIG4gPSBuLT5wcmV2aW91c1NpYmxpbmcoKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKHNpYmxpbmctPmlz UmVzZXQoKSkgeworICAgICAgICAgICAgICAgIGlmIChsYXN0ICE9IHNpYmxpbmcpCisgICAgICAg ICAgICAgICAgICAgIHNpYmxpbmctPmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgc2libGluZy0+aW5zZXJ0QWZ0ZXIo bmV3Tm9kZSwgMCk7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBsYXN0LT5w YXJlbnQoKS0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7CisgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICAvLyBOb3RoaW5nIGZvdW5kIGFtb25nIHNpYmxpbmdzLCBsZXQgb3VyIHBhcmVu dCBzZWFyY2gKKyAgICAgICAgICAgIGxhc3QgPSBwYXJlbnQoKS0+Z2V0Q291bnRlcihjb3VudGVy LCBmYWxzZSk7CisgICAgICAgICAgICBpZiAobGFzdC0+aXNSZXNldCgpKQorICAgICAgICAgICAg ICAgIGxhc3QtPmluc2VydEFmdGVyKG5ld05vZGUsIDApOworICAgICAgICAgICAgZWxzZQorICAg ICAgICAgICAgICAgIGxhc3QtPnBhcmVudCgpLT5pbnNlcnRBZnRlcihuZXdOb2RlLCBsYXN0KTsK KyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBuZXdOb2RlOworfQorCitDb3VudGVyTm9k ZSogUmVuZGVyT2JqZWN0Ojpsb29rdXBDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlcikgY29u c3QKK3sKKyAgICBDb3VudGVyTGlzdCogaSA9IG1fY291bnRlckxpc3Q7CisgICAgd2hpbGUgKGkp IHsKKyAgICAgICAgaWYgKGktPmNvdW50ZXIgPT0gY291bnRlcikKKyAgICAgICAgICAgIHJldHVy biBpLT5tX2NvdW50ZXJOb2RlOworICAgICAgICBpID0gaS0+bmV4dDsKKyAgICB9CisgICAgcmV0 dXJuIDA7Cit9CisKK3ZvaWQgUmVuZGVyT2JqZWN0OjpkZXN0cm95Q291bnRlcnMoKQoreworICAg IENvdW50ZXJMaXN0KiBqOworICAgIENvdW50ZXJMaXN0KiBpID0gbV9jb3VudGVyTGlzdDsKKyAg ICBtX2NvdW50ZXJMaXN0ID0gMDsKKyAgICB3aGlsZSAoaSkgeworICAgICAgICBpLT5tX2NvdW50 ZXJOb2RlLT5yZW1vdmUoKTsKKyAgICAgICAgZGVsZXRlIGktPm1fY291bnRlck5vZGU7CisgICAg ICAgIGogPSBpOworICAgICAgICBpID0gaS0+bmV4dDsKKyAgICAgICAgZGVsZXRlIGo7CisgICAg fQorfQorCit2b2lkIFJlbmRlck9iamVjdDo6aW5zZXJ0Q291bnRlcihjb25zdCBTdHJpbmcmIGNv dW50ZXIsIENvdW50ZXJOb2RlKiB2YWwpCit7CisgICAgQ291bnRlckxpc3QqIGkgPSBuZXcgQ291 bnRlckxpc3Q7CisgICAgaS0+Y291bnRlciA9IGNvdW50ZXI7CisgICAgaS0+bV9jb3VudGVyTm9k ZSA9IHZhbDsKKyAgICBpLT5uZXh0ID0gbV9jb3VudGVyTGlzdDsKKyAgICBtX2NvdW50ZXJMaXN0 ID0gaTsKK30KKwogVUNoYXIgUmVuZGVyT2JqZWN0OjpiYWNrc2xhc2hBc0N1cnJlbmN5U3ltYm9s KCkgY29uc3QKIHsKICAgICBpZiAoTm9kZSAqbm9kZSA9IGVsZW1lbnQoKSkKSW5kZXg6IHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyT2JqZWN0 LmgJKHJldmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCSh3b3JraW5n IGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0IChDKSAyMDAwIExhcnMgS25vbGwg KGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgQW50dGkgS29pdmlzdG8gKGtv aXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgRGlyayBNdWVsbGVyIChtdWVs bGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2Vu IChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA0LCAyMDA1LCAy MDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtNTQsNiArNTUsNyBAQAog Y2xhc3MgSFRNTEFyZWFFbGVtZW50OwogY2xhc3MgSW5saW5lQm94OwogY2xhc3MgSW5saW5lRmxv d0JveDsKK2NsYXNzIENvdW50ZXJOb2RlOwogY2xhc3MgUG9zaXRpb247CiBjbGFzcyBSZW5kZXJB cmVuYTsKIGNsYXNzIFJlbmRlckJsb2NrOwpAQCAtMTkyLDYgKzE5NCwxNSBAQAogICAgIHZpcnR1 YWwgaW50IHN0YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBpbnQgc3Rh dGljWSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAgICBib29sIGhhc0NvdW50ZXIoY29u c3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdDsKKyAgICBDb3VudGVyTm9kZSogZ2V0Q291bnRlcihj b25zdCBTdHJpbmcmIGNvdW50ZXIsIGJvb2wgdmlldyA9IGZhbHNlLCBib29sIGNvdW50ZXJzID0g ZmFsc2UpOworICAgIHZvaWQgZGVzdHJveUNvdW50ZXJzKCk7CisKK3Byb3RlY3RlZDoKKyAgICB2 b2lkIGluc2VydENvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyLCBDb3VudGVyTm9kZSogdmFs dWUpOworICAgIENvdW50ZXJOb2RlKiBsb29rdXBDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRl cikgY29uc3Q7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJlZSBtYW5pcHVsYXRp b24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAgICB2 aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTMsNiArMjY0LDcgQEAK ICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9 CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9 CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlzQm9keSgpIGNvbnN0OwpAQCAt OTAyLDYgKzkxNCwxMiBAQAogICAgIFJlbmRlck9iamVjdCAqbV9wYXJlbnQ7CiAgICAgUmVuZGVy T2JqZWN0ICptX3ByZXZpb3VzOwogICAgIFJlbmRlck9iamVjdCAqbV9uZXh0OworICAgIAorICAg IHN0cnVjdCBDb3VudGVyTGlzdCB7CisgICAgICAgIFN0cmluZyBjb3VudGVyOworICAgICAgICBD b3VudGVyTm9kZSAqbV9jb3VudGVyTm9kZTsKKyAgICAgICAgQ291bnRlckxpc3QgKm5leHQ7Cisg ICAgfSAqbV9jb3VudGVyTGlzdDsKIAogICAgIG11dGFibGUgc2hvcnQgbV92ZXJ0aWNhbFBvc2l0 aW9uOwogCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJl bmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvUmVuZGVy Q291bnRlci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU2IEBACisvKgorICogVGhpcyBmaWxl IGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENv cHlyaWdodCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20p CisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAs CisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKyNpZm5kZWYgUkVOREVS X0NPVU5URVJfSF8KKyNkZWZpbmUgUkVOREVSX0NPVU5URVJfSF8KKworI2luY2x1ZGUgIkRlcHJl Y2F0ZWRTdHJpbmcuaCIKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K KworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0Cit7CitwdWJsaWM6Cisg ICAgUmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRlcik7CisgICAg dmlydHVhbCB+UmVuZGVyQ291bnRlcigpIHt9OworCisgICAgdmlydHVhbCBjb25zdCBjaGFyKiBy ZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4gIlJlbmRlckNvdW50ZXIiOyB9CisKKyAgICB2aXJ0 dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorICAgIHZpcnR1YWwg dm9pZCBsYXlvdXQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgY2FsY01pbk1heFdpZHRoKCk7CisKK3By b3RlY3RlZDoKKyAgICBEZXByZWNhdGVkU3RyaW5nIHRvTGlzdFN0eWxlVHlwZShpbnQgdmFsdWUs IGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSk7CisKKyAgICBEZXByZWNhdGVkU3RyaW5n IG1faXRlbTsKKyAgICBDb3VudGVyRGF0YSogbV9jb3VudGVyOworICAgIENvdW50ZXJOb2RlKiBt X2NvdW50ZXJOb2RlOworfTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRl cmluZy9Db3VudGVyUmVzZXROb2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJS ZXNldE5vZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjQgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBv ZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChD KSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHly aWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3Rv biwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZuZGVmIF9Db3VudGVyX1Jlc2V0X05v ZGVfaF8KKyNkZWZpbmUgX0NvdW50ZXJfUmVzZXRfTm9kZV9oXworCisjaW5jbHVkZSAiQ291bnRl ck5vZGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBUaGlzIGZpbGUgaW1wbGVtZW50 cyBhIGNvdW50ZXItdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgYWxsIHBhcmVudHMgaW4g Y291bnRlcnMoKSBsb29rdXAsCisvLyBhbmQgZm9yIHByb3BhZ2F0aW5nIGNvdW50LWNoYW5nZXMg d2hlbiBub2RlcyBhcmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8vIFBsZWFzZSBub3RlIHRoYXQgb25s eSBjb3VudGVyLXJlc2V0IGFuZCByb290IGNhbiBiZSBwYXJlbnRzIGhlcmUsIGFuZCB0aGF0IHJl bmRlci10cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0IGNvdW50ZXItdHJlZSBzaWJsaW5ncworCisv LyBJbXBsZW1lbnRhdGlvbiBvZiBjb3VudGVyLXJlc2V0IGFuZCByb290CitjbGFzcyBDb3VudGVy UmVzZXROb2RlIDogcHVibGljIENvdW50ZXJOb2RlCit7CitwdWJsaWM6CisgICAgQ291bnRlclJl c2V0Tm9kZShSZW5kZXJPYmplY3QqIG8pOworICAgIHZpcnR1YWwgfkNvdW50ZXJSZXNldE5vZGUo KTsKKworICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVy biBtX2ZpcnN0OyB9OworICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIGxhc3RDaGlsZCgpIGNvbnN0 IHsgcmV0dXJuIG1fbGFzdDsgfTsKKyAgICB2aXJ0dWFsIHZvaWQgaW5zZXJ0QWZ0ZXIgKENvdW50 ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKTsKKyAgICB2aXJ0dWFsIHZv aWQgcmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGlsZCk7CisKKyAgICB2aXJ0dWFsIGJv b2wgaXNSZXNldCgpIHsgcmV0dXJuIHRydWU7IH07CisgICAgdmlydHVhbCB2b2lkIHJlY291bnQo Ym9vbCBmaXJzdCA9IGZhbHNlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7Cisg ICAgdmlydHVhbCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisKKyAgICB2b2lkIHVwZGF0ZVRvdGFs KGludCB2YWx1ZSk7CisgICAgLy8gVGhlIGhpZ2hlc3QgdmFsdWUgYW1vbmcgY2hpbGRyZW4KKyAg ICBpbnQgdG90YWwoKSBjb25zdCB7IHJldHVybiBtX3RvdGFsOyB9OworCitwcm90ZWN0ZWQ6Cisg ICAgaW50IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAgQ291bnRlck5v ZGUqIG1fbGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENv dW50ZXJSZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKKysrIHJl bmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MyBAQAor LyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRpb24gZm9yIEtE RS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVA Y2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMu CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0 bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNl IC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisg CisjaWZuZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0SXRlbV9ICisK KyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2Ns YXNzIENvdW50ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVyTm9kZQoreworcHVibGljOgorICAg IGludCBjb3VudCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBmaXJz dCA9IGZhbHNlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisKK307CisKK30g Ly9uYW1lc3BhY2UKKworI2VuZGlmClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpJbmRleDog cmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5k ZXJDb3VudGVyLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNw cAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMjYgQEAKKy8qKgorICogVGhpcyBmaWxlIGlzIHBh cnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdo dCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBD b3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBt b2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv bjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVk IGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkg V0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hB TlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBH TlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgor ICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUg dGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBC b3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisjaW5jbHVkZSAiQ291bnRlclJlc2V0Tm9kZS5o IgorI2luY2x1ZGUgIlJlbmRlckNvdW50ZXIuaCIKKyNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgor Cit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitSZW5k ZXJDb3VudGVyOjpSZW5kZXJDb3VudGVyKE5vZGUqIG5vZGUsIENvdW50ZXJEYXRhKiBjb3VudGVy KQorICAgIDogUmVuZGVyVGV4dChub2RlLDApLCBtX2NvdW50ZXIoY291bnRlciksIG1fY291bnRl ck5vZGUoMCkKK3sKK30KKwordm9pZCBSZW5kZXJDb3VudGVyOjpsYXlvdXQoKQoreworICAgIEFT U0VSVChuZWVkc0xheW91dCgpKTsKKworICAgIGlmICghbWluTWF4S25vd24oKSkKKyAgICAgICAg Y2FsY01pbk1heFdpZHRoKCk7CisKKyAgICBSZW5kZXJUZXh0OjpsYXlvdXQoKTsKK30KKworY29u c3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworc3RhdGljIERlcHJlY2F0ZWRTdHJpbmcgdG9S b21hbihpbnQgbnVtYmVyLCBib29sIHVwcGVyKQoreyAKKyAgICBEZXByZWNhdGVkU3RyaW5nIHJv bWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAndicsICd4JywgJ2wnLCAn YycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1tdID0geyAnSScsICdWJywg J1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hhciogZGlnaXRzID0gdXBw ZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8geworICAgICAg ICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkKKyAgICAg ICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQorICAgICAgICAgICAgICAg IHJvbWFuLmluc2VydCgwLCBkaWdpdHNbZF0pOworICAgICAgICBpZiAobnVtID49IDQgJiYgbnVt IDw9IDgpCisgICAgICAgICAgICByb21hbi5pbnNlcnQoMCwgZGlnaXRzW2QgKyAxXSk7CisgICAg ICAgIGlmIChudW0gPT0gOSkKKyAgICAgICAgICAgIHJvbWFuLmluc2VydCgwLCBkaWdpdHNbZCAr IDJdKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAgICAgICAgICAgIHJvbWFuLmluc2Vy dCgwLCBkaWdpdHNbZF0pOworICAgICAgICBudW1iZXIgLz0gMTA7CisgICAgICAgIGQgKz0gMjsK KyAgICB9IHdoaWxlIChudW1iZXIpOworICAgIHJldHVybiByb21hbjsKK30KKworc3RhdGljIERl cHJlY2F0ZWRTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJlciwgaW50IGxldHRlckEpCit7 CisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVybiBEZXByZWNhdGVkQ2hhcihsZXR0 ZXJBKTsgLy8gbWF0Y2ggV2luSUUgKEEuKSBub3QgRmlyZUZveCAoMC4pCisKKyAgICBEZXByZWNh dGVkU3RyaW5nIGxldHRlclN0cmluZzsKKyAgICB3aGlsZSAobnVtYmVyID4gMCkgeworICAgICAg ICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7CisgICAgICAgIGxldHRlclN0cmlu ZyA9IERlcHJlY2F0ZWRDaGFyKGxldHRlckEgKyBvbmVzRGlnaXQpICsgbGV0dGVyU3RyaW5nOwor ICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0OworICAgICAgICBudW1iZXIgLz0gMjY7CisgICAg fQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsKK30KKworc3RhdGljIERlcHJlY2F0ZWRTdHJp bmcgdG9IZWJyZXcoaW50IG51bWJlcikKK3sKKyAgICBpZiAobnVtYmVyIDwgMSkKKyAgICAgICAg cmV0dXJuIERlcHJlY2F0ZWRTdHJpbmc6Om51bWJlcihudW1iZXIpOworICAgIAorICAgIHN0YXRp YyBjb25zdCBEZXByZWNhdGVkQ2hhciB0ZW5EaWdpdFtdID0gezE0OTcsIDE0OTksIDE1MDAsIDE1 MDIsIDE1MDQsIDE1MDUsIDE1MDYsIDE1MDgsIDE1MTB9OworCisgICAgRGVwcmVjYXRlZFN0cmlu ZyBsZXR0ZXI7CisgICAgaWYgKG51bWJlciA+IDk5OSkgeworICAgICAgICBsZXR0ZXIgPSB0b0hl YnJldyhudW1iZXIgLyAxMDAwKSArICInIjsKKyAgICAgICAgbnVtYmVyID0gbnVtYmVyICUgMTAw MDsKKyAgICB9CisgICAgaW50IGZvdXJIdW5kcmVkcyA9IG51bWJlciAvIDQwMDsKKyAgICBmb3Ig KGludCBpID0gMDsgaSA8IGZvdXJIdW5kcmVkczsgaSsrKQorICAgICAgICBsZXR0ZXIgKz0gRGVw cmVjYXRlZENoYXIoMTUxMSArIDMpOworICAgIG51bWJlciAlPSA0MDA7CisgICAgaWYgKG51bWJl ciAvIDEwMCkKKyAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRDaGFyKDE1MTEgKyAobnVtYmVy IC8gMTAwKSAtIDEpOworICAgIG51bWJlciAlPSAxMDA7CisgICAgaWYgKG51bWJlciA9PSAxNSB8 fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRDaGFyKDE0ODcg KyA5KTsKKyAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRDaGFyKDE0ODcgKyBudW1iZXIgLSA5 KTsKKyAgICB9IGVsc2UgeworICAgICAgICBpbnQgdGVucyA9IG51bWJlciAvIDEwOworICAgICAg ICBpZiAodGVucykKKyAgICAgICAgICAgIGxldHRlciArPSB0ZW5EaWdpdFt0ZW5zIC0gMV07Cisg ICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAgICBpZiAobnVtYmVyKQorICAgICAg ICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRDaGFyKDE0ODcgKyBudW1iZXIpOworICAgIH0KKyAg ICByZXR1cm4gbGV0dGVyOworfQorCitEZXByZWNhdGVkU3RyaW5nIFJlbmRlckNvdW50ZXI6OnRv TGlzdFN0eWxlVHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSkK K3sKKyAgICBEZXByZWNhdGVkU3RyaW5nIGl0ZW07CisgICAgc3dpdGNoKHR5cGUpIHsKKyAgICAg ICAgY2FzZSBMTk9ORToKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICAvLyBHbHlwaHM6Cisg ICAgICAgIGNhc2UgRElTQzoKKyAgICAgICAgICAgIGl0ZW0gPSBEZXByZWNhdGVkQ2hhcigweDIw MjIpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgQ0lSQ0xFOgorICAgICAgICAg ICAgaXRlbSA9IERlcHJlY2F0ZWRDaGFyKDB4MjVlNik7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBpdGVtID0gRGVwcmVjYXRlZENoYXIoMHgy NWEwKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIEFSTUVOSUFOOgorICAgICAg ICBjYXNlIEdFT1JHSUFOOgorICAgICAgICBjYXNlIENKS19JREVPR1JBUEhJQzoKKyAgICAgICAg Y2FzZSBISVJBR0FOQToKKyAgICAgICAgY2FzZSBLQVRBS0FOQToKKyAgICAgICAgY2FzZSBISVJB R0FOQV9JUk9IQToKKyAgICAgICAgY2FzZSBLQVRBS0FOQV9JUk9IQToKKyAgICAgICAgY2FzZSBE RUNJTUFMX0xFQURJTkdfWkVSTzoKKyAgICAgICAgICAgIC8vICMjIyB1bnN1cHBvcnRlZCwgd2Ug dXNlIGRlY2ltYWwgaW5zdGVhZAorICAgICAgICBjYXNlIExERUNJTUFMOgorICAgICAgICAgICAg aXRlbS5zZXROdW0odmFsdWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIC8vIEFsZ29y aXRtaWM6CisgICAgICAgIGNhc2UgTE9XRVJfUk9NQU46CisgICAgICAgICAgICBpdGVtID0gdG9S b21hbih2YWx1ZSwgZmFsc2UpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQ RVJfUk9NQU46CisgICAgICAgICAgICBpdGVtID0gdG9Sb21hbih2YWx1ZSwgdHJ1ZSk7CisgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBMT1dFUl9HUkVFSzogeworICAgICAgICAgICAg aW50IG51bWJlciA9IHZhbHVlIC0gMTsKKyAgICAgICAgICAgIGludCBsID0gKG51bWJlciAlIDI0 KTsKKyAgICAgICAgICAgIGlmIChsID4gMTYpCisgICAgICAgICAgICAgICAgbCsrOyAvLyBTa2lw IEdSRUVLIFNNQUxMIExFVFRFUiBGSU5BTCBTSUdNQQorICAgICAgICAgICAgaXRlbSA9IERlcHJl Y2F0ZWRDaGFyKDk0NSArIGwpOworICAgICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCAobnVt YmVyIC8gMjQpOyBpKyspCisgICAgICAgICAgICAgICAgaXRlbSArPSAiJyI7CisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgfQorICAgICAgICBjYXNlIEhFQlJFVzoKKyAgICAgICAgICAgIGl0 ZW0gPSB0b0hlYnJldyh2YWx1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBM T1dFUl9BTFBIQToKKyAgICAgICAgY2FzZSBMT1dFUl9MQVRJTjoKKyAgICAgICAgICAgIGl0ZW0g PSB0b0xldHRlclN0cmluZyh2YWx1ZSwgJ2EnKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAg ICBjYXNlIFVQUEVSX0FMUEhBOgorICAgICAgICBjYXNlIFVQUEVSX0xBVElOOgorICAgICAgICAg ICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVlLCAnQScpOworICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBpdGVtLnNldE51bSh2YWx1ZSk7CisgICAg ICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVy Q291bnRlcjo6Y2FsY01pbk1heFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkp OworCisgICAgaWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGNvdW50 ZXJzOworICAgIGNvdW50ZXJzID0gIW1fY291bnRlci0+c2VwYXJhdG9yKCkuaXNOdWxsKCk7CisK KyAgICBpZiAoIW1fY291bnRlck5vZGUgJiYgcGFyZW50KCktPnBhcmVudCgpKQorICAgICAgICBt X2NvdW50ZXJOb2RlID0gcGFyZW50KCktPnBhcmVudCgpLT5nZXRDb3VudGVyKG1fY291bnRlci0+ aWRlbnRpZmllcigpLCB0cnVlLCBjb3VudGVycyk7CisKKyAgICBpbnQgdmFsdWUgPSBtX2NvdW50 ZXJOb2RlLT5jb3VudCgpOworICAgIGlmIChtX2NvdW50ZXJOb2RlLT5pc1Jlc2V0KCkpCisgICAg ICAgIHZhbHVlID0gbV9jb3VudGVyTm9kZS0+dmFsdWUoKTsKKyAgICAKKyAgICBpbnQgdG90YWwg PSB2YWx1ZTsKKyAgICBpZiAobV9jb3VudGVyTm9kZS0+cGFyZW50KCkpCisgICAgICAgIHRvdGFs ID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCktPnRvdGFsKCk7CisgICAgCisgICAgbV9pdGVtID0g dG9MaXN0U3R5bGVUeXBlKHZhbHVlLCB0b3RhbCwgKEVMaXN0U3R5bGVUeXBlKW1fY291bnRlci0+ bGlzdFN0eWxlKCkpOworCisgICAgaWYgKGNvdW50ZXJzKSB7CisgICAgICAgIENvdW50ZXJOb2Rl KiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCk7CisgICAgICAgIGJvb2wgZmlyc3Qg PSB0cnVlOworICAgICAgICB3aGlsZSAgKGNvdW50ZXItPnBhcmVudCgpICYmIChmaXJzdCB8fCAh KGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3VudGVyLT5wYXJlbnQoKS0+aXNSb290KCkpKSkgewor ICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVyLT5jb3VudCgpID8gY291bnRlci0+Y291bnQoKSA6 IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNvdW50ZXItPnBhcmVudCgpLT50b3RhbCgpOworICAg ICAgICAgICAgbV9pdGVtID0gdG9MaXN0U3R5bGVUeXBlKHZhbHVlLCB0b3RhbCwgKEVMaXN0U3R5 bGVUeXBlKW1fY291bnRlci0+bGlzdFN0eWxlKCkpIAorICAgICAgICAgICAgICAgICsgbV9jb3Vu dGVyLT5zZXBhcmF0b3IoKS5kZXByZWNhdGVkU3RyaW5nKCkgKyBtX2l0ZW07CisgICAgICAgICAg ICBjb3VudGVyID0gY291bnRlci0+cGFyZW50KCk7CisgICAgICAgICAgICBmaXJzdCA9IGZhbHNl OworICAgICAgICB9CisgICAgfQorCisgICAgc3RyID0gbmV3IFN0cmluZ0ltcGwoKHN0YXRpY19j YXN0PFN0cmluZz4obV9pdGVtKSkuY2hhcmFjdGVycygpLCBtX2l0ZW0ubGVuZ3RoKCkpOworICAg IAorICAgIFJlbmRlclRleHQ6OmNhbGNNaW5NYXhXaWR0aCgpOworfQpJbmRleDogcmVuZGVyaW5n L0NvdW50ZXJOb2RlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvQ291bnRlck5vZGUuY3Bw CShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSw5NyBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJl bmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2 IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJDb3Vu dGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKyNpbmNsdWRlICJSZW5k ZXJPYmplY3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDb3VudGVyTm9kZTo6Q291bnRl ck5vZGUoUmVuZGVyT2JqZWN0ICpvKQorICAgIDogbV9oYXNDb3VudGVycyhmYWxzZSksIG1faXNW aXN1YWwoZmFsc2UpLAorICAgICAgbV92YWx1ZSgwKSwgbV9jb3VudCgwKSwgbV9wYXJlbnQoMCks IG1fcHJldmlvdXMoMCksIG1fbmV4dCgwKSwKKyAgICAgIG1fcmVuZGVyZXIobykge30KKworQ291 bnRlck5vZGU6On5Db3VudGVyTm9kZSgpIHt9OworCit2b2lkIENvdW50ZXJOb2RlOjppbnNlcnRB ZnRlcihDb3VudGVyTm9kZSosIENvdW50ZXJOb2RlKikKK3sKKyAgICBBU1NFUlQoZmFsc2UpOwor fQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSopCit7CisgICAg QVNTRVJUKGZhbHNlKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6cmVtb3ZlKCkKK3sKKyAgICBp ZiAobV9wYXJlbnQpCisgICAgICAgIG1fcGFyZW50LT5yZW1vdmVDaGlsZCh0aGlzKTsKKyAgICBl bHNlIHsKKyAgICAgICAgQVNTRVJUKGlzUmVzZXQoKSk7CisgICAgICAgIEFTU0VSVCghZmlyc3RD aGlsZCgpKTsKKyAgICAgICAgQVNTRVJUKCFsYXN0Q2hpbGQoKSk7CisgICAgfQorfQorCit2b2lk IENvdW50ZXJOb2RlOjpzZXRIYXNDb3VudGVycygpCit7CisgICAgbV9oYXNDb3VudGVycyA9IHRy dWU7CisgICAgaWYgKHBhcmVudCgpKQorICAgICAgICBwYXJlbnQoKS0+c2V0SGFzQ291bnRlcnMo KTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6cmVjb3VudChib29sIGZpcnN0KQoreworICAgIGlu dCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3ByZXZpb3VzKQorICAgICAgICBtX2Nv dW50ID0gbV9wcmV2aW91cy0+Y291bnQoKSArIG1fdmFsdWU7CisgICAgZWxzZSB7CisgICAgICAg IGFzc2VydChtX3BhcmVudC0+Zmlyc3RDaGlsZCgpID09IHRoaXMpOworICAgICAgICBtX2NvdW50 ID0gbV9wYXJlbnQtPnZhbHVlKCkgKyBtX3ZhbHVlOworICAgIH0KKyAgICBpZiAob2xkX2NvdW50 ICE9IG1fY291bnQgJiYgIWZpcnN0KQorICAgICAgICBzZXRTZWxmRGlydHkoKTsKKyAgICBpZiAo b2xkX2NvdW50ICE9IG1fY291bnQgfHwgZmlyc3QpIHsKKyAgICAgICAgaWYgKG1fcGFyZW50KQor ICAgICAgICAgICAgbV9wYXJlbnQtPnVwZGF0ZVRvdGFsKG1fY291bnQpOworICAgICAgICBpZiAo bV9uZXh0KQorICAgICAgICAgICAgbV9uZXh0LT5yZWNvdW50KCk7CisgICAgfQorfQorCit2b2lk IENvdW50ZXJOb2RlOjpzZXRTZWxmRGlydHkoKQoreworICAgIGlmIChtX3JlbmRlcmVyICYmIG1f aXNWaXN1YWwpCisgICAgICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVj YWxjKCk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNldFBhcmVudERpcnR5KCkKK3sKKyAgICBp ZiAobV9yZW5kZXJlciAmJiBtX2lzVmlzdWFsICYmIG1faGFzQ291bnRlcnMpCisgICAgICAgIG1f cmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK30gLy8gbmFt ZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5k ZXJpbmcvUmVuZGVyU3R5bGUuaAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVy U3R5bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMzYsMTEgKzM2LDE0IEBACiAgKi8KIAogI2luY2x1 ZGUgIkNvbG9yLmgiCisjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFsdWUuaCIKKyNpbmNsdWRlICJD U1NWYWx1ZUxpc3QuaCIKICNpbmNsdWRlICJEYXRhUmVmLmgiCiAjaW5jbHVkZSAiRm9udC5oIgog I2luY2x1ZGUgIkdyYXBoaWNzVHlwZXMuaCIKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVk ZSAiTGVuZ3RoLmgiCisjaW5jbHVkZSAiUGFpci5oIgogI2luY2x1ZGUgIlNoYXJlZC5oIgogI2lu Y2x1ZGUgIlRleHREaXJlY3Rpb24uaCIKICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CkBAIC01OSw5 ICs2MiwxMSBAQAogCiB1c2luZyBzdGQ6Om1heDsKIAotY2xhc3MgQ1NTU3R5bGVTZWxlY3RvcjsK IGNsYXNzIENhY2hlZEltYWdlOwogY2xhc3MgQ2FjaGVkUmVzb3VyY2U7CitjbGFzcyBDU1NTdHls ZVNlbGVjdG9yOworY2xhc3MgQ1NTVmFsdWVMaXN0OworY2xhc3MgUGFpcjsKIGNsYXNzIFJlbmRl ckFyZW5hOwogY2xhc3MgU2hhZG93VmFsdWU7CiBjbGFzcyBTdHJpbmdJbXBsOwpAQCAtNDA3LDgg KzQxMiw4IEBACiAgICAgICAgIHJldHVybiAoIGNsaXAgPT0gby5jbGlwICYmCiAgICAgICAgICAg ICAgICAgIGhhc0NsaXAgPT0gby5oYXNDbGlwICYmCiAgICAgICAgICAgICAgICAgIGNvbHNwYW4g PT0gby5jb2xzcGFuICYmCi0gICAgICAgICAgICAgICAgIGNvdW50ZXJfaW5jcmVtZW50ID09IG8u Y291bnRlcl9pbmNyZW1lbnQgJiYKLSAgICAgICAgICAgICAgICAgY291bnRlcl9yZXNldCA9PSBv LmNvdW50ZXJfcmVzZXQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlckluY3JlbWVudCA9PSBv LmNvdW50ZXJJbmNyZW1lbnQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlclJlc2V0ID09IG8u Y291bnRlclJlc2V0ICYmCiAgICAgICAgICAgICAgICAgIHRleHREZWNvcmF0aW9uID09IG8udGV4 dERlY29yYXRpb24pOwogICAgIH0KICAgICBib29sIG9wZXJhdG9yIT0oIGNvbnN0IFN0eWxlVmlz dWFsRGF0YSAmbyApIGNvbnN0IHsKQEAgLTQyMSw4ICs0MjYsOCBAQAogICAgIAogICAgIHNob3J0 IGNvbHNwYW47IC8vIGZvciBodG1sLCBub3QgYSBjc3MyIGF0dHJpYnV0ZQogCi0gICAgc2hvcnQg Y291bnRlcl9pbmNyZW1lbnQ7IC8vb2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUgc3Bl c2lmaWMKLSAgICBzaG9ydCBjb3VudGVyX3Jlc2V0OyAgICAgLy9jYW4ndCBnbyB0byBpbmhlcml0 ZWQsIHNpbmNlIHRoZXNlIGFyZSBub3QgaW5oZXJpdGVkCisgICAgc2hvcnQgY291bnRlckluY3Jl bWVudDsgLy9vaywgc28gdGhlc2UgYXJlIG5vdCB2aXN1YWwgbW9kZSBzcGVzaWZpYworICAgIHNo b3J0IGNvdW50ZXJSZXNldDsgICAgIC8vY2FuJ3QgZ28gdG8gaW5oZXJpdGVkLCBzaW5jZSB0aGVz ZSBhcmUgbm90IGluaGVyaXRlZAogCiB9OwogCkBAIC04NzIsNiArODc3LDIwIEBACiAgICAgQ09O VEVOVF9OT05FLCBDT05URU5UX09CSkVDVCwgQ09OVEVOVF9URVhULCBDT05URU5UX0NPVU5URVIK IH07CiAKK3N0cnVjdCBDb3VudGVyRGF0YSB7CisgICAgQ291bnRlckRhdGEoKSB7fQorICAgIENv dW50ZXJEYXRhKFN0cmluZyBpLCBpbnQgbCwgU3RyaW5nIHNlcCkgOmlkZW50KGkpLCBscyhsKSwg cyhzZXApIHt9CisgICAgfkNvdW50ZXJEYXRhKCkge30KKyAgICAKKyAgICBTdHJpbmcgaWRlbnRp ZmllcigpIHsgcmV0dXJuIGlkZW50OyB9CisgICAgaW50IGxpc3RTdHlsZSgpIHsgcmV0dXJuIGxz OyB9CisgICAgU3RyaW5nIHNlcGFyYXRvcigpIHsgcmV0dXJuIHM7IH0KKworICAgIFN0cmluZyBp ZGVudDsKKyAgICBpbnQgbHM7CisgICAgU3RyaW5nIHM7Cit9OworCiBzdHJ1Y3QgQ29udGVudERh dGEgewogICAgIENvbnRlbnREYXRhKCkgOl9jb250ZW50VHlwZShDT05URU5UX05PTkUpLCBfbmV4 dENvbnRlbnQoMCkge30KICAgICB+Q29udGVudERhdGEoKTsKQEAgLTg4MSwxMyArOTAwLDE0IEBA CiAKICAgICBTdHJpbmdJbXBsKiBjb250ZW50VGV4dCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0g Q09OVEVOVF9URVhUKSByZXR1cm4gX2NvbnRlbnQudGV4dDsgcmV0dXJuIDA7IH0KICAgICBDYWNo ZWRSZXNvdXJjZSogY29udGVudE9iamVjdCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVO VF9PQkpFQ1QpIHJldHVybiBfY29udGVudC5vYmplY3Q7IHJldHVybiAwOyB9CisgICAgQ291bnRl ckRhdGEqIGNvbnRlbnRDb3VudGVyKCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5UX0NP VU5URVIpIHJldHVybiBfY29udGVudC5jb3VudGVyOyByZXR1cm4gMDsgfQogICAgIAogICAgIENv bnRlbnRUeXBlIF9jb250ZW50VHlwZTsKIAogICAgIHVuaW9uIHsKICAgICAgICAgQ2FjaGVkUmVz b3VyY2UqIG9iamVjdDsKICAgICAgICAgU3RyaW5nSW1wbCogdGV4dDsKLSAgICAgICAgLy8gY291 bnRlcnMuLi4KKyAgICAgICAgQ291bnRlckRhdGEqIGNvdW50ZXI7CiAgICAgfSBfY29udGVudCA7 CiAKICAgICBDb250ZW50RGF0YSogX25leHRDb250ZW50OwpAQCAtMTA0NSw3ICsxMDY1LDkgQEAK ICAgICAKICAgICAvLyBhZGRlZCB0aGlzIGhlcmUsIHNvIHdlIGNhbiBnZXQgcmlkIG9mIHRoZSB2 cHRyIGluIHRoaXMgY2xhc3MuCiAgICAgLy8gbWFrZXMgdXAgZm9yIHRoZSBzYW1lIHNpemUuCi0g ICAgQ29udGVudERhdGEgKmNvbnRlbnQ7CisgICAgQ29udGVudERhdGEqIGNvbnRlbnQ7CisgICAg Q1NTVmFsdWVMaXN0KiBjb3VudGVyUmVzZXRMaXN0OworICAgIENTU1ZhbHVlTGlzdCogY291bnRl ckluY3JlbWVudExpc3Q7CiAKICAgICB1bnNpZ25lZCBtX3BzZXVkb1N0YXRlIDogMzsgLy8gUHNl dWRvU3RhdGUKICAgICBib29sIG1fYWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyA6IDE7CkBA IC0xMjk1LDggKzEzMTcsOCBAQAogICAgIEVFbXB0eUNlbGwgZW1wdHlDZWxscygpIGNvbnN0IHsg cmV0dXJuIHN0YXRpY19jYXN0PEVFbXB0eUNlbGw+KGluaGVyaXRlZF9mbGFncy5fZW1wdHlfY2Vs bHMpOyB9CiAgICAgRUNhcHRpb25TaWRlIGNhcHRpb25TaWRlKCkgY29uc3QgeyByZXR1cm4gc3Rh dGljX2Nhc3Q8RUNhcHRpb25TaWRlPihpbmhlcml0ZWRfZmxhZ3MuX2NhcHRpb25fc2lkZSk7IH0K IAotICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNv dW50ZXJfaW5jcmVtZW50OyB9Ci0gICAgc2hvcnQgY291bnRlclJlc2V0KCkgY29uc3QgeyByZXR1 cm4gdmlzdWFsLT5jb3VudGVyX3Jlc2V0OyB9CisgICAgc2hvcnQgY291bnRlckluY3JlbWVudCgp IGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlckluY3JlbWVudDsgfQorICAgIHNob3J0IGNv dW50ZXJSZXNldCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlclJlc2V0OyB9CiAKICAg ICBFTGlzdFN0eWxlVHlwZSBsaXN0U3R5bGVUeXBlKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nh c3Q8RUxpc3RTdHlsZVR5cGU+KGluaGVyaXRlZF9mbGFncy5fbGlzdF9zdHlsZV90eXBlKTsgfQog ICAgIENhY2hlZEltYWdlICpsaXN0U3R5bGVJbWFnZSgpIGNvbnN0IHsgcmV0dXJuIGluaGVyaXRl ZC0+c3R5bGVfaW1hZ2U7IH0KQEAgLTE1MDEsOCArMTUyMyw4IEBACiAgICAgdm9pZCBzZXRDYXB0 aW9uU2lkZShFQ2FwdGlvblNpZGUgdikgeyBpbmhlcml0ZWRfZmxhZ3MuX2NhcHRpb25fc2lkZSA9 IHY7IH0KIAogCi0gICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50KHNob3J0IHYpIHsgIFNFVF9W QVIodmlzdWFsLGNvdW50ZXJfaW5jcmVtZW50LHYpIH0KLSAgICB2b2lkIHNldENvdW50ZXJSZXNl dChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVyX3Jlc2V0LHYpIH0KKyAgICB2b2lk IHNldENvdW50ZXJJbmNyZW1lbnQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1YWwsY291bnRlcklu Y3JlbWVudCx2KSB9CisgICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoc2hvcnQgdikgeyAgU0VUX1ZB Uih2aXN1YWwsY291bnRlclJlc2V0LHYpIH0KIAogICAgIHZvaWQgc2V0TGlzdFN0eWxlVHlwZShF TGlzdFN0eWxlVHlwZSB2KSB7IGluaGVyaXRlZF9mbGFncy5fbGlzdF9zdHlsZV90eXBlID0gdjsg fQogICAgIHZvaWQgc2V0TGlzdFN0eWxlSW1hZ2UoQ2FjaGVkSW1hZ2UgKnYpIHsgIFNFVF9WQVIo aW5oZXJpdGVkLHN0eWxlX2ltYWdlLHYpfQpAQCAtMTU5Nyw3ICsxNjE5LDE4IEBACiAgICAgYm9v bCBjb250ZW50RGF0YUVxdWl2YWxlbnQoY29uc3QgUmVuZGVyU3R5bGUgKm90aGVyU3R5bGUpIGNv bnN0OwogICAgIHZvaWQgc2V0Q29udGVudChTdHJpbmdJbXBsKiBzLCBib29sIGFkZCA9IGZhbHNl KTsKICAgICB2b2lkIHNldENvbnRlbnQoQ2FjaGVkUmVzb3VyY2UqIG8sIGJvb2wgYWRkID0gZmFs c2UpOworICAgIHZvaWQgc2V0Q29udGVudChDb3VudGVyRGF0YSogYywgYm9vbCBhZGQgPSBmYWxz ZSk7CiAKKyAgICBib29sIGNvdW50ZXJEYXRhRXF1aXZhbGVudChSZW5kZXJTdHlsZSogb3RoZXJT dHlsZSk7CisgICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoQ1NTVmFsdWVMaXN0KiB2KTsKKyAgICB2 b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoQ1NTVmFsdWVMaXN0KiB2KTsKKyAgICB2b2lkIGFkZENv dW50ZXJSZXNldChDU1NQcmltaXRpdmVWYWx1ZSogYyk7CisgICAgdm9pZCBhZGRDb3VudGVySW5j cmVtZW50KENTU1ByaW1pdGl2ZVZhbHVlKiBjKTsKKyAgICBib29sIGhhc0NvdW50ZXJSZXNldChj b25zdCBTdHJpbmcmIGMpIGNvbnN0OworICAgIGJvb2wgaGFzQ291bnRlckluY3JlbWVudChjb25z dCBTdHJpbmcmIGMpIGNvbnN0OworICAgIHNob3J0IGNvdW50ZXJSZXNldChjb25zdCBTdHJpbmcm IGMpIGNvbnN0OworICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjKSBj b25zdDsKKwogICAgIGJvb2wgaW5oZXJpdGVkTm90RXF1YWwoIFJlbmRlclN0eWxlICpvdGhlciAp IGNvbnN0OwogCiAgICAgLy8gVGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0d28gc3R5bGVzLiAgVGhl IGZvbGxvd2luZyB2YWx1ZXMgYXJlIHVzZWQ6CkluZGV4OiByZW5kZXJpbmcvQ291bnRlclJlc2V0 Tm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShy ZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDE1MyBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1M IHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxs YW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAy MDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICog dmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2 ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJ TkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjEx MS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJD b3VudGVyUmVzZXROb2RlLmgiCisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworQ291bnRlclJlc2V0Tm9kZTo6Q291bnRlclJlc2V0Tm9kZShSZW5kZXJP YmplY3QqIG8pIDogQ291bnRlck5vZGUobyksIG1fdG90YWwoMCksIG1fZmlyc3QoMCksIG1fbGFz dCgwKSB7fQorQ291bnRlclJlc2V0Tm9kZTo6fkNvdW50ZXJSZXNldE5vZGUoKSB7fTsKKwordm9p ZCBDb3VudGVyUmVzZXROb2RlOjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENv dW50ZXJOb2RlKiByZWZDaGlsZCkKK3sKKyAgICBBU1NFUlQobmV3Q2hpbGQpOworICAgIEFTU0VS VCghcmVmQ2hpbGQgfHwgcmVmQ2hpbGQtPnBhcmVudCgpID09IHRoaXMpOworCisgICAgbmV3Q2hp bGQtPm1fcGFyZW50ID0gdGhpczsKKyAgICBuZXdDaGlsZC0+bV9wcmV2aW91cyA9IHJlZkNoaWxk OworCisgICAgaWYgKHJlZkNoaWxkKSB7CisgICAgICAgIG5ld0NoaWxkLT5tX25leHQgPSByZWZD aGlsZC0+bV9uZXh0OworICAgICAgICByZWZDaGlsZC0+bV9uZXh0ID0gbmV3Q2hpbGQ7CisgICAg fSBlbHNlIHsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dCA9IG1fZmlyc3Q7CisgICAgICAgIG1f Zmlyc3QgPSBuZXdDaGlsZDsKKyAgICB9CisKKyAgICBpZiAobmV3Q2hpbGQtPm1fbmV4dCkgewor ICAgICAgICBhc3NlcnQobmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9PSByZWZDaGlsZCk7 CisgICAgICAgIG5ld0NoaWxkLT5tX25leHQtPm1fcHJldmlvdXMgPSBuZXdDaGlsZDsKKyAgICB9 IGVsc2UgeworICAgICAgICBhc3NlcnQgKG1fbGFzdCA9PSByZWZDaGlsZCk7CisgICAgICAgIG1f bGFzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIG5ld0NoaWxkLT5yZWNvdW50KHRydWUpOwor fQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKiBvbGRD aGlsZCkKK3sKKyAgICBBU1NFUlQob2xkQ2hpbGQpOworCisgICAgQ291bnRlck5vZGUqIG5leHQg PSBvbGRDaGlsZC0+bV9uZXh0OworICAgIENvdW50ZXJOb2RlKiBwcmV2ID0gb2xkQ2hpbGQtPm1f cHJldmlvdXM7CisKKyAgICBpZiAob2xkQ2hpbGQtPmZpcnN0Q2hpbGQoKSkgeworICAgICAgICBD b3VudGVyTm9kZSogZmlyc3QgPSBvbGRDaGlsZC0+Zmlyc3RDaGlsZCgpOworICAgICAgICBDb3Vu dGVyTm9kZSogbGFzdCA9IG9sZENoaWxkLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgaWYgKHByZXYp IHsKKyAgICAgICAgICAgIHByZXYtPm1fbmV4dCA9IGZpcnN0OworICAgICAgICAgICAgZmlyc3Qt Pm1fcHJldmlvdXMgPSBwcmV2OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIG1fZmlyc3Qg PSBmaXJzdDsKKworICAgICAgICBpZiAobmV4dCkgeworICAgICAgICAgICAgbmV4dC0+bV9wcmV2 aW91cyA9IGxhc3Q7CisgICAgICAgICAgICBsYXN0LT5tX25leHQgPSBuZXh0OworICAgICAgICB9 IGVsc2UKKyAgICAgICAgICAgIG1fbGFzdCA9IGxhc3Q7CisKKyAgICAgICAgbmV4dCA9IGZpcnN0 OworICAgICAgICB3aGlsZSAobmV4dCkgeworICAgICAgICAgICAgbmV4dC0+bV9wYXJlbnQgPSB0 aGlzOworICAgICAgICAgICAgbmV4dCA9IG5leHQtPm1fbmV4dDsKKyAgICAgICAgfQorCisgICAg ICAgIGZpcnN0LT5yZWNvdW50KHRydWUpOworICAgIH0gZWxzZSB7CisgICAgICAgIGlmIChwcmV2 KSAKKyAgICAgICAgICAgIHByZXYtPm1fbmV4dCA9IG5leHQ7CisgICAgICAgIGVsc2UgeworICAg ICAgICAgICAgYXNzZXJ0ICggbV9maXJzdCA9PSBvbGRDaGlsZCApOworICAgICAgICAgICAgbV9m aXJzdCA9IG5leHQ7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQorICAg ICAgICAgICAgbmV4dC0+bV9wcmV2aW91cyA9IHByZXY7CisgICAgICAgIGVsc2UgeworICAgICAg ICAgICAgYXNzZXJ0ICggbV9sYXN0ID09IG9sZENoaWxkICk7CisgICAgICAgICAgICBtX2xhc3Qg PSBwcmV2OworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBpZiAobmV4dCkKKyAgICAgICAg ICAgIG5leHQtPnJlY291bnQoKTsKKyAgICB9CisKKworICAgIG9sZENoaWxkLT5tX25leHQgPSAw OworICAgIG9sZENoaWxkLT5tX3ByZXZpb3VzID0gMDsKKyAgICBvbGRDaGlsZC0+bV9wYXJlbnQg PSAwOworfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnJlY291bnQoYm9vbCBmaXJzdCkKK3sK KyAgICBpbnQgb2xkX2NvdW50ID0gbV9jb3VudDsKKyAgICBpZiAobV9wcmV2aW91cykKKyAgICAg ICAgbV9jb3VudCA9IG1fcHJldmlvdXMtPmNvdW50KCk7CisgICAgZWxzZSBpZiAobV9wYXJlbnQp CisgICAgICAgIG1fY291bnQgPSBtX3BhcmVudC0+dmFsdWUoKTsKKyAgICBlbHNlCisgICAgICAg IG1fY291bnQgPSAwOworCisgICAgdXBkYXRlVG90YWwobV92YWx1ZSk7CisgICAgaWYgKCFmaXJz dCkKKyAgICAgICAgc2V0U2VsZkRpcnR5KCk7CisgICAgaWYgKG1fbmV4dCAmJiAoZmlyc3QgfHwg bV9jb3VudCAhPSBvbGRfY291bnQpKQorICAgICAgICBtX25leHQtPnJlY291bnQoKTsKK30KKwor dm9pZCBDb3VudGVyUmVzZXROb2RlOjpzZXRTZWxmRGlydHkoKQoreworICAgIHNldFBhcmVudERp cnR5KCk7Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6c2V0UGFyZW50RGlydHkoKQorewor ICAgIGlmIChoYXNDb3VudGVycygpKSB7CisgICAgICAgIGlmIChtX3JlbmRlcmVyICYmIG1faXNW aXN1YWwpCisgICAgICAgICAgICBtX3JlbmRlcmVyLT5zZXROZWVkc0xheW91dEFuZE1pbk1heFJl Y2FsYygpOworICAgICAgICBDb3VudGVyTm9kZSogbiA9IGZpcnN0Q2hpbGQoKTsKKyAgICAgICAg Zm9yKDsgbjsgbiA9IG4tPm5leHRTaWJsaW5nKCkpCisgICAgICAgICAgICBuLT5zZXRQYXJlbnRE aXJ0eSgpOworICAgIH0KK30KKwordm9pZCBDb3VudGVyUmVzZXROb2RlOjp1cGRhdGVUb3RhbChp bnQgdmFsdWUpCit7CisgICAgaWYgKHZhbHVlID4gbV90b3RhbCkKKyAgICAgICAgbV90b3RhbCA9 IHZhbHVlOworfQorCit9IC8vIG5hbWVzcGFjZQpJbmRleDogcmVuZGVyaW5nL1JlbmRlckNvbnRh aW5lci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAJKHJl dmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTQsNiArNCw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9sbCAo a25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBLb2l2aXN0byAoa29p dmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBEaXJrIE11ZWxsZXIgKG11ZWxs ZXJAa2RlLm9yZykKKyAqICAgICAgICAgICAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4g KGtkZUBjYXJld29sZi5jb20pCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDQsIDIwMDUsIDIw MDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KICAqIENvcHlyaWdodCAoQykgMjAwNiBBbmRyZXcgV2Vs bGluZ3RvbiAocHJvdG9uQHdpcmV0YXBwZWQubmV0KQogICoKQEAgLTI4LDYgKzI5LDcgQEAKICNp bmNsdWRlICJSZW5kZXJDb250YWluZXIuaCIKIAogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCisj aW5jbHVkZSAiUmVuZGVyQ291bnRlci5oIgogI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAj aW5jbHVkZSAiUmVuZGVyVGFibGUuaCIKICNpbmNsdWRlICJSZW5kZXJUZXh0RnJhZ21lbnQuaCIK QEAgLTI5Nyw2ICsyOTksOCBAQAogICAgICAgICAvLyBpbmxpbmUgc2hvdWxkIGJlIG11dGF0ZWQg dG8gSU5MSU5FLgogICAgICAgICBwc2V1ZG8tPnNldERpc3BsYXkoSU5MSU5FKTsKICAgICAKKyAg ICBSZW5kZXJTdHlsZSogc3R5bGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7 CisgICAgc3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgaWYgKG9sZENvbnRlbnRQcmVz ZW50KSB7CiAgICAgICAgIGlmIChjaGlsZCAmJiBjaGlsZC0+c3R5bGUoKS0+c3R5bGVUeXBlKCkg PT0gdHlwZSkgewogICAgICAgICAgICAgLy8gV2UgaGF2ZSBnZW5lcmF0ZWQgY29udGVudCBwcmVz ZW50IHN0aWxsLiAgV2Ugd2FudCB0byB3YWxrIHRoaXMgY29udGVudCBhbmQgdXBkYXRlIG91cgpA QCAtMzA5LDEzICszMTMsMTAgQEAKICAgICAgICAgICAgICAgICBpZiAoZ2VuQ2hpbGQtPmlzVGV4 dCgpKQogICAgICAgICAgICAgICAgICAgICAvLyBHZW5lcmF0ZWQgdGV4dCBjb250ZW50IGlzIGEg Y2hpbGQgd2hvc2Ugc3R5bGUgYWxzbyBuZWVkcyB0byBiZSBzZXQgdG8gdGhlIHBzZXVkbwogICAg ICAgICAgICAgICAgICAgICAvLyBzdHlsZS4KLSAgICAgICAgICAgICAgICAgICAgZ2VuQ2hpbGQt PnNldFN0eWxlKHBzZXVkbyk7Ci0gICAgICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAg ICAgICAgIGdlbkNoaWxkLT5zZXRTdHlsZShzdHlsZSk7CisgICAgICAgICAgICAgICAgZWxzZQog ICAgICAgICAgICAgICAgICAgICAvLyBJbWFnZXMgZ2V0IGFuIGVtcHR5IHN0eWxlIHRoYXQgaW5o ZXJpdHMgZnJvbSB0aGUgcHNldWRvLgotICAgICAgICAgICAgICAgICAgICBSZW5kZXJTdHlsZSog c3R5bGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7Ci0gICAgICAgICAgICAg ICAgICAgIHN0eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOwogICAgICAgICAgICAgICAgICAgICBn ZW5DaGlsZC0+c2V0U3R5bGUoc3R5bGUpOwotICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg IH0KICAgICAgICAgfQogICAgICAgICByZXR1cm47IC8vIFdlJ3ZlIHVwZGF0ZWQgdGhlIGdlbmVy YXRlZCBjb250ZW50LiBUaGF0J3MgYWxsIHdlIG5lZWRlZCB0byBkby4KQEAgLTMzNCwyMCArMzM1 LDIwIEBACiAgICAgICAgIGlmICghcHNldWRvQ29udGFpbmVyKQogICAgICAgICAgICAgcHNldWRv Q29udGFpbmVyID0gUmVuZGVyRmxvdzo6Y3JlYXRlQW5vbnltb3VzRmxvdyhkb2N1bWVudCgpLCBw c2V1ZG8pOyAvKiBhbm9ueW1vdXMgYm94ICovCiAgICAgICAgIAotICAgICAgICBpZiAoY29udGVu dERhdGEtPmNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9URVhUKQotICAgICAgICB7CisgICAgICAg IGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHsKICAgICAg ICAgICAgIFJlbmRlclRleHQqIHQgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclRleHRGcmFn bWVudChkb2N1bWVudCgpIC8qYW5vbnltb3VzIG9iamVjdCAqLywgY29udGVudERhdGEtPmNvbnRl bnRUZXh0KCkpOwotICAgICAgICAgICAgdC0+c2V0U3R5bGUocHNldWRvKTsKKyAgICAgICAgICAg IHQtPnNldFN0eWxlKHN0eWxlKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hp bGQodCk7Ci0gICAgICAgIH0KLSAgICAgICAgZWxzZSBpZiAoY29udGVudERhdGEtPmNvbnRlbnRU eXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpCi0gICAgICAgIHsKKyAgICAgICAgfSBlbHNlIGlmIChj b250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkgewogICAgICAgICAg ICAgUmVuZGVySW1hZ2UqIGltZyA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVySW1hZ2UoZG9j dW1lbnQoKSk7IC8qIEFub255bW91cyBvYmplY3QgKi8KLSAgICAgICAgICAgIFJlbmRlclN0eWxl KiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsKLSAgICAgICAgICAg IHN0eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOwogICAgICAgICAgICAgaW1nLT5zZXRTdHlsZShz dHlsZSk7CiAgICAgICAgICAgICBpbWctPnNldENvbnRlbnRPYmplY3QoY29udGVudERhdGEtPmNv bnRlbnRPYmplY3QoKSk7CiAgICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKGlt Zyk7CisgICAgICAgIH0gZWxzZSBpZiAoY29udGVudERhdGEtPl9jb250ZW50VHlwZSA9PSBDT05U RU5UX0NPVU5URVIpIHsKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIqIGMgPSBuZXcgKHJlbmRl ckFyZW5hKCkpIFJlbmRlckNvdW50ZXIoZWxlbWVudCgpLCBjb250ZW50RGF0YS0+Y29udGVudENv dW50ZXIoKSk7CisgICAgICAgICAgICBjLT5zZXRJc0Fub255bW91cyh0cnVlKTsKKyAgICAgICAg ICAgIGMtPnNldFN0eWxlKHN0eWxlKTsKKyAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRk Q2hpbGQoYyk7CiAgICAgICAgIH0KICAgICB9CiAKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTm9k ZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTm9kZS5oCShyZXZpc2lvbiAwKQor KysgcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsODUgQEAK Ky8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZv ciBLREUuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAo a2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwg SW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQ bGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyov CisjaWZuZGVmIF9Db3VudGVyX05vZGVfaF8KKyNkZWZpbmUgX0NvdW50ZXJfTm9kZV9oXworCisj aW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3Mg Q291bnRlclJlc2V0Tm9kZTsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3VudGVyLXRy ZWUgdGhhdCBpcyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9v a3VwLAorLy8gYW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9kZXMgYXJl IGFkZGVkIG9yIHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRlci1yZXNl dCBhbmQgcm9vdCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJlZSBwYXJl bnRzCisvLyBhcmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVtZW50YXRp b24gb2YgY291bnRlci1pbmNyZW1lbnQgYW5kIGNvdW50ZXItY29udGVudAorY2xhc3MgQ291bnRl ck5vZGUgeworcHVibGljOgorICAgIENvdW50ZXJOb2RlKFJlbmRlck9iamVjdCogbyk7CisgICAg dmlydHVhbCB+Q291bnRlck5vZGUoKTsKKworICAgIENvdW50ZXJSZXNldE5vZGUqIHBhcmVudCgp IGNvbnN0IHsgcmV0dXJuIG1fcGFyZW50OyB9CisgICAgQ291bnRlck5vZGUqIHByZXZpb3VzU2li bGluZygpIGNvbnN0IHsgcmV0dXJuIG1fcHJldmlvdXM7IH0KKyAgICBDb3VudGVyTm9kZSogbmV4 dFNpYmxpbmcoKSBjb25zdCB7IHJldHVybiBtX25leHQ7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJO b2RlKiBmaXJzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgQ291bnRl ck5vZGUqIGxhc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIHZvaWQg aW5zZXJ0QWZ0ZXIgKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxk KTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGlsZCk7 CisgICAgLy8gQ29udmVuaWVudCBzZWxmLXJlZmVyaW5nIHZlcnNpb24gb2YgdGhlIGFib3ZlCisg ICAgdm9pZCByZW1vdmUoKTsKKworICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFs dWU7IH0KKyAgICB2b2lkIHNldFZhbHVlKHNob3J0IHYpIHsgbV92YWx1ZSA9IHY7IH0KKyAgICBp bnQgY291bnQoKSBjb25zdCB7IHJldHVybiBtX2NvdW50OyB9CisKKyAgICB2aXJ0dWFsIGJvb2wg aXNSZXNldCgpIHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9v bCBmaXJzdCA9IGZhbHNlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisgICAg dmlydHVhbCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisKKyAgICBib29sIGhhc0NvdW50ZXJzKCkg Y29uc3QgeyByZXR1cm4gbV9oYXNDb3VudGVyczsgfTsKKyAgICBib29sIGlzVmlzdWFsKCkgY29u c3QgeyByZXR1cm4gbV9pc1Zpc3VhbDsgfTsKKyAgICB2b2lkIHNldEhhc0NvdW50ZXJzKCk7Cisg ICAgdm9pZCBzZXRJc1Zpc3VhbCgpIHsgbV9pc1Zpc3VhbCA9IHRydWU7IH07CisgICAgYm9vbCBp c1Jvb3QoKSB7IHJldHVybiBtX3JlbmRlcmVyICYmIG1fcmVuZGVyZXItPmlzUm9vdCgpOyB9Owor CisgICAgdm9pZCBzZXRSZW5kZXJlcihSZW5kZXJPYmplY3QqIG8pIHsgbV9yZW5kZXJlciA9IG87 IH07CisgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlcigpIGNvbnN0IHsgcmV0dXJuIG1fcmVuZGVy ZXI7IH07CisKKyAgICBmcmllbmQgY2xhc3MgQ291bnRlclJlc2V0Tm9kZTsKK3Byb3RlY3RlZDoK KyAgICBib29sIG1faGFzQ291bnRlcnMgOiAxOworICAgIGJvb2wgbV9pc1Zpc3VhbCA6IDE7Cisg ICAgc2hvcnQgbV92YWx1ZTsKKyAgICBzaG9ydCBtX2NvdW50OworICAgIENvdW50ZXJSZXNldE5v ZGUqIG1fcGFyZW50OworICAgIENvdW50ZXJOb2RlKiBtX3ByZXZpb3VzOworICAgIENvdW50ZXJO b2RlKiBtX25leHQ7CisgICAgUmVuZGVyT2JqZWN0KiBtX3JlbmRlcmVyOworfTsKKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gQ291bnRlck5vZGVfaApJbmRleDogcmVuZGVy aW5nL1JlbmRlclN0eWxlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5bGUu Y3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5kZXJTdHlsZS5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTkwLDggKzkwLDggQEAKICAgICA6IGhhc0NsaXAoZmFsc2UpCiAgICAgLCB0 ZXh0RGVjb3JhdGlvbihSZW5kZXJTdHlsZTo6aW5pdGlhbFRleHREZWNvcmF0aW9uKCkpCiAgICAg LCBjb2xzcGFuKDEpCi0gICAgLCBjb3VudGVyX2luY3JlbWVudCgwKQotICAgICwgY291bnRlcl9y ZXNldCgwKQorICAgICwgY291bnRlckluY3JlbWVudCgwKQorICAgICwgY291bnRlclJlc2V0KDAp CiB7CiB9CiAKQEAgLTEwNSw4ICsxMDUsOCBAQAogICAgICwgaGFzQ2xpcChvLmhhc0NsaXApCiAg ICAgLCB0ZXh0RGVjb3JhdGlvbihvLnRleHREZWNvcmF0aW9uKQogICAgICwgY29sc3BhbihvLmNv bHNwYW4pCi0gICAgLCBjb3VudGVyX2luY3JlbWVudChvLmNvdW50ZXJfaW5jcmVtZW50KQotICAg ICwgY291bnRlcl9yZXNldChvLmNvdW50ZXJfcmVzZXQpCisgICAgLCBjb3VudGVySW5jcmVtZW50 KG8uY291bnRlckluY3JlbWVudCkKKyAgICAsIGNvdW50ZXJSZXNldChvLmNvdW50ZXJSZXNldCkK IHsKIH0KIApAQCAtNTc4LDYgKzU3OCwxMSBAQAogICAgIH0KICAgICBkZWxldGUgY29udGVudDsK ICAgICAKKyAgICBpZiAoY291bnRlclJlc2V0TGlzdCkKKyAgICAgICAgY291bnRlclJlc2V0TGlz dC0+ZGVyZWYoKTsKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIGNvdW50 ZXJJbmNyZW1lbnRMaXN0LT5kZXJlZigpOworICAgIAogICAgIGRlbGV0ZSB0aGlzOwogICAgIAog ICAgIC8vIFJlY292ZXIgdGhlIHNpemUgbGVmdCB0aGVyZSBmb3IgdXMgYnkgb3BlcmF0b3IgZGVs ZXRlIGFuZCBmcmVlIHRoZSBtZW1vcnkuCkBAIC02MDEsNiArNjA2LDggQEAKICAgICAsIGluaGVy aXRlZChkZWZhdWx0U3R5bGUtPmluaGVyaXRlZCkKICAgICAsIHBzZXVkb1N0eWxlKDApCiAgICAg LCBjb250ZW50KDApCisgICAgLCBjb3VudGVyUmVzZXRMaXN0KDApCisgICAgLCBjb3VudGVySW5j cmVtZW50TGlzdCgwKQogICAgICwgbV9wc2V1ZG9TdGF0ZShQc2V1ZG9Vbmtub3duKQogICAgICwg bV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzKGZhbHNlKQogICAgICwgbV91bmlxdWUoZmFs c2UpCkBAIC02MTUsNiArNjIyLDggQEAKIFJlbmRlclN0eWxlOjpSZW5kZXJTdHlsZShib29sKQog ICAgIDogcHNldWRvU3R5bGUoMCkKICAgICAsIGNvbnRlbnQoMCkKKyAgICAsIGNvdW50ZXJSZXNl dExpc3QoMCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KDApCiAgICAgLCBtX3BzZXVkb1N0 YXRlKFBzZXVkb1Vua25vd24pCiAgICAgLCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMo ZmFsc2UpCiAgICAgLCBtX3VuaXF1ZShmYWxzZSkKQEAgLTY0OSw2ICs2NTgsOCBAQAogICAgICwg aW5oZXJpdGVkKG8uaW5oZXJpdGVkKQogICAgICwgcHNldWRvU3R5bGUoMCkKICAgICAsIGNvbnRl bnQoby5jb250ZW50KQorICAgICwgY291bnRlclJlc2V0TGlzdChvLmNvdW50ZXJSZXNldExpc3Qp CisgICAgLCBjb3VudGVySW5jcmVtZW50TGlzdChvLmNvdW50ZXJJbmNyZW1lbnRMaXN0KQogICAg ICwgbV9wc2V1ZG9TdGF0ZShvLm1fcHNldWRvU3RhdGUpCiAgICAgLCBtX2FmZmVjdGVkQnlBdHRy aWJ1dGVTZWxlY3RvcnMoZmFsc2UpCiAgICAgLCBtX3VuaXF1ZShmYWxzZSkKQEAgLTgzOCw4ICs4 NDksOCBAQAogICAgICAgICAhKG5vbmluaGVyaXRlZF9mbGFncy5fZmxvYXRpbmcgPT0gb3RoZXIt Pm5vbmluaGVyaXRlZF9mbGFncy5fZmxvYXRpbmcpIHx8CiAgICAgICAgICEobm9uaW5oZXJpdGVk X2ZsYWdzLl9vcmlnaW5hbERpc3BsYXkgPT0gb3RoZXItPm5vbmluaGVyaXRlZF9mbGFncy5fb3Jp Z2luYWxEaXNwbGF5KSB8fAogICAgICAgICAgdmlzdWFsLT5jb2xzcGFuICE9IG90aGVyLT52aXN1 YWwtPmNvbHNwYW4gfHwKLSAgICAgICAgIHZpc3VhbC0+Y291bnRlcl9pbmNyZW1lbnQgIT0gb3Ro ZXItPnZpc3VhbC0+Y291bnRlcl9pbmNyZW1lbnQgfHwKLSAgICAgICAgIHZpc3VhbC0+Y291bnRl cl9yZXNldCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVyX3Jlc2V0IHx8CisgICAgICAgICB2aXN1 YWwtPmNvdW50ZXJJbmNyZW1lbnQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlckluY3JlbWVudCB8 fAorICAgICAgICAgdmlzdWFsLT5jb3VudGVyUmVzZXQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRl clJlc2V0IHx8CiAgICAgICAgICBjc3MzTm9uSW5oZXJpdGVkRGF0YS0+dGV4dE92ZXJmbG93ICE9 IG90aGVyLT5jc3MzTm9uSW5oZXJpdGVkRGF0YS0+dGV4dE92ZXJmbG93IHx8CiAgICAgICAgICAo Y3NzM0luaGVyaXRlZERhdGEtPnRleHRTZWN1cml0eSAhPSBvdGhlci0+Y3NzM0luaGVyaXRlZERh dGEtPnRleHRTZWN1cml0eSkpCiAgICAgICAgIHJldHVybiBMYXlvdXQ7CkBAIC0xMDgwLDYgKzEw OTEsMzIgQEAKICAgICBuZXdDb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID0gQ09OVEVOVF9URVhU OwogfQogCit2b2lkIFJlbmRlclN0eWxlOjpzZXRDb250ZW50KENvdW50ZXJEYXRhKiBjLCBib29s IGFkZCkKK3sKKyAgICBpZiAoIWMpCisgICAgICAgIHJldHVybjsKKworICAgIENvbnRlbnREYXRh KiBsYXN0Q29udGVudCA9IGNvbnRlbnQ7CisgICAgd2hpbGUgKGxhc3RDb250ZW50ICYmIGxhc3RD b250ZW50LT5fbmV4dENvbnRlbnQpCisgICAgICAgIGxhc3RDb250ZW50ID0gbGFzdENvbnRlbnQt Pl9uZXh0Q29udGVudDsKKworICAgIGJvb2wgcmV1c2VDb250ZW50ID0gIWFkZDsKKyAgICBDb250 ZW50RGF0YSogbmV3Q29udGVudERhdGEgPSAwOworICAgIGlmIChyZXVzZUNvbnRlbnQgJiYgY29u dGVudCkgeworICAgICAgICBjb250ZW50LT5jbGVhckNvbnRlbnQoKTsKKyAgICAgICAgbmV3Q29u dGVudERhdGEgPSBjb250ZW50OworICAgIH0gZWxzZQorICAgICAgICBuZXdDb250ZW50RGF0YSA9 IG5ldyBDb250ZW50RGF0YTsKKworICAgIGlmIChsYXN0Q29udGVudCAmJiAhcmV1c2VDb250ZW50 KQorICAgICAgICBsYXN0Q29udGVudC0+X25leHRDb250ZW50ID0gbmV3Q29udGVudERhdGE7Cisg ICAgZWxzZQorICAgICAgICBjb250ZW50ID0gbmV3Q29udGVudERhdGE7CisKKyAgICBuZXdDb250 ZW50RGF0YS0+X2NvbnRlbnQuY291bnRlciA9IGM7CisgICAgbmV3Q29udGVudERhdGEtPl9jb250 ZW50VHlwZSA9IENPTlRFTlRfQ09VTlRFUjsKK30KKwogQ29udGVudERhdGE6On5Db250ZW50RGF0 YSgpCiB7CiAgICAgY2xlYXJDb250ZW50KCk7CkBAIC0xMDk4LDYgKzExMzUsMTAgQEAKICAgICAg ICAgY2FzZSBDT05URU5UX1RFWFQ6CiAgICAgICAgICAgICBfY29udGVudC50ZXh0LT5kZXJlZigp OwogICAgICAgICAgICAgX2NvbnRlbnQudGV4dCA9IDA7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgY2FzZSBDT05URU5UX0NPVU5URVI6CisgICAgICAgICAgICBfY29udGVudC5jb3VudGVy ID0gMDsKKyAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAg OwogICAgIH0KQEAgLTExODUsNiArMTIyNiwxMjIgQEAKICAgICByZXR1cm4geCA9PSBvLnggJiYg eSA9PSBvLnkgJiYgYmx1ciA9PSBvLmJsdXIgJiYgY29sb3IgPT0gby5jb2xvcjsKIH0KIAorYm9v bCBSZW5kZXJTdHlsZTo6Y291bnRlckRhdGFFcXVpdmFsZW50KFJlbmRlclN0eWxlKiBvdGhlclN0 eWxlKQoreworICAgIC8vICMjIyBTaG91bGQgd2UgY29tcGFyZSBjb250ZW50PworICAgIHJldHVy biBjb3VudGVyUmVzZXRMaXN0ID09IG90aGVyU3R5bGUtPmNvdW50ZXJSZXNldExpc3QgJiYKKyAg ICAgICAgICAgY291bnRlckluY3JlbWVudExpc3QgPT0gb3RoZXJTdHlsZS0+Y291bnRlckluY3Jl bWVudExpc3Q7Cit9CisKK3N0YXRpYyBib29sIGhhc0NvdW50ZXIoY29uc3QgU3RyaW5nJiBjLCBD U1NWYWx1ZUxpc3QqIGwpCit7CisgICAgaW50IGxlbiA9IGwtPmxlbmd0aCgpOworICAgIGZvciAo aW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIHBy aW1pdGl2ZVZhbHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihsLT5pdGVtKGkp KTsKKyAgICAgICAgUGFpciogcGFpciA9IHByaW1pdGl2ZVZhbHVlLT5nZXRQYWlyVmFsdWUoKTsK KyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nhc3Q8Q1NT UHJpbWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAgQVNTRVJUKHBhaXIgJiYg Y291bnRlck5hbWUpOworICAgICAgICBpZiAoY291bnRlck5hbWUtPmdldFN0cmluZ1ZhbHVlKCkg PT0gYykKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKK2Jvb2wgUmVuZGVyU3R5bGU6Omhhc0NvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmIGMp IGNvbnN0Cit7CisgICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiBoYXND b3VudGVyKGMsIGNvdW50ZXJSZXNldExpc3QpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZh bHNlOworfQorCitib29sIFJlbmRlclN0eWxlOjpoYXNDb3VudGVySW5jcmVtZW50KGNvbnN0IFN0 cmluZyYgYykgY29uc3QKK3sKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisgICAgICAg IHJldHVybiBoYXNDb3VudGVyKGMsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KTsKKyAgICBlbHNlCisg ICAgICAgIHJldHVybiBmYWxzZTsKK30KKworc3RhdGljIHNob3J0IHJlYWRDb3VudGVyKGNvbnN0 IFN0cmluZyYgYywgQ1NTVmFsdWVMaXN0KiBsLCBib29sIGlzUmVzZXQpCit7CisgICAgaW50IGxl biA9IGwtPmxlbmd0aCgpOworICAgIHNob3J0IHRvdGFsID0gMDsKKyAgICAKKyAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmlt aXRpdmVWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7 CisgICAgICAgIFBhaXIqIHBhaXIgPSBwcmltaXRpdmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7Cisg ICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBjb3VudGVyTmFtZSA9IHN0YXRpY19jYXN0PENTU1By aW1pdGl2ZVZhbHVlKj4ocGFpci0+Zmlyc3QoKSk7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVl KiBjb3VudGVyVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KHBhaXItPnNl Y29uZCgpKTsKKyAgICAgICAgQVNTRVJUKHBhaXIgJiYgY291bnRlck5hbWUgJiYgY291bnRlclZh bHVlKTsKKworICAgICAgICBpZiAoY291bnRlck5hbWUtPmdldFN0cmluZ1ZhbHVlKCkgPT0gYykg eworICAgICAgICAgICAgdG90YWwgKz0gKHNob3J0KWNvdW50ZXJWYWx1ZS0+Z2V0RmxvYXRWYWx1 ZSgpOworICAgICAgICAgICAgaWYgKGlzUmVzZXQpCisgICAgICAgICAgICAgICAgcmV0dXJuIHRv dGFsOworICAgICAgICB9CisgICAgfQorICAgIAorICAgIHJldHVybiB0b3RhbDsKK30KKworc2hv cnQgUmVuZGVyU3R5bGU6OmNvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmIGMpIGNvbnN0Cit7Cisg ICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiByZWFkQ291bnRlcihjLCBj b3VudGVyUmVzZXRMaXN0LCB0cnVlKTsKKyAgICBlbHNlCisgICAgICAgIHJldHVybiAwOworfQor CitzaG9ydCBSZW5kZXJTdHlsZTo6Y291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmIGMpIGNv bnN0Cit7CisgICAgaWYgKGNvdW50ZXJJbmNyZW1lbnRMaXN0KQorICAgICAgICByZXR1cm4gcmVh ZENvdW50ZXIoYywgY291bnRlckluY3JlbWVudExpc3QsIGZhbHNlKTsKKyAgICBlbHNlCisgICAg ICAgIHJldHVybiAwOworfQorCit2b2lkIFJlbmRlclN0eWxlOjpzZXRDb3VudGVyUmVzZXQoQ1NT VmFsdWVMaXN0KiBsKQoreworICAgIENTU1ZhbHVlTGlzdCogdCA9IGNvdW50ZXJSZXNldExpc3Q7 CisgICAgY291bnRlclJlc2V0TGlzdCA9IGw7CisgICAgaWYgKGwpCisgICAgICAgIGwtPnJlZigp OworICAgIGlmICh0KQorICAgICAgICB0LT5kZXJlZigpOworfQorCit2b2lkIFJlbmRlclN0eWxl OjpzZXRDb3VudGVySW5jcmVtZW50KENTU1ZhbHVlTGlzdCogbCkKK3sKKyAgICBDU1NWYWx1ZUxp c3QqIHQgPSBjb3VudGVySW5jcmVtZW50TGlzdDsKKyAgICBjb3VudGVySW5jcmVtZW50TGlzdCA9 IGw7CisgICAgCisgICAgaWYgKGwpIAorICAgICAgICBsLT5yZWYoKTsKKyAgICBpZiAodCkKKyAg ICAgICAgdC0+ZGVyZWYoKTsKK30KKwordm9pZCBSZW5kZXJTdHlsZTo6YWRkQ291bnRlclJlc2V0 KENTU1ByaW1pdGl2ZVZhbHVlKiBjKQoreworICAgIGlmICghY291bnRlclJlc2V0TGlzdCkgewor ICAgICAgICBjb3VudGVyUmVzZXRMaXN0ID0gbmV3IENTU1ZhbHVlTGlzdDsKKyAgICAgICAgY291 bnRlclJlc2V0TGlzdC0+cmVmKCk7CisgICAgfQorCisgICAgY291bnRlclJlc2V0TGlzdC0+YXBw ZW5kKGMpOworfQorCit2b2lkIFJlbmRlclN0eWxlOjphZGRDb3VudGVySW5jcmVtZW50KENTU1By aW1pdGl2ZVZhbHVlKiBjKQoreworICAgIGlmICghY291bnRlckluY3JlbWVudExpc3QpIHsKKyAg ICAgICAgY291bnRlckluY3JlbWVudExpc3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgICAgICBj b3VudGVySW5jcmVtZW50TGlzdC0+cmVmKCk7CisgICAgfQorCisgICAgY291bnRlckluY3JlbWVu dExpc3QtPmFwcGVuZChjKTsKK30KKwogY29uc3QgVmVjdG9yPFN0eWxlRGFzaGJvYXJkUmVnaW9u PiYgUmVuZGVyU3R5bGU6OmluaXRpYWxEYXNoYm9hcmRSZWdpb25zKCkKIHsgCiAgICAgc3RhdGlj IFZlY3RvcjxTdHlsZURhc2hib2FyZFJlZ2lvbj4gZW1wdHlMaXN0OwpJbmRleDogZG9tL05vZGUu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBkb20vTm9kZS5oCShyZXZpc2lvbiAxNjUyOCkKKysrIGRvbS9Ob2Rl LmgJKHdvcmtpbmcgY29weSkKQEAgLTEzNCw2ICsxMzQsMTAgQEAKICNpZmRlZiBTVkdfU1VQUE9S VAogICAgIHZpcnR1YWwgYm9vbCBpc1NWR0VsZW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsg fQogI2VuZGlmCisgICAgdmlydHVhbCBib29sIGlzT3JkZXJlZExpc3RFbGVtZW50KCkgY29uc3Qg eyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNVbm9yZGVyZWRMaXN0RWxlbWVu dCgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzTWVudUVsZW1l bnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0RpcmVjdG9y eUVsZW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc1N0 eWxlZEVsZW1lbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBp c0F0dHJpYnV0ZU5vZGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9v bCBpc1RleHROb2RlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KSW5kZXg6IFdlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDE2NTI4KQorKysgV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC04NTcsNiArODU3LDEzIEBACiAJCTkzNUZC Q0YyMDlCQTE0M0IwMEUyMzBCMSAvKiBFeGNlcHRpb25Db2RlLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzVGQkNGMTA5QkExNDNCMDBFMjMwQjEgLyog RXhjZXB0aW9uQ29kZS5oICovOyB9OwogCQk5MzZCNDI0RTA5QTQzNkNEMDBCQUE4MjAgLyogU1ZH Q1NTUGFyc2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEE4QzBGNkY2MDg5NzAxRjEwMEJBNTExNCAvKiBTVkdDU1NQYXJzZXIuY3BwICovOyB9Owog CQk5MzZCREQxRDBBMDMxQUVCMDA0REY0QUIgLyogR3JhcGhpY3NDb250ZXh0Q0cuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM2QkREMUMwQTAzMUFF QjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAqLzsgfTsKKwkJOTM3MUJCNzEwQUM0 N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJD b3VudGVyLmggKi87IH07CisJCTkzNzFCQjczMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3Vu dGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkz NzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLzsgfTsKKwkJOTM3 MUJCNzUwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc0MEFDNDdGQzgwMENENEE3 QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi87IH07CisJCTkzNzFCQjc3MEFDNDdGRDAwMENENEE3 QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc2MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXRO b2RlLmNwcCAqLzsgfTsKKwkJOTM3MUJCNzkwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2Rl LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3 ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLzsgfTsKKwkJOTM3MUJCN0IwQUM0 N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjdBMEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVy Tm9kZS5jcHAgKi87IH07CisJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlz dEl0ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkz NzFCQjdDMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0uaCAqLzsgfTsKIAkJOTM3 MjU2MTAwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIgaW4gRnJhbWV3b3JrcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcyNTYwRjBBNjE1NjQyMDBCMDUz QjkgLyogbGlic3FsaXRlMy5keWxpYiAqLzsgfTsKIAkJOTM4MEY0NzMwOUExMUFCNDAwMUZEQjM0 IC8qIFdpZGdldC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzgwRjQ3MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCAqLzsgfTsKIAkJOTM4 MEY0NzQwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4MEY0NzIwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdl dC5oICovOyB9OwpAQCAtMzE4Myw2ICszMTkwLDEzIEBACiAJCTkzNUZCQ0YxMDlCQTE0M0IwMEUy MzBCMSAvKiBFeGNlcHRpb25Db2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IEV4Y2VwdGlvbkNvZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM2QkREMUMw QTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEdyYXBoaWNzQ29udGV4dENHLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJOTM2REQwM0EwOUNFQUMyNzAwNTZBRThDIC8qIFJhbmdlLmlkbCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQ7IHBhdGggPSBSYW5nZS5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCTkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJDb3VudGVyLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3Vu dGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW5kZXJDb3Vu dGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzQwQUM0N0ZDODAw Q0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IENvdW50ZXJSZXNldE5vZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ OTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvdW50ZXJSZXNldE5vZGUuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291 bnRlck5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAz MDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJOb2Rl Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjdBMEFDNDdGREUwMENENEE3 QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gQ291bnRlck5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3 QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBDb3VudGVyTGlzdEl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJOTM3MjU2MEYwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSAiY29tcGlsZWQu bWFjaC1vLmR5bGliIjsgbmFtZSA9IGxpYnNxbGl0ZTMuZHlsaWI7IHBhdGggPSAvdXNyL2xpYi9s aWJzcWxpdGUzLmR5bGliOyBzb3VyY2VUcmVlID0gIjxhYnNvbHV0ZT4iOyB9OwogCQk5MzgwRjQ3 MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBXaWRnZXQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5 MzgwRjQ3MjA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBXaWRnZXQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTcx NjYsNiArNzE4MCwxMSBAQAogCQkJCUJDRUE0ODE0MDk3RDkzMDIwMDk0QzlFNCAvKiBiaWRpLmgg Ki8sCiAJCQkJQkNFQTQ4MTUwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFrX2xpbmVzLmNwcCAqLywK IAkJCQlCQ0VBNDgxNjA5N0Q5MzAyMDA5NEM5RTQgLyogYnJlYWtfbGluZXMuaCAqLywKKwkJCQk5 MzcxQkI3QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi8sCisJCQkJOTM3 MUJCN0EwQUM0N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCAqLywKKwkJCQk5MzcxQkI3 ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLywKKwkJCQk5MzcxQkI3NjBBQzQ3 RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgKi8sCisJCQkJOTM3MUJCNzQwQUM0 N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLywKIAkJCQlCQ0VBNDgxNzA5N0Q5 MzAyMDA5NEM5RTQgLyogRGF0YVJlZi5oICovLAogCQkJCUFCRTdCNTIxMEE0ODlGODMwMDMxODgx QyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmNwcCAqLywKIAkJCQlBQkU3QjUyMjBBNDg5Rjgz MDAzMTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5oICovLApAQCAtNzIwMiw2ICs3MjIx LDggQEAKIAkJCQlCQ0VBNDgyOTA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyVmlldy5oICovLAog CQkJCUJDRUE0ODJDMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250YWluZXIuY3BwICovLAog CQkJCUJDRUE0ODJEMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250YWluZXIuaCAqLywKKwkJ CQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi8sCisJCQkJ OTM3MUJCNzAwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCAqLywKIAkJCQlBOEVB NzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuY3BwICovLAogCQkJCUE4RUE3 M0IwMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNldC5oICovLAogCQkJCTA2NkM3NzJF MEFCNjAzRkQwMDIzOENDNCAvKiBSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5jcHAgKi8sCkBAIC04 NDUwLDYgKzg0NzEsMTAgQEAKIAkJCQlBODQxNUY5RTBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZh c01hc2tlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg0MTVGQTAwQUMxMEM1RDAwRjdEMERGIC8q IEtDYW52YXNNYXJrZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCUJDM0ZDQUE5MEFDM0RCNTgwMEJB NTRBRCAvKiBQbGF0Zm9ybVNjcm9sbEJhci5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM3MUJCNzEw QUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTkz NzFCQjc1MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggaW4gSGVhZGVycyAq LywKKwkJCQk5MzcxQkI3OTBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCBpbiBIZWFk ZXJzICovLAorCQkJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0u aCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nl c3NpbmcgPSAwOwogCQl9OwpAQCAtOTUzOCw2ICs5NTYzLDkgQEAKIAkJCQlBODQxNUY5RjBBQzEw QzVEMDBGN0QwREYgLyogS0NhbnZhc01hc2tlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBODQx NUZBMTBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc01hcmtlci5jcHAgaW4gU291cmNlcyAqLywK IAkJCQlBODQxNUZBMjBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc0ZpbHRlcnMuY3BwIGluIFNv dXJjZXMgKi8sCisJCQkJOTM3MUJCNzMwQUM0N0ZCODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIu Y3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCNzcwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50 ZXJSZXNldE5vZGUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCN0IwQUM0N0ZERTAwQ0Q0 QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogY3NzL2Nzc3BhcnNl ci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGNzcy9jc3NwYXJzZXIuaAkocmV2aXNpb24gMTY1MjgpCisrKyBj c3MvY3NzcGFyc2VyLmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NiwxMSArMTQ2LDEzIEBACiAKICAg ICAgICAgYm9vbCBwYXJzZVNoYXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKICAgICAg ICAgYm9vbCBwYXJzZUZvbnQoYm9vbCBpbXBvcnRhbnQpOworICAgICAgICBib29sIHBhcnNlQ291 bnRlcihpbnQgcHJvcElkLCBib29sIGluY3JlbWVudCwgYm9vbCBpbXBvcnRhbnQpOwogICAgICAg ICBDU1NWYWx1ZUxpc3QqIHBhcnNlRm9udEZhbWlseSgpOwogICAgICAgICBib29sIHBhcnNlQ29s b3JQYXJhbWV0ZXJzKFZhbHVlKiwgaW50KiBjb2xvclZhbHVlcywgYm9vbCBwYXJzZUFscGhhKTsK ICAgICAgICAgYm9vbCBwYXJzZUhTTFBhcmFtZXRlcnMoVmFsdWUqLCBkb3VibGUqIGNvbG9yVmFs dWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VD b2xvcigpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xvckZyb21WYWx1ZShW YWx1ZSopOworICAgICAgICBDU1NWYWx1ZSogcGFyc2VDb3VudGVyQ29udGVudChWYWx1ZUxpc3Qg KmFyZ3MsIGJvb2wgY291bnRlcnMpOwogICAgICAgICAKICNpZmRlZiBTVkdfU1VQUE9SVAogICAg ICAgICBib29sIHBhcnNlU1ZHVmFsdWUoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRhbnQpOwpJbmRl eDogY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9jc3NzdHlsZXNl bGVjdG9yLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3Nzc3R5bGVzZWxlY3Rvci5jcHAJ KHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjc3NzdHlsZXNlbGVj dG9yLmgiCiAKICNpbmNsdWRlICJDU1NCb3JkZXJJbWFnZVZhbHVlLmgiCisjaW5jbHVkZSAiQ291 bnRlci5oIgogI2luY2x1ZGUgIkNTU0ltYWdlVmFsdWUuaCIKICNpbmNsdWRlICJDU1NJbXBvcnRS dWxlLmgiCiAjaW5jbHVkZSAiQ1NTTWVkaWFSdWxlLmgiCkBAIC0zMTQ4LDcgKzMxNDksOSBAQAog CiAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKICAgICAgICAgICAgIENT U1ZhbHVlICppdGVtID0gbGlzdC0+aXRlbShpKTsKLSAgICAgICAgICAgIGlmICghaXRlbS0+aXNQ cmltaXRpdmVWYWx1ZSgpKSBjb250aW51ZTsKKyAgICAgICAgICAgIGlmICghaXRlbS0+aXNQcmlt aXRpdmVWYWx1ZSgpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgCiAg ICAgICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSAqdmFsID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0 aXZlVmFsdWUqPihpdGVtKTsKICAgICAgICAgICAgIGlmICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09 Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpCiAgICAgICAgICAgICAgICAgc3R5bGUtPnNl dENvbnRlbnQodmFsLT5nZXRTdHJpbmdWYWx1ZSgpLmltcGwoKSwgaSAhPSAwKTsKQEAgLTMxNjIs MjAgKzMxNjUsMzQgQEAKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudChlbGVtZW50 LT5nZXRBdHRyaWJ1dGUoYXR0cikuaW1wbCgpLCBpICE9IDApOwogICAgICAgICAgICAgICAgIC8v IHJlZ2lzdGVyIHRoZSBmYWN0IHRoYXQgdGhlIGF0dHJpYnV0ZSB2YWx1ZSBhZmZlY3RzIHRoZSBz dHlsZQogICAgICAgICAgICAgICAgIG1fc2VsZWN0b3JBdHRycy5hZGQoYXR0ci5sb2NhbE5hbWUo KS5pbXBsKCkpOwotICAgICAgICAgICAgfQotICAgICAgICAgICAgZWxzZSBpZiAodmFsLT5wcmlt aXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfVVJJKSB7CisgICAgICAgICAgICB9 IGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VS SSkgewogICAgICAgICAgICAgICAgIENTU0ltYWdlVmFsdWUgKmltYWdlID0gc3RhdGljX2Nhc3Q8 Q1NTSW1hZ2VWYWx1ZSo+KHZhbCk7CiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQo aW1hZ2UtPmltYWdlKGVsZW1lbnQtPmRvY3VtZW50KCktPmRvY0xvYWRlcigpKSwgaSAhPSAwKTsK LSAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBl KCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfQ09VTlRFUikgeworICAgICAgICAgICAgICAgIENv dW50ZXIqIGNvdW50ZXJWYWx1ZSA9IHZhbC0+Z2V0Q291bnRlclZhbHVlKCk7CisgICAgICAgICAg ICAgICAgQ291bnRlckRhdGEgY291bnRlciA9ICBDb3VudGVyRGF0YShjb3VudGVyVmFsdWUtPmlk ZW50aWZpZXIoKSwKKyAgICAgICAgICAgICAgICAgICAgY291bnRlclZhbHVlLT5saXN0U3R5bGVO dW1iZXIoKSwgY291bnRlclZhbHVlLT5zZXBhcmF0b3IoKSk7CisgICAgICAgICAgICAgICAgQ291 bnRlckRhdGEqIGMgPSBuZXcgQ291bnRlckRhdGEoY291bnRlcik7CisgICAgICAgICAgICAgICAg c3R5bGUtPnNldENvbnRlbnQoYywgaSAhPSAwKTsKKyAgICAgICAgICAgfQogICAgICAgICB9CiAg ICAgICAgIGJyZWFrOwogICAgIH0KIAotICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNSRU1F TlQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJJbmNyZW1lbnQKLSAgICBjYXNlIENT U19QUk9QX0NPVU5URVJfUkVTRVQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNl dAorICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6IHsKKyAgICAgICAgaWYoIXZh bHVlLT5pc1ZhbHVlTGlzdCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBDU1NWYWx1 ZUxpc3QqIGxpc3QgPSBzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QgKj4odmFsdWUpOworICAgICAg ICBzdHlsZS0+c2V0Q291bnRlckluY3JlbWVudChsaXN0KTsKICAgICAgICAgYnJlYWs7CisgICAg fQorICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNFVDogeworICAgICAgICBpZighdmFsdWUt PmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIENTU1ZhbHVlTGlz dCogbGlzdCA9IHN0YXRpY19jYXN0PENTU1ZhbHVlTGlzdCAqPih2YWx1ZSk7CisgICAgICAgIHN0 eWxlLT5zZXRDb3VudGVyUmVzZXQobGlzdCk7CisgICAgICAgIGJyZWFrOworICAgIH0KICAgICBj YXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOiB7CiAgICAgICAgIC8vIGxpc3Qgb2Ygc3RyaW5ncyBh bmQgaWRzCiAgICAgICAgIGlmIChpc0luaGVyaXQpIHsKSW5kZXg6IGNzcy9DU1NQcmltaXRpdmVW YWx1ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkocmV2aXNp b24gMTY1MjgpCisrKyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC01MjQsNyArNTI0LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBjYXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAgLy8gIyMjCisgICAgICAg ICAgICB0ZXh0ID0gImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQgKz0gU3RyaW5nOjpudW1i ZXIobV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7CisgICAgICAgICAgICAv LyAjIyMgYWRkIGxpc3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAgICAgICAgICAgYnJlYWs7CiAg ICAgICAgIGNhc2UgQ1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJlY3RJbXBsKiByZWN0VmFsID0g Z2V0UmVjdFZhbHVlKCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9D b3VudGVyLmgJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL0NvdW50ZXIuaAkod29ya2luZyBjb3B5 KQpAQCAtMjMsMjMgKzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJfSAogI2RlZmluZSBDb3VudGVy X0gKIAorI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1T dHJpbmcuaCIKICNpbmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5o IgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAog Y2xhc3MgQ291bnRlciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4gewogcHVibGljOgotICAgIFN0 cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9Ci0gICAgU3Ry aW5nIGxpc3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9Ci0gICAgU3RyaW5n IHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisgICAgQ291bnRlcigp IDogbV9pZGVudGlmaWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9zZXBhcmF0b3IoMCkgeyB9Cisg ICAgQ291bnRlcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVudGlmaWVyLCBQYXNz UmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisgICAgICAgIFBhc3NSZWZQdHI8 Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAgOiBtX2lkZW50aWZpZXIoaWRl bnRpZmllciksIG1fbGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2VwYXJhdG9yKHNlcGFyYXRvcikg eyB9CisgICAgdmlydHVhbCB+Q291bnRlcigpIHsgfQogCi1wcml2YXRlOgotICAgIFN0cmluZyBt X2lkZW50aWZpZXI7Ci0gICAgU3RyaW5nIG1fbGlzdFN0eWxlOwotICAgIFN0cmluZyBtX3NlcGFy YXRvcjsKLX07CisgICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25zdCB7IHJldHVybiBtX2lkZW50 aWZpZXIuZ2V0KCkgPyBtX2lkZW50aWZpZXIuZ2V0KCktPmdldFN0cmluZ1ZhbHVlKCkgOiBTdHJp bmcoKTsgfQorICAgIFN0cmluZyBsaXN0U3R5bGUoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHls ZS5nZXQoKSA/IG1fbGlzdFN0eWxlLmdldCgpLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7 IH0KKyAgICBTdHJpbmcgc2VwYXJhdG9yKCkgY29uc3QgeyByZXR1cm4gbV9zZXBhcmF0b3IuZ2V0 KCkgPyBtX3NlcGFyYXRvci5nZXQoKS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CiAK LX0gLy8gbmFtZXNwYWNlCisgICAgaW50IGxpc3RTdHlsZU51bWJlcigpIGNvbnN0IHsgcmV0dXJu IG1fbGlzdFN0eWxlLmdldCgpID8gKGludCkgbV9saXN0U3R5bGUuZ2V0KCktPmdldEZsb2F0VmFs dWUoKSA6IDA7IH0KKyAgICAKKyAgICB2b2lkIHNldElkZW50aWZpZXIoUGFzc1JlZlB0cjxDU1NQ cmltaXRpdmVWYWx1ZT4gaWRlbnRpZmllcikgeyBtX2lkZW50aWZpZXIgPSBpZGVudGlmaWVyOyB9 CisgICAgdm9pZCBzZXRMaXN0U3R5bGUoUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbGlz dFN0eWxlKSB7IG1fbGlzdFN0eWxlID0gbGlzdFN0eWxlOyB9CisgICAgdm9pZCBzZXRTZXBhcmF0 b3IoUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gc2VwYXJhdG9yKSB7IG1fc2VwYXJhdG9y ID0gc2VwYXJhdG9yOyB9CisgCitwcm90ZWN0ZWQ6CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZh bHVlPiBtX2lkZW50aWZpZXI7IC8vc3RyaW5nCisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBtX2xpc3RTdHlsZTsgLy9pbnQKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IG1fc2Vw YXJhdG9yOyAvL3N0cmluZworIH07CiAKK30gLy9uYW1lc3BhY2UKKwogI2VuZGlmCkluZGV4OiBj c3MvY3NzcGFyc2VyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3NzcGFyc2VyLmNwcAkocmV2aXNp b24gMTY1MjgpCisrKyBjc3MvY3NzcGFyc2VyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjUsNiAr MjUsNyBAQAogI2luY2x1ZGUgImNzc3BhcnNlci5oIgogCiAjaW5jbHVkZSAiQ1NTQm9yZGVySW1h Z2VWYWx1ZS5oIgorI2luY2x1ZGUgIkNvdW50ZXIuaCIKICNpbmNsdWRlICJDU1NJbWFnZVZhbHVl LmgiCiAjaW5jbHVkZSAiQ1NTQ2hhcnNldFJ1bGUuaCIKICNpbmNsdWRlICJDU1NJbXBvcnRSdWxl LmgiCkBAIC04NzAsNiArODcxLDE3IEBACiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIHZhbGlk X3ByaW1pdGl2ZSA9ICghaWQgJiYgdmFsaWRVbml0KHZhbHVlLCBGTnVtYmVyfEZMZW5ndGh8RlBl cmNlbnQsIHN0cmljdCkpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIENTU19QUk9QX0NPVU5U RVJfSU5DUkVNRU5UOiAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwgbm9uZSB8 IGluaGVyaXQKKyAgICAgICAgaWYgKGlkID09IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAgIHZh bGlkX3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiBw YXJzZUNvdW50ZXIocHJvcElkLCB0cnVlLCBpbXBvcnRhbnQpOworICAgICAgICBicmVhazsKKyAg ICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX1JFU0VUOiAgICAgICAgLy8gWyA8aWRlbnRpZmllcj4g PGludGVnZXI+PyBdKyB8IG5vbmUgfCBpbmhlcml0CisgICAgICAgICBpZiAoaWQgPT0gQ1NTX1ZB TF9OT05FKQorICAgICAgICAgICAgIHZhbGlkX3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGVs c2UKKyAgICAgICAgICAgIHJldHVybiBwYXJzZUNvdW50ZXIocHJvcElkLCBmYWxzZSwgaW1wb3J0 YW50KTsKICAgICBjYXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFt aWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVy aWMtZmFtaWx5Pl0gfCBpbmhlcml0CiAgICAgewpAQCAtMTUzMywxOCArMTU0NSwzMCBAQAogICAg ICAgICAgICAgcGFyc2VkVmFsdWUgPSBuZXcgQ1NTSW1hZ2VWYWx1ZSgKICAgICAgICAgICAgICAg ICBTdHJpbmcoS1VSTChzdHlsZUVsZW1lbnQtPmJhc2VVUkwoKS5kZXByZWNhdGVkU3RyaW5nKCks IHZhbHVlLmRlcHJlY2F0ZWRTdHJpbmcoKSkudXJsKCkpLCBzdHlsZUVsZW1lbnQpOwogICAgICAg ICB9IGVsc2UgaWYgKHZhbC0+dW5pdCA9PSBWYWx1ZTo6RnVuY3Rpb24pIHsKLSAgICAgICAgICAg IC8vIGF0dHIoWCkKKyAgICAgICAgICAgIC8vIGF0dHIoWCkgfCBjb3VudGVyKFggWyxZXSkgfCBj b3VudGVycyhYLCBZLCBbLFpdKQogICAgICAgICAgICAgVmFsdWVMaXN0ICphcmdzID0gdmFsLT5m dW5jdGlvbi0+YXJnczsKICAgICAgICAgICAgIFN0cmluZyBmbmFtZSA9IGRvbVN0cmluZyh2YWwt PmZ1bmN0aW9uLT5uYW1lKS5sb3dlcigpOwotICAgICAgICAgICAgaWYgKGZuYW1lICE9ICJhdHRy KCIgfHwgIWFyZ3MpCisgICAgICAgICAgICBpZiAoIWFyZ3MpCiAgICAgICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOwotICAgICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAg ICAgaWYgKGZuYW1lID09ICJhdHRyKCIpIHsKKyAgICAgICAgICAgICAgICBpZiAoYXJncy0+c2l6 ZSgpICE9IDEpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAg ICAgICBWYWx1ZSAqYSA9IGFyZ3MtPmN1cnJlbnQoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcg YXR0ck5hbWUgPSBkb21TdHJpbmcoYS0+c3RyaW5nKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9j dW1lbnQoKS0+aXNIVE1MRG9jdW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgYXR0ck5hbWUg PSBhdHRyTmFtZS5sb3dlcigpOworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENT U1ByaW1pdGl2ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0FUVFIpOwor ICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXIoIikg eworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3VudGVyQ29udGVudChhcmdz LCBmYWxzZSk7CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZhbHNl OworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXJz KCIpIHsKKyAgICAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IHBhcnNlQ291bnRlckNvbnRlbnQo YXJncywgdHJ1ZSk7CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZh bHNlOworICAgICAgICAgICAgfQorICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgIHJl dHVybiBmYWxzZTsKLSAgICAgICAgICAgIFZhbHVlICphID0gYXJncy0+Y3VycmVudCgpOwotICAg ICAgICAgICAgU3RyaW5nIGF0dHJOYW1lID0gZG9tU3RyaW5nKGEtPnN0cmluZyk7Ci0gICAgICAg ICAgICBpZiAoZG9jdW1lbnQoKS0+aXNIVE1MRG9jdW1lbnQoKSkKLSAgICAgICAgICAgICAgICBh dHRyTmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7Ci0gICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5l dyBDU1NQcmltaXRpdmVWYWx1ZShhdHRyTmFtZSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19BVFRS KTsKICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNT U19JREVOVCkgewogICAgICAgICAgICAgLy8gb3Blbi1xdW90ZQogICAgICAgICAgICAgLy8gY2xv c2UtcXVvdGUKQEAgLTE5NzgsNiArMjAwMiw1NCBAQAogfQogI2VuZGlmCiAKK0NTU1ZhbHVlKiBD U1NQYXJzZXI6OnBhcnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0ICphcmdzLCBib29sIGNvdW50 ZXJzKQoreworICAgIGlmIChjb3VudGVycyB8fCAoYXJncy0+c2l6ZSgpICE9IDEgJiYgYXJncy0+ c2l6ZSgpICE9IDMpKQorICAgICAgICBpZiAoIWNvdW50ZXJzIHx8IChhcmdzLT5zaXplKCkgIT0g MyAmJiBhcmdzLT5zaXplKCkgIT0gNSkpCisgICAgICAgICAgICByZXR1cm4gMDsKKworICAgIFZh bHVlICppID0gYXJncy0+Y3VycmVudCgpOworICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBpZGVudGlm aWVyID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCBDU1NQcmlt aXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7CisKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSogc2VwYXJh dG9yID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKFN0cmluZygpLCBDU1NQcmltaXRpdmVWYWx1ZTo6 Q1NTX1NUUklORyk7CisgICAgaWYgKGNvdW50ZXJzKSB7CisgICAgICAgIGkgPSBhcmdzLT5uZXh0 KCk7CisgICAgICAgIGlmIChpLT51bml0ICE9IFZhbHVlOjpPcGVyYXRvciB8fCBpLT5pVmFsdWUg IT0gJywnKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBpID0gYXJn cy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NT X1NUUklORykKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgc2VwYXJh dG9yID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCAoQ1NTUHJp bWl0aXZlVmFsdWU6OlVuaXRUeXBlcykgaS0+dW5pdCk7CisgICAgfQorICAgIAorICAgIC8vIE1h a2UgdGhlIGxpc3Qgc3R5bGUgZGVmYXVsdCBkZWNpbWFsCisgICAgQ1NTUHJpbWl0aXZlVmFsdWUq IGxpc3RTdHlsZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShDU1NfVkFMX0RFQ0lNQUwgLSBDU1Nf VkFMX0RJU0MsIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICBpID0gYXJncy0+ bmV4dCgpOworICAgIGlmIChpKSB7CisgICAgICAgIGlmIChpLT51bml0ICE9IFZhbHVlOjpPcGVy YXRvciB8fCBpLT5pVmFsdWUgIT0gJywnKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAg IAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+dW5pdCAhPSBDU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAg IAorICAgICAgICBzaG9ydCBscyA9IDA7CisgICAgICAgIGlmIChpLT5pZCA9PSBDU1NfVkFMX05P TkUpCisgICAgICAgICAgICBscyA9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEgLSBDU1NfVkFMX0RJ U0MgKyAxOworICAgICAgICBlbHNlIGlmIChpLT5pZCA+PSBDU1NfVkFMX0RJU0MgJiYgaS0+aWQg PD0gQ1NTX1ZBTF9LQVRBS0FOQV9JUk9IQSkKKyAgICAgICAgICAgIGxzID0gaS0+aWQgLSBDU1Nf VkFMX0RJU0M7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAg IGxpc3RTdHlsZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShscywgKENTU1ByaW1pdGl2ZVZhbHVl OjpVbml0VHlwZXMpIGktPnVuaXQpOworICAgIH0KKyAgICAKKyAgICBDb3VudGVyKiBjb3VudGVy ID0gbmV3IENvdW50ZXIoaWRlbnRpZmllciwgbGlzdFN0eWxlLCBzZXBhcmF0b3IpOworICAgIHJl dHVybiBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoY291bnRlcik7Cit9CisKIGJvb2wgQ1NTUGFyc2Vy OjpwYXJzZVNoYXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KQogewogICAgIFZhbHVlICp2 YWx1ZSA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOwpAQCAtMjY3Niw2ICsyNzQ4LDUyIEBACiAgICAg cmV0dXJuIGNvbnRleHQuZmFpbGVkKCk7CiB9CiAKK2Jvb2wgQ1NTUGFyc2VyOjpwYXJzZUNvdW50 ZXIoaW50IHByb3BJZCwgYm9vbCBpbmNyZW1lbnQsIGJvb2wgaW1wb3J0YW50KQoreworICAgIGVu dW0geyBJRCwgVkFMIH0gc3RhdGUgPSBJRDsKKworICAgIENTU1ZhbHVlTGlzdCogbGlzdCA9IG5l dyBDU1NWYWx1ZUxpc3Q7CisgICAgVmFsdWUqIHZhbDsKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSog Y291bnRlck5hbWU7CisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIG51bVZhbHVlOworICAgIAorICAg IHdoaWxlICh0cnVlKSB7CisgICAgICAgIHZhbCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOworICAg ICAgICBzd2l0Y2ggKHN0YXRlKSB7CisgICAgICAgICAgICBjYXNlIElEOgorICAgICAgICAgICAg ICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQp IHsKKyAgICAgICAgICAgICAgICAgICAgY291bnRlck5hbWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFs dWUoZG9tU3RyaW5nKHZhbC0+c3RyaW5nKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcp OworICAgICAgICAgICAgICAgICAgICBzdGF0ZSA9IFZBTDsKKyAgICAgICAgICAgICAgICAgICAg dmFsdWVMaXN0LT5uZXh0KCk7CisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGNhc2UgVkFM OiB7CisgICAgICAgICAgICAgICAgaW50IGkgPSAoaW5jcmVtZW50KSA/IDEgOiAwOworICAgICAg ICAgICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1Nf TlVNQkVSKSB7CisgICAgICAgICAgICAgICAgICAgIGkgPSAoc2hvcnQpdmFsLT5mVmFsdWU7Cisg ICAgICAgICAgICAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOworICAgICAgICAgICAgICAgIH0K KworICAgICAgICAgICAgICAgIG51bVZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGksIENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICAgICAgICAgICAgICBQYWlyKiBwYWly ID0gbmV3IFBhaXIoY291bnRlck5hbWUsIG51bVZhbHVlKTsKKyAgICAgICAgICAgICAgICBsaXN0 LT5hcHBlbmQobmV3IENTU1ByaW1pdGl2ZVZhbHVlKHBhaXIpKTsKKyAgICAgICAgICAgICAgICBz dGF0ZSA9IElEOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAg ICAgICB9CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICAKKyAgICBpZihsaXN0LT5sZW5ndGgo KSA+IDApIHsKKyAgICAgICAgYWRkUHJvcGVydHkocHJvcElkLCBsaXN0LCBpbXBvcnRhbnQpOwor ICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICBkZWxldGUgbGlzdDsKKyAgICByZXR1 cm4gZmFsc2U7Cit9CisKICNpZmRlZiBDU1NfREVCVUcKIAogc3RhdGljIGlubGluZSBpbnQgeXll cnJvcihjb25zdCBjaGFyICpzdHIpCg== 10763 2006-09-25 13:04:43 -0700 2006-09-26 17:21:16 -0700 Patch with minor adjustments postingMonday.txt text/plain 67498 bdakin SW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5kZXJP YmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0IChD KSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkg QW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAg RGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQgQWxs YW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChDKSAy MDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMjks NiArMzAsOCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIgCiAjaW5jbHVkZSAiQWZmaW5l VHJhbnNmb3JtLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKKyNpbmNsdWRlICJDb3VudGVy Tm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKICNpbmNsdWRlICJEZWNvZGVy LmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFbGVtZW50LmgiCkBAIC0zNyw2 ICs0MCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQu aCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MT0xpc3RFbGVtZW50Lmgi CiAjaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJBcmVuYS5oIgogI2luY2x1 ZGUgIlJlbmRlckZsZXhpYmxlQm94LmgiCkBAIC0xNTksNiArMTYzLDcgQEAKIG1fcGFyZW50KCAw ICksCiBtX3ByZXZpb3VzKCAwICksCiBtX25leHQoIDAgKSwKK21fY291bnRlckxpc3QoIDAgKSwK IG1fdmVydGljYWxQb3NpdGlvbiggUG9zaXRpb25VbmRlZmluZWQgKSwKIG1fbmVlZHNMYXlvdXQo IGZhbHNlICksCiBtX25vcm1hbENoaWxkTmVlZHNMYXlvdXQoIGZhbHNlICksCkBAIC0yMzk1LDYg KzI0MDAsOCBAQAogCiB2b2lkIFJlbmRlck9iamVjdDo6ZGVzdHJveSgpCiB7CisgICAgZGVzdHJv eUNvdW50ZXJzKCk7CisgICAgCiAgICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5yZW1v dmUodGhpcyk7CiAKICAgICAvLyBCeSBkZWZhdWx0IG5vIHJlZi1jb3VudGluZy4gUmVuZGVyV2lk Z2V0OjpkZXN0cm95KCkgZG9lc24ndCBjYWxsCkBAIC0yODM3LDYgKzI4NDQsMTcwIEBACiAgICAg cmV0dXJuIChhdm9pZHNGbG9hdHMoKSAmJiAoc3R5bGUoKS0+d2lkdGgoKS5pc0F1dG8oKSB8fCBp c0hSKCkgfHwgKHN0eWxlKCktPmh0bWxIYWNrcygpICYmICFpc1RhYmxlKCkpKSk7CiB9CiAKK2Jv b2wgUmVuZGVyT2JqZWN0OjpoYXNDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlcikgY29uc3QK K3sKKyAgICBpZiAoc3R5bGUoKSkKKyAgICAgICAgaWYgKGxvb2t1cENvdW50ZXIoY291bnRlcikg fHwgc3R5bGUoKS0+aGFzQ291bnRlclJlc2V0KGNvdW50ZXIpIHx8IAorICAgICAgICAgICAgICAg IHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpCisgICAgICAgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICAKKyAgICBpZiAoY291bnRlciA9PSAibGlzdC1pdGVtIikKKyAgICAgICAg aWYgKGlzTGlzdEl0ZW0oKSB8fCAoZWxlbWVudCgpICYmICgKKyAgICAgICAgICAgICAgICBlbGVt ZW50KCktPmhhc1RhZ05hbWUob2xUYWcpIHx8CisgICAgICAgICAgICAgICAgZWxlbWVudCgpLT5o YXNUYWdOYW1lKHVsVGFnKSB8fAorICAgICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFt ZShtZW51VGFnKSB8fAorICAgICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFtZShkaXJU YWcpKSkpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKworICAgIHJldHVybiBmYWxzZTsKK30K KworQ291bnRlck5vZGUqIFJlbmRlck9iamVjdDo6Z2V0Q291bnRlcihjb25zdCBTdHJpbmcmIGNv dW50ZXIsIGJvb2wgdmlldywgYm9vbCBjb3VudGVycykKK3sKKyAgICBpZiAoIXN0eWxlKCkpCisg ICAgICAgIHJldHVybiAwOworCisgICAgaW50IHZhbCA9IDA7CisgICAgQ291bnRlck5vZGUgKm5l d05vZGUgPSBsb29rdXBDb3VudGVyKGNvdW50ZXIpOworICAgIGlmIChuZXdOb2RlKQorICAgICAg ICByZXR1cm4gbmV3Tm9kZTsKKworICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVyUmVzZXQoY291 bnRlcikgfHwgaXNSb290KCkpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXRO b2RlKHRoaXMpOworICAgICAgICB2YWwgPSBzdHlsZSgpLT5jb3VudGVyUmVzZXQoY291bnRlcik7 CisgICAgICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50ZXIpKQorICAg ICAgICAgICAgdmFsICs9IHN0eWxlKCktPmNvdW50ZXJJbmNyZW1lbnQoY291bnRlcik7CisgICAg fSBlbHNlIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50ZXIpKSB7CisgICAg ICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUodGhpcyk7CisgICAgICAgIHZhbCArPSBzdHls ZSgpLT5jb3VudGVySW5jcmVtZW50KGNvdW50ZXIpOworICAgIH0gZWxzZSBpZiAoY291bnRlciA9 PSAibGlzdC1pdGVtIikgeworICAgICAgICBpZiAoaXNMaXN0SXRlbSgpKSB7CisgICAgICAgICAg ICBpZiAoZWxlbWVudCgpKSB7CisgICAgICAgICAgICAgICAgU3RyaW5nIHYgPSBzdGF0aWNfY2Fz dDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0QXR0cmlidXRlKCJ2YWx1ZSIpOworICAgICAgICAg ICAgICAgIGlmICghdi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3Tm9kZSA9 IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgICAgICAgICB2YWwgPSB2 LnRvSW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSAKKyAgICAgICAgICAg IAorICAgICAgICAgICAgaWYgKCFuZXdOb2RlKSB7CisgICAgICAgICAgICAgICAgbmV3Tm9kZSA9 IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAgICAgICAgICAgICB2YWwgPSAxOworICAgICAg ICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKGVsZW1lbnQoKSAmJiBlbGVtZW50KCktPmhhc1Rh Z05hbWUob2xUYWcpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJSZXNldE5v ZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSBzdGF0aWNfY2FzdDxIVE1MT0xpc3RFbGVtZW50 Kj4oZWxlbWVudCgpKS0+c3RhcnQoKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVtZW50KCkgJiYK KyAgICAgICAgICAgIChlbGVtZW50KCktPmhhc1RhZ05hbWUodWxUYWcpIHx8CisgICAgICAgICAg ICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAgICAgZWxlbWVu dCgpLT5oYXNUYWdOYW1lKGRpclRhZykpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IENv dW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSAwOworICAgICAgICB9Cisg ICAgfSAKKyAgICAKKyAgICBpZiAoIW5ld05vZGUpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBD b3VudGVyTm9kZSh0aGlzKTsKKyAgICAgICAgdmFsID0gMDsKKyAgICB9CisgICAgCisgICAgbmV3 Tm9kZS0+c2V0VmFsdWUodmFsKTsKKyAgICBpZiAodmlldykKKyAgICAgICAgbmV3Tm9kZS0+c2V0 SXNWaXN1YWwoKTsKKyAgICBpZiAoY291bnRlcnMpCisgICAgICAgIG5ld05vZGUtPnNldEhhc0Nv dW50ZXJzKCk7CisKKyAgICBpbnNlcnRDb3VudGVyKGNvdW50ZXIsIG5ld05vZGUpOworCisgICAg aWYgKCFpc1Jvb3QoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IDA7CisgICAgICAg IENvdW50ZXJOb2RlKiBjdXJyZW50ID0gMDsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiBuID0gIWlz TGlzdEl0ZW0oKSAmJiBwcmV2aW91c1NpYmxpbmcoKSA/IAorICAgICAgICAgICAgcHJldmlvdXNT aWJsaW5nKCktPnByZXZpb3VzU2libGluZygpIDogcHJldmlvdXNTaWJsaW5nKCk7CisKKyAgICAg ICAgd2hpbGUgKG4pIHsKKyAgICAgICAgICAgIGlmIChuLT5oYXNDb3VudGVyKGNvdW50ZXIpKSB7 CisgICAgICAgICAgICAgICAgY3VycmVudCA9IG4tPmdldENvdW50ZXIoY291bnRlcik7CisgICAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBu ID0gbi0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGxh c3QgPSBjdXJyZW50OworICAgICAgICBDb3VudGVyTm9kZSogc2libGluZyA9IGN1cnJlbnQ7Cisg ICAgICAgIGlmIChsYXN0ICYmICFuZXdOb2RlLT5pc1Jlc2V0KCkpIHsKKyAgICAgICAgICAgIC8v IEZvdW5kIHJlbmRlci1zaWJsaW5nLCBub3cgc2VhcmNoIGZvciBsYXRlciBjb3VudGVyLXNpYmxp bmdzIGFtb25nIGl0cyByZW5kZXItY2hpbGRyZW4KKyAgICAgICAgICAgIG4gPSBuLT5sYXN0Q2hp bGQoKTsKKyAgICAgICAgICAgIHdoaWxlIChuKSB7CisgICAgICAgICAgICAgICAgaWYgKG4tPmhh c0NvdW50ZXIoY291bnRlcikpIHsKKyAgICAgICAgICAgICAgICAgICAgY3VycmVudCA9IG4tPmdl dENvdW50ZXIoY291bnRlcik7CisgICAgICAgICAgICAgICAgICAgIGlmIChsYXN0LT5wYXJlbnQo KSA9PSBjdXJyZW50LT5wYXJlbnQoKSB8fCBzaWJsaW5nID09IGN1cnJlbnQtPnBhcmVudCgpKSB7 CisgICAgICAgICAgICAgICAgICAgICAgICBsYXN0ID0gY3VycmVudDsKKyAgICAgICAgICAgICAg ICAgICAgICAgIC8vIElmIHRoZSBjdXJyZW50IGNvdW50ZXIgaXMgbm90IHRoZSBsYXN0LCBzZWFy Y2ggZGVlcGVyCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoY3VycmVudC0+bmV4dFNpYmxp bmcoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgIG4gPSBuLT5sYXN0Q2hpbGQoKTsK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICAg ICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIG4gPSBu LT5wcmV2aW91c1NpYmxpbmcoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIAorICAgICAg ICAgICAgaWYgKHNpYmxpbmctPmlzUmVzZXQoKSkgeworICAgICAgICAgICAgICAgIGlmIChsYXN0 ICE9IHNpYmxpbmcpCisgICAgICAgICAgICAgICAgICAgIHNpYmxpbmctPmluc2VydEFmdGVyKG5l d05vZGUsIGxhc3QpOworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAg c2libGluZy0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAgICAgICB9IGVsc2UKKyAg ICAgICAgICAgICAgICBsYXN0LT5wYXJlbnQoKS0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7 CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAvLyBOb3RoaW5nIGZvdW5kIGFtb25nIHNp YmxpbmdzLCBsZXQgb3VyIHBhcmVudCBzZWFyY2gKKyAgICAgICAgICAgIGxhc3QgPSBwYXJlbnQo KS0+Z2V0Q291bnRlcihjb3VudGVyLCBmYWxzZSk7CisgICAgICAgICAgICBpZiAobGFzdC0+aXNS ZXNldCgpKQorICAgICAgICAgICAgICAgIGxhc3QtPmluc2VydEFmdGVyKG5ld05vZGUsIDApOwor ICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGxhc3QtPnBhcmVudCgpLT5pbnNlcnRB ZnRlcihuZXdOb2RlLCBsYXN0KTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBuZXdO b2RlOworfQorCitDb3VudGVyTm9kZSogUmVuZGVyT2JqZWN0Ojpsb29rdXBDb3VudGVyKGNvbnN0 IFN0cmluZyYgY291bnRlcikgY29uc3QKK3sKKyAgICBDb3VudGVyTGlzdCogaSA9IG1fY291bnRl ckxpc3Q7CisgICAgd2hpbGUgKGkpIHsKKyAgICAgICAgaWYgKGktPmNvdW50ZXIgPT0gY291bnRl cikKKyAgICAgICAgICAgIHJldHVybiBpLT5tX2NvdW50ZXJOb2RlOworICAgICAgICBpID0gaS0+ bmV4dDsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKK3ZvaWQgUmVuZGVyT2JqZWN0OjpkZXN0 cm95Q291bnRlcnMoKQoreworICAgIENvdW50ZXJMaXN0KiBqOworICAgIENvdW50ZXJMaXN0KiBp ID0gbV9jb3VudGVyTGlzdDsKKyAgICBtX2NvdW50ZXJMaXN0ID0gMDsKKyAgICB3aGlsZSAoaSkg eworICAgICAgICBpLT5tX2NvdW50ZXJOb2RlLT5yZW1vdmUoKTsKKyAgICAgICAgZGVsZXRlIGkt Pm1fY291bnRlck5vZGU7CisgICAgICAgIGogPSBpOworICAgICAgICBpID0gaS0+bmV4dDsKKyAg ICAgICAgZGVsZXRlIGo7CisgICAgfQorfQorCit2b2lkIFJlbmRlck9iamVjdDo6aW5zZXJ0Q291 bnRlcihjb25zdCBTdHJpbmcmIGNvdW50ZXIsIENvdW50ZXJOb2RlKiB2YWwpCit7CisgICAgQ291 bnRlckxpc3QqIGkgPSBuZXcgQ291bnRlckxpc3Q7CisgICAgaS0+Y291bnRlciA9IGNvdW50ZXI7 CisgICAgaS0+bV9jb3VudGVyTm9kZSA9IHZhbDsKKyAgICBpLT5uZXh0ID0gbV9jb3VudGVyTGlz dDsKKyAgICBtX2NvdW50ZXJMaXN0ID0gaTsKK30KKwogVUNoYXIgUmVuZGVyT2JqZWN0OjpiYWNr c2xhc2hBc0N1cnJlbmN5U3ltYm9sKCkgY29uc3QKIHsKICAgICBpZiAoTm9kZSAqbm9kZSA9IGVs ZW1lbnQoKSkKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBy ZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1Jl bmRlck9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0 IChDKSAyMDAwIExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIw MDAgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIw MDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQg QWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChD KSAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgpAQCAtNTQsNiArNTUsNyBAQAogY2xhc3MgSFRNTEFyZWFFbGVtZW50OwogY2xhc3MgSW5saW5l Qm94OwogY2xhc3MgSW5saW5lRmxvd0JveDsKK2NsYXNzIENvdW50ZXJOb2RlOwogY2xhc3MgUG9z aXRpb247CiBjbGFzcyBSZW5kZXJBcmVuYTsKIGNsYXNzIFJlbmRlckJsb2NrOwpAQCAtMTkyLDYg KzE5NCwxNSBAQAogICAgIHZpcnR1YWwgaW50IHN0YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9 CiAgICAgdmlydHVhbCBpbnQgc3RhdGljWSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAg ICBib29sIGhhc0NvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdDsKKyAgICBDb3Vu dGVyTm9kZSogZ2V0Q291bnRlcihjb25zdCBTdHJpbmcmIGNvdW50ZXIsIGJvb2wgdmlldyA9IGZh bHNlLCBib29sIGNvdW50ZXJzID0gZmFsc2UpOworICAgIHZvaWQgZGVzdHJveUNvdW50ZXJzKCk7 CisKK3Byb3RlY3RlZDoKKyAgICB2b2lkIGluc2VydENvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3Vu dGVyLCBDb3VudGVyTm9kZSogdmFsdWUpOworICAgIENvdW50ZXJOb2RlKiBsb29rdXBDb3VudGVy KGNvbnN0IFN0cmluZyYgY291bnRlcikgY29uc3Q7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJP YmplY3QgdHJlZSBtYW5pcHVsYXRpb24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8v Ly8vLy8vLy8vLy8vLy8KICAgICB2aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7 CkBAIC0yNTMsNiArMjY0LDcgQEAKICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgp IGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigp IGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29s IGlzQm9keSgpIGNvbnN0OwpAQCAtOTAyLDYgKzkxNCwxMiBAQAogICAgIFJlbmRlck9iamVjdCAq bV9wYXJlbnQ7CiAgICAgUmVuZGVyT2JqZWN0ICptX3ByZXZpb3VzOwogICAgIFJlbmRlck9iamVj dCAqbV9uZXh0OworICAgIAorICAgIHN0cnVjdCBDb3VudGVyTGlzdCB7CisgICAgICAgIFN0cmlu ZyBjb3VudGVyOworICAgICAgICBDb3VudGVyTm9kZSAqbV9jb3VudGVyTm9kZTsKKyAgICAgICAg Q291bnRlckxpc3QgKm5leHQ7CisgICAgfSAqbV9jb3VudGVyTGlzdDsKIAogICAgIG11dGFibGUg c2hvcnQgbV92ZXJ0aWNhbFBvc2l0aW9uOwogCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyQ291bnRl ci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDAp CisrKyByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU2 IEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2lu ZSBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5z ZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0 ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMg TGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZl ZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFs b25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3Qs IHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1w bGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAq CisgKi8KKyNpZm5kZWYgUkVOREVSX0NPVU5URVJfSF8KKyNkZWZpbmUgUkVOREVSX0NPVU5URVJf SF8KKworI2luY2x1ZGUgIkRlcHJlY2F0ZWRTdHJpbmcuaCIKKyNpbmNsdWRlICJSZW5kZXJUZXh0 LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8g LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KKworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5k ZXJUZXh0Cit7CitwdWJsaWM6CisgICAgUmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVy RGF0YSogY291bnRlcik7CisgICAgdmlydHVhbCB+UmVuZGVyQ291bnRlcigpIHt9OworCisgICAg dmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4gIlJlbmRlckNv dW50ZXIiOyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1cm4g dHJ1ZTsgfQorICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgY2Fs Y01pbk1heFdpZHRoKCk7CisKK3Byb3RlY3RlZDoKKyAgICBEZXByZWNhdGVkU3RyaW5nIHRvTGlz dFN0eWxlVHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSk7CisK KyAgICBEZXByZWNhdGVkU3RyaW5nIG1faXRlbTsKKyAgICBDb3VudGVyRGF0YSogbV9jb3VudGVy OworICAgIENvdW50ZXJOb2RlKiBtX2NvdW50ZXJOb2RlOworfTsKKworfSAvL25hbWVzcGFjZQor CisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmlu Zy9Db3VudGVyUmVzZXROb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjQgQEAKKy8qCisg KiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUu CisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNh cmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgor ICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwg b3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJh cnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAq IGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJh bnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZv ciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0 aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8K KyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAt IFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZu ZGVmIF9Db3VudGVyX1Jlc2V0X05vZGVfaF8KKyNkZWZpbmUgX0NvdW50ZXJfUmVzZXRfTm9kZV9o XworCisjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisv LyBUaGlzIGZpbGUgaW1wbGVtZW50cyBhIGNvdW50ZXItdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZp bmRpbmcgYWxsIHBhcmVudHMgaW4gY291bnRlcnMoKSBsb29rdXAsCisvLyBhbmQgZm9yIHByb3Bh Z2F0aW5nIGNvdW50LWNoYW5nZXMgd2hlbiBub2RlcyBhcmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8v IFBsZWFzZSBub3RlIHRoYXQgb25seSBjb3VudGVyLXJlc2V0IGFuZCByb290IGNhbiBiZSBwYXJl bnRzIGhlcmUsIGFuZCB0aGF0IHJlbmRlci10cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0IGNvdW50 ZXItdHJlZSBzaWJsaW5ncworCisvLyBJbXBsZW1lbnRhdGlvbiBvZiBjb3VudGVyLXJlc2V0IGFu ZCByb290CitjbGFzcyBDb3VudGVyUmVzZXROb2RlIDogcHVibGljIENvdW50ZXJOb2RlCit7Citw dWJsaWM6CisgICAgQ291bnRlclJlc2V0Tm9kZShSZW5kZXJPYmplY3QqIG8pOworICAgIHZpcnR1 YWwgfkNvdW50ZXJSZXNldE5vZGUoKTsKKworICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIGZpcnN0 Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2ZpcnN0OyB9OworICAgIHZpcnR1YWwgQ291bnRlck5v ZGUqIGxhc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdDsgfTsKKyAgICB2aXJ0dWFsIHZv aWQgaW5zZXJ0QWZ0ZXIgKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNo aWxkKTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGls ZCk7CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNSZXNldCgpIHsgcmV0dXJuIHRydWU7IH07CisgICAg dmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBmaXJzdCA9IGZhbHNlKTsKKyAgICB2aXJ0dWFsIHZv aWQgc2V0U2VsZkRpcnR5KCk7CisgICAgdmlydHVhbCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisK KyAgICB2b2lkIHVwZGF0ZVRvdGFsKGludCB2YWx1ZSk7CisgICAgLy8gVGhlIGhpZ2hlc3QgdmFs dWUgYW1vbmcgY2hpbGRyZW4KKyAgICBpbnQgdG90YWwoKSBjb25zdCB7IHJldHVybiBtX3RvdGFs OyB9OworCitwcm90ZWN0ZWQ6CisgICAgaW50IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1f Zmlyc3Q7CisgICAgQ291bnRlck5vZGUqIG1fbGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKKworI2VuZGlmIC8vIENvdW50ZXJSZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0Nv dW50ZXJMaXN0SXRlbS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0u aAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00g aW1wbGVtZW50YXRpb24gZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2 IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisgCisjaWZuZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5l IENvdW50ZXJMaXN0SXRlbV9ICisKKyNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVy Tm9kZQoreworcHVibGljOgorICAgIGludCBjb3VudCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2 b2lkIHJlY291bnQoYm9vbCBmaXJzdCA9IGZhbHNlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2Vs ZkRpcnR5KCk7CisKK307CisKK30gLy9uYW1lc3BhY2UKKworI2VuZGlmClwgTm8gbmV3bGluZSBh dCBlbmQgb2YgZmlsZQpJbmRleDogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRl cmluZy9SZW5kZXJDb3VudGVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMjYgQEAKKy8q KgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3Ig S0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtk ZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIElu Yy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxh Y2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisjaW5jbHVk ZSAiQ291bnRlclJlc2V0Tm9kZS5oIgorI2luY2x1ZGUgIlJlbmRlckNvdW50ZXIuaCIKKyNpbmNs dWRlICJSZW5kZXJTdHlsZS5oIgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworLy8gLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQorCitSZW5kZXJDb3VudGVyOjpSZW5kZXJDb3VudGVyKE5vZGUqIG5vZGUs IENvdW50ZXJEYXRhKiBjb3VudGVyKQorICAgIDogUmVuZGVyVGV4dChub2RlLDApLCBtX2NvdW50 ZXIoY291bnRlciksIG1fY291bnRlck5vZGUoMCkKK3sKK30KKwordm9pZCBSZW5kZXJDb3VudGVy OjpsYXlvdXQoKQoreworICAgIEFTU0VSVChuZWVkc0xheW91dCgpKTsKKworICAgIGlmICghbWlu TWF4S25vd24oKSkKKyAgICAgICAgY2FsY01pbk1heFdpZHRoKCk7CisKKyAgICBSZW5kZXJUZXh0 OjpsYXlvdXQoKTsKK30KKworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworc3RhdGlj IERlcHJlY2F0ZWRTdHJpbmcgdG9Sb21hbihpbnQgbnVtYmVyLCBib29sIHVwcGVyKQoreyAKKyAg ICBEZXByZWNhdGVkU3RyaW5nIHJvbWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsg J2knLCAndicsICd4JywgJ2wnLCAnYycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRp Z2l0c1tdID0geyAnSScsICdWJywgJ1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25z dCBVQ2hhciogZGlnaXRzID0gdXBwZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9 IDA7CisgICAgZG8geworICAgICAgICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlm IChudW0gJSA1IDwgNCkKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsg aS0tKQorICAgICAgICAgICAgICAgIHJvbWFuLmluc2VydCgwLCBkaWdpdHNbZF0pOworICAgICAg ICBpZiAobnVtID49IDQgJiYgbnVtIDw9IDgpCisgICAgICAgICAgICByb21hbi5pbnNlcnQoMCwg ZGlnaXRzW2QgKyAxXSk7CisgICAgICAgIGlmIChudW0gPT0gOSkKKyAgICAgICAgICAgIHJvbWFu Lmluc2VydCgwLCBkaWdpdHNbZCArIDJdKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAg ICAgICAgICAgIHJvbWFuLmluc2VydCgwLCBkaWdpdHNbZF0pOworICAgICAgICBudW1iZXIgLz0g MTA7CisgICAgICAgIGQgKz0gMjsKKyAgICB9IHdoaWxlIChudW1iZXIpOworICAgIHJldHVybiBy b21hbjsKK30KKworc3RhdGljIERlcHJlY2F0ZWRTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51 bWJlciwgaW50IGxldHRlckEpCit7CisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVy biBEZXByZWNhdGVkQ2hhcihsZXR0ZXJBKTsgLy8gbWF0Y2ggV2luSUUgKEEuKSBub3QgRmlyZUZv eCAoMC4pCisKKyAgICBEZXByZWNhdGVkU3RyaW5nIGxldHRlclN0cmluZzsKKyAgICB3aGlsZSAo bnVtYmVyID4gMCkgeworICAgICAgICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7 CisgICAgICAgIGxldHRlclN0cmluZyA9IERlcHJlY2F0ZWRDaGFyKGxldHRlckEgKyBvbmVzRGln aXQpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0OworICAgICAg ICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsKK30KKwor c3RhdGljIERlcHJlY2F0ZWRTdHJpbmcgdG9IZWJyZXcoaW50IG51bWJlcikKK3sKKyAgICBpZiAo bnVtYmVyIDwgMSkKKyAgICAgICAgcmV0dXJuIERlcHJlY2F0ZWRTdHJpbmc6Om51bWJlcihudW1i ZXIpOworICAgIAorICAgIHN0YXRpYyBjb25zdCBEZXByZWNhdGVkQ2hhciB0ZW5EaWdpdFtdID0g ezE0OTcsIDE0OTksIDE1MDAsIDE1MDIsIDE1MDQsIDE1MDUsIDE1MDYsIDE1MDgsIDE1MTB9Owor CisgICAgRGVwcmVjYXRlZFN0cmluZyBsZXR0ZXI7CisgICAgaWYgKG51bWJlciA+IDk5OSkgewor ICAgICAgICBsZXR0ZXIgPSB0b0hlYnJldyhudW1iZXIgLyAxMDAwKSArICInIjsKKyAgICAgICAg bnVtYmVyID0gbnVtYmVyICUgMTAwMDsKKyAgICB9CisgICAgaW50IGZvdXJIdW5kcmVkcyA9IG51 bWJlciAvIDQwMDsKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGZvdXJIdW5kcmVkczsgaSsrKQor ICAgICAgICBsZXR0ZXIgKz0gRGVwcmVjYXRlZENoYXIoMTUxMSArIDMpOworICAgIG51bWJlciAl PSA0MDA7CisgICAgaWYgKG51bWJlciAvIDEwMCkKKyAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0 ZWRDaGFyKDE1MTEgKyAobnVtYmVyIC8gMTAwKSAtIDEpOworICAgIG51bWJlciAlPSAxMDA7Cisg ICAgaWYgKG51bWJlciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAgbGV0dGVyICs9 IERlcHJlY2F0ZWRDaGFyKDE0ODcgKyA5KTsKKyAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRD aGFyKDE0ODcgKyBudW1iZXIgLSA5KTsKKyAgICB9IGVsc2UgeworICAgICAgICBpbnQgdGVucyA9 IG51bWJlciAvIDEwOworICAgICAgICBpZiAodGVucykKKyAgICAgICAgICAgIGxldHRlciArPSB0 ZW5EaWdpdFt0ZW5zIC0gMV07CisgICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAg ICBpZiAobnVtYmVyKQorICAgICAgICAgICAgbGV0dGVyICs9IERlcHJlY2F0ZWRDaGFyKDE0ODcg KyBudW1iZXIpOworICAgIH0KKyAgICByZXR1cm4gbGV0dGVyOworfQorCitEZXByZWNhdGVkU3Ry aW5nIFJlbmRlckNvdW50ZXI6OnRvTGlzdFN0eWxlVHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwg RUxpc3RTdHlsZVR5cGUgdHlwZSkKK3sKKyAgICBEZXByZWNhdGVkU3RyaW5nIGl0ZW07CisgICAg c3dpdGNoKHR5cGUpIHsKKyAgICAgICAgY2FzZSBMTk9ORToKKyAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICAvLyBHbHlwaHM6CisgICAgICAgIGNhc2UgRElTQzoKKyAgICAgICAgICAgIGl0ZW0g PSBEZXByZWNhdGVkQ2hhcigweDIwMjIpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNh c2UgQ0lSQ0xFOgorICAgICAgICAgICAgaXRlbSA9IERlcHJlY2F0ZWRDaGFyKDB4MjVlNik7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBpdGVt ID0gRGVwcmVjYXRlZENoYXIoMHgyNWEwKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBj YXNlIEFSTUVOSUFOOgorICAgICAgICBjYXNlIEdFT1JHSUFOOgorICAgICAgICBjYXNlIENKS19J REVPR1JBUEhJQzoKKyAgICAgICAgY2FzZSBISVJBR0FOQToKKyAgICAgICAgY2FzZSBLQVRBS0FO QToKKyAgICAgICAgY2FzZSBISVJBR0FOQV9JUk9IQToKKyAgICAgICAgY2FzZSBLQVRBS0FOQV9J Uk9IQToKKyAgICAgICAgY2FzZSBERUNJTUFMX0xFQURJTkdfWkVSTzoKKyAgICAgICAgICAgIC8v ICMjIyB1bnN1cHBvcnRlZCwgd2UgdXNlIGRlY2ltYWwgaW5zdGVhZAorICAgICAgICBjYXNlIExE RUNJTUFMOgorICAgICAgICAgICAgaXRlbS5zZXROdW0odmFsdWUpOworICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIC8vIEFsZ29yaXRtaWM6CisgICAgICAgIGNhc2UgTE9XRVJfUk9NQU46Cisg ICAgICAgICAgICBpdGVtID0gdG9Sb21hbih2YWx1ZSwgZmFsc2UpOworICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIGNhc2UgVVBQRVJfUk9NQU46CisgICAgICAgICAgICBpdGVtID0gdG9Sb21h bih2YWx1ZSwgdHJ1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBMT1dFUl9H UkVFSzogeworICAgICAgICAgICAgaW50IG51bWJlciA9IHZhbHVlIC0gMTsKKyAgICAgICAgICAg IGludCBsID0gKG51bWJlciAlIDI0KTsKKyAgICAgICAgICAgIGlmIChsID4gMTYpCisgICAgICAg ICAgICAgICAgbCsrOyAvLyBTa2lwIEdSRUVLIFNNQUxMIExFVFRFUiBGSU5BTCBTSUdNQQorICAg ICAgICAgICAgaXRlbSA9IERlcHJlY2F0ZWRDaGFyKDk0NSArIGwpOworICAgICAgICAgICAgZm9y IChpbnQgaSA9IDA7IGkgPCAobnVtYmVyIC8gMjQpOyBpKyspCisgICAgICAgICAgICAgICAgaXRl bSArPSAiJyI7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgICAgICBjYXNlIEhF QlJFVzoKKyAgICAgICAgICAgIGl0ZW0gPSB0b0hlYnJldyh2YWx1ZSk7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBMT1dFUl9BTFBIQToKKyAgICAgICAgY2FzZSBMT1dFUl9MQVRJ TjoKKyAgICAgICAgICAgIGl0ZW0gPSB0b0xldHRlclN0cmluZyh2YWx1ZSwgJ2EnKTsKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFVQUEVSX0FMUEhBOgorICAgICAgICBjYXNlIFVQ UEVSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVlLCAnQScp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBpdGVt LnNldE51bSh2YWx1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIGl0 ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6Y2FsY01pbk1heFdpZHRoKCkKK3sKKyAgICBB U1NFUlQoIW1pbk1heEtub3duKCkpOworCisgICAgaWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1 cm47CisKKyAgICBib29sIGNvdW50ZXJzOworICAgIGNvdW50ZXJzID0gIW1fY291bnRlci0+c2Vw YXJhdG9yKCkuaXNOdWxsKCk7CisKKyAgICBpZiAoIW1fY291bnRlck5vZGUgJiYgcGFyZW50KCkt PnBhcmVudCgpKQorICAgICAgICBtX2NvdW50ZXJOb2RlID0gcGFyZW50KCktPnBhcmVudCgpLT5n ZXRDb3VudGVyKG1fY291bnRlci0+aWRlbnRpZmllcigpLCB0cnVlLCBjb3VudGVycyk7CisKKyAg ICBpbnQgdmFsdWUgPSBtX2NvdW50ZXJOb2RlLT5jb3VudCgpOworICAgIGlmIChtX2NvdW50ZXJO b2RlLT5pc1Jlc2V0KCkpCisgICAgICAgIHZhbHVlID0gbV9jb3VudGVyTm9kZS0+dmFsdWUoKTsK KyAgICAKKyAgICBpbnQgdG90YWwgPSB2YWx1ZTsKKyAgICBpZiAobV9jb3VudGVyTm9kZS0+cGFy ZW50KCkpCisgICAgICAgIHRvdGFsID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCktPnRvdGFsKCk7 CisgICAgCisgICAgbV9pdGVtID0gdG9MaXN0U3R5bGVUeXBlKHZhbHVlLCB0b3RhbCwgKEVMaXN0 U3R5bGVUeXBlKW1fY291bnRlci0+bGlzdFN0eWxlKCkpOworCisgICAgaWYgKGNvdW50ZXJzKSB7 CisgICAgICAgIENvdW50ZXJOb2RlKiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCk7 CisgICAgICAgIGJvb2wgZmlyc3QgPSB0cnVlOworICAgICAgICB3aGlsZSAgKGNvdW50ZXItPnBh cmVudCgpICYmIChmaXJzdCB8fCAhKGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3VudGVyLT5wYXJl bnQoKS0+aXNSb290KCkpKSkgeworICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVyLT5jb3VudCgp ID8gY291bnRlci0+Y291bnQoKSA6IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNvdW50ZXItPnBh cmVudCgpLT50b3RhbCgpOworICAgICAgICAgICAgbV9pdGVtID0gdG9MaXN0U3R5bGVUeXBlKHZh bHVlLCB0b3RhbCwgKEVMaXN0U3R5bGVUeXBlKW1fY291bnRlci0+bGlzdFN0eWxlKCkpIAorICAg ICAgICAgICAgICAgICsgbV9jb3VudGVyLT5zZXBhcmF0b3IoKS5kZXByZWNhdGVkU3RyaW5nKCkg KyBtX2l0ZW07CisgICAgICAgICAgICBjb3VudGVyID0gY291bnRlci0+cGFyZW50KCk7CisgICAg ICAgICAgICBmaXJzdCA9IGZhbHNlOworICAgICAgICB9CisgICAgfQorCisgICAgc3RyID0gbmV3 IFN0cmluZ0ltcGwoKHN0YXRpY19jYXN0PFN0cmluZz4obV9pdGVtKSkuY2hhcmFjdGVycygpLCBt X2l0ZW0ubGVuZ3RoKCkpOworICAgIAorICAgIFJlbmRlclRleHQ6OmNhbGNNaW5NYXhXaWR0aCgp OworfQpJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5k ZXJpbmcvQ291bnRlck5vZGUuY3BwCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJO b2RlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5NyBAQAorLyoKKyAqIFRoaXMgZmlsZSBp cyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5 cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQor ICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgor ICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBv cHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1F UkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0 aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWls cy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsg c2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAor ICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5v ZGUuaCIKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgewor CitDb3VudGVyTm9kZTo6Q291bnRlck5vZGUoUmVuZGVyT2JqZWN0ICpvKQorICAgIDogbV9oYXND b3VudGVycyhmYWxzZSksIG1faXNWaXN1YWwoZmFsc2UpLAorICAgICAgbV92YWx1ZSgwKSwgbV9j b3VudCgwKSwgbV9wYXJlbnQoMCksIG1fcHJldmlvdXMoMCksIG1fbmV4dCgwKSwKKyAgICAgIG1f cmVuZGVyZXIobykge30KKworQ291bnRlck5vZGU6On5Db3VudGVyTm9kZSgpIHt9OworCit2b2lk IENvdW50ZXJOb2RlOjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSosIENvdW50ZXJOb2RlKikKK3sK KyAgICBBU1NFUlQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmVDaGlsZChD b3VudGVyTm9kZSopCit7CisgICAgQVNTRVJUKGZhbHNlKTsKK30KKwordm9pZCBDb3VudGVyTm9k ZTo6cmVtb3ZlKCkKK3sKKyAgICBpZiAobV9wYXJlbnQpCisgICAgICAgIG1fcGFyZW50LT5yZW1v dmVDaGlsZCh0aGlzKTsKKyAgICBlbHNlIHsKKyAgICAgICAgQVNTRVJUKGlzUmVzZXQoKSk7Cisg ICAgICAgIEFTU0VSVCghZmlyc3RDaGlsZCgpKTsKKyAgICAgICAgQVNTRVJUKCFsYXN0Q2hpbGQo KSk7CisgICAgfQorfQorCit2b2lkIENvdW50ZXJOb2RlOjpzZXRIYXNDb3VudGVycygpCit7Cisg ICAgbV9oYXNDb3VudGVycyA9IHRydWU7CisgICAgaWYgKHBhcmVudCgpKQorICAgICAgICBwYXJl bnQoKS0+c2V0SGFzQ291bnRlcnMoKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6cmVjb3VudChi b29sIGZpcnN0KQoreworICAgIGludCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3By ZXZpb3VzKQorICAgICAgICBtX2NvdW50ID0gbV9wcmV2aW91cy0+Y291bnQoKSArIG1fdmFsdWU7 CisgICAgZWxzZSB7CisgICAgICAgIGFzc2VydChtX3BhcmVudC0+Zmlyc3RDaGlsZCgpID09IHRo aXMpOworICAgICAgICBtX2NvdW50ID0gbV9wYXJlbnQtPnZhbHVlKCkgKyBtX3ZhbHVlOworICAg IH0KKyAgICBpZiAob2xkX2NvdW50ICE9IG1fY291bnQgJiYgIWZpcnN0KQorICAgICAgICBzZXRT ZWxmRGlydHkoKTsKKyAgICBpZiAob2xkX2NvdW50ICE9IG1fY291bnQgfHwgZmlyc3QpIHsKKyAg ICAgICAgaWYgKG1fcGFyZW50KQorICAgICAgICAgICAgbV9wYXJlbnQtPnVwZGF0ZVRvdGFsKG1f Y291bnQpOworICAgICAgICBpZiAobV9uZXh0KQorICAgICAgICAgICAgbV9uZXh0LT5yZWNvdW50 KCk7CisgICAgfQorfQorCit2b2lkIENvdW50ZXJOb2RlOjpzZXRTZWxmRGlydHkoKQoreworICAg IGlmIChtX3JlbmRlcmVyICYmIG1faXNWaXN1YWwpCisgICAgICAgIG1fcmVuZGVyZXItPnNldE5l ZWRzTGF5b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNldFBh cmVudERpcnR5KCkKK3sKKyAgICBpZiAobV9yZW5kZXJlciAmJiBtX2lzVmlzdWFsICYmIG1faGFz Q291bnRlcnMpCisgICAgICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVj YWxjKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAkocmV2aXNpb24gMTY1Mjgp CisrKyByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMzYsMTEgKzM2 LDE0IEBACiAgKi8KIAogI2luY2x1ZGUgIkNvbG9yLmgiCisjaW5jbHVkZSAiQ1NTUHJpbWl0aXZl VmFsdWUuaCIKKyNpbmNsdWRlICJDU1NWYWx1ZUxpc3QuaCIKICNpbmNsdWRlICJEYXRhUmVmLmgi CiAjaW5jbHVkZSAiRm9udC5oIgogI2luY2x1ZGUgIkdyYXBoaWNzVHlwZXMuaCIKICNpbmNsdWRl ICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiTGVuZ3RoLmgiCisjaW5jbHVkZSAiUGFpci5oIgogI2lu Y2x1ZGUgIlNoYXJlZC5oIgogI2luY2x1ZGUgIlRleHREaXJlY3Rpb24uaCIKICNpbmNsdWRlIDx3 dGYvVmVjdG9yLmg+CkBAIC01OSw5ICs2MiwxMSBAQAogCiB1c2luZyBzdGQ6Om1heDsKIAotY2xh c3MgQ1NTU3R5bGVTZWxlY3RvcjsKIGNsYXNzIENhY2hlZEltYWdlOwogY2xhc3MgQ2FjaGVkUmVz b3VyY2U7CitjbGFzcyBDU1NTdHlsZVNlbGVjdG9yOworY2xhc3MgQ1NTVmFsdWVMaXN0OworY2xh c3MgUGFpcjsKIGNsYXNzIFJlbmRlckFyZW5hOwogY2xhc3MgU2hhZG93VmFsdWU7CiBjbGFzcyBT dHJpbmdJbXBsOwpAQCAtNDA3LDggKzQxMiw4IEBACiAgICAgICAgIHJldHVybiAoIGNsaXAgPT0g by5jbGlwICYmCiAgICAgICAgICAgICAgICAgIGhhc0NsaXAgPT0gby5oYXNDbGlwICYmCiAgICAg ICAgICAgICAgICAgIGNvbHNwYW4gPT0gby5jb2xzcGFuICYmCi0gICAgICAgICAgICAgICAgIGNv dW50ZXJfaW5jcmVtZW50ID09IG8uY291bnRlcl9pbmNyZW1lbnQgJiYKLSAgICAgICAgICAgICAg ICAgY291bnRlcl9yZXNldCA9PSBvLmNvdW50ZXJfcmVzZXQgJiYKKyAgICAgICAgICAgICAgICAg Y291bnRlckluY3JlbWVudCA9PSBvLmNvdW50ZXJJbmNyZW1lbnQgJiYKKyAgICAgICAgICAgICAg ICAgY291bnRlclJlc2V0ID09IG8uY291bnRlclJlc2V0ICYmCiAgICAgICAgICAgICAgICAgIHRl eHREZWNvcmF0aW9uID09IG8udGV4dERlY29yYXRpb24pOwogICAgIH0KICAgICBib29sIG9wZXJh dG9yIT0oIGNvbnN0IFN0eWxlVmlzdWFsRGF0YSAmbyApIGNvbnN0IHsKQEAgLTQyMSw4ICs0MjYs OCBAQAogICAgIAogICAgIHNob3J0IGNvbHNwYW47IC8vIGZvciBodG1sLCBub3QgYSBjc3MyIGF0 dHJpYnV0ZQogCi0gICAgc2hvcnQgY291bnRlcl9pbmNyZW1lbnQ7IC8vb2ssIHNvIHRoZXNlIGFy ZSBub3QgdmlzdWFsIG1vZGUgc3Blc2lmaWMKLSAgICBzaG9ydCBjb3VudGVyX3Jlc2V0OyAgICAg Ly9jYW4ndCBnbyB0byBpbmhlcml0ZWQsIHNpbmNlIHRoZXNlIGFyZSBub3QgaW5oZXJpdGVkCisg ICAgc2hvcnQgY291bnRlckluY3JlbWVudDsgLy9vaywgc28gdGhlc2UgYXJlIG5vdCB2aXN1YWwg bW9kZSBzcGVzaWZpYworICAgIHNob3J0IGNvdW50ZXJSZXNldDsgICAgIC8vY2FuJ3QgZ28gdG8g aW5oZXJpdGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAogCiB9OwogCkBAIC04NzIs NiArODc3LDIwIEBACiAgICAgQ09OVEVOVF9OT05FLCBDT05URU5UX09CSkVDVCwgQ09OVEVOVF9U RVhULCBDT05URU5UX0NPVU5URVIKIH07CiAKK3N0cnVjdCBDb3VudGVyRGF0YSB7CisgICAgQ291 bnRlckRhdGEoKSB7fQorICAgIENvdW50ZXJEYXRhKFN0cmluZyBpLCBpbnQgbCwgU3RyaW5nIHNl cCkgOmlkZW50KGkpLCBscyhsKSwgcyhzZXApIHt9CisgICAgfkNvdW50ZXJEYXRhKCkge30KKyAg ICAKKyAgICBTdHJpbmcgaWRlbnRpZmllcigpIHsgcmV0dXJuIGlkZW50OyB9CisgICAgaW50IGxp c3RTdHlsZSgpIHsgcmV0dXJuIGxzOyB9CisgICAgU3RyaW5nIHNlcGFyYXRvcigpIHsgcmV0dXJu IHM7IH0KKworICAgIFN0cmluZyBpZGVudDsKKyAgICBpbnQgbHM7CisgICAgU3RyaW5nIHM7Cit9 OworCiBzdHJ1Y3QgQ29udGVudERhdGEgewogICAgIENvbnRlbnREYXRhKCkgOl9jb250ZW50VHlw ZShDT05URU5UX05PTkUpLCBfbmV4dENvbnRlbnQoMCkge30KICAgICB+Q29udGVudERhdGEoKTsK QEAgLTg4MSwxMyArOTAwLDE0IEBACiAKICAgICBTdHJpbmdJbXBsKiBjb250ZW50VGV4dCgpIHsg aWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9URVhUKSByZXR1cm4gX2NvbnRlbnQudGV4dDsg cmV0dXJuIDA7IH0KICAgICBDYWNoZWRSZXNvdXJjZSogY29udGVudE9iamVjdCgpIHsgaWYgKGNv bnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpIHJldHVybiBfY29udGVudC5vYmplY3Q7IHJl dHVybiAwOyB9CisgICAgQ291bnRlckRhdGEqIGNvbnRlbnRDb3VudGVyKCkgeyBpZiAoY29udGVu dFR5cGUoKSA9PSBDT05URU5UX0NPVU5URVIpIHJldHVybiBfY29udGVudC5jb3VudGVyOyByZXR1 cm4gMDsgfQogICAgIAogICAgIENvbnRlbnRUeXBlIF9jb250ZW50VHlwZTsKIAogICAgIHVuaW9u IHsKICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIG9iamVjdDsKICAgICAgICAgU3RyaW5nSW1wbCog dGV4dDsKLSAgICAgICAgLy8gY291bnRlcnMuLi4KKyAgICAgICAgQ291bnRlckRhdGEqIGNvdW50 ZXI7CiAgICAgfSBfY29udGVudCA7CiAKICAgICBDb250ZW50RGF0YSogX25leHRDb250ZW50OwpA QCAtMTA0NSw3ICsxMDY1LDkgQEAKICAgICAKICAgICAvLyBhZGRlZCB0aGlzIGhlcmUsIHNvIHdl IGNhbiBnZXQgcmlkIG9mIHRoZSB2cHRyIGluIHRoaXMgY2xhc3MuCiAgICAgLy8gbWFrZXMgdXAg Zm9yIHRoZSBzYW1lIHNpemUuCi0gICAgQ29udGVudERhdGEgKmNvbnRlbnQ7CisgICAgQ29udGVu dERhdGEqIGNvbnRlbnQ7CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVyUmVzZXRMaXN0OworICAg IENTU1ZhbHVlTGlzdCogY291bnRlckluY3JlbWVudExpc3Q7CiAKICAgICB1bnNpZ25lZCBtX3Bz ZXVkb1N0YXRlIDogMzsgLy8gUHNldWRvU3RhdGUKICAgICBib29sIG1fYWZmZWN0ZWRCeUF0dHJp YnV0ZVNlbGVjdG9ycyA6IDE7CkBAIC0xMjk1LDggKzEzMTcsOCBAQAogICAgIEVFbXB0eUNlbGwg ZW1wdHlDZWxscygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVFbXB0eUNlbGw+KGluaGVy aXRlZF9mbGFncy5fZW1wdHlfY2VsbHMpOyB9CiAgICAgRUNhcHRpb25TaWRlIGNhcHRpb25TaWRl KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8RUNhcHRpb25TaWRlPihpbmhlcml0ZWRfZmxh Z3MuX2NhcHRpb25fc2lkZSk7IH0KIAotICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoKSBjb25z dCB7IHJldHVybiB2aXN1YWwtPmNvdW50ZXJfaW5jcmVtZW50OyB9Ci0gICAgc2hvcnQgY291bnRl clJlc2V0KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyX3Jlc2V0OyB9CisgICAgc2hv cnQgY291bnRlckluY3JlbWVudCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlckluY3Jl bWVudDsgfQorICAgIHNob3J0IGNvdW50ZXJSZXNldCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+ Y291bnRlclJlc2V0OyB9CiAKICAgICBFTGlzdFN0eWxlVHlwZSBsaXN0U3R5bGVUeXBlKCkgY29u c3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8RUxpc3RTdHlsZVR5cGU+KGluaGVyaXRlZF9mbGFncy5f bGlzdF9zdHlsZV90eXBlKTsgfQogICAgIENhY2hlZEltYWdlICpsaXN0U3R5bGVJbWFnZSgpIGNv bnN0IHsgcmV0dXJuIGluaGVyaXRlZC0+c3R5bGVfaW1hZ2U7IH0KQEAgLTE1MDEsOCArMTUyMyw4 IEBACiAgICAgdm9pZCBzZXRDYXB0aW9uU2lkZShFQ2FwdGlvblNpZGUgdikgeyBpbmhlcml0ZWRf ZmxhZ3MuX2NhcHRpb25fc2lkZSA9IHY7IH0KIAogCi0gICAgdm9pZCBzZXRDb3VudGVySW5jcmVt ZW50KHNob3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJfaW5jcmVtZW50LHYpIH0KLSAg ICB2b2lkIHNldENvdW50ZXJSZXNldChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVy X3Jlc2V0LHYpIH0KKyAgICB2b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoc2hvcnQgdikgeyAgU0VU X1ZBUih2aXN1YWwsY291bnRlckluY3JlbWVudCx2KSB9CisgICAgdm9pZCBzZXRDb3VudGVyUmVz ZXQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1YWwsY291bnRlclJlc2V0LHYpIH0KIAogICAgIHZv aWQgc2V0TGlzdFN0eWxlVHlwZShFTGlzdFN0eWxlVHlwZSB2KSB7IGluaGVyaXRlZF9mbGFncy5f bGlzdF9zdHlsZV90eXBlID0gdjsgfQogICAgIHZvaWQgc2V0TGlzdFN0eWxlSW1hZ2UoQ2FjaGVk SW1hZ2UgKnYpIHsgIFNFVF9WQVIoaW5oZXJpdGVkLHN0eWxlX2ltYWdlLHYpfQpAQCAtMTU5Nyw3 ICsxNjE5LDIwIEBACiAgICAgYm9vbCBjb250ZW50RGF0YUVxdWl2YWxlbnQoY29uc3QgUmVuZGVy U3R5bGUgKm90aGVyU3R5bGUpIGNvbnN0OwogICAgIHZvaWQgc2V0Q29udGVudChTdHJpbmdJbXBs KiBzLCBib29sIGFkZCA9IGZhbHNlKTsKICAgICB2b2lkIHNldENvbnRlbnQoQ2FjaGVkUmVzb3Vy Y2UqIG8sIGJvb2wgYWRkID0gZmFsc2UpOworICAgIHZvaWQgc2V0Q29udGVudChDb3VudGVyRGF0 YSogYywgYm9vbCBhZGQgPSBmYWxzZSk7CiAKKyAgICBib29sIGNvdW50ZXJEYXRhRXF1aXZhbGVu dChSZW5kZXJTdHlsZSogb3RoZXJTdHlsZSk7CisgICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoQ1NT VmFsdWVMaXN0KiB2KTsKKyAgICB2b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoQ1NTVmFsdWVMaXN0 KiB2KTsKKyAgICB2b2lkIGFkZENvdW50ZXJSZXNldChDU1NQcmltaXRpdmVWYWx1ZSogYyk7Cisg ICAgdm9pZCBhZGRDb3VudGVySW5jcmVtZW50KENTU1ByaW1pdGl2ZVZhbHVlKiBjKTsKKyAgICBi b29sIGhhc0NvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmIGMpIGNvbnN0OworICAgIGJvb2wgaGFz Q291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmIGMpIGNvbnN0OworICAgIHNob3J0IGNvdW50 ZXJSZXNldChjb25zdCBTdHJpbmcmIGMpIGNvbnN0OworICAgIHNob3J0IGNvdW50ZXJJbmNyZW1l bnQoY29uc3QgU3RyaW5nJiBjKSBjb25zdDsKKyAgICBDU1NWYWx1ZUxpc3QqIGNvdW50ZXJSZXNl dFZhbHVlTGlzdCgpIHsgcmV0dXJuIGNvdW50ZXJSZXNldExpc3Q7IH0KKyAgICBDU1NWYWx1ZUxp c3QqIGNvdW50ZXJJbmNyZW1lbnRWYWx1ZUxpc3QoKSB7IHJldHVybiBjb3VudGVySW5jcmVtZW50 TGlzdDsgfQorCiAgICAgYm9vbCBpbmhlcml0ZWROb3RFcXVhbCggUmVuZGVyU3R5bGUgKm90aGVy ICkgY29uc3Q7CiAKICAgICAvLyBUaGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHR3byBzdHlsZXMuICBU aGUgZm9sbG93aW5nIHZhbHVlcyBhcmUgdXNlZDoKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVz ZXROb2RlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5jcHAJ KHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5jcHAJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMTUzIEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhU TUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBB bGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMp IDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5z ZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisg KiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3Bl IHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9y IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBz aG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09Q WUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAy MTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUg IkNvdW50ZXJSZXNldE5vZGUuaCIKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNw YWNlIFdlYkNvcmUgeworCitDb3VudGVyUmVzZXROb2RlOjpDb3VudGVyUmVzZXROb2RlKFJlbmRl ck9iamVjdCogbykgOiBDb3VudGVyTm9kZShvKSwgbV90b3RhbCgwKSwgbV9maXJzdCgwKSwgbV9s YXN0KDApIHt9CitDb3VudGVyUmVzZXROb2RlOjp+Q291bnRlclJlc2V0Tm9kZSgpIHt9OworCit2 b2lkIENvdW50ZXJSZXNldE5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwg Q291bnRlck5vZGUqIHJlZkNoaWxkKQoreworICAgIEFTU0VSVChuZXdDaGlsZCk7CisgICAgQVNT RVJUKCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+cGFyZW50KCkgPT0gdGhpcyk7CisKKyAgICBuZXdD aGlsZC0+bV9wYXJlbnQgPSB0aGlzOworICAgIG5ld0NoaWxkLT5tX3ByZXZpb3VzID0gcmVmQ2hp bGQ7CisKKyAgICBpZiAocmVmQ2hpbGQpIHsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dCA9IHJl ZkNoaWxkLT5tX25leHQ7CisgICAgICAgIHJlZkNoaWxkLT5tX25leHQgPSBuZXdDaGlsZDsKKyAg ICB9IGVsc2UgeworICAgICAgICBuZXdDaGlsZC0+bV9uZXh0ID0gbV9maXJzdDsKKyAgICAgICAg bV9maXJzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIGlmIChuZXdDaGlsZC0+bV9uZXh0KSB7 CisgICAgICAgIGFzc2VydChuZXdDaGlsZC0+bV9uZXh0LT5tX3ByZXZpb3VzID09IHJlZkNoaWxk KTsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9IG5ld0NoaWxkOworICAg IH0gZWxzZSB7CisgICAgICAgIGFzc2VydCAobV9sYXN0ID09IHJlZkNoaWxkKTsKKyAgICAgICAg bV9sYXN0ID0gbmV3Q2hpbGQ7CisgICAgfQorCisgICAgbmV3Q2hpbGQtPnJlY291bnQodHJ1ZSk7 Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9s ZENoaWxkKQoreworICAgIEFTU0VSVChvbGRDaGlsZCk7CisKKyAgICBDb3VudGVyTm9kZSogbmV4 dCA9IG9sZENoaWxkLT5tX25leHQ7CisgICAgQ291bnRlck5vZGUqIHByZXYgPSBvbGRDaGlsZC0+ bV9wcmV2aW91czsKKworICAgIGlmIChvbGRDaGlsZC0+Zmlyc3RDaGlsZCgpKSB7CisgICAgICAg IENvdW50ZXJOb2RlKiBmaXJzdCA9IG9sZENoaWxkLT5maXJzdENoaWxkKCk7CisgICAgICAgIENv dW50ZXJOb2RlKiBsYXN0ID0gb2xkQ2hpbGQtPmxhc3RDaGlsZCgpOworICAgICAgICBpZiAocHJl dikgeworICAgICAgICAgICAgcHJldi0+bV9uZXh0ID0gZmlyc3Q7CisgICAgICAgICAgICBmaXJz dC0+bV9wcmV2aW91cyA9IHByZXY7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgbV9maXJz dCA9IGZpcnN0OworCisgICAgICAgIGlmIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3By ZXZpb3VzID0gbGFzdDsKKyAgICAgICAgICAgIGxhc3QtPm1fbmV4dCA9IG5leHQ7CisgICAgICAg IH0gZWxzZQorICAgICAgICAgICAgbV9sYXN0ID0gbGFzdDsKKworICAgICAgICBuZXh0ID0gZmly c3Q7CisgICAgICAgIHdoaWxlIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3BhcmVudCA9 IHRoaXM7CisgICAgICAgICAgICBuZXh0ID0gbmV4dC0+bV9uZXh0OworICAgICAgICB9CisKKyAg ICAgICAgZmlyc3QtPnJlY291bnQodHJ1ZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKHBy ZXYpIAorICAgICAgICAgICAgcHJldi0+bV9uZXh0ID0gbmV4dDsKKyAgICAgICAgZWxzZSB7Cisg ICAgICAgICAgICBhc3NlcnQgKCBtX2ZpcnN0ID09IG9sZENoaWxkICk7CisgICAgICAgICAgICBt X2ZpcnN0ID0gbmV4dDsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgaWYgKG5leHQpCisg ICAgICAgICAgICBuZXh0LT5tX3ByZXZpb3VzID0gcHJldjsKKyAgICAgICAgZWxzZSB7CisgICAg ICAgICAgICBhc3NlcnQgKCBtX2xhc3QgPT0gb2xkQ2hpbGQgKTsKKyAgICAgICAgICAgIG1fbGFz dCA9IHByZXY7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQorICAgICAg ICAgICAgbmV4dC0+cmVjb3VudCgpOworICAgIH0KKworCisgICAgb2xkQ2hpbGQtPm1fbmV4dCA9 IDA7CisgICAgb2xkQ2hpbGQtPm1fcHJldmlvdXMgPSAwOworICAgIG9sZENoaWxkLT5tX3BhcmVu dCA9IDA7Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6cmVjb3VudChib29sIGZpcnN0KQor eworICAgIGludCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3ByZXZpb3VzKQorICAg ICAgICBtX2NvdW50ID0gbV9wcmV2aW91cy0+Y291bnQoKTsKKyAgICBlbHNlIGlmIChtX3BhcmVu dCkKKyAgICAgICAgbV9jb3VudCA9IG1fcGFyZW50LT52YWx1ZSgpOworICAgIGVsc2UKKyAgICAg ICAgbV9jb3VudCA9IDA7CisKKyAgICB1cGRhdGVUb3RhbChtX3ZhbHVlKTsKKyAgICBpZiAoIWZp cnN0KQorICAgICAgICBzZXRTZWxmRGlydHkoKTsKKyAgICBpZiAobV9uZXh0ICYmIChmaXJzdCB8 fCBtX2NvdW50ICE9IG9sZF9jb3VudCkpCisgICAgICAgIG1fbmV4dC0+cmVjb3VudCgpOworfQor Cit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnNldFNlbGZEaXJ0eSgpCit7CisgICAgc2V0UGFyZW50 RGlydHkoKTsKK30KKwordm9pZCBDb3VudGVyUmVzZXROb2RlOjpzZXRQYXJlbnREaXJ0eSgpCit7 CisgICAgaWYgKGhhc0NvdW50ZXJzKCkpIHsKKyAgICAgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV9p c1Zpc3VhbCkKKyAgICAgICAgICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4 UmVjYWxjKCk7CisgICAgICAgIENvdW50ZXJOb2RlKiBuID0gZmlyc3RDaGlsZCgpOworICAgICAg ICBmb3IoOyBuOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkKKyAgICAgICAgICAgIG4tPnNldFBhcmVu dERpcnR5KCk7CisgICAgfQorfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnVwZGF0ZVRvdGFs KGludCB2YWx1ZSkKK3sKKyAgICBpZiAodmFsdWUgPiBtX3RvdGFsKQorICAgICAgICBtX3RvdGFs ID0gdmFsdWU7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyQ29u dGFpbmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ29udGFpbmVyLmNwcAko cmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyQ29udGFpbmVyLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xs IChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChr b2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVl bGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNl biAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNCwgMjAwNSwg MjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICogQ29weXJpZ2h0IChDKSAyMDA2IEFuZHJldyBX ZWxsaW5ndG9uIChwcm90b25Ad2lyZXRhcHBlZC5uZXQpCiAgKgpAQCAtMjgsNiArMjksNyBAQAog I2luY2x1ZGUgIlJlbmRlckNvbnRhaW5lci5oIgogCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIK KyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIK ICNpbmNsdWRlICJSZW5kZXJUYWJsZS5oIgogI2luY2x1ZGUgIlJlbmRlclRleHRGcmFnbWVudC5o IgpAQCAtMjk3LDYgKzI5OSw4IEBACiAgICAgICAgIC8vIGlubGluZSBzaG91bGQgYmUgbXV0YXRl ZCB0byBJTkxJTkUuCiAgICAgICAgIHBzZXVkby0+c2V0RGlzcGxheShJTkxJTkUpOwogICAgIAor ICAgIFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUo KTsKKyAgICBzdHlsZS0+aW5oZXJpdEZyb20ocHNldWRvKTsKICAgICBpZiAob2xkQ29udGVudFBy ZXNlbnQpIHsKICAgICAgICAgaWYgKGNoaWxkICYmIGNoaWxkLT5zdHlsZSgpLT5zdHlsZVR5cGUo KSA9PSB0eXBlKSB7CiAgICAgICAgICAgICAvLyBXZSBoYXZlIGdlbmVyYXRlZCBjb250ZW50IHBy ZXNlbnQgc3RpbGwuICBXZSB3YW50IHRvIHdhbGsgdGhpcyBjb250ZW50IGFuZCB1cGRhdGUgb3Vy CkBAIC0zMDksMTMgKzMxMywxMCBAQAogICAgICAgICAgICAgICAgIGlmIChnZW5DaGlsZC0+aXNU ZXh0KCkpCiAgICAgICAgICAgICAgICAgICAgIC8vIEdlbmVyYXRlZCB0ZXh0IGNvbnRlbnQgaXMg YSBjaGlsZCB3aG9zZSBzdHlsZSBhbHNvIG5lZWRzIHRvIGJlIHNldCB0byB0aGUgcHNldWRvCiAg ICAgICAgICAgICAgICAgICAgIC8vIHN0eWxlLgotICAgICAgICAgICAgICAgICAgICBnZW5DaGls ZC0+c2V0U3R5bGUocHNldWRvKTsKLSAgICAgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAg ICAgICAgICAgZ2VuQ2hpbGQtPnNldFN0eWxlKHN0eWxlKTsKKyAgICAgICAgICAgICAgICBlbHNl CiAgICAgICAgICAgICAgICAgICAgIC8vIEltYWdlcyBnZXQgYW4gZW1wdHkgc3R5bGUgdGhhdCBp bmhlcml0cyBmcm9tIHRoZSBwc2V1ZG8uCi0gICAgICAgICAgICAgICAgICAgIFJlbmRlclN0eWxl KiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsKLSAgICAgICAgICAg ICAgICAgICAgc3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgICAgICAgICAgICAgICAg IGdlbkNoaWxkLT5zZXRTdHlsZShzdHlsZSk7Ci0gICAgICAgICAgICAgICAgfQogICAgICAgICAg ICAgfQogICAgICAgICB9CiAgICAgICAgIHJldHVybjsgLy8gV2UndmUgdXBkYXRlZCB0aGUgZ2Vu ZXJhdGVkIGNvbnRlbnQuIFRoYXQncyBhbGwgd2UgbmVlZGVkIHRvIGRvLgpAQCAtMzM0LDIwICsz MzUsMjAgQEAKICAgICAgICAgaWYgKCFwc2V1ZG9Db250YWluZXIpCiAgICAgICAgICAgICBwc2V1 ZG9Db250YWluZXIgPSBSZW5kZXJGbG93OjpjcmVhdGVBbm9ueW1vdXNGbG93KGRvY3VtZW50KCks IHBzZXVkbyk7IC8qIGFub255bW91cyBib3ggKi8KICAgICAgICAgCi0gICAgICAgIGlmIChjb250 ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpCi0gICAgICAgIHsKKyAgICAg ICAgaWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRFTlRfVEVYVCkgewogICAg ICAgICAgICAgUmVuZGVyVGV4dCogdCA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyVGV4dEZy YWdtZW50KGRvY3VtZW50KCkgLyphbm9ueW1vdXMgb2JqZWN0ICovLCBjb250ZW50RGF0YS0+Y29u dGVudFRleHQoKSk7Ci0gICAgICAgICAgICB0LT5zZXRTdHlsZShwc2V1ZG8pOworICAgICAgICAg ICAgdC0+c2V0U3R5bGUoc3R5bGUpOwogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRD aGlsZCh0KTsKLSAgICAgICAgfQotICAgICAgICBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVu dFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkKLSAgICAgICAgeworICAgICAgICB9IGVsc2UgaWYg KGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRFTlRfT0JKRUNUKSB7CiAgICAgICAg ICAgICBSZW5kZXJJbWFnZSogaW1nID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJJbWFnZShk b2N1bWVudCgpKTsgLyogQW5vbnltb3VzIG9iamVjdCAqLwotICAgICAgICAgICAgUmVuZGVyU3R5 bGUqIHN0eWxlID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJTdHlsZSgpOwotICAgICAgICAg ICAgc3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgICAgICAgICBpbWctPnNldFN0eWxl KHN0eWxlKTsKICAgICAgICAgICAgIGltZy0+c2V0Q29udGVudE9iamVjdChjb250ZW50RGF0YS0+ Y29udGVudE9iamVjdCgpKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQo aW1nKTsKKyAgICAgICAgfSBlbHNlIGlmIChjb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID09IENP TlRFTlRfQ09VTlRFUikgeworICAgICAgICAgICAgUmVuZGVyQ291bnRlciogYyA9IG5ldyAocmVu ZGVyQXJlbmEoKSkgUmVuZGVyQ291bnRlcihlbGVtZW50KCksIGNvbnRlbnREYXRhLT5jb250ZW50 Q291bnRlcigpKTsKKyAgICAgICAgICAgIGMtPnNldElzQW5vbnltb3VzKHRydWUpOworICAgICAg ICAgICAgYy0+c2V0U3R5bGUoc3R5bGUpOworICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5h ZGRDaGlsZChjKTsKICAgICAgICAgfQogICAgIH0KIApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJO b2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgJKHJldmlzaW9uIDAp CisrKyByZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4NSBA QAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUg Zm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2Vu IChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVy LCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxl IFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgor Ki8KKyNpZm5kZWYgX0NvdW50ZXJfTm9kZV9oXworI2RlZmluZSBfQ291bnRlcl9Ob2RlX2hfCisK KyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFz cyBDb3VudGVyUmVzZXROb2RlOworCisvLyBUaGlzIGZpbGUgaW1wbGVtZW50cyBhIGNvdW50ZXIt dHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgYWxsIHBhcmVudHMgaW4gY291bnRlcnMoKSBs b29rdXAsCisvLyBhbmQgZm9yIHByb3BhZ2F0aW5nIGNvdW50LWNoYW5nZXMgd2hlbiBub2RlcyBh cmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8vIFBsZWFzZSBub3RlIHRoYXQgb25seSBjb3VudGVyLXJl c2V0IGFuZCByb290IGNhbiBiZSBwYXJlbnRzIGhlcmUsIGFuZCB0aGF0IHJlbmRlci10cmVlIHBh cmVudHMKKy8vIGFyZSBqdXN0IGNvdW50ZXItdHJlZSBzaWJsaW5ncworCisvLyBJbXBsZW1lbnRh dGlvbiBvZiBjb3VudGVyLWluY3JlbWVudCBhbmQgY291bnRlci1jb250ZW50CitjbGFzcyBDb3Vu dGVyTm9kZSB7CitwdWJsaWM6CisgICAgQ291bnRlck5vZGUoUmVuZGVyT2JqZWN0KiBvKTsKKyAg ICB2aXJ0dWFsIH5Db3VudGVyTm9kZSgpOworCisgICAgQ291bnRlclJlc2V0Tm9kZSogcGFyZW50 KCkgY29uc3QgeyByZXR1cm4gbV9wYXJlbnQ7IH0KKyAgICBDb3VudGVyTm9kZSogcHJldmlvdXNT aWJsaW5nKCkgY29uc3QgeyByZXR1cm4gbV9wcmV2aW91czsgfQorICAgIENvdW50ZXJOb2RlKiBu ZXh0U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dDsgfQorICAgIHZpcnR1YWwgQ291bnRl ck5vZGUqIGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCBDb3Vu dGVyTm9kZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgdm9p ZCBpbnNlcnRBZnRlciAoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSogcmVmQ2hp bGQpOworICAgIHZpcnR1YWwgdm9pZCByZW1vdmVDaGlsZCAoQ291bnRlck5vZGUqIG9sZENoaWxk KTsKKyAgICAvLyBDb252ZW5pZW50IHNlbGYtcmVmZXJpbmcgdmVyc2lvbiBvZiB0aGUgYWJvdmUK KyAgICB2b2lkIHJlbW92ZSgpOworCisgICAgaW50IHZhbHVlKCkgY29uc3QgeyByZXR1cm4gbV92 YWx1ZTsgfQorICAgIHZvaWQgc2V0VmFsdWUoc2hvcnQgdikgeyBtX3ZhbHVlID0gdjsgfQorICAg IGludCBjb3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fY291bnQ7IH0KKworICAgIHZpcnR1YWwgYm9v bCBpc1Jlc2V0KCkgeyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcmVjb3VudChi b29sIGZpcnN0ID0gZmFsc2UpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKyAg ICB2aXJ0dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKworICAgIGJvb2wgaGFzQ291bnRlcnMo KSBjb25zdCB7IHJldHVybiBtX2hhc0NvdW50ZXJzOyB9OworICAgIGJvb2wgaXNWaXN1YWwoKSBj b25zdCB7IHJldHVybiBtX2lzVmlzdWFsOyB9OworICAgIHZvaWQgc2V0SGFzQ291bnRlcnMoKTsK KyAgICB2b2lkIHNldElzVmlzdWFsKCkgeyBtX2lzVmlzdWFsID0gdHJ1ZTsgfTsKKyAgICBib29s IGlzUm9vdCgpIHsgcmV0dXJuIG1fcmVuZGVyZXIgJiYgbV9yZW5kZXJlci0+aXNSb290KCk7IH07 CisKKyAgICB2b2lkIHNldFJlbmRlcmVyKFJlbmRlck9iamVjdCogbykgeyBtX3JlbmRlcmVyID0g bzsgfTsKKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKCkgY29uc3QgeyByZXR1cm4gbV9yZW5k ZXJlcjsgfTsKKworICAgIGZyaWVuZCBjbGFzcyBDb3VudGVyUmVzZXROb2RlOworcHJvdGVjdGVk OgorICAgIGJvb2wgbV9oYXNDb3VudGVycyA6IDE7CisgICAgYm9vbCBtX2lzVmlzdWFsIDogMTsK KyAgICBzaG9ydCBtX3ZhbHVlOworICAgIHNob3J0IG1fY291bnQ7CisgICAgQ291bnRlclJlc2V0 Tm9kZSogbV9wYXJlbnQ7CisgICAgQ291bnRlck5vZGUqIG1fcHJldmlvdXM7CisgICAgQ291bnRl ck5vZGUqIG1fbmV4dDsKKyAgICBSZW5kZXJPYmplY3QqIG1fcmVuZGVyZXI7Cit9OworCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDb3VudGVyTm9kZV9oCkluZGV4OiByZW5k ZXJpbmcvUmVuZGVyU3R5bGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJTdHls ZS5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNwcAkod29y a2luZyBjb3B5KQpAQCAtOTAsOCArOTAsOCBAQAogICAgIDogaGFzQ2xpcChmYWxzZSkKICAgICAs IHRleHREZWNvcmF0aW9uKFJlbmRlclN0eWxlOjppbml0aWFsVGV4dERlY29yYXRpb24oKSkKICAg ICAsIGNvbHNwYW4oMSkKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KDApCi0gICAgLCBjb3VudGVy X3Jlc2V0KDApCisgICAgLCBjb3VudGVySW5jcmVtZW50KDApCisgICAgLCBjb3VudGVyUmVzZXQo MCkKIHsKIH0KIApAQCAtMTA1LDggKzEwNSw4IEBACiAgICAgLCBoYXNDbGlwKG8uaGFzQ2xpcCkK ICAgICAsIHRleHREZWNvcmF0aW9uKG8udGV4dERlY29yYXRpb24pCiAgICAgLCBjb2xzcGFuKG8u Y29sc3BhbikKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KG8uY291bnRlcl9pbmNyZW1lbnQpCi0g ICAgLCBjb3VudGVyX3Jlc2V0KG8uY291bnRlcl9yZXNldCkKKyAgICAsIGNvdW50ZXJJbmNyZW1l bnQoby5jb3VudGVySW5jcmVtZW50KQorICAgICwgY291bnRlclJlc2V0KG8uY291bnRlclJlc2V0 KQogewogfQogCkBAIC01NzgsNiArNTc4LDExIEBACiAgICAgfQogICAgIGRlbGV0ZSBjb250ZW50 OwogICAgIAorICAgIGlmIChjb3VudGVyUmVzZXRMaXN0KQorICAgICAgICBjb3VudGVyUmVzZXRM aXN0LT5kZXJlZigpOworICAgIGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgY291 bnRlckluY3JlbWVudExpc3QtPmRlcmVmKCk7CisgICAgCiAgICAgZGVsZXRlIHRoaXM7CiAgICAg CiAgICAgLy8gUmVjb3ZlciB0aGUgc2l6ZSBsZWZ0IHRoZXJlIGZvciB1cyBieSBvcGVyYXRvciBk ZWxldGUgYW5kIGZyZWUgdGhlIG1lbW9yeS4KQEAgLTYwMSw2ICs2MDYsOCBAQAogICAgICwgaW5o ZXJpdGVkKGRlZmF1bHRTdHlsZS0+aW5oZXJpdGVkKQogICAgICwgcHNldWRvU3R5bGUoMCkKICAg ICAsIGNvbnRlbnQoMCkKKyAgICAsIGNvdW50ZXJSZXNldExpc3QoMCkKKyAgICAsIGNvdW50ZXJJ bmNyZW1lbnRMaXN0KDApCiAgICAgLCBtX3BzZXVkb1N0YXRlKFBzZXVkb1Vua25vd24pCiAgICAg LCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMoZmFsc2UpCiAgICAgLCBtX3VuaXF1ZShm YWxzZSkKQEAgLTYxNSw2ICs2MjIsOCBAQAogUmVuZGVyU3R5bGU6OlJlbmRlclN0eWxlKGJvb2wp CiAgICAgOiBwc2V1ZG9TdHlsZSgwKQogICAgICwgY29udGVudCgwKQorICAgICwgY291bnRlclJl c2V0TGlzdCgwKQorICAgICwgY291bnRlckluY3JlbWVudExpc3QoMCkKICAgICAsIG1fcHNldWRv U3RhdGUoUHNldWRvVW5rbm93bikKICAgICAsIG1fYWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9y cyhmYWxzZSkKICAgICAsIG1fdW5pcXVlKGZhbHNlKQpAQCAtNjQ5LDYgKzY1OCw4IEBACiAgICAg LCBpbmhlcml0ZWQoby5pbmhlcml0ZWQpCiAgICAgLCBwc2V1ZG9TdHlsZSgwKQogICAgICwgY29u dGVudChvLmNvbnRlbnQpCisgICAgLCBjb3VudGVyUmVzZXRMaXN0KG8uY291bnRlclJlc2V0TGlz dCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KG8uY291bnRlckluY3JlbWVudExpc3QpCiAg ICAgLCBtX3BzZXVkb1N0YXRlKG8ubV9wc2V1ZG9TdGF0ZSkKICAgICAsIG1fYWZmZWN0ZWRCeUF0 dHJpYnV0ZVNlbGVjdG9ycyhmYWxzZSkKICAgICAsIG1fdW5pcXVlKGZhbHNlKQpAQCAtODM4LDgg Kzg0OSw4IEBACiAgICAgICAgICEobm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZyA9PSBvdGhl ci0+bm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZykgfHwKICAgICAgICAgIShub25pbmhlcml0 ZWRfZmxhZ3MuX29yaWdpbmFsRGlzcGxheSA9PSBvdGhlci0+bm9uaW5oZXJpdGVkX2ZsYWdzLl9v cmlnaW5hbERpc3BsYXkpIHx8CiAgICAgICAgICB2aXN1YWwtPmNvbHNwYW4gIT0gb3RoZXItPnZp c3VhbC0+Y29sc3BhbiB8fAotICAgICAgICAgdmlzdWFsLT5jb3VudGVyX2luY3JlbWVudCAhPSBv dGhlci0+dmlzdWFsLT5jb3VudGVyX2luY3JlbWVudCB8fAotICAgICAgICAgdmlzdWFsLT5jb3Vu dGVyX3Jlc2V0ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJfcmVzZXQgfHwKKyAgICAgICAgIHZp c3VhbC0+Y291bnRlckluY3JlbWVudCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVySW5jcmVtZW50 IHx8CisgICAgICAgICB2aXN1YWwtPmNvdW50ZXJSZXNldCAhPSBvdGhlci0+dmlzdWFsLT5jb3Vu dGVyUmVzZXQgfHwKICAgICAgICAgIGNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cg IT0gb3RoZXItPmNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cgfHwKICAgICAgICAg IChjc3MzSW5oZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5ICE9IG90aGVyLT5jc3MzSW5oZXJpdGVk RGF0YS0+dGV4dFNlY3VyaXR5KSkKICAgICAgICAgcmV0dXJuIExheW91dDsKQEAgLTEwODAsNiAr MTA5MSwzMiBAQAogICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudFR5cGUgPSBDT05URU5UX1RF WFQ7CiB9CiAKK3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvbnRlbnQoQ291bnRlckRhdGEqIGMsIGJv b2wgYWRkKQoreworICAgIGlmICghYykKKyAgICAgICAgcmV0dXJuOworCisgICAgQ29udGVudERh dGEqIGxhc3RDb250ZW50ID0gY29udGVudDsKKyAgICB3aGlsZSAobGFzdENvbnRlbnQgJiYgbGFz dENvbnRlbnQtPl9uZXh0Q29udGVudCkKKyAgICAgICAgbGFzdENvbnRlbnQgPSBsYXN0Q29udGVu dC0+X25leHRDb250ZW50OworCisgICAgYm9vbCByZXVzZUNvbnRlbnQgPSAhYWRkOworICAgIENv bnRlbnREYXRhKiBuZXdDb250ZW50RGF0YSA9IDA7CisgICAgaWYgKHJldXNlQ29udGVudCAmJiBj b250ZW50KSB7CisgICAgICAgIGNvbnRlbnQtPmNsZWFyQ29udGVudCgpOworICAgICAgICBuZXdD b250ZW50RGF0YSA9IGNvbnRlbnQ7CisgICAgfSBlbHNlCisgICAgICAgIG5ld0NvbnRlbnREYXRh ID0gbmV3IENvbnRlbnREYXRhOworCisgICAgaWYgKGxhc3RDb250ZW50ICYmICFyZXVzZUNvbnRl bnQpCisgICAgICAgIGxhc3RDb250ZW50LT5fbmV4dENvbnRlbnQgPSBuZXdDb250ZW50RGF0YTsK KyAgICBlbHNlCisgICAgICAgIGNvbnRlbnQgPSBuZXdDb250ZW50RGF0YTsKKworICAgIG5ld0Nv bnRlbnREYXRhLT5fY29udGVudC5jb3VudGVyID0gYzsKKyAgICBuZXdDb250ZW50RGF0YS0+X2Nv bnRlbnRUeXBlID0gQ09OVEVOVF9DT1VOVEVSOworfQorCiBDb250ZW50RGF0YTo6fkNvbnRlbnRE YXRhKCkKIHsKICAgICBjbGVhckNvbnRlbnQoKTsKQEAgLTEwOTgsNiArMTEzNSwxMCBAQAogICAg ICAgICBjYXNlIENPTlRFTlRfVEVYVDoKICAgICAgICAgICAgIF9jb250ZW50LnRleHQtPmRlcmVm KCk7CiAgICAgICAgICAgICBfY29udGVudC50ZXh0ID0gMDsKKyAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICBjYXNlIENPTlRFTlRfQ09VTlRFUjoKKyAgICAgICAgICAgIF9jb250ZW50LmNvdW50 ZXIgPSAwOworICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAg ICA7CiAgICAgfQpAQCAtMTE4NSw2ICsxMjI2LDEyMiBAQAogICAgIHJldHVybiB4ID09IG8ueCAm JiB5ID09IG8ueSAmJiBibHVyID09IG8uYmx1ciAmJiBjb2xvciA9PSBvLmNvbG9yOwogfQogCiti b29sIFJlbmRlclN0eWxlOjpjb3VudGVyRGF0YUVxdWl2YWxlbnQoUmVuZGVyU3R5bGUqIG90aGVy U3R5bGUpCit7CisgICAgLy8gIyMjIFNob3VsZCB3ZSBjb21wYXJlIGNvbnRlbnQ/CisgICAgcmV0 dXJuIGNvdW50ZXJSZXNldExpc3QgPT0gb3RoZXJTdHlsZS0+Y291bnRlclJlc2V0TGlzdCAmJgor ICAgICAgICAgICBjb3VudGVySW5jcmVtZW50TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVySW5j cmVtZW50TGlzdDsKK30KKworc3RhdGljIGJvb2wgaGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGMs IENTU1ZhbHVlTGlzdCogbCkKK3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAgZm9y IChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSog cHJpbWl0aXZlVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0o aSkpOworICAgICAgICBQYWlyKiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgp OworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0aWNfY2FzdDxD U1NQcmltaXRpdmVWYWx1ZSo+KHBhaXItPmZpcnN0KCkpOworICAgICAgICBBU1NFUlQocGFpciAm JiBjb3VudGVyTmFtZSk7CisgICAgICAgIGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUo KSA9PSBjKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxz ZTsKK30KKworYm9vbCBSZW5kZXJTdHlsZTo6aGFzQ291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYg YykgY29uc3QKK3sKKyAgICBpZiAoY291bnRlclJlc2V0TGlzdCkKKyAgICAgICAgcmV0dXJuIGhh c0NvdW50ZXIoYywgY291bnRlclJlc2V0TGlzdCk7CisgICAgZWxzZQorICAgICAgICByZXR1cm4g ZmFsc2U7Cit9CisKK2Jvb2wgUmVuZGVyU3R5bGU6Omhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3Qg U3RyaW5nJiBjKSBjb25zdAoreworICAgIGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAg ICAgcmV0dXJuIGhhc0NvdW50ZXIoYywgY291bnRlckluY3JlbWVudExpc3QpOworICAgIGVsc2UK KyAgICAgICAgcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgc2hvcnQgcmVhZENvdW50ZXIoY29u c3QgU3RyaW5nJiBjLCBDU1NWYWx1ZUxpc3QqIGwsIGJvb2wgaXNSZXNldCkKK3sKKyAgICBpbnQg bGVuID0gbC0+bGVuZ3RoKCk7CisgICAgc2hvcnQgdG90YWwgPSAwOworICAgIAorICAgIGZvciAo aW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIHBy aW1pdGl2ZVZhbHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihsLT5pdGVtKGkp KTsKKyAgICAgICAgUGFpciogcGFpciA9IHByaW1pdGl2ZVZhbHVlLT5nZXRQYWlyVmFsdWUoKTsK KyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nhc3Q8Q1NT UHJpbWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFs dWUqIGNvdW50ZXJWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4ocGFpci0+ c2Vjb25kKCkpOworICAgICAgICBBU1NFUlQocGFpciAmJiBjb3VudGVyTmFtZSAmJiBjb3VudGVy VmFsdWUpOworCisgICAgICAgIGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBj KSB7CisgICAgICAgICAgICB0b3RhbCArPSAoc2hvcnQpY291bnRlclZhbHVlLT5nZXRGbG9hdFZh bHVlKCk7CisgICAgICAgICAgICBpZiAoaXNSZXNldCkKKyAgICAgICAgICAgICAgICByZXR1cm4g dG90YWw7CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgcmV0dXJuIHRvdGFsOworfQorCitz aG9ydCBSZW5kZXJTdHlsZTo6Y291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgYykgY29uc3QKK3sK KyAgICBpZiAoY291bnRlclJlc2V0TGlzdCkKKyAgICAgICAgcmV0dXJuIHJlYWRDb3VudGVyKGMs IGNvdW50ZXJSZXNldExpc3QsIHRydWUpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9 CisKK3Nob3J0IFJlbmRlclN0eWxlOjpjb3VudGVySW5jcmVtZW50KGNvbnN0IFN0cmluZyYgYykg Y29uc3QKK3sKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiBy ZWFkQ291bnRlcihjLCBjb3VudGVySW5jcmVtZW50TGlzdCwgZmFsc2UpOworICAgIGVsc2UKKyAg ICAgICAgcmV0dXJuIDA7Cit9CisKK3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvdW50ZXJSZXNldChD U1NWYWx1ZUxpc3QqIGwpCit7CisgICAgQ1NTVmFsdWVMaXN0KiB0ID0gY291bnRlclJlc2V0TGlz dDsKKyAgICBjb3VudGVyUmVzZXRMaXN0ID0gbDsKKyAgICBpZiAobCkKKyAgICAgICAgbC0+cmVm KCk7CisgICAgaWYgKHQpCisgICAgICAgIHQtPmRlcmVmKCk7Cit9CisKK3ZvaWQgUmVuZGVyU3R5 bGU6OnNldENvdW50ZXJJbmNyZW1lbnQoQ1NTVmFsdWVMaXN0KiBsKQoreworICAgIENTU1ZhbHVl TGlzdCogdCA9IGNvdW50ZXJJbmNyZW1lbnRMaXN0OworICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0 ID0gbDsKKyAgICAKKyAgICBpZiAobCkgCisgICAgICAgIGwtPnJlZigpOworICAgIGlmICh0KQor ICAgICAgICB0LT5kZXJlZigpOworfQorCit2b2lkIFJlbmRlclN0eWxlOjphZGRDb3VudGVyUmVz ZXQoQ1NTUHJpbWl0aXZlVmFsdWUqIGMpCit7CisgICAgaWYgKCFjb3VudGVyUmVzZXRMaXN0KSB7 CisgICAgICAgIGNvdW50ZXJSZXNldExpc3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgICAgICBj b3VudGVyUmVzZXRMaXN0LT5yZWYoKTsKKyAgICB9CisKKyAgICBjb3VudGVyUmVzZXRMaXN0LT5h cHBlbmQoYyk7Cit9CisKK3ZvaWQgUmVuZGVyU3R5bGU6OmFkZENvdW50ZXJJbmNyZW1lbnQoQ1NT UHJpbWl0aXZlVmFsdWUqIGMpCit7CisgICAgaWYgKCFjb3VudGVySW5jcmVtZW50TGlzdCkgewor ICAgICAgICBjb3VudGVySW5jcmVtZW50TGlzdCA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgICAg IGNvdW50ZXJJbmNyZW1lbnRMaXN0LT5yZWYoKTsKKyAgICB9CisKKyAgICBjb3VudGVySW5jcmVt ZW50TGlzdC0+YXBwZW5kKGMpOworfQorCiBjb25zdCBWZWN0b3I8U3R5bGVEYXNoYm9hcmRSZWdp b24+JiBSZW5kZXJTdHlsZTo6aW5pdGlhbERhc2hib2FyZFJlZ2lvbnMoKQogeyAKICAgICBzdGF0 aWMgVmVjdG9yPFN0eWxlRGFzaGJvYXJkUmVnaW9uPiBlbXB0eUxpc3Q7CkluZGV4OiBXZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCShyZXZpc2lvbiAxNjUyOCkKKysrIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvagkod29ya2luZyBjb3B5KQpAQCAtODU3LDYgKzg1NywxMyBAQAogCQk5 MzVGQkNGMjA5QkExNDNCMDBFMjMwQjEgLyogRXhjZXB0aW9uQ29kZS5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM1RkJDRjEwOUJBMTQzQjAwRTIzMEIx IC8qIEV4Y2VwdGlvbkNvZGUuaCAqLzsgfTsKIAkJOTM2QjQyNEUwOUE0MzZDRDAwQkFBODIwIC8q IFNWR0NTU1BhcnNlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSBBOEMwRjZGNjA4OTcwMUYxMDBCQTUxMTQgLyogU1ZHQ1NTUGFyc2VyLmNwcCAqLzsg fTsKIAkJOTM2QkREMUQwQTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNkJERDFDMEEw MzFBRUIwMDRERjRBQiAvKiBHcmFwaGljc0NvbnRleHRDRy5jcHAgKi87IH07CisJCTkzNzFCQjcx MEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVu ZGVyQ291bnRlci5oICovOyB9OworCQk5MzcxQkI3MzBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVy Q291bnRlci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi87IH07CisJ CTkzNzFCQjc1MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3NDBBQzQ3RkM4MDBD RDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oICovOyB9OworCQk5MzcxQkI3NzBBQzQ3RkQwMDBD RDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3NjBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJl c2V0Tm9kZS5jcHAgKi87IH07CisJCTkzNzFCQjc5MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVy Tm9kZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3 MUJCNzgwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggKi87IH07CisJCTkzNzFCQjdC MEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291 bnRlck5vZGUuY3BwICovOyB9OworCQk5MzcxQkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRl ckxpc3RJdGVtLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA5MzcxQkI3QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi87IH07CiAJ CTkzNzI1NjEwMEE2MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliIGluIEZyYW1ld29y a3MgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MjU2MEYwQTYxNTY0MjAw QjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIgKi87IH07CiAJCTkzODBGNDczMDlBMTFBQjQwMDFG REIzNCAvKiBXaWRnZXQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gOTM4MEY0NzEwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgKi87IH07CiAJ CTkzODBGNDc0MDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuaCBpbiBIZWFkZXJzICovID0ge2lz YSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzODBGNDcyMDlBMTFBQjQwMDFGREIzNCAvKiBX aWRnZXQuaCAqLzsgfTsKQEAgLTMxODMsNiArMzE5MCwxMyBAQAogCQk5MzVGQkNGMTA5QkExNDNC MDBFMjMwQjEgLyogRXhjZXB0aW9uQ29kZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBFeGNlcHRpb25Db2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNkJE RDFDMEEwMzFBRUIwMDRERjRBQiAvKiBHcmFwaGljc0NvbnRleHRDRy5jcHAgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBHcmFwaGljc0NvbnRleHRDRy5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNkREMDNBMDlDRUFDMjcwMDU2QUU4QyAvKiBSYW5nZS5p ZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtu b3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gUmFuZ2UuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQk5MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVuZGVyQ291bnRlci5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVy Q291bnRlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g MzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVuZGVy Q291bnRlci5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc0MEFDNDdG QzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j Lmg7IHBhdGggPSBDb3VudGVyUmVzZXROb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTkzNzFCQjc2MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBDb3VudGVyUmVzZXROb2RlLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzgwQUM0N0ZENzAwQ0Q0QTdCIC8q IENvdW50ZXJOb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3VudGVy Tm9kZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3QTBBQzQ3RkRFMDBD RDRBN0IgLyogQ291bnRlck5vZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IENvdW50ZXJOb2RlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3 MUJCN0MwQUM0N0ZFNzAwQ0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gQ291bnRlckxpc3RJdGVtLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTkzNzI1NjBGMEE2MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGli ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gImNvbXBp bGVkLm1hY2gtby5keWxpYiI7IG5hbWUgPSBsaWJzcWxpdGUzLmR5bGliOyBwYXRoID0gL3Vzci9s aWIvbGlic3FsaXRlMy5keWxpYjsgc291cmNlVHJlZSA9ICI8YWJzb2x1dGU+IjsgfTsKIAkJOTM4 MEY0NzEwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gV2lkZ2V0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJOTM4MEY0NzIwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gV2lkZ2V0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBA IC03MTY2LDYgKzcxODAsMTEgQEAKIAkJCQlCQ0VBNDgxNDA5N0Q5MzAyMDA5NEM5RTQgLyogYmlk aS5oICovLAogCQkJCUJDRUE0ODE1MDk3RDkzMDIwMDk0QzlFNCAvKiBicmVha19saW5lcy5jcHAg Ki8sCiAJCQkJQkNFQTQ4MTYwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFrX2xpbmVzLmggKi8sCisJ CQkJOTM3MUJCN0MwQUM0N0ZFNzAwQ0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICovLAorCQkJ CTkzNzFCQjdBMEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8sCisJCQkJOTM3 MUJCNzgwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggKi8sCisJCQkJOTM3MUJCNzYw QUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovLAorCQkJCTkzNzFCQjc0 MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi8sCiAJCQkJQkNFQTQ4MTcw OTdEOTMwMjAwOTRDOUU0IC8qIERhdGFSZWYuaCAqLywKIAkJCQlBQkU3QjUyMTBBNDg5RjgzMDAz MTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5jcHAgKi8sCiAJCQkJQUJFN0I1MjIwQTQ4 OUY4MzAwMzE4ODFDIC8qIERlcHJlY2F0ZWRSZW5kZXJTZWxlY3QuaCAqLywKQEAgLTcyMDIsNiAr NzIyMSw4IEBACiAJCQkJQkNFQTQ4MjkwOTdEOTMwMjAwOTRDOUU0IC8qIFJlbmRlclZpZXcuaCAq LywKIAkJCQlCQ0VBNDgyQzA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmNwcCAq LywKIAkJCQlCQ0VBNDgyRDA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmggKi8s CisJCQkJOTM3MUJCNzIwQUM0N0ZCODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuY3BwICovLAor CQkJCTkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi8sCiAJCQkJ QThFQTczQUYwQTE5MDBFMzAwQThFRjVGIC8qIFJlbmRlckZpZWxkc2V0LmNwcCAqLywKIAkJCQlB OEVBNzNCMDBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuaCAqLywKIAkJCQkwNjZD NzcyRTBBQjYwM0ZEMDAyMzhDQzQgLyogUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuY3BwICovLApA QCAtODQ1MCw2ICs4NDcxLDEwIEBACiAJCQkJQTg0MTVGOUUwQUMxMEM1RDAwRjdEMERGIC8qIEtD YW52YXNNYXNrZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCUE4NDE1RkEwMEFDMTBDNUQwMEY3RDBE RiAvKiBLQ2FudmFzTWFya2VyLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzNGQ0FBOTBBQzNEQjU4 MDBCQTU0QUQgLyogUGxhdGZvcm1TY3JvbGxCYXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzNzFC QjcxMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLywKKwkJ CQk5MzcxQkI3NTBBQzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oIGluIEhlYWRl cnMgKi8sCisJCQkJOTM3MUJCNzkwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggaW4g SGVhZGVycyAqLywKKwkJCQk5MzcxQkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJ dGVtLmggaW4gSGVhZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rw cm9jZXNzaW5nID0gMDsKIAkJfTsKQEAgLTk1MzgsNiArOTU2Myw5IEBACiAJCQkJQTg0MTVGOUYw QUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXNrZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ QTg0MTVGQTEwQUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXJrZXIuY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJQTg0MTVGQTIwQUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNGaWx0ZXJzLmNwcCBp biBTb3VyY2VzICovLAorCQkJCTkzNzFCQjczMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3Vu dGVyLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTkzNzFCQjc3MEFDNDdGRDAwMENENEE3QiAvKiBD b3VudGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTkzNzFCQjdCMEFDNDdGREUw MENENEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5P bmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKSW5kZXg6IGNzcy9DU1ND b21wdXRlZFN0eWxlRGVjbGFyYXRpb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9DU1NDb21wdXRl ZFN0eWxlRGVjbGFyYXRpb24uY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9DU1NDb21wdXRl ZFN0eWxlRGVjbGFyYXRpb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02MDIsMTEgKzYwMiw5IEBA CiAgICAgICAgIC8vIEZJWE1FOiB1bmltcGxlbWVudGVkCiAgICAgICAgIGJyZWFrOwogICAgIGNh c2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6Ci0gICAgICAgIC8vIEZJWE1FOiB1bmltcGxl bWVudGVkCi0gICAgICAgIGJyZWFrOworICAgICAgICByZXR1cm4gc3R5bGUtPmNvdW50ZXJJbmNy ZW1lbnRWYWx1ZUxpc3QoKTsKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVTRVQ6Ci0gICAg ICAgIC8vIEZJWE1FOiB1bmltcGxlbWVudGVkCi0gICAgICAgIGJyZWFrOworICAgICAgICByZXR1 cm4gc3R5bGUtPmNvdW50ZXJSZXNldFZhbHVlTGlzdCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ1VS U09SOgogICAgICAgICBpZiAoc3R5bGUtPmN1cnNvckltYWdlKCkpCiAgICAgICAgICAgICByZXR1 cm4gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKHN0eWxlLT5jdXJzb3JJbWFnZSgpLT51cmwoKSwgQ1NT UHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpOwpJbmRleDogY3NzL2Nzc3BhcnNlci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIGNzcy9jc3NwYXJzZXIuaAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3NzcGFyc2Vy LmgJKHdvcmtpbmcgY29weSkKQEAgLTE0NiwxMSArMTQ2LDEzIEBACiAKICAgICAgICAgYm9vbCBw YXJzZVNoYXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgYm9vbCBwYXJz ZUZvbnQoYm9vbCBpbXBvcnRhbnQpOworICAgICAgICBib29sIHBhcnNlQ291bnRlcihpbnQgcHJv cElkLCBib29sIGluY3JlbWVudCwgYm9vbCBpbXBvcnRhbnQpOwogICAgICAgICBDU1NWYWx1ZUxp c3QqIHBhcnNlRm9udEZhbWlseSgpOwogICAgICAgICBib29sIHBhcnNlQ29sb3JQYXJhbWV0ZXJz KFZhbHVlKiwgaW50KiBjb2xvclZhbHVlcywgYm9vbCBwYXJzZUFscGhhKTsKICAgICAgICAgYm9v bCBwYXJzZUhTTFBhcmFtZXRlcnMoVmFsdWUqLCBkb3VibGUqIGNvbG9yVmFsdWVzLCBib29sIHBh cnNlQWxwaGEpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xvcigpOwogICAg ICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xvckZyb21WYWx1ZShWYWx1ZSopOworICAg ICAgICBDU1NWYWx1ZSogcGFyc2VDb3VudGVyQ29udGVudChWYWx1ZUxpc3QgKmFyZ3MsIGJvb2wg Y291bnRlcnMpOwogICAgICAgICAKICNpZmRlZiBTVkdfU1VQUE9SVAogICAgICAgICBib29sIHBh cnNlU1ZHVmFsdWUoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRhbnQpOwpJbmRleDogY3NzL2Nzc3N0 eWxlc2VsZWN0b3IuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAko cmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3Nzc3R5bGVzZWxlY3Rvci5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTI2LDYgKzI2LDcgQEAKICNpbmNsdWRlICJjc3NzdHlsZXNlbGVjdG9yLmgiCiAKICNp bmNsdWRlICJDU1NCb3JkZXJJbWFnZVZhbHVlLmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgogI2lu Y2x1ZGUgIkNTU0ltYWdlVmFsdWUuaCIKICNpbmNsdWRlICJDU1NJbXBvcnRSdWxlLmgiCiAjaW5j bHVkZSAiQ1NTTWVkaWFSdWxlLmgiCkBAIC0zMTQ4LDcgKzMxNDksOSBAQAogCiAgICAgICAgIGZv ciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKICAgICAgICAgICAgIENTU1ZhbHVlICppdGVt ID0gbGlzdC0+aXRlbShpKTsKLSAgICAgICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRpdmVWYWx1 ZSgpKSBjb250aW51ZTsKKyAgICAgICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRpdmVWYWx1ZSgp KQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgCiAgICAgICAgICAgICBD U1NQcmltaXRpdmVWYWx1ZSAqdmFsID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihp dGVtKTsKICAgICAgICAgICAgIGlmICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZl VmFsdWU6OkNTU19TVFJJTkcpCiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQodmFs LT5nZXRTdHJpbmdWYWx1ZSgpLmltcGwoKSwgaSAhPSAwKTsKQEAgLTMxNjIsMjAgKzMxNjUsMzQg QEAKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudChlbGVtZW50LT5nZXRBdHRyaWJ1 dGUoYXR0cikuaW1wbCgpLCBpICE9IDApOwogICAgICAgICAgICAgICAgIC8vIHJlZ2lzdGVyIHRo ZSBmYWN0IHRoYXQgdGhlIGF0dHJpYnV0ZSB2YWx1ZSBhZmZlY3RzIHRoZSBzdHlsZQogICAgICAg ICAgICAgICAgIG1fc2VsZWN0b3JBdHRycy5hZGQoYXR0ci5sb2NhbE5hbWUoKS5pbXBsKCkpOwot ICAgICAgICAgICAgfQotICAgICAgICAgICAgZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9 PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfVVJJKSB7CisgICAgICAgICAgICB9IGVsc2UgaWYgKHZh bC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgewogICAgICAg ICAgICAgICAgIENTU0ltYWdlVmFsdWUgKmltYWdlID0gc3RhdGljX2Nhc3Q8Q1NTSW1hZ2VWYWx1 ZSo+KHZhbCk7CiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoaW1hZ2UtPmltYWdl KGVsZW1lbnQtPmRvY3VtZW50KCktPmRvY0xvYWRlcigpKSwgaSAhPSAwKTsKLSAgICAgICAgICAg IH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1p dGl2ZVZhbHVlOjpDU1NfQ09VTlRFUikgeworICAgICAgICAgICAgICAgIENvdW50ZXIqIGNvdW50 ZXJWYWx1ZSA9IHZhbC0+Z2V0Q291bnRlclZhbHVlKCk7CisgICAgICAgICAgICAgICAgQ291bnRl ckRhdGEgY291bnRlciA9ICBDb3VudGVyRGF0YShjb3VudGVyVmFsdWUtPmlkZW50aWZpZXIoKSwK KyAgICAgICAgICAgICAgICAgICAgY291bnRlclZhbHVlLT5saXN0U3R5bGVOdW1iZXIoKSwgY291 bnRlclZhbHVlLT5zZXBhcmF0b3IoKSk7CisgICAgICAgICAgICAgICAgQ291bnRlckRhdGEqIGMg PSBuZXcgQ291bnRlckRhdGEoY291bnRlcik7CisgICAgICAgICAgICAgICAgc3R5bGUtPnNldENv bnRlbnQoYywgaSAhPSAwKTsKKyAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIGJyZWFr OwogICAgIH0KIAotICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6Ci0gICAgICAg IC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJJbmNyZW1lbnQKLSAgICBjYXNlIENTU19QUk9QX0NPVU5U RVJfUkVTRVQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNldAorICAgIGNhc2Ug Q1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6IHsKKyAgICAgICAgaWYoIXZhbHVlLT5pc1ZhbHVl TGlzdCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBDU1NWYWx1ZUxpc3QqIGxpc3Qg PSBzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QgKj4odmFsdWUpOworICAgICAgICBzdHlsZS0+c2V0 Q291bnRlckluY3JlbWVudChsaXN0KTsKICAgICAgICAgYnJlYWs7CisgICAgfQorICAgIGNhc2Ug Q1NTX1BST1BfQ09VTlRFUl9SRVNFVDogeworICAgICAgICBpZighdmFsdWUtPmlzVmFsdWVMaXN0 KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIENTU1ZhbHVlTGlzdCogbGlzdCA9IHN0 YXRpY19jYXN0PENTU1ZhbHVlTGlzdCAqPih2YWx1ZSk7CisgICAgICAgIHN0eWxlLT5zZXRDb3Vu dGVyUmVzZXQobGlzdCk7CisgICAgICAgIGJyZWFrOworICAgIH0KICAgICBjYXNlIENTU19QUk9Q X0ZPTlRfRkFNSUxZOiB7CiAgICAgICAgIC8vIGxpc3Qgb2Ygc3RyaW5ncyBhbmQgaWRzCiAgICAg ICAgIGlmIChpc0luaGVyaXQpIHsKSW5kZXg6IGNzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkocmV2aXNpb24gMTY1MjgpCisr KyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01MjQsNyArNTI0 LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBj YXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAgLy8gIyMjCisgICAgICAgICAgICB0ZXh0ID0g ImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQgKz0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5u dW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7CisgICAgICAgICAgICAvLyAjIyMgYWRkIGxp c3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2Ug Q1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJlY3RJbXBsKiByZWN0VmFsID0gZ2V0UmVjdFZhbHVl KCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9Db3VudGVyLmgJKHJl dmlzaW9uIDE2NTI4KQorKysgY3NzL0NvdW50ZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjMsMjMg KzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJfSAogI2RlZmluZSBDb3VudGVyX0gKIAorI2luY2x1 ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKICNp bmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ291bnRl ciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4gewogcHVibGljOgotICAgIFN0cmluZyBpZGVudGlm aWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9Ci0gICAgU3RyaW5nIGxpc3RTdHls ZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9Ci0gICAgU3RyaW5nIHNlcGFyYXRvcigp IGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisgICAgQ291bnRlcigpIDogbV9pZGVudGlm aWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9zZXBhcmF0b3IoMCkgeyB9CisgICAgQ291bnRlcihQ YXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVudGlmaWVyLCBQYXNzUmVmUHRyPENTU1By aW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisgICAgICAgIFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZl VmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAgOiBtX2lkZW50aWZpZXIoaWRlbnRpZmllciksIG1f bGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2VwYXJhdG9yKHNlcGFyYXRvcikgeyB9CisgICAgdmly dHVhbCB+Q291bnRlcigpIHsgfQogCi1wcml2YXRlOgotICAgIFN0cmluZyBtX2lkZW50aWZpZXI7 Ci0gICAgU3RyaW5nIG1fbGlzdFN0eWxlOwotICAgIFN0cmluZyBtX3NlcGFyYXRvcjsKLX07Cisg ICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25zdCB7IHJldHVybiBtX2lkZW50aWZpZXIuZ2V0KCkg PyBtX2lkZW50aWZpZXIuZ2V0KCktPmdldFN0cmluZ1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQorICAg IFN0cmluZyBsaXN0U3R5bGUoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZS5nZXQoKSA/IG1f bGlzdFN0eWxlLmdldCgpLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0KKyAgICBTdHJp bmcgc2VwYXJhdG9yKCkgY29uc3QgeyByZXR1cm4gbV9zZXBhcmF0b3IuZ2V0KCkgPyBtX3NlcGFy YXRvci5nZXQoKS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CiAKLX0gLy8gbmFtZXNw YWNlCisgICAgaW50IGxpc3RTdHlsZU51bWJlcigpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxl LmdldCgpID8gKGludCkgbV9saXN0U3R5bGUuZ2V0KCktPmdldEZsb2F0VmFsdWUoKSA6IDA7IH0K KyAgICAKKyAgICB2b2lkIHNldElkZW50aWZpZXIoUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1 ZT4gaWRlbnRpZmllcikgeyBtX2lkZW50aWZpZXIgPSBpZGVudGlmaWVyOyB9CisgICAgdm9pZCBz ZXRMaXN0U3R5bGUoUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbGlzdFN0eWxlKSB7IG1f bGlzdFN0eWxlID0gbGlzdFN0eWxlOyB9CisgICAgdm9pZCBzZXRTZXBhcmF0b3IoUGFzc1JlZlB0 cjxDU1NQcmltaXRpdmVWYWx1ZT4gc2VwYXJhdG9yKSB7IG1fc2VwYXJhdG9yID0gc2VwYXJhdG9y OyB9CisgCitwcm90ZWN0ZWQ6CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBtX2lkZW50 aWZpZXI7IC8vc3RyaW5nCisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBtX2xpc3RTdHls ZTsgLy9pbnQKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IG1fc2VwYXJhdG9yOyAvL3N0 cmluZworIH07CiAKK30gLy9uYW1lc3BhY2UKKwogI2VuZGlmCkluZGV4OiBjc3MvY3NzcGFyc2Vy LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3NzcGFyc2VyLmNwcAkocmV2aXNpb24gMTY1MjgpCisr KyBjc3MvY3NzcGFyc2VyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjUsNiArMjUsNyBAQAogI2lu Y2x1ZGUgImNzc3BhcnNlci5oIgogCiAjaW5jbHVkZSAiQ1NTQm9yZGVySW1hZ2VWYWx1ZS5oIgor I2luY2x1ZGUgIkNvdW50ZXIuaCIKICNpbmNsdWRlICJDU1NJbWFnZVZhbHVlLmgiCiAjaW5jbHVk ZSAiQ1NTQ2hhcnNldFJ1bGUuaCIKICNpbmNsdWRlICJDU1NJbXBvcnRSdWxlLmgiCkBAIC04NzAs NiArODcxLDE3IEBACiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIHZhbGlkX3ByaW1pdGl2ZSA9 ICghaWQgJiYgdmFsaWRVbml0KHZhbHVlLCBGTnVtYmVyfEZMZW5ndGh8RlBlcmNlbnQsIHN0cmlj dCkpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfSU5DUkVNRU5U OiAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwgbm9uZSB8IGluaGVyaXQKKyAg ICAgICAgaWYgKGlkID09IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAgIHZhbGlkX3ByaW1pdGl2 ZSA9IHRydWU7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiBwYXJzZUNvdW50ZXIo cHJvcElkLCB0cnVlLCBpbXBvcnRhbnQpOworICAgICAgICBicmVhazsKKyAgICAgY2FzZSBDU1Nf UFJPUF9DT1VOVEVSX1JFU0VUOiAgICAgICAgLy8gWyA8aWRlbnRpZmllcj4gPGludGVnZXI+PyBd KyB8IG5vbmUgfCBpbmhlcml0CisgICAgICAgICBpZiAoaWQgPT0gQ1NTX1ZBTF9OT05FKQorICAg ICAgICAgICAgIHZhbGlkX3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGVsc2UKKyAgICAgICAg ICAgIHJldHVybiBwYXJzZUNvdW50ZXIocHJvcElkLCBmYWxzZSwgaW1wb3J0YW50KTsKICAgICBj YXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFtaWx5LW5hbWU+IHwg PGdlbmVyaWMtZmFtaWx5PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5Pl0g fCBpbmhlcml0CiAgICAgewpAQCAtMTUzMywxOCArMTU0NSwzMCBAQAogICAgICAgICAgICAgcGFy c2VkVmFsdWUgPSBuZXcgQ1NTSW1hZ2VWYWx1ZSgKICAgICAgICAgICAgICAgICBTdHJpbmcoS1VS TChzdHlsZUVsZW1lbnQtPmJhc2VVUkwoKS5kZXByZWNhdGVkU3RyaW5nKCksIHZhbHVlLmRlcHJl Y2F0ZWRTdHJpbmcoKSkudXJsKCkpLCBzdHlsZUVsZW1lbnQpOwogICAgICAgICB9IGVsc2UgaWYg KHZhbC0+dW5pdCA9PSBWYWx1ZTo6RnVuY3Rpb24pIHsKLSAgICAgICAgICAgIC8vIGF0dHIoWCkK KyAgICAgICAgICAgIC8vIGF0dHIoWCkgfCBjb3VudGVyKFggWyxZXSkgfCBjb3VudGVycyhYLCBZ LCBbLFpdKQogICAgICAgICAgICAgVmFsdWVMaXN0ICphcmdzID0gdmFsLT5mdW5jdGlvbi0+YXJn czsKICAgICAgICAgICAgIFN0cmluZyBmbmFtZSA9IGRvbVN0cmluZyh2YWwtPmZ1bmN0aW9uLT5u YW1lKS5sb3dlcigpOwotICAgICAgICAgICAgaWYgKGZuYW1lICE9ICJhdHRyKCIgfHwgIWFyZ3Mp CisgICAgICAgICAgICBpZiAoIWFyZ3MpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwot ICAgICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAgICAgaWYgKGZuYW1l ID09ICJhdHRyKCIpIHsKKyAgICAgICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEpCisg ICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgICBWYWx1ZSAq YSA9IGFyZ3MtPmN1cnJlbnQoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUgPSBk b21TdHJpbmcoYS0+c3RyaW5nKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+aXNI VE1MRG9jdW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgYXR0ck5hbWUgPSBhdHRyTmFtZS5s b3dlcigpOworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZh bHVlKGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0FUVFIpOworICAgICAgICAgICAg fSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXIoIikgeworICAgICAgICAg ICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3VudGVyQ29udGVudChhcmdzLCBmYWxzZSk7Cisg ICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZhbHNlOworICAgICAgICAg ICAgfSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXJzKCIpIHsKKyAgICAg ICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IHBhcnNlQ291bnRlckNvbnRlbnQoYXJncywgdHJ1ZSk7 CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZhbHNlOworICAgICAg ICAgICAgfQorICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsK LSAgICAgICAgICAgIFZhbHVlICphID0gYXJncy0+Y3VycmVudCgpOwotICAgICAgICAgICAgU3Ry aW5nIGF0dHJOYW1lID0gZG9tU3RyaW5nKGEtPnN0cmluZyk7Ci0gICAgICAgICAgICBpZiAoZG9j dW1lbnQoKS0+aXNIVE1MRG9jdW1lbnQoKSkKLSAgICAgICAgICAgICAgICBhdHRyTmFtZSA9IGF0 dHJOYW1lLmxvd2VyKCk7Ci0gICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NQcmltaXRp dmVWYWx1ZShhdHRyTmFtZSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19BVFRSKTsKICAgICAgICAg fSBlbHNlIGlmICh2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkgewog ICAgICAgICAgICAgLy8gb3Blbi1xdW90ZQogICAgICAgICAgICAgLy8gY2xvc2UtcXVvdGUKQEAg LTE5NzgsNiArMjAwMiw1NCBAQAogfQogI2VuZGlmCiAKK0NTU1ZhbHVlKiBDU1NQYXJzZXI6OnBh cnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0ICphcmdzLCBib29sIGNvdW50ZXJzKQoreworICAg IGlmIChjb3VudGVycyB8fCAoYXJncy0+c2l6ZSgpICE9IDEgJiYgYXJncy0+c2l6ZSgpICE9IDMp KQorICAgICAgICBpZiAoIWNvdW50ZXJzIHx8IChhcmdzLT5zaXplKCkgIT0gMyAmJiBhcmdzLT5z aXplKCkgIT0gNSkpCisgICAgICAgICAgICByZXR1cm4gMDsKKworICAgIFZhbHVlICppID0gYXJn cy0+Y3VycmVudCgpOworICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBpZGVudGlmaWVyID0gbmV3IENT U1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCBDU1NQcmltaXRpdmVWYWx1ZTo6 Q1NTX1NUUklORyk7CisKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSogc2VwYXJhdG9yID0gbmV3IENT U1ByaW1pdGl2ZVZhbHVlKFN0cmluZygpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7 CisgICAgaWYgKGNvdW50ZXJzKSB7CisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAg IGlmIChpLT51bml0ICE9IFZhbHVlOjpPcGVyYXRvciB8fCBpLT5pVmFsdWUgIT0gJywnKQorICAg ICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOwor ICAgICAgICBpZiAoaS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORykKKyAg ICAgICAgICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENT U1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCAoQ1NTUHJpbWl0aXZlVmFsdWU6 OlVuaXRUeXBlcykgaS0+dW5pdCk7CisgICAgfQorICAgIAorICAgIC8vIE1ha2UgdGhlIGxpc3Qg c3R5bGUgZGVmYXVsdCBkZWNpbWFsCisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGxpc3RTdHlsZSA9 IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShDU1NfVkFMX0RFQ0lNQUwgLSBDU1NfVkFMX0RJU0MsIENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICBpID0gYXJncy0+bmV4dCgpOworICAg IGlmIChpKSB7CisgICAgICAgIGlmIChpLT51bml0ICE9IFZhbHVlOjpPcGVyYXRvciB8fCBpLT5p VmFsdWUgIT0gJywnKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBp ID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1 ZTo6Q1NTX0lERU5UKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBz aG9ydCBscyA9IDA7CisgICAgICAgIGlmIChpLT5pZCA9PSBDU1NfVkFMX05PTkUpCisgICAgICAg ICAgICBscyA9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEgLSBDU1NfVkFMX0RJU0MgKyAxOworICAg ICAgICBlbHNlIGlmIChpLT5pZCA+PSBDU1NfVkFMX0RJU0MgJiYgaS0+aWQgPD0gQ1NTX1ZBTF9L QVRBS0FOQV9JUk9IQSkKKyAgICAgICAgICAgIGxzID0gaS0+aWQgLSBDU1NfVkFMX0RJU0M7Cisg ICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgIGxpc3RTdHlsZSA9 IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShscywgKENTU1ByaW1pdGl2ZVZhbHVlOjpVbml0VHlwZXMp IGktPnVuaXQpOworICAgIH0KKyAgICAKKyAgICBDb3VudGVyKiBjb3VudGVyID0gbmV3IENvdW50 ZXIoaWRlbnRpZmllciwgbGlzdFN0eWxlLCBzZXBhcmF0b3IpOworICAgIHJldHVybiBuZXcgQ1NT UHJpbWl0aXZlVmFsdWUoY291bnRlcik7Cit9CisKIGJvb2wgQ1NTUGFyc2VyOjpwYXJzZVNoYXBl KGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KQogewogICAgIFZhbHVlICp2YWx1ZSA9IHZhbHVl TGlzdC0+Y3VycmVudCgpOwpAQCAtMjY3Niw2ICsyNzQ4LDUyIEBACiAgICAgcmV0dXJuIGNvbnRl eHQuZmFpbGVkKCk7CiB9CiAKK2Jvb2wgQ1NTUGFyc2VyOjpwYXJzZUNvdW50ZXIoaW50IHByb3BJ ZCwgYm9vbCBpbmNyZW1lbnQsIGJvb2wgaW1wb3J0YW50KQoreworICAgIGVudW0geyBJRCwgVkFM IH0gc3RhdGUgPSBJRDsKKworICAgIENTU1ZhbHVlTGlzdCogbGlzdCA9IG5ldyBDU1NWYWx1ZUxp c3Q7CisgICAgVmFsdWUqIHZhbDsKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSogY291bnRlck5hbWU7 CisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIG51bVZhbHVlOworICAgIAorICAgIHdoaWxlICh0cnVl KSB7CisgICAgICAgIHZhbCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOworICAgICAgICBzd2l0Y2gg KHN0YXRlKSB7CisgICAgICAgICAgICBjYXNlIElEOgorICAgICAgICAgICAgICAgIGlmICh2YWwg JiYgdmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpIHsKKyAgICAgICAg ICAgICAgICAgICAgY291bnRlck5hbWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5n KHZhbC0+c3RyaW5nKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpOworICAgICAgICAg ICAgICAgICAgICBzdGF0ZSA9IFZBTDsKKyAgICAgICAgICAgICAgICAgICAgdmFsdWVMaXN0LT5u ZXh0KCk7CisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGNhc2UgVkFMOiB7CisgICAgICAg ICAgICAgICAgaW50IGkgPSAoaW5jcmVtZW50KSA/IDEgOiAwOworICAgICAgICAgICAgICAgIGlm ICh2YWwgJiYgdmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKSB7Cisg ICAgICAgICAgICAgICAgICAgIGkgPSAoc2hvcnQpdmFsLT5mVmFsdWU7CisgICAgICAgICAgICAg ICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOworICAgICAgICAgICAgICAgIH0KKworICAgICAgICAg ICAgICAgIG51bVZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGksIENTU1ByaW1pdGl2ZVZh bHVlOjpDU1NfTlVNQkVSKTsKKyAgICAgICAgICAgICAgICBQYWlyKiBwYWlyID0gbmV3IFBhaXIo Y291bnRlck5hbWUsIG51bVZhbHVlKTsKKyAgICAgICAgICAgICAgICBsaXN0LT5hcHBlbmQobmV3 IENTU1ByaW1pdGl2ZVZhbHVlKHBhaXIpKTsKKyAgICAgICAgICAgICAgICBzdGF0ZSA9IElEOwor ICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAg ICAgIGJyZWFrOworICAgIH0KKyAgICAKKyAgICBpZihsaXN0LT5sZW5ndGgoKSA+IDApIHsKKyAg ICAgICAgYWRkUHJvcGVydHkocHJvcElkLCBsaXN0LCBpbXBvcnRhbnQpOworICAgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICB9CisKKyAgICBkZWxldGUgbGlzdDsKKyAgICByZXR1cm4gZmFsc2U7Cit9 CisKICNpZmRlZiBDU1NfREVCVUcKIAogc3RhdGljIGlubGluZSBpbnQgeXllcnJvcihjb25zdCBj aGFyICpzdHIpCg== 10788 2006-09-26 17:21:16 -0700 2006-09-26 23:43:38 -0700 Patch the addresses Darin's comments, but leaks postingTuesday.txt text/plain 69184 bdakin SW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5kZXJP YmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0IChD KSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkg QW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAg RGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQgQWxs YW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChDKSAy MDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMjks NiArMzAsOCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIgCiAjaW5jbHVkZSAiQWZmaW5l VHJhbnNmb3JtLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKKyNpbmNsdWRlICJDb3VudGVy Tm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKICNpbmNsdWRlICJEZWNvZGVy LmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFbGVtZW50LmgiCkBAIC0zNyw2 ICs0MCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQu aCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MT0xpc3RFbGVtZW50Lmgi CiAjaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJBcmVuYS5oIgogI2luY2x1 ZGUgIlJlbmRlckZsZXhpYmxlQm94LmgiCkBAIC0xNTksNiArMTYzLDcgQEAKIG1fcGFyZW50KCAw ICksCiBtX3ByZXZpb3VzKCAwICksCiBtX25leHQoIDAgKSwKK21fY291bnRlck5vZGVNYXAoIDAg KSwKIG1fdmVydGljYWxQb3NpdGlvbiggUG9zaXRpb25VbmRlZmluZWQgKSwKIG1fbmVlZHNMYXlv dXQoIGZhbHNlICksCiBtX25vcm1hbENoaWxkTmVlZHNMYXlvdXQoIGZhbHNlICksCkBAIC0yMzk1 LDYgKzI0MDAsMTEgQEAKIAogdm9pZCBSZW5kZXJPYmplY3Q6OmRlc3Ryb3koKQogeworICAgIGlm IChtX2NvdW50ZXJOb2RlTWFwKSB7CisgICAgICAgIG1fY291bnRlck5vZGVNYXAtPmNsZWFyKCk7 CisgICAgICAgIGRlbGV0ZSBtX2NvdW50ZXJOb2RlTWFwOworICAgIH0KKyAgICAKICAgICBkb2N1 bWVudCgpLT5heE9iamVjdENhY2hlKCktPnJlbW92ZSh0aGlzKTsKIAogICAgIC8vIEJ5IGRlZmF1 bHQgbm8gcmVmLWNvdW50aW5nLiBSZW5kZXJXaWRnZXQ6OmRlc3Ryb3koKSBkb2Vzbid0IGNhbGwK QEAgLTI4MzcsNiArMjg0NywxMzggQEAKICAgICByZXR1cm4gKGF2b2lkc0Zsb2F0cygpICYmIChz dHlsZSgpLT53aWR0aCgpLmlzQXV0bygpIHx8IGlzSFIoKSB8fCAoc3R5bGUoKS0+aHRtbEhhY2tz KCkgJiYgIWlzVGFibGUoKSkpKTsKIH0KIAorYm9vbCBSZW5kZXJPYmplY3Q6Omhhc0NvdW50ZXIo Y29uc3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdAoreworICAgIGlmIChzdHlsZSgpKQorICAgICAg ICBpZiAoKG1fY291bnRlck5vZGVNYXAgJiYgbV9jb3VudGVyTm9kZU1hcC0+Z2V0KGNvdW50ZXIp KSB8fCBzdHlsZSgpLT5oYXNDb3VudGVyUmVzZXQoY291bnRlcikgfHwgCisgICAgICAgICAgICAg ICAgc3R5bGUoKS0+aGFzQ291bnRlckluY3JlbWVudChjb3VudGVyKSkKKyAgICAgICAgICAgIHJl dHVybiB0cnVlOworICAgIAorICAgIGlmIChjb3VudGVyID09ICJsaXN0LWl0ZW0iKQorICAgICAg ICBpZiAoaXNMaXN0SXRlbSgpIHx8IChlbGVtZW50KCkgJiYgKAorICAgICAgICAgICAgICAgIGVs ZW1lbnQoKS0+aGFzVGFnTmFtZShvbFRhZykgfHwKKyAgICAgICAgICAgICAgICBlbGVtZW50KCkt Pmhhc1RhZ05hbWUodWxUYWcpIHx8CisgICAgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdO YW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKGRp clRhZykpKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJuIGZhbHNlOwor fQorCitDb3VudGVyTm9kZSogUmVuZGVyT2JqZWN0OjpmaW5kQ291bnRlcihjb25zdCBTdHJpbmcm IGNvdW50ZXIsIGJvb2wgdmlldywgYm9vbCBjb3VudGVycykKK3sKKyAgICBpZiAoIXN0eWxlKCkp CisgICAgICAgIHJldHVybiAwOworCisgICAgaW50IHZhbCA9IDA7CisgICAgQ291bnRlck5vZGUq IG5ld05vZGUgPSBtX2NvdW50ZXJOb2RlTWFwID8gbV9jb3VudGVyTm9kZU1hcC0+Z2V0KGNvdW50 ZXIpIDogMDsKKyAgICBpZiAobmV3Tm9kZSkKKyAgICAgICAgcmV0dXJuIG5ld05vZGU7CisKKyAg ICBpZiAoc3R5bGUoKS0+aGFzQ291bnRlclJlc2V0KGNvdW50ZXIpIHx8IGlzUm9vdCgpKSB7Cisg ICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJSZXNldE5vZGUodGhp cyk7CisgICAgICAgIHZhbCA9IHN0eWxlKCktPmNvdW50ZXJSZXNldChjb3VudGVyKTsKKyAgICAg ICAgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpCisgICAgICAgICAg ICB2YWwgKz0gc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChjb3VudGVyKTsKKyAgICB9IGVsc2Ug aWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpIHsKKyAgICAgICAgbmV3 Tm9kZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgQ291bnRlck5vZGUodGhpcyk7CisgICAgICAgIHZh bCArPSBzdHlsZSgpLT5jb3VudGVySW5jcmVtZW50KGNvdW50ZXIpOworICAgIH0gZWxzZSBpZiAo Y291bnRlciA9PSAibGlzdC1pdGVtIikgeworICAgICAgICBpZiAoaXNMaXN0SXRlbSgpKSB7Cisg ICAgICAgICAgICBpZiAoZWxlbWVudCgpKSB7CisgICAgICAgICAgICAgICAgU3RyaW5nIHYgPSBz dGF0aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0QXR0cmlidXRlKCJ2YWx1ZSIpOwor ICAgICAgICAgICAgICAgIGlmICghdi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgICAgICAgICAg bmV3Tm9kZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgQ291bnRlclJlc2V0Tm9kZSh0aGlzKTsKKyAg ICAgICAgICAgICAgICAgICAgdmFsID0gdi50b0ludCgpOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgIH0gCisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmICghbmV3Tm9kZSkgewor ICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJOb2Rl KHRoaXMpOworICAgICAgICAgICAgICAgIHZhbCA9IDE7CisgICAgICAgICAgICB9CisgICAgICAg IH0gZWxzZSBpZiAoZWxlbWVudCgpICYmIGVsZW1lbnQoKS0+aGFzVGFnTmFtZShvbFRhZykpIHsK KyAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJSZXNldE5v ZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSBzdGF0aWNfY2FzdDxIVE1MT0xpc3RFbGVtZW50 Kj4oZWxlbWVudCgpKS0+c3RhcnQoKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVtZW50KCkgJiYK KyAgICAgICAgICAgIChlbGVtZW50KCktPmhhc1RhZ05hbWUodWxUYWcpIHx8CisgICAgICAgICAg ICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAgICAgZWxlbWVu dCgpLT5oYXNUYWdOYW1lKGRpclRhZykpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IChy ZW5kZXJBcmVuYSgpKSBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgdmFsID0g MDsKKyAgICAgICAgfQorICAgIH0gCisgICAgCisgICAgaWYgKCFuZXdOb2RlKSB7CisgICAgICAg IG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJOb2RlKHRoaXMpOworICAgICAg ICB2YWwgPSAwOworICAgIH0KKyAgICAKKyAgICBuZXdOb2RlLT5zZXRWYWx1ZSh2YWwpOworICAg IGlmICh2aWV3KQorICAgICAgICBuZXdOb2RlLT5zZXRJc1Zpc3VhbCgpOworICAgIGlmIChjb3Vu dGVycykKKyAgICAgICAgbmV3Tm9kZS0+c2V0SGFzQ291bnRlcnMoKTsKKworICAgIGlmICghbV9j b3VudGVyTm9kZU1hcCkKKyAgICAgICAgbV9jb3VudGVyTm9kZU1hcCA9IG5ldyBIYXNoTWFwPFN0 cmluZywgQ291bnRlck5vZGUqPjsKKyAgICBtX2NvdW50ZXJOb2RlTWFwLT5zZXQoY291bnRlciwg bmV3Tm9kZSk7CisKKyAgICBpZiAoIWlzUm9vdCgpKSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBs YXN0ID0gMDsKKyAgICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnQgPSAwOworICAgICAgICBSZW5k ZXJPYmplY3QqIG4gPSAhaXNMaXN0SXRlbSgpICYmIHByZXZpb3VzU2libGluZygpID8gCisgICAg ICAgICAgICBwcmV2aW91c1NpYmxpbmcoKS0+cHJldmlvdXNTaWJsaW5nKCkgOiBwcmV2aW91c1Np YmxpbmcoKTsKKworICAgICAgICB3aGlsZSAobikgeworICAgICAgICAgICAgaWYgKG4tPmhhc0Nv dW50ZXIoY291bnRlcikpIHsKKyAgICAgICAgICAgICAgICBjdXJyZW50ID0gbi0+ZmluZENvdW50 ZXIoY291bnRlcik7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9IGVsc2UK KyAgICAgICAgICAgICAgICBuID0gbi0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAgICAgIH0KKyAg ICAgICAgCisgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAgICBDb3VudGVyTm9kZSogc2li bGluZyA9IGN1cnJlbnQ7CisgICAgICAgIGlmIChsYXN0ICYmICFuZXdOb2RlLT5pc1Jlc2V0KCkp IHsKKyAgICAgICAgICAgIC8vIEZvdW5kIHJlbmRlci1zaWJsaW5nLCBub3cgc2VhcmNoIGZvciBs YXRlciBjb3VudGVyLXNpYmxpbmdzIGFtb25nIGl0cyByZW5kZXItY2hpbGRyZW4KKyAgICAgICAg ICAgIG4gPSBuLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgIHdoaWxlIChuKSB7CisgICAgICAg ICAgICAgICAgaWYgKG4tPmhhc0NvdW50ZXIoY291bnRlcikpIHsKKyAgICAgICAgICAgICAgICAg ICAgY3VycmVudCA9IG4tPmZpbmRDb3VudGVyKGNvdW50ZXIpOworICAgICAgICAgICAgICAgICAg ICBpZiAobGFzdC0+cGFyZW50KCkgPT0gY3VycmVudC0+cGFyZW50KCkgfHwgc2libGluZyA9PSBj dXJyZW50LT5wYXJlbnQoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbGFzdCA9IGN1cnJl bnQ7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBJZiB0aGUgY3VycmVudCBjb3VudGVyIGlz IG5vdCB0aGUgbGFzdCwgc2VhcmNoIGRlZXBlcgorICAgICAgICAgICAgICAgICAgICAgICAgaWYg KGN1cnJlbnQtPm5leHRTaWJsaW5nKCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBu ID0gbi0+bGFzdENoaWxkKCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICBuID0gbi0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAgICAgICAgICB9Cisg ICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChzaWJsaW5nLT5pc1Jlc2V0KCkpIHsKKyAgICAg ICAgICAgICAgICBpZiAobGFzdCAhPSBzaWJsaW5nKQorICAgICAgICAgICAgICAgICAgICBzaWJs aW5nLT5pbnNlcnRBZnRlcihuZXdOb2RlLCBsYXN0KTsKKyAgICAgICAgICAgICAgICBlbHNlCisg ICAgICAgICAgICAgICAgICAgIHNpYmxpbmctPmluc2VydEFmdGVyKG5ld05vZGUsIDApOworICAg ICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgbGFzdC0+cGFyZW50KCktPmluc2VydEFm dGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgLy8gTm90 aGluZyBmb3VuZCBhbW9uZyBzaWJsaW5ncywgbGV0IG91ciBwYXJlbnQgc2VhcmNoCisgICAgICAg ICAgICBsYXN0ID0gcGFyZW50KCktPmZpbmRDb3VudGVyKGNvdW50ZXIsIGZhbHNlKTsKKyAgICAg ICAgICAgIGlmIChsYXN0LT5pc1Jlc2V0KCkpCisgICAgICAgICAgICAgICAgbGFzdC0+aW5zZXJ0 QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgbGFz dC0+cGFyZW50KCktPmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICB9CisgICAg fQorCisgICAgcmV0dXJuIG5ld05vZGU7Cit9CisKIFVDaGFyIFJlbmRlck9iamVjdDo6YmFja3Ns YXNoQXNDdXJyZW5jeVN5bWJvbCgpIGNvbnN0CiB7CiAgICAgaWYgKE5vZGUgKm5vZGUgPSBlbGVt ZW50KCkpCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5oCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5k ZXJPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAo QykgMjAwMCBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAw IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAw IERpcmsgTXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFs bGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykg MjAwMywgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICoKICAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK QEAgLTMxLDYgKzMyLDcgQEAKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlNj cm9sbEJhci5oIgogI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgorI2luY2x1ZGUgPHd0Zi9I YXNoTWFwLmg+CiAKIC8qCiAgKiAgVGhlIHBhaW50aW5nIG9mIGEgbGF5ZXIgb2NjdXJzIGluIHRo cmVlIGRpc3RpbmN0IHBoYXNlcy4gIEVhY2ggcGhhc2UgaW52b2x2ZXMKQEAgLTU0LDYgKzU2LDcg QEAKIGNsYXNzIEhUTUxBcmVhRWxlbWVudDsKIGNsYXNzIElubGluZUJveDsKIGNsYXNzIElubGlu ZUZsb3dCb3g7CitjbGFzcyBDb3VudGVyTm9kZTsKIGNsYXNzIFBvc2l0aW9uOwogY2xhc3MgUmVu ZGVyQXJlbmE7CiBjbGFzcyBSZW5kZXJCbG9jazsKQEAgLTE5Miw2ICsxOTUsMTAgQEAKICAgICB2 aXJ0dWFsIGludCBzdGF0aWNYKCkgY29uc3QgeyByZXR1cm4gMDsgfQogICAgIHZpcnR1YWwgaW50 IHN0YXRpY1koKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgCisgICAgYm9vbCBoYXNDb3VudGVy KGNvbnN0IFN0cmluZyYgY291bnRlcikgY29uc3Q7CisgICAgQ291bnRlck5vZGUqIGZpbmRDb3Vu dGVyKGNvbnN0IFN0cmluZyYgY291bnRlciwgYm9vbCB2aWV3ID0gZmFsc2UsIGJvb2wgY291bnRl cnMgPSBmYWxzZSk7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJlZSBtYW5pcHVs YXRpb24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAg ICB2aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTMsNiArMjYwLDcg QEAKICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlzQm9keSgpIGNvbnN0OwpA QCAtOTAyLDYgKzkxMCw4IEBACiAgICAgUmVuZGVyT2JqZWN0ICptX3BhcmVudDsKICAgICBSZW5k ZXJPYmplY3QgKm1fcHJldmlvdXM7CiAgICAgUmVuZGVyT2JqZWN0ICptX25leHQ7CisgICAgCisg ICAgSGFzaE1hcDxTdHJpbmcsIENvdW50ZXJOb2RlKj4qIG1fY291bnRlck5vZGVNYXA7CiAKICAg ICBtdXRhYmxlIHNob3J0IG1fdmVydGljYWxQb3NpdGlvbjsKIApJbmRleDogcmVuZGVyaW5nL1Jl bmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCShy ZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw1NiBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRl cmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2Fu ZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFw cGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVi bGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u LgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0 IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2 ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3 LCBVU0EuCisgKgorICovCisjaWZuZGVmIFJFTkRFUl9DT1VOVEVSX0hfCisjZGVmaW5lIFJFTkRF Ul9DT1VOVEVSX0hfCisKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K KworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0Cit7CitwdWJsaWM6Cisg ICAgUmVuZGVyQ291bnRlcihOb2RlKiwgQ291bnRlckRhdGEqKTsKKyAgICB2aXJ0dWFsIH5SZW5k ZXJDb3VudGVyKCkge307CisgICAgdmlydHVhbCB2b2lkIGRlc3Ryb3koKTsKKworICAgIHZpcnR1 YWwgY29uc3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0IHsgcmV0dXJuICJSZW5kZXJDb3VudGVy IjsgfQorCisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIHRydWU7 IH0KKyAgICB2aXJ0dWFsIHZvaWQgbGF5b3V0KCk7CisgICAgdmlydHVhbCB2b2lkIGNhbGNNaW5N YXhXaWR0aCgpOworCitwcm90ZWN0ZWQ6CisgICAgU3RyaW5nIHRvTGlzdFN0eWxlVHlwZShpbnQg dmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSk7CisKKyAgICBTdHJpbmcgbV9p dGVtOworICAgIENvdW50ZXJEYXRhKiBtX2NvdW50ZXI7CisgICAgQ291bnRlck5vZGUqIG1fY291 bnRlck5vZGU7Cit9OworCit9IC8vbmFtZXNwYWNlCisKKyNlbmRpZgpJbmRleDogcmVuZGVyaW5n L0NvdW50ZXJSZXNldE5vZGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvQ291bnRlclJlc2V0 Tm9kZS5oCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuaAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSw2NCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRo ZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0 IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxl IENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBN QSAwMjExMS0xMzA3LCBVU0EuCisgKgorKi8KKyNpZm5kZWYgQ291bnRlcl9SZXNldF9Ob2RlX2hf CisjZGVmaW5lIENvdW50ZXJfUmVzZXRfTm9kZV9oXworCisjaW5jbHVkZSAiQ291bnRlck5vZGUu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBUaGlzIGZpbGUgaW1wbGVtZW50cyBhIGNv dW50ZXItdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgYWxsIHBhcmVudHMgaW4gY291bnRl cnMoKSBsb29rdXAsCisvLyBhbmQgZm9yIHByb3BhZ2F0aW5nIGNvdW50LWNoYW5nZXMgd2hlbiBu b2RlcyBhcmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8vIFBsZWFzZSBub3RlIHRoYXQgb25seSBjb3Vu dGVyLXJlc2V0IGFuZCByb290IGNhbiBiZSBwYXJlbnRzIGhlcmUsIGFuZCB0aGF0IHJlbmRlci10 cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0IGNvdW50ZXItdHJlZSBzaWJsaW5ncworCisvLyBJbXBs ZW1lbnRhdGlvbiBvZiBjb3VudGVyLXJlc2V0IGFuZCByb290CitjbGFzcyBDb3VudGVyUmVzZXRO b2RlIDogcHVibGljIENvdW50ZXJOb2RlCit7CitwdWJsaWM6CisgICAgQ291bnRlclJlc2V0Tm9k ZShSZW5kZXJPYmplY3QqKTsKKyAgICB2aXJ0dWFsIH5Db3VudGVyUmVzZXROb2RlKCk7CisKKyAg ICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBmaXJzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gbV9maXJz dDsgfTsKKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBsYXN0Q2hpbGQoKSBjb25zdCB7IHJldHVy biBtX2xhc3Q7IH07CisgICAgdmlydHVhbCB2b2lkIGluc2VydEFmdGVyIChDb3VudGVyTm9kZSog bmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGlsZCk7CisgICAgdmlydHVhbCB2b2lkIHJlbW92 ZUNoaWxkIChDb3VudGVyTm9kZSopOworCisgICAgdmlydHVhbCBib29sIGlzUmVzZXQoKSB7IHJl dHVybiB0cnVlOyB9OworICAgIHZpcnR1YWwgdm9pZCByZWNvdW50KGJvb2wgZmlyc3QgPSBmYWxz ZSk7CisgICAgdmlydHVhbCB2b2lkIHNldFNlbGZEaXJ0eSgpOworICAgIHZpcnR1YWwgdm9pZCBz ZXRQYXJlbnREaXJ0eSgpOworCisgICAgdm9pZCB1cGRhdGVUb3RhbChpbnQgdmFsdWUpOworICAg IC8vIFRoZSBoaWdoZXN0IHZhbHVlIGFtb25nIGNoaWxkcmVuCisgICAgaW50IHRvdGFsKCkgY29u c3QgeyByZXR1cm4gbV90b3RhbDsgfTsKKworcHJvdGVjdGVkOgorICAgIGludCBtX3RvdGFsOwor ICAgIENvdW50ZXJOb2RlKiBtX2ZpcnN0OworICAgIENvdW50ZXJOb2RlKiBtX2xhc3Q7Cit9Owor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDb3VudGVyUmVzZXROb2RlX2gK SW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJp bmcvQ291bnRlckxpc3RJdGVtLmgJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvQ291bnRlckxp c3RJdGVtLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNDMgQEAKKy8qCisgKiBUaGlzIGZpbGUg aXMgcGFydCBvZiB0aGUgRE9NIGltcGxlbWVudGF0aW9uIGZvciBLREUuCisgKgorICogQ29weXJp Z2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAq IENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAq IG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0 aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFO WSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJD SEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhl IEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNl ZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAq IEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqLworIAorI2lmbmRlZiBDb3VudGVy TGlzdEl0ZW1fSAorI2RlZmluZSBDb3VudGVyTGlzdEl0ZW1fSAorCisjaW5jbHVkZSAiUmVuZGVy TGlzdEl0ZW0uaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBDb3VudGVyTGlzdEl0 ZW0gOiBwdWJsaWMgQ291bnRlck5vZGUKK3sKK3B1YmxpYzoKKyAgICBpbnQgY291bnQoKSBjb25z dDsKKworICAgIHZpcnR1YWwgdm9pZCByZWNvdW50KGJvb2wgZmlyc3QgPSBmYWxzZSk7CisgICAg dmlydHVhbCB2b2lkIHNldFNlbGZEaXJ0eSgpOworCit9OworCit9IC8vbmFtZXNwYWNlCisKKyNl bmRpZgpJbmRleDogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJl bmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9SZW5k ZXJDb3VudGVyLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNjYgQEAKKy8qKgorICogVGhp cyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoK KyAqIENvcHlyaWdodCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29s Zi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChh dCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlz IGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQg V0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBv ZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBs aWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0 ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworI2luY2x1 ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlJlbmRlckNvdW50ZXIuaCIKKworI2luY2x1ZGUgIkNv dW50ZXJOb2RlLmgiCisjaW5jbHVkZSAiQ291bnRlclJlc2V0Tm9kZS5oIgorI2luY2x1ZGUgIkRv Y3VtZW50LmgiCisjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCitSZW5kZXJDb3VudGVyOjpSZW5kZXJDb3VudGVyKE5vZGUqIG5vZGUsIENvdW50ZXJEYXRh KiBjb3VudGVyKQorICAgIDogUmVuZGVyVGV4dChub2RlLDApLCBtX2NvdW50ZXIoY291bnRlciks IG1fY291bnRlck5vZGUoMCkKK3sKK30KKwordm9pZCBSZW5kZXJDb3VudGVyOjpkZXN0cm95KCkK K3sKKyAgICBpZiAobV9jb3VudGVyTm9kZSkKKyAgICAgICAgbV9jb3VudGVyTm9kZS0+ZGVzdHJv eUNvdW50ZXJOb2RlKGRvY3VtZW50KCktPnJlbmRlckFyZW5hKCkpOworICAgIAorICAgIFJlbmRl clRleHQ6OmRlc3Ryb3koKTsKK30KKwordm9pZCBSZW5kZXJDb3VudGVyOjpsYXlvdXQoKQorewor ICAgIEFTU0VSVChuZWVkc0xheW91dCgpKTsKKworICAgIGlmICghbWluTWF4S25vd24oKSkKKyAg ICAgICAgY2FsY01pbk1heFdpZHRoKCk7CisKKyAgICBSZW5kZXJUZXh0OjpsYXlvdXQoKTsKK30K KworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworc3RhdGljIFN0cmluZyB0b1JvbWFu KGludCBudW1iZXIsIGJvb2wgdXBwZXIpCit7IAorICAgIFN0cmluZyByb21hbjsKKyAgICBjb25z dCBVQ2hhciBsZGlnaXRzW10gPSB7ICdpJywgJ3YnLCAneCcsICdsJywgJ2MnLCAnZCcsICdtJyB9 OworICAgIGNvbnN0IFVDaGFyIHVkaWdpdHNbXSA9IHsgJ0knLCAnVicsICdYJywgJ0wnLCAnQycs ICdEJywgJ00nIH07CisgICAgY29uc3QgVUNoYXIqIGRpZ2l0cyA9IHVwcGVyID8gdWRpZ2l0cyA6 IGxkaWdpdHM7CisgICAgVUNoYXIgYzsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8geworICAgICAg ICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkKKyAgICAg ICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKSB7CisgICAgICAgICAgICAg ICAgYyA9IFVDaGFyKGRpZ2l0c1tkXSk7CisgICAgICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KFN0 cmluZygmYywgMSksIDApOworICAgICAgICAgICAgfQorICAgICAgICBpZiAobnVtID49IDQgJiYg bnVtIDw9IDgpIHsKKyAgICAgICAgICAgIGMgPSBVQ2hhcihkaWdpdHNbZCArIDFdKTsKKyAgICAg ICAgICAgIHJvbWFuLmluc2VydChTdHJpbmcoJmMsIDEpLCAwKTsKKyAgICAgICAgfQorICAgICAg ICBpZiAobnVtID09IDkpIHsKKyAgICAgICAgICAgIGMgPSBVQ2hhcihkaWdpdHNbZCArIDJdKTsK KyAgICAgICAgICAgIHJvbWFuLmluc2VydChTdHJpbmcoJmMsIDEpLCAwKTsKKyAgICAgICAgfQor ICAgICAgICBpZiAobnVtICUgNSA9PSA0KSB7CisgICAgICAgICAgICBjID0gVUNoYXIoZGlnaXRz W2RdKTsKKyAgICAgICAgICAgIHJvbWFuLmluc2VydChTdHJpbmcoJmMsIDEpLCAwKTsKKyAgICAg ICAgfQorICAgICAgICBudW1iZXIgLz0gMTA7CisgICAgICAgIGQgKz0gMjsKKyAgICB9IHdoaWxl IChudW1iZXIpOworICAgIHJldHVybiByb21hbjsKK30KKworc3RhdGljIFN0cmluZyB0b0xldHRl clN0cmluZyhpbnQgbnVtYmVyLCBpbnQgbGV0dGVyQSkKK3sKKyAgICBVQ2hhciBjOworICAgIAor ICAgIGlmIChudW1iZXIgPCAyKSB7CisgICAgICAgIGMgPSBVQ2hhcihsZXR0ZXJBKTsKKyAgICAg ICAgcmV0dXJuIFN0cmluZygmYywgMSk7IC8vIG1hdGNoIFdpbklFIChBLikgbm90IEZpcmVGb3gg KDAuKQorICAgIH0KKworICAgIFN0cmluZyBsZXR0ZXJTdHJpbmc7CisgICAgd2hpbGUgKG51bWJl ciA+IDApIHsKKyAgICAgICAgaW50IG9uZXNEaWdpdCA9IChudW1iZXIgLSAxKSAlIDI2OworICAg ICAgICAgYyA9IFVDaGFyKGxldHRlckEgKyBvbmVzRGlnaXQpOworICAgICAgICBsZXR0ZXJTdHJp bmcgPSBTdHJpbmcoJmMsIDEpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25l c0RpZ2l0OworICAgICAgICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRl clN0cmluZzsKK30KKworc3RhdGljIFN0cmluZyB0b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAg IGlmIChudW1iZXIgPCAxKQorICAgICAgICByZXR1cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsK KyAgICAKKyAgICBzdGF0aWMgY29uc3QgVUNoYXIgdGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAx NTAwLCAxNTAyLCAxNTA0LCAxNTA1LCAxNTA2LCAxNTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBs ZXR0ZXI7CisgICAgVUNoYXIgYzsKKyAgICBpZiAobnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxl dHRlciA9IHRvSGVicmV3KG51bWJlciAvIDEwMDApICsgIiciOworICAgICAgICBudW1iZXIgPSBu dW1iZXIgJSAxMDAwOworICAgIH0KKyAgICBpbnQgZm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAw OworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZm91ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAg YyA9IFVDaGFyKDE1MTEgKyAzKTsKKyAgICAgICAgbGV0dGVyICs9IFN0cmluZygmYywgMSk7Cisg ICAgfQorICAgIG51bWJlciAlPSA0MDA7CisgICAgaWYgKG51bWJlciAvIDEwMCkgeworICAgICAg ICBjID0gVUNoYXIoMTUxMSArIChudW1iZXIgLyAxMDApIC0gMSk7CisgICAgICAgIGxldHRlciAr PSBTdHJpbmcoJmMsIDEpOworICAgIH0KKyAgICBudW1iZXIgJT0gMTAwOworICAgIGlmIChudW1i ZXIgPT0gMTUgfHwgbnVtYmVyID09IDE2KSB7CisgICAgICAgIGMgPSBVQ2hhcigxNDg3ICsgOSk7 CisgICAgICAgIGxldHRlciArPSBTdHJpbmcoJmMsIDEpOworICAgICAgICBjID0gVUNoYXIoMTQ4 NyArIG51bWJlciAtIDkpOworICAgICAgICBsZXR0ZXIgKz0gU3RyaW5nKCZjLCAxKTsKKyAgICB9 IGVsc2UgeworICAgICAgICBpbnQgdGVucyA9IG51bWJlciAvIDEwOworICAgICAgICBpZiAodGVu cykgeworICAgICAgICAgICAgYyA9IFVDaGFyKHRlbkRpZ2l0W3RlbnMgLSAxXSk7CisgICAgICAg ICAgICBsZXR0ZXIgKz0gU3RyaW5nKCZjLCAxKTsKKyAgICAgICAgfQorICAgICAgICBudW1iZXIg PSBudW1iZXIgJSAxMDsKKyAgICAgICAgaWYgKG51bWJlcikgeworICAgICAgICAgICAgYyA9IFVD aGFyKDE0ODcgKyBudW1iZXIpOworICAgICAgICAgICAgbGV0dGVyICs9IFN0cmluZygmYywgMSk7 CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIGxldHRlcjsKK30KKworU3RyaW5nIFJlbmRl ckNvdW50ZXI6OnRvTGlzdFN0eWxlVHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHls ZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJpbmcgaXRlbTsKKyAgICBVQ2hhciBjOworICAgIHN3aXRj aCh0eXBlKSB7CisgICAgICAgIGNhc2UgTE5PTkU6CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgLy8gR2x5cGhzOgorICAgICAgICBjYXNlIERJU0M6CisgICAgICAgICAgICBjID0gVUNoYXIo MHgyMDIyKTsKKyAgICAgICAgICAgIGl0ZW0gPSBTdHJpbmcoJmMsIDEpOworICAgICAgICAgICAg YnJlYWs7CisgICAgICAgIGNhc2UgQ0lSQ0xFOgorICAgICAgICAgICAgYyA9IFVDaGFyKDB4MjVl Nik7CisgICAgICAgICAgICBpdGVtID0gU3RyaW5nKCZjLCAxKTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICBjYXNlIFNRVUFSRToKKyAgICAgICAgICAgIGMgPSBVQ2hhcigweDI1YTApOwor ICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgY2FzZSBBUk1FTklBTjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoKKyAgICAgICAgY2Fz ZSBDSktfSURFT0dSQVBISUM6CisgICAgICAgIGNhc2UgSElSQUdBTkE6CisgICAgICAgIGNhc2Ug S0FUQUtBTkE6CisgICAgICAgIGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgS0FU QUtBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pFUk86CisgICAgICAg ICAgICAvLyAjIyMgdW5zdXBwb3J0ZWQsIHdlIHVzZSBkZWNpbWFsIGluc3RlYWQKKyAgICAgICAg Y2FzZSBMREVDSU1BTDoKKyAgICAgICAgICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgLy8gQWxnb3JpdG1pYzoKKyAgICAgICAgY2Fz ZSBMT1dFUl9ST01BTjoKKyAgICAgICAgICAgIGl0ZW0gPSB0b1JvbWFuKHZhbHVlLCBmYWxzZSk7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBVUFBFUl9ST01BTjoKKyAgICAgICAg ICAgIGl0ZW0gPSB0b1JvbWFuKHZhbHVlLCB0cnVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICBjYXNlIExPV0VSX0dSRUVLOiB7CisgICAgICAgICAgICBpbnQgbnVtYmVyID0gdmFsdWUg LSAxOworICAgICAgICAgICAgaW50IGwgPSAobnVtYmVyICUgMjQpOworICAgICAgICAgICAgaWYg KGwgPiAxNikKKyAgICAgICAgICAgICAgICBsKys7IC8vIFNraXAgR1JFRUsgU01BTEwgTEVUVEVS IEZJTkFMIFNJR01BCisgICAgICAgICAgICBjID0gVUNoYXIoOTQ1ICsgbCk7CisgICAgICAgICAg ICBpdGVtID0gU3RyaW5nKCZjLCAxKTsKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwg KG51bWJlciAvIDI0KTsgaSsrKQorICAgICAgICAgICAgICAgIGl0ZW0gKz0gIiciOworICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAgICAgY2FzZSBIRUJSRVc6CisgICAgICAgICAg ICBpdGVtID0gdG9IZWJyZXcodmFsdWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNh c2UgTE9XRVJfQUxQSEE6CisgICAgICAgIGNhc2UgTE9XRVJfTEFUSU46CisgICAgICAgICAgICBp dGVtID0gdG9MZXR0ZXJTdHJpbmcodmFsdWUsICdhJyk7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgY2FzZSBVUFBFUl9BTFBIQToKKyAgICAgICAgY2FzZSBVUFBFUl9MQVRJTjoKKyAgICAg ICAgICAgIGl0ZW0gPSB0b0xldHRlclN0cmluZyh2YWx1ZSwgJ0EnKTsKKyAgICAgICAgICAgIGJy ZWFrOworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgaXRlbSA9IFN0cmluZzo6bnVtYmVy KHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgIH0KKyAgICByZXR1cm4gaXRlbTsKK30K Kwordm9pZCBSZW5kZXJDb3VudGVyOjpjYWxjTWluTWF4V2lkdGgoKQoreworICAgIEFTU0VSVCgh bWluTWF4S25vd24oKSk7CisKKyAgICBpZiAoIXN0eWxlKCkpCisgICAgICAgIHJldHVybjsKKwor ICAgIGJvb2wgY291bnRlcnM7CisgICAgY291bnRlcnMgPSAhbV9jb3VudGVyLT5zZXBhcmF0b3Io KS5pc051bGwoKTsKKworICAgIGlmICghbV9jb3VudGVyTm9kZSAmJiBwYXJlbnQoKS0+cGFyZW50 KCkpCisgICAgICAgIG1fY291bnRlck5vZGUgPSBwYXJlbnQoKS0+cGFyZW50KCktPmZpbmRDb3Vu dGVyKG1fY291bnRlci0+aWRlbnRpZmllcigpLCB0cnVlLCBjb3VudGVycyk7CisKKyAgICBpbnQg dmFsdWUgPSBtX2NvdW50ZXJOb2RlLT5jb3VudCgpOworICAgIGlmIChtX2NvdW50ZXJOb2RlLT5p c1Jlc2V0KCkpCisgICAgICAgIHZhbHVlID0gbV9jb3VudGVyTm9kZS0+dmFsdWUoKTsKKyAgICAK KyAgICBpbnQgdG90YWwgPSB2YWx1ZTsKKyAgICBpZiAobV9jb3VudGVyTm9kZS0+cGFyZW50KCkp CisgICAgICAgIHRvdGFsID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCktPnRvdGFsKCk7CisgICAg CisgICAgbV9pdGVtID0gdG9MaXN0U3R5bGVUeXBlKHZhbHVlLCB0b3RhbCwgKEVMaXN0U3R5bGVU eXBlKW1fY291bnRlci0+bGlzdFN0eWxlKCkpOworCisgICAgaWYgKGNvdW50ZXJzKSB7CisgICAg ICAgIENvdW50ZXJOb2RlKiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCk7CisgICAg ICAgIGJvb2wgZmlyc3QgPSB0cnVlOworICAgICAgICB3aGlsZSAgKGNvdW50ZXItPnBhcmVudCgp ICYmIChmaXJzdCB8fCAhKGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3VudGVyLT5wYXJlbnQoKS0+ aXNSb290KCkpKSkgeworICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVyLT5jb3VudCgpID8gY291 bnRlci0+Y291bnQoKSA6IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNvdW50ZXItPnBhcmVudCgp LT50b3RhbCgpOworICAgICAgICAgICAgbV9pdGVtID0gdG9MaXN0U3R5bGVUeXBlKHZhbHVlLCB0 b3RhbCwgKEVMaXN0U3R5bGVUeXBlKW1fY291bnRlci0+bGlzdFN0eWxlKCkpIAorICAgICAgICAg ICAgICAgICsgbV9jb3VudGVyLT5zZXBhcmF0b3IoKSArIG1faXRlbTsKKyAgICAgICAgICAgIGNv dW50ZXIgPSBjb3VudGVyLT5wYXJlbnQoKTsKKyAgICAgICAgICAgIGZpcnN0ID0gZmFsc2U7Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICBzdHIgPSBuZXcgU3RyaW5nSW1wbCgoc3RhdGljX2Nhc3Q8 U3RyaW5nPihtX2l0ZW0pKS5jaGFyYWN0ZXJzKCksIG1faXRlbS5sZW5ndGgoKSk7CisgICAgCisg ICAgUmVuZGVyVGV4dDo6Y2FsY01pbk1heFdpZHRoKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdl YkNvcmUKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVu ZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVy Tm9kZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTMwIEBACisvKgorICogVGhpcyBmaWxl IGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENv cHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20p CisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29y CisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3Ry aWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICog TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5 OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAs CisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNv bmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisKKyNpbmNsdWRlICJDb3VudGVyUmVz ZXROb2RlLmgiCisjaW5jbHVkZSAiUmVuZGVyQXJlbmEuaCIKKyNpbmNsdWRlICJSZW5kZXJPYmpl Y3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDb3VudGVyTm9kZTo6Q291bnRlck5vZGUo UmVuZGVyT2JqZWN0ICpvKSAKK3sKKyAgICBtX2hhc0NvdW50ZXJzID0gZmFsc2U7CisgICAgbV9p c1Zpc3VhbCA9IGZhbHNlOworICAgIG1fdmFsdWUgPSAwOworICAgIG1fY291bnQgPSAwOworICAg IG1fcGFyZW50ID0gMDsKKyAgICBtX3ByZXZpb3VzID0gMDsKKyAgICBtX25leHQgPSAwOworICAg IG1fcmVuZGVyZXIgPSBvOworfQorCitDb3VudGVyTm9kZTo6fkNvdW50ZXJOb2RlKCkge307CisK K3ZvaWQqIENvdW50ZXJOb2RlOjpvcGVyYXRvciBuZXcoc2l6ZV90IHN6LCBSZW5kZXJBcmVuYSog cmVuZGVyQXJlbmEpIHRocm93KCkKK3sKKyAgICByZXR1cm4gcmVuZGVyQXJlbmEtPmFsbG9jYXRl KHN6KTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6ZGVzdHJveUNvdW50ZXJOb2RlKFJlbmRlckFy ZW5hKiBhcmVuYSkKK3sKKyAgICBhcmVuYURlbGV0ZShhcmVuYSk7Cit9CisKK3ZvaWQgQ291bnRl ck5vZGU6Om9wZXJhdG9yIGRlbGV0ZSh2b2lkKiBwdHIsIHNpemVfdCBzeikKK3sKKyAgICAvLyBT dGFzaCBzaXplIHdoZXJlIGRlc3Ryb3kgY2FuIGZpbmQgaXQuCisgICAgKihzaXplX3QgKilwdHIg PSBzejsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6YXJlbmFEZWxldGUoUmVuZGVyQXJlbmEqIGFy ZW5hKQoreworICAgIGRlbGV0ZSB0aGlzOworICAgIAorICAgIC8vIFJlY292ZXIgdGhlIHNpemUg bGVmdCB0aGVyZSBmb3IgdXMgYnkgb3BlcmF0b3IgZGVsZXRlIGFuZCBmcmVlIHRoZSBtZW1vcnku CisgICAgYXJlbmEtPmZyZWUoKihzaXplX3QgKil0aGlzLCB0aGlzKTsKK30KKwordm9pZCBDb3Vu dGVyTm9kZTo6aW5zZXJ0QWZ0ZXIoQ291bnRlck5vZGUqLCBDb3VudGVyTm9kZSopCit7CisgICAg QVNTRVJUKGZhbHNlKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRl ck5vZGUqKQoreworICAgIEFTU0VSVChmYWxzZSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJl bW92ZSgpCit7CisgICAgaWYgKG1fcGFyZW50KQorICAgICAgICBtX3BhcmVudC0+cmVtb3ZlQ2hp bGQodGhpcyk7CisgICAgZWxzZSB7CisgICAgICAgIEFTU0VSVChpc1Jlc2V0KCkpOworICAgICAg ICBBU1NFUlQoIWZpcnN0Q2hpbGQoKSk7CisgICAgICAgIEFTU0VSVCghbGFzdENoaWxkKCkpOwor ICAgIH0KK30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0SGFzQ291bnRlcnMoKQoreworICAgIG1f aGFzQ291bnRlcnMgPSB0cnVlOworICAgIGlmIChwYXJlbnQoKSkKKyAgICAgICAgcGFyZW50KCkt PnNldEhhc0NvdW50ZXJzKCk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlY291bnQoYm9vbCBm aXJzdCkKK3sKKyAgICBpbnQgb2xkX2NvdW50ID0gbV9jb3VudDsKKyAgICBpZiAobV9wcmV2aW91 cykKKyAgICAgICAgbV9jb3VudCA9IG1fcHJldmlvdXMtPmNvdW50KCkgKyBtX3ZhbHVlOworICAg IGVsc2UgeworICAgICAgICBhc3NlcnQobV9wYXJlbnQtPmZpcnN0Q2hpbGQoKSA9PSB0aGlzKTsK KyAgICAgICAgbV9jb3VudCA9IG1fcGFyZW50LT52YWx1ZSgpICsgbV92YWx1ZTsKKyAgICB9Cisg ICAgaWYgKG9sZF9jb3VudCAhPSBtX2NvdW50ICYmICFmaXJzdCkKKyAgICAgICAgc2V0U2VsZkRp cnR5KCk7CisgICAgaWYgKG9sZF9jb3VudCAhPSBtX2NvdW50IHx8IGZpcnN0KSB7CisgICAgICAg IGlmIChtX3BhcmVudCkKKyAgICAgICAgICAgIG1fcGFyZW50LT51cGRhdGVUb3RhbChtX2NvdW50 KTsKKyAgICAgICAgaWYgKG1fbmV4dCkKKyAgICAgICAgICAgIG1fbmV4dC0+cmVjb3VudCgpOwor ICAgIH0KK30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0U2VsZkRpcnR5KCkKK3sKKyAgICBpZiAo bV9yZW5kZXJlciAmJiBtX2lzVmlzdWFsKQorICAgICAgICBtX3JlbmRlcmVyLT5zZXROZWVkc0xh eW91dEFuZE1pbk1heFJlY2FsYygpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpzZXRQYXJlbnRE aXJ0eSgpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV9pc1Zpc3VhbCAmJiBtX2hhc0NvdW50 ZXJzKQorICAgICAgICBtX3JlbmRlcmVyLT5zZXROZWVkc0xheW91dEFuZE1pbk1heFJlY2FsYygp OworfQorCit9IC8vIG5hbWVzcGFjZQpJbmRleDogcmVuZGVyaW5nL1JlbmRlclN0eWxlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRlclN0eWxlLmgJKHJldmlzaW9uIDE2NTI4KQorKysg cmVuZGVyaW5nL1JlbmRlclN0eWxlLmgJKHdvcmtpbmcgY29weSkKQEAgLTM2LDExICszNiwxNCBA QAogICovCiAKICNpbmNsdWRlICJDb2xvci5oIgorI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVl LmgiCisjaW5jbHVkZSAiQ1NTVmFsdWVMaXN0LmgiCiAjaW5jbHVkZSAiRGF0YVJlZi5oIgogI2lu Y2x1ZGUgIkZvbnQuaCIKICNpbmNsdWRlICJHcmFwaGljc1R5cGVzLmgiCiAjaW5jbHVkZSAiSW50 UmVjdC5oIgogI2luY2x1ZGUgIkxlbmd0aC5oIgorI2luY2x1ZGUgIlBhaXIuaCIKICNpbmNsdWRl ICJTaGFyZWQuaCIKICNpbmNsdWRlICJUZXh0RGlyZWN0aW9uLmgiCiAjaW5jbHVkZSA8d3RmL1Zl Y3Rvci5oPgpAQCAtNTksOSArNjIsMTEgQEAKIAogdXNpbmcgc3RkOjptYXg7CiAKLWNsYXNzIENT U1N0eWxlU2VsZWN0b3I7CiBjbGFzcyBDYWNoZWRJbWFnZTsKIGNsYXNzIENhY2hlZFJlc291cmNl OworY2xhc3MgQ1NTU3R5bGVTZWxlY3RvcjsKK2NsYXNzIENTU1ZhbHVlTGlzdDsKK2NsYXNzIFBh aXI7CiBjbGFzcyBSZW5kZXJBcmVuYTsKIGNsYXNzIFNoYWRvd1ZhbHVlOwogY2xhc3MgU3RyaW5n SW1wbDsKQEAgLTQwNyw4ICs0MTIsOCBAQAogICAgICAgICByZXR1cm4gKCBjbGlwID09IG8uY2xp cCAmJgogICAgICAgICAgICAgICAgICBoYXNDbGlwID09IG8uaGFzQ2xpcCAmJgogICAgICAgICAg ICAgICAgICBjb2xzcGFuID09IG8uY29sc3BhbiAmJgotICAgICAgICAgICAgICAgICBjb3VudGVy X2luY3JlbWVudCA9PSBvLmNvdW50ZXJfaW5jcmVtZW50ICYmCi0gICAgICAgICAgICAgICAgIGNv dW50ZXJfcmVzZXQgPT0gby5jb3VudGVyX3Jlc2V0ICYmCisgICAgICAgICAgICAgICAgIGNvdW50 ZXJJbmNyZW1lbnQgPT0gby5jb3VudGVySW5jcmVtZW50ICYmCisgICAgICAgICAgICAgICAgIGNv dW50ZXJSZXNldCA9PSBvLmNvdW50ZXJSZXNldCAmJgogICAgICAgICAgICAgICAgICB0ZXh0RGVj b3JhdGlvbiA9PSBvLnRleHREZWNvcmF0aW9uKTsKICAgICB9CiAgICAgYm9vbCBvcGVyYXRvciE9 KCBjb25zdCBTdHlsZVZpc3VhbERhdGEgJm8gKSBjb25zdCB7CkBAIC00MjEsOCArNDI2LDggQEAK ICAgICAKICAgICBzaG9ydCBjb2xzcGFuOyAvLyBmb3IgaHRtbCwgbm90IGEgY3NzMiBhdHRyaWJ1 dGUKIAotICAgIHNob3J0IGNvdW50ZXJfaW5jcmVtZW50OyAvL29rLCBzbyB0aGVzZSBhcmUgbm90 IHZpc3VhbCBtb2RlIHNwZXNpZmljCi0gICAgc2hvcnQgY291bnRlcl9yZXNldDsgICAgIC8vY2Fu J3QgZ28gdG8gaW5oZXJpdGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAorICAgIHNo b3J0IGNvdW50ZXJJbmNyZW1lbnQ7IC8vb2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUg c3Blc2lmaWMKKyAgICBzaG9ydCBjb3VudGVyUmVzZXQ7ICAgICAvL2Nhbid0IGdvIHRvIGluaGVy aXRlZCwgc2luY2UgdGhlc2UgYXJlIG5vdCBpbmhlcml0ZWQKIAogfTsKIApAQCAtODcyLDYgKzg3 NywyMCBAQAogICAgIENPTlRFTlRfTk9ORSwgQ09OVEVOVF9PQkpFQ1QsIENPTlRFTlRfVEVYVCwg Q09OVEVOVF9DT1VOVEVSCiB9OwogCitzdHJ1Y3QgQ291bnRlckRhdGEgeworICAgIENvdW50ZXJE YXRhKCkge30KKyAgICBDb3VudGVyRGF0YShTdHJpbmcgaSwgaW50IGwsIFN0cmluZyBzZXApIDpp ZGVudChpKSwgbHMobCksIHMoc2VwKSB7fQorICAgIH5Db3VudGVyRGF0YSgpIHt9CisgICAgCisg ICAgU3RyaW5nIGlkZW50aWZpZXIoKSB7IHJldHVybiBpZGVudDsgfQorICAgIGludCBsaXN0U3R5 bGUoKSB7IHJldHVybiBsczsgfQorICAgIFN0cmluZyBzZXBhcmF0b3IoKSB7IHJldHVybiBzOyB9 CisKKyAgICBTdHJpbmcgaWRlbnQ7CisgICAgaW50IGxzOworICAgIFN0cmluZyBzOworfTsKKwog c3RydWN0IENvbnRlbnREYXRhIHsKICAgICBDb250ZW50RGF0YSgpIDpfY29udGVudFR5cGUoQ09O VEVOVF9OT05FKSwgX25leHRDb250ZW50KDApIHt9CiAgICAgfkNvbnRlbnREYXRhKCk7CkBAIC04 ODEsMTMgKzkwMCwxNCBAQAogCiAgICAgU3RyaW5nSW1wbCogY29udGVudFRleHQoKSB7IGlmIChj b250ZW50VHlwZSgpID09IENPTlRFTlRfVEVYVCkgcmV0dXJuIF9jb250ZW50LnRleHQ7IHJldHVy biAwOyB9CiAgICAgQ2FjaGVkUmVzb3VyY2UqIGNvbnRlbnRPYmplY3QoKSB7IGlmIChjb250ZW50 VHlwZSgpID09IENPTlRFTlRfT0JKRUNUKSByZXR1cm4gX2NvbnRlbnQub2JqZWN0OyByZXR1cm4g MDsgfQorICAgIENvdW50ZXJEYXRhKiBjb250ZW50Q291bnRlcigpIHsgaWYgKGNvbnRlbnRUeXBl KCkgPT0gQ09OVEVOVF9DT1VOVEVSKSByZXR1cm4gX2NvbnRlbnQuY291bnRlcjsgcmV0dXJuIDA7 IH0KICAgICAKICAgICBDb250ZW50VHlwZSBfY29udGVudFR5cGU7CiAKICAgICB1bmlvbiB7CiAg ICAgICAgIENhY2hlZFJlc291cmNlKiBvYmplY3Q7CiAgICAgICAgIFN0cmluZ0ltcGwqIHRleHQ7 Ci0gICAgICAgIC8vIGNvdW50ZXJzLi4uCisgICAgICAgIENvdW50ZXJEYXRhKiBjb3VudGVyOwog ICAgIH0gX2NvbnRlbnQgOwogCiAgICAgQ29udGVudERhdGEqIF9uZXh0Q29udGVudDsKQEAgLTEw NDUsNyArMTA2NSw5IEBACiAgICAgCiAgICAgLy8gYWRkZWQgdGhpcyBoZXJlLCBzbyB3ZSBjYW4g Z2V0IHJpZCBvZiB0aGUgdnB0ciBpbiB0aGlzIGNsYXNzLgogICAgIC8vIG1ha2VzIHVwIGZvciB0 aGUgc2FtZSBzaXplLgotICAgIENvbnRlbnREYXRhICpjb250ZW50OworICAgIENvbnRlbnREYXRh KiBjb250ZW50OworICAgIENTU1ZhbHVlTGlzdCogY291bnRlclJlc2V0TGlzdDsKKyAgICBDU1NW YWx1ZUxpc3QqIGNvdW50ZXJJbmNyZW1lbnRMaXN0OwogCiAgICAgdW5zaWduZWQgbV9wc2V1ZG9T dGF0ZSA6IDM7IC8vIFBzZXVkb1N0YXRlCiAgICAgYm9vbCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVT ZWxlY3RvcnMgOiAxOwpAQCAtMTI5NSw4ICsxMzE3LDggQEAKICAgICBFRW1wdHlDZWxsIGVtcHR5 Q2VsbHMoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFRW1wdHlDZWxsPihpbmhlcml0ZWRf ZmxhZ3MuX2VtcHR5X2NlbGxzKTsgfQogICAgIEVDYXB0aW9uU2lkZSBjYXB0aW9uU2lkZSgpIGNv bnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVDYXB0aW9uU2lkZT4oaW5oZXJpdGVkX2ZsYWdzLl9j YXB0aW9uX3NpZGUpOyB9CiAKLSAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkgY29uc3QgeyBy ZXR1cm4gdmlzdWFsLT5jb3VudGVyX2luY3JlbWVudDsgfQotICAgIHNob3J0IGNvdW50ZXJSZXNl dCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlcl9yZXNldDsgfQorICAgIHNob3J0IGNv dW50ZXJJbmNyZW1lbnQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQ7 IH0KKyAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNvdW50 ZXJSZXNldDsgfQogCiAgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0eWxlVHlwZSgpIGNvbnN0IHsg cmV0dXJuIHN0YXRpY19jYXN0PEVMaXN0U3R5bGVUeXBlPihpbmhlcml0ZWRfZmxhZ3MuX2xpc3Rf c3R5bGVfdHlwZSk7IH0KICAgICBDYWNoZWRJbWFnZSAqbGlzdFN0eWxlSW1hZ2UoKSBjb25zdCB7 IHJldHVybiBpbmhlcml0ZWQtPnN0eWxlX2ltYWdlOyB9CkBAIC0xNTAxLDggKzE1MjMsOCBAQAog ICAgIHZvaWQgc2V0Q2FwdGlvblNpZGUoRUNhcHRpb25TaWRlIHYpIHsgaW5oZXJpdGVkX2ZsYWdz Ll9jYXB0aW9uX3NpZGUgPSB2OyB9CiAKIAotICAgIHZvaWQgc2V0Q291bnRlckluY3JlbWVudChz aG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVyX2luY3JlbWVudCx2KSB9Ci0gICAgdm9p ZCBzZXRDb3VudGVyUmVzZXQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1YWwsY291bnRlcl9yZXNl dCx2KSB9CisgICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50KHNob3J0IHYpIHsgIFNFVF9WQVIo dmlzdWFsLGNvdW50ZXJJbmNyZW1lbnQsdikgfQorICAgIHZvaWQgc2V0Q291bnRlclJlc2V0KHNo b3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJSZXNldCx2KSB9CiAKICAgICB2b2lkIHNl dExpc3RTdHlsZVR5cGUoRUxpc3RTdHlsZVR5cGUgdikgeyBpbmhlcml0ZWRfZmxhZ3MuX2xpc3Rf c3R5bGVfdHlwZSA9IHY7IH0KICAgICB2b2lkIHNldExpc3RTdHlsZUltYWdlKENhY2hlZEltYWdl ICp2KSB7ICBTRVRfVkFSKGluaGVyaXRlZCxzdHlsZV9pbWFnZSx2KX0KQEAgLTE1OTcsNyArMTYx OSwyMCBAQAogICAgIGJvb2wgY29udGVudERhdGFFcXVpdmFsZW50KGNvbnN0IFJlbmRlclN0eWxl ICpvdGhlclN0eWxlKSBjb25zdDsKICAgICB2b2lkIHNldENvbnRlbnQoU3RyaW5nSW1wbCogcywg Ym9vbCBhZGQgPSBmYWxzZSk7CiAgICAgdm9pZCBzZXRDb250ZW50KENhY2hlZFJlc291cmNlKiBv LCBib29sIGFkZCA9IGZhbHNlKTsKKyAgICB2b2lkIHNldENvbnRlbnQoQ291bnRlckRhdGEqIGMs IGJvb2wgYWRkID0gZmFsc2UpOwogCisgICAgYm9vbCBjb3VudGVyRGF0YUVxdWl2YWxlbnQoUmVu ZGVyU3R5bGUqIG90aGVyU3R5bGUpOworICAgIHZvaWQgc2V0Q291bnRlclJlc2V0KENTU1ZhbHVl TGlzdCogdik7CisgICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50KENTU1ZhbHVlTGlzdCogdik7 CisgICAgdm9pZCBhZGRDb3VudGVyUmVzZXQoQ1NTUHJpbWl0aXZlVmFsdWUqIGMpOworICAgIHZv aWQgYWRkQ291bnRlckluY3JlbWVudChDU1NQcmltaXRpdmVWYWx1ZSogYyk7CisgICAgYm9vbCBo YXNDb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJiBjKSBjb25zdDsKKyAgICBib29sIGhhc0NvdW50 ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjKSBjb25zdDsKKyAgICBzaG9ydCBjb3VudGVyUmVz ZXQoY29uc3QgU3RyaW5nJiBjKSBjb25zdDsKKyAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KGNv bnN0IFN0cmluZyYgYykgY29uc3Q7CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVyUmVzZXRWYWx1 ZUxpc3QoKSB7IHJldHVybiBjb3VudGVyUmVzZXRMaXN0OyB9CisgICAgQ1NTVmFsdWVMaXN0KiBj b3VudGVySW5jcmVtZW50VmFsdWVMaXN0KCkgeyByZXR1cm4gY291bnRlckluY3JlbWVudExpc3Q7 IH0KKwogICAgIGJvb2wgaW5oZXJpdGVkTm90RXF1YWwoIFJlbmRlclN0eWxlICpvdGhlciApIGNv bnN0OwogCiAgICAgLy8gVGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0d28gc3R5bGVzLiAgVGhlIGZv bGxvd2luZyB2YWx1ZXMgYXJlIHVzZWQ6CkluZGV4OiByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9k ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZp c2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDE1NCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJl bmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2 IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJDb3Vu dGVyUmVzZXROb2RlLmgiCisKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitDb3VudGVyUmVzZXROb2RlOjpDb3VudGVyUmVzZXROb2RlKFJlbmRlck9i amVjdCogbykgOiBDb3VudGVyTm9kZShvKSwgbV90b3RhbCgwKSwgbV9maXJzdCgwKSwgbV9sYXN0 KDApIHt9CitDb3VudGVyUmVzZXROb2RlOjp+Q291bnRlclJlc2V0Tm9kZSgpIHt9OworCit2b2lk IENvdW50ZXJSZXNldE5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291 bnRlck5vZGUqIHJlZkNoaWxkKQoreworICAgIEFTU0VSVChuZXdDaGlsZCk7CisgICAgQVNTRVJU KCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+cGFyZW50KCkgPT0gdGhpcyk7CisKKyAgICBuZXdDaGls ZC0+bV9wYXJlbnQgPSB0aGlzOworICAgIG5ld0NoaWxkLT5tX3ByZXZpb3VzID0gcmVmQ2hpbGQ7 CisKKyAgICBpZiAocmVmQ2hpbGQpIHsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dCA9IHJlZkNo aWxkLT5tX25leHQ7CisgICAgICAgIHJlZkNoaWxkLT5tX25leHQgPSBuZXdDaGlsZDsKKyAgICB9 IGVsc2UgeworICAgICAgICBuZXdDaGlsZC0+bV9uZXh0ID0gbV9maXJzdDsKKyAgICAgICAgbV9m aXJzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIGlmIChuZXdDaGlsZC0+bV9uZXh0KSB7Cisg ICAgICAgIGFzc2VydChuZXdDaGlsZC0+bV9uZXh0LT5tX3ByZXZpb3VzID09IHJlZkNoaWxkKTsK KyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9IG5ld0NoaWxkOworICAgIH0g ZWxzZSB7CisgICAgICAgIGFzc2VydCAobV9sYXN0ID09IHJlZkNoaWxkKTsKKyAgICAgICAgbV9s YXN0ID0gbmV3Q2hpbGQ7CisgICAgfQorCisgICAgbmV3Q2hpbGQtPnJlY291bnQodHJ1ZSk7Cit9 CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9sZENo aWxkKQoreworICAgIEFTU0VSVChvbGRDaGlsZCk7CisKKyAgICBDb3VudGVyTm9kZSogbmV4dCA9 IG9sZENoaWxkLT5tX25leHQ7CisgICAgQ291bnRlck5vZGUqIHByZXYgPSBvbGRDaGlsZC0+bV9w cmV2aW91czsKKworICAgIGlmIChvbGRDaGlsZC0+Zmlyc3RDaGlsZCgpKSB7CisgICAgICAgIENv dW50ZXJOb2RlKiBmaXJzdCA9IG9sZENoaWxkLT5maXJzdENoaWxkKCk7CisgICAgICAgIENvdW50 ZXJOb2RlKiBsYXN0ID0gb2xkQ2hpbGQtPmxhc3RDaGlsZCgpOworICAgICAgICBpZiAocHJldikg eworICAgICAgICAgICAgcHJldi0+bV9uZXh0ID0gZmlyc3Q7CisgICAgICAgICAgICBmaXJzdC0+ bV9wcmV2aW91cyA9IHByZXY7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgbV9maXJzdCA9 IGZpcnN0OworCisgICAgICAgIGlmIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3ByZXZp b3VzID0gbGFzdDsKKyAgICAgICAgICAgIGxhc3QtPm1fbmV4dCA9IG5leHQ7CisgICAgICAgIH0g ZWxzZQorICAgICAgICAgICAgbV9sYXN0ID0gbGFzdDsKKworICAgICAgICBuZXh0ID0gZmlyc3Q7 CisgICAgICAgIHdoaWxlIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3BhcmVudCA9IHRo aXM7CisgICAgICAgICAgICBuZXh0ID0gbmV4dC0+bV9uZXh0OworICAgICAgICB9CisKKyAgICAg ICAgZmlyc3QtPnJlY291bnQodHJ1ZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgaWYgKHByZXYp IAorICAgICAgICAgICAgcHJldi0+bV9uZXh0ID0gbmV4dDsKKyAgICAgICAgZWxzZSB7CisgICAg ICAgICAgICBhc3NlcnQgKCBtX2ZpcnN0ID09IG9sZENoaWxkICk7CisgICAgICAgICAgICBtX2Zp cnN0ID0gbmV4dDsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgaWYgKG5leHQpCisgICAg ICAgICAgICBuZXh0LT5tX3ByZXZpb3VzID0gcHJldjsKKyAgICAgICAgZWxzZSB7CisgICAgICAg ICAgICBhc3NlcnQgKCBtX2xhc3QgPT0gb2xkQ2hpbGQgKTsKKyAgICAgICAgICAgIG1fbGFzdCA9 IHByZXY7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQorICAgICAgICAg ICAgbmV4dC0+cmVjb3VudCgpOworICAgIH0KKworCisgICAgb2xkQ2hpbGQtPm1fbmV4dCA9IDA7 CisgICAgb2xkQ2hpbGQtPm1fcHJldmlvdXMgPSAwOworICAgIG9sZENoaWxkLT5tX3BhcmVudCA9 IDA7Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6cmVjb3VudChib29sIGZpcnN0KQorewor ICAgIGludCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3ByZXZpb3VzKQorICAgICAg ICBtX2NvdW50ID0gbV9wcmV2aW91cy0+Y291bnQoKTsKKyAgICBlbHNlIGlmIChtX3BhcmVudCkK KyAgICAgICAgbV9jb3VudCA9IG1fcGFyZW50LT52YWx1ZSgpOworICAgIGVsc2UKKyAgICAgICAg bV9jb3VudCA9IDA7CisKKyAgICB1cGRhdGVUb3RhbChtX3ZhbHVlKTsKKyAgICBpZiAoIWZpcnN0 KQorICAgICAgICBzZXRTZWxmRGlydHkoKTsKKyAgICBpZiAobV9uZXh0ICYmIChmaXJzdCB8fCBt X2NvdW50ICE9IG9sZF9jb3VudCkpCisgICAgICAgIG1fbmV4dC0+cmVjb3VudCgpOworfQorCit2 b2lkIENvdW50ZXJSZXNldE5vZGU6OnNldFNlbGZEaXJ0eSgpCit7CisgICAgc2V0UGFyZW50RGly dHkoKTsKK30KKwordm9pZCBDb3VudGVyUmVzZXROb2RlOjpzZXRQYXJlbnREaXJ0eSgpCit7Cisg ICAgaWYgKGhhc0NvdW50ZXJzKCkpIHsKKyAgICAgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV9pc1Zp c3VhbCkKKyAgICAgICAgICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVj YWxjKCk7CisgICAgICAgIENvdW50ZXJOb2RlKiBuID0gZmlyc3RDaGlsZCgpOworICAgICAgICBm b3IoOyBuOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkKKyAgICAgICAgICAgIG4tPnNldFBhcmVudERp cnR5KCk7CisgICAgfQorfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnVwZGF0ZVRvdGFsKGlu dCB2YWx1ZSkKK3sKKyAgICBpZiAodmFsdWUgPiBtX3RvdGFsKQorICAgICAgICBtX3RvdGFsID0g dmFsdWU7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyQ29udGFp bmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ29udGFpbmVyLmNwcAkocmV2 aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyQ29udGFpbmVyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChr bm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2 aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVlbGxl ckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAo a2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwMywgMjAwNCwgMjAwNSwgMjAw NiBBcHBsZSBDb21wdXRlciwgSW5jLgogICogQ29weXJpZ2h0IChDKSAyMDA2IEFuZHJldyBXZWxs aW5ndG9uIChwcm90b25Ad2lyZXRhcHBlZC5uZXQpCiAgKgpAQCAtMjgsNiArMjksNyBAQAogI2lu Y2x1ZGUgIlJlbmRlckNvbnRhaW5lci5oIgogCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKKyNp bmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNp bmNsdWRlICJSZW5kZXJUYWJsZS5oIgogI2luY2x1ZGUgIlJlbmRlclRleHRGcmFnbWVudC5oIgpA QCAtMjk3LDYgKzI5OSw4IEBACiAgICAgICAgIC8vIGlubGluZSBzaG91bGQgYmUgbXV0YXRlZCB0 byBJTkxJTkUuCiAgICAgICAgIHBzZXVkby0+c2V0RGlzcGxheShJTkxJTkUpOwogICAgIAorICAg IFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsK KyAgICBzdHlsZS0+aW5oZXJpdEZyb20ocHNldWRvKTsKICAgICBpZiAob2xkQ29udGVudFByZXNl bnQpIHsKICAgICAgICAgaWYgKGNoaWxkICYmIGNoaWxkLT5zdHlsZSgpLT5zdHlsZVR5cGUoKSA9 PSB0eXBlKSB7CiAgICAgICAgICAgICAvLyBXZSBoYXZlIGdlbmVyYXRlZCBjb250ZW50IHByZXNl bnQgc3RpbGwuICBXZSB3YW50IHRvIHdhbGsgdGhpcyBjb250ZW50IGFuZCB1cGRhdGUgb3VyCkBA IC0zMDksMTMgKzMxMywxMCBAQAogICAgICAgICAgICAgICAgIGlmIChnZW5DaGlsZC0+aXNUZXh0 KCkpCiAgICAgICAgICAgICAgICAgICAgIC8vIEdlbmVyYXRlZCB0ZXh0IGNvbnRlbnQgaXMgYSBj aGlsZCB3aG9zZSBzdHlsZSBhbHNvIG5lZWRzIHRvIGJlIHNldCB0byB0aGUgcHNldWRvCiAgICAg ICAgICAgICAgICAgICAgIC8vIHN0eWxlLgotICAgICAgICAgICAgICAgICAgICBnZW5DaGlsZC0+ c2V0U3R5bGUocHNldWRvKTsKLSAgICAgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgICAg ICAgICAgZ2VuQ2hpbGQtPnNldFN0eWxlKHN0eWxlKTsKKyAgICAgICAgICAgICAgICBlbHNlCiAg ICAgICAgICAgICAgICAgICAgIC8vIEltYWdlcyBnZXQgYW4gZW1wdHkgc3R5bGUgdGhhdCBpbmhl cml0cyBmcm9tIHRoZSBwc2V1ZG8uCi0gICAgICAgICAgICAgICAgICAgIFJlbmRlclN0eWxlKiBz dHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsKLSAgICAgICAgICAgICAg ICAgICAgc3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgICAgICAgICAgICAgICAgIGdl bkNoaWxkLT5zZXRTdHlsZShzdHlsZSk7Ci0gICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg fQogICAgICAgICB9CiAgICAgICAgIHJldHVybjsgLy8gV2UndmUgdXBkYXRlZCB0aGUgZ2VuZXJh dGVkIGNvbnRlbnQuIFRoYXQncyBhbGwgd2UgbmVlZGVkIHRvIGRvLgpAQCAtMzM0LDIwICszMzUs MjAgQEAKICAgICAgICAgaWYgKCFwc2V1ZG9Db250YWluZXIpCiAgICAgICAgICAgICBwc2V1ZG9D b250YWluZXIgPSBSZW5kZXJGbG93OjpjcmVhdGVBbm9ueW1vdXNGbG93KGRvY3VtZW50KCksIHBz ZXVkbyk7IC8qIGFub255bW91cyBib3ggKi8KICAgICAgICAgCi0gICAgICAgIGlmIChjb250ZW50 RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpCi0gICAgICAgIHsKKyAgICAgICAg aWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRFTlRfVEVYVCkgewogICAgICAg ICAgICAgUmVuZGVyVGV4dCogdCA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyVGV4dEZyYWdt ZW50KGRvY3VtZW50KCkgLyphbm9ueW1vdXMgb2JqZWN0ICovLCBjb250ZW50RGF0YS0+Y29udGVu dFRleHQoKSk7Ci0gICAgICAgICAgICB0LT5zZXRTdHlsZShwc2V1ZG8pOworICAgICAgICAgICAg dC0+c2V0U3R5bGUoc3R5bGUpOwogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRDaGls ZCh0KTsKLSAgICAgICAgfQotICAgICAgICBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5 cGUoKSA9PSBDT05URU5UX09CSkVDVCkKLSAgICAgICAgeworICAgICAgICB9IGVsc2UgaWYgKGNv bnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRFTlRfT0JKRUNUKSB7CiAgICAgICAgICAg ICBSZW5kZXJJbWFnZSogaW1nID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJJbWFnZShkb2N1 bWVudCgpKTsgLyogQW5vbnltb3VzIG9iamVjdCAqLwotICAgICAgICAgICAgUmVuZGVyU3R5bGUq IHN0eWxlID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJTdHlsZSgpOwotICAgICAgICAgICAg c3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgICAgICAgICBpbWctPnNldFN0eWxlKHN0 eWxlKTsKICAgICAgICAgICAgIGltZy0+c2V0Q29udGVudE9iamVjdChjb250ZW50RGF0YS0+Y29u dGVudE9iamVjdCgpKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQoaW1n KTsKKyAgICAgICAgfSBlbHNlIGlmIChjb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID09IENPTlRF TlRfQ09VTlRFUikgeworICAgICAgICAgICAgUmVuZGVyQ291bnRlciogYyA9IG5ldyAocmVuZGVy QXJlbmEoKSkgUmVuZGVyQ291bnRlcihlbGVtZW50KCksIGNvbnRlbnREYXRhLT5jb250ZW50Q291 bnRlcigpKTsKKyAgICAgICAgICAgIGMtPnNldElzQW5vbnltb3VzKHRydWUpOworICAgICAgICAg ICAgYy0+c2V0U3R5bGUoc3R5bGUpOworICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRD aGlsZChjKTsKICAgICAgICAgfQogICAgIH0KIApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJOb2Rl LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgJKHJldmlzaW9uIDApCisr KyByZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5NyBAQAor LyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9y IEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChr ZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJ bmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBs YWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorKi8K KyNpZm5kZWYgQ291bnRlcl9Ob2RlX2hfCisjZGVmaW5lIENvdW50ZXJfTm9kZV9oXworCisjaW5j bHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQ291 bnRlclJlc2V0Tm9kZTsKK2NsYXNzIFJlbmRlckFyZW5hOworCisvLyBUaGlzIGZpbGUgaW1wbGVt ZW50cyBhIGNvdW50ZXItdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZpbmRpbmcgYWxsIHBhcmVudHMg aW4gY291bnRlcnMoKSBsb29rdXAsCisvLyBhbmQgZm9yIHByb3BhZ2F0aW5nIGNvdW50LWNoYW5n ZXMgd2hlbiBub2RlcyBhcmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8vIFBsZWFzZSBub3RlIHRoYXQg b25seSBjb3VudGVyLXJlc2V0IGFuZCByb290IGNhbiBiZSBwYXJlbnRzIGhlcmUsIGFuZCB0aGF0 IHJlbmRlci10cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0IGNvdW50ZXItdHJlZSBzaWJsaW5ncwor CisvLyBJbXBsZW1lbnRhdGlvbiBvZiBjb3VudGVyLWluY3JlbWVudCBhbmQgY291bnRlci1jb250 ZW50CitjbGFzcyBDb3VudGVyTm9kZSB7CitwdWJsaWM6CisgICAgQ291bnRlck5vZGUoUmVuZGVy T2JqZWN0Kik7CisgICAgdmlydHVhbCB+Q291bnRlck5vZGUoKTsKKyAgICB2aXJ0dWFsIHZvaWQg ZGVzdHJveUNvdW50ZXJOb2RlKFJlbmRlckFyZW5hKik7CisgICAgCisgICAgLy8gT3ZlcmxvYWRl ZCBuZXcgb3BlcmF0b3IuICBEZXJpdmVkIGNsYXNzZXMgbXVzdCBvdmVycmlkZSBvcGVyYXRvciBu ZXcKKyAgICAvLyBpbiBvcmRlciB0byBhbGxvY2F0ZSBvdXQgb2YgdGhlIFJlbmRlckFyZW5hLgor ICAgIHZvaWQqIG9wZXJhdG9yIG5ldyhzaXplX3Qgc3osIFJlbmRlckFyZW5hKiByZW5kZXJBcmVu YSkgdGhyb3coKTsKKyAgICAKKyAgICAvLyBPdmVycmlkZGVuIHRvIHByZXZlbnQgdGhlIG5vcm1h bCBkZWxldGUgZnJvbSBiZWluZyBjYWxsZWQuCisgICAgdm9pZCBvcGVyYXRvciBkZWxldGUodm9p ZCogcHRyLCBzaXplX3Qgc3opOworCisgICAgQ291bnRlclJlc2V0Tm9kZSogcGFyZW50KCkgY29u c3QgeyByZXR1cm4gbV9wYXJlbnQ7IH0KKyAgICBDb3VudGVyTm9kZSogcHJldmlvdXNTaWJsaW5n KCkgY29uc3QgeyByZXR1cm4gbV9wcmV2aW91czsgfQorICAgIENvdW50ZXJOb2RlKiBuZXh0U2li bGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dDsgfQorICAgIHZpcnR1YWwgQ291bnRlck5vZGUq IGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCBDb3VudGVyTm9k ZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgdm9pZCBpbnNl cnRBZnRlciAoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSogcmVmQ2hpbGQpOwor ICAgIHZpcnR1YWwgdm9pZCByZW1vdmVDaGlsZCAoQ291bnRlck5vZGUqIG9sZENoaWxkKTsKKyAg ICAvLyBDb252ZW5pZW50IHNlbGYtcmVmZXJpbmcgdmVyc2lvbiBvZiB0aGUgYWJvdmUKKyAgICB2 b2lkIHJlbW92ZSgpOworCisgICAgaW50IHZhbHVlKCkgY29uc3QgeyByZXR1cm4gbV92YWx1ZTsg fQorICAgIHZvaWQgc2V0VmFsdWUoc2hvcnQgdikgeyBtX3ZhbHVlID0gdjsgfQorICAgIGludCBj b3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fY291bnQ7IH0KKworICAgIHZpcnR1YWwgYm9vbCBpc1Jl c2V0KCkgeyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcmVjb3VudChib29sIGZp cnN0ID0gZmFsc2UpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKyAgICB2aXJ0 dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKworICAgIGJvb2wgaGFzQ291bnRlcnMoKSBjb25z dCB7IHJldHVybiBtX2hhc0NvdW50ZXJzOyB9OworICAgIGJvb2wgaXNWaXN1YWwoKSBjb25zdCB7 IHJldHVybiBtX2lzVmlzdWFsOyB9OworICAgIHZvaWQgc2V0SGFzQ291bnRlcnMoKTsKKyAgICB2 b2lkIHNldElzVmlzdWFsKCkgeyBtX2lzVmlzdWFsID0gdHJ1ZTsgfTsKKyAgICBib29sIGlzUm9v dCgpIHsgcmV0dXJuIG1fcmVuZGVyZXIgJiYgbV9yZW5kZXJlci0+aXNSb290KCk7IH07CisKKyAg ICB2b2lkIHNldFJlbmRlcmVyKFJlbmRlck9iamVjdCogbykgeyBtX3JlbmRlcmVyID0gbzsgfTsK KyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKCkgY29uc3QgeyByZXR1cm4gbV9yZW5kZXJlcjsg fTsKKworICAgIGZyaWVuZCBjbGFzcyBDb3VudGVyUmVzZXROb2RlOworcHJvdGVjdGVkOgorICAg IGJvb2wgbV9oYXNDb3VudGVycyA6IDE7CisgICAgYm9vbCBtX2lzVmlzdWFsIDogMTsKKyAgICBz aG9ydCBtX3ZhbHVlOworICAgIHNob3J0IG1fY291bnQ7CisgICAgQ291bnRlclJlc2V0Tm9kZSog bV9wYXJlbnQ7CisgICAgQ291bnRlck5vZGUqIG1fcHJldmlvdXM7CisgICAgQ291bnRlck5vZGUq IG1fbmV4dDsKKyAgICBSZW5kZXJPYmplY3QqIG1fcmVuZGVyZXI7CisgICAgCitwcml2YXRlOgor ICAgIHZvaWQgYXJlbmFEZWxldGUoUmVuZGVyQXJlbmEqIGFyZW5hKTsKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENvdW50ZXJOb2RlX2gKSW5kZXg6IHJlbmRlcmlu Zy9SZW5kZXJTdHlsZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNw cAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC05MCw4ICs5MCw4IEBACiAgICAgOiBoYXNDbGlwKGZhbHNlKQogICAgICwgdGV4 dERlY29yYXRpb24oUmVuZGVyU3R5bGU6OmluaXRpYWxUZXh0RGVjb3JhdGlvbigpKQogICAgICwg Y29sc3BhbigxKQotICAgICwgY291bnRlcl9pbmNyZW1lbnQoMCkKLSAgICAsIGNvdW50ZXJfcmVz ZXQoMCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnQoMCkKKyAgICAsIGNvdW50ZXJSZXNldCgwKQog ewogfQogCkBAIC0xMDUsOCArMTA1LDggQEAKICAgICAsIGhhc0NsaXAoby5oYXNDbGlwKQogICAg ICwgdGV4dERlY29yYXRpb24oby50ZXh0RGVjb3JhdGlvbikKICAgICAsIGNvbHNwYW4oby5jb2xz cGFuKQotICAgICwgY291bnRlcl9pbmNyZW1lbnQoby5jb3VudGVyX2luY3JlbWVudCkKLSAgICAs IGNvdW50ZXJfcmVzZXQoby5jb3VudGVyX3Jlc2V0KQorICAgICwgY291bnRlckluY3JlbWVudChv LmNvdW50ZXJJbmNyZW1lbnQpCisgICAgLCBjb3VudGVyUmVzZXQoby5jb3VudGVyUmVzZXQpCiB7 CiB9CiAKQEAgLTU3OCw2ICs1NzgsMTEgQEAKICAgICB9CiAgICAgZGVsZXRlIGNvbnRlbnQ7CiAg ICAgCisgICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIGNvdW50ZXJSZXNldExpc3Qt PmRlcmVmKCk7CisgICAgaWYgKGNvdW50ZXJJbmNyZW1lbnRMaXN0KQorICAgICAgICBjb3VudGVy SW5jcmVtZW50TGlzdC0+ZGVyZWYoKTsKKyAgICAKICAgICBkZWxldGUgdGhpczsKICAgICAKICAg ICAvLyBSZWNvdmVyIHRoZSBzaXplIGxlZnQgdGhlcmUgZm9yIHVzIGJ5IG9wZXJhdG9yIGRlbGV0 ZSBhbmQgZnJlZSB0aGUgbWVtb3J5LgpAQCAtNjAxLDYgKzYwNiw4IEBACiAgICAgLCBpbmhlcml0 ZWQoZGVmYXVsdFN0eWxlLT5pbmhlcml0ZWQpCiAgICAgLCBwc2V1ZG9TdHlsZSgwKQogICAgICwg Y29udGVudCgwKQorICAgICwgY291bnRlclJlc2V0TGlzdCgwKQorICAgICwgY291bnRlckluY3Jl bWVudExpc3QoMCkKICAgICAsIG1fcHNldWRvU3RhdGUoUHNldWRvVW5rbm93bikKICAgICAsIG1f YWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyhmYWxzZSkKICAgICAsIG1fdW5pcXVlKGZhbHNl KQpAQCAtNjE1LDYgKzYyMiw4IEBACiBSZW5kZXJTdHlsZTo6UmVuZGVyU3R5bGUoYm9vbCkKICAg ICA6IHBzZXVkb1N0eWxlKDApCiAgICAgLCBjb250ZW50KDApCisgICAgLCBjb3VudGVyUmVzZXRM aXN0KDApCisgICAgLCBjb3VudGVySW5jcmVtZW50TGlzdCgwKQogICAgICwgbV9wc2V1ZG9TdGF0 ZShQc2V1ZG9Vbmtub3duKQogICAgICwgbV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzKGZh bHNlKQogICAgICwgbV91bmlxdWUoZmFsc2UpCkBAIC02NDksNiArNjU4LDggQEAKICAgICAsIGlu aGVyaXRlZChvLmluaGVyaXRlZCkKICAgICAsIHBzZXVkb1N0eWxlKDApCiAgICAgLCBjb250ZW50 KG8uY29udGVudCkKKyAgICAsIGNvdW50ZXJSZXNldExpc3Qoby5jb3VudGVyUmVzZXRMaXN0KQor ICAgICwgY291bnRlckluY3JlbWVudExpc3Qoby5jb3VudGVySW5jcmVtZW50TGlzdCkKICAgICAs IG1fcHNldWRvU3RhdGUoby5tX3BzZXVkb1N0YXRlKQogICAgICwgbV9hZmZlY3RlZEJ5QXR0cmli dXRlU2VsZWN0b3JzKGZhbHNlKQogICAgICwgbV91bmlxdWUoZmFsc2UpCkBAIC04MzgsOCArODQ5 LDggQEAKICAgICAgICAgIShub25pbmhlcml0ZWRfZmxhZ3MuX2Zsb2F0aW5nID09IG90aGVyLT5u b25pbmhlcml0ZWRfZmxhZ3MuX2Zsb2F0aW5nKSB8fAogICAgICAgICAhKG5vbmluaGVyaXRlZF9m bGFncy5fb3JpZ2luYWxEaXNwbGF5ID09IG90aGVyLT5ub25pbmhlcml0ZWRfZmxhZ3MuX29yaWdp bmFsRGlzcGxheSkgfHwKICAgICAgICAgIHZpc3VhbC0+Y29sc3BhbiAhPSBvdGhlci0+dmlzdWFs LT5jb2xzcGFuIHx8Ci0gICAgICAgICB2aXN1YWwtPmNvdW50ZXJfaW5jcmVtZW50ICE9IG90aGVy LT52aXN1YWwtPmNvdW50ZXJfaW5jcmVtZW50IHx8Ci0gICAgICAgICB2aXN1YWwtPmNvdW50ZXJf cmVzZXQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlcl9yZXNldCB8fAorICAgICAgICAgdmlzdWFs LT5jb3VudGVySW5jcmVtZW50ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQgfHwK KyAgICAgICAgIHZpc3VhbC0+Y291bnRlclJlc2V0ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJS ZXNldCB8fAogICAgICAgICAgY3NzM05vbkluaGVyaXRlZERhdGEtPnRleHRPdmVyZmxvdyAhPSBv dGhlci0+Y3NzM05vbkluaGVyaXRlZERhdGEtPnRleHRPdmVyZmxvdyB8fAogICAgICAgICAgKGNz czNJbmhlcml0ZWREYXRhLT50ZXh0U2VjdXJpdHkgIT0gb3RoZXItPmNzczNJbmhlcml0ZWREYXRh LT50ZXh0U2VjdXJpdHkpKQogICAgICAgICByZXR1cm4gTGF5b3V0OwpAQCAtMTA4MCw2ICsxMDkx LDMyIEBACiAgICAgbmV3Q29udGVudERhdGEtPl9jb250ZW50VHlwZSA9IENPTlRFTlRfVEVYVDsK IH0KIAordm9pZCBSZW5kZXJTdHlsZTo6c2V0Q29udGVudChDb3VudGVyRGF0YSogYywgYm9vbCBh ZGQpCit7CisgICAgaWYgKCFjKQorICAgICAgICByZXR1cm47CisKKyAgICBDb250ZW50RGF0YSog bGFzdENvbnRlbnQgPSBjb250ZW50OworICAgIHdoaWxlIChsYXN0Q29udGVudCAmJiBsYXN0Q29u dGVudC0+X25leHRDb250ZW50KQorICAgICAgICBsYXN0Q29udGVudCA9IGxhc3RDb250ZW50LT5f bmV4dENvbnRlbnQ7CisKKyAgICBib29sIHJldXNlQ29udGVudCA9ICFhZGQ7CisgICAgQ29udGVu dERhdGEqIG5ld0NvbnRlbnREYXRhID0gMDsKKyAgICBpZiAocmV1c2VDb250ZW50ICYmIGNvbnRl bnQpIHsKKyAgICAgICAgY29udGVudC0+Y2xlYXJDb250ZW50KCk7CisgICAgICAgIG5ld0NvbnRl bnREYXRhID0gY29udGVudDsKKyAgICB9IGVsc2UKKyAgICAgICAgbmV3Q29udGVudERhdGEgPSBu ZXcgQ29udGVudERhdGE7CisKKyAgICBpZiAobGFzdENvbnRlbnQgJiYgIXJldXNlQ29udGVudCkK KyAgICAgICAgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVudCA9IG5ld0NvbnRlbnREYXRhOworICAg IGVsc2UKKyAgICAgICAgY29udGVudCA9IG5ld0NvbnRlbnREYXRhOworCisgICAgbmV3Q29udGVu dERhdGEtPl9jb250ZW50LmNvdW50ZXIgPSBjOworICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVu dFR5cGUgPSBDT05URU5UX0NPVU5URVI7Cit9CisKIENvbnRlbnREYXRhOjp+Q29udGVudERhdGEo KQogewogICAgIGNsZWFyQ29udGVudCgpOwpAQCAtMTA5OCw2ICsxMTM1LDEwIEBACiAgICAgICAg IGNhc2UgQ09OVEVOVF9URVhUOgogICAgICAgICAgICAgX2NvbnRlbnQudGV4dC0+ZGVyZWYoKTsK ICAgICAgICAgICAgIF9jb250ZW50LnRleHQgPSAwOworICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIGNhc2UgQ09OVEVOVF9DT1VOVEVSOgorICAgICAgICAgICAgX2NvbnRlbnQuY291bnRlciA9 IDA7CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAgIDsK ICAgICB9CkBAIC0xMTg1LDYgKzEyMjYsMTIyIEBACiAgICAgcmV0dXJuIHggPT0gby54ICYmIHkg PT0gby55ICYmIGJsdXIgPT0gby5ibHVyICYmIGNvbG9yID09IG8uY29sb3I7CiB9CiAKK2Jvb2wg UmVuZGVyU3R5bGU6OmNvdW50ZXJEYXRhRXF1aXZhbGVudChSZW5kZXJTdHlsZSogb3RoZXJTdHls ZSkKK3sKKyAgICAvLyAjIyMgU2hvdWxkIHdlIGNvbXBhcmUgY29udGVudD8KKyAgICByZXR1cm4g Y291bnRlclJlc2V0TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVyUmVzZXRMaXN0ICYmCisgICAg ICAgICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0ID09IG90aGVyU3R5bGUtPmNvdW50ZXJJbmNyZW1l bnRMaXN0OworfQorCitzdGF0aWMgYm9vbCBoYXNDb3VudGVyKGNvbnN0IFN0cmluZyYgYywgQ1NT VmFsdWVMaXN0KiBsKQoreworICAgIGludCBsZW4gPSBsLT5sZW5ndGgoKTsKKyAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmlt aXRpdmVWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7 CisgICAgICAgIFBhaXIqIHBhaXIgPSBwcmltaXRpdmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7Cisg ICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBjb3VudGVyTmFtZSA9IHN0YXRpY19jYXN0PENTU1By aW1pdGl2ZVZhbHVlKj4ocGFpci0+Zmlyc3QoKSk7CisgICAgICAgIEFTU0VSVChwYWlyICYmIGNv dW50ZXJOYW1lKTsKKyAgICAgICAgaWYgKGNvdW50ZXJOYW1lLT5nZXRTdHJpbmdWYWx1ZSgpID09 IGMpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJuIGZhbHNlOwor fQorCitib29sIFJlbmRlclN0eWxlOjpoYXNDb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJiBjKSBj b25zdAoreworICAgIGlmIChjb3VudGVyUmVzZXRMaXN0KQorICAgICAgICByZXR1cm4gaGFzQ291 bnRlcihjLCBjb3VudGVyUmVzZXRMaXN0KTsKKyAgICBlbHNlCisgICAgICAgIHJldHVybiBmYWxz ZTsKK30KKworYm9vbCBSZW5kZXJTdHlsZTo6aGFzQ291bnRlckluY3JlbWVudChjb25zdCBTdHJp bmcmIGMpIGNvbnN0Cit7CisgICAgaWYgKGNvdW50ZXJJbmNyZW1lbnRMaXN0KQorICAgICAgICBy ZXR1cm4gaGFzQ291bnRlcihjLCBjb3VudGVySW5jcmVtZW50TGlzdCk7CisgICAgZWxzZQorICAg ICAgICByZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyBzaG9ydCByZWFkQ291bnRlcihjb25zdCBT dHJpbmcmIGMsIENTU1ZhbHVlTGlzdCogbCwgYm9vbCBpc1Jlc2V0KQoreworICAgIGludCBsZW4g PSBsLT5sZW5ndGgoKTsKKyAgICBzaG9ydCB0b3RhbCA9IDA7CisgICAgCisgICAgZm9yIChpbnQg aSA9IDA7IGkgPCBsZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0 aXZlVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0oaSkpOwor ICAgICAgICBQYWlyKiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgpOworICAg ICAgICBDU1NQcmltaXRpdmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0aWNfY2FzdDxDU1NQcmlt aXRpdmVWYWx1ZSo+KHBhaXItPmZpcnN0KCkpOworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSog Y291bnRlclZhbHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWlyLT5zZWNv bmQoKSk7CisgICAgICAgIEFTU0VSVChwYWlyICYmIGNvdW50ZXJOYW1lICYmIGNvdW50ZXJWYWx1 ZSk7CisKKyAgICAgICAgaWYgKGNvdW50ZXJOYW1lLT5nZXRTdHJpbmdWYWx1ZSgpID09IGMpIHsK KyAgICAgICAgICAgIHRvdGFsICs9IChzaG9ydCljb3VudGVyVmFsdWUtPmdldEZsb2F0VmFsdWUo KTsKKyAgICAgICAgICAgIGlmIChpc1Jlc2V0KQorICAgICAgICAgICAgICAgIHJldHVybiB0b3Rh bDsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gdG90YWw7Cit9CisKK3Nob3J0 IFJlbmRlclN0eWxlOjpjb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJiBjKSBjb25zdAoreworICAg IGlmIChjb3VudGVyUmVzZXRMaXN0KQorICAgICAgICByZXR1cm4gcmVhZENvdW50ZXIoYywgY291 bnRlclJlc2V0TGlzdCwgdHJ1ZSk7CisgICAgZWxzZQorICAgICAgICByZXR1cm4gMDsKK30KKwor c2hvcnQgUmVuZGVyU3R5bGU6OmNvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjKSBjb25z dAoreworICAgIGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIHJlYWRD b3VudGVyKGMsIGNvdW50ZXJJbmNyZW1lbnRMaXN0LCBmYWxzZSk7CisgICAgZWxzZQorICAgICAg ICByZXR1cm4gMDsKK30KKwordm9pZCBSZW5kZXJTdHlsZTo6c2V0Q291bnRlclJlc2V0KENTU1Zh bHVlTGlzdCogbCkKK3sKKyAgICBDU1NWYWx1ZUxpc3QqIHQgPSBjb3VudGVyUmVzZXRMaXN0Owor ICAgIGNvdW50ZXJSZXNldExpc3QgPSBsOworICAgIGlmIChsKQorICAgICAgICBsLT5yZWYoKTsK KyAgICBpZiAodCkKKyAgICAgICAgdC0+ZGVyZWYoKTsKK30KKwordm9pZCBSZW5kZXJTdHlsZTo6 c2V0Q291bnRlckluY3JlbWVudChDU1NWYWx1ZUxpc3QqIGwpCit7CisgICAgQ1NTVmFsdWVMaXN0 KiB0ID0gY291bnRlckluY3JlbWVudExpc3Q7CisgICAgY291bnRlckluY3JlbWVudExpc3QgPSBs OworICAgIAorICAgIGlmIChsKSAKKyAgICAgICAgbC0+cmVmKCk7CisgICAgaWYgKHQpCisgICAg ICAgIHQtPmRlcmVmKCk7Cit9CisKK3ZvaWQgUmVuZGVyU3R5bGU6OmFkZENvdW50ZXJSZXNldChD U1NQcmltaXRpdmVWYWx1ZSogYykKK3sKKyAgICBpZiAoIWNvdW50ZXJSZXNldExpc3QpIHsKKyAg ICAgICAgY291bnRlclJlc2V0TGlzdCA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgICAgIGNvdW50 ZXJSZXNldExpc3QtPnJlZigpOworICAgIH0KKworICAgIGNvdW50ZXJSZXNldExpc3QtPmFwcGVu ZChjKTsKK30KKwordm9pZCBSZW5kZXJTdHlsZTo6YWRkQ291bnRlckluY3JlbWVudChDU1NQcmlt aXRpdmVWYWx1ZSogYykKK3sKKyAgICBpZiAoIWNvdW50ZXJJbmNyZW1lbnRMaXN0KSB7CisgICAg ICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0ID0gbmV3IENTU1ZhbHVlTGlzdDsKKyAgICAgICAgY291 bnRlckluY3JlbWVudExpc3QtPnJlZigpOworICAgIH0KKworICAgIGNvdW50ZXJJbmNyZW1lbnRM aXN0LT5hcHBlbmQoYyk7Cit9CisKIGNvbnN0IFZlY3RvcjxTdHlsZURhc2hib2FyZFJlZ2lvbj4m IFJlbmRlclN0eWxlOjppbml0aWFsRGFzaGJvYXJkUmVnaW9ucygpCiB7IAogICAgIHN0YXRpYyBW ZWN0b3I8U3R5bGVEYXNoYm9hcmRSZWdpb24+IGVtcHR5TGlzdDsKSW5kZXg6IFdlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDE2NTI4KQorKysgV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC04NTcsNiArODU3LDEzIEBACiAJCTkzNUZC Q0YyMDlCQTE0M0IwMEUyMzBCMSAvKiBFeGNlcHRpb25Db2RlLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzVGQkNGMTA5QkExNDNCMDBFMjMwQjEgLyog RXhjZXB0aW9uQ29kZS5oICovOyB9OwogCQk5MzZCNDI0RTA5QTQzNkNEMDBCQUE4MjAgLyogU1ZH Q1NTUGFyc2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IEE4QzBGNkY2MDg5NzAxRjEwMEJBNTExNCAvKiBTVkdDU1NQYXJzZXIuY3BwICovOyB9Owog CQk5MzZCREQxRDBBMDMxQUVCMDA0REY0QUIgLyogR3JhcGhpY3NDb250ZXh0Q0cuY3BwIGluIFNv dXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM2QkREMUMwQTAzMUFF QjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAqLzsgfTsKKwkJOTM3MUJCNzEwQUM0 N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJD b3VudGVyLmggKi87IH07CisJCTkzNzFCQjczMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3Vu dGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkz NzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLzsgfTsKKwkJOTM3 MUJCNzUwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc0MEFDNDdGQzgwMENENEE3 QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi87IH07CisJCTkzNzFCQjc3MEFDNDdGRDAwMENENEE3 QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc2MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXRO b2RlLmNwcCAqLzsgfTsKKwkJOTM3MUJCNzkwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2Rl LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3 ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLzsgfTsKKwkJOTM3MUJCN0IwQUM0 N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjdBMEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVy Tm9kZS5jcHAgKi87IH07CisJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlz dEl0ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkz NzFCQjdDMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0uaCAqLzsgfTsKIAkJOTM3 MjU2MTAwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIgaW4gRnJhbWV3b3JrcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcyNTYwRjBBNjE1NjQyMDBCMDUz QjkgLyogbGlic3FsaXRlMy5keWxpYiAqLzsgfTsKIAkJOTM4MEY0NzMwOUExMUFCNDAwMUZEQjM0 IC8qIFdpZGdldC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzgwRjQ3MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCAqLzsgfTsKIAkJOTM4 MEY0NzQwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4MEY0NzIwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdl dC5oICovOyB9OwpAQCAtMzE4Myw2ICszMTkwLDEzIEBACiAJCTkzNUZCQ0YxMDlCQTE0M0IwMEUy MzBCMSAvKiBFeGNlcHRpb25Db2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9 IEV4Y2VwdGlvbkNvZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM2QkREMUMw QTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEdyYXBoaWNzQ29udGV4dENHLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJOTM2REQwM0EwOUNFQUMyNzAwNTZBRThDIC8qIFJhbmdlLmlkbCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHRleHQ7IHBhdGggPSBSYW5nZS5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CisJCTkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJDb3VudGVyLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3Vu dGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW5kZXJDb3Vu dGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzQwQUM0N0ZDODAw Q0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IENvdW50ZXJSZXNldE5vZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJ OTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvdW50ZXJSZXNldE5vZGUuY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291 bnRlck5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAz MDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJOb2Rl Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjdBMEFDNDdGREUwMENENEE3 QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRo ID0gQ291bnRlck5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3 QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBDb3VudGVyTGlzdEl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJOTM3MjU2MEYwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSAiY29tcGlsZWQu bWFjaC1vLmR5bGliIjsgbmFtZSA9IGxpYnNxbGl0ZTMuZHlsaWI7IHBhdGggPSAvdXNyL2xpYi9s aWJzcWxpdGUzLmR5bGliOyBzb3VyY2VUcmVlID0gIjxhYnNvbHV0ZT4iOyB9OwogCQk5MzgwRjQ3 MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBXaWRnZXQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5 MzgwRjQ3MjA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBXaWRnZXQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTcx NjYsNiArNzE4MCwxMSBAQAogCQkJCUJDRUE0ODE0MDk3RDkzMDIwMDk0QzlFNCAvKiBiaWRpLmgg Ki8sCiAJCQkJQkNFQTQ4MTUwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFrX2xpbmVzLmNwcCAqLywK IAkJCQlCQ0VBNDgxNjA5N0Q5MzAyMDA5NEM5RTQgLyogYnJlYWtfbGluZXMuaCAqLywKKwkJCQk5 MzcxQkI3QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi8sCisJCQkJOTM3 MUJCN0EwQUM0N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCAqLywKKwkJCQk5MzcxQkI3 ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLywKKwkJCQk5MzcxQkI3NjBBQzQ3 RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgKi8sCisJCQkJOTM3MUJCNzQwQUM0 N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLywKIAkJCQlCQ0VBNDgxNzA5N0Q5 MzAyMDA5NEM5RTQgLyogRGF0YVJlZi5oICovLAogCQkJCUFCRTdCNTIxMEE0ODlGODMwMDMxODgx QyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmNwcCAqLywKIAkJCQlBQkU3QjUyMjBBNDg5Rjgz MDAzMTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5oICovLApAQCAtNzIwMiw2ICs3MjIx LDggQEAKIAkJCQlCQ0VBNDgyOTA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyVmlldy5oICovLAog CQkJCUJDRUE0ODJDMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250YWluZXIuY3BwICovLAog CQkJCUJDRUE0ODJEMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250YWluZXIuaCAqLywKKwkJ CQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi8sCisJCQkJ OTM3MUJCNzAwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCAqLywKIAkJCQlBOEVB NzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuY3BwICovLAogCQkJCUE4RUE3 M0IwMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNldC5oICovLAogCQkJCTA2NkM3NzJF MEFCNjAzRkQwMDIzOENDNCAvKiBSZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5jcHAgKi8sCkBAIC04 NDUwLDYgKzg0NzEsMTAgQEAKIAkJCQlBODQxNUY5RTBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZh c01hc2tlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg0MTVGQTAwQUMxMEM1RDAwRjdEMERGIC8q IEtDYW52YXNNYXJrZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCUJDM0ZDQUE5MEFDM0RCNTgwMEJB NTRBRCAvKiBQbGF0Zm9ybVNjcm9sbEJhci5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM3MUJCNzEw QUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTkz NzFCQjc1MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggaW4gSGVhZGVycyAq LywKKwkJCQk5MzcxQkI3OTBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCBpbiBIZWFk ZXJzICovLAorCQkJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0u aCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nl c3NpbmcgPSAwOwogCQl9OwpAQCAtOTUzOCw2ICs5NTYzLDkgQEAKIAkJCQlBODQxNUY5RjBBQzEw QzVEMDBGN0QwREYgLyogS0NhbnZhc01hc2tlci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlBODQx NUZBMTBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc01hcmtlci5jcHAgaW4gU291cmNlcyAqLywK IAkJCQlBODQxNUZBMjBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc0ZpbHRlcnMuY3BwIGluIFNv dXJjZXMgKi8sCisJCQkJOTM3MUJCNzMwQUM0N0ZCODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIu Y3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCNzcwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50 ZXJSZXNldE5vZGUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCN0IwQUM0N0ZERTAwQ0Q0 QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlG b3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogY3NzL0NTU0NvbXB1 dGVkU3R5bGVEZWNsYXJhdGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU0NvbXB1dGVkU3R5 bGVEZWNsYXJhdGlvbi5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL0NTU0NvbXB1dGVkU3R5 bGVEZWNsYXJhdGlvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYwMiwxMSArNjAyLDkgQEAKICAg ICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50ZWQKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBD U1NfUFJPUF9DT1VOVEVSX0lOQ1JFTUVOVDoKLSAgICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50 ZWQKLSAgICAgICAgYnJlYWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+Y291bnRlckluY3JlbWVu dFZhbHVlTGlzdCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNFVDoKLSAgICAgICAg Ly8gRklYTUU6IHVuaW1wbGVtZW50ZWQKLSAgICAgICAgYnJlYWs7CisgICAgICAgIHJldHVybiBz dHlsZS0+Y291bnRlclJlc2V0VmFsdWVMaXN0KCk7CiAgICAgY2FzZSBDU1NfUFJPUF9DVVJTT1I6 CiAgICAgICAgIGlmIChzdHlsZS0+Y3Vyc29ySW1hZ2UoKSkKICAgICAgICAgICAgIHJldHVybiBu ZXcgQ1NTUHJpbWl0aXZlVmFsdWUoc3R5bGUtPmN1cnNvckltYWdlKCktPnVybCgpLCBDU1NQcmlt aXRpdmVWYWx1ZTo6Q1NTX1VSSSk7CkluZGV4OiBjc3MvY3NzcGFyc2VyLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gY3NzL2Nzc3BhcnNlci5oCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9jc3NwYXJzZXIuaAko d29ya2luZyBjb3B5KQpAQCAtMTQ2LDExICsxNDYsMTMgQEAKIAogICAgICAgICBib29sIHBhcnNl U2hhcGUoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRhbnQpOwogICAgICAgICBib29sIHBhcnNlRm9u dChib29sIGltcG9ydGFudCk7CisgICAgICAgIGJvb2wgcGFyc2VDb3VudGVyKGludCBwcm9wSWQs IGJvb2wgaW5jcmVtZW50LCBib29sIGltcG9ydGFudCk7CiAgICAgICAgIENTU1ZhbHVlTGlzdCog cGFyc2VGb250RmFtaWx5KCk7CiAgICAgICAgIGJvb2wgcGFyc2VDb2xvclBhcmFtZXRlcnMoVmFs dWUqLCBpbnQqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBib29sIHBh cnNlSFNMUGFyYW1ldGVycyhWYWx1ZSosIGRvdWJsZSogY29sb3JWYWx1ZXMsIGJvb2wgcGFyc2VB bHBoYSk7CiAgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yKCk7CiAgICAgICAg IENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yRnJvbVZhbHVlKFZhbHVlKik7CisgICAgICAg IENTU1ZhbHVlKiBwYXJzZUNvdW50ZXJDb250ZW50KFZhbHVlTGlzdCAqYXJncywgYm9vbCBjb3Vu dGVycyk7CiAgICAgICAgIAogI2lmZGVmIFNWR19TVVBQT1JUCiAgICAgICAgIGJvb2wgcGFyc2VT VkdWYWx1ZShpbnQgcHJvcElkLCBib29sIGltcG9ydGFudCk7CkluZGV4OiBjc3MvY3Nzc3R5bGVz ZWxlY3Rvci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCShyZXZp c2lvbiAxNjUyOCkKKysrIGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQpA QCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNzc3N0eWxlc2VsZWN0b3IuaCIKIAogI2luY2x1 ZGUgIkNTU0JvcmRlckltYWdlVmFsdWUuaCIKKyNpbmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVk ZSAiQ1NTSW1hZ2VWYWx1ZS5oIgogI2luY2x1ZGUgIkNTU0ltcG9ydFJ1bGUuaCIKICNpbmNsdWRl ICJDU1NNZWRpYVJ1bGUuaCIKQEAgLTMxNDgsNyArMzE0OSw5IEBACiAKICAgICAgICAgZm9yIChp bnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewogICAgICAgICAgICAgQ1NTVmFsdWUgKml0ZW0gPSBs aXN0LT5pdGVtKGkpOwotICAgICAgICAgICAgaWYgKCFpdGVtLT5pc1ByaW1pdGl2ZVZhbHVlKCkp IGNvbnRpbnVlOworICAgICAgICAgICAgaWYgKCFpdGVtLT5pc1ByaW1pdGl2ZVZhbHVlKCkpCisg ICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAKICAgICAgICAgICAgIENTU1By aW1pdGl2ZVZhbHVlICp2YWwgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGl0ZW0p OwogICAgICAgICAgICAgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRpdmVWYWx1 ZTo6Q1NTX1NUUklORykKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudCh2YWwtPmdl dFN0cmluZ1ZhbHVlKCkuaW1wbCgpLCBpICE9IDApOwpAQCAtMzE2MiwyMCArMzE2NSwzNCBAQAog ICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KGVsZW1lbnQtPmdldEF0dHJpYnV0ZShh dHRyKS5pbXBsKCksIGkgIT0gMCk7CiAgICAgICAgICAgICAgICAgLy8gcmVnaXN0ZXIgdGhlIGZh Y3QgdGhhdCB0aGUgYXR0cmlidXRlIHZhbHVlIGFmZmVjdHMgdGhlIHN0eWxlCiAgICAgICAgICAg ICAgICAgbV9zZWxlY3RvckF0dHJzLmFkZChhdHRyLmxvY2FsTmFtZSgpLmltcGwoKSk7Ci0gICAg ICAgICAgICB9Ci0gICAgICAgICAgICBlbHNlIGlmICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NT UHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKKyAgICAgICAgICAgIH0gZWxzZSBpZiAodmFsLT5w cmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfVVJJKSB7CiAgICAgICAgICAg ICAgICAgQ1NTSW1hZ2VWYWx1ZSAqaW1hZ2UgPSBzdGF0aWNfY2FzdDxDU1NJbWFnZVZhbHVlKj4o dmFsKTsKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudChpbWFnZS0+aW1hZ2UoZWxl bWVudC0+ZG9jdW1lbnQoKS0+ZG9jTG9hZGVyKCkpLCBpICE9IDApOwotICAgICAgICAgICAgfQor ICAgICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZl VmFsdWU6OkNTU19DT1VOVEVSKSB7CisgICAgICAgICAgICAgICAgQ291bnRlciogY291bnRlclZh bHVlID0gdmFsLT5nZXRDb3VudGVyVmFsdWUoKTsKKyAgICAgICAgICAgICAgICBDb3VudGVyRGF0 YSBjb3VudGVyID0gIENvdW50ZXJEYXRhKGNvdW50ZXJWYWx1ZS0+aWRlbnRpZmllcigpLAorICAg ICAgICAgICAgICAgICAgICBjb3VudGVyVmFsdWUtPmxpc3RTdHlsZU51bWJlcigpLCBjb3VudGVy VmFsdWUtPnNlcGFyYXRvcigpKTsKKyAgICAgICAgICAgICAgICBDb3VudGVyRGF0YSogYyA9IG5l dyBDb3VudGVyRGF0YShjb3VudGVyKTsKKyAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVu dChjLCBpICE9IDApOworICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgICAgYnJlYWs7CiAg ICAgfQogCi0gICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX0lOQ1JFTUVOVDoKLSAgICAgICAgLy8g bGlzdCBvZiBDU1MyQ291bnRlckluY3JlbWVudAotICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9S RVNFVDoKLSAgICAgICAgLy8gbGlzdCBvZiBDU1MyQ291bnRlclJlc2V0CisgICAgY2FzZSBDU1Nf UFJPUF9DT1VOVEVSX0lOQ1JFTUVOVDogeworICAgICAgICBpZiAoIXZhbHVlLT5pc1ZhbHVlTGlz dCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBDU1NWYWx1ZUxpc3QqIGxpc3QgPSBz dGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QgKj4odmFsdWUpOworICAgICAgICBzdHlsZS0+c2V0Q291 bnRlckluY3JlbWVudChsaXN0KTsKICAgICAgICAgYnJlYWs7CisgICAgfQorICAgIGNhc2UgQ1NT X1BST1BfQ09VTlRFUl9SRVNFVDogeworICAgICAgICBpZiAoIXZhbHVlLT5pc1ZhbHVlTGlzdCgp KQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBDU1NWYWx1ZUxpc3QqIGxpc3QgPSBzdGF0 aWNfY2FzdDxDU1NWYWx1ZUxpc3QgKj4odmFsdWUpOworICAgICAgICBzdHlsZS0+c2V0Q291bnRl clJlc2V0KGxpc3QpOworICAgICAgICBicmVhazsKKyAgICB9CiAgICAgY2FzZSBDU1NfUFJPUF9G T05UX0ZBTUlMWTogewogICAgICAgICAvLyBsaXN0IG9mIHN0cmluZ3MgYW5kIGlkcwogICAgICAg ICBpZiAoaXNJbmhlcml0KSB7CkluZGV4OiBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIGNzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysg Y3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTI0LDcgKzUyNCwx MCBAQAogICAgICAgICAgICAgLy8gIyMjCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2Fz ZSBDU1NfQ09VTlRFUjoKLSAgICAgICAgICAgIC8vICMjIworICAgICAgICAgICAgdGV4dCA9ICJj b3VudGVyKCI7CisgICAgICAgICAgICB0ZXh0ICs9IFN0cmluZzo6bnVtYmVyKG1fdmFsdWUubnVt KTsKKyAgICAgICAgICAgIHRleHQgKz0gIikiOworICAgICAgICAgICAgLy8gIyMjIGFkZCBsaXN0 LXN0eWxlIGFuZCBzZXBhcmF0b3IKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENT U19SRUNUOiB7CiAgICAgICAgICAgICBSZWN0SW1wbCogcmVjdFZhbCA9IGdldFJlY3RWYWx1ZSgp OwpJbmRleDogY3NzL0NvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvQ291bnRlci5oCShyZXZp c2lvbiAxNjUyOCkKKysrIGNzcy9Db3VudGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTIzLDIzICsy MywzNyBAQAogI2lmbmRlZiBDb3VudGVyX0gKICNkZWZpbmUgQ291bnRlcl9ICiAKKyNpbmNsdWRl ICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCiAjaW5j bHVkZSAiU2hhcmVkLmgiCi0jaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNpbmNsdWRlIDx3 dGYvUGFzc1JlZlB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIENvdW50ZXIg OiBwdWJsaWMgU2hhcmVkPENvdW50ZXI+IHsKIHB1YmxpYzoKLSAgICBTdHJpbmcgaWRlbnRpZmll cigpIGNvbnN0IHsgcmV0dXJuIG1faWRlbnRpZmllcjsgfQotICAgIFN0cmluZyBsaXN0U3R5bGUo KSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZTsgfQotICAgIFN0cmluZyBzZXBhcmF0b3IoKSBj b25zdCB7IHJldHVybiBtX3NlcGFyYXRvcjsgfQorICAgIENvdW50ZXIoKSA6IG1faWRlbnRpZmll cigwKSwgbV9saXN0U3R5bGUoMCksIG1fc2VwYXJhdG9yKDApIHsgfQorICAgIENvdW50ZXIoUGFz c1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gaWRlbnRpZmllciwgUGFzc1JlZlB0cjxDU1NQcmlt aXRpdmVWYWx1ZT4gbGlzdFN0eWxlLAorICAgICAgICBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZh bHVlPiBzZXBhcmF0b3IpCisgICAgICAgIDogbV9pZGVudGlmaWVyKGlkZW50aWZpZXIpLCBtX2xp c3RTdHlsZShsaXN0U3R5bGUpLCBtX3NlcGFyYXRvcihzZXBhcmF0b3IpIHsgfQorICAgIHZpcnR1 YWwgfkNvdW50ZXIoKSB7IH0KIAotcHJpdmF0ZToKLSAgICBTdHJpbmcgbV9pZGVudGlmaWVyOwot ICAgIFN0cmluZyBtX2xpc3RTdHlsZTsKLSAgICBTdHJpbmcgbV9zZXBhcmF0b3I7Ci19OworICAg IFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyLmdldCgpID8g bV9pZGVudGlmaWVyLmdldCgpLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0KKyAgICBT dHJpbmcgbGlzdFN0eWxlKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUuZ2V0KCkgPyBtX2xp c3RTdHlsZS5nZXQoKS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5n IHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yLmdldCgpID8gbV9zZXBhcmF0 b3IuZ2V0KCktPmdldFN0cmluZ1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQogCi19IC8vIG5hbWVzcGFj ZQorICAgIGludCBsaXN0U3R5bGVOdW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZS5n ZXQoKSA/IChpbnQpIG1fbGlzdFN0eWxlLmdldCgpLT5nZXRGbG9hdFZhbHVlKCkgOiAwOyB9Cisg ICAgCisgICAgdm9pZCBzZXRJZGVudGlmaWVyKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+ IGlkZW50aWZpZXIpIHsgbV9pZGVudGlmaWVyID0gaWRlbnRpZmllcjsgfQorICAgIHZvaWQgc2V0 TGlzdFN0eWxlKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGxpc3RTdHlsZSkgeyBtX2xp c3RTdHlsZSA9IGxpc3RTdHlsZTsgfQorICAgIHZvaWQgc2V0U2VwYXJhdG9yKFBhc3NSZWZQdHI8 Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikgeyBtX3NlcGFyYXRvciA9IHNlcGFyYXRvcjsg fQorIAorcHJvdGVjdGVkOgorICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbV9pZGVudGlm aWVyOyAvL3N0cmluZworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbV9saXN0U3R5bGU7 IC8vaW50CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBtX3NlcGFyYXRvcjsgLy9zdHJp bmcKKyB9OwogCit9IC8vbmFtZXNwYWNlCisKICNlbmRpZgpJbmRleDogY3NzL2Nzc3BhcnNlci5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysg Y3NzL2Nzc3BhcnNlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNs dWRlICJjc3NwYXJzZXIuaCIKIAogI2luY2x1ZGUgIkNTU0JvcmRlckltYWdlVmFsdWUuaCIKKyNp bmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ1NTSW1hZ2VWYWx1ZS5oIgogI2luY2x1ZGUg IkNTU0NoYXJzZXRSdWxlLmgiCiAjaW5jbHVkZSAiQ1NTSW1wb3J0UnVsZS5oIgpAQCAtODcwLDYg Kzg3MSwxNyBAQAogICAgICAgICBlbHNlCiAgICAgICAgICAgICB2YWxpZF9wcmltaXRpdmUgPSAo IWlkICYmIHZhbGlkVW5pdCh2YWx1ZSwgRk51bWJlcnxGTGVuZ3RofEZQZXJjZW50LCBzdHJpY3Qp KTsKICAgICAgICAgYnJlYWs7CisgICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX0lOQ1JFTUVOVDog ICAgLy8gWyA8aWRlbnRpZmllcj4gPGludGVnZXI+PyBdKyB8IG5vbmUgfCBpbmhlcml0CisgICAg ICAgIGlmIChpZCA9PSBDU1NfVkFMX05PTkUpCisgICAgICAgICAgICB2YWxpZF9wcmltaXRpdmUg PSB0cnVlOworICAgICAgICBlbHNlCisgICAgICAgICAgICByZXR1cm4gcGFyc2VDb3VudGVyKHBy b3BJZCwgdHJ1ZSwgaW1wb3J0YW50KTsKKyAgICAgICAgYnJlYWs7CisgICAgIGNhc2UgQ1NTX1BS T1BfQ09VTlRFUl9SRVNFVDogICAgICAgIC8vIFsgPGlkZW50aWZpZXI+IDxpbnRlZ2VyPj8gXSsg fCBub25lIHwgaW5oZXJpdAorICAgICAgICAgaWYgKGlkID09IENTU19WQUxfTk9ORSkKKyAgICAg ICAgICAgICB2YWxpZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAgICBlbHNlCisgICAgICAgICAg ICByZXR1cm4gcGFyc2VDb3VudGVyKHByb3BJZCwgZmFsc2UsIGltcG9ydGFudCk7CiAgICAgY2Fz ZSBDU1NfUFJPUF9GT05UX0ZBTUlMWToKICAgICAgICAgLy8gW1sgPGZhbWlseS1uYW1lPiB8IDxn ZW5lcmljLWZhbWlseT4gXSxdKiBbPGZhbWlseS1uYW1lPiB8IDxnZW5lcmljLWZhbWlseT5dIHwg aW5oZXJpdAogICAgIHsKQEAgLTE1MjQsMjcgKzE1MzYsMzkgQEAKIGJvb2wgQ1NTUGFyc2VyOjpw YXJzZUNvbnRlbnQoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRhbnQpCiB7CiAgICAgQ1NTVmFsdWVM aXN0KiB2YWx1ZXMgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgIENTU1ZhbHVlKiBwYXJzZWRWYWx1 ZSA9IDA7CiAKICAgICB3aGlsZSAoVmFsdWUqIHZhbCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpKSB7 Ci0gICAgICAgIENTU1ZhbHVlKiBwYXJzZWRWYWx1ZSA9IDA7CiAgICAgICAgIGlmICh2YWwtPnVu aXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKICAgICAgICAgICAgIC8vIHVybAog ICAgICAgICAgICAgU3RyaW5nIHZhbHVlID0gcGFyc2VVUkwoZG9tU3RyaW5nKHZhbC0+c3RyaW5n KSk7CiAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NJbWFnZVZhbHVlKAogICAgICAg ICAgICAgICAgIFN0cmluZyhLVVJMKHN0eWxlRWxlbWVudC0+YmFzZVVSTCgpLmRlcHJlY2F0ZWRT dHJpbmcoKSwgdmFsdWUuZGVwcmVjYXRlZFN0cmluZygpKS51cmwoKSksIHN0eWxlRWxlbWVudCk7 CiAgICAgICAgIH0gZWxzZSBpZiAodmFsLT51bml0ID09IFZhbHVlOjpGdW5jdGlvbikgewotICAg ICAgICAgICAgLy8gYXR0cihYKQorICAgICAgICAgICAgLy8gYXR0cihYKSB8IGNvdW50ZXIoWCBb LFldKSB8IGNvdW50ZXJzKFgsIFksIFssWl0pCiAgICAgICAgICAgICBWYWx1ZUxpc3QgKmFyZ3Mg PSB2YWwtPmZ1bmN0aW9uLT5hcmdzOwogICAgICAgICAgICAgU3RyaW5nIGZuYW1lID0gZG9tU3Ry aW5nKHZhbC0+ZnVuY3Rpb24tPm5hbWUpLmxvd2VyKCk7Ci0gICAgICAgICAgICBpZiAoZm5hbWUg IT0gImF0dHIoIiB8fCAhYXJncykKKyAgICAgICAgICAgIGlmICghYXJncykKICAgICAgICAgICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEpCisg ICAgICAgICAgICBpZiAoZm5hbWUgPT0gImF0dHIoIikgeworICAgICAgICAgICAgICAgIGlmIChh cmdzLT5zaXplKCkgIT0gMSkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAg ICAgICAgICAgICAgIFZhbHVlICphID0gYXJncy0+Y3VycmVudCgpOworICAgICAgICAgICAgICAg IFN0cmluZyBhdHRyTmFtZSA9IGRvbVN0cmluZyhhLT5zdHJpbmcpOworICAgICAgICAgICAgICAg IGlmIChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVudCgpKQorICAgICAgICAgICAgICAgICAgICBh dHRyTmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUg PSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoYXR0ck5hbWUsIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1Nf QVRUUik7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGlmIChmbmFtZSA9PSAiY291 bnRlcigiKSB7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUgPSBwYXJzZUNvdW50ZXJDb250 ZW50KGFyZ3MsIGZhbHNlKTsKKyAgICAgICAgICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKSByZXR1 cm4gZmFsc2U7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGlmIChmbmFtZSA9PSAi Y291bnRlcnMoIikgeworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3VudGVy Q29udGVudChhcmdzLCB0cnVlKTsKKyAgICAgICAgICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKSBy ZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBlbHNlCiAgICAgICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAgICAgVmFsdWUgKmEgPSBhcmdzLT5jdXJyZW50 KCk7Ci0gICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUgPSBkb21TdHJpbmcoYS0+c3RyaW5nKTsK LSAgICAgICAgICAgIGlmIChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVudCgpKQotICAgICAgICAg ICAgICAgIGF0dHJOYW1lID0gYXR0ck5hbWUubG93ZXIoKTsKLSAgICAgICAgICAgIHBhcnNlZFZh bHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6 Q1NTX0FUVFIpOwogICAgICAgICB9IGVsc2UgaWYgKHZhbC0+dW5pdCA9PSBDU1NQcmltaXRpdmVW YWx1ZTo6Q1NTX0lERU5UKSB7CiAgICAgICAgICAgICAvLyBvcGVuLXF1b3RlCiAgICAgICAgICAg ICAvLyBjbG9zZS1xdW90ZQpAQCAtMTU2Nyw2ICsxNTkxLDggQEAKICAgICB9CiAKICAgICBkZWxl dGUgdmFsdWVzOworICAgIGlmIChwYXJzZWRWYWx1ZSkKKyAgICAgICAgZGVsZXRlIHBhcnNlZFZh bHVlOwogICAgIHJldHVybiBmYWxzZTsKIH0KIApAQCAtMTk3OCw2ICsyMDA0LDU0IEBACiB9CiAj ZW5kaWYKIAorQ1NTVmFsdWUqIENTU1BhcnNlcjo6cGFyc2VDb3VudGVyQ29udGVudChWYWx1ZUxp c3QgKmFyZ3MsIGJvb2wgY291bnRlcnMpCit7CisgICAgaWYgKGNvdW50ZXJzIHx8IChhcmdzLT5z aXplKCkgIT0gMSAmJiBhcmdzLT5zaXplKCkgIT0gMykpCisgICAgICAgIGlmICghY291bnRlcnMg fHwgKGFyZ3MtPnNpemUoKSAhPSAzICYmIGFyZ3MtPnNpemUoKSAhPSA1KSkKKyAgICAgICAgICAg IHJldHVybiAwOworCisgICAgVmFsdWUgKmkgPSBhcmdzLT5jdXJyZW50KCk7CisgICAgQ1NTUHJp bWl0aXZlVmFsdWUqIGlkZW50aWZpZXIgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5n KGktPnN0cmluZyksIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKworICAgIENTU1By aW1pdGl2ZVZhbHVlKiBzZXBhcmF0b3IgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoU3RyaW5nKCks IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKyAgICBpZiAoY291bnRlcnMpIHsKKyAg ICAgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICAgICAgaWYgKGktPnVuaXQgIT0gVmFsdWU6Ok9w ZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcpCisgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAg ICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51bml0ICE9IENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAg ICAgIAorICAgICAgICBzZXBhcmF0b3IgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5n KGktPnN0cmluZyksIChDU1NQcmltaXRpdmVWYWx1ZTo6VW5pdFR5cGVzKSBpLT51bml0KTsKKyAg ICB9CisgICAgCisgICAgLy8gTWFrZSB0aGUgbGlzdCBzdHlsZSBkZWZhdWx0IGRlY2ltYWwKKyAg ICBDU1NQcmltaXRpdmVWYWx1ZSogbGlzdFN0eWxlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKENT U19WQUxfREVDSU1BTCAtIENTU19WQUxfRElTQywgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1C RVIpOworICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgaWYgKGkpIHsKKyAgICAgICAgaWYgKGkt PnVuaXQgIT0gVmFsdWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAg IGlmIChpLT51bml0ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIHNob3J0IGxzID0gMDsKKyAgICAgICAgaWYg KGktPmlkID09IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAgIGxzID0gQ1NTX1ZBTF9LQVRBS0FO QV9JUk9IQSAtIENTU19WQUxfRElTQyArIDE7CisgICAgICAgIGVsc2UgaWYgKGktPmlkID49IENT U19WQUxfRElTQyAmJiBpLT5pZCA8PSBDU1NfVkFMX0tBVEFLQU5BX0lST0hBKQorICAgICAgICAg ICAgbHMgPSBpLT5pZCAtIENTU19WQUxfRElTQzsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAg cmV0dXJuIDA7CisKKyAgICAgICAgbGlzdFN0eWxlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGxz LCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBlcykgaS0+dW5pdCk7CisgICAgfQorICAgIAor ICAgIENvdW50ZXIqIGNvdW50ZXIgPSBuZXcgQ291bnRlcihpZGVudGlmaWVyLCBsaXN0U3R5bGUs IHNlcGFyYXRvcik7CisgICAgcmV0dXJuIG5ldyBDU1NQcmltaXRpdmVWYWx1ZShjb3VudGVyKTsK K30KKwogYm9vbCBDU1NQYXJzZXI6OnBhcnNlU2hhcGUoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRh bnQpCiB7CiAgICAgVmFsdWUgKnZhbHVlID0gdmFsdWVMaXN0LT5jdXJyZW50KCk7CkBAIC0yNjc2 LDYgKzI3NTAsNTIgQEAKICAgICByZXR1cm4gY29udGV4dC5mYWlsZWQoKTsKIH0KIAorYm9vbCBD U1NQYXJzZXI6OnBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBib29sIGluY3JlbWVudCwgYm9vbCBp bXBvcnRhbnQpCit7CisgICAgZW51bSB7IElELCBWQUwgfSBzdGF0ZSA9IElEOworCisgICAgQ1NT VmFsdWVMaXN0KiBsaXN0ID0gbmV3IENTU1ZhbHVlTGlzdDsKKyAgICBWYWx1ZSogdmFsOworICAg IENTU1ByaW1pdGl2ZVZhbHVlKiBjb3VudGVyTmFtZTsKKyAgICBDU1NQcmltaXRpdmVWYWx1ZSog bnVtVmFsdWU7CisgICAgCisgICAgd2hpbGUgKHRydWUpIHsKKyAgICAgICAgdmFsID0gdmFsdWVM aXN0LT5jdXJyZW50KCk7CisgICAgICAgIHN3aXRjaCAoc3RhdGUpIHsKKyAgICAgICAgICAgIGNh c2UgSUQ6CisgICAgICAgICAgICAgICAgaWYgKHZhbCAmJiB2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0 aXZlVmFsdWU6OkNTU19JREVOVCkgeworICAgICAgICAgICAgICAgICAgICBjb3VudGVyTmFtZSA9 IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShkb21TdHJpbmcodmFsLT5zdHJpbmcpLCBDU1NQcmltaXRp dmVWYWx1ZTo6Q1NTX1NUUklORyk7CisgICAgICAgICAgICAgICAgICAgIHN0YXRlID0gVkFMOwor ICAgICAgICAgICAgICAgICAgICB2YWx1ZUxpc3QtPm5leHQoKTsKKyAgICAgICAgICAgICAgICAg ICAgY29udGludWU7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICAgICAgY2FzZSBWQUw6IHsKKyAgICAgICAgICAgICAgICBpbnQgaSA9IChpbmNyZW1l bnQpID8gMSA6IDA7CisgICAgICAgICAgICAgICAgaWYgKHZhbCAmJiB2YWwtPnVuaXQgPT0gQ1NT UHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpIHsKKyAgICAgICAgICAgICAgICAgICAgaSA9IChz aG9ydCl2YWwtPmZWYWx1ZTsKKyAgICAgICAgICAgICAgICAgICAgdmFsdWVMaXN0LT5uZXh0KCk7 CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgbnVtVmFsdWUgPSBuZXcgQ1NT UHJpbWl0aXZlVmFsdWUoaSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpOworICAgICAg ICAgICAgICAgIFBhaXIqIHBhaXIgPSBuZXcgUGFpcihjb3VudGVyTmFtZSwgbnVtVmFsdWUpOwor ICAgICAgICAgICAgICAgIGxpc3QtPmFwcGVuZChuZXcgQ1NTUHJpbWl0aXZlVmFsdWUocGFpcikp OworICAgICAgICAgICAgICAgIHN0YXRlID0gSUQ7CisgICAgICAgICAgICAgICAgY29udGludWU7 CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgYnJlYWs7CisgICAgfQorICAgIAor ICAgIGlmIChsaXN0LT5sZW5ndGgoKSA+IDApIHsKKyAgICAgICAgYWRkUHJvcGVydHkocHJvcElk LCBsaXN0LCBpbXBvcnRhbnQpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICBk ZWxldGUgbGlzdDsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKICNpZmRlZiBDU1NfREVCVUcKIAog c3RhdGljIGlubGluZSBpbnQgeXllcnJvcihjb25zdCBjaGFyICpzdHIpCg== 10793 2006-09-26 23:43:24 -0700 2006-09-28 02:14:23 -0700 better tuesNight.txt text/plain 69238 bdakin SW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5kZXJP YmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0IChD KSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkg QW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAg RGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQgQWxs YW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChDKSAy MDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMjks NiArMzAsOCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIgCiAjaW5jbHVkZSAiQWZmaW5l VHJhbnNmb3JtLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKKyNpbmNsdWRlICJDb3VudGVy Tm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKICNpbmNsdWRlICJEZWNvZGVy LmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJFbGVtZW50LmgiCkBAIC0zNyw2 ICs0MCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQu aCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MT0xpc3RFbGVtZW50Lmgi CiAjaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJBcmVuYS5oIgogI2luY2x1 ZGUgIlJlbmRlckZsZXhpYmxlQm94LmgiCkBAIC0xNTksNiArMTYzLDcgQEAKIG1fcGFyZW50KCAw ICksCiBtX3ByZXZpb3VzKCAwICksCiBtX25leHQoIDAgKSwKK21fY291bnRlck5vZGVNYXAoIDAg KSwKIG1fdmVydGljYWxQb3NpdGlvbiggUG9zaXRpb25VbmRlZmluZWQgKSwKIG1fbmVlZHNMYXlv dXQoIGZhbHNlICksCiBtX25vcm1hbENoaWxkTmVlZHNMYXlvdXQoIGZhbHNlICksCkBAIC0yMzk1 LDYgKzI0MDAsMTEgQEAKIAogdm9pZCBSZW5kZXJPYmplY3Q6OmRlc3Ryb3koKQogeworICAgIGlm IChtX2NvdW50ZXJOb2RlTWFwKSB7CisgICAgICAgIGRlbGV0ZUFsbFZhbHVlcygqbV9jb3VudGVy Tm9kZU1hcCk7CisgICAgICAgIGRlbGV0ZSBtX2NvdW50ZXJOb2RlTWFwOworICAgIH0KKyAgICAK ICAgICBkb2N1bWVudCgpLT5heE9iamVjdENhY2hlKCktPnJlbW92ZSh0aGlzKTsKIAogICAgIC8v IEJ5IGRlZmF1bHQgbm8gcmVmLWNvdW50aW5nLiBSZW5kZXJXaWRnZXQ6OmRlc3Ryb3koKSBkb2Vz bid0IGNhbGwKQEAgLTI4MzcsNiArMjg0NywxMzggQEAKICAgICByZXR1cm4gKGF2b2lkc0Zsb2F0 cygpICYmIChzdHlsZSgpLT53aWR0aCgpLmlzQXV0bygpIHx8IGlzSFIoKSB8fCAoc3R5bGUoKS0+ aHRtbEhhY2tzKCkgJiYgIWlzVGFibGUoKSkpKTsKIH0KIAorYm9vbCBSZW5kZXJPYmplY3Q6Omhh c0NvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdAoreworICAgIGlmIChzdHlsZSgp KQorICAgICAgICBpZiAoKG1fY291bnRlck5vZGVNYXAgJiYgbV9jb3VudGVyTm9kZU1hcC0+Z2V0 KGNvdW50ZXIpKSB8fCBzdHlsZSgpLT5oYXNDb3VudGVyUmVzZXQoY291bnRlcikgfHwgCisgICAg ICAgICAgICAgICAgc3R5bGUoKS0+aGFzQ291bnRlckluY3JlbWVudChjb3VudGVyKSkKKyAgICAg ICAgICAgIHJldHVybiB0cnVlOworICAgIAorICAgIGlmIChjb3VudGVyID09ICJsaXN0LWl0ZW0i KQorICAgICAgICBpZiAoaXNMaXN0SXRlbSgpIHx8IChlbGVtZW50KCkgJiYgKAorICAgICAgICAg ICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFtZShvbFRhZykgfHwKKyAgICAgICAgICAgICAgICBl bGVtZW50KCktPmhhc1RhZ05hbWUodWxUYWcpIHx8CisgICAgICAgICAgICAgICAgZWxlbWVudCgp LT5oYXNUYWdOYW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNU YWdOYW1lKGRpclRhZykpKSkKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworCisgICAgcmV0dXJu IGZhbHNlOworfQorCitDb3VudGVyTm9kZSogUmVuZGVyT2JqZWN0OjpmaW5kQ291bnRlcihjb25z dCBTdHJpbmcmIGNvdW50ZXIsIGJvb2wgdmlldywgYm9vbCBjb3VudGVycykKK3sKKyAgICBpZiAo IXN0eWxlKCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgaW50IHZhbCA9IDA7CisgICAgQ291 bnRlck5vZGUqIG5ld05vZGUgPSBtX2NvdW50ZXJOb2RlTWFwID8gbV9jb3VudGVyTm9kZU1hcC0+ Z2V0KGNvdW50ZXIpIDogMDsKKyAgICBpZiAobmV3Tm9kZSkKKyAgICAgICAgcmV0dXJuIG5ld05v ZGU7CisKKyAgICBpZiAoc3R5bGUoKS0+aGFzQ291bnRlclJlc2V0KGNvdW50ZXIpIHx8IGlzUm9v dCgpKSB7CisgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJSZXNl dE5vZGUodGhpcyk7CisgICAgICAgIHZhbCA9IHN0eWxlKCktPmNvdW50ZXJSZXNldChjb3VudGVy KTsKKyAgICAgICAgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpCisg ICAgICAgICAgICB2YWwgKz0gc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChjb3VudGVyKTsKKyAg ICB9IGVsc2UgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpIHsKKyAg ICAgICAgbmV3Tm9kZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgQ291bnRlck5vZGUodGhpcyk7Cisg ICAgICAgIHZhbCArPSBzdHlsZSgpLT5jb3VudGVySW5jcmVtZW50KGNvdW50ZXIpOworICAgIH0g ZWxzZSBpZiAoY291bnRlciA9PSAibGlzdC1pdGVtIikgeworICAgICAgICBpZiAoaXNMaXN0SXRl bSgpKSB7CisgICAgICAgICAgICBpZiAoZWxlbWVudCgpKSB7CisgICAgICAgICAgICAgICAgU3Ry aW5nIHYgPSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0QXR0cmlidXRlKCJ2 YWx1ZSIpOworICAgICAgICAgICAgICAgIGlmICghdi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAg ICAgICAgICAgbmV3Tm9kZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgQ291bnRlclJlc2V0Tm9kZSh0 aGlzKTsKKyAgICAgICAgICAgICAgICAgICAgdmFsID0gdi50b0ludCgpOworICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIH0gCisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmICghbmV3 Tm9kZSkgeworICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENv dW50ZXJOb2RlKHRoaXMpOworICAgICAgICAgICAgICAgIHZhbCA9IDE7CisgICAgICAgICAgICB9 CisgICAgICAgIH0gZWxzZSBpZiAoZWxlbWVudCgpICYmIGVsZW1lbnQoKS0+aGFzVGFnTmFtZShv bFRhZykpIHsKKyAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50 ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSBzdGF0aWNfY2FzdDxIVE1MT0xp c3RFbGVtZW50Kj4oZWxlbWVudCgpKS0+c3RhcnQoKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVt ZW50KCkgJiYKKyAgICAgICAgICAgIChlbGVtZW50KCktPmhhc1RhZ05hbWUodWxUYWcpIHx8Cisg ICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAg ICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKGRpclRhZykpKSB7CisgICAgICAgICAgICBuZXdOb2Rl ID0gbmV3IChyZW5kZXJBcmVuYSgpKSBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAg ICAgdmFsID0gMDsKKyAgICAgICAgfQorICAgIH0gCisgICAgCisgICAgaWYgKCFuZXdOb2RlKSB7 CisgICAgICAgIG5ld05vZGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIENvdW50ZXJOb2RlKHRoaXMp OworICAgICAgICB2YWwgPSAwOworICAgIH0KKyAgICAKKyAgICBuZXdOb2RlLT5zZXRWYWx1ZSh2 YWwpOworICAgIGlmICh2aWV3KQorICAgICAgICBuZXdOb2RlLT5zZXRJc1Zpc3VhbCgpOworICAg IGlmIChjb3VudGVycykKKyAgICAgICAgbmV3Tm9kZS0+c2V0SGFzQ291bnRlcnMoKTsKKworICAg IGlmICghbV9jb3VudGVyTm9kZU1hcCkKKyAgICAgICAgbV9jb3VudGVyTm9kZU1hcCA9IG5ldyBI YXNoTWFwPFN0cmluZywgQ291bnRlck5vZGUqPjsKKyAgICBtX2NvdW50ZXJOb2RlTWFwLT5zZXQo Y291bnRlciwgbmV3Tm9kZSk7CisKKyAgICBpZiAoIWlzUm9vdCgpKSB7CisgICAgICAgIENvdW50 ZXJOb2RlKiBsYXN0ID0gMDsKKyAgICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnQgPSAwOworICAg ICAgICBSZW5kZXJPYmplY3QqIG4gPSAhaXNMaXN0SXRlbSgpICYmIHByZXZpb3VzU2libGluZygp ID8gCisgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmcoKS0+cHJldmlvdXNTaWJsaW5nKCkgOiBw cmV2aW91c1NpYmxpbmcoKTsKKworICAgICAgICB3aGlsZSAobikgeworICAgICAgICAgICAgaWYg KG4tPmhhc0NvdW50ZXIoY291bnRlcikpIHsKKyAgICAgICAgICAgICAgICBjdXJyZW50ID0gbi0+ ZmluZENvdW50ZXIoY291bnRlcik7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAg ICB9IGVsc2UKKyAgICAgICAgICAgICAgICBuID0gbi0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAg ICAgIH0KKyAgICAgICAgCisgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAgICBDb3VudGVy Tm9kZSogc2libGluZyA9IGN1cnJlbnQ7CisgICAgICAgIGlmIChsYXN0ICYmICFuZXdOb2RlLT5p c1Jlc2V0KCkpIHsKKyAgICAgICAgICAgIC8vIEZvdW5kIHJlbmRlci1zaWJsaW5nLCBub3cgc2Vh cmNoIGZvciBsYXRlciBjb3VudGVyLXNpYmxpbmdzIGFtb25nIGl0cyByZW5kZXItY2hpbGRyZW4K KyAgICAgICAgICAgIG4gPSBuLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgICAgIHdoaWxlIChuKSB7 CisgICAgICAgICAgICAgICAgaWYgKG4tPmhhc0NvdW50ZXIoY291bnRlcikpIHsKKyAgICAgICAg ICAgICAgICAgICAgY3VycmVudCA9IG4tPmZpbmRDb3VudGVyKGNvdW50ZXIpOworICAgICAgICAg ICAgICAgICAgICBpZiAobGFzdC0+cGFyZW50KCkgPT0gY3VycmVudC0+cGFyZW50KCkgfHwgc2li bGluZyA9PSBjdXJyZW50LT5wYXJlbnQoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbGFz dCA9IGN1cnJlbnQ7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBJZiB0aGUgY3VycmVudCBj b3VudGVyIGlzIG5vdCB0aGUgbGFzdCwgc2VhcmNoIGRlZXBlcgorICAgICAgICAgICAgICAgICAg ICAgICAgaWYgKGN1cnJlbnQtPm5leHRTaWJsaW5nKCkpIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICBuID0gbi0+bGFzdENoaWxkKCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgICAgICAgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICBuID0gbi0+cHJldmlvdXNTaWJsaW5nKCk7CisgICAgICAg ICAgICB9CisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChzaWJsaW5nLT5pc1Jlc2V0KCkp IHsKKyAgICAgICAgICAgICAgICBpZiAobGFzdCAhPSBzaWJsaW5nKQorICAgICAgICAgICAgICAg ICAgICBzaWJsaW5nLT5pbnNlcnRBZnRlcihuZXdOb2RlLCBsYXN0KTsKKyAgICAgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgICAgIHNpYmxpbmctPmluc2VydEFmdGVyKG5ld05vZGUs IDApOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgbGFzdC0+cGFyZW50KCkt Pmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgLy8gTm90aGluZyBmb3VuZCBhbW9uZyBzaWJsaW5ncywgbGV0IG91ciBwYXJlbnQgc2VhcmNo CisgICAgICAgICAgICBsYXN0ID0gcGFyZW50KCktPmZpbmRDb3VudGVyKGNvdW50ZXIsIGZhbHNl KTsKKyAgICAgICAgICAgIGlmIChsYXN0LT5pc1Jlc2V0KCkpCisgICAgICAgICAgICAgICAgbGFz dC0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgICAgbGFzdC0+cGFyZW50KCktPmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAg ICB9CisgICAgfQorCisgICAgcmV0dXJuIG5ld05vZGU7Cit9CisKIFVDaGFyIFJlbmRlck9iamVj dDo6YmFja3NsYXNoQXNDdXJyZW5jeVN5bWJvbCgpIGNvbnN0CiB7CiAgICAgaWYgKE5vZGUgKm5v ZGUgPSBlbGVtZW50KCkpCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENv cHlyaWdodCAoQykgMjAwMCBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAg IChDKSAyMDAwIEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAg IChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICogICAgICAgICAgIChD KSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHly aWdodCAoQykgMjAwMywgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICoK ICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKQEAgLTMxLDYgKzMyLDcgQEAKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2lu Y2x1ZGUgIlNjcm9sbEJhci5oIgogI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgorI2luY2x1 ZGUgPHd0Zi9IYXNoTWFwLmg+CiAKIC8qCiAgKiAgVGhlIHBhaW50aW5nIG9mIGEgbGF5ZXIgb2Nj dXJzIGluIHRocmVlIGRpc3RpbmN0IHBoYXNlcy4gIEVhY2ggcGhhc2UgaW52b2x2ZXMKQEAgLTU0 LDYgKzU2LDcgQEAKIGNsYXNzIEhUTUxBcmVhRWxlbWVudDsKIGNsYXNzIElubGluZUJveDsKIGNs YXNzIElubGluZUZsb3dCb3g7CitjbGFzcyBDb3VudGVyTm9kZTsKIGNsYXNzIFBvc2l0aW9uOwog Y2xhc3MgUmVuZGVyQXJlbmE7CiBjbGFzcyBSZW5kZXJCbG9jazsKQEAgLTE5Miw2ICsxOTUsMTAg QEAKICAgICB2aXJ0dWFsIGludCBzdGF0aWNYKCkgY29uc3QgeyByZXR1cm4gMDsgfQogICAgIHZp cnR1YWwgaW50IHN0YXRpY1koKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgCisgICAgYm9vbCBo YXNDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlcikgY29uc3Q7CisgICAgQ291bnRlck5vZGUq IGZpbmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlciwgYm9vbCB2aWV3ID0gZmFsc2UsIGJv b2wgY291bnRlcnMgPSBmYWxzZSk7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJl ZSBtYW5pcHVsYXRpb24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8v Ly8vLy8KICAgICB2aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTMs NiArMjYwLDcgQEAKICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsg cmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsg cmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0 dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0 dXJuIGZhbHNlOyB9CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlzQm9keSgp IGNvbnN0OwpAQCAtOTAyLDYgKzkxMCw4IEBACiAgICAgUmVuZGVyT2JqZWN0ICptX3BhcmVudDsK ICAgICBSZW5kZXJPYmplY3QgKm1fcHJldmlvdXM7CiAgICAgUmVuZGVyT2JqZWN0ICptX25leHQ7 CisgICAgCisgICAgSGFzaE1hcDxTdHJpbmcsIENvdW50ZXJOb2RlKj4qIG1fY291bnRlck5vZGVN YXA7CiAKICAgICBtdXRhYmxlIHNob3J0IG1fdmVydGljYWxQb3NpdGlvbjsKIApJbmRleDogcmVu ZGVyaW5nL1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5oCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw1NSBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBI VE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQg QWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChD KSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAw MjExMS0xMzA3LCBVU0EuCisgKgorICovCisjaWZuZGVmIFJFTkRFUl9DT1VOVEVSX0hfCisjZGVm aW5lIFJFTkRFUl9DT1VOVEVSX0hfCisKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KKworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0Cit7Citw dWJsaWM6CisgICAgUmVuZGVyQ291bnRlcihOb2RlKiwgQ291bnRlckRhdGEqKTsKKyAgICB2aXJ0 dWFsIH5SZW5kZXJDb3VudGVyKCkge307CisKKyAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRl ck5hbWUoKSBjb25zdCB7IHJldHVybiAiUmVuZGVyQ291bnRlciI7IH0KKworICAgIHZpcnR1YWwg Ym9vbCBpc0NvdW50ZXIoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisgICAgdmlydHVhbCB2b2lk IGxheW91dCgpOworICAgIHZpcnR1YWwgdm9pZCBjYWxjTWluTWF4V2lkdGgoKTsKKworcHJvdGVj dGVkOgorICAgIFN0cmluZyB0b0xpc3RTdHlsZVR5cGUoaW50IHZhbHVlLCBpbnQgdG90YWwsIEVM aXN0U3R5bGVUeXBlIHR5cGUpOworCisgICAgU3RyaW5nIG1faXRlbTsKKyAgICBDb3VudGVyRGF0 YSogbV9jb3VudGVyOworICAgIENvdW50ZXJOb2RlKiBtX2NvdW50ZXJOb2RlOworfTsKKworfSAv L25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuaAkocmV2aXNpb24gMCkK KysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs NjQgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5n aW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEpl bnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21w dXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0 aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisg KiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJl IHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBp bXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1Ymxp YyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICog YWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5v dCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRl bXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgor ICoKKyovCisjaWZuZGVmIENvdW50ZXJfUmVzZXRfTm9kZV9oXworI2RlZmluZSBDb3VudGVyX1Jl c2V0X05vZGVfaF8KKworI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3VudGVyLXRyZWUgdGhhdCBpcyB1 c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9va3VwLAorLy8gYW5k IGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9kZXMgYXJlIGFkZGVkIG9yIHJl bW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRlci1yZXNldCBhbmQgcm9vdCBj YW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJlZSBwYXJlbnRzCisvLyBhcmUg anVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVtZW50YXRpb24gb2YgY291bnRl ci1yZXNldCBhbmQgcm9vdAorY2xhc3MgQ291bnRlclJlc2V0Tm9kZSA6IHB1YmxpYyBDb3VudGVy Tm9kZQoreworcHVibGljOgorICAgIENvdW50ZXJSZXNldE5vZGUoUmVuZGVyT2JqZWN0Kik7Cisg ICAgdmlydHVhbCB+Q291bnRlclJlc2V0Tm9kZSgpOworCisgICAgdmlydHVhbCBDb3VudGVyTm9k ZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlyc3Q7IH07CisgICAgdmlydHVhbCBD b3VudGVyTm9kZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gbV9sYXN0OyB9OworICAgIHZp cnR1YWwgdm9pZCBpbnNlcnRBZnRlciAoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9k ZSogcmVmQ2hpbGQpOworICAgIHZpcnR1YWwgdm9pZCByZW1vdmVDaGlsZCAoQ291bnRlck5vZGUq KTsKKworICAgIHZpcnR1YWwgYm9vbCBpc1Jlc2V0KCkgeyByZXR1cm4gdHJ1ZTsgfTsKKyAgICB2 aXJ0dWFsIHZvaWQgcmVjb3VudChib29sIGZpcnN0ID0gZmFsc2UpOworICAgIHZpcnR1YWwgdm9p ZCBzZXRTZWxmRGlydHkoKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKwor ICAgIHZvaWQgdXBkYXRlVG90YWwoaW50IHZhbHVlKTsKKyAgICAvLyBUaGUgaGlnaGVzdCB2YWx1 ZSBhbW9uZyBjaGlsZHJlbgorICAgIGludCB0b3RhbCgpIGNvbnN0IHsgcmV0dXJuIG1fdG90YWw7 IH07CisKK3Byb3RlY3RlZDoKKyAgICBpbnQgbV90b3RhbDsKKyAgICBDb3VudGVyTm9kZSogbV9m aXJzdDsKKyAgICBDb3VudGVyTm9kZSogbV9sYXN0OworfTsKKworfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQorCisjZW5kaWYgLy8gQ291bnRlclJlc2V0Tm9kZV9oCkluZGV4OiByZW5kZXJpbmcvQ291 bnRlckxpc3RJdGVtLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5o CShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDQzIEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIERPTSBp bXBsZW1lbnRhdGlvbiBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBT YW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYg QXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2Fy ZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJz aW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQg aGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5M SUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJ bmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEz MDcsIFVTQS4KKyAqCisgKi8KKyAKKyNpZm5kZWYgQ291bnRlckxpc3RJdGVtX0gKKyNkZWZpbmUg Q291bnRlckxpc3RJdGVtX0gKKworI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQ291bnRlckxpc3RJdGVtIDogcHVibGljIENvdW50ZXJO b2RlCit7CitwdWJsaWM6CisgICAgaW50IGNvdW50KCkgY29uc3Q7CisKKyAgICB2aXJ0dWFsIHZv aWQgcmVjb3VudChib29sIGZpcnN0ID0gZmFsc2UpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxm RGlydHkoKTsKKworfTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmlu Zy9SZW5kZXJDb3VudGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRl ci5jcHAJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsMjU4IEBACisvKioKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRo ZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIw MDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0 IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExp Y2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhl cgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUg aG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZ OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElU WSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBM aWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxl IENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBN QSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNs dWRlICJSZW5kZXJDb3VudGVyLmgiCisKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1 ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKyNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUg IlJlbmRlclN0eWxlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworUmVuZGVyQ291bnRlcjo6 UmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRlcikKKyAgICA6IFJl bmRlclRleHQobm9kZSwwKSwgbV9jb3VudGVyKGNvdW50ZXIpLCBtX2NvdW50ZXJOb2RlKDApCit7 Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6bGF5b3V0KCkKK3sKKyAgICBBU1NFUlQobmVlZHNM YXlvdXQoKSk7CisKKyAgICBpZiAoIW1pbk1heEtub3duKCkpCisgICAgICAgIGNhbGNNaW5NYXhX aWR0aCgpOworCisgICAgUmVuZGVyVGV4dDo6bGF5b3V0KCk7Cit9CisKK2NvbnN0IGludCBjTWFy a2VyUGFkZGluZyA9IDc7CisKK3N0YXRpYyBTdHJpbmcgdG9Sb21hbihpbnQgbnVtYmVyLCBib29s IHVwcGVyKQoreyAKKyAgICBTdHJpbmcgcm9tYW47CisgICAgY29uc3QgVUNoYXIgbGRpZ2l0c1td ID0geyAnaScsICd2JywgJ3gnLCAnbCcsICdjJywgJ2QnLCAnbScgfTsKKyAgICBjb25zdCBVQ2hh ciB1ZGlnaXRzW10gPSB7ICdJJywgJ1YnLCAnWCcsICdMJywgJ0MnLCAnRCcsICdNJyB9OworICAg IGNvbnN0IFVDaGFyKiBkaWdpdHMgPSB1cHBlciA/IHVkaWdpdHMgOiBsZGlnaXRzOworICAgIFVD aGFyIGM7CisgICAgaW50IGQgPSAwOworICAgIGRvIHsKKyAgICAgICAgaW50IG51bSA9IG51bWJl ciAlIDEwOworICAgICAgICBpZiAobnVtICUgNSA8IDQpCisgICAgICAgICAgICBmb3IgKGludCBp ID0gbnVtICUgNTsgaSA+IDA7IGktLSkgeworICAgICAgICAgICAgICAgIGMgPSBVQ2hhcihkaWdp dHNbZF0pOworICAgICAgICAgICAgICAgIHJvbWFuLmluc2VydChTdHJpbmcoJmMsIDEpLCAwKTsK KyAgICAgICAgICAgIH0KKyAgICAgICAgaWYgKG51bSA+PSA0ICYmIG51bSA8PSA4KSB7CisgICAg ICAgICAgICBjID0gVUNoYXIoZGlnaXRzW2QgKyAxXSk7CisgICAgICAgICAgICByb21hbi5pbnNl cnQoU3RyaW5nKCZjLCAxKSwgMCk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKG51bSA9PSA5KSB7 CisgICAgICAgICAgICBjID0gVUNoYXIoZGlnaXRzW2QgKyAyXSk7CisgICAgICAgICAgICByb21h bi5pbnNlcnQoU3RyaW5nKCZjLCAxKSwgMCk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKG51bSAl IDUgPT0gNCkgeworICAgICAgICAgICAgYyA9IFVDaGFyKGRpZ2l0c1tkXSk7CisgICAgICAgICAg ICByb21hbi5pbnNlcnQoU3RyaW5nKCZjLCAxKSwgMCk7CisgICAgICAgIH0KKyAgICAgICAgbnVt YmVyIC89IDEwOworICAgICAgICBkICs9IDI7CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAgICBy ZXR1cm4gcm9tYW47Cit9CisKK3N0YXRpYyBTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJl ciwgaW50IGxldHRlckEpCit7CisgICAgVUNoYXIgYzsKKyAgICAKKyAgICBpZiAobnVtYmVyIDwg MikgeworICAgICAgICBjID0gVUNoYXIobGV0dGVyQSk7CisgICAgICAgIHJldHVybiBTdHJpbmco JmMsIDEpOyAvLyBtYXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94ICgwLikKKyAgICB9CisKKyAg ICBTdHJpbmcgbGV0dGVyU3RyaW5nOworICAgIHdoaWxlIChudW1iZXIgPiAwKSB7CisgICAgICAg IGludCBvbmVzRGlnaXQgPSAobnVtYmVyIC0gMSkgJSAyNjsKKyAgICAgICAgIGMgPSBVQ2hhcihs ZXR0ZXJBICsgb25lc0RpZ2l0KTsKKyAgICAgICAgbGV0dGVyU3RyaW5nID0gU3RyaW5nKCZjLCAx KSArIGxldHRlclN0cmluZzsKKyAgICAgICAgbnVtYmVyIC09IG9uZXNEaWdpdDsKKyAgICAgICAg bnVtYmVyIC89IDI2OworICAgIH0KKworICAgIHJldHVybiBsZXR0ZXJTdHJpbmc7Cit9CisKK3N0 YXRpYyBTdHJpbmcgdG9IZWJyZXcoaW50IG51bWJlcikKK3sKKyAgICBpZiAobnVtYmVyIDwgMSkK KyAgICAgICAgcmV0dXJuIFN0cmluZzo6bnVtYmVyKG51bWJlcik7CisgICAgCisgICAgc3RhdGlj IGNvbnN0IFVDaGFyIHRlbkRpZ2l0W10gPSB7MTQ5NywgMTQ5OSwgMTUwMCwgMTUwMiwgMTUwNCwg MTUwNSwgMTUwNiwgMTUwOCwgMTUxMH07CisKKyAgICBTdHJpbmcgbGV0dGVyOworICAgIFVDaGFy IGM7CisgICAgaWYgKG51bWJlciA+IDk5OSkgeworICAgICAgICBsZXR0ZXIgPSB0b0hlYnJldyhu dW1iZXIgLyAxMDAwKSArICInIjsKKyAgICAgICAgbnVtYmVyID0gbnVtYmVyICUgMTAwMDsKKyAg ICB9CisgICAgaW50IGZvdXJIdW5kcmVkcyA9IG51bWJlciAvIDQwMDsKKyAgICBmb3IgKGludCBp ID0gMDsgaSA8IGZvdXJIdW5kcmVkczsgaSsrKSB7CisgICAgICAgIGMgPSBVQ2hhcigxNTExICsg Myk7CisgICAgICAgIGxldHRlciArPSBTdHJpbmcoJmMsIDEpOworICAgIH0KKyAgICBudW1iZXIg JT0gNDAwOworICAgIGlmIChudW1iZXIgLyAxMDApIHsKKyAgICAgICAgYyA9IFVDaGFyKDE1MTEg KyAobnVtYmVyIC8gMTAwKSAtIDEpOworICAgICAgICBsZXR0ZXIgKz0gU3RyaW5nKCZjLCAxKTsK KyAgICB9CisgICAgbnVtYmVyICU9IDEwMDsKKyAgICBpZiAobnVtYmVyID09IDE1IHx8IG51bWJl ciA9PSAxNikgeworICAgICAgICBjID0gVUNoYXIoMTQ4NyArIDkpOworICAgICAgICBsZXR0ZXIg Kz0gU3RyaW5nKCZjLCAxKTsKKyAgICAgICAgYyA9IFVDaGFyKDE0ODcgKyBudW1iZXIgLSA5KTsK KyAgICAgICAgbGV0dGVyICs9IFN0cmluZygmYywgMSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg aW50IHRlbnMgPSBudW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRlbnMpIHsKKyAgICAgICAgICAg IGMgPSBVQ2hhcih0ZW5EaWdpdFt0ZW5zIC0gMV0pOworICAgICAgICAgICAgbGV0dGVyICs9IFN0 cmluZygmYywgMSk7CisgICAgICAgIH0KKyAgICAgICAgbnVtYmVyID0gbnVtYmVyICUgMTA7Cisg ICAgICAgIGlmIChudW1iZXIpIHsKKyAgICAgICAgICAgIGMgPSBVQ2hhcigxNDg3ICsgbnVtYmVy KTsKKyAgICAgICAgICAgIGxldHRlciArPSBTdHJpbmcoJmMsIDEpOworICAgICAgICB9CisgICAg fQorICAgIHJldHVybiBsZXR0ZXI7Cit9CisKK1N0cmluZyBSZW5kZXJDb3VudGVyOjp0b0xpc3RT dHlsZVR5cGUoaW50IHZhbHVlLCBpbnQgdG90YWwsIEVMaXN0U3R5bGVUeXBlIHR5cGUpCit7Cisg ICAgU3RyaW5nIGl0ZW07CisgICAgVUNoYXIgYzsKKyAgICBzd2l0Y2godHlwZSkgeworICAgICAg ICBjYXNlIExOT05FOgorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIC8vIEdseXBoczoKKyAg ICAgICAgY2FzZSBESVNDOgorICAgICAgICAgICAgYyA9IFVDaGFyKDB4MjAyMik7CisgICAgICAg ICAgICBpdGVtID0gU3RyaW5nKCZjLCAxKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBj YXNlIENJUkNMRToKKyAgICAgICAgICAgIGMgPSBVQ2hhcigweDI1ZTYpOworICAgICAgICAgICAg aXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBT UVVBUkU6CisgICAgICAgICAgICBjID0gVUNoYXIoMHgyNWEwKTsKKyAgICAgICAgICAgIGl0ZW0g PSBTdHJpbmcoJmMsIDEpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgQVJNRU5J QU46CisgICAgICAgIGNhc2UgR0VPUkdJQU46CisgICAgICAgIGNhc2UgQ0pLX0lERU9HUkFQSElD OgorICAgICAgICBjYXNlIEhJUkFHQU5BOgorICAgICAgICBjYXNlIEtBVEFLQU5BOgorICAgICAg ICBjYXNlIEhJUkFHQU5BX0lST0hBOgorICAgICAgICBjYXNlIEtBVEFLQU5BX0lST0hBOgorICAg ICAgICBjYXNlIERFQ0lNQUxfTEVBRElOR19aRVJPOgorICAgICAgICAgICAgLy8gIyMjIHVuc3Vw cG9ydGVkLCB3ZSB1c2UgZGVjaW1hbCBpbnN0ZWFkCisgICAgICAgIGNhc2UgTERFQ0lNQUw6Cisg ICAgICAgICAgICBpdGVtID0gU3RyaW5nOjpudW1iZXIodmFsdWUpOworICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIC8vIEFsZ29yaXRtaWM6CisgICAgICAgIGNhc2UgTE9XRVJfUk9NQU46Cisg ICAgICAgICAgICBpdGVtID0gdG9Sb21hbih2YWx1ZSwgZmFsc2UpOworICAgICAgICAgICAgYnJl YWs7CisgICAgICAgIGNhc2UgVVBQRVJfUk9NQU46CisgICAgICAgICAgICBpdGVtID0gdG9Sb21h bih2YWx1ZSwgdHJ1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBMT1dFUl9H UkVFSzogeworICAgICAgICAgICAgaW50IG51bWJlciA9IHZhbHVlIC0gMTsKKyAgICAgICAgICAg IGludCBsID0gKG51bWJlciAlIDI0KTsKKyAgICAgICAgICAgIGlmIChsID4gMTYpCisgICAgICAg ICAgICAgICAgbCsrOyAvLyBTa2lwIEdSRUVLIFNNQUxMIExFVFRFUiBGSU5BTCBTSUdNQQorICAg ICAgICAgICAgYyA9IFVDaGFyKDk0NSArIGwpOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygm YywgMSk7CisgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkr KykKKyAgICAgICAgICAgICAgICBpdGVtICs9ICInIjsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICB9CisgICAgICAgIGNhc2UgSEVCUkVXOgorICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3 KHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgor ICAgICAgICBjYXNlIExPV0VSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3Ry aW5nKHZhbHVlLCAnYScpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJf QUxQSEE6CisgICAgICAgIGNhc2UgVVBQRVJfTEFUSU46CisgICAgICAgICAgICBpdGVtID0gdG9M ZXR0ZXJTdHJpbmcodmFsdWUsICdBJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVm YXVsdDoKKyAgICAgICAgICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAg ICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291 bnRlcjo6Y2FsY01pbk1heFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkpOwor CisgICAgaWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGNvdW50ZXJz OworICAgIGNvdW50ZXJzID0gIW1fY291bnRlci0+c2VwYXJhdG9yKCkuaXNOdWxsKCk7CisKKyAg ICBpZiAoIW1fY291bnRlck5vZGUgJiYgcGFyZW50KCktPnBhcmVudCgpKQorICAgICAgICBtX2Nv dW50ZXJOb2RlID0gcGFyZW50KCktPnBhcmVudCgpLT5maW5kQ291bnRlcihtX2NvdW50ZXItPmlk ZW50aWZpZXIoKSwgdHJ1ZSwgY291bnRlcnMpOworCisgICAgaW50IHZhbHVlID0gbV9jb3VudGVy Tm9kZS0+Y291bnQoKTsKKyAgICBpZiAobV9jb3VudGVyTm9kZS0+aXNSZXNldCgpKQorICAgICAg ICB2YWx1ZSA9IG1fY291bnRlck5vZGUtPnZhbHVlKCk7CisgICAgCisgICAgaW50IHRvdGFsID0g dmFsdWU7CisgICAgaWYgKG1fY291bnRlck5vZGUtPnBhcmVudCgpKQorICAgICAgICB0b3RhbCA9 IG1fY291bnRlck5vZGUtPnBhcmVudCgpLT50b3RhbCgpOworICAgIAorICAgIG1faXRlbSA9IHRv TGlzdFN0eWxlVHlwZSh2YWx1ZSwgdG90YWwsIChFTGlzdFN0eWxlVHlwZSltX2NvdW50ZXItPmxp c3RTdHlsZSgpKTsKKworICAgIGlmIChjb3VudGVycykgeworICAgICAgICBDb3VudGVyTm9kZSog Y291bnRlciA9IG1fY291bnRlck5vZGUtPnBhcmVudCgpOworICAgICAgICBib29sIGZpcnN0ID0g dHJ1ZTsKKyAgICAgICAgd2hpbGUgIChjb3VudGVyLT5wYXJlbnQoKSAmJiAoZmlyc3QgfHwgIShj b3VudGVyLT5pc1Jlc2V0KCkgJiYgY291bnRlci0+cGFyZW50KCktPmlzUm9vdCgpKSkpIHsKKyAg ICAgICAgICAgIHZhbHVlID0gY291bnRlci0+Y291bnQoKSA/IGNvdW50ZXItPmNvdW50KCkgOiAx OworICAgICAgICAgICAgdG90YWwgPSBjb3VudGVyLT5wYXJlbnQoKS0+dG90YWwoKTsKKyAgICAg ICAgICAgIG1faXRlbSA9IHRvTGlzdFN0eWxlVHlwZSh2YWx1ZSwgdG90YWwsIChFTGlzdFN0eWxl VHlwZSltX2NvdW50ZXItPmxpc3RTdHlsZSgpKSAKKyAgICAgICAgICAgICAgICArIG1fY291bnRl ci0+c2VwYXJhdG9yKCkgKyBtX2l0ZW07CisgICAgICAgICAgICBjb3VudGVyID0gY291bnRlci0+ cGFyZW50KCk7CisgICAgICAgICAgICBmaXJzdCA9IGZhbHNlOworICAgICAgICB9CisgICAgfQor CisgICAgc3RyID0gbmV3IFN0cmluZ0ltcGwoKHN0YXRpY19jYXN0PFN0cmluZz4obV9pdGVtKSku Y2hhcmFjdGVycygpLCBtX2l0ZW0ubGVuZ3RoKCkpOworICAgIAorICAgIFJlbmRlclRleHQ6OmNh bGNNaW5NYXhXaWR0aCgpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiByZW5k ZXJpbmcvQ291bnRlck5vZGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTm9k ZS5jcHAJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvQ291bnRlck5vZGUuY3BwCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDEzMCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBI VE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUg QWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChD KSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAw MjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJDb3VudGVyTm9kZS5oIgorCisjaW5jbHVkZSAiQ291bnRlclJlc2V0Tm9kZS5oIgorI2luY2x1 ZGUgIlJlbmRlckFyZW5hLmgiCisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworQ291bnRlck5vZGU6OkNvdW50ZXJOb2RlKFJlbmRlck9iamVjdCAqbykg Cit7CisgICAgbV9oYXNDb3VudGVycyA9IGZhbHNlOworICAgIG1faXNWaXN1YWwgPSBmYWxzZTsK KyAgICBtX3ZhbHVlID0gMDsKKyAgICBtX2NvdW50ID0gMDsKKyAgICBtX3BhcmVudCA9IDA7Cisg ICAgbV9wcmV2aW91cyA9IDA7CisgICAgbV9uZXh0ID0gMDsKKyAgICBtX3JlbmRlcmVyID0gbzsK K30KKworQ291bnRlck5vZGU6On5Db3VudGVyTm9kZSgpIHt9OworCit2b2lkKiBDb3VudGVyTm9k ZTo6b3BlcmF0b3IgbmV3KHNpemVfdCBzeiwgUmVuZGVyQXJlbmEqIHJlbmRlckFyZW5hKSB0aHJv dygpCit7CisgICAgcmV0dXJuIHJlbmRlckFyZW5hLT5hbGxvY2F0ZShzeik7Cit9CisKK3ZvaWQg Q291bnRlck5vZGU6OmRlc3Ryb3lDb3VudGVyTm9kZShSZW5kZXJBcmVuYSogYXJlbmEpCit7Cisg ICAgYXJlbmFEZWxldGUoYXJlbmEpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpvcGVyYXRvciBk ZWxldGUodm9pZCogcHRyLCBzaXplX3Qgc3opCit7CisgICAgLy8gU3Rhc2ggc2l6ZSB3aGVyZSBk ZXN0cm95IGNhbiBmaW5kIGl0LgorICAgICooc2l6ZV90ICopcHRyID0gc3o7Cit9CisKK3ZvaWQg Q291bnRlck5vZGU6OmFyZW5hRGVsZXRlKFJlbmRlckFyZW5hKiBhcmVuYSkKK3sKKyAgICBkZWxl dGUgdGhpczsKKyAgICAKKyAgICAvLyBSZWNvdmVyIHRoZSBzaXplIGxlZnQgdGhlcmUgZm9yIHVz IGJ5IG9wZXJhdG9yIGRlbGV0ZSBhbmQgZnJlZSB0aGUgbWVtb3J5LgorICAgIGFyZW5hLT5mcmVl KCooc2l6ZV90ICopdGhpcywgdGhpcyk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFm dGVyKENvdW50ZXJOb2RlKiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VSVChmYWxzZSk7Cit9 CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKikKK3sKKyAgICBB U1NFUlQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmUoKQoreworICAgIGlm IChtX3BhcmVudCkKKyAgICAgICAgbV9wYXJlbnQtPnJlbW92ZUNoaWxkKHRoaXMpOworICAgIGVs c2UgeworICAgICAgICBBU1NFUlQoaXNSZXNldCgpKTsKKyAgICAgICAgQVNTRVJUKCFmaXJzdENo aWxkKCkpOworICAgICAgICBBU1NFUlQoIWxhc3RDaGlsZCgpKTsKKyAgICB9Cit9CisKK3ZvaWQg Q291bnRlck5vZGU6OnNldEhhc0NvdW50ZXJzKCkKK3sKKyAgICBtX2hhc0NvdW50ZXJzID0gdHJ1 ZTsKKyAgICBpZiAocGFyZW50KCkpCisgICAgICAgIHBhcmVudCgpLT5zZXRIYXNDb3VudGVycygp OworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50KGJvb2wgZmlyc3QpCit7CisgICAgaW50 IG9sZF9jb3VudCA9IG1fY291bnQ7CisgICAgaWYgKG1fcHJldmlvdXMpCisgICAgICAgIG1fY291 bnQgPSBtX3ByZXZpb3VzLT5jb3VudCgpICsgbV92YWx1ZTsKKyAgICBlbHNlIHsKKyAgICAgICAg YXNzZXJ0KG1fcGFyZW50LT5maXJzdENoaWxkKCkgPT0gdGhpcyk7CisgICAgICAgIG1fY291bnQg PSBtX3BhcmVudC0+dmFsdWUoKSArIG1fdmFsdWU7CisgICAgfQorICAgIGlmIChvbGRfY291bnQg IT0gbV9jb3VudCAmJiAhZmlyc3QpCisgICAgICAgIHNldFNlbGZEaXJ0eSgpOworICAgIGlmIChv bGRfY291bnQgIT0gbV9jb3VudCB8fCBmaXJzdCkgeworICAgICAgICBpZiAobV9wYXJlbnQpCisg ICAgICAgICAgICBtX3BhcmVudC0+dXBkYXRlVG90YWwobV9jb3VudCk7CisgICAgICAgIGlmICht X25leHQpCisgICAgICAgICAgICBtX25leHQtPnJlY291bnQoKTsKKyAgICB9Cit9CisKK3ZvaWQg Q291bnRlck5vZGU6OnNldFNlbGZEaXJ0eSgpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV9p c1Zpc3VhbCkKKyAgICAgICAgbV9yZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNh bGMoKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlm IChtX3JlbmRlcmVyICYmIG1faXNWaXN1YWwgJiYgbV9oYXNDb3VudGVycykKKyAgICAgICAgbV9y ZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNhbGMoKTsKK30KKworfSAvLyBuYW1l c3BhY2UKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJTdHlsZS5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRl cmluZy9SZW5kZXJTdHlsZS5oCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5kZXJT dHlsZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwxMSArMzYsMTQgQEAKICAqLwogCiAjaW5jbHVk ZSAiQ29sb3IuaCIKKyNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIkNT U1ZhbHVlTGlzdC5oIgogI2luY2x1ZGUgIkRhdGFSZWYuaCIKICNpbmNsdWRlICJGb250LmgiCiAj aW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFJlY3QuaCIKICNpbmNsdWRl ICJMZW5ndGguaCIKKyNpbmNsdWRlICJQYWlyLmgiCiAjaW5jbHVkZSAiU2hhcmVkLmgiCiAjaW5j bHVkZSAiVGV4dERpcmVjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KQEAgLTU5LDkg KzYyLDExIEBACiAKIHVzaW5nIHN0ZDo6bWF4OwogCi1jbGFzcyBDU1NTdHlsZVNlbGVjdG9yOwog Y2xhc3MgQ2FjaGVkSW1hZ2U7CiBjbGFzcyBDYWNoZWRSZXNvdXJjZTsKK2NsYXNzIENTU1N0eWxl U2VsZWN0b3I7CitjbGFzcyBDU1NWYWx1ZUxpc3Q7CitjbGFzcyBQYWlyOwogY2xhc3MgUmVuZGVy QXJlbmE7CiBjbGFzcyBTaGFkb3dWYWx1ZTsKIGNsYXNzIFN0cmluZ0ltcGw7CkBAIC00MDcsOCAr NDEyLDggQEAKICAgICAgICAgcmV0dXJuICggY2xpcCA9PSBvLmNsaXAgJiYKICAgICAgICAgICAg ICAgICAgaGFzQ2xpcCA9PSBvLmhhc0NsaXAgJiYKICAgICAgICAgICAgICAgICAgY29sc3BhbiA9 PSBvLmNvbHNwYW4gJiYKLSAgICAgICAgICAgICAgICAgY291bnRlcl9pbmNyZW1lbnQgPT0gby5j b3VudGVyX2luY3JlbWVudCAmJgotICAgICAgICAgICAgICAgICBjb3VudGVyX3Jlc2V0ID09IG8u Y291bnRlcl9yZXNldCAmJgorICAgICAgICAgICAgICAgICBjb3VudGVySW5jcmVtZW50ID09IG8u Y291bnRlckluY3JlbWVudCAmJgorICAgICAgICAgICAgICAgICBjb3VudGVyUmVzZXQgPT0gby5j b3VudGVyUmVzZXQgJiYKICAgICAgICAgICAgICAgICAgdGV4dERlY29yYXRpb24gPT0gby50ZXh0 RGVjb3JhdGlvbik7CiAgICAgfQogICAgIGJvb2wgb3BlcmF0b3IhPSggY29uc3QgU3R5bGVWaXN1 YWxEYXRhICZvICkgY29uc3QgewpAQCAtNDIxLDggKzQyNiw4IEBACiAgICAgCiAgICAgc2hvcnQg Y29sc3BhbjsgLy8gZm9yIGh0bWwsIG5vdCBhIGNzczIgYXR0cmlidXRlCiAKLSAgICBzaG9ydCBj b3VudGVyX2luY3JlbWVudDsgLy9vaywgc28gdGhlc2UgYXJlIG5vdCB2aXN1YWwgbW9kZSBzcGVz aWZpYwotICAgIHNob3J0IGNvdW50ZXJfcmVzZXQ7ICAgICAvL2Nhbid0IGdvIHRvIGluaGVyaXRl ZCwgc2luY2UgdGhlc2UgYXJlIG5vdCBpbmhlcml0ZWQKKyAgICBzaG9ydCBjb3VudGVySW5jcmVt ZW50OyAvL29rLCBzbyB0aGVzZSBhcmUgbm90IHZpc3VhbCBtb2RlIHNwZXNpZmljCisgICAgc2hv cnQgY291bnRlclJlc2V0OyAgICAgLy9jYW4ndCBnbyB0byBpbmhlcml0ZWQsIHNpbmNlIHRoZXNl IGFyZSBub3QgaW5oZXJpdGVkCiAKIH07CiAKQEAgLTg3Miw2ICs4NzcsMjAgQEAKICAgICBDT05U RU5UX05PTkUsIENPTlRFTlRfT0JKRUNULCBDT05URU5UX1RFWFQsIENPTlRFTlRfQ09VTlRFUgog fTsKIAorc3RydWN0IENvdW50ZXJEYXRhIHsKKyAgICBDb3VudGVyRGF0YSgpIHt9CisgICAgQ291 bnRlckRhdGEoU3RyaW5nIGksIGludCBsLCBTdHJpbmcgc2VwKSA6aWRlbnQoaSksIGxzKGwpLCBz KHNlcCkge30KKyAgICB+Q291bnRlckRhdGEoKSB7fQorICAgIAorICAgIFN0cmluZyBpZGVudGlm aWVyKCkgeyByZXR1cm4gaWRlbnQ7IH0KKyAgICBpbnQgbGlzdFN0eWxlKCkgeyByZXR1cm4gbHM7 IH0KKyAgICBTdHJpbmcgc2VwYXJhdG9yKCkgeyByZXR1cm4gczsgfQorCisgICAgU3RyaW5nIGlk ZW50OworICAgIGludCBsczsKKyAgICBTdHJpbmcgczsKK307CisKIHN0cnVjdCBDb250ZW50RGF0 YSB7CiAgICAgQ29udGVudERhdGEoKSA6X2NvbnRlbnRUeXBlKENPTlRFTlRfTk9ORSksIF9uZXh0 Q29udGVudCgwKSB7fQogICAgIH5Db250ZW50RGF0YSgpOwpAQCAtODgxLDEzICs5MDAsMTQgQEAK IAogICAgIFN0cmluZ0ltcGwqIGNvbnRlbnRUZXh0KCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBD T05URU5UX1RFWFQpIHJldHVybiBfY29udGVudC50ZXh0OyByZXR1cm4gMDsgfQogICAgIENhY2hl ZFJlc291cmNlKiBjb250ZW50T2JqZWN0KCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5U X09CSkVDVCkgcmV0dXJuIF9jb250ZW50Lm9iamVjdDsgcmV0dXJuIDA7IH0KKyAgICBDb3VudGVy RGF0YSogY29udGVudENvdW50ZXIoKSB7IGlmIChjb250ZW50VHlwZSgpID09IENPTlRFTlRfQ09V TlRFUikgcmV0dXJuIF9jb250ZW50LmNvdW50ZXI7IHJldHVybiAwOyB9CiAgICAgCiAgICAgQ29u dGVudFR5cGUgX2NvbnRlbnRUeXBlOwogCiAgICAgdW5pb24gewogICAgICAgICBDYWNoZWRSZXNv dXJjZSogb2JqZWN0OwogICAgICAgICBTdHJpbmdJbXBsKiB0ZXh0OwotICAgICAgICAvLyBjb3Vu dGVycy4uLgorICAgICAgICBDb3VudGVyRGF0YSogY291bnRlcjsKICAgICB9IF9jb250ZW50IDsK IAogICAgIENvbnRlbnREYXRhKiBfbmV4dENvbnRlbnQ7CkBAIC0xMDQ1LDcgKzEwNjUsOSBAQAog ICAgIAogICAgIC8vIGFkZGVkIHRoaXMgaGVyZSwgc28gd2UgY2FuIGdldCByaWQgb2YgdGhlIHZw dHIgaW4gdGhpcyBjbGFzcy4KICAgICAvLyBtYWtlcyB1cCBmb3IgdGhlIHNhbWUgc2l6ZS4KLSAg ICBDb250ZW50RGF0YSAqY29udGVudDsKKyAgICBDb250ZW50RGF0YSogY29udGVudDsKKyAgICBD U1NWYWx1ZUxpc3QqIGNvdW50ZXJSZXNldExpc3Q7CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVy SW5jcmVtZW50TGlzdDsKIAogICAgIHVuc2lnbmVkIG1fcHNldWRvU3RhdGUgOiAzOyAvLyBQc2V1 ZG9TdGF0ZQogICAgIGJvb2wgbV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzIDogMTsKQEAg LTEyOTUsOCArMTMxNyw4IEBACiAgICAgRUVtcHR5Q2VsbCBlbXB0eUNlbGxzKCkgY29uc3QgeyBy ZXR1cm4gc3RhdGljX2Nhc3Q8RUVtcHR5Q2VsbD4oaW5oZXJpdGVkX2ZsYWdzLl9lbXB0eV9jZWxs cyk7IH0KICAgICBFQ2FwdGlvblNpZGUgY2FwdGlvblNpZGUoKSBjb25zdCB7IHJldHVybiBzdGF0 aWNfY2FzdDxFQ2FwdGlvblNpZGU+KGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlKTsgfQog Ci0gICAgc2hvcnQgY291bnRlckluY3JlbWVudCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291 bnRlcl9pbmNyZW1lbnQ7IH0KLSAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVy biB2aXN1YWwtPmNvdW50ZXJfcmVzZXQ7IH0KKyAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkg Y29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVySW5jcmVtZW50OyB9CisgICAgc2hvcnQgY291 bnRlclJlc2V0KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyUmVzZXQ7IH0KIAogICAg IEVMaXN0U3R5bGVUeXBlIGxpc3RTdHlsZVR5cGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2Fz dDxFTGlzdFN0eWxlVHlwZT4oaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUpOyB9CiAg ICAgQ2FjaGVkSW1hZ2UgKmxpc3RTdHlsZUltYWdlKCkgY29uc3QgeyByZXR1cm4gaW5oZXJpdGVk LT5zdHlsZV9pbWFnZTsgfQpAQCAtMTUwMSw4ICsxNTIzLDggQEAKICAgICB2b2lkIHNldENhcHRp b25TaWRlKEVDYXB0aW9uU2lkZSB2KSB7IGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlID0g djsgfQogCiAKLSAgICB2b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoc2hvcnQgdikgeyAgU0VUX1ZB Uih2aXN1YWwsY291bnRlcl9pbmNyZW1lbnQsdikgfQotICAgIHZvaWQgc2V0Q291bnRlclJlc2V0 KHNob3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJfcmVzZXQsdikgfQorICAgIHZvaWQg c2V0Q291bnRlckluY3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVySW5j cmVtZW50LHYpIH0KKyAgICB2b2lkIHNldENvdW50ZXJSZXNldChzaG9ydCB2KSB7ICBTRVRfVkFS KHZpc3VhbCxjb3VudGVyUmVzZXQsdikgfQogCiAgICAgdm9pZCBzZXRMaXN0U3R5bGVUeXBlKEVM aXN0U3R5bGVUeXBlIHYpIHsgaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUgPSB2OyB9 CiAgICAgdm9pZCBzZXRMaXN0U3R5bGVJbWFnZShDYWNoZWRJbWFnZSAqdikgeyAgU0VUX1ZBUihp bmhlcml0ZWQsc3R5bGVfaW1hZ2Usdil9CkBAIC0xNTk3LDcgKzE2MTksMjAgQEAKICAgICBib29s IGNvbnRlbnREYXRhRXF1aXZhbGVudChjb25zdCBSZW5kZXJTdHlsZSAqb3RoZXJTdHlsZSkgY29u c3Q7CiAgICAgdm9pZCBzZXRDb250ZW50KFN0cmluZ0ltcGwqIHMsIGJvb2wgYWRkID0gZmFsc2Up OwogICAgIHZvaWQgc2V0Q29udGVudChDYWNoZWRSZXNvdXJjZSogbywgYm9vbCBhZGQgPSBmYWxz ZSk7CisgICAgdm9pZCBzZXRDb250ZW50KENvdW50ZXJEYXRhKiBjLCBib29sIGFkZCA9IGZhbHNl KTsKIAorICAgIGJvb2wgY291bnRlckRhdGFFcXVpdmFsZW50KFJlbmRlclN0eWxlKiBvdGhlclN0 eWxlKTsKKyAgICB2b2lkIHNldENvdW50ZXJSZXNldChDU1NWYWx1ZUxpc3QqIHYpOworICAgIHZv aWQgc2V0Q291bnRlckluY3JlbWVudChDU1NWYWx1ZUxpc3QqIHYpOworICAgIHZvaWQgYWRkQ291 bnRlclJlc2V0KENTU1ByaW1pdGl2ZVZhbHVlKiBjKTsKKyAgICB2b2lkIGFkZENvdW50ZXJJbmNy ZW1lbnQoQ1NTUHJpbWl0aXZlVmFsdWUqIGMpOworICAgIGJvb2wgaGFzQ291bnRlclJlc2V0KGNv bnN0IFN0cmluZyYgYykgY29uc3Q7CisgICAgYm9vbCBoYXNDb3VudGVySW5jcmVtZW50KGNvbnN0 IFN0cmluZyYgYykgY29uc3Q7CisgICAgc2hvcnQgY291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYg YykgY29uc3Q7CisgICAgc2hvcnQgY291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmIGMpIGNv bnN0OworICAgIENTU1ZhbHVlTGlzdCogY291bnRlclJlc2V0VmFsdWVMaXN0KCkgeyByZXR1cm4g Y291bnRlclJlc2V0TGlzdDsgfQorICAgIENTU1ZhbHVlTGlzdCogY291bnRlckluY3JlbWVudFZh bHVlTGlzdCgpIHsgcmV0dXJuIGNvdW50ZXJJbmNyZW1lbnRMaXN0OyB9CisKICAgICBib29sIGlu aGVyaXRlZE5vdEVxdWFsKCBSZW5kZXJTdHlsZSAqb3RoZXIgKSBjb25zdDsKIAogICAgIC8vIFRo ZSBkaWZmZXJlbmNlIGJldHdlZW4gdHdvIHN0eWxlcy4gIFRoZSBmb2xsb3dpbmcgdmFsdWVzIGFy ZSB1c2VkOgpJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRl cmluZy9Db3VudGVyUmVzZXROb2RlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxNTQgQEAK Ky8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZv ciBLREUuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAo a2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwg SW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGlj ZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlz IGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1 bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVk IHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEg Y29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcg d2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3Jp dGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQ bGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQ291bnRlclJlc2V0Tm9kZS5oIgor CisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworQ291 bnRlclJlc2V0Tm9kZTo6Q291bnRlclJlc2V0Tm9kZShSZW5kZXJPYmplY3QqIG8pIDogQ291bnRl ck5vZGUobyksIG1fdG90YWwoMCksIG1fZmlyc3QoMCksIG1fbGFzdCgwKSB7fQorQ291bnRlclJl c2V0Tm9kZTo6fkNvdW50ZXJSZXNldE5vZGUoKSB7fTsKKwordm9pZCBDb3VudGVyUmVzZXROb2Rl OjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGls ZCkKK3sKKyAgICBBU1NFUlQobmV3Q2hpbGQpOworICAgIEFTU0VSVCghcmVmQ2hpbGQgfHwgcmVm Q2hpbGQtPnBhcmVudCgpID09IHRoaXMpOworCisgICAgbmV3Q2hpbGQtPm1fcGFyZW50ID0gdGhp czsKKyAgICBuZXdDaGlsZC0+bV9wcmV2aW91cyA9IHJlZkNoaWxkOworCisgICAgaWYgKHJlZkNo aWxkKSB7CisgICAgICAgIG5ld0NoaWxkLT5tX25leHQgPSByZWZDaGlsZC0+bV9uZXh0OworICAg ICAgICByZWZDaGlsZC0+bV9uZXh0ID0gbmV3Q2hpbGQ7CisgICAgfSBlbHNlIHsKKyAgICAgICAg bmV3Q2hpbGQtPm1fbmV4dCA9IG1fZmlyc3Q7CisgICAgICAgIG1fZmlyc3QgPSBuZXdDaGlsZDsK KyAgICB9CisKKyAgICBpZiAobmV3Q2hpbGQtPm1fbmV4dCkgeworICAgICAgICBhc3NlcnQobmV3 Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9PSByZWZDaGlsZCk7CisgICAgICAgIG5ld0NoaWxk LT5tX25leHQtPm1fcHJldmlvdXMgPSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAgICAgICBh c3NlcnQgKG1fbGFzdCA9PSByZWZDaGlsZCk7CisgICAgICAgIG1fbGFzdCA9IG5ld0NoaWxkOwor ICAgIH0KKworICAgIG5ld0NoaWxkLT5yZWNvdW50KHRydWUpOworfQorCit2b2lkIENvdW50ZXJS ZXNldE5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKiBvbGRDaGlsZCkKK3sKKyAgICBBU1NF UlQob2xkQ2hpbGQpOworCisgICAgQ291bnRlck5vZGUqIG5leHQgPSBvbGRDaGlsZC0+bV9uZXh0 OworICAgIENvdW50ZXJOb2RlKiBwcmV2ID0gb2xkQ2hpbGQtPm1fcHJldmlvdXM7CisKKyAgICBp ZiAob2xkQ2hpbGQtPmZpcnN0Q2hpbGQoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogZmlyc3Qg PSBvbGRDaGlsZC0+Zmlyc3RDaGlsZCgpOworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IG9s ZENoaWxkLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgaWYgKHByZXYpIHsKKyAgICAgICAgICAgIHBy ZXYtPm1fbmV4dCA9IGZpcnN0OworICAgICAgICAgICAgZmlyc3QtPm1fcHJldmlvdXMgPSBwcmV2 OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIG1fZmlyc3QgPSBmaXJzdDsKKworICAgICAg ICBpZiAobmV4dCkgeworICAgICAgICAgICAgbmV4dC0+bV9wcmV2aW91cyA9IGxhc3Q7CisgICAg ICAgICAgICBsYXN0LT5tX25leHQgPSBuZXh0OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAg IG1fbGFzdCA9IGxhc3Q7CisKKyAgICAgICAgbmV4dCA9IGZpcnN0OworICAgICAgICB3aGlsZSAo bmV4dCkgeworICAgICAgICAgICAgbmV4dC0+bV9wYXJlbnQgPSB0aGlzOworICAgICAgICAgICAg bmV4dCA9IG5leHQtPm1fbmV4dDsKKyAgICAgICAgfQorCisgICAgICAgIGZpcnN0LT5yZWNvdW50 KHRydWUpOworICAgIH0gZWxzZSB7CisgICAgICAgIGlmIChwcmV2KSAKKyAgICAgICAgICAgIHBy ZXYtPm1fbmV4dCA9IG5leHQ7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgYXNzZXJ0ICgg bV9maXJzdCA9PSBvbGRDaGlsZCApOworICAgICAgICAgICAgbV9maXJzdCA9IG5leHQ7CisgICAg ICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQorICAgICAgICAgICAgbmV4dC0+bV9w cmV2aW91cyA9IHByZXY7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgYXNzZXJ0ICggbV9s YXN0ID09IG9sZENoaWxkICk7CisgICAgICAgICAgICBtX2xhc3QgPSBwcmV2OworICAgICAgICB9 CisgICAgICAgIAorICAgICAgICBpZiAobmV4dCkKKyAgICAgICAgICAgIG5leHQtPnJlY291bnQo KTsKKyAgICB9CisKKworICAgIG9sZENoaWxkLT5tX25leHQgPSAwOworICAgIG9sZENoaWxkLT5t X3ByZXZpb3VzID0gMDsKKyAgICBvbGRDaGlsZC0+bV9wYXJlbnQgPSAwOworfQorCit2b2lkIENv dW50ZXJSZXNldE5vZGU6OnJlY291bnQoYm9vbCBmaXJzdCkKK3sKKyAgICBpbnQgb2xkX2NvdW50 ID0gbV9jb3VudDsKKyAgICBpZiAobV9wcmV2aW91cykKKyAgICAgICAgbV9jb3VudCA9IG1fcHJl dmlvdXMtPmNvdW50KCk7CisgICAgZWxzZSBpZiAobV9wYXJlbnQpCisgICAgICAgIG1fY291bnQg PSBtX3BhcmVudC0+dmFsdWUoKTsKKyAgICBlbHNlCisgICAgICAgIG1fY291bnQgPSAwOworCisg ICAgdXBkYXRlVG90YWwobV92YWx1ZSk7CisgICAgaWYgKCFmaXJzdCkKKyAgICAgICAgc2V0U2Vs ZkRpcnR5KCk7CisgICAgaWYgKG1fbmV4dCAmJiAoZmlyc3QgfHwgbV9jb3VudCAhPSBvbGRfY291 bnQpKQorICAgICAgICBtX25leHQtPnJlY291bnQoKTsKK30KKwordm9pZCBDb3VudGVyUmVzZXRO b2RlOjpzZXRTZWxmRGlydHkoKQoreworICAgIHNldFBhcmVudERpcnR5KCk7Cit9CisKK3ZvaWQg Q291bnRlclJlc2V0Tm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlmIChoYXNDb3VudGVy cygpKSB7CisgICAgICAgIGlmIChtX3JlbmRlcmVyICYmIG1faXNWaXN1YWwpCisgICAgICAgICAg ICBtX3JlbmRlcmVyLT5zZXROZWVkc0xheW91dEFuZE1pbk1heFJlY2FsYygpOworICAgICAgICBD b3VudGVyTm9kZSogbiA9IGZpcnN0Q2hpbGQoKTsKKyAgICAgICAgZm9yKDsgbjsgbiA9IG4tPm5l eHRTaWJsaW5nKCkpCisgICAgICAgICAgICBuLT5zZXRQYXJlbnREaXJ0eSgpOworICAgIH0KK30K Kwordm9pZCBDb3VudGVyUmVzZXROb2RlOjp1cGRhdGVUb3RhbChpbnQgdmFsdWUpCit7CisgICAg aWYgKHZhbHVlID4gbV90b3RhbCkKKyAgICAgICAgbV90b3RhbCA9IHZhbHVlOworfQorCit9IC8v IG5hbWVzcGFjZQpJbmRleDogcmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gcmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysg cmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQsNiArNCw3 IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkgTGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykKICAq ICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBLb2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykKICAq ICAgICAgICAgICAoQykgMjAwMCBEaXJrIE11ZWxsZXIgKG11ZWxsZXJAa2RlLm9yZykKKyAqICAg ICAgICAgICAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20p CiAgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDQsIDIwMDUsIDIwMDYgQXBwbGUgQ29tcHV0ZXIs IEluYy4KICAqIENvcHlyaWdodCAoQykgMjAwNiBBbmRyZXcgV2VsbGluZ3RvbiAocHJvdG9uQHdp cmV0YXBwZWQubmV0KQogICoKQEAgLTI4LDYgKzI5LDcgQEAKICNpbmNsdWRlICJSZW5kZXJDb250 YWluZXIuaCIKIAogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCisjaW5jbHVkZSAiUmVuZGVyQ291 bnRlci5oIgogI2luY2x1ZGUgIlJlbmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFi bGUuaCIKICNpbmNsdWRlICJSZW5kZXJUZXh0RnJhZ21lbnQuaCIKQEAgLTI5Nyw2ICsyOTksOCBA QAogICAgICAgICAvLyBpbmxpbmUgc2hvdWxkIGJlIG11dGF0ZWQgdG8gSU5MSU5FLgogICAgICAg ICBwc2V1ZG8tPnNldERpc3BsYXkoSU5MSU5FKTsKICAgICAKKyAgICBSZW5kZXJTdHlsZSogc3R5 bGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7CisgICAgc3R5bGUtPmluaGVy aXRGcm9tKHBzZXVkbyk7CiAgICAgaWYgKG9sZENvbnRlbnRQcmVzZW50KSB7CiAgICAgICAgIGlm IChjaGlsZCAmJiBjaGlsZC0+c3R5bGUoKS0+c3R5bGVUeXBlKCkgPT0gdHlwZSkgewogICAgICAg ICAgICAgLy8gV2UgaGF2ZSBnZW5lcmF0ZWQgY29udGVudCBwcmVzZW50IHN0aWxsLiAgV2Ugd2Fu dCB0byB3YWxrIHRoaXMgY29udGVudCBhbmQgdXBkYXRlIG91cgpAQCAtMzA5LDEzICszMTMsMTAg QEAKICAgICAgICAgICAgICAgICBpZiAoZ2VuQ2hpbGQtPmlzVGV4dCgpKQogICAgICAgICAgICAg ICAgICAgICAvLyBHZW5lcmF0ZWQgdGV4dCBjb250ZW50IGlzIGEgY2hpbGQgd2hvc2Ugc3R5bGUg YWxzbyBuZWVkcyB0byBiZSBzZXQgdG8gdGhlIHBzZXVkbwogICAgICAgICAgICAgICAgICAgICAv LyBzdHlsZS4KLSAgICAgICAgICAgICAgICAgICAgZ2VuQ2hpbGQtPnNldFN0eWxlKHBzZXVkbyk7 Ci0gICAgICAgICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGdlbkNoaWxkLT5z ZXRTdHlsZShzdHlsZSk7CisgICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAg ICAvLyBJbWFnZXMgZ2V0IGFuIGVtcHR5IHN0eWxlIHRoYXQgaW5oZXJpdHMgZnJvbSB0aGUgcHNl dWRvLgotICAgICAgICAgICAgICAgICAgICBSZW5kZXJTdHlsZSogc3R5bGUgPSBuZXcgKHJlbmRl ckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7Ci0gICAgICAgICAgICAgICAgICAgIHN0eWxlLT5pbmhl cml0RnJvbShwc2V1ZG8pOwogICAgICAgICAgICAgICAgICAgICBnZW5DaGlsZC0+c2V0U3R5bGUo c3R5bGUpOwotICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAg ICAgICByZXR1cm47IC8vIFdlJ3ZlIHVwZGF0ZWQgdGhlIGdlbmVyYXRlZCBjb250ZW50LiBUaGF0 J3MgYWxsIHdlIG5lZWRlZCB0byBkby4KQEAgLTMzNCwyMCArMzM1LDIwIEBACiAgICAgICAgIGlm ICghcHNldWRvQ29udGFpbmVyKQogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyID0gUmVuZGVy Rmxvdzo6Y3JlYXRlQW5vbnltb3VzRmxvdyhkb2N1bWVudCgpLCBwc2V1ZG8pOyAvKiBhbm9ueW1v dXMgYm94ICovCiAgICAgICAgIAotICAgICAgICBpZiAoY29udGVudERhdGEtPmNvbnRlbnRUeXBl KCkgPT0gQ09OVEVOVF9URVhUKQotICAgICAgICB7CisgICAgICAgIGlmIChjb250ZW50RGF0YS0+ Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHsKICAgICAgICAgICAgIFJlbmRlclRleHQq IHQgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclRleHRGcmFnbWVudChkb2N1bWVudCgpIC8q YW5vbnltb3VzIG9iamVjdCAqLywgY29udGVudERhdGEtPmNvbnRlbnRUZXh0KCkpOwotICAgICAg ICAgICAgdC0+c2V0U3R5bGUocHNldWRvKTsKKyAgICAgICAgICAgIHQtPnNldFN0eWxlKHN0eWxl KTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQodCk7Ci0gICAgICAgIH0K LSAgICAgICAgZWxzZSBpZiAoY29udGVudERhdGEtPmNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9P QkpFQ1QpCi0gICAgICAgIHsKKyAgICAgICAgfSBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVu dFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkgewogICAgICAgICAgICAgUmVuZGVySW1hZ2UqIGlt ZyA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVySW1hZ2UoZG9jdW1lbnQoKSk7IC8qIEFub255 bW91cyBvYmplY3QgKi8KLSAgICAgICAgICAgIFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVu ZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsKLSAgICAgICAgICAgIHN0eWxlLT5pbmhlcml0RnJv bShwc2V1ZG8pOwogICAgICAgICAgICAgaW1nLT5zZXRTdHlsZShzdHlsZSk7CiAgICAgICAgICAg ICBpbWctPnNldENvbnRlbnRPYmplY3QoY29udGVudERhdGEtPmNvbnRlbnRPYmplY3QoKSk7CiAg ICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKGltZyk7CisgICAgICAgIH0gZWxz ZSBpZiAoY29udGVudERhdGEtPl9jb250ZW50VHlwZSA9PSBDT05URU5UX0NPVU5URVIpIHsKKyAg ICAgICAgICAgIFJlbmRlckNvdW50ZXIqIGMgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlckNv dW50ZXIoZWxlbWVudCgpLCBjb250ZW50RGF0YS0+Y29udGVudENvdW50ZXIoKSk7CisgICAgICAg ICAgICBjLT5zZXRJc0Fub255bW91cyh0cnVlKTsKKyAgICAgICAgICAgIGMtPnNldFN0eWxlKHN0 eWxlKTsKKyAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQoYyk7CiAgICAgICAg IH0KICAgICB9CiAKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTm9kZS5oCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IHJlbmRlcmluZy9Db3VudGVyTm9kZS5oCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50 ZXJOb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsOTcgQEAKKy8qCisgKiBUaGlzIGZpbGUg aXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisgKgorICogQ29w eXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkK KyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwg UHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3Vu ZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJp YnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VU IEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7 IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwK KyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZuZGVmIENvdW50ZXJf Tm9kZV9oXworI2RlZmluZSBDb3VudGVyX05vZGVfaF8KKworI2luY2x1ZGUgIlJlbmRlck9iamVj dC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50ZXJSZXNldE5vZGU7Citj bGFzcyBSZW5kZXJBcmVuYTsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3VudGVyLXRy ZWUgdGhhdCBpcyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9v a3VwLAorLy8gYW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9kZXMgYXJl IGFkZGVkIG9yIHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRlci1yZXNl dCBhbmQgcm9vdCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJlZSBwYXJl bnRzCisvLyBhcmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVtZW50YXRp b24gb2YgY291bnRlci1pbmNyZW1lbnQgYW5kIGNvdW50ZXItY29udGVudAorY2xhc3MgQ291bnRl ck5vZGUgeworcHVibGljOgorICAgIENvdW50ZXJOb2RlKFJlbmRlck9iamVjdCopOworICAgIHZp cnR1YWwgfkNvdW50ZXJOb2RlKCk7CisgICAgdmlydHVhbCB2b2lkIGRlc3Ryb3lDb3VudGVyTm9k ZShSZW5kZXJBcmVuYSopOworICAgIAorICAgIC8vIE92ZXJsb2FkZWQgbmV3IG9wZXJhdG9yLiAg RGVyaXZlZCBjbGFzc2VzIG11c3Qgb3ZlcnJpZGUgb3BlcmF0b3IgbmV3CisgICAgLy8gaW4gb3Jk ZXIgdG8gYWxsb2NhdGUgb3V0IG9mIHRoZSBSZW5kZXJBcmVuYS4KKyAgICB2b2lkKiBvcGVyYXRv ciBuZXcoc2l6ZV90IHN6LCBSZW5kZXJBcmVuYSogcmVuZGVyQXJlbmEpIHRocm93KCk7CisgICAg CisgICAgLy8gT3ZlcnJpZGRlbiB0byBwcmV2ZW50IHRoZSBub3JtYWwgZGVsZXRlIGZyb20gYmVp bmcgY2FsbGVkLgorICAgIHZvaWQgb3BlcmF0b3IgZGVsZXRlKHZvaWQqIHB0ciwgc2l6ZV90IHN6 KTsKKworICAgIENvdW50ZXJSZXNldE5vZGUqIHBhcmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fcGFy ZW50OyB9CisgICAgQ291bnRlck5vZGUqIHByZXZpb3VzU2libGluZygpIGNvbnN0IHsgcmV0dXJu IG1fcHJldmlvdXM7IH0KKyAgICBDb3VudGVyTm9kZSogbmV4dFNpYmxpbmcoKSBjb25zdCB7IHJl dHVybiBtX25leHQ7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBmaXJzdENoaWxkKCkgY29u c3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIGxhc3RDaGlsZCgpIGNv bnN0IHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIHZvaWQgaW5zZXJ0QWZ0ZXIgKENvdW50ZXJO b2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKTsKKyAgICB2aXJ0dWFsIHZvaWQg cmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGlsZCk7CisgICAgLy8gQ29udmVuaWVudCBz ZWxmLXJlZmVyaW5nIHZlcnNpb24gb2YgdGhlIGFib3ZlCisgICAgdm9pZCByZW1vdmUoKTsKKwor ICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFsdWU7IH0KKyAgICB2b2lkIHNldFZh bHVlKHNob3J0IHYpIHsgbV92YWx1ZSA9IHY7IH0KKyAgICBpbnQgY291bnQoKSBjb25zdCB7IHJl dHVybiBtX2NvdW50OyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNSZXNldCgpIHsgcmV0dXJuIGZh bHNlOyB9CisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBmaXJzdCA9IGZhbHNlKTsKKyAg ICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisgICAgdmlydHVhbCB2b2lkIHNldFBhcmVu dERpcnR5KCk7CisKKyAgICBib29sIGhhc0NvdW50ZXJzKCkgY29uc3QgeyByZXR1cm4gbV9oYXND b3VudGVyczsgfTsKKyAgICBib29sIGlzVmlzdWFsKCkgY29uc3QgeyByZXR1cm4gbV9pc1Zpc3Vh bDsgfTsKKyAgICB2b2lkIHNldEhhc0NvdW50ZXJzKCk7CisgICAgdm9pZCBzZXRJc1Zpc3VhbCgp IHsgbV9pc1Zpc3VhbCA9IHRydWU7IH07CisgICAgYm9vbCBpc1Jvb3QoKSB7IHJldHVybiBtX3Jl bmRlcmVyICYmIG1fcmVuZGVyZXItPmlzUm9vdCgpOyB9OworCisgICAgdm9pZCBzZXRSZW5kZXJl cihSZW5kZXJPYmplY3QqIG8pIHsgbV9yZW5kZXJlciA9IG87IH07CisgICAgUmVuZGVyT2JqZWN0 KiByZW5kZXJlcigpIGNvbnN0IHsgcmV0dXJuIG1fcmVuZGVyZXI7IH07CisKKyAgICBmcmllbmQg Y2xhc3MgQ291bnRlclJlc2V0Tm9kZTsKK3Byb3RlY3RlZDoKKyAgICBib29sIG1faGFzQ291bnRl cnMgOiAxOworICAgIGJvb2wgbV9pc1Zpc3VhbCA6IDE7CisgICAgc2hvcnQgbV92YWx1ZTsKKyAg ICBzaG9ydCBtX2NvdW50OworICAgIENvdW50ZXJSZXNldE5vZGUqIG1fcGFyZW50OworICAgIENv dW50ZXJOb2RlKiBtX3ByZXZpb3VzOworICAgIENvdW50ZXJOb2RlKiBtX25leHQ7CisgICAgUmVu ZGVyT2JqZWN0KiBtX3JlbmRlcmVyOworICAgIAorcHJpdmF0ZToKKyAgICB2b2lkIGFyZW5hRGVs ZXRlKFJlbmRlckFyZW5hKiBhcmVuYSk7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBDb3VudGVyTm9kZV9oCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJTdHlsZS5jcHAJKHJldmlzaW9uIDE2NTI4 KQorKysgcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTAsOCAr OTAsOCBAQAogICAgIDogaGFzQ2xpcChmYWxzZSkKICAgICAsIHRleHREZWNvcmF0aW9uKFJlbmRl clN0eWxlOjppbml0aWFsVGV4dERlY29yYXRpb24oKSkKICAgICAsIGNvbHNwYW4oMSkKLSAgICAs IGNvdW50ZXJfaW5jcmVtZW50KDApCi0gICAgLCBjb3VudGVyX3Jlc2V0KDApCisgICAgLCBjb3Vu dGVySW5jcmVtZW50KDApCisgICAgLCBjb3VudGVyUmVzZXQoMCkKIHsKIH0KIApAQCAtMTA1LDgg KzEwNSw4IEBACiAgICAgLCBoYXNDbGlwKG8uaGFzQ2xpcCkKICAgICAsIHRleHREZWNvcmF0aW9u KG8udGV4dERlY29yYXRpb24pCiAgICAgLCBjb2xzcGFuKG8uY29sc3BhbikKLSAgICAsIGNvdW50 ZXJfaW5jcmVtZW50KG8uY291bnRlcl9pbmNyZW1lbnQpCi0gICAgLCBjb3VudGVyX3Jlc2V0KG8u Y291bnRlcl9yZXNldCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnQoby5jb3VudGVySW5jcmVtZW50 KQorICAgICwgY291bnRlclJlc2V0KG8uY291bnRlclJlc2V0KQogewogfQogCkBAIC01NzgsNiAr NTc4LDExIEBACiAgICAgfQogICAgIGRlbGV0ZSBjb250ZW50OwogICAgIAorICAgIGlmIChjb3Vu dGVyUmVzZXRMaXN0KQorICAgICAgICBjb3VudGVyUmVzZXRMaXN0LT5kZXJlZigpOworICAgIGlm IChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgY291bnRlckluY3JlbWVudExpc3QtPmRl cmVmKCk7CisgICAgCiAgICAgZGVsZXRlIHRoaXM7CiAgICAgCiAgICAgLy8gUmVjb3ZlciB0aGUg c2l6ZSBsZWZ0IHRoZXJlIGZvciB1cyBieSBvcGVyYXRvciBkZWxldGUgYW5kIGZyZWUgdGhlIG1l bW9yeS4KQEAgLTYwMSw2ICs2MDYsOCBAQAogICAgICwgaW5oZXJpdGVkKGRlZmF1bHRTdHlsZS0+ aW5oZXJpdGVkKQogICAgICwgcHNldWRvU3R5bGUoMCkKICAgICAsIGNvbnRlbnQoMCkKKyAgICAs IGNvdW50ZXJSZXNldExpc3QoMCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KDApCiAgICAg LCBtX3BzZXVkb1N0YXRlKFBzZXVkb1Vua25vd24pCiAgICAgLCBtX2FmZmVjdGVkQnlBdHRyaWJ1 dGVTZWxlY3RvcnMoZmFsc2UpCiAgICAgLCBtX3VuaXF1ZShmYWxzZSkKQEAgLTYxNSw2ICs2MjIs OCBAQAogUmVuZGVyU3R5bGU6OlJlbmRlclN0eWxlKGJvb2wpCiAgICAgOiBwc2V1ZG9TdHlsZSgw KQogICAgICwgY29udGVudCgwKQorICAgICwgY291bnRlclJlc2V0TGlzdCgwKQorICAgICwgY291 bnRlckluY3JlbWVudExpc3QoMCkKICAgICAsIG1fcHNldWRvU3RhdGUoUHNldWRvVW5rbm93bikK ICAgICAsIG1fYWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyhmYWxzZSkKICAgICAsIG1fdW5p cXVlKGZhbHNlKQpAQCAtNjQ5LDYgKzY1OCw4IEBACiAgICAgLCBpbmhlcml0ZWQoby5pbmhlcml0 ZWQpCiAgICAgLCBwc2V1ZG9TdHlsZSgwKQogICAgICwgY29udGVudChvLmNvbnRlbnQpCisgICAg LCBjb3VudGVyUmVzZXRMaXN0KG8uY291bnRlclJlc2V0TGlzdCkKKyAgICAsIGNvdW50ZXJJbmNy ZW1lbnRMaXN0KG8uY291bnRlckluY3JlbWVudExpc3QpCiAgICAgLCBtX3BzZXVkb1N0YXRlKG8u bV9wc2V1ZG9TdGF0ZSkKICAgICAsIG1fYWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyhmYWxz ZSkKICAgICAsIG1fdW5pcXVlKGZhbHNlKQpAQCAtODM4LDggKzg0OSw4IEBACiAgICAgICAgICEo bm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZyA9PSBvdGhlci0+bm9uaW5oZXJpdGVkX2ZsYWdz Ll9mbG9hdGluZykgfHwKICAgICAgICAgIShub25pbmhlcml0ZWRfZmxhZ3MuX29yaWdpbmFsRGlz cGxheSA9PSBvdGhlci0+bm9uaW5oZXJpdGVkX2ZsYWdzLl9vcmlnaW5hbERpc3BsYXkpIHx8CiAg ICAgICAgICB2aXN1YWwtPmNvbHNwYW4gIT0gb3RoZXItPnZpc3VhbC0+Y29sc3BhbiB8fAotICAg ICAgICAgdmlzdWFsLT5jb3VudGVyX2luY3JlbWVudCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVy X2luY3JlbWVudCB8fAotICAgICAgICAgdmlzdWFsLT5jb3VudGVyX3Jlc2V0ICE9IG90aGVyLT52 aXN1YWwtPmNvdW50ZXJfcmVzZXQgfHwKKyAgICAgICAgIHZpc3VhbC0+Y291bnRlckluY3JlbWVu dCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVySW5jcmVtZW50IHx8CisgICAgICAgICB2aXN1YWwt PmNvdW50ZXJSZXNldCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVyUmVzZXQgfHwKICAgICAgICAg IGNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cgIT0gb3RoZXItPmNzczNOb25Jbmhl cml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cgfHwKICAgICAgICAgIChjc3MzSW5oZXJpdGVkRGF0YS0+ dGV4dFNlY3VyaXR5ICE9IG90aGVyLT5jc3MzSW5oZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5KSkK ICAgICAgICAgcmV0dXJuIExheW91dDsKQEAgLTEwODAsNiArMTA5MSwzMiBAQAogICAgIG5ld0Nv bnRlbnREYXRhLT5fY29udGVudFR5cGUgPSBDT05URU5UX1RFWFQ7CiB9CiAKK3ZvaWQgUmVuZGVy U3R5bGU6OnNldENvbnRlbnQoQ291bnRlckRhdGEqIGMsIGJvb2wgYWRkKQoreworICAgIGlmICgh YykKKyAgICAgICAgcmV0dXJuOworCisgICAgQ29udGVudERhdGEqIGxhc3RDb250ZW50ID0gY29u dGVudDsKKyAgICB3aGlsZSAobGFzdENvbnRlbnQgJiYgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVu dCkKKyAgICAgICAgbGFzdENvbnRlbnQgPSBsYXN0Q29udGVudC0+X25leHRDb250ZW50OworCisg ICAgYm9vbCByZXVzZUNvbnRlbnQgPSAhYWRkOworICAgIENvbnRlbnREYXRhKiBuZXdDb250ZW50 RGF0YSA9IDA7CisgICAgaWYgKHJldXNlQ29udGVudCAmJiBjb250ZW50KSB7CisgICAgICAgIGNv bnRlbnQtPmNsZWFyQ29udGVudCgpOworICAgICAgICBuZXdDb250ZW50RGF0YSA9IGNvbnRlbnQ7 CisgICAgfSBlbHNlCisgICAgICAgIG5ld0NvbnRlbnREYXRhID0gbmV3IENvbnRlbnREYXRhOwor CisgICAgaWYgKGxhc3RDb250ZW50ICYmICFyZXVzZUNvbnRlbnQpCisgICAgICAgIGxhc3RDb250 ZW50LT5fbmV4dENvbnRlbnQgPSBuZXdDb250ZW50RGF0YTsKKyAgICBlbHNlCisgICAgICAgIGNv bnRlbnQgPSBuZXdDb250ZW50RGF0YTsKKworICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudC5j b3VudGVyID0gYzsKKyAgICBuZXdDb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID0gQ09OVEVOVF9D T1VOVEVSOworfQorCiBDb250ZW50RGF0YTo6fkNvbnRlbnREYXRhKCkKIHsKICAgICBjbGVhckNv bnRlbnQoKTsKQEAgLTEwOTgsNiArMTEzNSwxMCBAQAogICAgICAgICBjYXNlIENPTlRFTlRfVEVY VDoKICAgICAgICAgICAgIF9jb250ZW50LnRleHQtPmRlcmVmKCk7CiAgICAgICAgICAgICBfY29u dGVudC50ZXh0ID0gMDsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIENPTlRFTlRf Q09VTlRFUjoKKyAgICAgICAgICAgIF9jb250ZW50LmNvdW50ZXIgPSAwOworICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgICA7CiAgICAgfQpAQCAtMTE4NSw2 ICsxMjI2LDEyMiBAQAogICAgIHJldHVybiB4ID09IG8ueCAmJiB5ID09IG8ueSAmJiBibHVyID09 IG8uYmx1ciAmJiBjb2xvciA9PSBvLmNvbG9yOwogfQogCitib29sIFJlbmRlclN0eWxlOjpjb3Vu dGVyRGF0YUVxdWl2YWxlbnQoUmVuZGVyU3R5bGUqIG90aGVyU3R5bGUpCit7CisgICAgLy8gIyMj IFNob3VsZCB3ZSBjb21wYXJlIGNvbnRlbnQ/CisgICAgcmV0dXJuIGNvdW50ZXJSZXNldExpc3Qg PT0gb3RoZXJTdHlsZS0+Y291bnRlclJlc2V0TGlzdCAmJgorICAgICAgICAgICBjb3VudGVySW5j cmVtZW50TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVySW5jcmVtZW50TGlzdDsKK30KKworc3Rh dGljIGJvb2wgaGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGMsIENTU1ZhbHVlTGlzdCogbCkKK3sK KyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47 IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0aXZlVmFsdWUgPSBzdGF0 aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0oaSkpOworICAgICAgICBQYWlyKiBw YWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgpOworICAgICAgICBDU1NQcmltaXRp dmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KHBh aXItPmZpcnN0KCkpOworICAgICAgICBBU1NFUlQocGFpciAmJiBjb3VudGVyTmFtZSk7CisgICAg ICAgIGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBjKQorICAgICAgICAgICAg cmV0dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5kZXJT dHlsZTo6aGFzQ291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgYykgY29uc3QKK3sKKyAgICBpZiAo Y291bnRlclJlc2V0TGlzdCkKKyAgICAgICAgcmV0dXJuIGhhc0NvdW50ZXIoYywgY291bnRlclJl c2V0TGlzdCk7CisgICAgZWxzZQorICAgICAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgUmVu ZGVyU3R5bGU6Omhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjKSBjb25zdAorewor ICAgIGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIGhhc0NvdW50ZXIo YywgY291bnRlckluY3JlbWVudExpc3QpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZhbHNl OworfQorCitzdGF0aWMgc2hvcnQgcmVhZENvdW50ZXIoY29uc3QgU3RyaW5nJiBjLCBDU1NWYWx1 ZUxpc3QqIGwsIGJvb2wgaXNSZXNldCkKK3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7Cisg ICAgc2hvcnQgdG90YWwgPSAwOworICAgIAorICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBp KyspIHsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIHByaW1pdGl2ZVZhbHVlID0gc3RhdGlj X2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihsLT5pdGVtKGkpKTsKKyAgICAgICAgUGFpciogcGFp ciA9IHByaW1pdGl2ZVZhbHVlLT5nZXRQYWlyVmFsdWUoKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZl VmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWly LT5maXJzdCgpKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJWYWx1ZSA9IHN0 YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4ocGFpci0+c2Vjb25kKCkpOworICAgICAgICBB U1NFUlQocGFpciAmJiBjb3VudGVyTmFtZSAmJiBjb3VudGVyVmFsdWUpOworCisgICAgICAgIGlm IChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBjKSB7CisgICAgICAgICAgICB0b3Rh bCArPSAoc2hvcnQpY291bnRlclZhbHVlLT5nZXRGbG9hdFZhbHVlKCk7CisgICAgICAgICAgICBp ZiAoaXNSZXNldCkKKyAgICAgICAgICAgICAgICByZXR1cm4gdG90YWw7CisgICAgICAgIH0KKyAg ICB9CisgICAgCisgICAgcmV0dXJuIHRvdGFsOworfQorCitzaG9ydCBSZW5kZXJTdHlsZTo6Y291 bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgYykgY29uc3QKK3sKKyAgICBpZiAoY291bnRlclJlc2V0 TGlzdCkKKyAgICAgICAgcmV0dXJuIHJlYWRDb3VudGVyKGMsIGNvdW50ZXJSZXNldExpc3QsIHRy dWUpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKK3Nob3J0IFJlbmRlclN0eWxl Ojpjb3VudGVySW5jcmVtZW50KGNvbnN0IFN0cmluZyYgYykgY29uc3QKK3sKKyAgICBpZiAoY291 bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiByZWFkQ291bnRlcihjLCBjb3VudGVy SW5jcmVtZW50TGlzdCwgZmFsc2UpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9CisK K3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvdW50ZXJSZXNldChDU1NWYWx1ZUxpc3QqIGwpCit7Cisg ICAgQ1NTVmFsdWVMaXN0KiB0ID0gY291bnRlclJlc2V0TGlzdDsKKyAgICBjb3VudGVyUmVzZXRM aXN0ID0gbDsKKyAgICBpZiAobCkKKyAgICAgICAgbC0+cmVmKCk7CisgICAgaWYgKHQpCisgICAg ICAgIHQtPmRlcmVmKCk7Cit9CisKK3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvdW50ZXJJbmNyZW1l bnQoQ1NTVmFsdWVMaXN0KiBsKQoreworICAgIENTU1ZhbHVlTGlzdCogdCA9IGNvdW50ZXJJbmNy ZW1lbnRMaXN0OworICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0ID0gbDsKKyAgICAKKyAgICBpZiAo bCkgCisgICAgICAgIGwtPnJlZigpOworICAgIGlmICh0KQorICAgICAgICB0LT5kZXJlZigpOwor fQorCit2b2lkIFJlbmRlclN0eWxlOjphZGRDb3VudGVyUmVzZXQoQ1NTUHJpbWl0aXZlVmFsdWUq IGMpCit7CisgICAgaWYgKCFjb3VudGVyUmVzZXRMaXN0KSB7CisgICAgICAgIGNvdW50ZXJSZXNl dExpc3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgICAgICBjb3VudGVyUmVzZXRMaXN0LT5yZWYo KTsKKyAgICB9CisKKyAgICBjb3VudGVyUmVzZXRMaXN0LT5hcHBlbmQoYyk7Cit9CisKK3ZvaWQg UmVuZGVyU3R5bGU6OmFkZENvdW50ZXJJbmNyZW1lbnQoQ1NTUHJpbWl0aXZlVmFsdWUqIGMpCit7 CisgICAgaWYgKCFjb3VudGVySW5jcmVtZW50TGlzdCkgeworICAgICAgICBjb3VudGVySW5jcmVt ZW50TGlzdCA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0 LT5yZWYoKTsKKyAgICB9CisKKyAgICBjb3VudGVySW5jcmVtZW50TGlzdC0+YXBwZW5kKGMpOwor fQorCiBjb25zdCBWZWN0b3I8U3R5bGVEYXNoYm9hcmRSZWdpb24+JiBSZW5kZXJTdHlsZTo6aW5p dGlhbERhc2hib2FyZFJlZ2lvbnMoKQogeyAKICAgICBzdGF0aWMgVmVjdG9yPFN0eWxlRGFzaGJv YXJkUmVnaW9uPiBlbXB0eUxpc3Q7CkluZGV4OiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCShy ZXZpc2lvbiAxNjUyOCkKKysrIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkod29y a2luZyBjb3B5KQpAQCAtODU3LDYgKzg1NywxMyBAQAogCQk5MzVGQkNGMjA5QkExNDNCMDBFMjMw QjEgLyogRXhjZXB0aW9uQ29kZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gOTM1RkJDRjEwOUJBMTQzQjAwRTIzMEIxIC8qIEV4Y2VwdGlvbkNvZGUuaCAq LzsgfTsKIAkJOTM2QjQyNEUwOUE0MzZDRDAwQkFBODIwIC8qIFNWR0NTU1BhcnNlci5jcHAgaW4g U291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEMwRjZGNjA4OTcw MUYxMDBCQTUxMTQgLyogU1ZHQ1NTUGFyc2VyLmNwcCAqLzsgfTsKIAkJOTM2QkREMUQwQTAzMUFF QjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNkJERDFDMEEwMzFBRUIwMDRERjRBQiAvKiBHcmFw aGljc0NvbnRleHRDRy5jcHAgKi87IH07CisJCTkzNzFCQjcxMEFDNDdGQUUwMENENEE3QiAvKiBS ZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oICovOyB9Owor CQk5MzcxQkI3MzBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3MjBBQzQ3RkI4MDBD RDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi87IH07CisJCTkzNzFCQjc1MEFDNDdGQzgwMENE NEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3NDBBQzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0 Tm9kZS5oICovOyB9OworCQk5MzcxQkI3NzBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0 Tm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5 MzcxQkI3NjBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgKi87IH07CisJ CTkzNzFCQjc5MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVyTm9kZS5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCNzgwQUM0N0ZENzAwQ0Q0QTdC IC8qIENvdW50ZXJOb2RlLmggKi87IH07CisJCTkzNzFCQjdCMEFDNDdGREUwMENENEE3QiAvKiBD b3VudGVyTm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUuY3BwICovOyB9Owor CQk5MzcxQkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3QzBBQzQ3RkU3MDBD RDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi87IH07CiAJCTkzNzI1NjEwMEE2MTU2NDIwMEIw NTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliIGluIEZyYW1ld29ya3MgKi8gPSB7aXNhID0gUEJYQnVp bGRGaWxlOyBmaWxlUmVmID0gOTM3MjU2MEYwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMu ZHlsaWIgKi87IH07CiAJCTkzODBGNDczMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4MEY0NzEwOUEx MUFCNDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgKi87IH07CiAJCTkzODBGNDc0MDlBMTFBQjQwMDFG REIzNCAvKiBXaWRnZXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzODBGNDcyMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuaCAqLzsgfTsKQEAgLTMx ODMsNiArMzE5MCwxMyBAQAogCQk5MzVGQkNGMTA5QkExNDNCMDBFMjMwQjEgLyogRXhjZXB0aW9u Q29kZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFeGNlcHRpb25Db2RlLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNkJERDFDMEEwMzFBRUIwMDRERjRBQiAv KiBHcmFwaGljc0NvbnRleHRDRy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBHcmFwaGljc0NvbnRleHRDRy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTkzNkREMDNBMDlDRUFDMjcwMDU2QUU4QyAvKiBSYW5nZS5pZGwgKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBw YXRoID0gUmFuZ2UuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3MDBB QzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gUmVuZGVyQ291bnRlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owor CQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVuZGVyQ291bnRlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc0MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVy UmVzZXROb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g MzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3VudGVyUmVz ZXROb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc2MEFDNDdGRDAw MENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBDb3VudGVyUmVzZXROb2RlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKKwkJOTM3MUJCNzgwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3VudGVyTm9kZS5oOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OworCQk5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvdW50ZXJOb2RlLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCN0MwQUM0N0ZFNzAwQ0Q0QTdC IC8qIENvdW50ZXJMaXN0SXRlbS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g Q291bnRlckxpc3RJdGVtLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNzI1NjBG MEE2MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gImNvbXBpbGVkLm1hY2gtby5keWxpYiI7IG5h bWUgPSBsaWJzcWxpdGUzLmR5bGliOyBwYXRoID0gL3Vzci9saWIvbGlic3FsaXRlMy5keWxpYjsg c291cmNlVHJlZSA9ICI8YWJzb2x1dGU+IjsgfTsKIAkJOTM4MEY0NzEwOUExMUFCNDAwMUZEQjM0 IC8qIFdpZGdldC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gV2lk Z2V0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM4MEY0NzIwOUExMUFCNDAw MUZEQjM0IC8qIFdpZGdldC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gV2lk Z2V0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC03MTY2LDYgKzcxODAsMTEgQEAK IAkJCQlCQ0VBNDgxNDA5N0Q5MzAyMDA5NEM5RTQgLyogYmlkaS5oICovLAogCQkJCUJDRUE0ODE1 MDk3RDkzMDIwMDk0QzlFNCAvKiBicmVha19saW5lcy5jcHAgKi8sCiAJCQkJQkNFQTQ4MTYwOTdE OTMwMjAwOTRDOUU0IC8qIGJyZWFrX2xpbmVzLmggKi8sCisJCQkJOTM3MUJCN0MwQUM0N0ZFNzAw Q0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICovLAorCQkJCTkzNzFCQjdBMEFDNDdGREUwMENE NEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8sCisJCQkJOTM3MUJCNzgwQUM0N0ZENzAwQ0Q0QTdC IC8qIENvdW50ZXJOb2RlLmggKi8sCisJCQkJOTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENv dW50ZXJSZXNldE5vZGUuY3BwICovLAorCQkJCTkzNzFCQjc0MEFDNDdGQzgwMENENEE3QiAvKiBD b3VudGVyUmVzZXROb2RlLmggKi8sCiAJCQkJQkNFQTQ4MTcwOTdEOTMwMjAwOTRDOUU0IC8qIERh dGFSZWYuaCAqLywKIAkJCQlBQkU3QjUyMTBBNDg5RjgzMDAzMTg4MUMgLyogRGVwcmVjYXRlZFJl bmRlclNlbGVjdC5jcHAgKi8sCiAJCQkJQUJFN0I1MjIwQTQ4OUY4MzAwMzE4ODFDIC8qIERlcHJl Y2F0ZWRSZW5kZXJTZWxlY3QuaCAqLywKQEAgLTcyMDIsNiArNzIyMSw4IEBACiAJCQkJQkNFQTQ4 MjkwOTdEOTMwMjAwOTRDOUU0IC8qIFJlbmRlclZpZXcuaCAqLywKIAkJCQlCQ0VBNDgyQzA5N0Q5 MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmNwcCAqLywKIAkJCQlCQ0VBNDgyRDA5N0Q5 MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmggKi8sCisJCQkJOTM3MUJCNzIwQUM0N0ZC ODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuY3BwICovLAorCQkJCTkzNzFCQjcwMEFDNDdGQUUw MENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi8sCiAJCQkJQThFQTczQUYwQTE5MDBFMzAwQThF RjVGIC8qIFJlbmRlckZpZWxkc2V0LmNwcCAqLywKIAkJCQlBOEVBNzNCMDBBMTkwMEUzMDBBOEVG NUYgLyogUmVuZGVyRmllbGRzZXQuaCAqLywKIAkJCQkwNjZDNzcyRTBBQjYwM0ZEMDAyMzhDQzQg LyogUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuY3BwICovLApAQCAtODQ1MCw2ICs4NDcxLDEwIEBA CiAJCQkJQTg0MTVGOUUwQUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXNrZXIuaCBpbiBIZWFk ZXJzICovLAogCQkJCUE4NDE1RkEwMEFDMTBDNUQwMEY3RDBERiAvKiBLQ2FudmFzTWFya2VyLmgg aW4gSGVhZGVycyAqLywKIAkJCQlCQzNGQ0FBOTBBQzNEQjU4MDBCQTU0QUQgLyogUGxhdGZvcm1T Y3JvbGxCYXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzNzFCQjcxMEFDNDdGQUUwMENENEE3QiAv KiBSZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLywKKwkJCQk5MzcxQkI3NTBBQzQ3RkM4MDBD RDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM3MUJCNzkw QUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggaW4gSGVhZGVycyAqLywKKwkJCQk5Mzcx QkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggaW4gSGVhZGVycyAqLywK IAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsK QEAgLTk1MzgsNiArOTU2Myw5IEBACiAJCQkJQTg0MTVGOUYwQUMxMEM1RDAwRjdEMERGIC8qIEtD YW52YXNNYXNrZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTg0MTVGQTEwQUMxMEM1RDAwRjdE MERGIC8qIEtDYW52YXNNYXJrZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTg0MTVGQTIwQUMx MEM1RDAwRjdEMERGIC8qIEtDYW52YXNGaWx0ZXJzLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTkz NzFCQjczMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNwcCBpbiBTb3VyY2VzICov LAorCQkJCTkzNzFCQjc3MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCBp biBTb3VyY2VzICovLAorCQkJCTkzNzFCQjdCMEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVyTm9k ZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rw cm9jZXNzaW5nID0gMDsKIAkJfTsKSW5kZXg6IGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRp b24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRpb24uY3Bw CShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRpb24uY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC02MDIsMTEgKzYwMiw5IEBACiAgICAgICAgIC8vIEZJWE1FOiB1 bmltcGxlbWVudGVkCiAgICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9J TkNSRU1FTlQ6Ci0gICAgICAgIC8vIEZJWE1FOiB1bmltcGxlbWVudGVkCi0gICAgICAgIGJyZWFr OworICAgICAgICByZXR1cm4gc3R5bGUtPmNvdW50ZXJJbmNyZW1lbnRWYWx1ZUxpc3QoKTsKICAg ICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVTRVQ6Ci0gICAgICAgIC8vIEZJWE1FOiB1bmltcGxl bWVudGVkCi0gICAgICAgIGJyZWFrOworICAgICAgICByZXR1cm4gc3R5bGUtPmNvdW50ZXJSZXNl dFZhbHVlTGlzdCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ1VSU09SOgogICAgICAgICBpZiAoc3R5 bGUtPmN1cnNvckltYWdlKCkpCiAgICAgICAgICAgICByZXR1cm4gbmV3IENTU1ByaW1pdGl2ZVZh bHVlKHN0eWxlLT5jdXJzb3JJbWFnZSgpLT51cmwoKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19V UkkpOwpJbmRleDogY3NzL2Nzc3BhcnNlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9jc3NwYXJzZXIu aAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3NzcGFyc2VyLmgJKHdvcmtpbmcgY29weSkKQEAg LTE0NiwxMSArMTQ2LDEzIEBACiAKICAgICAgICAgYm9vbCBwYXJzZVNoYXBlKGludCBwcm9wSWQs IGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgYm9vbCBwYXJzZUZvbnQoYm9vbCBpbXBvcnRhbnQp OworICAgICAgICBib29sIHBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBib29sIGluY3JlbWVudCwg Ym9vbCBpbXBvcnRhbnQpOwogICAgICAgICBDU1NWYWx1ZUxpc3QqIHBhcnNlRm9udEZhbWlseSgp OwogICAgICAgICBib29sIHBhcnNlQ29sb3JQYXJhbWV0ZXJzKFZhbHVlKiwgaW50KiBjb2xvclZh bHVlcywgYm9vbCBwYXJzZUFscGhhKTsKICAgICAgICAgYm9vbCBwYXJzZUhTTFBhcmFtZXRlcnMo VmFsdWUqLCBkb3VibGUqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBD U1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xvcigpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1 ZSogcGFyc2VDb2xvckZyb21WYWx1ZShWYWx1ZSopOworICAgICAgICBDU1NWYWx1ZSogcGFyc2VD b3VudGVyQ29udGVudChWYWx1ZUxpc3QgKmFyZ3MsIGJvb2wgY291bnRlcnMpOwogICAgICAgICAK ICNpZmRlZiBTVkdfU1VQUE9SVAogICAgICAgICBib29sIHBhcnNlU1ZHVmFsdWUoaW50IHByb3BJ ZCwgYm9vbCBpbXBvcnRhbnQpOwpJbmRleDogY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBj c3MvY3Nzc3R5bGVzZWxlY3Rvci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI2LDYgKzI2LDcgQEAK ICNpbmNsdWRlICJjc3NzdHlsZXNlbGVjdG9yLmgiCiAKICNpbmNsdWRlICJDU1NCb3JkZXJJbWFn ZVZhbHVlLmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgogI2luY2x1ZGUgIkNTU0ltYWdlVmFsdWUu aCIKICNpbmNsdWRlICJDU1NJbXBvcnRSdWxlLmgiCiAjaW5jbHVkZSAiQ1NTTWVkaWFSdWxlLmgi CkBAIC0zMTQ4LDcgKzMxNDksOSBAQAogCiAgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVu OyBpKyspIHsKICAgICAgICAgICAgIENTU1ZhbHVlICppdGVtID0gbGlzdC0+aXRlbShpKTsKLSAg ICAgICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRpdmVWYWx1ZSgpKSBjb250aW51ZTsKKyAgICAg ICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRpdmVWYWx1ZSgpKQorICAgICAgICAgICAgICAgIGNv bnRpbnVlOworICAgICAgICAgICAgCiAgICAgICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSAqdmFs ID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihpdGVtKTsKICAgICAgICAgICAgIGlm ICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpCiAg ICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQodmFsLT5nZXRTdHJpbmdWYWx1ZSgpLmlt cGwoKSwgaSAhPSAwKTsKQEAgLTMxNjIsMjAgKzMxNjUsMzQgQEAKICAgICAgICAgICAgICAgICBz dHlsZS0+c2V0Q29udGVudChlbGVtZW50LT5nZXRBdHRyaWJ1dGUoYXR0cikuaW1wbCgpLCBpICE9 IDApOwogICAgICAgICAgICAgICAgIC8vIHJlZ2lzdGVyIHRoZSBmYWN0IHRoYXQgdGhlIGF0dHJp YnV0ZSB2YWx1ZSBhZmZlY3RzIHRoZSBzdHlsZQogICAgICAgICAgICAgICAgIG1fc2VsZWN0b3JB dHRycy5hZGQoYXR0ci5sb2NhbE5hbWUoKS5pbXBsKCkpOwotICAgICAgICAgICAgfQotICAgICAg ICAgICAgZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpD U1NfVVJJKSB7CisgICAgICAgICAgICB9IGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1D U1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgewogICAgICAgICAgICAgICAgIENTU0ltYWdlVmFs dWUgKmltYWdlID0gc3RhdGljX2Nhc3Q8Q1NTSW1hZ2VWYWx1ZSo+KHZhbCk7CiAgICAgICAgICAg ICAgICAgc3R5bGUtPnNldENvbnRlbnQoaW1hZ2UtPmltYWdlKGVsZW1lbnQtPmRvY3VtZW50KCkt PmRvY0xvYWRlcigpKSwgaSAhPSAwKTsKLSAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxz ZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfQ09VTlRF UikgeworICAgICAgICAgICAgICAgIENvdW50ZXIqIGNvdW50ZXJWYWx1ZSA9IHZhbC0+Z2V0Q291 bnRlclZhbHVlKCk7CisgICAgICAgICAgICAgICAgQ291bnRlckRhdGEgY291bnRlciA9ICBDb3Vu dGVyRGF0YShjb3VudGVyVmFsdWUtPmlkZW50aWZpZXIoKSwKKyAgICAgICAgICAgICAgICAgICAg Y291bnRlclZhbHVlLT5saXN0U3R5bGVOdW1iZXIoKSwgY291bnRlclZhbHVlLT5zZXBhcmF0b3Io KSk7CisgICAgICAgICAgICAgICAgQ291bnRlckRhdGEqIGMgPSBuZXcgQ291bnRlckRhdGEoY291 bnRlcik7CisgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoYywgaSAhPSAwKTsKKyAg ICAgICAgICAgfQogICAgICAgICB9CiAgICAgICAgIGJyZWFrOwogICAgIH0KIAotICAgIGNhc2Ug Q1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50 ZXJJbmNyZW1lbnQKLSAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVTRVQ6Ci0gICAgICAgIC8v IGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNldAorICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNS RU1FTlQ6IHsKKyAgICAgICAgaWYgKCF2YWx1ZS0+aXNWYWx1ZUxpc3QoKSkKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgQ1NTVmFsdWVMaXN0KiBsaXN0ID0gc3RhdGljX2Nhc3Q8Q1NTVmFs dWVMaXN0ICo+KHZhbHVlKTsKKyAgICAgICAgc3R5bGUtPnNldENvdW50ZXJJbmNyZW1lbnQobGlz dCk7CiAgICAgICAgIGJyZWFrOworICAgIH0KKyAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVT RVQ6IHsKKyAgICAgICAgaWYgKCF2YWx1ZS0+aXNWYWx1ZUxpc3QoKSkKKyAgICAgICAgICAgIHJl dHVybjsKKyAgICAgICAgQ1NTVmFsdWVMaXN0KiBsaXN0ID0gc3RhdGljX2Nhc3Q8Q1NTVmFsdWVM aXN0ICo+KHZhbHVlKTsKKyAgICAgICAgc3R5bGUtPnNldENvdW50ZXJSZXNldChsaXN0KTsKKyAg ICAgICAgYnJlYWs7CisgICAgfQogICAgIGNhc2UgQ1NTX1BST1BfRk9OVF9GQU1JTFk6IHsKICAg ICAgICAgLy8gbGlzdCBvZiBzdHJpbmdzIGFuZCBpZHMKICAgICAgICAgaWYgKGlzSW5oZXJpdCkg ewpJbmRleDogY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvQ1NT UHJpbWl0aXZlVmFsdWUuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9DU1NQcmltaXRpdmVW YWx1ZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTUyNCw3ICs1MjQsMTAgQEAKICAgICAgICAgICAg IC8vICMjIwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX0NPVU5URVI6Ci0g ICAgICAgICAgICAvLyAjIyMKKyAgICAgICAgICAgIHRleHQgPSAiY291bnRlcigiOworICAgICAg ICAgICAgdGV4dCArPSBTdHJpbmc6Om51bWJlcihtX3ZhbHVlLm51bSk7CisgICAgICAgICAgICB0 ZXh0ICs9ICIpIjsKKyAgICAgICAgICAgIC8vICMjIyBhZGQgbGlzdC1zdHlsZSBhbmQgc2VwYXJh dG9yCiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBDU1NfUkVDVDogewogICAgICAg ICAgICAgUmVjdEltcGwqIHJlY3RWYWwgPSBnZXRSZWN0VmFsdWUoKTsKSW5kZXg6IGNzcy9Db3Vu dGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gY3NzL0NvdW50ZXIuaAkocmV2aXNpb24gMTY1MjgpCisrKyBj c3MvQ291bnRlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0yMywyMyArMjMsMzcgQEAKICNpZm5kZWYg Q291bnRlcl9ICiAjZGVmaW5lIENvdW50ZXJfSAogCisjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFs dWUuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgogI2luY2x1ZGUgIlNoYXJlZC5oIgot I2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4K IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBjbGFzcyBDb3VudGVyIDogcHVibGljIFNoYXJlZDxD b3VudGVyPiB7CiBwdWJsaWM6Ci0gICAgU3RyaW5nIGlkZW50aWZpZXIoKSBjb25zdCB7IHJldHVy biBtX2lkZW50aWZpZXI7IH0KLSAgICBTdHJpbmcgbGlzdFN0eWxlKCkgY29uc3QgeyByZXR1cm4g bV9saXN0U3R5bGU7IH0KLSAgICBTdHJpbmcgc2VwYXJhdG9yKCkgY29uc3QgeyByZXR1cm4gbV9z ZXBhcmF0b3I7IH0KKyAgICBDb3VudGVyKCkgOiBtX2lkZW50aWZpZXIoMCksIG1fbGlzdFN0eWxl KDApLCBtX3NlcGFyYXRvcigwKSB7IH0KKyAgICBDb3VudGVyKFBhc3NSZWZQdHI8Q1NTUHJpbWl0 aXZlVmFsdWU+IGlkZW50aWZpZXIsIFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGxpc3RT dHlsZSwKKyAgICAgICAgUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gc2VwYXJhdG9yKQor ICAgICAgICA6IG1faWRlbnRpZmllcihpZGVudGlmaWVyKSwgbV9saXN0U3R5bGUobGlzdFN0eWxl KSwgbV9zZXBhcmF0b3Ioc2VwYXJhdG9yKSB7IH0KKyAgICB2aXJ0dWFsIH5Db3VudGVyKCkgeyB9 CiAKLXByaXZhdGU6Ci0gICAgU3RyaW5nIG1faWRlbnRpZmllcjsKLSAgICBTdHJpbmcgbV9saXN0 U3R5bGU7Ci0gICAgU3RyaW5nIG1fc2VwYXJhdG9yOwotfTsKKyAgICBTdHJpbmcgaWRlbnRpZmll cigpIGNvbnN0IHsgcmV0dXJuIG1faWRlbnRpZmllci5nZXQoKSA/IG1faWRlbnRpZmllci5nZXQo KS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5nIGxpc3RTdHlsZSgp IGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlLmdldCgpID8gbV9saXN0U3R5bGUuZ2V0KCktPmdl dFN0cmluZ1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQorICAgIFN0cmluZyBzZXBhcmF0b3IoKSBjb25z dCB7IHJldHVybiBtX3NlcGFyYXRvci5nZXQoKSA/IG1fc2VwYXJhdG9yLmdldCgpLT5nZXRTdHJp bmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0KIAotfSAvLyBuYW1lc3BhY2UKKyAgICBpbnQgbGlzdFN0 eWxlTnVtYmVyKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUuZ2V0KCkgPyAoaW50KSBtX2xp c3RTdHlsZS5nZXQoKS0+Z2V0RmxvYXRWYWx1ZSgpIDogMDsgfQorICAgIAorICAgIHZvaWQgc2V0 SWRlbnRpZmllcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVudGlmaWVyKSB7IG1f aWRlbnRpZmllciA9IGlkZW50aWZpZXI7IH0KKyAgICB2b2lkIHNldExpc3RTdHlsZShQYXNzUmVm UHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUpIHsgbV9saXN0U3R5bGUgPSBsaXN0U3R5 bGU7IH0KKyAgICB2b2lkIHNldFNlcGFyYXRvcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBzZXBhcmF0b3IpIHsgbV9zZXBhcmF0b3IgPSBzZXBhcmF0b3I7IH0KKyAKK3Byb3RlY3RlZDoK KyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IG1faWRlbnRpZmllcjsgLy9zdHJpbmcKKyAg ICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IG1fbGlzdFN0eWxlOyAvL2ludAorICAgIFJlZlB0 cjxDU1NQcmltaXRpdmVWYWx1ZT4gbV9zZXBhcmF0b3I7IC8vc3RyaW5nCisgfTsKIAorfSAvL25h bWVzcGFjZQorCiAjZW5kaWYKSW5kZXg6IGNzcy9jc3NwYXJzZXIuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IGNzcy9jc3NwYXJzZXIuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9jc3NwYXJzZXIuY3Bw CSh3b3JraW5nIGNvcHkpCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSAiY3NzcGFyc2VyLmgi CiAKICNpbmNsdWRlICJDU1NCb3JkZXJJbWFnZVZhbHVlLmgiCisjaW5jbHVkZSAiQ291bnRlci5o IgogI2luY2x1ZGUgIkNTU0ltYWdlVmFsdWUuaCIKICNpbmNsdWRlICJDU1NDaGFyc2V0UnVsZS5o IgogI2luY2x1ZGUgIkNTU0ltcG9ydFJ1bGUuaCIKQEAgLTg3MCw2ICs4NzEsMTcgQEAKICAgICAg ICAgZWxzZQogICAgICAgICAgICAgdmFsaWRfcHJpbWl0aXZlID0gKCFpZCAmJiB2YWxpZFVuaXQo dmFsdWUsIEZOdW1iZXJ8Rkxlbmd0aHxGUGVyY2VudCwgc3RyaWN0KSk7CiAgICAgICAgIGJyZWFr OworICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6ICAgIC8vIFsgPGlkZW50aWZp ZXI+IDxpbnRlZ2VyPj8gXSsgfCBub25lIHwgaW5oZXJpdAorICAgICAgICBpZiAoaWQgPT0gQ1NT X1ZBTF9OT05FKQorICAgICAgICAgICAgdmFsaWRfcHJpbWl0aXZlID0gdHJ1ZTsKKyAgICAgICAg ZWxzZQorICAgICAgICAgICAgcmV0dXJuIHBhcnNlQ291bnRlcihwcm9wSWQsIHRydWUsIGltcG9y dGFudCk7CisgICAgICAgIGJyZWFrOworICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVTRVQ6 ICAgICAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwgbm9uZSB8IGluaGVyaXQK KyAgICAgICAgIGlmIChpZCA9PSBDU1NfVkFMX05PTkUpCisgICAgICAgICAgICAgdmFsaWRfcHJp bWl0aXZlID0gdHJ1ZTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgcmV0dXJuIHBhcnNlQ291 bnRlcihwcm9wSWQsIGZhbHNlLCBpbXBvcnRhbnQpOwogICAgIGNhc2UgQ1NTX1BST1BfRk9OVF9G QU1JTFk6CiAgICAgICAgIC8vIFtbIDxmYW1pbHktbmFtZT4gfCA8Z2VuZXJpYy1mYW1pbHk+IF0s XSogWzxmYW1pbHktbmFtZT4gfCA8Z2VuZXJpYy1mYW1pbHk+XSB8IGluaGVyaXQKICAgICB7CkBA IC0xNTI0LDI3ICsxNTM2LDM5IEBACiBib29sIENTU1BhcnNlcjo6cGFyc2VDb250ZW50KGludCBw cm9wSWQsIGJvb2wgaW1wb3J0YW50KQogewogICAgIENTU1ZhbHVlTGlzdCogdmFsdWVzID0gbmV3 IENTU1ZhbHVlTGlzdDsKKyAgICBDU1NWYWx1ZSogcGFyc2VkVmFsdWUgPSAwOwogCiAgICAgd2hp bGUgKFZhbHVlKiB2YWwgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKSkgewotICAgICAgICBDU1NWYWx1 ZSogcGFyc2VkVmFsdWUgPSAwOwogICAgICAgICBpZiAodmFsLT51bml0ID09IENTU1ByaW1pdGl2 ZVZhbHVlOjpDU1NfVVJJKSB7CiAgICAgICAgICAgICAvLyB1cmwKICAgICAgICAgICAgIFN0cmlu ZyB2YWx1ZSA9IHBhcnNlVVJMKGRvbVN0cmluZyh2YWwtPnN0cmluZykpOwogICAgICAgICAgICAg cGFyc2VkVmFsdWUgPSBuZXcgQ1NTSW1hZ2VWYWx1ZSgKICAgICAgICAgICAgICAgICBTdHJpbmco S1VSTChzdHlsZUVsZW1lbnQtPmJhc2VVUkwoKS5kZXByZWNhdGVkU3RyaW5nKCksIHZhbHVlLmRl cHJlY2F0ZWRTdHJpbmcoKSkudXJsKCkpLCBzdHlsZUVsZW1lbnQpOwogICAgICAgICB9IGVsc2Ug aWYgKHZhbC0+dW5pdCA9PSBWYWx1ZTo6RnVuY3Rpb24pIHsKLSAgICAgICAgICAgIC8vIGF0dHIo WCkKKyAgICAgICAgICAgIC8vIGF0dHIoWCkgfCBjb3VudGVyKFggWyxZXSkgfCBjb3VudGVycyhY LCBZLCBbLFpdKQogICAgICAgICAgICAgVmFsdWVMaXN0ICphcmdzID0gdmFsLT5mdW5jdGlvbi0+ YXJnczsKICAgICAgICAgICAgIFN0cmluZyBmbmFtZSA9IGRvbVN0cmluZyh2YWwtPmZ1bmN0aW9u LT5uYW1lKS5sb3dlcigpOwotICAgICAgICAgICAgaWYgKGZuYW1lICE9ICJhdHRyKCIgfHwgIWFy Z3MpCisgICAgICAgICAgICBpZiAoIWFyZ3MpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwotICAgICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAgICAgaWYgKGZu YW1lID09ICJhdHRyKCIpIHsKKyAgICAgICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEp CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgICBWYWx1 ZSAqYSA9IGFyZ3MtPmN1cnJlbnQoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUg PSBkb21TdHJpbmcoYS0+c3RyaW5nKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+ aXNIVE1MRG9jdW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgYXR0ck5hbWUgPSBhdHRyTmFt ZS5sb3dlcigpOworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2 ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0FUVFIpOworICAgICAgICAg ICAgfSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXIoIikgeworICAgICAg ICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3VudGVyQ29udGVudChhcmdzLCBmYWxzZSk7 CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZhbHNlOworICAgICAg ICAgICAgfSBlbHNlCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImNvdW50ZXJzKCIpIHsKKyAg ICAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IHBhcnNlQ291bnRlckNvbnRlbnQoYXJncywgdHJ1 ZSk7CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkgcmV0dXJuIGZhbHNlOworICAg ICAgICAgICAgfQorICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxz ZTsKLSAgICAgICAgICAgIFZhbHVlICphID0gYXJncy0+Y3VycmVudCgpOwotICAgICAgICAgICAg U3RyaW5nIGF0dHJOYW1lID0gZG9tU3RyaW5nKGEtPnN0cmluZyk7Ci0gICAgICAgICAgICBpZiAo ZG9jdW1lbnQoKS0+aXNIVE1MRG9jdW1lbnQoKSkKLSAgICAgICAgICAgICAgICBhdHRyTmFtZSA9 IGF0dHJOYW1lLmxvd2VyKCk7Ci0gICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NQcmlt aXRpdmVWYWx1ZShhdHRyTmFtZSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19BVFRSKTsKICAgICAg ICAgfSBlbHNlIGlmICh2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkg ewogICAgICAgICAgICAgLy8gb3Blbi1xdW90ZQogICAgICAgICAgICAgLy8gY2xvc2UtcXVvdGUK QEAgLTE1NjcsNiArMTU5MSw3IEBACiAgICAgfQogCiAgICAgZGVsZXRlIHZhbHVlczsKKyAgICBk ZWxldGUgcGFyc2VkVmFsdWU7CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCkBAIC0xOTc4LDYgKzIw MDMsNjUgQEAKIH0KICNlbmRpZgogCitDU1NWYWx1ZSogQ1NTUGFyc2VyOjpwYXJzZUNvdW50ZXJD b250ZW50KFZhbHVlTGlzdCAqYXJncywgYm9vbCBjb3VudGVycykKK3sKKyAgICBDU1NQcmltaXRp dmVWYWx1ZSogaWRlbnRpZmllciA9IDA7CisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIHNlcGFyYXRv ciA9IDA7CisgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGxpc3RTdHlsZSA9IDA7CisKKyAgICBpZiAo Y291bnRlcnMgfHwgKGFyZ3MtPnNpemUoKSAhPSAxICYmIGFyZ3MtPnNpemUoKSAhPSAzKSkKKyAg ICAgICAgaWYgKCFjb3VudGVycyB8fCAoYXJncy0+c2l6ZSgpICE9IDMgJiYgYXJncy0+c2l6ZSgp ICE9IDUpKQorICAgICAgICAgICAgZ290byBpbnZhbGlkOworICAgIAorICAgIFZhbHVlICppID0g YXJncy0+Y3VycmVudCgpOworICAgIGlkZW50aWZpZXIgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUo ZG9tU3RyaW5nKGktPnN0cmluZyksIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKwor ICAgIGlmICghY291bnRlcnMpCisgICAgICAgIHNlcGFyYXRvciA9IG5ldyBDU1NQcmltaXRpdmVW YWx1ZShTdHJpbmcoKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpOworICAgIGVsc2Ug eworICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+dW5pdCAhPSBWYWx1 ZTo6T3BlcmF0b3IgfHwgaS0+aVZhbHVlICE9ICcsJykKKyAgICAgICAgICAgIGdvdG8gaW52YWxp ZDsKKyAgICAgICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51 bml0ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKQorICAgICAgICAgICAgZ290byBp bnZhbGlkOworICAgICAgICAKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENTU1ByaW1pdGl2ZVZh bHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBlcykg aS0+dW5pdCk7CisgICAgfQorCisgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICBpZiAoIWkpIC8v IE1ha2UgdGhlIGxpc3Qgc3R5bGUgZGVmYXVsdCBkZWNpbWFsCisgICAgICAgIGxpc3RTdHlsZSA9 IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShDU1NfVkFMX0RFQ0lNQUwgLSBDU1NfVkFMX0RJU0MsIENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICBlbHNlIHsKKyAgICAgICAgaWYgKGkt PnVuaXQgIT0gVmFsdWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcpCisgICAgICAgICAg ICBnb3RvIGludmFsaWQ7CisgICAgICAgIAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAg ICAgICBpZiAoaS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKQorICAgICAg ICAgICAgZ290byBpbnZhbGlkOworICAgICAgICAKKyAgICAgICAgc2hvcnQgbHMgPSAwOworICAg ICAgICBpZiAoaS0+aWQgPT0gQ1NTX1ZBTF9OT05FKQorICAgICAgICAgICAgbHMgPSBDU1NfVkFM X0tBVEFLQU5BX0lST0hBIC0gQ1NTX1ZBTF9ESVNDICsgMTsKKyAgICAgICAgZWxzZSBpZiAoaS0+ aWQgPj0gQ1NTX1ZBTF9ESVNDICYmIGktPmlkIDw9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEpCisg ICAgICAgICAgICBscyA9IGktPmlkIC0gQ1NTX1ZBTF9ESVNDOworICAgICAgICBlbHNlCisgICAg ICAgICAgICBnb3RvIGludmFsaWQ7CisKKyAgICAgICAgbGlzdFN0eWxlID0gbmV3IENTU1ByaW1p dGl2ZVZhbHVlKGxzLCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBlcykgaS0+dW5pdCk7Cisg ICAgfQorICAgIAorICAgIENvdW50ZXIqIGNvdW50ZXIgPSBuZXcgQ291bnRlcihpZGVudGlmaWVy LCBsaXN0U3R5bGUsIHNlcGFyYXRvcik7CisgICAgcmV0dXJuIG5ldyBDU1NQcmltaXRpdmVWYWx1 ZShjb3VudGVyKTsKKyAgICAKK2ludmFsaWQ6CisgICAgZGVsZXRlIGlkZW50aWZpZXI7CisgICAg ZGVsZXRlIHNlcGFyYXRvcjsKKyAgICBkZWxldGUgbGlzdFN0eWxlOworICAgIHJldHVybiAwOwor fQorCiBib29sIENTU1BhcnNlcjo6cGFyc2VTaGFwZShpbnQgcHJvcElkLCBib29sIGltcG9ydGFu dCkKIHsKICAgICBWYWx1ZSAqdmFsdWUgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKTsKQEAgLTI2NzYs NiArMjc2MCw1NCBAQAogICAgIHJldHVybiBjb250ZXh0LmZhaWxlZCgpOwogfQogCitib29sIENT U1BhcnNlcjo6cGFyc2VDb3VudGVyKGludCBwcm9wSWQsIGJvb2wgaW5jcmVtZW50LCBib29sIGlt cG9ydGFudCkKK3sKKyAgICBlbnVtIHsgSUQsIFZBTCB9IHN0YXRlID0gSUQ7CisKKyAgICBDU1NW YWx1ZUxpc3QqIGxpc3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgIFZhbHVlKiB2YWw7CisgICAg Q1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gMDsKKyAgICBDU1NQcmltaXRpdmVWYWx1 ZSogbnVtVmFsdWUgPSAwOworICAgIAorICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgIHZhbCA9 IHZhbHVlTGlzdC0+Y3VycmVudCgpOworICAgICAgICBzd2l0Y2ggKHN0YXRlKSB7CisgICAgICAg ICAgICBjYXNlIElEOgorICAgICAgICAgICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09IENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpIHsKKyAgICAgICAgICAgICAgICAgICAgY291bnRl ck5hbWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5nKHZhbC0+c3RyaW5nKSwgQ1NT UHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpOworICAgICAgICAgICAgICAgICAgICBzdGF0ZSA9 IFZBTDsKKyAgICAgICAgICAgICAgICAgICAgdmFsdWVMaXN0LT5uZXh0KCk7CisgICAgICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIGNhc2UgVkFMOiB7CisgICAgICAgICAgICAgICAgaW50IGkgPSAo aW5jcmVtZW50KSA/IDEgOiAwOworICAgICAgICAgICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0 ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKSB7CisgICAgICAgICAgICAgICAgICAg IGkgPSAoc2hvcnQpdmFsLT5mVmFsdWU7CisgICAgICAgICAgICAgICAgICAgIHZhbHVlTGlzdC0+ bmV4dCgpOworICAgICAgICAgICAgICAgIH0KKworICAgICAgICAgICAgICAgIG51bVZhbHVlID0g bmV3IENTU1ByaW1pdGl2ZVZhbHVlKGksIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsK KyAgICAgICAgICAgICAgICBQYWlyKiBwYWlyID0gbmV3IFBhaXIoY291bnRlck5hbWUsIG51bVZh bHVlKTsKKyAgICAgICAgICAgICAgICBsaXN0LT5hcHBlbmQobmV3IENTU1ByaW1pdGl2ZVZhbHVl KHBhaXIpKTsKKyAgICAgICAgICAgICAgICBzdGF0ZSA9IElEOworICAgICAgICAgICAgICAgIGNv bnRpbnVlOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIGJyZWFrOworICAgIH0K KyAgICAKKyAgICBpZiAobGlzdC0+bGVuZ3RoKCkgPiAwKSB7CisgICAgICAgIGFkZFByb3BlcnR5 KHByb3BJZCwgbGlzdCwgaW1wb3J0YW50KTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQor CisgICAgZGVsZXRlIGNvdW50ZXJOYW1lOworICAgIGRlbGV0ZSBudW1WYWx1ZTsKKyAgICBkZWxl dGUgbGlzdDsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKICNpZmRlZiBDU1NfREVCVUcKIAogc3Rh dGljIGlubGluZSBpbnQgeXllcnJvcihjb25zdCBjaGFyICpzdHIpCg== 10821 2006-09-28 02:14:23 -0700 2006-09-29 00:05:36 -0700 Patch for Darin's most recent comments wednesLLate.txt text/plain 67451 bdakin SW5kZXg6IHBsYXRmb3JtL1N0cmluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vU3RyaW5n LmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBwbGF0Zm9ybS9TdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xNTcsNiArMTU3LDE2IEBACiAgICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ci5tX2lt cGwuZ2V0KCksIHBvcyk7CiB9CiAKK3ZvaWQgU3RyaW5nOjppbnNlcnQoY29uc3QgVUNoYXIqIHN0 ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpCit7CisgICAgU3RyaW5nSW1wbCogbmV3 SW1wbCA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKworICAgIGlmICghbV9pbXBsKQor ICAgICAgICBtX2ltcGwgPSBuZXdJbXBsOworICAgIGVsc2UKKyAgICAgICAgbV9pbXBsLT5pbnNl cnQobmV3SW1wbCwgcG9zKTsKK30KKwogVUNoYXIgU3RyaW5nOjpvcGVyYXRvcltdKHVuc2lnbmVk IGkpIGNvbnN0CiB7CiAgICAgaWYgKCFtX2ltcGwgfHwgaSA+PSBtX2ltcGwtPmxlbmd0aCgpKQpJ bmRleDogcGxhdGZvcm0vUGxhdGZvcm1TdHJpbmcuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBwbGF0Zm9ybS9Q bGF0Zm9ybVN0cmluZy5oCShyZXZpc2lvbiAxNjUyOCkKKysrIHBsYXRmb3JtL1BsYXRmb3JtU3Ry aW5nLmgJKHdvcmtpbmcgY29weSkKQEAgLTkwLDYgKzkwLDcgQEAKICAgICB2b2lkIGFwcGVuZChj aGFyKTsKICAgICB2b2lkIGFwcGVuZChVQ2hhcik7CiAgICAgdm9pZCBpbnNlcnQoY29uc3QgU3Ry aW5nJiwgdW5zaWduZWQgcG9zKTsKKyAgICB2b2lkIGluc2VydChjb25zdCBVQ2hhciosIHVuc2ln bmVkIGxlbmd0aCwgdW5zaWduZWQgcG9zKTsKIAogICAgIFN0cmluZyYgcmVwbGFjZShVQ2hhciBh LCBVQ2hhciBiKSB7IGlmIChtX2ltcGwpIG1faW1wbCA9IG1faW1wbC0+cmVwbGFjZShhLCBiKTsg cmV0dXJuICp0aGlzOyB9CiAgICAgU3RyaW5nJiByZXBsYWNlKFVDaGFyIGEsIGNvbnN0IFN0cmlu ZyYgYikgeyBpZiAobV9pbXBsKSBtX2ltcGwgPSBtX2ltcGwtPnJlcGxhY2UoYSwgYi5pbXBsKCkp OyByZXR1cm4gKnRoaXM7IH0KSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysr IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBA QAogICogQ29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAg ICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAg ICAgICAgICAgKEMpIDIwMDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAg ICAgICAgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQog ICogQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAg KgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgpAQCAtMjksNiArMzAsOCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIg CiAjaW5jbHVkZSAiQWZmaW5lVHJhbnNmb3JtLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIK KyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIK ICNpbmNsdWRlICJEZWNvZGVyLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNsdWRlICJF bGVtZW50LmgiCkBAIC0zNyw2ICs0MCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRl ICJHcmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJI VE1MT0xpc3RFbGVtZW50LmgiCiAjaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRlICJSZW5k ZXJBcmVuYS5oIgogI2luY2x1ZGUgIlJlbmRlckZsZXhpYmxlQm94LmgiCkBAIC02NSw2ICs2OSwx OCBAQAogc3RhdGljIHZvaWQgKmJhc2VPZlJlbmRlck9iamVjdEJlaW5nRGVsZXRlZDsKICNlbmRp ZgogCit0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBDb3VudGVyTm9kZSo+IENvdW50ZXJOb2RlTWFw OwordHlwZWRlZiBIYXNoTWFwPGNvbnN0IFJlbmRlck9iamVjdCosIENvdW50ZXJOb2RlTWFwKj4g UmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzOworc3RhdGljIFJlbmRlck9iamVjdHNUb0Nv dW50ZXJOb2RlTWFwcyogZ2V0UmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKCkKK3sKKyAg ICBzdGF0aWMgUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKiBfcmVuZGVyT2JqZWN0c1Rv Q291bnRlck5vZGVNYXBzOworICAgIAorICAgIGlmICghX3JlbmRlck9iamVjdHNUb0NvdW50ZXJO b2RlTWFwcykKKyAgICAgICAgX3JlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyA9IG5ldyBI YXNoTWFwPGNvbnN0IFJlbmRlck9iamVjdCosIENvdW50ZXJOb2RlTWFwKj47CisgICAgCisgICAg cmV0dXJuIF9yZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHM7Cit9CisKIHZvaWQqIFJlbmRl ck9iamVjdDo6b3BlcmF0b3IgbmV3KHNpemVfdCBzeiwgUmVuZGVyQXJlbmEqIHJlbmRlckFyZW5h KSB0aHJvdygpCiB7CiAgICAgcmV0dXJuIHJlbmRlckFyZW5hLT5hbGxvY2F0ZShzeik7CkBAIC0x NzcsNyArMTkzLDggQEAKIAogbV9yZXBsYWNlZCggZmFsc2UgKSwKIG1faXNEcmFnZ2luZyggZmFs c2UgKSwKLW1faGFzT3ZlcmZsb3dDbGlwKGZhbHNlKQorbV9oYXNPdmVyZmxvd0NsaXAoZmFsc2Up LAorbV9oYXNDb3VudGVyTm9kZU1hcChmYWxzZSkKIHsKICNpZm5kZWYgTkRFQlVHCiAgICAgKytS ZW5kZXJPYmplY3RDb3VudGVyOjpjb3VudDsKQEAgLTIzOTUsNiArMjQxMiwxNiBAQAogCiB2b2lk IFJlbmRlck9iamVjdDo6ZGVzdHJveSgpCiB7CisgICAgaWYgKG1faGFzQ291bnRlck5vZGVNYXAp IHsKKyAgICAgICAgUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKiBvYmplY3RzTWFwID0g Z2V0UmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKCk7CisgICAgICAgIENvdW50ZXJOb2Rl TWFwKiBjb3VudGVyTm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7CisgICAgICAgIGlm IChjb3VudGVyTm9kZXNNYXApIHsKKyAgICAgICAgICAgIGRlbGV0ZUFsbFZhbHVlcygqY291bnRl ck5vZGVzTWFwKTsKKyAgICAgICAgICAgIG9iamVjdHNNYXAtPnJlbW92ZSh0aGlzKTsKKyAgICAg ICAgICAgIGRlbGV0ZSBjb3VudGVyTm9kZXNNYXA7CisgICAgICAgIH0KKyAgICB9CisgICAgCiAg ICAgZG9jdW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5yZW1vdmUodGhpcyk7CiAKICAgICAvLyBC eSBkZWZhdWx0IG5vIHJlZi1jb3VudGluZy4gUmVuZGVyV2lkZ2V0OjpkZXN0cm95KCkgZG9lc24n dCBjYWxsCkBAIC0yODM3LDYgKzI4NjQsMTU5IEBACiAgICAgcmV0dXJuIChhdm9pZHNGbG9hdHMo KSAmJiAoc3R5bGUoKS0+d2lkdGgoKS5pc0F1dG8oKSB8fCBpc0hSKCkgfHwgKHN0eWxlKCktPmh0 bWxIYWNrcygpICYmICFpc1RhYmxlKCkpKSk7CiB9CiAKK2Jvb2wgUmVuZGVyT2JqZWN0OjpoYXND b3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlcikgY29uc3QKK3sKKyAgICBpZiAoc3R5bGUoKSkg eworICAgICAgICBpZiAoc3R5bGUoKS0+aGFzQ291bnRlclJlc2V0KGNvdW50ZXIpIHx8IHN0eWxl KCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlcikpCisgICAgICAgICAgICByZXR1cm4gdHJ1 ZTsKKyAgICAgICAgaWYgKG1faGFzQ291bnRlck5vZGVNYXApIHsKKyAgICAgICAgICAgIFJlbmRl ck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyogb2JqZWN0c01hcCA9IGdldFJlbmRlck9iamVjdHNU b0NvdW50ZXJOb2RlTWFwcygpOworICAgICAgICAgICAgQ291bnRlck5vZGVNYXAqIGNvdW50ZXJO b2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKTsKKyAgICAgICAgICAgIGlmIChjb3VudGVy Tm9kZXNNYXAgJiYgY291bnRlck5vZGVzTWFwLT5nZXQoY291bnRlcikpCisgICAgICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICB9CisgICAgCisgICAgaWYgKGNvdW50ZXIg PT0gImxpc3QtaXRlbSIpCisgICAgICAgIGlmIChpc0xpc3RJdGVtKCkgfHwgKGVsZW1lbnQoKSAm JiAoCisgICAgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG9sVGFnKSB8fAorICAg ICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFtZSh1bFRhZykgfHwKKyAgICAgICAgICAg ICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUobWVudVRhZykgfHwKKyAgICAgICAgICAgICAgICBl bGVtZW50KCktPmhhc1RhZ05hbWUoZGlyVGFnKSkpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7 CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK0NvdW50ZXJOb2RlKiBSZW5kZXJPYmplY3Q6OmZp bmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlciwgYm9vbCB2aWV3LCBib29sIGNvdW50ZXJz KQoreworICAgIGlmICghc3R5bGUoKSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBpbnQgdmFs ID0gMDsKKyAgICBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMqIG9iamVjdHNNYXAgPSBn ZXRSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMoKTsKKyAgICBDb3VudGVyTm9kZSogbmV3 Tm9kZSA9IDA7CisgICAgaWYgKG1faGFzQ291bnRlck5vZGVNYXApIHsKKyAgICAgICAgQ291bnRl ck5vZGVNYXAqIGNvdW50ZXJOb2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKTsKKyAgICAg ICAgaWYgKGNvdW50ZXJOb2Rlc01hcCkKKyAgICAgICAgICAgIG5ld05vZGUgPSBjb3VudGVyTm9k ZXNNYXAtPmdldChjb3VudGVyKTsKKyAgICB9CisgICAgICAgIAorICAgIGlmIChuZXdOb2RlKQor ICAgICAgICByZXR1cm4gbmV3Tm9kZTsKKworICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVyUmVz ZXQoY291bnRlcikgfHwgaXNSb290KCkpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVy UmVzZXROb2RlKHRoaXMpOworICAgICAgICB2YWwgPSBzdHlsZSgpLT5jb3VudGVyUmVzZXQoY291 bnRlcik7CisgICAgICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50ZXIp KQorICAgICAgICAgICAgdmFsICs9IHN0eWxlKCktPmNvdW50ZXJJbmNyZW1lbnQoY291bnRlcik7 CisgICAgfSBlbHNlIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50ZXIpKSB7 CisgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUodGhpcyk7CisgICAgICAgIHZhbCAr PSBzdHlsZSgpLT5jb3VudGVySW5jcmVtZW50KGNvdW50ZXIpOworICAgIH0gZWxzZSBpZiAoY291 bnRlciA9PSAibGlzdC1pdGVtIikgeworICAgICAgICBpZiAoaXNMaXN0SXRlbSgpKSB7CisgICAg ICAgICAgICBpZiAoZWxlbWVudCgpKSB7CisgICAgICAgICAgICAgICAgU3RyaW5nIHYgPSBzdGF0 aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0QXR0cmlidXRlKCJ2YWx1ZSIpOworICAg ICAgICAgICAgICAgIGlmICghdi5pc0VtcHR5KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3 Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgICAgICAgICB2 YWwgPSB2LnRvSW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSAKKyAgICAg ICAgICAgIAorICAgICAgICAgICAgaWYgKCFuZXdOb2RlKSB7CisgICAgICAgICAgICAgICAgbmV3 Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAgICAgICAgICAgICB2YWwgPSAxOwor ICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYgKGVsZW1lbnQoKSAmJiBlbGVtZW50KCkt Pmhhc1RhZ05hbWUob2xUYWcpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJS ZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSBzdGF0aWNfY2FzdDxIVE1MT0xpc3RF bGVtZW50Kj4oZWxlbWVudCgpKS0+c3RhcnQoKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVtZW50 KCkgJiYKKyAgICAgICAgICAgIChlbGVtZW50KCktPmhhc1RhZ05hbWUodWxUYWcpIHx8CisgICAg ICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG1lbnVUYWcpIHx8CisgICAgICAgICAgICAg ZWxlbWVudCgpLT5oYXNUYWdOYW1lKGRpclRhZykpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0g bmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICB2YWwgPSAwOworICAgICAg ICB9CisgICAgfSAKKyAgICAKKyAgICBpZiAoIW5ld05vZGUpIHsKKyAgICAgICAgbmV3Tm9kZSA9 IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAgICAgdmFsID0gMDsKKyAgICB9CisgICAgCisg ICAgbmV3Tm9kZS0+c2V0VmFsdWUodmFsKTsKKyAgICBpZiAodmlldykKKyAgICAgICAgbmV3Tm9k ZS0+c2V0SXNWaXN1YWwoKTsKKyAgICBpZiAoY291bnRlcnMpCisgICAgICAgIG5ld05vZGUtPnNl dFVzZXNDb3VudGVycygpOworCisgICAgQ291bnRlck5vZGVNYXAqIG5vZGVNYXA7CisgICAgaWYg KG1faGFzQ291bnRlck5vZGVNYXApIHsKKyAgICAgICAgbm9kZU1hcCA9IG9iamVjdHNNYXAtPmdl dCh0aGlzKTsKKyAgICAgICAgb2JqZWN0c01hcC0+cmVtb3ZlKHRoaXMpOworICAgIH0gZWxzZSB7 CisgICAgICAgIG5vZGVNYXAgPSBuZXcgQ291bnRlck5vZGVNYXA7CisgICAgICAgIG1faGFzQ291 bnRlck5vZGVNYXAgPSB0cnVlOworICAgIH0KKyAgICAKKyAgICBub2RlTWFwLT5zZXQoY291bnRl ciwgbmV3Tm9kZSk7CisgICAgb2JqZWN0c01hcC0+c2V0KHRoaXMsIG5vZGVNYXApOworCisgICAg aWYgKCFpc1Jvb3QoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IDA7CisgICAgICAg IENvdW50ZXJOb2RlKiBjdXJyZW50ID0gMDsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiBuID0gIWlz TGlzdEl0ZW0oKSAmJiBwcmV2aW91c1NpYmxpbmcoKSA/IAorICAgICAgICAgICAgcHJldmlvdXNT aWJsaW5nKCktPnByZXZpb3VzU2libGluZygpIDogcHJldmlvdXNTaWJsaW5nKCk7CisKKyAgICAg ICAgd2hpbGUgKG4pIHsKKyAgICAgICAgICAgIGlmIChuLT5oYXNDb3VudGVyKGNvdW50ZXIpKSB7 CisgICAgICAgICAgICAgICAgY3VycmVudCA9IG4tPmZpbmRDb3VudGVyKGNvdW50ZXIpOworICAg ICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAg biA9IG4tPnByZXZpb3VzU2libGluZygpOworICAgICAgICB9CisgICAgICAgIAorICAgICAgICBs YXN0ID0gY3VycmVudDsKKyAgICAgICAgQ291bnRlck5vZGUqIHNpYmxpbmcgPSBjdXJyZW50Owor ICAgICAgICBpZiAobGFzdCAmJiAhbmV3Tm9kZS0+aXNSZXNldCgpKSB7CisgICAgICAgICAgICAv LyBGb3VuZCByZW5kZXItc2libGluZywgbm93IHNlYXJjaCBmb3IgbGF0ZXIgY291bnRlci1zaWJs aW5ncyBhbW9uZyBpdHMgcmVuZGVyLWNoaWxkcmVuCisgICAgICAgICAgICBuID0gbi0+bGFzdENo aWxkKCk7CisgICAgICAgICAgICB3aGlsZSAobikgeworICAgICAgICAgICAgICAgIGlmIChuLT5o YXNDb3VudGVyKGNvdW50ZXIpKSB7CisgICAgICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBuLT5m aW5kQ291bnRlcihjb3VudGVyKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGxhc3QtPnBhcmVu dCgpID09IGN1cnJlbnQtPnBhcmVudCgpIHx8IHNpYmxpbmcgPT0gY3VycmVudC0+cGFyZW50KCkp IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAgICAgICAg ICAgICAgICAgICAgLy8gSWYgdGhlIGN1cnJlbnQgY291bnRlciBpcyBub3QgdGhlIGxhc3QsIHNl YXJjaCBkZWVwZXIKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChjdXJyZW50LT5uZXh0U2li bGluZygpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgbiA9IG4tPmxhc3RDaGlsZCgp OworICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAg ICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgbiA9 IG4tPnByZXZpb3VzU2libGluZygpOworICAgICAgICAgICAgfQorICAgICAgICAgICAgCisgICAg ICAgICAgICBpZiAoc2libGluZy0+aXNSZXNldCgpKSB7CisgICAgICAgICAgICAgICAgaWYgKGxh c3QgIT0gc2libGluZykKKyAgICAgICAgICAgICAgICAgICAgc2libGluZy0+aW5zZXJ0QWZ0ZXIo bmV3Tm9kZSwgbGFzdCk7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAg ICBzaWJsaW5nLT5pbnNlcnRBZnRlcihuZXdOb2RlLCAwKTsKKyAgICAgICAgICAgIH0gZWxzZQor ICAgICAgICAgICAgICAgIGxhc3QtPnBhcmVudCgpLT5pbnNlcnRBZnRlcihuZXdOb2RlLCBsYXN0 KTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIE5vdGhpbmcgZm91bmQgYW1vbmcg c2libGluZ3MsIGxldCBvdXIgcGFyZW50IHNlYXJjaAorICAgICAgICAgICAgbGFzdCA9IHBhcmVu dCgpLT5maW5kQ291bnRlcihjb3VudGVyLCBmYWxzZSk7CisgICAgICAgICAgICBpZiAobGFzdC0+ aXNSZXNldCgpKQorICAgICAgICAgICAgICAgIGxhc3QtPmluc2VydEFmdGVyKG5ld05vZGUsIDAp OworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGxhc3QtPnBhcmVudCgpLT5pbnNl cnRBZnRlcihuZXdOb2RlLCBsYXN0KTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiBu ZXdOb2RlOworfQorCiBVQ2hhciBSZW5kZXJPYmplY3Q6OmJhY2tzbGFzaEFzQ3VycmVuY3lTeW1i b2woKSBjb25zdAogewogICAgIGlmIChOb2RlICpub2RlID0gZWxlbWVudCgpKQpJbmRleDogcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJPYmpl Y3QuaAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgJKHdvcmtp bmcgY29weSkKQEAgLTQsNiArNCw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDIwMDAgTGFycyBLbm9s bCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBBbnR0aSBLb2l2aXN0byAo a29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBEaXJrIE11ZWxsZXIgKG11 ZWxsZXJAa2RlLm9yZykKKyAqICAgICAgICAgICAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5z ZW4gKGtkZUBjYXJld29sZi5jb20pCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIwMDQsIDIwMDUs IDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBz b2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0zMSw2ICszMiw3IEBA CiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKICNpbmNsdWRlICJTY3JvbGxCYXIuaCIKICNpbmNs dWRlICJWaXNpYmxlUG9zaXRpb24uaCIKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogCiAvKgog ICogIFRoZSBwYWludGluZyBvZiBhIGxheWVyIG9jY3VycyBpbiB0aHJlZSBkaXN0aW5jdCBwaGFz ZXMuICBFYWNoIHBoYXNlIGludm9sdmVzCkBAIC01NCw2ICs1Niw3IEBACiBjbGFzcyBIVE1MQXJl YUVsZW1lbnQ7CiBjbGFzcyBJbmxpbmVCb3g7CiBjbGFzcyBJbmxpbmVGbG93Qm94OworY2xhc3Mg Q291bnRlck5vZGU7CiBjbGFzcyBQb3NpdGlvbjsKIGNsYXNzIFJlbmRlckFyZW5hOwogY2xhc3Mg UmVuZGVyQmxvY2s7CkBAIC0xOTIsNiArMTk1LDEwIEBACiAgICAgdmlydHVhbCBpbnQgc3RhdGlj WCgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICB2aXJ0dWFsIGludCBzdGF0aWNZKCkgY29uc3Qg eyByZXR1cm4gMDsgfQogICAgIAorICAgIGJvb2wgaGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGNv dW50ZXIpIGNvbnN0OworICAgIENvdW50ZXJOb2RlKiBmaW5kQ291bnRlcihjb25zdCBTdHJpbmcm IGNvdW50ZXIsIGJvb2wgdmlldyA9IGZhbHNlLCBib29sIGNvdW50ZXJzID0gZmFsc2UpOworCitw dWJsaWM6CiAgICAgLy8gUmVuZGVyT2JqZWN0IHRyZWUgbWFuaXB1bGF0aW9uCiAgICAgLy8vLy8v Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vCiAgICAgdmlydHVhbCBib29sIGNh bkhhdmVDaGlsZHJlbigpIGNvbnN0OwpAQCAtMjUzLDYgKzI2MCw3IEBACiAgICAgCiAgICAgdmly dHVhbCBib29sIGlzTGlzdEl0ZW0oKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1 YWwgYm9vbCBpc0xpc3RNYXJrZXIoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorICAgIHZpcnR1 YWwgYm9vbCBpc0NvdW50ZXIoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwg Ym9vbCBpc1JlbmRlclZpZXcoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIGJvb2wgaXNS b290KCkgY29uc3Q7CiAgICAgYm9vbCBpc0JvZHkoKSBjb25zdDsKQEAgLTkyNCw2ICs5MzIsOCBA QAogICAgIGJvb2wgbV9pc0RyYWdnaW5nICAgICAgICAgICAgICAgIDogMTsKICAgICAKICAgICBi b29sIG1faGFzT3ZlcmZsb3dDbGlwICAgICAgICAgICA6IDE7CisgICAgCisgICAgYm9vbCBtX2hh c0NvdW50ZXJOb2RlTWFwICAgICAgICAgOiAxOwogCiAgICAgLy8gbm90ZTogZG8gbm90IGFkZCB1 bm5lY2Vzc2FyeSBiaXRmbGFncywgd2UgaGF2ZSAzMiBiaXQgYWxyZWFkeSEKICAgICBmcmllbmQg Y2xhc3MgUmVuZGVyTGlzdEl0ZW07CkluZGV4OiByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJKHJldmlzaW9uIDApCisrKyBy ZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU0IEBACisv KgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3Ig S0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNCBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtk ZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIElu Yy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxh Y2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8K KyNpZm5kZWYgUkVOREVSX0NPVU5URVJfSF8KKyNkZWZpbmUgUkVOREVSX0NPVU5URVJfSF8KKwor I2luY2x1ZGUgIlJlbmRlclRleHQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworICAgIGNsYXNz IENvdW50ZXJOb2RlOworCisvLyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitjbGFzcyBSZW5kZXJD b3VudGVyIDogcHVibGljIFJlbmRlclRleHQgeworCitwdWJsaWM6CisgICAgUmVuZGVyQ291bnRl cihOb2RlKiwgQ291bnRlckRhdGEqKTsKKworICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVy TmFtZSgpIGNvbnN0IHsgcmV0dXJuICJSZW5kZXJDb3VudGVyIjsgfQorCisgICAgdmlydHVhbCBi b29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICB2aXJ0dWFsIHZvaWQg bGF5b3V0KCk7CisgICAgdmlydHVhbCB2b2lkIGNhbGNNaW5NYXhXaWR0aCgpOworCitwcml2YXRl OgorICAgIFN0cmluZyBjb252ZXJ0VmFsdWVUb1R5cGUoaW50IHZhbHVlLCBpbnQgdG90YWwsIEVM aXN0U3R5bGVUeXBlKTsKKworICAgIFN0cmluZyBtX2l0ZW07CisgICAgQ291bnRlckRhdGEqIG1f Y291bnRlcjsKKyAgICBDb3VudGVyTm9kZSogbV9jb3VudGVyTm9kZTsKK307CisKK30gLy9uYW1l c3BhY2UKKworI2VuZGlmCkluZGV4OiByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJKHJldmlzaW9uIDApCisrKyBy ZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYyIEBA CisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBm b3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4g KGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIs IEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUg UGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisq LworI2lmbmRlZiBDb3VudGVyX1Jlc2V0X05vZGVfaF8KKyNkZWZpbmUgQ291bnRlcl9SZXNldF9O b2RlX2hfCisKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKKy8vIFRoaXMgZmlsZSBpbXBsZW1lbnRzIGEgY291bnRlci10cmVlIHRoYXQgaXMgdXNlZCBm b3IgZmluZGluZyBhbGwgcGFyZW50cyBpbiBjb3VudGVycygpIGxvb2t1cCwKKy8vIGFuZCBmb3Ig cHJvcGFnYXRpbmcgY291bnQtY2hhbmdlcyB3aGVuIG5vZGVzIGFyZSBhZGRlZCBvciByZW1vdmVk LgorLy8gUGxlYXNlIG5vdGUgdGhhdCBvbmx5IGNvdW50ZXItcmVzZXQgYW5kIHJvb3QgY2FuIGJl IHBhcmVudHMgaGVyZSwgYW5kIHRoYXQgcmVuZGVyLXRyZWUgcGFyZW50cworLy8gYXJlIGp1c3Qg Y291bnRlci10cmVlIHNpYmxpbmdzCisKKy8vIEltcGxlbWVudGF0aW9uIG9mIGNvdW50ZXItcmVz ZXQgYW5kIHJvb3QKK2NsYXNzIENvdW50ZXJSZXNldE5vZGUgOiBwdWJsaWMgQ291bnRlck5vZGUK K3sKK3B1YmxpYzoKKyAgICBDb3VudGVyUmVzZXROb2RlKFJlbmRlck9iamVjdCopOworICAgIHZp cnR1YWwgfkNvdW50ZXJSZXNldE5vZGUoKTsKKworICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIGZp cnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2ZpcnN0OyB9OworICAgIHZpcnR1YWwgQ291bnRl ck5vZGUqIGxhc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdDsgfTsKKyAgICB2aXJ0dWFs IHZvaWQgaW5zZXJ0QWZ0ZXIgKENvdW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJl ZkNoaWxkKTsKKworICAgIHZpcnR1YWwgYm9vbCBpc1Jlc2V0KCkgeyByZXR1cm4gdHJ1ZTsgfTsK KyAgICB2aXJ0dWFsIHZvaWQgcmVjb3VudChib29sIHNldERpcnR5ID0gdHJ1ZSk7CisgICAgdmly dHVhbCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisKKyAgICB2b2lkIHVwZGF0ZVRvdGFsKGludCB2 YWx1ZSk7CisgICAgLy8gVGhlIGhpZ2hlc3QgdmFsdWUgYW1vbmcgY2hpbGRyZW4KKyAgICBpbnQg dG90YWwoKSBjb25zdCB7IHJldHVybiBtX3RvdGFsOyB9OworCitwcm90ZWN0ZWQ6CisgICAgaW50 IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAgQ291bnRlck5vZGUqIG1f bGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENvdW50ZXJS ZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmlu Zy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAq IFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRpb24gZm9yIEtERS4KKyAq CisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdv bGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICog dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3Vp dGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisgCisjaWZu ZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0SXRlbV9ICisKKyNpbmNs dWRlICJDb3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50 ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVyTm9kZQoreworcHVibGljOgorICAgIGludCBjb3Vu dCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBzZXREaXJ0eSA9IHRy dWUpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKworfTsKKworfSAvL25hbWVz cGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCisrKyByZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQ1IEBACisv KioKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9y IEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChr ZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJ bmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBs YWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCisKKyNp bmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKyNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworUmVuZGVyQ291 bnRlcjo6UmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRlcikKKyAg ICA6IFJlbmRlclRleHQobm9kZSwgMCksIG1fY291bnRlcihjb3VudGVyKSwgbV9jb3VudGVyTm9k ZSgwKQoreworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmxheW91dCgpCit7CisgICAgQVNTRVJU KG5lZWRzTGF5b3V0KCkpOworCisgICAgaWYgKCFtaW5NYXhLbm93bigpKQorICAgICAgICBjYWxj TWluTWF4V2lkdGgoKTsKKworICAgIFJlbmRlclRleHQ6OmxheW91dCgpOworfQorCitzdGF0aWMg U3RyaW5nIHRvUm9tYW4oaW50IG51bWJlciwgYm9vbCB1cHBlcikKK3sgCisgICAgU3RyaW5nIHJv bWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAndicsICd4JywgJ2wnLCAn YycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1tdID0geyAnSScsICdWJywg J1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hhciogZGlnaXRzID0gdXBw ZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8geworICAgICAg ICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkKKyAgICAg ICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQorICAgICAgICAgICAgICAg IHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA+PSA0ICYm IG51bSA8PSA4KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdpdHNbZCArIDFdLCAxLCAw KTsKKyAgICAgICAgaWYgKG51bSA9PSA5KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdp dHNbZCArIDJdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAgICAgICAgICAg IHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgbnVtYmVyIC89IDEwOwor ICAgICAgICBkICs9IDI7CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAgICByZXR1cm4gcm9tYW47 Cit9CisKK3N0YXRpYyBTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJlciwgVUNoYXIgbGV0 dGVyQSkKK3sgCisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVybiBTdHJpbmcoJmxl dHRlckEsIDEpOyAvLyBtYXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94ICgwLikKKworICAgIFN0 cmluZyBsZXR0ZXJTdHJpbmc7CisgICAgVUNoYXIgYzsKKyAgICB3aGlsZSAobnVtYmVyID4gMCkg eworICAgICAgICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7CisgICAgICAgIGMg PSBsZXR0ZXJBICsgb25lc0RpZ2l0OworICAgICAgICBsZXR0ZXJTdHJpbmcgPSBTdHJpbmcoJmMs IDEpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0OworICAgICAg ICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsKK30KKwor c3RhdGljIFN0cmluZyB0b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAgIGlmIChudW1iZXIgPCAx KQorICAgICAgICByZXR1cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsKKyAgICAKKyAgICBzdGF0 aWMgY29uc3QgVUNoYXIgdGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAxNTAwLCAxNTAyLCAxNTA0 LCAxNTA1LCAxNTA2LCAxNTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBsZXR0ZXI7CisgICAgVUNo YXIgYzsKKyAgICBpZiAobnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxldHRlciA9IHRvSGVicmV3 KG51bWJlciAvIDEwMDApICsgIiciOworICAgICAgICBudW1iZXIgPSBudW1iZXIgJSAxMDAwOwor ICAgIH0KKyAgICBpbnQgZm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAwOworICAgIGZvciAoaW50 IGkgPSAwOyBpIDwgZm91ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAgYyA9IDE1MTEgKyAzOwor ICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgIH0KKyAgICBudW1iZXIgJT0gNDAwOworICAg IGlmIChudW1iZXIgLyAxMDApIHsKKyAgICAgICAgYyA9IDE1MTEgKyAobnVtYmVyIC8gMTAwKSAt IDE7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfQorICAgIG51bWJlciAlPSAxMDA7 CisgICAgaWYgKG51bWJlciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAgYyA9IDE0 ODcgKyA5OworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICBjID0gMTQ4NyArIG51 bWJlciAtIDk7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfSBlbHNlIHsKKyAgICAg ICAgaW50IHRlbnMgPSBudW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRlbnMpIHsKKyAgICAgICAg ICAgIGMgPSB0ZW5EaWdpdFt0ZW5zIC0gMV07CisgICAgICAgICAgICBsZXR0ZXIuYXBwZW5kKGMp OworICAgICAgICB9CisgICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAgICBpZiAo bnVtYmVyKSB7CisgICAgICAgICAgICBjID0gMTQ4NyArIG51bWJlcjsKKyAgICAgICAgICAgIGxl dHRlci5hcHBlbmQoYyk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIGxldHRlcjsKK30K KworU3RyaW5nIFJlbmRlckNvdW50ZXI6OmNvbnZlcnRWYWx1ZVRvVHlwZShpbnQgdmFsdWUsIGlu dCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJpbmcgaXRlbTsKKyAgICBV Q2hhciBjOworICAgIHN3aXRjaCh0eXBlKSB7CisgICAgICAgIGNhc2UgTE5PTkU6CisgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgLy8gR2x5cGhzOgorICAgICAgICBjYXNlIERJU0M6CisgICAg ICAgICAgICBjID0gMHgyMDIyOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBDSVJDTEU6CisgICAgICAgICAgICBjID0g MHgyNWU2OworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBjID0gMHgyNWEwOworICAg ICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgY2FzZSBBUk1FTklBTjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoKKyAgICAgICAgY2FzZSBD SktfSURFT0dSQVBISUM6CisgICAgICAgIGNhc2UgSElSQUdBTkE6CisgICAgICAgIGNhc2UgS0FU QUtBTkE6CisgICAgICAgIGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgS0FUQUtB TkFfSVJPSEE6CisgICAgICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pFUk86CisgICAgICAgICAg ICAvLyBGSVhNRTogVGhlc2UgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gRm9yIG5vdyB3ZSds bCB1c2UgZGVjaW1hbCBpbnN0ZWFkLgorICAgICAgICBjYXNlIExERUNJTUFMOgorICAgICAgICAg ICAgaXRlbSA9IFN0cmluZzo6bnVtYmVyKHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICAvLyBBbGdvcml0bWljOgorICAgICAgICBjYXNlIExPV0VSX1JPTUFOOgorICAgICAgICAg ICAgaXRlbSA9IHRvUm9tYW4odmFsdWUsIGZhbHNlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICBjYXNlIFVQUEVSX1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9tYW4odmFsdWUs IHRydWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgTE9XRVJfR1JFRUs6IHsK KyAgICAgICAgICAgIGludCBudW1iZXIgPSB2YWx1ZSAtIDE7CisgICAgICAgICAgICBpbnQgbCA9 IChudW1iZXIgJSAyNCk7CisgICAgICAgICAgICBpZiAobCA+IDE2KQorICAgICAgICAgICAgICAg IGwrKzsgLy8gU2tpcCBHUkVFSyBTTUFMTCBMRVRURVIgRklOQUwgU0lHTUEKKyAgICAgICAgICAg IGMgPSA5NDUgKyBsOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAg ICAgICBmb3IgKGludCBpID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkrKykKKyAgICAgICAgICAg ICAgICBpdGVtICs9ICInIjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgICAg IGNhc2UgSEVCUkVXOgorICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3KHZhbHVlKTsKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgorICAgICAgICBjYXNlIExP V0VSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVlLCAnYScp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJfQUxQSEE6CisgICAgICAg IGNhc2UgVVBQRVJfTEFUSU46CisgICAgICAgICAgICBpdGVtID0gdG9MZXR0ZXJTdHJpbmcodmFs dWUsICdBJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAg ICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAg ICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6Y2FsY01pbk1h eFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkpOworCisgICAgaWYgKCFzdHls ZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGNvdW50ZXJzID0gIW1fY291bnRlci0+ c2VwYXJhdG9yKCkuaXNOdWxsKCk7CisKKyAgICBpZiAoIW1fY291bnRlck5vZGUgJiYgcGFyZW50 KCktPnBhcmVudCgpKQorICAgICAgICBtX2NvdW50ZXJOb2RlID0gcGFyZW50KCktPnBhcmVudCgp LT5maW5kQ291bnRlcihtX2NvdW50ZXItPmlkZW50aWZpZXIoKSwgdHJ1ZSwgY291bnRlcnMpOwor CisgICAgaW50IHZhbHVlID0gbV9jb3VudGVyTm9kZS0+Y291bnQoKTsKKyAgICBpZiAobV9jb3Vu dGVyTm9kZS0+aXNSZXNldCgpKQorICAgICAgICB2YWx1ZSA9IG1fY291bnRlck5vZGUtPnZhbHVl KCk7CisgICAgCisgICAgaW50IHRvdGFsID0gdmFsdWU7CisgICAgaWYgKG1fY291bnRlck5vZGUt PnBhcmVudCgpKQorICAgICAgICB0b3RhbCA9IG1fY291bnRlck5vZGUtPnBhcmVudCgpLT50b3Rh bCgpOworICAgIAorICAgIG1faXRlbSA9IGNvbnZlcnRWYWx1ZVRvVHlwZSh2YWx1ZSwgdG90YWws IChFTGlzdFN0eWxlVHlwZSltX2NvdW50ZXItPmxpc3RTdHlsZSgpKTsKKworICAgIGlmIChjb3Vu dGVycykgeworICAgICAgICBDb3VudGVyTm9kZSogY291bnRlciA9IG1fY291bnRlck5vZGUtPnBh cmVudCgpOworICAgICAgICBib29sIGZpcnN0ID0gdHJ1ZTsKKyAgICAgICAgd2hpbGUgIChjb3Vu dGVyLT5wYXJlbnQoKSAmJiAoZmlyc3QgfHwgIShjb3VudGVyLT5pc1Jlc2V0KCkgJiYgY291bnRl ci0+cGFyZW50KCktPmlzUm9vdCgpKSkpIHsKKyAgICAgICAgICAgIHZhbHVlID0gY291bnRlci0+ Y291bnQoKSA/IGNvdW50ZXItPmNvdW50KCkgOiAxOworICAgICAgICAgICAgdG90YWwgPSBjb3Vu dGVyLT5wYXJlbnQoKS0+dG90YWwoKTsKKyAgICAgICAgICAgIG1faXRlbSA9IGNvbnZlcnRWYWx1 ZVRvVHlwZSh2YWx1ZSwgdG90YWwsIChFTGlzdFN0eWxlVHlwZSltX2NvdW50ZXItPmxpc3RTdHls ZSgpKSAKKyAgICAgICAgICAgICAgICArIG1fY291bnRlci0+c2VwYXJhdG9yKCkgKyBtX2l0ZW07 CisgICAgICAgICAgICBjb3VudGVyID0gY291bnRlci0+cGFyZW50KCk7CisgICAgICAgICAgICBm aXJzdCA9IGZhbHNlOworICAgICAgICB9CisgICAgfQorCisgICAgc3RyID0gbmV3IFN0cmluZ0lt cGwoKHN0YXRpY19jYXN0PFN0cmluZz4obV9pdGVtKSkuY2hhcmFjdGVycygpLCBtX2l0ZW0ubGVu Z3RoKCkpOworICAgIAorICAgIFJlbmRlclRleHQ6OmNhbGNNaW5NYXhXaWR0aCgpOworfQorCit9 IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiByZW5kZXJpbmcvQ291bnRlck5vZGUuY3BwCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHJldmlzaW9uIDApCisrKyBy ZW5kZXJpbmcvQ291bnRlck5vZGUuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDkwIEBACisv KgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3Ig S0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtk ZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIElu Yy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxh Y2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisKKyNpbmNs dWRlICJDb3VudGVyUmVzZXROb2RlLmgiCisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworQ291bnRlck5vZGU6OkNvdW50ZXJOb2RlKFJlbmRlck9iamVj dCAqbykKKyAgICA6IG1faGFzQ291bnRlcnMoZmFsc2UpCisgICAgLCBtX2lzVmlzdWFsKGZhbHNl KQorICAgICwgbV92YWx1ZSgwKQorICAgICwgbV9jb3VudCAoMCkKKyAgICAsIG1fcGFyZW50KDAp CisgICAgLCBtX3ByZXZpb3VzKDApCisgICAgLCBtX25leHQgKDApCisgICAgLCBtX3JlbmRlcmVy KG8pCit7ICAgCit9CisKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2Rl KiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VSVChmYWxzZSk7Cit9CisKK3ZvaWQgQ291bnRl ck5vZGU6OnNldFVzZXNDb3VudGVycygpCit7CisgICAgZm9yIChDb3VudGVyTm9kZSogYyA9IHRo aXM7IGM7IGMgPSBjLT5wYXJlbnQoKSkKKyAgICAgICAgYy0+c2V0SGFzQ291bnRlcnMoKTsKK30K Kwordm9pZCBDb3VudGVyTm9kZTo6cmVjb3VudChib29sIHNldERpcnR5KQoreworICAgIGJvb2wg cmVjb3VudE5leHQgPSB0cnVlOworICAgIGZvciAoQ291bnRlck5vZGUqIGMgPSB0aGlzOyBjICYm IHJlY291bnROZXh0OyBjID0gYy0+bmV4dFNpYmxpbmcoKSkgeworICAgICAgICBpbnQgb2xkQ291 bnQgPSBjLT5jb3VudCgpOworICAgICAgICBpZiAoYy0+cHJldmlvdXNTaWJsaW5nKCkpCisgICAg ICAgICAgICBjLT5zZXRDb3VudChjLT5wcmV2aW91c1NpYmxpbmcoKS0+Y291bnQoKSArIGMtPnZh bHVlKCkpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIEFTU0VSVChjLT5wYXJlbnQoKS0+ Zmlyc3RDaGlsZCgpID09IHRoaXMpOworICAgICAgICAgICAgYy0+c2V0Q291bnQoYy0+cGFyZW50 KCktPnZhbHVlKCkgKyBjLT52YWx1ZSgpKTsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAg aWYgKG9sZENvdW50ICE9IGMtPmNvdW50KCkgJiYgc2V0RGlydHkpCisgICAgICAgICAgICBjLT5z ZXRTZWxmRGlydHkoKTsKKyAgICAgICAgCisgICAgICAgIHJlY291bnROZXh0ID0gb2xkQ291bnQg IT0gYy0+Y291bnQoKSB8fCAhc2V0RGlydHk7CisgICAgICAgIHNldERpcnR5ID0gdHJ1ZTsKKyAg ICAgICAgCisgICAgICAgIGlmIChyZWNvdW50TmV4dCAmJiBjLT5wYXJlbnQoKSkKKyAgICAgICAg ICAgIGMtPnBhcmVudCgpLT51cGRhdGVUb3RhbChjLT5jb3VudCgpKTsKKyAgICB9Cit9CisKK3Zv aWQgQ291bnRlck5vZGU6OnNldFNlbGZEaXJ0eSgpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYg bV9pc1Zpc3VhbCkKKyAgICAgICAgbV9yZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhS ZWNhbGMoKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAg IGlmIChtX3JlbmRlcmVyICYmIG1faXNWaXN1YWwgJiYgbV9oYXNDb3VudGVycykKKyAgICAgICAg bV9yZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNhbGMoKTsKK30KKworfSAvLyBu YW1lc3BhY2UKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJTdHlsZS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJl bmRlcmluZy9SZW5kZXJTdHlsZS5oCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5k ZXJTdHlsZS5oCSh3b3JraW5nIGNvcHkpCkBAIC0zNiwxMSArMzYsMTQgQEAKICAqLwogCiAjaW5j bHVkZSAiQ29sb3IuaCIKKyNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUg IkNTU1ZhbHVlTGlzdC5oIgogI2luY2x1ZGUgIkRhdGFSZWYuaCIKICNpbmNsdWRlICJGb250Lmgi CiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFJlY3QuaCIKICNpbmNs dWRlICJMZW5ndGguaCIKKyNpbmNsdWRlICJQYWlyLmgiCiAjaW5jbHVkZSAiU2hhcmVkLmgiCiAj aW5jbHVkZSAiVGV4dERpcmVjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KQEAgLTU5 LDkgKzYyLDExIEBACiAKIHVzaW5nIHN0ZDo6bWF4OwogCi1jbGFzcyBDU1NTdHlsZVNlbGVjdG9y OwogY2xhc3MgQ2FjaGVkSW1hZ2U7CiBjbGFzcyBDYWNoZWRSZXNvdXJjZTsKK2NsYXNzIENTU1N0 eWxlU2VsZWN0b3I7CitjbGFzcyBDU1NWYWx1ZUxpc3Q7CitjbGFzcyBQYWlyOwogY2xhc3MgUmVu ZGVyQXJlbmE7CiBjbGFzcyBTaGFkb3dWYWx1ZTsKIGNsYXNzIFN0cmluZ0ltcGw7CkBAIC00MDcs OCArNDEyLDggQEAKICAgICAgICAgcmV0dXJuICggY2xpcCA9PSBvLmNsaXAgJiYKICAgICAgICAg ICAgICAgICAgaGFzQ2xpcCA9PSBvLmhhc0NsaXAgJiYKICAgICAgICAgICAgICAgICAgY29sc3Bh biA9PSBvLmNvbHNwYW4gJiYKLSAgICAgICAgICAgICAgICAgY291bnRlcl9pbmNyZW1lbnQgPT0g by5jb3VudGVyX2luY3JlbWVudCAmJgotICAgICAgICAgICAgICAgICBjb3VudGVyX3Jlc2V0ID09 IG8uY291bnRlcl9yZXNldCAmJgorICAgICAgICAgICAgICAgICBjb3VudGVySW5jcmVtZW50ID09 IG8uY291bnRlckluY3JlbWVudCAmJgorICAgICAgICAgICAgICAgICBjb3VudGVyUmVzZXQgPT0g by5jb3VudGVyUmVzZXQgJiYKICAgICAgICAgICAgICAgICAgdGV4dERlY29yYXRpb24gPT0gby50 ZXh0RGVjb3JhdGlvbik7CiAgICAgfQogICAgIGJvb2wgb3BlcmF0b3IhPSggY29uc3QgU3R5bGVW aXN1YWxEYXRhICZvICkgY29uc3QgewpAQCAtNDIxLDggKzQyNiw4IEBACiAgICAgCiAgICAgc2hv cnQgY29sc3BhbjsgLy8gZm9yIGh0bWwsIG5vdCBhIGNzczIgYXR0cmlidXRlCiAKLSAgICBzaG9y dCBjb3VudGVyX2luY3JlbWVudDsgLy9vaywgc28gdGhlc2UgYXJlIG5vdCB2aXN1YWwgbW9kZSBz cGVzaWZpYwotICAgIHNob3J0IGNvdW50ZXJfcmVzZXQ7ICAgICAvL2Nhbid0IGdvIHRvIGluaGVy aXRlZCwgc2luY2UgdGhlc2UgYXJlIG5vdCBpbmhlcml0ZWQKKyAgICBzaG9ydCBjb3VudGVySW5j cmVtZW50OyAvLyBvaywgc28gdGhlc2UgYXJlIG5vdCB2aXN1YWwgbW9kZSBzcGVjaWZpYworICAg IHNob3J0IGNvdW50ZXJSZXNldDsgICAgIC8vIGNhbid0IGdvIHRvIGluaGVyaXRlZCwgc2luY2Ug dGhlc2UgYXJlIG5vdCBpbmhlcml0ZWQKIAogfTsKIApAQCAtODcyLDYgKzg3NywyMCBAQAogICAg IENPTlRFTlRfTk9ORSwgQ09OVEVOVF9PQkpFQ1QsIENPTlRFTlRfVEVYVCwgQ09OVEVOVF9DT1VO VEVSCiB9OwogCitzdHJ1Y3QgQ291bnRlckRhdGEgeworICAgIENvdW50ZXJEYXRhKCkge30KKyAg ICBDb3VudGVyRGF0YShjb25zdCBTdHJpbmcmIGksIEVMaXN0U3R5bGVUeXBlIGwsIGNvbnN0IFN0 cmluZyYgc2VwKSA6aWRlbnQoaSksIGxzKGwpLCBzKHNlcCkge30KKyAgICAKKyAgICBTdHJpbmcg aWRlbnRpZmllcigpIHsgcmV0dXJuIGlkZW50OyB9CisgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0 eWxlKCkgeyByZXR1cm4gbHM7IH0KKyAgICBTdHJpbmcgc2VwYXJhdG9yKCkgeyByZXR1cm4gczsg fQorCitwcml2YXRlOgorICAgIFN0cmluZyBpZGVudDsKKyAgICBFTGlzdFN0eWxlVHlwZSBsczsK KyAgICBTdHJpbmcgczsKK307CisKIHN0cnVjdCBDb250ZW50RGF0YSB7CiAgICAgQ29udGVudERh dGEoKSA6X2NvbnRlbnRUeXBlKENPTlRFTlRfTk9ORSksIF9uZXh0Q29udGVudCgwKSB7fQogICAg IH5Db250ZW50RGF0YSgpOwpAQCAtODgxLDEzICs5MDAsMTQgQEAKIAogICAgIFN0cmluZ0ltcGwq IGNvbnRlbnRUZXh0KCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHJldHVy biBfY29udGVudC50ZXh0OyByZXR1cm4gMDsgfQogICAgIENhY2hlZFJlc291cmNlKiBjb250ZW50 T2JqZWN0KCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkgcmV0dXJuIF9j b250ZW50Lm9iamVjdDsgcmV0dXJuIDA7IH0KKyAgICBDb3VudGVyRGF0YSogY29udGVudENvdW50 ZXIoKSB7IGlmIChjb250ZW50VHlwZSgpID09IENPTlRFTlRfQ09VTlRFUikgcmV0dXJuIF9jb250 ZW50LmNvdW50ZXI7IHJldHVybiAwOyB9CiAgICAgCiAgICAgQ29udGVudFR5cGUgX2NvbnRlbnRU eXBlOwogCiAgICAgdW5pb24gewogICAgICAgICBDYWNoZWRSZXNvdXJjZSogb2JqZWN0OwogICAg ICAgICBTdHJpbmdJbXBsKiB0ZXh0OwotICAgICAgICAvLyBjb3VudGVycy4uLgorICAgICAgICBD b3VudGVyRGF0YSogY291bnRlcjsKICAgICB9IF9jb250ZW50IDsKIAogICAgIENvbnRlbnREYXRh KiBfbmV4dENvbnRlbnQ7CkBAIC0xMDQ1LDcgKzEwNjUsOSBAQAogICAgIAogICAgIC8vIGFkZGVk IHRoaXMgaGVyZSwgc28gd2UgY2FuIGdldCByaWQgb2YgdGhlIHZwdHIgaW4gdGhpcyBjbGFzcy4K ICAgICAvLyBtYWtlcyB1cCBmb3IgdGhlIHNhbWUgc2l6ZS4KLSAgICBDb250ZW50RGF0YSAqY29u dGVudDsKKyAgICBDb250ZW50RGF0YSogY29udGVudDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0 PiBjb3VudGVyUmVzZXRMaXN0OworICAgIFJlZlB0cjxDU1NWYWx1ZUxpc3Q+IGNvdW50ZXJJbmNy ZW1lbnRMaXN0OwogCiAgICAgdW5zaWduZWQgbV9wc2V1ZG9TdGF0ZSA6IDM7IC8vIFBzZXVkb1N0 YXRlCiAgICAgYm9vbCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMgOiAxOwpAQCAtMTI5 NSw4ICsxMzE3LDggQEAKICAgICBFRW1wdHlDZWxsIGVtcHR5Q2VsbHMoKSBjb25zdCB7IHJldHVy biBzdGF0aWNfY2FzdDxFRW1wdHlDZWxsPihpbmhlcml0ZWRfZmxhZ3MuX2VtcHR5X2NlbGxzKTsg fQogICAgIEVDYXB0aW9uU2lkZSBjYXB0aW9uU2lkZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19j YXN0PEVDYXB0aW9uU2lkZT4oaW5oZXJpdGVkX2ZsYWdzLl9jYXB0aW9uX3NpZGUpOyB9CiAKLSAg ICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVy X2luY3JlbWVudDsgfQotICAgIHNob3J0IGNvdW50ZXJSZXNldCgpIGNvbnN0IHsgcmV0dXJuIHZp c3VhbC0+Y291bnRlcl9yZXNldDsgfQorICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoKSBjb25z dCB7IHJldHVybiB2aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQ7IH0KKyAgICBzaG9ydCBjb3VudGVy UmVzZXQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNvdW50ZXJSZXNldDsgfQogCiAgICAgRUxp c3RTdHlsZVR5cGUgbGlzdFN0eWxlVHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVM aXN0U3R5bGVUeXBlPihpbmhlcml0ZWRfZmxhZ3MuX2xpc3Rfc3R5bGVfdHlwZSk7IH0KICAgICBD YWNoZWRJbWFnZSAqbGlzdFN0eWxlSW1hZ2UoKSBjb25zdCB7IHJldHVybiBpbmhlcml0ZWQtPnN0 eWxlX2ltYWdlOyB9CkBAIC0xNTAxLDggKzE1MjMsOCBAQAogICAgIHZvaWQgc2V0Q2FwdGlvblNp ZGUoRUNhcHRpb25TaWRlIHYpIHsgaW5oZXJpdGVkX2ZsYWdzLl9jYXB0aW9uX3NpZGUgPSB2OyB9 CiAKIAotICAgIHZvaWQgc2V0Q291bnRlckluY3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZp c3VhbCxjb3VudGVyX2luY3JlbWVudCx2KSB9Ci0gICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoc2hv cnQgdikgeyAgU0VUX1ZBUih2aXN1YWwsY291bnRlcl9yZXNldCx2KSB9CisgICAgdm9pZCBzZXRD b3VudGVySW5jcmVtZW50KHNob3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJJbmNyZW1l bnQsdikgfQorICAgIHZvaWQgc2V0Q291bnRlclJlc2V0KHNob3J0IHYpIHsgIFNFVF9WQVIodmlz dWFsLGNvdW50ZXJSZXNldCx2KSB9CiAKICAgICB2b2lkIHNldExpc3RTdHlsZVR5cGUoRUxpc3RT dHlsZVR5cGUgdikgeyBpbmhlcml0ZWRfZmxhZ3MuX2xpc3Rfc3R5bGVfdHlwZSA9IHY7IH0KICAg ICB2b2lkIHNldExpc3RTdHlsZUltYWdlKENhY2hlZEltYWdlICp2KSB7ICBTRVRfVkFSKGluaGVy aXRlZCxzdHlsZV9pbWFnZSx2KX0KQEAgLTE1OTcsNyArMTYxOSwxOCBAQAogICAgIGJvb2wgY29u dGVudERhdGFFcXVpdmFsZW50KGNvbnN0IFJlbmRlclN0eWxlICpvdGhlclN0eWxlKSBjb25zdDsK ICAgICB2b2lkIHNldENvbnRlbnQoU3RyaW5nSW1wbCogcywgYm9vbCBhZGQgPSBmYWxzZSk7CiAg ICAgdm9pZCBzZXRDb250ZW50KENhY2hlZFJlc291cmNlKiBvLCBib29sIGFkZCA9IGZhbHNlKTsK KyAgICB2b2lkIHNldENvbnRlbnQoQ291bnRlckRhdGEqLCBib29sIGFkZCA9IGZhbHNlKTsKIAor ICAgIGJvb2wgY291bnRlckRhdGFFcXVpdmFsZW50KFJlbmRlclN0eWxlKik7CisgICAgdm9pZCBz ZXRDb3VudGVyUmVzZXRMaXN0KFBhc3NSZWZQdHI8Q1NTVmFsdWVMaXN0PiBsKSB7IGNvdW50ZXJS ZXNldExpc3QgPSBsOyB9CisgICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50TGlzdChQYXNzUmVm UHRyPENTU1ZhbHVlTGlzdD4gbCkgeyBjb3VudGVySW5jcmVtZW50TGlzdCA9IGw7IH0KKyAgICBi b29sIGhhc0NvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICBib29sIGhhc0Nv dW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgc2hvcnQgY291bnRlclJl c2V0KGNvbnN0IFN0cmluZyYpIGNvbnN0OworICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoY29u c3QgU3RyaW5nJikgY29uc3Q7CisgICAgUGFzc1JlZlB0cjxDU1NWYWx1ZUxpc3Q+IGNvdW50ZXJS ZXNldFZhbHVlTGlzdCgpIHsgcmV0dXJuIGNvdW50ZXJSZXNldExpc3Q7IH0KKyAgICBQYXNzUmVm UHRyPENTU1ZhbHVlTGlzdD4gY291bnRlckluY3JlbWVudFZhbHVlTGlzdCgpIHsgcmV0dXJuIGNv dW50ZXJJbmNyZW1lbnRMaXN0OyB9CisKICAgICBib29sIGluaGVyaXRlZE5vdEVxdWFsKCBSZW5k ZXJTdHlsZSAqb3RoZXIgKSBjb25zdDsKIAogICAgIC8vIFRoZSBkaWZmZXJlbmNlIGJldHdlZW4g dHdvIHN0eWxlcy4gIFRoZSBmb2xsb3dpbmcgdmFsdWVzIGFyZSB1c2VkOgpJbmRleDogcmVuZGVy aW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVy UmVzZXROb2RlLmNwcAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2Rl LmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw5OCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBw YXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICog Q29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICog bW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJs aWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRp b24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5Z IFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNI QU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUg R05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K KyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFy eSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2Vl IHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICog Qm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJDb3VudGVyUmVzZXROb2RlLmgiCisKKyNpbmNsdWRlICJSZW5kZXJPYmpl Y3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitDb3VudGVyUmVzZXROb2RlOjpDb3VudGVy UmVzZXROb2RlKFJlbmRlck9iamVjdCogbykgOiBDb3VudGVyTm9kZShvKSwgbV90b3RhbCgwKSwg bV9maXJzdCgwKSwgbV9sYXN0KDApIHt9CitDb3VudGVyUmVzZXROb2RlOjp+Q291bnRlclJlc2V0 Tm9kZSgpIHt9OworCit2b2lkIENvdW50ZXJSZXNldE5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJO b2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKQoreworICAgIEFTU0VSVChuZXdD aGlsZCk7CisgICAgQVNTRVJUKCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+cGFyZW50KCkgPT0gdGhp cyk7CisKKyAgICBuZXdDaGlsZC0+bV9wYXJlbnQgPSB0aGlzOworICAgIG5ld0NoaWxkLT5tX3By ZXZpb3VzID0gcmVmQ2hpbGQ7CisKKyAgICBpZiAocmVmQ2hpbGQpIHsKKyAgICAgICAgbmV3Q2hp bGQtPm1fbmV4dCA9IHJlZkNoaWxkLT5tX25leHQ7CisgICAgICAgIHJlZkNoaWxkLT5tX25leHQg PSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAgICAgICBuZXdDaGlsZC0+bV9uZXh0ID0gbV9m aXJzdDsKKyAgICAgICAgbV9maXJzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIGlmIChuZXdD aGlsZC0+bV9uZXh0KSB7CisgICAgICAgIGFzc2VydChuZXdDaGlsZC0+bV9uZXh0LT5tX3ByZXZp b3VzID09IHJlZkNoaWxkKTsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9 IG5ld0NoaWxkOworICAgIH0gZWxzZSB7CisgICAgICAgIGFzc2VydCAobV9sYXN0ID09IHJlZkNo aWxkKTsKKyAgICAgICAgbV9sYXN0ID0gbmV3Q2hpbGQ7CisgICAgfQorCisgICAgbmV3Q2hpbGQt PnJlY291bnQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnJlY291bnQoYm9v bCBzZXREaXJ0eSkKK3sKKyAgICBib29sIHJlY291bnROZXh0ID0gdHJ1ZTsKKyAgICBmb3IgKENv dW50ZXJSZXNldE5vZGUqIGMgPSB0aGlzOyBjICYmIHJlY291bnROZXh0OyBjID0gc3RhdGljX2Nh c3Q8Q291bnRlclJlc2V0Tm9kZSo+KGMtPm5leHRTaWJsaW5nKCkpKSB7CisgICAgICAgIGludCBv bGRDb3VudCA9IG1fY291bnQ7CisgICAgICAgIGlmIChjLT5wcmV2aW91c1NpYmxpbmcoKSkKKyAg ICAgICAgICAgIGMtPnNldENvdW50KGMtPnByZXZpb3VzU2libGluZygpLT5jb3VudCgpKTsKKyAg ICAgICAgZWxzZSBpZiAoYy0+cGFyZW50KCkpCisgICAgICAgICAgICBjLT5zZXRDb3VudChjLT5w YXJlbnQoKS0+dmFsdWUoKSk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGMtPnNldENvdW50 KDApOworCisgICAgICAgIGMtPnVwZGF0ZVRvdGFsKGMtPnZhbHVlKCkpOworICAgICAgICBpZiAo c2V0RGlydHkpCisgICAgICAgICAgICBjLT5zZXRTZWxmRGlydHkoKTsKKyAgICAgICAgCisgICAg ICAgIHJlY291bnROZXh0ID0gb2xkQ291bnQgIT0gYy0+Y291bnQoKSB8fCAhc2V0RGlydHk7Cisg ICAgICAgIHNldERpcnR5ID0gdHJ1ZTsKKyAgICB9Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9k ZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlmIChoYXNDb3VudGVycygpKQorICAgICAgICBz ZXRTZWxmRGlydHkoKTsKKyAgICAgICAgCisgICAgZm9yIChDb3VudGVyTm9kZSogbiA9IGZpcnN0 Q2hpbGQoKTsgbjsgbiA9IG4tPm5leHRTaWJsaW5nKCkpCisgICAgICAgIGlmIChuLT5oYXNDb3Vu dGVycygpKQorICAgICAgICAgICAgbi0+c2V0U2VsZkRpcnR5KCk7Cit9CisKK3ZvaWQgQ291bnRl clJlc2V0Tm9kZTo6dXBkYXRlVG90YWwoaW50IHZhbHVlKQoreworICAgIGlmICh2YWx1ZSA+IG1f dG90YWwpCisgICAgICAgIG1fdG90YWwgPSB2YWx1ZTsKK30KKworfSAvLyBuYW1lc3BhY2UKSW5k ZXg6IHJlbmRlcmluZy9SZW5kZXJDb250YWluZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmlu Zy9SZW5kZXJDb250YWluZXIuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJlbmRlcmluZy9SZW5k ZXJDb250YWluZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJp Z2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMp IDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMp IDIwMDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIw MDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0 IChDKSAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKiBDb3B5 cmlnaHQgKEMpIDIwMDYgQW5kcmV3IFdlbGxpbmd0b24gKHByb3RvbkB3aXJldGFwcGVkLm5ldCkK ICAqCkBAIC0yOCw2ICsyOSw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQ29udGFpbmVyLmgiCiAKICNp bmNsdWRlICJodG1sZWRpdGluZy5oIgorI2luY2x1ZGUgIlJlbmRlckNvdW50ZXIuaCIKICNpbmNs dWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlclRhYmxlLmgiCiAjaW5jbHVk ZSAiUmVuZGVyVGV4dEZyYWdtZW50LmgiCkBAIC0yOTYsNyArMjk4LDcgQEAKICAgICAgICAgLy8g ZGV0ZXJtaW5lZCB0aGF0IHRoZSBwc2V1ZG8gaXMgbm90IGRpc3BsYXkgTk9ORSwgYW55IGRpc3Bs YXkgb3RoZXIgdGhhbgogICAgICAgICAvLyBpbmxpbmUgc2hvdWxkIGJlIG11dGF0ZWQgdG8gSU5M SU5FLgogICAgICAgICBwc2V1ZG8tPnNldERpc3BsYXkoSU5MSU5FKTsKLSAgICAKKwogICAgIGlm IChvbGRDb250ZW50UHJlc2VudCkgewogICAgICAgICBpZiAoY2hpbGQgJiYgY2hpbGQtPnN0eWxl KCktPnN0eWxlVHlwZSgpID09IHR5cGUpIHsKICAgICAgICAgICAgIC8vIFdlIGhhdmUgZ2VuZXJh dGVkIGNvbnRlbnQgcHJlc2VudCBzdGlsbC4gIFdlIHdhbnQgdG8gd2FsayB0aGlzIGNvbnRlbnQg YW5kIHVwZGF0ZSBvdXIKQEAgLTMzNCwyMCArMzM2LDI0IEBACiAgICAgICAgIGlmICghcHNldWRv Q29udGFpbmVyKQogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyID0gUmVuZGVyRmxvdzo6Y3Jl YXRlQW5vbnltb3VzRmxvdyhkb2N1bWVudCgpLCBwc2V1ZG8pOyAvKiBhbm9ueW1vdXMgYm94ICov CiAgICAgICAgIAotICAgICAgICBpZiAoY29udGVudERhdGEtPmNvbnRlbnRUeXBlKCkgPT0gQ09O VEVOVF9URVhUKQotICAgICAgICB7CisgICAgICAgIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5 cGUoKSA9PSBDT05URU5UX1RFWFQpIHsKICAgICAgICAgICAgIFJlbmRlclRleHQqIHQgPSBuZXcg KHJlbmRlckFyZW5hKCkpIFJlbmRlclRleHRGcmFnbWVudChkb2N1bWVudCgpIC8qYW5vbnltb3Vz IG9iamVjdCAqLywgY29udGVudERhdGEtPmNvbnRlbnRUZXh0KCkpOwogICAgICAgICAgICAgdC0+ c2V0U3R5bGUocHNldWRvKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQo dCk7Ci0gICAgICAgIH0KLSAgICAgICAgZWxzZSBpZiAoY29udGVudERhdGEtPmNvbnRlbnRUeXBl KCkgPT0gQ09OVEVOVF9PQkpFQ1QpCi0gICAgICAgIHsKKyAgICAgICAgfSBlbHNlIGlmIChjb250 ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkgewogICAgICAgICAgICAg UmVuZGVySW1hZ2UqIGltZyA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVySW1hZ2UoZG9jdW1l bnQoKSk7IC8qIEFub255bW91cyBvYmplY3QgKi8KICAgICAgICAgICAgIFJlbmRlclN0eWxlKiBz dHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsKICAgICAgICAgICAgIHN0 eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOwogICAgICAgICAgICAgaW1nLT5zZXRTdHlsZShzdHls ZSk7CiAgICAgICAgICAgICBpbWctPnNldENvbnRlbnRPYmplY3QoY29udGVudERhdGEtPmNvbnRl bnRPYmplY3QoKSk7CiAgICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKGltZyk7 CisgICAgICAgIH0gZWxzZSBpZiAoY29udGVudERhdGEtPl9jb250ZW50VHlwZSA9PSBDT05URU5U X0NPVU5URVIpIHsKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIqIGMgPSBuZXcgKHJlbmRlckFy ZW5hKCkpIFJlbmRlckNvdW50ZXIoZWxlbWVudCgpLCBjb250ZW50RGF0YS0+Y29udGVudENvdW50 ZXIoKSk7CisgICAgICAgICAgICBSZW5kZXJTdHlsZSogc3R5bGUgPSBuZXcgKHJlbmRlckFyZW5h KCkpIFJlbmRlclN0eWxlKCk7CisgICAgICAgICAgICBzdHlsZS0+aW5oZXJpdEZyb20ocHNldWRv KTsKKyAgICAgICAgICAgIGMtPnNldElzQW5vbnltb3VzKHRydWUpOworICAgICAgICAgICAgYy0+ c2V0U3R5bGUoc3R5bGUpOworICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRDaGlsZChj KTsKICAgICAgICAgfQogICAgIH0KIApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgJKHJldmlzaW9uIDApCisrKyByZW5k ZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw4NCBAQAorLyoKKyAq IFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4K KyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2Fy ZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisg KgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRl IGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJh cnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNv ZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBv ciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFy eSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICog YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y IG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRo aXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bwor ICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0g U3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorKi8KKyNpZm5k ZWYgQ291bnRlcl9Ob2RlX2hfCisjZGVmaW5lIENvdW50ZXJfTm9kZV9oXworCisjaW5jbHVkZSAi UmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgQ291bnRlclJl c2V0Tm9kZTsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3VudGVyLXRyZWUgdGhhdCBp cyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9va3VwLAorLy8g YW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9kZXMgYXJlIGFkZGVkIG9y IHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRlci1yZXNldCBhbmQgcm9v dCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJlZSBwYXJlbnRzCisvLyBh cmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVtZW50YXRpb24gb2YgY291 bnRlci1pbmNyZW1lbnQgYW5kIGNvdW50ZXItY29udGVudAorY2xhc3MgQ291bnRlck5vZGUgewor cHVibGljOgorICAgIENvdW50ZXJOb2RlKFJlbmRlck9iamVjdCopOworICAgIHZpcnR1YWwgfkNv dW50ZXJOb2RlKCkge30KKworICAgIENvdW50ZXJSZXNldE5vZGUqIHBhcmVudCgpIGNvbnN0IHsg cmV0dXJuIG1fcGFyZW50OyB9CisgICAgQ291bnRlck5vZGUqIHByZXZpb3VzU2libGluZygpIGNv bnN0IHsgcmV0dXJuIG1fcHJldmlvdXM7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBuZXh0 U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dDsgfQorICAgIHZpcnR1YWwgQ291bnRlck5v ZGUqIGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCBDb3VudGVy Tm9kZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgdm9pZCBp bnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGlsZCk7 CisKKyAgICBzaG9ydCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFsdWU7IH0KKyAgICB2b2lk IHNldFZhbHVlKHNob3J0IHYpIHsgbV92YWx1ZSA9IHY7IH0KKyAgICBzaG9ydCBjb3VudCgpIGNv bnN0IHsgcmV0dXJuIG1fY291bnQ7IH0KKyAgICB2b2lkIHNldENvdW50KHNob3J0IGMpIHsgbV9j b3VudCA9IGM7IH0KKyAgICB2b2lkIHNldEhhc0NvdW50ZXJzKCkgeyBtX2hhc0NvdW50ZXJzID0g dHJ1ZTsgfQorCisgICAgdmlydHVhbCBib29sIGlzUmVzZXQoKSB7IHJldHVybiBmYWxzZTsgfQor ICAgIHZpcnR1YWwgdm9pZCByZWNvdW50KGJvb2wgc2V0RGlydHkgPSB0cnVlKTsKKyAgICB2aXJ0 dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisgICAgdmlydHVhbCB2b2lkIHNldFBhcmVudERpcnR5 KCk7CisKKyAgICBib29sIGhhc0NvdW50ZXJzKCkgY29uc3QgeyByZXR1cm4gbV9oYXNDb3VudGVy czsgfTsKKyAgICBib29sIGlzVmlzdWFsKCkgY29uc3QgeyByZXR1cm4gbV9pc1Zpc3VhbDsgfTsK KyAgICB2b2lkIHNldFVzZXNDb3VudGVycygpOworICAgIHZvaWQgc2V0SXNWaXN1YWwoKSB7IG1f aXNWaXN1YWwgPSB0cnVlOyB9OworICAgIGJvb2wgaXNSb290KCkgY29uc3QgeyByZXR1cm4gbV9y ZW5kZXJlciAmJiBtX3JlbmRlcmVyLT5pc1Jvb3QoKTsgfQorCisgICAgdm9pZCBzZXRSZW5kZXJl cihSZW5kZXJPYmplY3QqIG8pIHsgbV9yZW5kZXJlciA9IG87IH07CisgICAgUmVuZGVyT2JqZWN0 KiByZW5kZXJlcigpIGNvbnN0IHsgcmV0dXJuIG1fcmVuZGVyZXI7IH07CisKKyAgICBmcmllbmQg Y2xhc3MgQ291bnRlclJlc2V0Tm9kZTsKK3Byb3RlY3RlZDoKKyAgICBib29sIG1faGFzQ291bnRl cnM7CisgICAgYm9vbCBtX2lzVmlzdWFsOworICAgIHNob3J0IG1fdmFsdWU7CisgICAgc2hvcnQg bV9jb3VudDsKKyAgICBDb3VudGVyUmVzZXROb2RlKiBtX3BhcmVudDsKKyAgICBDb3VudGVyTm9k ZSogbV9wcmV2aW91czsKKyAgICBDb3VudGVyTm9kZSogbV9uZXh0OworICAgIFJlbmRlck9iamVj dCogbV9yZW5kZXJlcjsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8v IENvdW50ZXJOb2RlX2gKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJTdHlsZS5jcHAKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5k ZXJpbmcvUmVuZGVyU3R5bGUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC05MCw4ICs5MCw4IEBACiAg ICAgOiBoYXNDbGlwKGZhbHNlKQogICAgICwgdGV4dERlY29yYXRpb24oUmVuZGVyU3R5bGU6Omlu aXRpYWxUZXh0RGVjb3JhdGlvbigpKQogICAgICwgY29sc3BhbigxKQotICAgICwgY291bnRlcl9p bmNyZW1lbnQoMCkKLSAgICAsIGNvdW50ZXJfcmVzZXQoMCkKKyAgICAsIGNvdW50ZXJJbmNyZW1l bnQoMCkKKyAgICAsIGNvdW50ZXJSZXNldCgwKQogewogfQogCkBAIC0xMDUsOCArMTA1LDggQEAK ICAgICAsIGhhc0NsaXAoby5oYXNDbGlwKQogICAgICwgdGV4dERlY29yYXRpb24oby50ZXh0RGVj b3JhdGlvbikKICAgICAsIGNvbHNwYW4oby5jb2xzcGFuKQotICAgICwgY291bnRlcl9pbmNyZW1l bnQoby5jb3VudGVyX2luY3JlbWVudCkKLSAgICAsIGNvdW50ZXJfcmVzZXQoby5jb3VudGVyX3Jl c2V0KQorICAgICwgY291bnRlckluY3JlbWVudChvLmNvdW50ZXJJbmNyZW1lbnQpCisgICAgLCBj b3VudGVyUmVzZXQoby5jb3VudGVyUmVzZXQpCiB7CiB9CiAKQEAgLTU3Nyw3ICs1NzcsNiBAQAog ICAgICAgICBwcmV2LT5kZXJlZihhcmVuYSk7CiAgICAgfQogICAgIGRlbGV0ZSBjb250ZW50Owot ICAgIAogICAgIGRlbGV0ZSB0aGlzOwogICAgIAogICAgIC8vIFJlY292ZXIgdGhlIHNpemUgbGVm dCB0aGVyZSBmb3IgdXMgYnkgb3BlcmF0b3IgZGVsZXRlIGFuZCBmcmVlIHRoZSBtZW1vcnkuCkBA IC02NDksNiArNjQ4LDggQEAKICAgICAsIGluaGVyaXRlZChvLmluaGVyaXRlZCkKICAgICAsIHBz ZXVkb1N0eWxlKDApCiAgICAgLCBjb250ZW50KG8uY29udGVudCkKKyAgICAsIGNvdW50ZXJSZXNl dExpc3Qoby5jb3VudGVyUmVzZXRMaXN0KQorICAgICwgY291bnRlckluY3JlbWVudExpc3Qoby5j b3VudGVySW5jcmVtZW50TGlzdCkKICAgICAsIG1fcHNldWRvU3RhdGUoby5tX3BzZXVkb1N0YXRl KQogICAgICwgbV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzKGZhbHNlKQogICAgICwgbV91 bmlxdWUoZmFsc2UpCkBAIC04MzgsOCArODM5LDggQEAKICAgICAgICAgIShub25pbmhlcml0ZWRf ZmxhZ3MuX2Zsb2F0aW5nID09IG90aGVyLT5ub25pbmhlcml0ZWRfZmxhZ3MuX2Zsb2F0aW5nKSB8 fAogICAgICAgICAhKG5vbmluaGVyaXRlZF9mbGFncy5fb3JpZ2luYWxEaXNwbGF5ID09IG90aGVy LT5ub25pbmhlcml0ZWRfZmxhZ3MuX29yaWdpbmFsRGlzcGxheSkgfHwKICAgICAgICAgIHZpc3Vh bC0+Y29sc3BhbiAhPSBvdGhlci0+dmlzdWFsLT5jb2xzcGFuIHx8Ci0gICAgICAgICB2aXN1YWwt PmNvdW50ZXJfaW5jcmVtZW50ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJfaW5jcmVtZW50IHx8 Ci0gICAgICAgICB2aXN1YWwtPmNvdW50ZXJfcmVzZXQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRl cl9yZXNldCB8fAorICAgICAgICAgdmlzdWFsLT5jb3VudGVySW5jcmVtZW50ICE9IG90aGVyLT52 aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQgfHwKKyAgICAgICAgIHZpc3VhbC0+Y291bnRlclJlc2V0 ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJSZXNldCB8fAogICAgICAgICAgY3NzM05vbkluaGVy aXRlZERhdGEtPnRleHRPdmVyZmxvdyAhPSBvdGhlci0+Y3NzM05vbkluaGVyaXRlZERhdGEtPnRl eHRPdmVyZmxvdyB8fAogICAgICAgICAgKGNzczNJbmhlcml0ZWREYXRhLT50ZXh0U2VjdXJpdHkg IT0gb3RoZXItPmNzczNJbmhlcml0ZWREYXRhLT50ZXh0U2VjdXJpdHkpKQogICAgICAgICByZXR1 cm4gTGF5b3V0OwpAQCAtMTA4MCw2ICsxMDgxLDMyIEBACiAgICAgbmV3Q29udGVudERhdGEtPl9j b250ZW50VHlwZSA9IENPTlRFTlRfVEVYVDsKIH0KIAordm9pZCBSZW5kZXJTdHlsZTo6c2V0Q29u dGVudChDb3VudGVyRGF0YSogYywgYm9vbCBhZGQpCit7CisgICAgaWYgKCFjKQorICAgICAgICBy ZXR1cm47CisKKyAgICBDb250ZW50RGF0YSogbGFzdENvbnRlbnQgPSBjb250ZW50OworICAgIHdo aWxlIChsYXN0Q29udGVudCAmJiBsYXN0Q29udGVudC0+X25leHRDb250ZW50KQorICAgICAgICBs YXN0Q29udGVudCA9IGxhc3RDb250ZW50LT5fbmV4dENvbnRlbnQ7CisKKyAgICBib29sIHJldXNl Q29udGVudCA9ICFhZGQ7CisgICAgQ29udGVudERhdGEqIG5ld0NvbnRlbnREYXRhID0gMDsKKyAg ICBpZiAocmV1c2VDb250ZW50ICYmIGNvbnRlbnQpIHsKKyAgICAgICAgY29udGVudC0+Y2xlYXJD b250ZW50KCk7CisgICAgICAgIG5ld0NvbnRlbnREYXRhID0gY29udGVudDsKKyAgICB9IGVsc2UK KyAgICAgICAgbmV3Q29udGVudERhdGEgPSBuZXcgQ29udGVudERhdGE7CisKKyAgICBpZiAobGFz dENvbnRlbnQgJiYgIXJldXNlQ29udGVudCkKKyAgICAgICAgbGFzdENvbnRlbnQtPl9uZXh0Q29u dGVudCA9IG5ld0NvbnRlbnREYXRhOworICAgIGVsc2UKKyAgICAgICAgY29udGVudCA9IG5ld0Nv bnRlbnREYXRhOworCisgICAgbmV3Q29udGVudERhdGEtPl9jb250ZW50LmNvdW50ZXIgPSBjOwor ICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudFR5cGUgPSBDT05URU5UX0NPVU5URVI7Cit9CisK IENvbnRlbnREYXRhOjp+Q29udGVudERhdGEoKQogewogICAgIGNsZWFyQ29udGVudCgpOwpAQCAt MTA5OCw2ICsxMTI1LDEwIEBACiAgICAgICAgIGNhc2UgQ09OVEVOVF9URVhUOgogICAgICAgICAg ICAgX2NvbnRlbnQudGV4dC0+ZGVyZWYoKTsKICAgICAgICAgICAgIF9jb250ZW50LnRleHQgPSAw OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgQ09OVEVOVF9DT1VOVEVSOgorICAg ICAgICAgICAgX2NvbnRlbnQuY291bnRlciA9IDA7CisgICAgICAgICAgICBicmVhazsKICAgICAg ICAgZGVmYXVsdDoKICAgICAgICAgICAgIDsKICAgICB9CkBAIC0xMTg1LDYgKzEyMTYsODMgQEAK ICAgICByZXR1cm4geCA9PSBvLnggJiYgeSA9PSBvLnkgJiYgYmx1ciA9PSBvLmJsdXIgJiYgY29s b3IgPT0gby5jb2xvcjsKIH0KIAorYm9vbCBSZW5kZXJTdHlsZTo6Y291bnRlckRhdGFFcXVpdmFs ZW50KFJlbmRlclN0eWxlKiBvdGhlclN0eWxlKQoreworICAgIC8vIEZJWE1FOiBTaG91bGQgd2Ug YWxzbyBjb21wYXJlIHRoZSBDb3VudGVyRGF0YT8gCisgICAgcmV0dXJuIGNvdW50ZXJSZXNldExp c3QgPT0gb3RoZXJTdHlsZS0+Y291bnRlclJlc2V0TGlzdCAmJgorICAgICAgICAgICBjb3VudGVy SW5jcmVtZW50TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVySW5jcmVtZW50TGlzdDsKK30KKwor c3RhdGljIGJvb2wgaGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGMsIENTU1ZhbHVlTGlzdCogbCkK K3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBs ZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0aXZlVmFsdWUgPSBz dGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0oaSkpOworICAgICAgICBQYWly KiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgpOworICAgICAgICBDU1NQcmlt aXRpdmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+ KHBhaXItPmZpcnN0KCkpOworICAgICAgICBBU1NFUlQocGFpciAmJiBjb3VudGVyTmFtZSk7Cisg ICAgICAgIGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBjKQorICAgICAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5k ZXJTdHlsZTo6aGFzQ291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0 Cit7CisgICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiBoYXNDb3VudGVy KGNvdW50ZXJOYW1lLCBjb3VudGVyUmVzZXRMaXN0LmdldCgpKTsKKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKK2Jvb2wgUmVuZGVyU3R5bGU6Omhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5n JiBjb3VudGVyTmFtZSkgY29uc3QKK3sKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisg ICAgICAgIHJldHVybiBoYXNDb3VudGVyKGNvdW50ZXJOYW1lLCBjb3VudGVySW5jcmVtZW50TGlz dC5nZXQoKSk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgc2hvcnQgcmVhZENvdW50 ZXIoY29uc3QgU3RyaW5nJiBjLCBDU1NWYWx1ZUxpc3QqIGwsIGJvb2wgaXNSZXNldCkKK3sKKyAg ICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAgc2hvcnQgdG90YWwgPSAwOworICAgIAorICAg IGZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFs dWUqIHByaW1pdGl2ZVZhbHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihsLT5p dGVtKGkpKTsKKyAgICAgICAgUGFpciogcGFpciA9IHByaW1pdGl2ZVZhbHVlLT5nZXRQYWlyVmFs dWUoKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nh c3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAgQ1NTUHJpbWl0 aXZlVmFsdWUqIGNvdW50ZXJWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4o cGFpci0+c2Vjb25kKCkpOworICAgICAgICBBU1NFUlQocGFpciAmJiBjb3VudGVyTmFtZSAmJiBj b3VudGVyVmFsdWUpOworCisgICAgICAgIGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUo KSA9PSBjKSB7CisgICAgICAgICAgICBpbnQgdG90YWxJbnQgPSB0b3RhbCArIGNvdW50ZXJWYWx1 ZS0+Z2V0RmxvYXRWYWx1ZSgpOworICAgICAgICAgICAgaWYgKHRvdGFsSW50IDwgU0hSVF9NQVgg JiYgdG90YWxJbnQgPiBTSFJUX01JTikKKyAgICAgICAgICAgICAgICB0b3RhbCArPSAoc2hvcnQp Y291bnRlclZhbHVlLT5nZXRGbG9hdFZhbHVlKCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAg ICAgICAgICAgcmV0dXJuIHRvdGFsOworICAgICAgICAgICAgaWYgKGlzUmVzZXQpCisgICAgICAg ICAgICAgICAgcmV0dXJuIHRvdGFsOworICAgICAgICB9CisgICAgfQorICAgIAorICAgIHJldHVy biB0b3RhbDsKK30KKworc2hvcnQgUmVuZGVyU3R5bGU6OmNvdW50ZXJSZXNldChjb25zdCBTdHJp bmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAgIGlmIChjb3VudGVyUmVzZXRMaXN0KQorICAg ICAgICByZXR1cm4gcmVhZENvdW50ZXIoY291bnRlck5hbWUsIGNvdW50ZXJSZXNldExpc3QuZ2V0 KCksIHRydWUpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKK3Nob3J0IFJlbmRl clN0eWxlOjpjb3VudGVySW5jcmVtZW50KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0 Cit7CisgICAgaWYgKGNvdW50ZXJJbmNyZW1lbnRMaXN0KQorICAgICAgICByZXR1cm4gcmVhZENv dW50ZXIoY291bnRlck5hbWUsIGNvdW50ZXJJbmNyZW1lbnRMaXN0LmdldCgpLCBmYWxzZSk7Cisg ICAgZWxzZQorICAgICAgICByZXR1cm4gMDsKK30KKwogY29uc3QgVmVjdG9yPFN0eWxlRGFzaGJv YXJkUmVnaW9uPiYgUmVuZGVyU3R5bGU6OmluaXRpYWxEYXNoYm9hcmRSZWdpb25zKCkKIHsgCiAg ICAgc3RhdGljIFZlY3RvcjxTdHlsZURhc2hib2FyZFJlZ2lvbj4gZW1wdHlMaXN0OwpJbmRleDog V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagkocmV2aXNpb24gMTY1MjgpCisrKyBXZWJDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTg1Nyw2ICs4NTcsMTMg QEAKIAkJOTM1RkJDRjIwOUJBMTQzQjAwRTIzMEIxIC8qIEV4Y2VwdGlvbkNvZGUuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNUZCQ0YxMDlCQTE0M0Iw MEUyMzBCMSAvKiBFeGNlcHRpb25Db2RlLmggKi87IH07CiAJCTkzNkI0MjRFMDlBNDM2Q0QwMEJB QTgyMCAvKiBTVkdDU1NQYXJzZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gQThDMEY2RjYwODk3MDFGMTAwQkE1MTE0IC8qIFNWR0NTU1BhcnNlci5j cHAgKi87IH07CiAJCTkzNkJERDFEMEEwMzFBRUIwMDRERjRBQiAvKiBHcmFwaGljc0NvbnRleHRD Ry5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzZC REQxQzBBMDMxQUVCMDA0REY0QUIgLyogR3JhcGhpY3NDb250ZXh0Q0cuY3BwICovOyB9OworCQk5 MzcxQkI3MTBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oIGluIEhlYWRlcnMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCNzAwQUM0N0ZBRTAwQ0Q0QTdC IC8qIFJlbmRlckNvdW50ZXIuaCAqLzsgfTsKKwkJOTM3MUJCNzMwQUM0N0ZCODAwQ0Q0QTdCIC8q IFJlbmRlckNvdW50ZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gOTM3MUJCNzIwQUM0N0ZCODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuY3BwICov OyB9OworCQk5MzcxQkI3NTBBQzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oIGlu IEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCNzQwQUM0 N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLzsgfTsKKwkJOTM3MUJCNzcwQUM0 N0ZEMDAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENv dW50ZXJSZXNldE5vZGUuY3BwICovOyB9OworCQk5MzcxQkI3OTBBQzQ3RkQ3MDBDRDRBN0IgLyog Q291bnRlck5vZGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDkzNzFCQjc4MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVyTm9kZS5oICovOyB9OworCQk5 MzcxQkI3QjBBQzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUuY3BwIGluIFNvdXJjZXMgKi8g PSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCN0EwQUM0N0ZERTAwQ0Q0QTdC IC8qIENvdW50ZXJOb2RlLmNwcCAqLzsgfTsKKwkJOTM3MUJCN0QwQUM0N0ZFNzAwQ0Q0QTdCIC8q IENvdW50ZXJMaXN0SXRlbS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gOTM3MUJCN0MwQUM0N0ZFNzAwQ0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICov OyB9OwogCQk5MzcyNTYxMDBBNjE1NjQyMDBCMDUzQjkgLyogbGlic3FsaXRlMy5keWxpYiBpbiBG cmFtZXdvcmtzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzI1NjBGMEE2 MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliICovOyB9OwogCQk5MzgwRjQ3MzA5QTEx QUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzODBGNDcxMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuY3BwICov OyB9OwogCQk5MzgwRjQ3NDA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzgwRjQ3MjA5QTExQUI0MDAxRkRC MzQgLyogV2lkZ2V0LmggKi87IH07CkBAIC0zMTgzLDYgKzMxOTAsMTMgQEAKIAkJOTM1RkJDRjEw OUJBMTQzQjAwRTIzMEIxIC8qIEV4Y2VwdGlvbkNvZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gRXhjZXB0aW9uQ29kZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQk5MzZCREQxQzBBMDMxQUVCMDA0REY0QUIgLyogR3JhcGhpY3NDb250ZXh0Q0cuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gR3JhcGhpY3NDb250ZXh0Q0cuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk5MzZERDAzQTA5Q0VBQzI3MDA1NkFFOEMgLyog UmFuZ2UuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IFJhbmdlLmlkbDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzAwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50 ZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFJlbmRlckNvdW50ZXIuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzIwQUM0N0ZCODAwQ0Q0QTdCIC8q IFJlbmRlckNvdW50ZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IFJlbmRlckNvdW50ZXIuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3 NDBBQzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuYy5oOyBwYXRoID0gQ291bnRlclJlc2V0Tm9kZS5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQk5MzcxQkI3NjBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ291bnRlclJlc2V0Tm9k ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc4MEFDNDdGRDcwMENE NEE3QiAvKiBDb3VudGVyTm9kZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g Q291bnRlck5vZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCN0EwQUM0 N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBDb3VudGVyTm9kZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTkzNzFCQjdDMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0uaCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJMaXN0SXRlbS5oOyBzb3VyY2VUcmVl ID0gIjxncm91cD4iOyB9OwogCQk5MzcyNTYwRjBBNjE1NjQyMDBCMDUzQjkgLyogbGlic3FsaXRl My5keWxpYiAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9 ICJjb21waWxlZC5tYWNoLW8uZHlsaWIiOyBuYW1lID0gbGlic3FsaXRlMy5keWxpYjsgcGF0aCA9 IC91c3IvbGliL2xpYnNxbGl0ZTMuZHlsaWI7IHNvdXJjZVRyZWUgPSAiPGFic29sdXRlPiI7IH07 CiAJCTkzODBGNDcxMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFdpZGdldC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTkzODBGNDcyMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdpZGdldC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwpAQCAtNzE2Niw2ICs3MTgwLDExIEBACiAJCQkJQkNFQTQ4MTQwOTdEOTMwMjAwOTRDOUU0 IC8qIGJpZGkuaCAqLywKIAkJCQlCQ0VBNDgxNTA5N0Q5MzAyMDA5NEM5RTQgLyogYnJlYWtfbGlu ZXMuY3BwICovLAogCQkJCUJDRUE0ODE2MDk3RDkzMDIwMDk0QzlFNCAvKiBicmVha19saW5lcy5o ICovLAorCQkJCTkzNzFCQjdDMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0uaCAq LywKKwkJCQk5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUuY3BwICovLAor CQkJCTkzNzFCQjc4MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVyTm9kZS5oICovLAorCQkJCTkz NzFCQjc2MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCAqLywKKwkJCQk5 MzcxQkI3NDBBQzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oICovLAogCQkJCUJD RUE0ODE3MDk3RDkzMDIwMDk0QzlFNCAvKiBEYXRhUmVmLmggKi8sCiAJCQkJQUJFN0I1MjEwQTQ4 OUY4MzAwMzE4ODFDIC8qIERlcHJlY2F0ZWRSZW5kZXJTZWxlY3QuY3BwICovLAogCQkJCUFCRTdC NTIyMEE0ODlGODMwMDMxODgxQyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmggKi8sCkBAIC03 MjAyLDYgKzcyMjEsOCBAQAogCQkJCUJDRUE0ODI5MDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJW aWV3LmggKi8sCiAJCQkJQkNFQTQ4MkMwOTdEOTMwMjAwOTRDOUU0IC8qIFJlbmRlckNvbnRhaW5l ci5jcHAgKi8sCiAJCQkJQkNFQTQ4MkQwOTdEOTMwMjAwOTRDOUU0IC8qIFJlbmRlckNvbnRhaW5l ci5oICovLAorCQkJCTkzNzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNw cCAqLywKKwkJCQk5MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oICov LAogCQkJCUE4RUE3M0FGMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNldC5jcHAgKi8s CiAJCQkJQThFQTczQjAwQTE5MDBFMzAwQThFRjVGIC8qIFJlbmRlckZpZWxkc2V0LmggKi8sCiAJ CQkJMDY2Qzc3MkUwQUI2MDNGRDAwMjM4Q0M0IC8qIFJlbmRlckZpbGVVcGxvYWRDb250cm9sLmNw cCAqLywKQEAgLTg0NTAsNiArODQ3MSwxMCBAQAogCQkJCUE4NDE1RjlFMEFDMTBDNUQwMEY3RDBE RiAvKiBLQ2FudmFzTWFza2VyLmggaW4gSGVhZGVycyAqLywKIAkJCQlBODQxNUZBMDBBQzEwQzVE MDBGN0QwREYgLyogS0NhbnZhc01hcmtlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQkMzRkNBQTkw QUMzREI1ODAwQkE1NEFEIC8qIFBsYXRmb3JtU2Nyb2xsQmFyLmggaW4gSGVhZGVycyAqLywKKwkJ CQk5MzcxQkI3MTBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oIGluIEhlYWRlcnMg Ki8sCisJCQkJOTM3MUJCNzUwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCBp biBIZWFkZXJzICovLAorCQkJCTkzNzFCQjc5MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVyTm9k ZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM3MUJCN0QwQUM0N0ZFNzAwQ0Q0QTdCIC8qIENvdW50 ZXJMaXN0SXRlbS5oIGluIEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1l bnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC05NTM4LDYgKzk1NjMsOSBAQAogCQkJCUE4 NDE1RjlGMEFDMTBDNUQwMEY3RDBERiAvKiBLQ2FudmFzTWFza2VyLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCUE4NDE1RkExMEFDMTBDNUQwMEY3RDBERiAvKiBLQ2FudmFzTWFya2VyLmNwcCBpbiBT b3VyY2VzICovLAogCQkJCUE4NDE1RkEyMEFDMTBDNUQwMEY3RDBERiAvKiBLQ2FudmFzRmlsdGVy cy5jcHAgaW4gU291cmNlcyAqLywKKwkJCQk5MzcxQkI3MzBBQzQ3RkI4MDBDRDRBN0IgLyogUmVu ZGVyQ291bnRlci5jcHAgaW4gU291cmNlcyAqLywKKwkJCQk5MzcxQkI3NzBBQzQ3RkQwMDBDRDRB N0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgaW4gU291cmNlcyAqLywKKwkJCQk5MzcxQkI3QjBB QzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwog CQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkluZGV4OiBj c3MvQ1NTQ29tcHV0ZWRTdHlsZURlY2xhcmF0aW9uLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvQ1NT Q29tcHV0ZWRTdHlsZURlY2xhcmF0aW9uLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvQ1NT Q29tcHV0ZWRTdHlsZURlY2xhcmF0aW9uLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjAyLDExICs2 MDIsOSBAQAogICAgICAgICAvLyBGSVhNRTogdW5pbXBsZW1lbnRlZAogICAgICAgICBicmVhazsK ICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfSU5DUkVNRU5UOgotICAgICAgICAvLyBGSVhNRTog dW5pbXBsZW1lbnRlZAotICAgICAgICBicmVhazsKKyAgICAgICAgcmV0dXJuIHN0eWxlLT5jb3Vu dGVySW5jcmVtZW50VmFsdWVMaXN0KCk7CiAgICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX1JFU0VU OgotICAgICAgICAvLyBGSVhNRTogdW5pbXBsZW1lbnRlZAotICAgICAgICBicmVhazsKKyAgICAg ICAgcmV0dXJuIHN0eWxlLT5jb3VudGVyUmVzZXRWYWx1ZUxpc3QoKTsKICAgICBjYXNlIENTU19Q Uk9QX0NVUlNPUjoKICAgICAgICAgaWYgKHN0eWxlLT5jdXJzb3JJbWFnZSgpKQogICAgICAgICAg ICAgcmV0dXJuIG5ldyBDU1NQcmltaXRpdmVWYWx1ZShzdHlsZS0+Y3Vyc29ySW1hZ2UoKS0+dXJs KCksIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfVVJJKTsKSW5kZXg6IGNzcy9jc3NwYXJzZXIuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBjc3MvY3NzcGFyc2VyLmgJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL2Nz c3BhcnNlci5oCSh3b3JraW5nIGNvcHkpCkBAIC0xNDYsMTEgKzE0NiwxMyBAQAogCiAgICAgICAg IGJvb2wgcGFyc2VTaGFwZShpbnQgcHJvcElkLCBib29sIGltcG9ydGFudCk7CiAgICAgICAgIGJv b2wgcGFyc2VGb250KGJvb2wgaW1wb3J0YW50KTsKKyAgICAgICAgYm9vbCBwYXJzZUNvdW50ZXIo aW50IHByb3BJZCwgaW50IGRlZmF1bHRWYWx1ZSwgYm9vbCBpbXBvcnRhbnQpOwogICAgICAgICBD U1NWYWx1ZUxpc3QqIHBhcnNlRm9udEZhbWlseSgpOwogICAgICAgICBib29sIHBhcnNlQ29sb3JQ YXJhbWV0ZXJzKFZhbHVlKiwgaW50KiBjb2xvclZhbHVlcywgYm9vbCBwYXJzZUFscGhhKTsKICAg ICAgICAgYm9vbCBwYXJzZUhTTFBhcmFtZXRlcnMoVmFsdWUqLCBkb3VibGUqIGNvbG9yVmFsdWVz LCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xv cigpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFyc2VDb2xvckZyb21WYWx1ZShWYWx1 ZSopOworICAgICAgICBQYXNzUmVmUHRyPENTU1ZhbHVlPiBwYXJzZUNvdW50ZXJDb250ZW50KFZh bHVlTGlzdCAqYXJncywgYm9vbCBjb3VudGVycyk7CiAgICAgICAgIAogI2lmZGVmIFNWR19TVVBQ T1JUCiAgICAgICAgIGJvb2wgcGFyc2VTVkdWYWx1ZShpbnQgcHJvcElkLCBib29sIGltcG9ydGFu dCk7CkluZGV4OiBjc3MvY3Nzc3R5bGVzZWxlY3Rvci5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL2Nz c3N0eWxlc2VsZWN0b3IuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9jc3NzdHlsZXNlbGVj dG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjYsNiArMjYsNyBAQAogI2luY2x1ZGUgImNzc3N0 eWxlc2VsZWN0b3IuaCIKIAogI2luY2x1ZGUgIkNTU0JvcmRlckltYWdlVmFsdWUuaCIKKyNpbmNs dWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ1NTSW1hZ2VWYWx1ZS5oIgogI2luY2x1ZGUgIkNT U0ltcG9ydFJ1bGUuaCIKICNpbmNsdWRlICJDU1NNZWRpYVJ1bGUuaCIKQEAgLTMxNDgsNyArMzE0 OSw5IEBACiAKICAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgewogICAgICAg ICAgICAgQ1NTVmFsdWUgKml0ZW0gPSBsaXN0LT5pdGVtKGkpOwotICAgICAgICAgICAgaWYgKCFp dGVtLT5pc1ByaW1pdGl2ZVZhbHVlKCkpIGNvbnRpbnVlOworICAgICAgICAgICAgaWYgKCFpdGVt LT5pc1ByaW1pdGl2ZVZhbHVlKCkpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICAKICAgICAgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlICp2YWwgPSBzdGF0aWNfY2FzdDxD U1NQcmltaXRpdmVWYWx1ZSo+KGl0ZW0pOwogICAgICAgICAgICAgaWYgKHZhbC0+cHJpbWl0aXZl VHlwZSgpPT1DU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORykKICAgICAgICAgICAgICAgICBz dHlsZS0+c2V0Q29udGVudCh2YWwtPmdldFN0cmluZ1ZhbHVlKCkuaW1wbCgpLCBpICE9IDApOwpA QCAtMzE2MiwxOSArMzE2NSwzMCBAQAogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50 KGVsZW1lbnQtPmdldEF0dHJpYnV0ZShhdHRyKS5pbXBsKCksIGkgIT0gMCk7CiAgICAgICAgICAg ICAgICAgLy8gcmVnaXN0ZXIgdGhlIGZhY3QgdGhhdCB0aGUgYXR0cmlidXRlIHZhbHVlIGFmZmVj dHMgdGhlIHN0eWxlCiAgICAgICAgICAgICAgICAgbV9zZWxlY3RvckF0dHJzLmFkZChhdHRyLmxv Y2FsTmFtZSgpLmltcGwoKSk7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBlbHNlIGlmICh2 YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKKyAgICAg ICAgICAgIH0gZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfVVJJKSB7CiAgICAgICAgICAgICAgICAgQ1NTSW1hZ2VWYWx1ZSAqaW1hZ2UgPSBzdGF0 aWNfY2FzdDxDU1NJbWFnZVZhbHVlKj4odmFsKTsKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0 Q29udGVudChpbWFnZS0+aW1hZ2UoZWxlbWVudC0+ZG9jdW1lbnQoKS0+ZG9jTG9hZGVyKCkpLCBp ICE9IDApOwotICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnByaW1p dGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19DT1VOVEVSKSB7CisgICAgICAgICAg ICAgICAgQ291bnRlciogY291bnRlclZhbHVlID0gdmFsLT5nZXRDb3VudGVyVmFsdWUoKTsKKyAg ICAgICAgICAgICAgICBDb3VudGVyRGF0YSBjb3VudGVyKGNvdW50ZXJWYWx1ZS0+aWRlbnRpZmll cigpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICwoRUxpc3RTdHlsZVR5cGUp Y291bnRlclZhbHVlLT5saXN0U3R5bGVOdW1iZXIoKQorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAsY291bnRlclZhbHVlLT5zZXBhcmF0b3IoKSk7CisgICAgICAgICAgICAgICAg Q291bnRlckRhdGEqIGMgPSBuZXcgQ291bnRlckRhdGEoY291bnRlcik7CisgICAgICAgICAgICAg ICAgc3R5bGUtPnNldENvbnRlbnQoYywgaSAhPSAwKTsKKyAgICAgICAgICAgfQogICAgICAgICB9 CiAgICAgICAgIGJyZWFrOwogICAgIH0KIAogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9JTkNS RU1FTlQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJJbmNyZW1lbnQKKyAgICAgICAg aWYgKCF2YWx1ZS0+aXNWYWx1ZUxpc3QoKSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg c3R5bGUtPnNldENvdW50ZXJJbmNyZW1lbnRMaXN0KHN0YXRpY19jYXN0PENTU1ZhbHVlTGlzdCo+ KHZhbHVlKSk7CisgICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNF VDoKLSAgICAgICAgLy8gbGlzdCBvZiBDU1MyQ291bnRlclJlc2V0CisgICAgICAgIGlmICghdmFs dWUtPmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIHN0eWxlLT5z ZXRDb3VudGVyUmVzZXRMaXN0KHN0YXRpY19jYXN0PENTU1ZhbHVlTGlzdCo+KHZhbHVlKSk7CiAg ICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1BfRk9OVF9GQU1JTFk6IHsKICAgICAgICAg Ly8gbGlzdCBvZiBzdHJpbmdzIGFuZCBpZHMKSW5kZXg6IGNzcy9DU1NQcmltaXRpdmVWYWx1ZS5j cHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkocmV2aXNpb24gMTY1 MjgpCisrKyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC01MjQs NyArNTI0LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAgLy8gIyMjCisgICAgICAgICAgICB0 ZXh0ID0gImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQgKz0gU3RyaW5nOjpudW1iZXIobV92 YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7CisgICAgICAgICAgICAvLyAjIyMg YWRkIGxpc3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGNhc2UgQ1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJlY3RJbXBsKiByZWN0VmFsID0gZ2V0UmVj dFZhbHVlKCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9Db3VudGVy LmgJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL0NvdW50ZXIuaAkod29ya2luZyBjb3B5KQpAQCAt MjMsMjMgKzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJfSAogI2RlZmluZSBDb3VudGVyX0gKIAor I2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcu aCIKICNpbmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2lu Y2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3Mg Q291bnRlciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4gewogcHVibGljOgotICAgIFN0cmluZyBp ZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9Ci0gICAgU3RyaW5nIGxp c3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9Ci0gICAgU3RyaW5nIHNlcGFy YXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisgICAgQ291bnRlcigpIDogbV9p ZGVudGlmaWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9zZXBhcmF0b3IoMCkgeyB9CisgICAgQ291 bnRlcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVudGlmaWVyLCBQYXNzUmVmUHRy PENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisgICAgICAgIFBhc3NSZWZQdHI8Q1NTUHJp bWl0aXZlVmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAgOiBtX2lkZW50aWZpZXIoaWRlbnRpZmll ciksIG1fbGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2VwYXJhdG9yKHNlcGFyYXRvcikgeyB9Cisg ICAgfkNvdW50ZXIoKSB7IH0KIAotcHJpdmF0ZToKLSAgICBTdHJpbmcgbV9pZGVudGlmaWVyOwot ICAgIFN0cmluZyBtX2xpc3RTdHlsZTsKLSAgICBTdHJpbmcgbV9zZXBhcmF0b3I7Ci19OworICAg IFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyID8gbV9pZGVu dGlmaWVyLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0KKyAgICBTdHJpbmcgbGlzdFN0 eWxlKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUgPyBtX2xpc3RTdHlsZS0+Z2V0U3RyaW5n VmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5nIHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0 dXJuIG1fc2VwYXJhdG9yID8gbV9zZXBhcmF0b3ItPmdldFN0cmluZ1ZhbHVlKCkgOiBTdHJpbmco KTsgfQogCi19IC8vIG5hbWVzcGFjZQorICAgIGludCBsaXN0U3R5bGVOdW1iZXIoKSBjb25zdCB7 IHJldHVybiBtX2xpc3RTdHlsZS5nZXQoKSA/IChpbnQpIG1fbGlzdFN0eWxlLmdldCgpLT5nZXRG bG9hdFZhbHVlKCkgOiAwOyB9CisgICAgCisgICAgdm9pZCBzZXRJZGVudGlmaWVyKFBhc3NSZWZQ dHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGlkZW50aWZpZXIpIHsgbV9pZGVudGlmaWVyID0gaWRlbnRp ZmllcjsgfQorICAgIHZvaWQgc2V0TGlzdFN0eWxlKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFs dWU+IGxpc3RTdHlsZSkgeyBtX2xpc3RTdHlsZSA9IGxpc3RTdHlsZTsgfQorICAgIHZvaWQgc2V0 U2VwYXJhdG9yKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikgeyBtX3Nl cGFyYXRvciA9IHNlcGFyYXRvcjsgfQorIAorcHJvdGVjdGVkOgorICAgIFJlZlB0cjxDU1NQcmlt aXRpdmVWYWx1ZT4gbV9pZGVudGlmaWVyOyAvL3N0cmluZworICAgIFJlZlB0cjxDU1NQcmltaXRp dmVWYWx1ZT4gbV9saXN0U3R5bGU7IC8vaW50CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBtX3NlcGFyYXRvcjsgLy9zdHJpbmcKKyB9OwogCit9IC8vbmFtZXNwYWNlCisKICNlbmRpZgpJ bmRleDogY3NzL2Nzc3BhcnNlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5jcHAJ KHJldmlzaW9uIDE2NTI4KQorKysgY3NzL2Nzc3BhcnNlci5jcHAJKHdvcmtpbmcgY29weSkKQEAg LTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJjc3NwYXJzZXIuaCIKIAogI2luY2x1ZGUgIkNTU0Jv cmRlckltYWdlVmFsdWUuaCIKKyNpbmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ1NTSW1h Z2VWYWx1ZS5oIgogI2luY2x1ZGUgIkNTU0NoYXJzZXRSdWxlLmgiCiAjaW5jbHVkZSAiQ1NTSW1w b3J0UnVsZS5oIgpAQCAtODcwLDYgKzg3MSwxNyBAQAogICAgICAgICBlbHNlCiAgICAgICAgICAg ICB2YWxpZF9wcmltaXRpdmUgPSAoIWlkICYmIHZhbGlkVW5pdCh2YWx1ZSwgRk51bWJlcnxGTGVu Z3RofEZQZXJjZW50LCBzdHJpY3QpKTsKICAgICAgICAgYnJlYWs7CisgICAgY2FzZSBDU1NfUFJP UF9DT1VOVEVSX0lOQ1JFTUVOVDogICAgLy8gWyA8aWRlbnRpZmllcj4gPGludGVnZXI+PyBdKyB8 IG5vbmUgfCBpbmhlcml0CisgICAgICAgIGlmIChpZCA9PSBDU1NfVkFMX05PTkUpCisgICAgICAg ICAgICB2YWxpZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAgICBlbHNlCisgICAgICAgICAgICBy ZXR1cm4gcGFyc2VDb3VudGVyKHByb3BJZCwgMSwgaW1wb3J0YW50KTsKKyAgICAgICAgYnJlYWs7 CisgICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNFVDogICAgICAgIC8vIFsgPGlkZW50aWZp ZXI+IDxpbnRlZ2VyPj8gXSsgfCBub25lIHwgaW5oZXJpdAorICAgICAgICAgaWYgKGlkID09IENT U19WQUxfTk9ORSkKKyAgICAgICAgICAgICB2YWxpZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAg ICBlbHNlCisgICAgICAgICAgICByZXR1cm4gcGFyc2VDb3VudGVyKHByb3BJZCwgMCwgaW1wb3J0 YW50KTsKICAgICBjYXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFt aWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVy aWMtZmFtaWx5Pl0gfCBpbmhlcml0CiAgICAgewpAQCAtMTUyMywyOCArMTUzNSw0MCBAQAogLy8g WyA8c3RyaW5nPiB8IGF0dHIoWCkgfCBvcGVuLXF1b3RlIHwgY2xvc2UtcXVvdGUgfCBuby1vcGVu LXF1b3RlIHwgbm8tY2xvc2UtcXVvdGUgXSsgfCBpbmhlcml0CiBib29sIENTU1BhcnNlcjo6cGFy c2VDb250ZW50KGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KQogewotICAgIENTU1ZhbHVlTGlz dCogdmFsdWVzID0gbmV3IENTU1ZhbHVlTGlzdDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiB2 YWx1ZXMgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgIFJlZlB0cjxDU1NWYWx1ZT4gcGFyc2VkVmFs dWU7CiAKICAgICB3aGlsZSAoVmFsdWUqIHZhbCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpKSB7Ci0g ICAgICAgIENTU1ZhbHVlKiBwYXJzZWRWYWx1ZSA9IDA7CiAgICAgICAgIGlmICh2YWwtPnVuaXQg PT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKICAgICAgICAgICAgIC8vIHVybAogICAg ICAgICAgICAgU3RyaW5nIHZhbHVlID0gcGFyc2VVUkwoZG9tU3RyaW5nKHZhbC0+c3RyaW5nKSk7 CiAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NJbWFnZVZhbHVlKAogICAgICAgICAg ICAgICAgIFN0cmluZyhLVVJMKHN0eWxlRWxlbWVudC0+YmFzZVVSTCgpLmRlcHJlY2F0ZWRTdHJp bmcoKSwgdmFsdWUuZGVwcmVjYXRlZFN0cmluZygpKS51cmwoKSksIHN0eWxlRWxlbWVudCk7CiAg ICAgICAgIH0gZWxzZSBpZiAodmFsLT51bml0ID09IFZhbHVlOjpGdW5jdGlvbikgewotICAgICAg ICAgICAgLy8gYXR0cihYKQorICAgICAgICAgICAgLy8gYXR0cihYKSB8IGNvdW50ZXIoWCBbLFld KSB8IGNvdW50ZXJzKFgsIFksIFssWl0pCiAgICAgICAgICAgICBWYWx1ZUxpc3QgKmFyZ3MgPSB2 YWwtPmZ1bmN0aW9uLT5hcmdzOwogICAgICAgICAgICAgU3RyaW5nIGZuYW1lID0gZG9tU3RyaW5n KHZhbC0+ZnVuY3Rpb24tPm5hbWUpLmxvd2VyKCk7Ci0gICAgICAgICAgICBpZiAoZm5hbWUgIT0g ImF0dHIoIiB8fCAhYXJncykKKyAgICAgICAgICAgIGlmICghYXJncykKICAgICAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7Ci0gICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEpCisgICAg ICAgICAgICBpZiAoZm5hbWUgPT0gImF0dHIoIikgeworICAgICAgICAgICAgICAgIGlmIChhcmdz LT5zaXplKCkgIT0gMSkKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAg ICAgICAgICAgIFZhbHVlICphID0gYXJncy0+Y3VycmVudCgpOworICAgICAgICAgICAgICAgIFN0 cmluZyBhdHRyTmFtZSA9IGRvbVN0cmluZyhhLT5zdHJpbmcpOworICAgICAgICAgICAgICAgIGlm IChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVudCgpKQorICAgICAgICAgICAgICAgICAgICBhdHRy TmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUgPSBu ZXcgQ1NTUHJpbWl0aXZlVmFsdWUoYXR0ck5hbWUsIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfQVRU Uik7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGlmIChmbmFtZSA9PSAiY291bnRl cigiKSB7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUgPSBwYXJzZUNvdW50ZXJDb250ZW50 KGFyZ3MsIGZhbHNlKS5nZXQoKTsKKyAgICAgICAgICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKSBy ZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIGlmIChmbmFtZSA9 PSAiY291bnRlcnMoIikgeworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3Vu dGVyQ29udGVudChhcmdzLCB0cnVlKS5nZXQoKTsKKyAgICAgICAgICAgICAgICBpZiAoIXBhcnNl ZFZhbHVlKSByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBlbHNlCiAg ICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAgICAgVmFsdWUgKmEgPSBhcmdz LT5jdXJyZW50KCk7Ci0gICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUgPSBkb21TdHJpbmcoYS0+ c3RyaW5nKTsKLSAgICAgICAgICAgIGlmIChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVudCgpKQot ICAgICAgICAgICAgICAgIGF0dHJOYW1lID0gYXR0ck5hbWUubG93ZXIoKTsKLSAgICAgICAgICAg IHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRp dmVWYWx1ZTo6Q1NTX0FUVFIpOwogICAgICAgICB9IGVsc2UgaWYgKHZhbC0+dW5pdCA9PSBDU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKSB7CiAgICAgICAgICAgICAvLyBvcGVuLXF1b3RlCiAg ICAgICAgICAgICAvLyBjbG9zZS1xdW90ZQpAQCAtMTU2MSwxMiArMTU4NSwxMSBAQAogICAgIH0K IAogICAgIGlmICh2YWx1ZXMtPmxlbmd0aCgpKSB7Ci0gICAgICAgIGFkZFByb3BlcnR5KHByb3BJ ZCwgdmFsdWVzLCBpbXBvcnRhbnQpOworICAgICAgICBhZGRQcm9wZXJ0eShwcm9wSWQsIHZhbHVl cy5nZXQoKSwgaW1wb3J0YW50KTsKICAgICAgICAgdmFsdWVMaXN0LT5uZXh0KCk7CiAgICAgICAg IHJldHVybiB0cnVlOwogICAgIH0KIAotICAgIGRlbGV0ZSB2YWx1ZXM7CiAgICAgcmV0dXJuIGZh bHNlOwogfQogCkBAIC0xOTc4LDYgKzIwMDEsNjEgQEAKIH0KICNlbmRpZgogCitQYXNzUmVmUHRy PENTU1ZhbHVlPiBDU1NQYXJzZXI6OnBhcnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0ICphcmdz LCBib29sIGNvdW50ZXJzKQoreworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gaWRlbnRp ZmllcjsKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcjsKKyAgICBSZWZQ dHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGxpc3RTdHlsZTsKKworICAgIHVuc2lnbmVkIG51bUFyZ3Mg PSBhcmdzLT5zaXplKCk7CisgICAgaWYgKGNvdW50ZXJzICYmIG51bUFyZ3MgIT0gMyAmJiBudW1B cmdzICE9IDUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghY291bnRlcnMgJiYgbnVtQXJn cyAhPSAxICYmIG51bUFyZ3MgIT0gMykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisgICAgVmFs dWUgKmkgPSBhcmdzLT5jdXJyZW50KCk7CisgICAgaWRlbnRpZmllciA9IG5ldyBDU1NQcmltaXRp dmVWYWx1ZShkb21TdHJpbmcoaS0+c3RyaW5nKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJ TkcpOworCisgICAgaWYgKCFjb3VudGVycykKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENTU1By aW1pdGl2ZVZhbHVlKFN0cmluZygpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7Cisg ICAgZWxzZSB7CisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51bml0 ICE9IFZhbHVlOjpPcGVyYXRvciB8fCBpLT5pVmFsdWUgIT0gJywnKQorICAgICAgICAgICAgcmV0 dXJuIDA7CisgICAgICAgIAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAo aS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORykKKyAgICAgICAgICAgIHJl dHVybiAwOworICAgICAgICAKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENTU1ByaW1pdGl2ZVZh bHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBlcykg aS0+dW5pdCk7CisgICAgfQorCisgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICBpZiAoIWkpIC8v IE1ha2UgdGhlIGxpc3Qgc3R5bGUgZGVmYXVsdCBkZWNpbWFsCisgICAgICAgIGxpc3RTdHlsZSA9 IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShDU1NfVkFMX0RFQ0lNQUwgLSBDU1NfVkFMX0RJU0MsIENT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICBlbHNlIHsKKyAgICAgICAgaWYgKGkt PnVuaXQgIT0gVmFsdWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAg IGlmIChpLT51bml0ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIHNob3J0IGxzID0gMDsKKyAgICAgICAgaWYg KGktPmlkID09IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAgIGxzID0gQ1NTX1ZBTF9LQVRBS0FO QV9JUk9IQSAtIENTU19WQUxfRElTQyArIDE7CisgICAgICAgIGVsc2UgaWYgKGktPmlkID49IENT U19WQUxfRElTQyAmJiBpLT5pZCA8PSBDU1NfVkFMX0tBVEFLQU5BX0lST0hBKQorICAgICAgICAg ICAgbHMgPSBpLT5pZCAtIENTU19WQUxfRElTQzsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAg cmV0dXJuIDA7CisKKyAgICAgICAgbGlzdFN0eWxlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGxz LCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBlcykgaS0+dW5pdCk7CisgICAgfQorICAgIAor ICAgIENvdW50ZXIqIGNvdW50ZXIgPSBuZXcgQ291bnRlcihpZGVudGlmaWVyLmdldCgpLCBsaXN0 U3R5bGUuZ2V0KCksIHNlcGFyYXRvci5nZXQoKSk7CisgICAgcmV0dXJuIG5ldyBDU1NQcmltaXRp dmVWYWx1ZShjb3VudGVyKTsKK30KKwogYm9vbCBDU1NQYXJzZXI6OnBhcnNlU2hhcGUoaW50IHBy b3BJZCwgYm9vbCBpbXBvcnRhbnQpCiB7CiAgICAgVmFsdWUgKnZhbHVlID0gdmFsdWVMaXN0LT5j dXJyZW50KCk7CkBAIC0yNjc2LDYgKzI3NTQsNTEgQEAKICAgICByZXR1cm4gY29udGV4dC5mYWls ZWQoKTsKIH0KIAorYm9vbCBDU1NQYXJzZXI6OnBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBpbnQg ZGVmYXVsdFZhbHVlLCBib29sIGltcG9ydGFudCkKK3sKKyAgICBlbnVtIHsgSUQsIFZBTCB9IHN0 YXRlID0gSUQ7CisKKyAgICBWYWx1ZSogdmFsOworICAgIFJlZlB0cjxDU1NWYWx1ZUxpc3Q+IGxp c3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gY291 bnRlck5hbWU7CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBudW1WYWx1ZTsKKyAgICAK KyAgICB3aGlsZSAodHJ1ZSkgeworICAgICAgICB2YWwgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKTsK KyAgICAgICAgc3dpdGNoIChzdGF0ZSkgeworICAgICAgICAgICAgY2FzZSBJRDoKKyAgICAgICAg ICAgICAgICBpZiAodmFsICYmIHZhbC0+dW5pdCA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0lE RU5UKSB7CisgICAgICAgICAgICAgICAgICAgIGNvdW50ZXJOYW1lID0gbmV3IENTU1ByaW1pdGl2 ZVZhbHVlKGRvbVN0cmluZyh2YWwtPnN0cmluZyksIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RS SU5HKTsKKyAgICAgICAgICAgICAgICAgICAgc3RhdGUgPSBWQUw7CisgICAgICAgICAgICAgICAg ICAgIHZhbHVlTGlzdC0+bmV4dCgpOworICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICBjYXNl IFZBTDogeworICAgICAgICAgICAgICAgIGludCBpID0gZGVmYXVsdFZhbHVlOworICAgICAgICAg ICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVN QkVSKSB7CisgICAgICAgICAgICAgICAgICAgIGkgPSAoc2hvcnQpdmFsLT5mVmFsdWU7CisgICAg ICAgICAgICAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOworICAgICAgICAgICAgICAgIH0KKwor ICAgICAgICAgICAgICAgIG51bVZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGksIENTU1By aW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKKyAgICAgICAgICAgICAgICBQYWlyKiBwYWlyID0g bmV3IFBhaXIoY291bnRlck5hbWUuZ2V0KCksIG51bVZhbHVlLmdldCgpKTsKKyAgICAgICAgICAg ICAgICBsaXN0LT5hcHBlbmQobmV3IENTU1ByaW1pdGl2ZVZhbHVlKHBhaXIpKTsKKyAgICAgICAg ICAgICAgICBzdGF0ZSA9IElEOworICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAg ICAgfQorICAgICAgICB9CisgICAgICAgIGJyZWFrOworICAgIH0KKyAgICAKKyAgICBpZiAobGlz dC0+bGVuZ3RoKCkgPiAwKSB7CisgICAgICAgIGFkZFByb3BlcnR5KHByb3BJZCwgbGlzdC5nZXQo KSwgaW1wb3J0YW50KTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorCisgICAgcmV0dXJu IGZhbHNlOworfQorCiAjaWZkZWYgQ1NTX0RFQlVHCiAKIHN0YXRpYyBpbmxpbmUgaW50IHl5ZXJy b3IoY29uc3QgY2hhciAqc3RyKQo= 10831 2006-09-29 00:05:36 -0700 2006-10-01 16:07:19 -0700 another round thursdayNight.txt text/plain 71643 bdakin SW5kZXg6IHBsYXRmb3JtL1N0cmluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vU3RyaW5n LmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBwbGF0Zm9ybS9TdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xNTcsNiArMTU3LDE0IEBACiAgICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ci5tX2lt cGwuZ2V0KCksIHBvcyk7CiB9CiAKK3ZvaWQgU3RyaW5nOjppbnNlcnQoY29uc3QgVUNoYXIqIHN0 ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpCit7CisgICAgaWYgKCFtX2ltcGwpCisg ICAgICAgIG1faW1wbCA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICBlbHNlCisg ICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ciwgbGVuZ3RoLCBwb3MpOworfQorCiBVQ2hhciBTdHJp bmc6Om9wZXJhdG9yW10odW5zaWduZWQgaSkgY29uc3QKIHsKICAgICBpZiAoIW1faW1wbCB8fCBp ID49IG1faW1wbC0+bGVuZ3RoKCkpCkluZGV4OiBwbGF0Zm9ybS9QbGF0Zm9ybVN0cmluZy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHBsYXRmb3JtL1BsYXRmb3JtU3RyaW5nLmgJKHJldmlzaW9uIDE2NTI4KQor KysgcGxhdGZvcm0vUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5KQpAQCAtOTAsNiArOTAs NyBAQAogICAgIHZvaWQgYXBwZW5kKGNoYXIpOwogICAgIHZvaWQgYXBwZW5kKFVDaGFyKTsKICAg ICB2b2lkIGluc2VydChjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBwb3MpOworICAgIHZvaWQgaW5z ZXJ0KGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpOwogCiAgICAg U3RyaW5nJiByZXBsYWNlKFVDaGFyIGEsIFVDaGFyIGIpIHsgaWYgKG1faW1wbCkgbV9pbXBsID0g bV9pbXBsLT5yZXBsYWNlKGEsIGIpOyByZXR1cm4gKnRoaXM7IH0KICAgICBTdHJpbmcmIHJlcGxh Y2UoVUNoYXIgYSwgY29uc3QgU3RyaW5nJiBiKSB7IGlmIChtX2ltcGwpIG1faW1wbCA9IG1faW1w bC0+cmVwbGFjZShhLCBiLmltcGwoKSk7IHJldHVybiAqdGhpczsgfQpJbmRleDogcGxhdGZvcm0v U3RyaW5nSW1wbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuaAkocmV2aXNp b24gMTY1MjgpCisrKyBwbGF0Zm9ybS9TdHJpbmdJbXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTgw LDYgKzgwLDcgQEAKICAgICB2b2lkIGFwcGVuZChjaGFyKTsKICAgICB2b2lkIGFwcGVuZChVQ2hh cik7CiAgICAgdm9pZCBpbnNlcnQoY29uc3QgU3RyaW5nSW1wbCosIHVuc2lnbmVkIHBvcyk7Cisg ICAgdm9pZCBpbnNlcnQoY29uc3QgVUNoYXIqIHN0ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBwb3MpOwogICAgIHZvaWQgdHJ1bmNhdGUoaW50IGxlbik7CiAgICAgdm9pZCByZW1vdmUodW5z aWduZWQgcG9zLCBpbnQgbGVuID0gMSk7CiAKSW5kZXg6IHBsYXRmb3JtL1N0cmluZ0ltcGwuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCShyZXZpc2lvbiAxNjUyOCkK KysrIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTcsNiArMTk3 LDI2IEBACiAgICAgfQogfQogCit2b2lkIFN0cmluZ0ltcGw6Omluc2VydChjb25zdCBVQ2hhciog c3RyLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIHBvcykKK3sKKyAgICBhc3NlcnQoIW1faW5U YWJsZSk7CisgICAgaWYgKHBvcyA+PSBtX2xlbmd0aCkgeworICAgICAgICBhcHBlbmQoKnN0cik7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgaWYgKHN0ciAmJiBsZW5ndGggIT0gMCkgewor ICAgICAgICBpbnQgbmV3bGVuID0gbV9sZW5ndGggKyBsZW5ndGg7CisgICAgICAgIFVDaGFyKiBj ID0gbmV3VUNoYXJWZWN0b3IobmV3bGVuKTsKKyAgICAgICAgbWVtY3B5KGMsIG1fZGF0YSwgcG9z ICogc2l6ZW9mKFVDaGFyKSk7CisgICAgICAgIG1lbWNweShjICsgcG9zLCBzdHIsIGxlbmd0aCAq IHNpemVvZihVQ2hhcikpOworICAgICAgICBtZW1jcHkoYyArIHBvcyArIGxlbmd0aCwgbV9kYXRh ICsgcG9zLCAobV9sZW5ndGggLSBwb3MpICogc2l6ZW9mKFVDaGFyKSk7CisgICAgICAgIGRlbGV0 ZVVDaGFyVmVjdG9yKG1fZGF0YSk7CisgICAgICAgIG1fZGF0YSA9IGM7CisgICAgICAgIG1fbGVu Z3RoID0gbmV3bGVuOworICAgICAgICBtX2hhc1Rlcm1pbmF0aW5nTnVsbENoYXJhY3RlciA9IGZh bHNlOworICAgIH0KK30KKwogdm9pZCBTdHJpbmdJbXBsOjp0cnVuY2F0ZShpbnQgbGVuKQogewog ICAgIGFzc2VydCghbV9pblRhYmxlKTsKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCShyZXZpc2lvbiAxNjUy OCkKKysrIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYg KzQsNyBAQAogICogQ29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcp CiAgKiAgICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcp CiAgKiAgICAgICAgICAgKEMpIDIwMDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisg KiAgICAgICAgICAgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYu Y29tKQogICogQ29weXJpZ2h0IChDKSAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJ bmMuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgpAQCAtMjksNiArMzAsOCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2Fj aGUuaCIgCiAjaW5jbHVkZSAiQWZmaW5lVHJhbnNmb3JtLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1h Z2UuaCIKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5v ZGUuaCIKICNpbmNsdWRlICJEZWNvZGVyLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNs dWRlICJFbGVtZW50LmgiCkBAIC0zNyw2ICs0MCw3IEBACiAjaW5jbHVkZSAiRnJhbWUuaCIKICNp bmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNs dWRlICJIVE1MT0xpc3RFbGVtZW50LmgiCiAjaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRl ICJSZW5kZXJBcmVuYS5oIgogI2luY2x1ZGUgIlJlbmRlckZsZXhpYmxlQm94LmgiCkBAIC02NSw2 ICs2OSwxNSBAQAogc3RhdGljIHZvaWQgKmJhc2VPZlJlbmRlck9iamVjdEJlaW5nRGVsZXRlZDsK ICNlbmRpZgogCit0eXBlZGVmIEhhc2hNYXA8U3RyaW5nLCBDb3VudGVyTm9kZSo+IENvdW50ZXJO b2RlTWFwOwordHlwZWRlZiBIYXNoTWFwPGNvbnN0IFJlbmRlck9iamVjdCosIENvdW50ZXJOb2Rl TWFwKj4gUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzOworCitzdGF0aWMgUmVuZGVyT2Jq ZWN0c1RvQ291bnRlck5vZGVNYXBzKiBnZXRSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMo KQoreworICAgIHN0YXRpYyBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMgb2JqZWN0c01h cDsKKyAgICByZXR1cm4gJm9iamVjdHNNYXA7Cit9CisKIHZvaWQqIFJlbmRlck9iamVjdDo6b3Bl cmF0b3IgbmV3KHNpemVfdCBzeiwgUmVuZGVyQXJlbmEqIHJlbmRlckFyZW5hKSB0aHJvdygpCiB7 CiAgICAgcmV0dXJuIHJlbmRlckFyZW5hLT5hbGxvY2F0ZShzeik7CkBAIC0xNzcsNyArMTkwLDgg QEAKIAogbV9yZXBsYWNlZCggZmFsc2UgKSwKIG1faXNEcmFnZ2luZyggZmFsc2UgKSwKLW1faGFz T3ZlcmZsb3dDbGlwKGZhbHNlKQorbV9oYXNPdmVyZmxvd0NsaXAoZmFsc2UpLAorbV9oYXNDb3Vu dGVyTm9kZU1hcChmYWxzZSkKIHsKICNpZm5kZWYgTkRFQlVHCiAgICAgKytSZW5kZXJPYmplY3RD b3VudGVyOjpjb3VudDsKQEAgLTIzOTUsNiArMjQwOSwyMiBAQAogCiB2b2lkIFJlbmRlck9iamVj dDo6ZGVzdHJveSgpCiB7CisgICAgaWYgKG1faGFzQ291bnRlck5vZGVNYXApIHsKKyAgICAgICAg UmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKiBvYmplY3RzTWFwID0gZ2V0UmVuZGVyT2Jq ZWN0c1RvQ291bnRlck5vZGVNYXBzKCk7CisgICAgICAgIENvdW50ZXJOb2RlTWFwKiBjb3VudGVy Tm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7CisgICAgICAgIGlmIChjb3VudGVyTm9k ZXNNYXApIHsKKyAgICAgICAgICAgIENvdW50ZXJOb2RlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQg PSBjb3VudGVyTm9kZXNNYXAtPmVuZCgpOworICAgICAgICAgICAgZm9yIChDb3VudGVyTm9kZU1h cDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBjb3VudGVyTm9kZXNNYXAtPmJlZ2luKCk7IGl0ICE9IGVu ZDsgKytpdCkgeworICAgICAgICAgICAgICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9IGl0 LT5zZWNvbmQ7CisgICAgICAgICAgICAgICAgY291bnRlck5vZGUtPnJlbW92ZSgpOworICAgICAg ICAgICAgICAgIGRlbGV0ZSBjb3VudGVyTm9kZTsKKyAgICAgICAgICAgICAgICBjb3VudGVyTm9k ZSA9IDA7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBvYmplY3RzTWFwLT5yZW1vdmUodGhp cyk7CisgICAgICAgICAgICBkZWxldGUgY291bnRlck5vZGVzTWFwOworICAgICAgICB9CisgICAg fQorICAgIAogICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+cmVtb3ZlKHRoaXMpOwog CiAgICAgLy8gQnkgZGVmYXVsdCBubyByZWYtY291bnRpbmcuIFJlbmRlcldpZGdldDo6ZGVzdHJv eSgpIGRvZXNuJ3QgY2FsbApAQCAtMjgzNyw2ICsyODY3LDE1OSBAQAogICAgIHJldHVybiAoYXZv aWRzRmxvYXRzKCkgJiYgKHN0eWxlKCktPndpZHRoKCkuaXNBdXRvKCkgfHwgaXNIUigpIHx8IChz dHlsZSgpLT5odG1sSGFja3MoKSAmJiAhaXNUYWJsZSgpKSkpOwogfQogCitib29sIFJlbmRlck9i amVjdDo6aGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAg IGlmIChzdHlsZSgpKSB7CisgICAgICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVyUmVzZXQoY291 bnRlck5hbWUpIHx8IHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpKQor ICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmIChtX2hhc0NvdW50ZXJOb2RlTWFw KSB7CisgICAgICAgICAgICBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMqIG9iamVjdHNN YXAgPSBnZXRSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMoKTsKKyAgICAgICAgICAgIENv dW50ZXJOb2RlTWFwKiBjb3VudGVyTm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7Cisg ICAgICAgICAgICBpZiAoY291bnRlck5vZGVzTWFwICYmIGNvdW50ZXJOb2Rlc01hcC0+Z2V0KGNv dW50ZXJOYW1lKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAg IH0KKyAgICAKKyAgICBpZiAoY291bnRlck5hbWUgPT0gImxpc3QtaXRlbSIpCisgICAgICAgIGlm IChpc0xpc3RJdGVtKCkgfHwgKGVsZW1lbnQoKSAmJiAoCisgICAgICAgICAgICAgICAgZWxlbWVu dCgpLT5oYXNUYWdOYW1lKG9sVGFnKSB8fAorICAgICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFz VGFnTmFtZSh1bFRhZykgfHwKKyAgICAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUo bWVudVRhZykgfHwKKyAgICAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUoZGlyVGFn KSkpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K0NvdW50ZXJOb2RlKiBSZW5kZXJPYmplY3Q6OmZpbmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291 bnRlck5hbWUsIGJvb2wgd2lsbE5lZWRMYXlvdXQsIGJvb2wgdXNlc1NlcGFyYXRvcikKK3sKKyAg ICBpZiAoIXN0eWxlKCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgaW50IHZhbCA9IDA7Cisg ICAgUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKiBvYmplY3RzTWFwID0gZ2V0UmVuZGVy T2JqZWN0c1RvQ291bnRlck5vZGVNYXBzKCk7CisgICAgQ291bnRlck5vZGUqIG5ld05vZGUgPSAw OworICAgIGlmIChtX2hhc0NvdW50ZXJOb2RlTWFwKSB7CisgICAgICAgIENvdW50ZXJOb2RlTWFw KiBjb3VudGVyTm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7CisgICAgICAgIGlmIChj b3VudGVyTm9kZXNNYXApCisgICAgICAgICAgICBuZXdOb2RlID0gY291bnRlck5vZGVzTWFwLT5n ZXQoY291bnRlck5hbWUpOworICAgIH0KKyAgICAgICAgCisgICAgaWYgKG5ld05vZGUpCisgICAg ICAgIHJldHVybiBuZXdOb2RlOworCisgICAgaWYgKHN0eWxlKCktPmhhc0NvdW50ZXJSZXNldChj b3VudGVyTmFtZSkgfHwgaXNSb290KCkpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVy UmVzZXROb2RlKHRoaXMpOworICAgICAgICB2YWwgPSBzdHlsZSgpLT5jb3VudGVyUmVzZXQoY291 bnRlck5hbWUpOworICAgICAgICBpZiAoc3R5bGUoKS0+aGFzQ291bnRlckluY3JlbWVudChjb3Vu dGVyTmFtZSkpCisgICAgICAgICAgICB2YWwgKz0gc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChj b3VudGVyTmFtZSk7CisgICAgfSBlbHNlIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50 KGNvdW50ZXJOYW1lKSkgeworICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKHRoaXMp OworICAgICAgICB2YWwgKz0gc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChjb3VudGVyTmFtZSk7 CisgICAgfSBlbHNlIGlmIChjb3VudGVyTmFtZSA9PSAibGlzdC1pdGVtIikgeworICAgICAgICBp ZiAoaXNMaXN0SXRlbSgpKSB7CisgICAgICAgICAgICBpZiAoZWxlbWVudCgpKSB7CisgICAgICAg ICAgICAgICAgU3RyaW5nIHYgPSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgpKS0+Z2V0 QXR0cmlidXRlKCJ2YWx1ZSIpOworICAgICAgICAgICAgICAgIGlmICghdi5pc0VtcHR5KCkpIHsK KyAgICAgICAgICAgICAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMp OworICAgICAgICAgICAgICAgICAgICB2YWwgPSB2LnRvSW50KCk7CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgfSAKKyAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKCFuZXdOb2Rl KSB7CisgICAgICAgICAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAg ICAgICAgICAgICAgICB2YWwgPSAxOworICAgICAgICAgICAgfQorICAgICAgICB9IGVsc2UgaWYg KGVsZW1lbnQoKSAmJiBlbGVtZW50KCktPmhhc1RhZ05hbWUob2xUYWcpKSB7CisgICAgICAgICAg ICBuZXdOb2RlID0gbmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICB2YWwg PSBzdGF0aWNfY2FzdDxIVE1MT0xpc3RFbGVtZW50Kj4oZWxlbWVudCgpKS0+c3RhcnQoKTsKKyAg ICAgICAgfSBlbHNlIGlmIChlbGVtZW50KCkgJiYKKyAgICAgICAgICAgIChlbGVtZW50KCktPmhh c1RhZ05hbWUodWxUYWcpIHx8CisgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKG1l bnVUYWcpIHx8CisgICAgICAgICAgICAgZWxlbWVudCgpLT5oYXNUYWdOYW1lKGRpclRhZykpKSB7 CisgICAgICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAg ICAgICAgICB2YWwgPSAwOworICAgICAgICB9CisgICAgfSAKKyAgICAKKyAgICBpZiAoIW5ld05v ZGUpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAgICAg dmFsID0gMDsKKyAgICB9CisgICAgCisgICAgbmV3Tm9kZS0+c2V0VmFsdWUodmFsKTsKKyAgICBp ZiAod2lsbE5lZWRMYXlvdXQpCisgICAgICAgIG5ld05vZGUtPnNldFdpbGxOZWVkTGF5b3V0KCk7 CisgICAgaWYgKHVzZXNTZXBhcmF0b3IpCisgICAgICAgIG5ld05vZGUtPnNldFVzZXNTZXBhcmF0 b3IoKTsKKworICAgIENvdW50ZXJOb2RlTWFwKiBub2RlTWFwOworICAgIGlmIChtX2hhc0NvdW50 ZXJOb2RlTWFwKSB7CisgICAgICAgIG5vZGVNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7Cisg ICAgICAgIG9iamVjdHNNYXAtPnJlbW92ZSh0aGlzKTsKKyAgICB9IGVsc2UgeworICAgICAgICBu b2RlTWFwID0gbmV3IENvdW50ZXJOb2RlTWFwOworICAgICAgICBtX2hhc0NvdW50ZXJOb2RlTWFw ID0gdHJ1ZTsKKyAgICB9CisgICAgCisgICAgbm9kZU1hcC0+c2V0KGNvdW50ZXJOYW1lLCBuZXdO b2RlKTsKKyAgICBvYmplY3RzTWFwLT5zZXQodGhpcywgbm9kZU1hcCk7CisKKyAgICBpZiAoIWlz Um9vdCgpKSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBsYXN0ID0gMDsKKyAgICAgICAgQ291bnRl ck5vZGUqIGN1cnJlbnQgPSAwOworICAgICAgICBSZW5kZXJPYmplY3QqIG4gPSAhaXNMaXN0SXRl bSgpICYmIHByZXZpb3VzU2libGluZygpID8gCisgICAgICAgICAgICBwcmV2aW91c1NpYmxpbmco KS0+cHJldmlvdXNTaWJsaW5nKCkgOiBwcmV2aW91c1NpYmxpbmcoKTsKKworICAgICAgICB3aGls ZSAobikgeworICAgICAgICAgICAgaWYgKG4tPmhhc0NvdW50ZXIoY291bnRlck5hbWUpKSB7Cisg ICAgICAgICAgICAgICAgY3VycmVudCA9IG4tPmZpbmRDb3VudGVyKGNvdW50ZXJOYW1lKTsKKyAg ICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAg IG4gPSBuLT5wcmV2aW91c1NpYmxpbmcoKTsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAg bGFzdCA9IGN1cnJlbnQ7CisgICAgICAgIENvdW50ZXJOb2RlKiBzaWJsaW5nID0gY3VycmVudDsK KyAgICAgICAgaWYgKGxhc3QgJiYgIW5ld05vZGUtPmlzUmVzZXQoKSkgeworICAgICAgICAgICAg Ly8gRm91bmQgcmVuZGVyLXNpYmxpbmcsIG5vdyBzZWFyY2ggZm9yIGxhdGVyIGNvdW50ZXItc2li bGluZ3MgYW1vbmcgaXRzIHJlbmRlci1jaGlsZHJlbgorICAgICAgICAgICAgbiA9IG4tPmxhc3RD aGlsZCgpOworICAgICAgICAgICAgd2hpbGUgKG4pIHsKKyAgICAgICAgICAgICAgICBpZiAobi0+ aGFzQ291bnRlcihjb3VudGVyTmFtZSkpIHsKKyAgICAgICAgICAgICAgICAgICAgY3VycmVudCA9 IG4tPmZpbmRDb3VudGVyKGNvdW50ZXJOYW1lKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKGxh c3QtPnBhcmVudCgpID09IGN1cnJlbnQtPnBhcmVudCgpIHx8IHNpYmxpbmcgPT0gY3VycmVudC0+ cGFyZW50KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAg ICAgICAgICAgICAgICAgICAgICAgLy8gSWYgdGhlIGN1cnJlbnQgY291bnRlciBpcyBub3QgdGhl IGxhc3QsIHNlYXJjaCBkZWVwZXIKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChjdXJyZW50 LT5uZXh0U2libGluZygpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgbiA9IG4tPmxh c3RDaGlsZCgpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJl YWs7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgbiA9IG4tPnByZXZpb3VzU2libGluZygpOworICAgICAgICAgICAgfQorICAgICAgICAg ICAgCisgICAgICAgICAgICBpZiAoc2libGluZy0+aXNSZXNldCgpKSB7CisgICAgICAgICAgICAg ICAgaWYgKGxhc3QgIT0gc2libGluZykKKyAgICAgICAgICAgICAgICAgICAgc2libGluZy0+aW5z ZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAg ICAgICAgICAgICBzaWJsaW5nLT5pbnNlcnRBZnRlcihuZXdOb2RlLCAwKTsKKyAgICAgICAgICAg IH0gZWxzZQorICAgICAgICAgICAgICAgIGxhc3QtPnBhcmVudCgpLT5pbnNlcnRBZnRlcihuZXdO b2RlLCBsYXN0KTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIC8vIE5vdGhpbmcgZm91 bmQgYW1vbmcgc2libGluZ3MsIGxldCBvdXIgcGFyZW50IHNlYXJjaAorICAgICAgICAgICAgbGFz dCA9IHBhcmVudCgpLT5maW5kQ291bnRlcihjb3VudGVyTmFtZSwgZmFsc2UpOworICAgICAgICAg ICAgaWYgKGxhc3QtPmlzUmVzZXQoKSkKKyAgICAgICAgICAgICAgICBsYXN0LT5pbnNlcnRBZnRl cihuZXdOb2RlLCAwKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBsYXN0LT5w YXJlbnQoKS0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7CisgICAgICAgIH0KKyAgICB9CisK KyAgICByZXR1cm4gbmV3Tm9kZTsKK30KKwogVUNoYXIgUmVuZGVyT2JqZWN0OjpiYWNrc2xhc2hB c0N1cnJlbmN5U3ltYm9sKCkgY29uc3QKIHsKICAgICBpZiAoTm9kZSAqbm9kZSA9IGVsZW1lbnQo KSkKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1JlbmRlck9i amVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBAQAogICogQ29weXJpZ2h0IChDKSAy MDAwIExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgQW50 dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDAgRGly ayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAgICAgICAgKEMpIDIwMDQgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQogICogQ29weXJpZ2h0IChDKSAyMDAz LCAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCiAgKgogICogVGhpcyBsaWJy YXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAt MzEsNiArMzIsNyBAQAogI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCiAjaW5jbHVkZSAiU2Nyb2xs QmFyLmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCisjaW5jbHVkZSA8d3RmL0hhc2hN YXAuaD4KIAogLyoKICAqICBUaGUgcGFpbnRpbmcgb2YgYSBsYXllciBvY2N1cnMgaW4gdGhyZWUg ZGlzdGluY3QgcGhhc2VzLiAgRWFjaCBwaGFzZSBpbnZvbHZlcwpAQCAtNTQsNiArNTYsNyBAQAog Y2xhc3MgSFRNTEFyZWFFbGVtZW50OwogY2xhc3MgSW5saW5lQm94OwogY2xhc3MgSW5saW5lRmxv d0JveDsKK2NsYXNzIENvdW50ZXJOb2RlOwogY2xhc3MgUG9zaXRpb247CiBjbGFzcyBSZW5kZXJB cmVuYTsKIGNsYXNzIFJlbmRlckJsb2NrOwpAQCAtMTkyLDYgKzE5NSwxMCBAQAogICAgIHZpcnR1 YWwgaW50IHN0YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBpbnQgc3Rh dGljWSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAgICBib29sIGhhc0NvdW50ZXIoY29u c3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdDsKKyAgICBDb3VudGVyTm9kZSogZmluZENvdW50ZXIo Y29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSwgYm9vbCB3aWxsTmVlZExheW91dCA9IGZhbHNlLCBi b29sIHVzZXNTZXBhcmF0b3IgPSBmYWxzZSk7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmpl Y3QgdHJlZSBtYW5pcHVsYXRpb24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8v Ly8vLy8vLy8vLy8KICAgICB2aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBA IC0yNTMsNiArMjYwLDcgQEAKICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0 IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0 IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlz Qm9keSgpIGNvbnN0OwpAQCAtOTI0LDYgKzkzMiw4IEBACiAgICAgYm9vbCBtX2lzRHJhZ2dpbmcg ICAgICAgICAgICAgICAgOiAxOwogICAgIAogICAgIGJvb2wgbV9oYXNPdmVyZmxvd0NsaXAgICAg ICAgICAgIDogMTsKKyAgICAKKyAgICBib29sIG1faGFzQ291bnRlck5vZGVNYXAgICAgICAgICA6 IDE7CiAKICAgICAvLyBub3RlOiBkbyBub3QgYWRkIHVubmVjZXNzYXJ5IGJpdGZsYWdzLCB3ZSBo YXZlIDMyIGJpdCBhbHJlYWR5IQogICAgIGZyaWVuZCBjbGFzcyBSZW5kZXJMaXN0SXRlbTsKSW5k ZXg6IHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1Jl bmRlckNvdW50ZXIuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmgJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNTQgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBv ZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChD KSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHly aWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3Rv biwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqLworI2lmbmRlZiBSRU5ERVJfQ09VTlRFUl9I XworI2RlZmluZSBSRU5ERVJfQ09VTlRFUl9IXworCisjaW5jbHVkZSAiUmVuZGVyVGV4dC5oIgor CituYW1lc3BhY2UgV2ViQ29yZSB7CisgICAgY2xhc3MgQ291bnRlck5vZGU7CisKKy8vIC0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisKK2NsYXNzIFJlbmRlckNvdW50ZXIgOiBwdWJsaWMgUmVuZGVyVGV4 dCB7CisKK3B1YmxpYzoKKyAgICBSZW5kZXJDb3VudGVyKE5vZGUqLCBDb3VudGVyRGF0YSopOwor ICAgIAorICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0IHsgcmV0dXJu ICJSZW5kZXJDb3VudGVyIjsgfQorCisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0 IHsgcmV0dXJuIHRydWU7IH0KKyAgICB2aXJ0dWFsIHZvaWQgbGF5b3V0KCk7CisgICAgdmlydHVh bCB2b2lkIGNhbGNNaW5NYXhXaWR0aCgpOworCitwcml2YXRlOgorICAgIFN0cmluZyBjb252ZXJ0 VmFsdWVUb1R5cGUoaW50IHZhbHVlLCBpbnQgdG90YWwsIEVMaXN0U3R5bGVUeXBlKTsKKworICAg IFN0cmluZyBtX2l0ZW07CisgICAgQ291bnRlckRhdGEqIG1fY291bnRlcjsKKyAgICBDb3VudGVy Tm9kZSogbV9jb3VudGVyTm9kZTsKK307CisKK30gLy9uYW1lc3BhY2UKKworI2VuZGlmCkluZGV4 OiByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9D b3VudGVyUmVzZXROb2RlLmgJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvQ291bnRlclJlc2V0 Tm9kZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYyIEBACisvKgorICogVGhpcyBmaWxlIGlz IHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHly aWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisg KiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBz ZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisg KiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisqLworI2lmbmRlZiBDb3VudGVyX1Jl c2V0X05vZGVfaF8KKyNkZWZpbmUgQ291bnRlcl9SZXNldF9Ob2RlX2hfCisKKyNpbmNsdWRlICJD b3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIFRoaXMgZmlsZSBpbXBs ZW1lbnRzIGEgY291bnRlci10cmVlIHRoYXQgaXMgdXNlZCBmb3IgZmluZGluZyBhbGwgcGFyZW50 cyBpbiBjb3VudGVycygpIGxvb2t1cCwKKy8vIGFuZCBmb3IgcHJvcGFnYXRpbmcgY291bnQtY2hh bmdlcyB3aGVuIG5vZGVzIGFyZSBhZGRlZCBvciByZW1vdmVkLgorLy8gUGxlYXNlIG5vdGUgdGhh dCBvbmx5IGNvdW50ZXItcmVzZXQgYW5kIHJvb3QgY2FuIGJlIHBhcmVudHMgaGVyZSwgYW5kIHRo YXQgcmVuZGVyLXRyZWUgcGFyZW50cworLy8gYXJlIGp1c3QgY291bnRlci10cmVlIHNpYmxpbmdz CisKKy8vIEltcGxlbWVudGF0aW9uIG9mIGNvdW50ZXItcmVzZXQgYW5kIHJvb3QKK2NsYXNzIENv dW50ZXJSZXNldE5vZGUgOiBwdWJsaWMgQ291bnRlck5vZGUgeworCitwdWJsaWM6CisgICAgQ291 bnRlclJlc2V0Tm9kZShSZW5kZXJPYmplY3QqKTsKKworICAgIHZpcnR1YWwgQ291bnRlck5vZGUq IGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiBtX2ZpcnN0OyB9OworICAgIHZpcnR1YWwgQ291 bnRlck5vZGUqIGxhc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fbGFzdDsgfTsKKyAgICB2aXJ0 dWFsIHZvaWQgaW5zZXJ0QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSog cmVmQ2hpbGQpOworICAgIHZpcnR1YWwgdm9pZCByZW1vdmVDaGlsZCAoQ291bnRlck5vZGUqKTsK KworICAgIHZpcnR1YWwgYm9vbCBpc1Jlc2V0KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfTsKKyAg ICB2aXJ0dWFsIENvdW50ZXJOb2RlKiByZWNvdW50QW5kR2V0TmV4dChib29sIHNldERpcnR5ID0g dHJ1ZSk7CisgICAgdmlydHVhbCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisKKyAgICB2b2lkIHVw ZGF0ZVRvdGFsKGludCB2YWx1ZSk7CisgICAgLy8gVGhlIGhpZ2hlc3QgdmFsdWUgYW1vbmcgY2hp bGRyZW4KKyAgICBpbnQgdG90YWwoKSBjb25zdCB7IHJldHVybiBtX3RvdGFsOyB9OworCitwcm90 ZWN0ZWQ6CisgICAgaW50IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAg Q291bnRlck5vZGUqIG1fbGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2Vu ZGlmIC8vIENvdW50ZXJSZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRl bS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24g MCkKKysrIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSw0MyBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRp b24gZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVu c2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1 dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90 LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVt cGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisg KgorICovCisgCisjaWZuZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0 SXRlbV9ICisKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7 CisKK2NsYXNzIENvdW50ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVyTm9kZQoreworcHVibGlj OgorICAgIGludCBjb3VudCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9v bCBzZXREaXJ0eSA9IHRydWUpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKwor fTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb3Vu dGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlz aW9uIDApCisrKyByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMjQ1IEBACisvKioKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRl cmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2Fu ZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFw cGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7 IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVi bGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lv biAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9u LgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0 IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2 ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhh dmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElC LiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5j LiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3 LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJD b3VudGVyLmgiCisKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJS ZXNldE5vZGUuaCIKKyNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxl LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0g NzsKKworUmVuZGVyQ291bnRlcjo6UmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0 YSogY291bnRlcikKKyAgICA6IFJlbmRlclRleHQobm9kZSwgMCksIG1fY291bnRlcihjb3VudGVy KSwgbV9jb3VudGVyTm9kZSgwKQoreworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmxheW91dCgp Cit7CisgICAgQVNTRVJUKG5lZWRzTGF5b3V0KCkpOworCisgICAgaWYgKCFtaW5NYXhLbm93bigp KQorICAgICAgICBjYWxjTWluTWF4V2lkdGgoKTsKKworICAgIFJlbmRlclRleHQ6OmxheW91dCgp OworfQorCitzdGF0aWMgU3RyaW5nIHRvUm9tYW4oaW50IG51bWJlciwgYm9vbCB1cHBlcikKK3sg CisgICAgU3RyaW5nIHJvbWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAn dicsICd4JywgJ2wnLCAnYycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1td ID0geyAnSScsICdWJywgJ1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hh ciogZGlnaXRzID0gdXBwZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7Cisg ICAgZG8geworICAgICAgICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0g JSA1IDwgNCkKKyAgICAgICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQor ICAgICAgICAgICAgICAgIHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAg aWYgKG51bSA+PSA0ICYmIG51bSA8PSA4KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdp dHNbZCArIDFdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA9PSA5KQorICAgICAgICAgICAgcm9t YW4uaW5zZXJ0KCZkaWdpdHNbZCArIDJdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0g NCkKKyAgICAgICAgICAgIHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAg bnVtYmVyIC89IDEwOworICAgICAgICBkICs9IDI7CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAg ICByZXR1cm4gcm9tYW47Cit9CisKK3N0YXRpYyBTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51 bWJlciwgVUNoYXIgbGV0dGVyQSkKK3sgCisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJl dHVybiBTdHJpbmcoJmxldHRlckEsIDEpOyAvLyBtYXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94 ICgwLikKKworICAgIFN0cmluZyBsZXR0ZXJTdHJpbmc7CisgICAgVUNoYXIgYzsKKyAgICB3aGls ZSAobnVtYmVyID4gMCkgeworICAgICAgICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUg MjY7CisgICAgICAgIGMgPSBsZXR0ZXJBICsgb25lc0RpZ2l0OworICAgICAgICBsZXR0ZXJTdHJp bmcgPSBTdHJpbmcoJmMsIDEpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25l c0RpZ2l0OworICAgICAgICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRl clN0cmluZzsKK30KKworc3RhdGljIFN0cmluZyB0b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAg IGlmIChudW1iZXIgPCAxKQorICAgICAgICByZXR1cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsK KyAgICAKKyAgICBzdGF0aWMgY29uc3QgVUNoYXIgdGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAx NTAwLCAxNTAyLCAxNTA0LCAxNTA1LCAxNTA2LCAxNTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBs ZXR0ZXI7CisgICAgVUNoYXIgYzsKKyAgICBpZiAobnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxl dHRlciA9IHRvSGVicmV3KG51bWJlciAvIDEwMDApICsgIiciOworICAgICAgICBudW1iZXIgPSBu dW1iZXIgJSAxMDAwOworICAgIH0KKyAgICBpbnQgZm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAw OworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZm91ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAg YyA9IDE1MTEgKyAzOworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgIH0KKyAgICBudW1i ZXIgJT0gNDAwOworICAgIGlmIChudW1iZXIgLyAxMDApIHsKKyAgICAgICAgYyA9IDE1MTEgKyAo bnVtYmVyIC8gMTAwKSAtIDE7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfQorICAg IG51bWJlciAlPSAxMDA7CisgICAgaWYgKG51bWJlciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsK KyAgICAgICAgYyA9IDE0ODcgKyA5OworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAg ICBjID0gMTQ4NyArIG51bWJlciAtIDk7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAg fSBlbHNlIHsKKyAgICAgICAgaW50IHRlbnMgPSBudW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRl bnMpIHsKKyAgICAgICAgICAgIGMgPSB0ZW5EaWdpdFt0ZW5zIC0gMV07CisgICAgICAgICAgICBs ZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICB9CisgICAgICAgIG51bWJlciA9IG51bWJlciAlIDEw OworICAgICAgICBpZiAobnVtYmVyKSB7CisgICAgICAgICAgICBjID0gMTQ4NyArIG51bWJlcjsK KyAgICAgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0 dXJuIGxldHRlcjsKK30KKworU3RyaW5nIFJlbmRlckNvdW50ZXI6OmNvbnZlcnRWYWx1ZVRvVHlw ZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJp bmcgaXRlbTsKKyAgICBVQ2hhciBjOworICAgIHN3aXRjaCh0eXBlKSB7CisgICAgICAgIGNhc2Ug TE5PTkU6CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgLy8gR2x5cGhzOgorICAgICAgICBj YXNlIERJU0M6CisgICAgICAgICAgICBjID0gMHgyMDIyOworICAgICAgICAgICAgaXRlbSA9IFN0 cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBDSVJDTEU6Cisg ICAgICAgICAgICBjID0gMHgyNWU2OworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7 CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBj ID0gMHgyNWEwOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgY2FzZSBBUk1FTklBTjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoK KyAgICAgICAgY2FzZSBDSktfSURFT0dSQVBISUM6CisgICAgICAgIGNhc2UgSElSQUdBTkE6Cisg ICAgICAgIGNhc2UgS0FUQUtBTkE6CisgICAgICAgIGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAg ICAgIGNhc2UgS0FUQUtBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pF Uk86CisgICAgICAgICAgICAvLyBGSVhNRTogVGhlc2UgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRl ZC4gRm9yIG5vdyB3ZSdsbCB1c2UgZGVjaW1hbCBpbnN0ZWFkLgorICAgICAgICBjYXNlIExERUNJ TUFMOgorICAgICAgICAgICAgaXRlbSA9IFN0cmluZzo6bnVtYmVyKHZhbHVlKTsKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAvLyBBbGdvcml0bWljOgorICAgICAgICBjYXNlIExPV0VSX1JP TUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9tYW4odmFsdWUsIGZhbHNlKTsKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICBjYXNlIFVQUEVSX1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9 IHRvUm9tYW4odmFsdWUsIHRydWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2Ug TE9XRVJfR1JFRUs6IHsKKyAgICAgICAgICAgIGludCBudW1iZXIgPSB2YWx1ZSAtIDE7CisgICAg ICAgICAgICBpbnQgbCA9IChudW1iZXIgJSAyNCk7CisgICAgICAgICAgICBpZiAobCA+IDE2KQor ICAgICAgICAgICAgICAgIGwrKzsgLy8gU2tpcCBHUkVFSyBTTUFMTCBMRVRURVIgRklOQUwgU0lH TUEKKyAgICAgICAgICAgIGMgPSA5NDUgKyBsOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygm YywgMSk7CisgICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkr KykKKyAgICAgICAgICAgICAgICBpdGVtICs9ICInIjsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICB9CisgICAgICAgIGNhc2UgSEVCUkVXOgorICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3 KHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgor ICAgICAgICBjYXNlIExPV0VSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3Ry aW5nKHZhbHVlLCAnYScpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJf QUxQSEE6CisgICAgICAgIGNhc2UgVVBQRVJfTEFUSU46CisgICAgICAgICAgICBpdGVtID0gdG9M ZXR0ZXJTdHJpbmcodmFsdWUsICdBJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVm YXVsdDoKKyAgICAgICAgICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAg ICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291 bnRlcjo6Y2FsY01pbk1heFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkpOwor CisgICAgaWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGNvdW50ZXJz ID0gIW1fY291bnRlci0+c2VwYXJhdG9yKCkuaXNOdWxsKCk7CisKKyAgICBpZiAoIW1fY291bnRl ck5vZGUgJiYgcGFyZW50KCktPnBhcmVudCgpKQorICAgICAgICBtX2NvdW50ZXJOb2RlID0gcGFy ZW50KCktPnBhcmVudCgpLT5maW5kQ291bnRlcihtX2NvdW50ZXItPmlkZW50aWZpZXIoKSwgdHJ1 ZSwgY291bnRlcnMpOworCisgICAgaW50IHZhbHVlID0gbV9jb3VudGVyTm9kZS0+Y291bnQoKTsK KyAgICBpZiAobV9jb3VudGVyTm9kZS0+aXNSZXNldCgpKQorICAgICAgICB2YWx1ZSA9IG1fY291 bnRlck5vZGUtPnZhbHVlKCk7CisgICAgCisgICAgaW50IHRvdGFsID0gdmFsdWU7CisgICAgaWYg KG1fY291bnRlck5vZGUtPnBhcmVudCgpKQorICAgICAgICB0b3RhbCA9IG1fY291bnRlck5vZGUt PnBhcmVudCgpLT50b3RhbCgpOworICAgIAorICAgIG1faXRlbSA9IGNvbnZlcnRWYWx1ZVRvVHlw ZSh2YWx1ZSwgdG90YWwsIChFTGlzdFN0eWxlVHlwZSltX2NvdW50ZXItPmxpc3RTdHlsZSgpKTsK KworICAgIGlmIChjb3VudGVycykgeworICAgICAgICBDb3VudGVyTm9kZSogY291bnRlciA9IG1f Y291bnRlck5vZGUtPnBhcmVudCgpOworICAgICAgICBib29sIGZpcnN0ID0gdHJ1ZTsKKyAgICAg ICAgd2hpbGUgIChjb3VudGVyLT5wYXJlbnQoKSAmJiAoZmlyc3QgfHwgIShjb3VudGVyLT5pc1Jl c2V0KCkgJiYgY291bnRlci0+cGFyZW50KCktPmlzUm9vdCgpKSkpIHsKKyAgICAgICAgICAgIHZh bHVlID0gY291bnRlci0+Y291bnQoKSA/IGNvdW50ZXItPmNvdW50KCkgOiAxOworICAgICAgICAg ICAgdG90YWwgPSBjb3VudGVyLT5wYXJlbnQoKS0+dG90YWwoKTsKKyAgICAgICAgICAgIG1faXRl bSA9IGNvbnZlcnRWYWx1ZVRvVHlwZSh2YWx1ZSwgdG90YWwsIChFTGlzdFN0eWxlVHlwZSltX2Nv dW50ZXItPmxpc3RTdHlsZSgpKSAKKyAgICAgICAgICAgICAgICArIG1fY291bnRlci0+c2VwYXJh dG9yKCkgKyBtX2l0ZW07CisgICAgICAgICAgICBjb3VudGVyID0gY291bnRlci0+cGFyZW50KCk7 CisgICAgICAgICAgICBmaXJzdCA9IGZhbHNlOworICAgICAgICB9CisgICAgfQorCisgICAgc3Ry ID0gbmV3IFN0cmluZ0ltcGwobV9pdGVtLmNoYXJhY3RlcnMoKSwgbV9pdGVtLmxlbmd0aCgpKTsK KyAgICAKKyAgICBSZW5kZXJUZXh0OjpjYWxjTWluTWF4V2lkdGgoKTsKK30KKworfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSByZW5kZXJpbmcvQ291bnRlck5vZGUuY3BwCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5n L0NvdW50ZXJOb2RlLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMTEgQEAKKy8qCisgKiBU aGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisg KgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3 b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1 aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyAqLworCisjaW5j bHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKKworI2luY2x1ZGUgIkNv dW50ZXJSZXNldE5vZGUuaCIKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitDb3VudGVyTm9kZTo6Q291bnRlck5vZGUoUmVuZGVyT2JqZWN0ICpvKQor ICAgIDogbV9oYXNTZXBhcmF0b3IoZmFsc2UpCisgICAgLCBtX3dpbGxOZWVkTGF5b3V0KGZhbHNl KQorICAgICwgbV92YWx1ZSgwKQorICAgICwgbV9jb3VudCAoMCkKKyAgICAsIG1fcGFyZW50KDAp CisgICAgLCBtX3ByZXZpb3VzKDApCisgICAgLCBtX25leHQgKDApCisgICAgLCBtX3JlbmRlcmVy KG8pCit7ICAgCit9CisKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2Rl KiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VSVChmYWxzZSk7Cit9CisKK3ZvaWQgQ291bnRl ck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKikKK3sKKyAgICBBU1NFUlQoZmFsc2UpOwor fQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmUoKQoreworICAgIGlmIChtX3BhcmVudCkKKyAg ICAgICAgbV9wYXJlbnQtPnJlbW92ZUNoaWxkKHRoaXMpOworICAgIGVsc2UgeworICAgICAgICBB U1NFUlQoaXNSZXNldCgpKTsKKyAgICAgICAgQVNTRVJUKCFmaXJzdENoaWxkKCkpOworICAgICAg ICBBU1NFUlQoIWxhc3RDaGlsZCgpKTsKKyAgICB9Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNl dFVzZXNTZXBhcmF0b3IoKQoreworICAgIGZvciAoQ291bnRlck5vZGUqIGMgPSB0aGlzOyBjOyBj ID0gYy0+cGFyZW50KCkpCisgICAgICAgIGMtPnNldEhhc1NlcGFyYXRvcigpOworfQorCitDb3Vu dGVyTm9kZSogQ291bnRlck5vZGU6OnJlY291bnRBbmRHZXROZXh0KGJvb2wgc2V0RGlydHkpCit7 CisgICAgaW50IG9sZF9jb3VudCA9IG1fY291bnQ7CisgICAgaWYgKG1fcHJldmlvdXMpCisgICAg ICAgIG1fY291bnQgPSBtX3ByZXZpb3VzLT5jb3VudCgpICsgbV92YWx1ZTsKKyAgICBlbHNlIHsK KyAgICAgICAgYXNzZXJ0KG1fcGFyZW50LT5maXJzdENoaWxkKCkgPT0gdGhpcyk7CisgICAgICAg IG1fY291bnQgPSBtX3BhcmVudC0+dmFsdWUoKSArIG1fdmFsdWU7CisgICAgfQorICAgIAorICAg IGlmIChvbGRfY291bnQgIT0gbV9jb3VudCAmJiBzZXREaXJ0eSkKKyAgICAgICAgc2V0U2VsZkRp cnR5KCk7CisgICAgaWYgKG9sZF9jb3VudCAhPSBtX2NvdW50IHx8ICFzZXREaXJ0eSkgeworICAg ICAgICBpZiAobV9wYXJlbnQpCisgICAgICAgICAgICBtX3BhcmVudC0+dXBkYXRlVG90YWwobV9j b3VudCk7CisgICAgICAgIHJldHVybiBtX25leHQ7CisgICAgfQorICAgIAorICAgIHJldHVybiAw OworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50VHJlZShib29sIHNldERpcnR5KQorewor ICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9IHRoaXM7CisgICAgd2hpbGUgKGNvdW50ZXJO b2RlKQorICAgICAgICBjb3VudGVyTm9kZSA9IGNvdW50ZXJOb2RlLT5yZWNvdW50QW5kR2V0TmV4 dChzZXREaXJ0eSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNldFNlbGZEaXJ0eSgpCit7Cisg ICAgaWYgKG1fcmVuZGVyZXIgJiYgbV93aWxsTmVlZExheW91dCkKKyAgICAgICAgbV9yZW5kZXJl ci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNhbGMoKTsKK30KKwordm9pZCBDb3VudGVyTm9k ZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlmIChtX3JlbmRlcmVyICYmIG1fd2lsbE5lZWRM YXlvdXQgJiYgbV9oYXNTZXBhcmF0b3IpCisgICAgICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5 b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4OiByZW5kZXJp bmcvUmVuZGVyU3R5bGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAko cmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAkod29ya2luZyBjb3B5 KQpAQCAtMzUsMTIgKzM1LDE1IEBACiAgKiBhbmQgcHJvZHVjZSBpbnZhbGl1ZCByZXN1bHRzLgog ICovCiAKKyNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIkNTU1ZhbHVl TGlzdC5oIgogI2luY2x1ZGUgIkNvbG9yLmgiCiAjaW5jbHVkZSAiRGF0YVJlZi5oIgogI2luY2x1 ZGUgIkZvbnQuaCIKICNpbmNsdWRlICJHcmFwaGljc1R5cGVzLmgiCiAjaW5jbHVkZSAiSW50UmVj dC5oIgogI2luY2x1ZGUgIkxlbmd0aC5oIgorI2luY2x1ZGUgIlBhaXIuaCIKICNpbmNsdWRlICJT aGFyZWQuaCIKICNpbmNsdWRlICJUZXh0RGlyZWN0aW9uLmgiCiAjaW5jbHVkZSA8d3RmL1ZlY3Rv ci5oPgpAQCAtNTksOSArNjIsMTEgQEAKIAogdXNpbmcgc3RkOjptYXg7CiAKLWNsYXNzIENTU1N0 eWxlU2VsZWN0b3I7CiBjbGFzcyBDYWNoZWRJbWFnZTsKIGNsYXNzIENhY2hlZFJlc291cmNlOwor Y2xhc3MgQ1NTU3R5bGVTZWxlY3RvcjsKK2NsYXNzIENTU1ZhbHVlTGlzdDsKK2NsYXNzIFBhaXI7 CiBjbGFzcyBSZW5kZXJBcmVuYTsKIGNsYXNzIFNoYWRvd1ZhbHVlOwogY2xhc3MgU3RyaW5nSW1w bDsKQEAgLTQwNyw4ICs0MTIsOCBAQAogICAgICAgICByZXR1cm4gKCBjbGlwID09IG8uY2xpcCAm JgogICAgICAgICAgICAgICAgICBoYXNDbGlwID09IG8uaGFzQ2xpcCAmJgogICAgICAgICAgICAg ICAgICBjb2xzcGFuID09IG8uY29sc3BhbiAmJgotICAgICAgICAgICAgICAgICBjb3VudGVyX2lu Y3JlbWVudCA9PSBvLmNvdW50ZXJfaW5jcmVtZW50ICYmCi0gICAgICAgICAgICAgICAgIGNvdW50 ZXJfcmVzZXQgPT0gby5jb3VudGVyX3Jlc2V0ICYmCisgICAgICAgICAgICAgICAgIGNvdW50ZXJJ bmNyZW1lbnQgPT0gby5jb3VudGVySW5jcmVtZW50ICYmCisgICAgICAgICAgICAgICAgIGNvdW50 ZXJSZXNldCA9PSBvLmNvdW50ZXJSZXNldCAmJgogICAgICAgICAgICAgICAgICB0ZXh0RGVjb3Jh dGlvbiA9PSBvLnRleHREZWNvcmF0aW9uKTsKICAgICB9CiAgICAgYm9vbCBvcGVyYXRvciE9KCBj b25zdCBTdHlsZVZpc3VhbERhdGEgJm8gKSBjb25zdCB7CkBAIC00MjEsOCArNDI2LDggQEAKICAg ICAKICAgICBzaG9ydCBjb2xzcGFuOyAvLyBmb3IgaHRtbCwgbm90IGEgY3NzMiBhdHRyaWJ1dGUK IAotICAgIHNob3J0IGNvdW50ZXJfaW5jcmVtZW50OyAvL29rLCBzbyB0aGVzZSBhcmUgbm90IHZp c3VhbCBtb2RlIHNwZXNpZmljCi0gICAgc2hvcnQgY291bnRlcl9yZXNldDsgICAgIC8vY2FuJ3Qg Z28gdG8gaW5oZXJpdGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAorICAgIHNob3J0 IGNvdW50ZXJJbmNyZW1lbnQ7IC8vIG9rLCBzbyB0aGVzZSBhcmUgbm90IHZpc3VhbCBtb2RlIHNw ZWNpZmljCisgICAgc2hvcnQgY291bnRlclJlc2V0OyAgICAgLy8gY2FuJ3QgZ28gdG8gaW5oZXJp dGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAogCiB9OwogCkBAIC04NzIsNiArODc3 LDIzIEBACiAgICAgQ09OVEVOVF9OT05FLCBDT05URU5UX09CSkVDVCwgQ09OVEVOVF9URVhULCBD T05URU5UX0NPVU5URVIKIH07CiAKK2NsYXNzIENvdW50ZXJEYXRhIHsKKyAgICAKK3B1YmxpYzoK KyAgICBDb3VudGVyRGF0YSgpIHt9CisgICAgQ291bnRlckRhdGEoY29uc3QgU3RyaW5nJiBpLCBF TGlzdFN0eWxlVHlwZSBsLCBjb25zdCBTdHJpbmcmIHMpCisgICAgICAgIDogbV9pZGVudGlmaWVy KGkpLCBtX2xpc3RTdHlsZShsKSwgbV9zZXBhcmF0b3Iocykge30KKyAgICAKKyAgICBTdHJpbmcg aWRlbnRpZmllcigpIHsgcmV0dXJuIG1faWRlbnRpZmllcjsgfQorICAgIEVMaXN0U3R5bGVUeXBl IGxpc3RTdHlsZSgpIHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9CisgICAgU3RyaW5nIHNlcGFyYXRv cigpIHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1faWRl bnRpZmllcjsKKyAgICBFTGlzdFN0eWxlVHlwZSBtX2xpc3RTdHlsZTsKKyAgICBTdHJpbmcgbV9z ZXBhcmF0b3I7Cit9OworCiBzdHJ1Y3QgQ29udGVudERhdGEgewogICAgIENvbnRlbnREYXRhKCkg Ol9jb250ZW50VHlwZShDT05URU5UX05PTkUpLCBfbmV4dENvbnRlbnQoMCkge30KICAgICB+Q29u dGVudERhdGEoKTsKQEAgLTg4MSwxMyArOTAzLDE0IEBACiAKICAgICBTdHJpbmdJbXBsKiBjb250 ZW50VGV4dCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9URVhUKSByZXR1cm4gX2Nv bnRlbnQudGV4dDsgcmV0dXJuIDA7IH0KICAgICBDYWNoZWRSZXNvdXJjZSogY29udGVudE9iamVj dCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpIHJldHVybiBfY29udGVu dC5vYmplY3Q7IHJldHVybiAwOyB9CisgICAgQ291bnRlckRhdGEqIGNvbnRlbnRDb3VudGVyKCkg eyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5UX0NPVU5URVIpIHJldHVybiBfY29udGVudC5j b3VudGVyOyByZXR1cm4gMDsgfQogICAgIAogICAgIENvbnRlbnRUeXBlIF9jb250ZW50VHlwZTsK IAogICAgIHVuaW9uIHsKICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIG9iamVjdDsKICAgICAgICAg U3RyaW5nSW1wbCogdGV4dDsKLSAgICAgICAgLy8gY291bnRlcnMuLi4KKyAgICAgICAgQ291bnRl ckRhdGEqIGNvdW50ZXI7CiAgICAgfSBfY29udGVudCA7CiAKICAgICBDb250ZW50RGF0YSogX25l eHRDb250ZW50OwpAQCAtMTA0NSw3ICsxMDY4LDkgQEAKICAgICAKICAgICAvLyBhZGRlZCB0aGlz IGhlcmUsIHNvIHdlIGNhbiBnZXQgcmlkIG9mIHRoZSB2cHRyIGluIHRoaXMgY2xhc3MuCiAgICAg Ly8gbWFrZXMgdXAgZm9yIHRoZSBzYW1lIHNpemUuCi0gICAgQ29udGVudERhdGEgKmNvbnRlbnQ7 CisgICAgQ29udGVudERhdGEqIGNvbnRlbnQ7CisgICAgUmVmUHRyPENTU1ZhbHVlTGlzdD4gY291 bnRlclJlc2V0TGlzdDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiBjb3VudGVySW5jcmVtZW50 TGlzdDsKIAogICAgIHVuc2lnbmVkIG1fcHNldWRvU3RhdGUgOiAzOyAvLyBQc2V1ZG9TdGF0ZQog ICAgIGJvb2wgbV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzIDogMTsKQEAgLTEyOTUsOCAr MTMyMCw4IEBACiAgICAgRUVtcHR5Q2VsbCBlbXB0eUNlbGxzKCkgY29uc3QgeyByZXR1cm4gc3Rh dGljX2Nhc3Q8RUVtcHR5Q2VsbD4oaW5oZXJpdGVkX2ZsYWdzLl9lbXB0eV9jZWxscyk7IH0KICAg ICBFQ2FwdGlvblNpZGUgY2FwdGlvblNpZGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxF Q2FwdGlvblNpZGU+KGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlKTsgfQogCi0gICAgc2hv cnQgY291bnRlckluY3JlbWVudCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlcl9pbmNy ZW1lbnQ7IH0KLSAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwt PmNvdW50ZXJfcmVzZXQ7IH0KKyAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkgY29uc3QgeyBy ZXR1cm4gdmlzdWFsLT5jb3VudGVySW5jcmVtZW50OyB9CisgICAgc2hvcnQgY291bnRlclJlc2V0 KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyUmVzZXQ7IH0KIAogICAgIEVMaXN0U3R5 bGVUeXBlIGxpc3RTdHlsZVR5cGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFTGlzdFN0 eWxlVHlwZT4oaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUpOyB9CiAgICAgQ2FjaGVk SW1hZ2UgKmxpc3RTdHlsZUltYWdlKCkgY29uc3QgeyByZXR1cm4gaW5oZXJpdGVkLT5zdHlsZV9p bWFnZTsgfQpAQCAtMTUwMSw4ICsxNTI2LDggQEAKICAgICB2b2lkIHNldENhcHRpb25TaWRlKEVD YXB0aW9uU2lkZSB2KSB7IGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlID0gdjsgfQogCiAK LSAgICB2b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1YWws Y291bnRlcl9pbmNyZW1lbnQsdikgfQotICAgIHZvaWQgc2V0Q291bnRlclJlc2V0KHNob3J0IHYp IHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJfcmVzZXQsdikgfQorICAgIHZvaWQgc2V0Q291bnRl ckluY3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVySW5jcmVtZW50LHYp IH0KKyAgICB2b2lkIHNldENvdW50ZXJSZXNldChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxj b3VudGVyUmVzZXQsdikgfQogCiAgICAgdm9pZCBzZXRMaXN0U3R5bGVUeXBlKEVMaXN0U3R5bGVU eXBlIHYpIHsgaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUgPSB2OyB9CiAgICAgdm9p ZCBzZXRMaXN0U3R5bGVJbWFnZShDYWNoZWRJbWFnZSAqdikgeyAgU0VUX1ZBUihpbmhlcml0ZWQs c3R5bGVfaW1hZ2Usdil9CkBAIC0xNTk3LDcgKzE2MjIsMTggQEAKICAgICBib29sIGNvbnRlbnRE YXRhRXF1aXZhbGVudChjb25zdCBSZW5kZXJTdHlsZSAqb3RoZXJTdHlsZSkgY29uc3Q7CiAgICAg dm9pZCBzZXRDb250ZW50KFN0cmluZ0ltcGwqIHMsIGJvb2wgYWRkID0gZmFsc2UpOwogICAgIHZv aWQgc2V0Q29udGVudChDYWNoZWRSZXNvdXJjZSogbywgYm9vbCBhZGQgPSBmYWxzZSk7CisgICAg dm9pZCBzZXRDb250ZW50KENvdW50ZXJEYXRhKiwgYm9vbCBhZGQgPSBmYWxzZSk7CiAKKyAgICBi b29sIGNvdW50ZXJEYXRhRXF1aXZhbGVudChSZW5kZXJTdHlsZSopOworICAgIHZvaWQgc2V0Q291 bnRlclJlc2V0TGlzdChQYXNzUmVmUHRyPENTU1ZhbHVlTGlzdD4gbCkgeyBjb3VudGVyUmVzZXRM aXN0ID0gbDsgfQorICAgIHZvaWQgc2V0Q291bnRlckluY3JlbWVudExpc3QoUGFzc1JlZlB0cjxD U1NWYWx1ZUxpc3Q+IGwpIHsgY291bnRlckluY3JlbWVudExpc3QgPSBsOyB9CisgICAgYm9vbCBo YXNDb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgYm9vbCBoYXNDb3VudGVy SW5jcmVtZW50KGNvbnN0IFN0cmluZyYpIGNvbnN0OworICAgIGludCBjb3VudGVyUmVzZXQoY29u c3QgU3RyaW5nJikgY29uc3Q7CisgICAgaW50IGNvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5n JikgY29uc3Q7CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVyUmVzZXRWYWx1ZUxpc3QoKSB7IHJl dHVybiBjb3VudGVyUmVzZXRMaXN0LmdldCgpOyB9CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVy SW5jcmVtZW50VmFsdWVMaXN0KCkgeyByZXR1cm4gY291bnRlckluY3JlbWVudExpc3QuZ2V0KCk7 IH0KKwogICAgIGJvb2wgaW5oZXJpdGVkTm90RXF1YWwoIFJlbmRlclN0eWxlICpvdGhlciApIGNv bnN0OwogCiAgICAgLy8gVGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0d28gc3R5bGVzLiAgVGhlIGZv bGxvd2luZyB2YWx1ZXMgYXJlIHVzZWQ6CkluZGV4OiByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9k ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZp c2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZpc2lvbiAwKQpA QCAtMCwwICsxLDE1NiBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJl bmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2 IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJDb3Vu dGVyUmVzZXROb2RlLmgiCisKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCitDb3VudGVyUmVzZXROb2RlOjpDb3VudGVyUmVzZXROb2RlKFJlbmRlck9i amVjdCogbykKKyAgICA6IENvdW50ZXJOb2RlKG8pCisgICAgLCBtX3RvdGFsKDApCisgICAgLCBt X2ZpcnN0KDApCisgICAgLCBtX2xhc3QoMCkKK3sKK30KKwordm9pZCBDb3VudGVyUmVzZXROb2Rl OjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGls ZCkKK3sKKyAgICBBU1NFUlQobmV3Q2hpbGQpOworICAgIEFTU0VSVCghcmVmQ2hpbGQgfHwgcmVm Q2hpbGQtPnBhcmVudCgpID09IHRoaXMpOworCisgICAgbmV3Q2hpbGQtPm1fcGFyZW50ID0gdGhp czsKKyAgICBuZXdDaGlsZC0+bV9wcmV2aW91cyA9IHJlZkNoaWxkOworCisgICAgaWYgKHJlZkNo aWxkKSB7CisgICAgICAgIG5ld0NoaWxkLT5tX25leHQgPSByZWZDaGlsZC0+bV9uZXh0OworICAg ICAgICByZWZDaGlsZC0+bV9uZXh0ID0gbmV3Q2hpbGQ7CisgICAgfSBlbHNlIHsKKyAgICAgICAg bmV3Q2hpbGQtPm1fbmV4dCA9IG1fZmlyc3Q7CisgICAgICAgIG1fZmlyc3QgPSBuZXdDaGlsZDsK KyAgICB9CisKKyAgICBpZiAobmV3Q2hpbGQtPm1fbmV4dCkgeworICAgICAgICBhc3NlcnQobmV3 Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9PSByZWZDaGlsZCk7CisgICAgICAgIG5ld0NoaWxk LT5tX25leHQtPm1fcHJldmlvdXMgPSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAgICAgICBh c3NlcnQgKG1fbGFzdCA9PSByZWZDaGlsZCk7CisgICAgICAgIG1fbGFzdCA9IG5ld0NoaWxkOwor ICAgIH0KKworICAgIG5ld0NoaWxkLT5yZWNvdW50VHJlZShmYWxzZSk7Cit9CisKK3ZvaWQgQ291 bnRlclJlc2V0Tm9kZTo6cmVtb3ZlQ2hpbGQoQ291bnRlck5vZGUqIG9sZENoaWxkKQoreworICAg IEFTU0VSVChvbGRDaGlsZCk7CisKKyAgICBDb3VudGVyTm9kZSogbmV4dCA9IG9sZENoaWxkLT5t X25leHQ7CisgICAgQ291bnRlck5vZGUqIHByZXYgPSBvbGRDaGlsZC0+bV9wcmV2aW91czsKKwor ICAgIGlmIChvbGRDaGlsZC0+Zmlyc3RDaGlsZCgpKSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBm aXJzdCA9IG9sZENoaWxkLT5maXJzdENoaWxkKCk7CisgICAgICAgIENvdW50ZXJOb2RlKiBsYXN0 ID0gb2xkQ2hpbGQtPmxhc3RDaGlsZCgpOworICAgICAgICBpZiAocHJldikgeworICAgICAgICAg ICAgcHJldi0+bV9uZXh0ID0gZmlyc3Q7CisgICAgICAgICAgICBmaXJzdC0+bV9wcmV2aW91cyA9 IHByZXY7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgbV9maXJzdCA9IGZpcnN0OworCisg ICAgICAgIGlmIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3ByZXZpb3VzID0gbGFzdDsK KyAgICAgICAgICAgIGxhc3QtPm1fbmV4dCA9IG5leHQ7CisgICAgICAgIH0gZWxzZQorICAgICAg ICAgICAgbV9sYXN0ID0gbGFzdDsKKworICAgICAgICBuZXh0ID0gZmlyc3Q7CisgICAgICAgIHdo aWxlIChuZXh0KSB7CisgICAgICAgICAgICBuZXh0LT5tX3BhcmVudCA9IHRoaXM7CisgICAgICAg ICAgICBuZXh0ID0gbmV4dC0+bV9uZXh0OworICAgICAgICB9CisKKyAgICAgICAgZmlyc3QtPnJl Y291bnRUcmVlKHRydWUpOworICAgIH0gZWxzZSB7CisgICAgICAgIGlmIChwcmV2KSAKKyAgICAg ICAgICAgIHByZXYtPm1fbmV4dCA9IG5leHQ7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAg YXNzZXJ0ICggbV9maXJzdCA9PSBvbGRDaGlsZCApOworICAgICAgICAgICAgbV9maXJzdCA9IG5l eHQ7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQorICAgICAgICAgICAg bmV4dC0+bV9wcmV2aW91cyA9IHByZXY7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgYXNz ZXJ0ICggbV9sYXN0ID09IG9sZENoaWxkICk7CisgICAgICAgICAgICBtX2xhc3QgPSBwcmV2Owor ICAgICAgICB9CisgICAgICAgIAorICAgICAgICBpZiAobmV4dCkKKyAgICAgICAgICAgIG5leHQt PnJlY291bnRUcmVlKCk7CisgICAgfQorCisKKyAgICBvbGRDaGlsZC0+bV9uZXh0ID0gMDsKKyAg ICBvbGRDaGlsZC0+bV9wcmV2aW91cyA9IDA7CisgICAgb2xkQ2hpbGQtPm1fcGFyZW50ID0gMDsK K30KKworQ291bnRlck5vZGUqIENvdW50ZXJSZXNldE5vZGU6OnJlY291bnRBbmRHZXROZXh0KGJv b2wgc2V0RGlydHkpCit7CisgICAgaW50IG9sZF9jb3VudCA9IG1fY291bnQ7CisgICAgaWYgKG1f cHJldmlvdXMpCisgICAgICAgIG1fY291bnQgPSBtX3ByZXZpb3VzLT5jb3VudCgpOworICAgIGVs c2UgaWYgKG1fcGFyZW50KQorICAgICAgICBtX2NvdW50ID0gbV9wYXJlbnQtPnZhbHVlKCk7Cisg ICAgZWxzZQorICAgICAgICBtX2NvdW50ID0gMDsKKworICAgIHVwZGF0ZVRvdGFsKG1fdmFsdWUp OworICAgIAorICAgIGlmIChzZXREaXJ0eSkKKyAgICAgICAgc2V0U2VsZkRpcnR5KCk7CisgICAg aWYgKCFzZXREaXJ0eSB8fCBtX2NvdW50ICE9IG9sZF9jb3VudCkKKyAgICAgICAgcmV0dXJuIG1f bmV4dDsKKyAgICAKKyAgICByZXR1cm4gMDsKK30KKwordm9pZCBDb3VudGVyUmVzZXROb2RlOjpz ZXRQYXJlbnREaXJ0eSgpCit7CisgICAgaWYgKGhhc1NlcGFyYXRvcigpKQorICAgICAgICBzZXRT ZWxmRGlydHkoKTsKKyAgICAgICAgCisgICAgZm9yIChDb3VudGVyTm9kZSogbiA9IGZpcnN0Q2hp bGQoKTsgbjsgbiA9IG4tPm5leHRTaWJsaW5nKCkpCisgICAgICAgIGlmIChuLT5oYXNTZXBhcmF0 b3IoKSkKKyAgICAgICAgICAgIG4tPnNldFNlbGZEaXJ0eSgpOworfQorCit2b2lkIENvdW50ZXJS ZXNldE5vZGU6OnVwZGF0ZVRvdGFsKGludCB2YWx1ZSkKK3sKKyAgICBpZiAodmFsdWUgPiBtX3Rv dGFsKQorICAgICAgICBtX3RvdGFsID0gdmFsdWU7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4 OiByZW5kZXJpbmcvUmVuZGVyQ29udGFpbmVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcv UmVuZGVyQ29udGFpbmVyLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVy Q29udGFpbmVyLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdo dCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAx OTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAy MDAwIERpcmsgTXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0 IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAo QykgMjAwMywgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICogQ29weXJp Z2h0IChDKSAyMDA2IEFuZHJldyBXZWxsaW5ndG9uIChwcm90b25Ad2lyZXRhcHBlZC5uZXQpCiAg KgpAQCAtMjgsNiArMjksNyBAQAogI2luY2x1ZGUgIlJlbmRlckNvbnRhaW5lci5oIgogCiAjaW5j bHVkZSAiaHRtbGVkaXRpbmcuaCIKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCiAjaW5jbHVk ZSAiUmVuZGVyTGlzdEl0ZW0uaCIKICNpbmNsdWRlICJSZW5kZXJUYWJsZS5oIgogI2luY2x1ZGUg IlJlbmRlclRleHRGcmFnbWVudC5oIgpAQCAtMjk2LDcgKzI5OCw3IEBACiAgICAgICAgIC8vIGRl dGVybWluZWQgdGhhdCB0aGUgcHNldWRvIGlzIG5vdCBkaXNwbGF5IE5PTkUsIGFueSBkaXNwbGF5 IG90aGVyIHRoYW4KICAgICAgICAgLy8gaW5saW5lIHNob3VsZCBiZSBtdXRhdGVkIHRvIElOTElO RS4KICAgICAgICAgcHNldWRvLT5zZXREaXNwbGF5KElOTElORSk7Ci0gICAgCisKICAgICBpZiAo b2xkQ29udGVudFByZXNlbnQpIHsKICAgICAgICAgaWYgKGNoaWxkICYmIGNoaWxkLT5zdHlsZSgp LT5zdHlsZVR5cGUoKSA9PSB0eXBlKSB7CiAgICAgICAgICAgICAvLyBXZSBoYXZlIGdlbmVyYXRl ZCBjb250ZW50IHByZXNlbnQgc3RpbGwuICBXZSB3YW50IHRvIHdhbGsgdGhpcyBjb250ZW50IGFu ZCB1cGRhdGUgb3VyCkBAIC0zMzQsMjAgKzMzNiwyNCBAQAogICAgICAgICBpZiAoIXBzZXVkb0Nv bnRhaW5lcikKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lciA9IFJlbmRlckZsb3c6OmNyZWF0 ZUFub255bW91c0Zsb3coZG9jdW1lbnQoKSwgcHNldWRvKTsgLyogYW5vbnltb3VzIGJveCAqLwog ICAgICAgICAKLSAgICAgICAgaWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRF TlRfVEVYVCkKLSAgICAgICAgeworICAgICAgICBpZiAoY29udGVudERhdGEtPmNvbnRlbnRUeXBl KCkgPT0gQ09OVEVOVF9URVhUKSB7CiAgICAgICAgICAgICBSZW5kZXJUZXh0KiB0ID0gbmV3IChy ZW5kZXJBcmVuYSgpKSBSZW5kZXJUZXh0RnJhZ21lbnQoZG9jdW1lbnQoKSAvKmFub255bW91cyBv YmplY3QgKi8sIGNvbnRlbnREYXRhLT5jb250ZW50VGV4dCgpKTsKICAgICAgICAgICAgIHQtPnNl dFN0eWxlKHBzZXVkbyk7CiAgICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKHQp OwotICAgICAgICB9Ci0gICAgICAgIGVsc2UgaWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgp ID09IENPTlRFTlRfT0JKRUNUKQotICAgICAgICB7CisgICAgICAgIH0gZWxzZSBpZiAoY29udGVu dERhdGEtPmNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpIHsKICAgICAgICAgICAgIFJl bmRlckltYWdlKiBpbWcgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlckltYWdlKGRvY3VtZW50 KCkpOyAvKiBBbm9ueW1vdXMgb2JqZWN0ICovCiAgICAgICAgICAgICBSZW5kZXJTdHlsZSogc3R5 bGUgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7CiAgICAgICAgICAgICBzdHls ZS0+aW5oZXJpdEZyb20ocHNldWRvKTsKICAgICAgICAgICAgIGltZy0+c2V0U3R5bGUoc3R5bGUp OwogICAgICAgICAgICAgaW1nLT5zZXRDb250ZW50T2JqZWN0KGNvbnRlbnREYXRhLT5jb250ZW50 T2JqZWN0KCkpOwogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRDaGlsZChpbWcpOwor ICAgICAgICB9IGVsc2UgaWYgKGNvbnRlbnREYXRhLT5fY29udGVudFR5cGUgPT0gQ09OVEVOVF9D T1VOVEVSKSB7CisgICAgICAgICAgICBSZW5kZXJDb3VudGVyKiBjID0gbmV3IChyZW5kZXJBcmVu YSgpKSBSZW5kZXJDb3VudGVyKGVsZW1lbnQoKSwgY29udGVudERhdGEtPmNvbnRlbnRDb3VudGVy KCkpOworICAgICAgICAgICAgUmVuZGVyU3R5bGUqIHN0eWxlID0gbmV3IChyZW5kZXJBcmVuYSgp KSBSZW5kZXJTdHlsZSgpOworICAgICAgICAgICAgc3R5bGUtPmluaGVyaXRGcm9tKHBzZXVkbyk7 CisgICAgICAgICAgICBjLT5zZXRJc0Fub255bW91cyh0cnVlKTsKKyAgICAgICAgICAgIGMtPnNl dFN0eWxlKHN0eWxlKTsKKyAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQoYyk7 CiAgICAgICAgIH0KICAgICB9CiAKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTm9kZS5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTm9kZS5oCShyZXZpc2lvbiAwKQorKysgcmVuZGVy aW5nL0NvdW50ZXJOb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsODcgQEAKKy8qCisgKiBU aGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisg KgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3 b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBp dCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5 IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0 d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3Ig KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkg aXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1 dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5 IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlz IGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1 aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZuZGVm IENvdW50ZXJfTm9kZV9oXworI2RlZmluZSBDb3VudGVyX05vZGVfaF8KKworI2luY2x1ZGUgIlJl bmRlck9iamVjdC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50ZXJSZXNl dE5vZGU7CisKKy8vIFRoaXMgZmlsZSBpbXBsZW1lbnRzIGEgY291bnRlci10cmVlIHRoYXQgaXMg dXNlZCBmb3IgZmluZGluZyBhbGwgcGFyZW50cyBpbiBjb3VudGVycygpIGxvb2t1cCwKKy8vIGFu ZCBmb3IgcHJvcGFnYXRpbmcgY291bnQtY2hhbmdlcyB3aGVuIG5vZGVzIGFyZSBhZGRlZCBvciBy ZW1vdmVkLgorLy8gUGxlYXNlIG5vdGUgdGhhdCBvbmx5IGNvdW50ZXItcmVzZXQgYW5kIHJvb3Qg Y2FuIGJlIHBhcmVudHMgaGVyZSwgYW5kIHRoYXQgcmVuZGVyLXRyZWUgcGFyZW50cworLy8gYXJl IGp1c3QgY291bnRlci10cmVlIHNpYmxpbmdzCisKKy8vIEltcGxlbWVudGF0aW9uIG9mIGNvdW50 ZXItaW5jcmVtZW50IGFuZCBjb3VudGVyLWNvbnRlbnQKK2NsYXNzIENvdW50ZXJOb2RlIHsKK3B1 YmxpYzoKKyAgICBDb3VudGVyTm9kZShSZW5kZXJPYmplY3QqKTsKKyAgICB2aXJ0dWFsIH5Db3Vu dGVyTm9kZSgpIHt9CisKKyAgICBDb3VudGVyUmVzZXROb2RlKiBwYXJlbnQoKSBjb25zdCB7IHJl dHVybiBtX3BhcmVudDsgfQorICAgIENvdW50ZXJOb2RlKiBwcmV2aW91c1NpYmxpbmcoKSBjb25z dCB7IHJldHVybiBtX3ByZXZpb3VzOyB9CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogbmV4dFNp YmxpbmcoKSBjb25zdCB7IHJldHVybiBtX25leHQ7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2Rl KiBmaXJzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZpcnR1YWwgQ291bnRlck5v ZGUqIGxhc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIHZvaWQgaW5z ZXJ0QWZ0ZXIoQ291bnRlck5vZGUqIG5ld0NoaWxkLCBDb3VudGVyTm9kZSogcmVmQ2hpbGQpOwor ICAgIHZpcnR1YWwgdm9pZCByZW1vdmVDaGlsZCAoQ291bnRlck5vZGUqIG9sZENoaWxkKTsKKyAg ICB2b2lkIHJlbW92ZSgpOworCisgICAgaW50IHZhbHVlKCkgY29uc3QgeyByZXR1cm4gbV92YWx1 ZTsgfQorICAgIHZvaWQgc2V0VmFsdWUoaW50IHYpIHsgbV92YWx1ZSA9IHY7IH0KKyAgICBpbnQg Y291bnQoKSBjb25zdCB7IHJldHVybiBtX2NvdW50OyB9CisgICAgdm9pZCBzZXRDb3VudChpbnQg YykgeyBtX2NvdW50ID0gYzsgfQorICAgIHZvaWQgc2V0SGFzU2VwYXJhdG9yKCkgeyBtX2hhc1Nl cGFyYXRvciA9IHRydWU7IH0KKworICAgIHZpcnR1YWwgYm9vbCBpc1Jlc2V0KCkgY29uc3R7IHJl dHVybiBmYWxzZTsgfQorICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIHJlY291bnRBbmRHZXROZXh0 KGJvb2wgc2V0RGlydHkgPSB0cnVlKTsKKyAgICB2aXJ0dWFsIHZvaWQgcmVjb3VudFRyZWUoYm9v bCBzZXREaXJ0eSA9IHRydWUpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKyAg ICB2aXJ0dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKworICAgIGJvb2wgaGFzU2VwYXJhdG9y KCkgY29uc3QgeyByZXR1cm4gbV9oYXNTZXBhcmF0b3I7IH07CisgICAgYm9vbCB3aWxsTmVlZExh eW91dCgpIGNvbnN0IHsgcmV0dXJuIG1fd2lsbE5lZWRMYXlvdXQ7IH07CisgICAgdm9pZCBzZXRV c2VzU2VwYXJhdG9yKCk7CisgICAgdm9pZCBzZXRXaWxsTmVlZExheW91dCgpIHsgbV93aWxsTmVl ZExheW91dCA9IHRydWU7IH07CisgICAgYm9vbCBpc1Jvb3QoKSBjb25zdCB7IHJldHVybiBtX3Jl bmRlcmVyICYmIG1fcmVuZGVyZXItPmlzUm9vdCgpOyB9CisKKyAgICB2b2lkIHNldFJlbmRlcmVy KFJlbmRlck9iamVjdCogbykgeyBtX3JlbmRlcmVyID0gbzsgfTsKKyAgICBSZW5kZXJPYmplY3Qq IHJlbmRlcmVyKCkgY29uc3QgeyByZXR1cm4gbV9yZW5kZXJlcjsgfTsKKworICAgIGZyaWVuZCBj bGFzcyBDb3VudGVyUmVzZXROb2RlOworcHJvdGVjdGVkOgorICAgIGJvb2wgbV9oYXNTZXBhcmF0 b3I7CisgICAgYm9vbCBtX3dpbGxOZWVkTGF5b3V0OworICAgIGludCBtX3ZhbHVlOworICAgIGlu dCBtX2NvdW50OworICAgIENvdW50ZXJSZXNldE5vZGUqIG1fcGFyZW50OworICAgIENvdW50ZXJO b2RlKiBtX3ByZXZpb3VzOworICAgIENvdW50ZXJOb2RlKiBtX25leHQ7CisgICAgUmVuZGVyT2Jq ZWN0KiBtX3JlbmRlcmVyOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYg Ly8gQ291bnRlck5vZGVfaApJbmRleDogcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIHJl bmRlcmluZy9SZW5kZXJTdHlsZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTkwLDggKzkwLDggQEAK ICAgICA6IGhhc0NsaXAoZmFsc2UpCiAgICAgLCB0ZXh0RGVjb3JhdGlvbihSZW5kZXJTdHlsZTo6 aW5pdGlhbFRleHREZWNvcmF0aW9uKCkpCiAgICAgLCBjb2xzcGFuKDEpCi0gICAgLCBjb3VudGVy X2luY3JlbWVudCgwKQotICAgICwgY291bnRlcl9yZXNldCgwKQorICAgICwgY291bnRlckluY3Jl bWVudCgwKQorICAgICwgY291bnRlclJlc2V0KDApCiB7CiB9CiAKQEAgLTEwNSw4ICsxMDUsOCBA QAogICAgICwgaGFzQ2xpcChvLmhhc0NsaXApCiAgICAgLCB0ZXh0RGVjb3JhdGlvbihvLnRleHRE ZWNvcmF0aW9uKQogICAgICwgY29sc3BhbihvLmNvbHNwYW4pCi0gICAgLCBjb3VudGVyX2luY3Jl bWVudChvLmNvdW50ZXJfaW5jcmVtZW50KQotICAgICwgY291bnRlcl9yZXNldChvLmNvdW50ZXJf cmVzZXQpCisgICAgLCBjb3VudGVySW5jcmVtZW50KG8uY291bnRlckluY3JlbWVudCkKKyAgICAs IGNvdW50ZXJSZXNldChvLmNvdW50ZXJSZXNldCkKIHsKIH0KIApAQCAtNTc3LDcgKzU3Nyw2IEBA CiAgICAgICAgIHByZXYtPmRlcmVmKGFyZW5hKTsKICAgICB9CiAgICAgZGVsZXRlIGNvbnRlbnQ7 Ci0gICAgCiAgICAgZGVsZXRlIHRoaXM7CiAgICAgCiAgICAgLy8gUmVjb3ZlciB0aGUgc2l6ZSBs ZWZ0IHRoZXJlIGZvciB1cyBieSBvcGVyYXRvciBkZWxldGUgYW5kIGZyZWUgdGhlIG1lbW9yeS4K QEAgLTY0OSw2ICs2NDgsOCBAQAogICAgICwgaW5oZXJpdGVkKG8uaW5oZXJpdGVkKQogICAgICwg cHNldWRvU3R5bGUoMCkKICAgICAsIGNvbnRlbnQoby5jb250ZW50KQorICAgICwgY291bnRlclJl c2V0TGlzdChvLmNvdW50ZXJSZXNldExpc3QpCisgICAgLCBjb3VudGVySW5jcmVtZW50TGlzdChv LmNvdW50ZXJJbmNyZW1lbnRMaXN0KQogICAgICwgbV9wc2V1ZG9TdGF0ZShvLm1fcHNldWRvU3Rh dGUpCiAgICAgLCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMoZmFsc2UpCiAgICAgLCBt X3VuaXF1ZShmYWxzZSkKQEAgLTgzOCw4ICs4MzksOCBAQAogICAgICAgICAhKG5vbmluaGVyaXRl ZF9mbGFncy5fZmxvYXRpbmcgPT0gb3RoZXItPm5vbmluaGVyaXRlZF9mbGFncy5fZmxvYXRpbmcp IHx8CiAgICAgICAgICEobm9uaW5oZXJpdGVkX2ZsYWdzLl9vcmlnaW5hbERpc3BsYXkgPT0gb3Ro ZXItPm5vbmluaGVyaXRlZF9mbGFncy5fb3JpZ2luYWxEaXNwbGF5KSB8fAogICAgICAgICAgdmlz dWFsLT5jb2xzcGFuICE9IG90aGVyLT52aXN1YWwtPmNvbHNwYW4gfHwKLSAgICAgICAgIHZpc3Vh bC0+Y291bnRlcl9pbmNyZW1lbnQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlcl9pbmNyZW1lbnQg fHwKLSAgICAgICAgIHZpc3VhbC0+Y291bnRlcl9yZXNldCAhPSBvdGhlci0+dmlzdWFsLT5jb3Vu dGVyX3Jlc2V0IHx8CisgICAgICAgICB2aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQgIT0gb3RoZXIt PnZpc3VhbC0+Y291bnRlckluY3JlbWVudCB8fAorICAgICAgICAgdmlzdWFsLT5jb3VudGVyUmVz ZXQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlclJlc2V0IHx8CiAgICAgICAgICBjc3MzTm9uSW5o ZXJpdGVkRGF0YS0+dGV4dE92ZXJmbG93ICE9IG90aGVyLT5jc3MzTm9uSW5oZXJpdGVkRGF0YS0+ dGV4dE92ZXJmbG93IHx8CiAgICAgICAgICAoY3NzM0luaGVyaXRlZERhdGEtPnRleHRTZWN1cml0 eSAhPSBvdGhlci0+Y3NzM0luaGVyaXRlZERhdGEtPnRleHRTZWN1cml0eSkpCiAgICAgICAgIHJl dHVybiBMYXlvdXQ7CkBAIC05MjUsNiArOTI2LDEwIEBACiAgICAgLy8gSWYgcmVnaW9ucyBjaGFu Z2UgdHJpZ2dlciBhIHJlbGF5b3V0IHRvIHJlLWNhbGMgcmVnaW9ucy4KICAgICBpZiAoIShjc3Mz Tm9uSW5oZXJpdGVkRGF0YS0+bV9kYXNoYm9hcmRSZWdpb25zID09IG90aGVyLT5jc3MzTm9uSW5o ZXJpdGVkRGF0YS0+bV9kYXNoYm9hcmRSZWdpb25zKSkKICAgICAgICAgcmV0dXJuIExheW91dDsK KyAgICAKKyAgICAvLyBJZiB0aGUgY291bnRlciBsaXN0cyBjaGFuZ2UsIHRyaWdnZXIgYSByZWxh eW91dCB0byByZS1jYWxjIENvdW50ZXJOb2Rlcy4KKyAgICBpZiAoY291bnRlclJlc2V0TGlzdCAh PSBvdGhlci0+Y291bnRlclJlc2V0TGlzdCB8fCBjb3VudGVySW5jcmVtZW50TGlzdCAhPSBvdGhl ci0+Y291bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiBMYXlvdXQ7CiAKICAgICAv LyBNYWtlIHN1cmUgdGhlc2UgbGVmdC90b3AvcmlnaHQvYm90dG9tIGNoZWNrcyBzdGF5IGJlbG93 IGFsbCBsYXlvdXQgY2hlY2tzIGFuZCBhYm92ZQogICAgIC8vIGFsbCB2aXNpYmxlIGNoZWNrcy4K QEAgLTEwODAsNiArMTA4NSwzMiBAQAogICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudFR5cGUg PSBDT05URU5UX1RFWFQ7CiB9CiAKK3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvbnRlbnQoQ291bnRl ckRhdGEqIGMsIGJvb2wgYWRkKQoreworICAgIGlmICghYykKKyAgICAgICAgcmV0dXJuOworCisg ICAgQ29udGVudERhdGEqIGxhc3RDb250ZW50ID0gY29udGVudDsKKyAgICB3aGlsZSAobGFzdENv bnRlbnQgJiYgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVudCkKKyAgICAgICAgbGFzdENvbnRlbnQg PSBsYXN0Q29udGVudC0+X25leHRDb250ZW50OworCisgICAgYm9vbCByZXVzZUNvbnRlbnQgPSAh YWRkOworICAgIENvbnRlbnREYXRhKiBuZXdDb250ZW50RGF0YSA9IDA7CisgICAgaWYgKHJldXNl Q29udGVudCAmJiBjb250ZW50KSB7CisgICAgICAgIGNvbnRlbnQtPmNsZWFyQ29udGVudCgpOwor ICAgICAgICBuZXdDb250ZW50RGF0YSA9IGNvbnRlbnQ7CisgICAgfSBlbHNlCisgICAgICAgIG5l d0NvbnRlbnREYXRhID0gbmV3IENvbnRlbnREYXRhOworCisgICAgaWYgKGxhc3RDb250ZW50ICYm ICFyZXVzZUNvbnRlbnQpCisgICAgICAgIGxhc3RDb250ZW50LT5fbmV4dENvbnRlbnQgPSBuZXdD b250ZW50RGF0YTsKKyAgICBlbHNlCisgICAgICAgIGNvbnRlbnQgPSBuZXdDb250ZW50RGF0YTsK KworICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudC5jb3VudGVyID0gYzsKKyAgICBuZXdDb250 ZW50RGF0YS0+X2NvbnRlbnRUeXBlID0gQ09OVEVOVF9DT1VOVEVSOworfQorCiBDb250ZW50RGF0 YTo6fkNvbnRlbnREYXRhKCkKIHsKICAgICBjbGVhckNvbnRlbnQoKTsKQEAgLTEwOTgsNiArMTEy OSwxMSBAQAogICAgICAgICBjYXNlIENPTlRFTlRfVEVYVDoKICAgICAgICAgICAgIF9jb250ZW50 LnRleHQtPmRlcmVmKCk7CiAgICAgICAgICAgICBfY29udGVudC50ZXh0ID0gMDsKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICBjYXNlIENPTlRFTlRfQ09VTlRFUjoKKyAgICAgICAgICAgIGRl bGV0ZSBfY29udGVudC5jb3VudGVyOworICAgICAgICAgICAgX2NvbnRlbnQuY291bnRlciA9IDA7 CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAgIDsKICAg ICB9CkBAIC0xMTg1LDYgKzEyMjEsODggQEAKICAgICByZXR1cm4geCA9PSBvLnggJiYgeSA9PSBv LnkgJiYgYmx1ciA9PSBvLmJsdXIgJiYgY29sb3IgPT0gby5jb2xvcjsKIH0KIAorYm9vbCBSZW5k ZXJTdHlsZTo6Y291bnRlckRhdGFFcXVpdmFsZW50KFJlbmRlclN0eWxlKiBvdGhlclN0eWxlKQor eworICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYWxzbyBjb21wYXJlIHRoZSBDb3VudGVyRGF0YT8g CisgICAgcmV0dXJuIGNvdW50ZXJSZXNldExpc3QgPT0gb3RoZXJTdHlsZS0+Y291bnRlclJlc2V0 TGlzdCAmJgorICAgICAgICAgICBjb3VudGVySW5jcmVtZW50TGlzdCA9PSBvdGhlclN0eWxlLT5j b3VudGVySW5jcmVtZW50TGlzdDsKK30KKworc3RhdGljIGJvb2wgaGFzQ291bnRlcihjb25zdCBT dHJpbmcmIGMsIENTU1ZhbHVlTGlzdCogbCkKK3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7 CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRp dmVWYWx1ZSogcHJpbWl0aXZlVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+ KGwtPml0ZW0oaSkpOworICAgICAgICBQYWlyKiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBh aXJWYWx1ZSgpOworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0 aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KHBhaXItPmZpcnN0KCkpOworICAgICAgICBBU1NF UlQocGFpcik7CisgICAgICAgIEFTU0VSVChjb3VudGVyTmFtZSk7CisgICAgICAgIGlmIChjb3Vu dGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBjKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7 CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5kZXJTdHlsZTo6aGFzQ291 bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0Cit7CisgICAgaWYgKGNv dW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiBoYXNDb3VudGVyKGNvdW50ZXJOYW1lLCBj b3VudGVyUmVzZXRMaXN0LmdldCgpKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wgUmVu ZGVyU3R5bGU6Omhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSkg Y29uc3QKK3sKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiBo YXNDb3VudGVyKGNvdW50ZXJOYW1lLCBjb3VudGVySW5jcmVtZW50TGlzdC5nZXQoKSk7CisgICAg cmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW50IHJlYWRDb3VudGVyKGNvbnN0IFN0cmluZyYg YywgQ1NTVmFsdWVMaXN0KiBsLCBib29sIGlzUmVzZXQpCit7CisgICAgaW50IGxlbiA9IGwtPmxl bmd0aCgpOworICAgIGludCB0b3RhbCA9IDA7CisgICAgCisgICAgZm9yIChpbnQgaSA9IDA7IGkg PCBsZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0aXZlVmFsdWUg PSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0oaSkpOworICAgICAgICBQ YWlyKiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgpOworICAgICAgICBDU1NQ cmltaXRpdmVWYWx1ZSogY291bnRlck5hbWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1 ZSo+KHBhaXItPmZpcnN0KCkpOworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogY291bnRlclZh bHVlID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWlyLT5zZWNvbmQoKSk7Cisg ICAgICAgIEFTU0VSVChwYWlyKTsKKyAgICAgICAgQVNTRVJUKGNvdW50ZXJOYW1lKTsKKyAgICAg ICAgQVNTRVJUKGNvdW50ZXJWYWx1ZSk7CisKKyAgICAgICAgaWYgKGNvdW50ZXJOYW1lLT5nZXRT dHJpbmdWYWx1ZSgpID09IGMpIHsKKyAgICAgICAgICAgIGZsb2F0IHZhbHVlID0gY291bnRlclZh bHVlLT5nZXRGbG9hdFZhbHVlKCk7CisgICAgICAgICAgICBpZiAodmFsdWUgPCBJTlRfTUFYICYm IHZhbHVlID4gSU5UX01JTikgeworICAgICAgICAgICAgICAgIGZsb2F0IGZsb2F0VG90YWwgPSAo aW50KXZhbHVlICsgdG90YWw7CisgICAgICAgICAgICAgICAgaWYgKGZsb2F0VG90YWwgPCBJTlRf TUFYICYmIGZsb2F0VG90YWwgPiBJTlRfTUlOKQorICAgICAgICAgICAgICAgICAgICB0b3RhbCAr PSAoaW50KXZhbHVlOworICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAgICAgICAgcmV0dXJu IHRvdGFsOworICAgICAgICAgICAgaWYgKGlzUmVzZXQpCisgICAgICAgICAgICAgICAgcmV0dXJu IHRvdGFsOworICAgICAgICB9CisgICAgfQorICAgIAorICAgIHJldHVybiB0b3RhbDsKK30KKwor aW50IFJlbmRlclN0eWxlOjpjb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSkg Y29uc3QKK3sKKyAgICBpZiAoY291bnRlclJlc2V0TGlzdCkKKyAgICAgICAgcmV0dXJuIHJlYWRD b3VudGVyKGNvdW50ZXJOYW1lLCBjb3VudGVyUmVzZXRMaXN0LmdldCgpLCB0cnVlKTsKKyAgICBl bHNlCisgICAgICAgIHJldHVybiAwOworfQorCitpbnQgUmVuZGVyU3R5bGU6OmNvdW50ZXJJbmNy ZW1lbnQoY29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSkgY29uc3QKK3sKKyAgICBpZiAoY291bnRl ckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiByZWFkQ291bnRlcihjb3VudGVyTmFtZSwg Y291bnRlckluY3JlbWVudExpc3QuZ2V0KCksIGZhbHNlKTsKKyAgICBlbHNlCisgICAgICAgIHJl dHVybiAwOworfQorCiBjb25zdCBWZWN0b3I8U3R5bGVEYXNoYm9hcmRSZWdpb24+JiBSZW5kZXJT dHlsZTo6aW5pdGlhbERhc2hib2FyZFJlZ2lvbnMoKQogeyAKICAgICBzdGF0aWMgVmVjdG9yPFN0 eWxlRGFzaGJvYXJkUmVnaW9uPiBlbXB0eUxpc3Q7CkluZGV4OiBXZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCShyZXZpc2lvbiAxNjUyOCkKKysrIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagkod29ya2luZyBjb3B5KQpAQCAtODU3LDYgKzg1NywxMyBAQAogCQk5MzVGQkNGMjA5QkEx NDNCMDBFMjMwQjEgLyogRXhjZXB0aW9uQ29kZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOTM1RkJDRjEwOUJBMTQzQjAwRTIzMEIxIC8qIEV4Y2VwdGlv bkNvZGUuaCAqLzsgfTsKIAkJOTM2QjQyNEUwOUE0MzZDRDAwQkFBODIwIC8qIFNWR0NTU1BhcnNl ci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEMw RjZGNjA4OTcwMUYxMDBCQTUxMTQgLyogU1ZHQ1NTUGFyc2VyLmNwcCAqLzsgfTsKIAkJOTM2QkRE MUQwQTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCBpbiBTb3VyY2VzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNkJERDFDMEEwMzFBRUIwMDRERjRB QiAvKiBHcmFwaGljc0NvbnRleHRDRy5jcHAgKi87IH07CisJCTkzNzFCQjcxMEFDNDdGQUUwMENE NEE3QiAvKiBSZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA5MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5o ICovOyB9OworCQk5MzcxQkI3MzBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3MjBB QzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAgKi87IH07CisJCTkzNzFCQjc1MEFD NDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3NDBBQzQ3RkM4MDBDRDRBN0IgLyogQ291 bnRlclJlc2V0Tm9kZS5oICovOyB9OworCQk5MzcxQkI3NzBBQzQ3RkQwMDBDRDRBN0IgLyogQ291 bnRlclJlc2V0Tm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA5MzcxQkI3NjBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAg Ki87IH07CisJCTkzNzFCQjc5MEFDNDdGRDcwMENENEE3QiAvKiBDb3VudGVyTm9kZS5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MUJCNzgwQUM0N0ZE NzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggKi87IH07CisJCTkzNzFCQjdCMEFDNDdGREUwMENE NEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291bnRlck5vZGUuY3Bw ICovOyB9OworCQk5MzcxQkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcxQkI3QzBB QzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi87IH07CiAJCTkzNzI1NjEwMEE2 MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliIGluIEZyYW1ld29ya3MgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM3MjU2MEYwQTYxNTY0MjAwQjA1M0I5IC8qIGxp YnNxbGl0ZTMuZHlsaWIgKi87IH07CiAJCTkzODBGNDczMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRn ZXQuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4 MEY0NzEwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgKi87IH07CiAJCTkzODBGNDc0MDlB MTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IDkzODBGNDcyMDlBMTFBQjQwMDFGREIzNCAvKiBXaWRnZXQuaCAqLzsg fTsKQEAgLTMxODMsNiArMzE5MCwxMyBAQAogCQk5MzVGQkNGMTA5QkExNDNCMDBFMjMwQjEgLyog RXhjZXB0aW9uQ29kZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGlu ZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBFeGNlcHRp b25Db2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTkzNkJERDFDMEEwMzFBRUIw MDRERjRBQiAvKiBHcmFwaGljc0NvbnRleHRDRy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBHcmFwaGljc0NvbnRleHRDRy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTkzNkREMDNBMDlDRUFDMjcwMDU2QUU4QyAvKiBSYW5nZS5pZGwgKi8gPSB7aXNh ID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUg PSB0ZXh0OyBwYXRoID0gUmFuZ2UuaWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5 MzcxQkI3MDBBQzQ3RkFFMDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gUmVuZGVyQ291bnRlci5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRlci5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVuZGVyQ291bnRlci5jcHA7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc0MEFDNDdGQzgwMENENEE3QiAv KiBDb3VudGVyUmVzZXROb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBD b3VudGVyUmVzZXROb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjc2 MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBDb3VudGVyUmVzZXROb2RlLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzgwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2Rl LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3VudGVyTm9kZS5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3QTBBQzQ3RkRFMDBDRDRBN0IgLyogQ291 bnRlck5vZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvdW50 ZXJOb2RlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3MUJCN0MwQUM0N0ZF NzAwQ0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gQ291bnRlckxpc3RJdGVtLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJ CTkzNzI1NjBGMEE2MTU2NDIwMEIwNTNCOSAvKiBsaWJzcWxpdGUzLmR5bGliICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gImNvbXBpbGVkLm1hY2gtby5k eWxpYiI7IG5hbWUgPSBsaWJzcWxpdGUzLmR5bGliOyBwYXRoID0gL3Vzci9saWIvbGlic3FsaXRl My5keWxpYjsgc291cmNlVHJlZSA9ICI8YWJzb2x1dGU+IjsgfTsKIAkJOTM4MEY0NzEwOUExMUFC NDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gV2lkZ2V0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM4MEY0NzIw OUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gV2lkZ2V0Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC03MTY2LDYgKzcx ODAsMTEgQEAKIAkJCQlCQ0VBNDgxNDA5N0Q5MzAyMDA5NEM5RTQgLyogYmlkaS5oICovLAogCQkJ CUJDRUE0ODE1MDk3RDkzMDIwMDk0QzlFNCAvKiBicmVha19saW5lcy5jcHAgKi8sCiAJCQkJQkNF QTQ4MTYwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFrX2xpbmVzLmggKi8sCisJCQkJOTM3MUJCN0Mw QUM0N0ZFNzAwQ0Q0QTdCIC8qIENvdW50ZXJMaXN0SXRlbS5oICovLAorCQkJCTkzNzFCQjdBMEFD NDdGREUwMENENEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8sCisJCQkJOTM3MUJCNzgwQUM0N0ZE NzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggKi8sCisJCQkJOTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0 QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovLAorCQkJCTkzNzFCQjc0MEFDNDdGQzgwMENE NEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi8sCiAJCQkJQkNFQTQ4MTcwOTdEOTMwMjAwOTRD OUU0IC8qIERhdGFSZWYuaCAqLywKIAkJCQlBQkU3QjUyMTBBNDg5RjgzMDAzMTg4MUMgLyogRGVw cmVjYXRlZFJlbmRlclNlbGVjdC5jcHAgKi8sCiAJCQkJQUJFN0I1MjIwQTQ4OUY4MzAwMzE4ODFD IC8qIERlcHJlY2F0ZWRSZW5kZXJTZWxlY3QuaCAqLywKQEAgLTcyMDIsNiArNzIyMSw4IEBACiAJ CQkJQkNFQTQ4MjkwOTdEOTMwMjAwOTRDOUU0IC8qIFJlbmRlclZpZXcuaCAqLywKIAkJCQlCQ0VB NDgyQzA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmNwcCAqLywKIAkJCQlCQ0VB NDgyRDA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQ29udGFpbmVyLmggKi8sCisJCQkJOTM3MUJC NzIwQUM0N0ZCODAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuY3BwICovLAorCQkJCTkzNzFCQjcw MEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi8sCiAJCQkJQThFQTczQUYwQTE5 MDBFMzAwQThFRjVGIC8qIFJlbmRlckZpZWxkc2V0LmNwcCAqLywKIAkJCQlBOEVBNzNCMDBBMTkw MEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuaCAqLywKIAkJCQkwNjZDNzcyRTBBQjYwM0ZE MDAyMzhDQzQgLyogUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuY3BwICovLApAQCAtODQ1MCw2ICs4 NDcxLDEwIEBACiAJCQkJQTg0MTVGOUUwQUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXNrZXIu aCBpbiBIZWFkZXJzICovLAogCQkJCUE4NDE1RkEwMEFDMTBDNUQwMEY3RDBERiAvKiBLQ2FudmFz TWFya2VyLmggaW4gSGVhZGVycyAqLywKIAkJCQlCQzNGQ0FBOTBBQzNEQjU4MDBCQTU0QUQgLyog UGxhdGZvcm1TY3JvbGxCYXIuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzNzFCQjcxMEFDNDdGQUUw MENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmggaW4gSGVhZGVycyAqLywKKwkJCQk5MzcxQkI3NTBB QzQ3RkM4MDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJ OTM3MUJCNzkwQUM0N0ZENzAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmggaW4gSGVhZGVycyAqLywK KwkJCQk5MzcxQkI3RDBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggaW4gSGVh ZGVycyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0g MDsKIAkJfTsKQEAgLTk1MzgsNiArOTU2Myw5IEBACiAJCQkJQTg0MTVGOUYwQUMxMEM1RDAwRjdE MERGIC8qIEtDYW52YXNNYXNrZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTg0MTVGQTEwQUMx MEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXJrZXIuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJQTg0 MTVGQTIwQUMxMEM1RDAwRjdEMERGIC8qIEtDYW52YXNGaWx0ZXJzLmNwcCBpbiBTb3VyY2VzICov LAorCQkJCTkzNzFCQjczMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNwcCBpbiBT b3VyY2VzICovLAorCQkJCTkzNzFCQjc3MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXRO b2RlLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTkzNzFCQjdCMEFDNDdGREUwMENENEE3QiAvKiBD b3VudGVyTm9kZS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95 bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKSW5kZXg6IGNzcy9DU1NDb21wdXRlZFN0eWxl RGVjbGFyYXRpb24uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFy YXRpb24uY3BwCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9DU1NDb21wdXRlZFN0eWxlRGVjbGFy YXRpb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC02MDIsMTEgKzYwMiw5IEBACiAgICAgICAgIC8v IEZJWE1FOiB1bmltcGxlbWVudGVkCiAgICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1Bf Q09VTlRFUl9JTkNSRU1FTlQ6Ci0gICAgICAgIC8vIEZJWE1FOiB1bmltcGxlbWVudGVkCi0gICAg ICAgIGJyZWFrOworICAgICAgICByZXR1cm4gc3R5bGUtPmNvdW50ZXJJbmNyZW1lbnRWYWx1ZUxp c3QoKTsKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVTRVQ6Ci0gICAgICAgIC8vIEZJWE1F OiB1bmltcGxlbWVudGVkCi0gICAgICAgIGJyZWFrOworICAgICAgICByZXR1cm4gc3R5bGUtPmNv dW50ZXJSZXNldFZhbHVlTGlzdCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ1VSU09SOgogICAgICAg ICBpZiAoc3R5bGUtPmN1cnNvckltYWdlKCkpCiAgICAgICAgICAgICByZXR1cm4gbmV3IENTU1By aW1pdGl2ZVZhbHVlKHN0eWxlLT5jdXJzb3JJbWFnZSgpLT51cmwoKSwgQ1NTUHJpbWl0aXZlVmFs dWU6OkNTU19VUkkpOwpJbmRleDogY3NzL2Nzc3BhcnNlci5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGNzcy9j c3NwYXJzZXIuaAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3NzcGFyc2VyLmgJKHdvcmtpbmcg Y29weSkKQEAgLTEyMCw3ICsxMjAsNyBAQAogCiAgICAgICAgIERvY3VtZW50KiBkb2N1bWVudCgp IGNvbnN0OwogCi0gICAgICAgIHZvaWQgYWRkUHJvcGVydHkoaW50IHByb3BJZCwgQ1NTVmFsdWUq LCBib29sIGltcG9ydGFudCk7CisgICAgICAgIHZvaWQgYWRkUHJvcGVydHkoaW50IHByb3BJZCwg UGFzc1JlZlB0cjxDU1NWYWx1ZT4sIGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgdm9pZCByb2xs YmFja0xhc3RQcm9wZXJ0aWVzKGludCBudW0pOwogICAgICAgICBib29sIGhhc1Byb3BlcnRpZXMo KSBjb25zdCB7IHJldHVybiBudW1QYXJzZWRQcm9wZXJ0aWVzID4gMDsgfQogCkBAIC0xNDYsMTEg KzE0NiwxMyBAQAogCiAgICAgICAgIGJvb2wgcGFyc2VTaGFwZShpbnQgcHJvcElkLCBib29sIGlt cG9ydGFudCk7CiAgICAgICAgIGJvb2wgcGFyc2VGb250KGJvb2wgaW1wb3J0YW50KTsKKyAgICAg ICAgYm9vbCBwYXJzZUNvdW50ZXIoaW50IHByb3BJZCwgaW50IGRlZmF1bHRWYWx1ZSwgYm9vbCBp bXBvcnRhbnQpOwogICAgICAgICBDU1NWYWx1ZUxpc3QqIHBhcnNlRm9udEZhbWlseSgpOwogICAg ICAgICBib29sIHBhcnNlQ29sb3JQYXJhbWV0ZXJzKFZhbHVlKiwgaW50KiBjb2xvclZhbHVlcywg Ym9vbCBwYXJzZUFscGhhKTsKICAgICAgICAgYm9vbCBwYXJzZUhTTFBhcmFtZXRlcnMoVmFsdWUq LCBkb3VibGUqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBDU1NQcmlt aXRpdmVWYWx1ZSogcGFyc2VDb2xvcigpOwogICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcGFy c2VDb2xvckZyb21WYWx1ZShWYWx1ZSopOworICAgICAgICBQYXNzUmVmUHRyPENTU1ZhbHVlPiBw YXJzZUNvdW50ZXJDb250ZW50KFZhbHVlTGlzdCogYXJncywgYm9vbCBjb3VudGVycyk7CiAgICAg ICAgIAogI2lmZGVmIFNWR19TVVBQT1JUCiAgICAgICAgIGJvb2wgcGFyc2VTVkdWYWx1ZShpbnQg cHJvcElkLCBib29sIGltcG9ydGFudCk7CkluZGV4OiBjc3MvY3Nzc3R5bGVzZWxlY3Rvci5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCShyZXZpc2lvbiAxNjUyOCkK KysrIGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMzcsNiArMzcs NyBAQAogI2luY2x1ZGUgIkNTU1N0eWxlU2hlZXQuaCIKICNpbmNsdWRlICJDU1NWYWx1ZUtleXdv cmRzLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWVMaXN0LmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgog I2luY2x1ZGUgIkNhY2hlZEltYWdlLmgiCiAjaW5jbHVkZSAiRGFzaGJvYXJkUmVnaW9uLmgiCiAj aW5jbHVkZSAiRm9udEZhbWlseVZhbHVlLmgiCkBAIC0zMTQ4LDcgKzMxNDksOSBAQAogCiAgICAg ICAgIGZvciAoaW50IGkgPSAwOyBpIDwgbGVuOyBpKyspIHsKICAgICAgICAgICAgIENTU1ZhbHVl ICppdGVtID0gbGlzdC0+aXRlbShpKTsKLSAgICAgICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRp dmVWYWx1ZSgpKSBjb250aW51ZTsKKyAgICAgICAgICAgIGlmICghaXRlbS0+aXNQcmltaXRpdmVW YWx1ZSgpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgCiAgICAgICAg ICAgICBDU1NQcmltaXRpdmVWYWx1ZSAqdmFsID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFs dWUqPihpdGVtKTsKICAgICAgICAgICAgIGlmICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJp bWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpCiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRl bnQodmFsLT5nZXRTdHJpbmdWYWx1ZSgpLmltcGwoKSwgaSAhPSAwKTsKQEAgLTMxNjIsMTkgKzMx NjUsMjggQEAKICAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudChlbGVtZW50LT5nZXRB dHRyaWJ1dGUoYXR0cikuaW1wbCgpLCBpICE9IDApOwogICAgICAgICAgICAgICAgIC8vIHJlZ2lz dGVyIHRoZSBmYWN0IHRoYXQgdGhlIGF0dHJpYnV0ZSB2YWx1ZSBhZmZlY3RzIHRoZSBzdHlsZQog ICAgICAgICAgICAgICAgIG1fc2VsZWN0b3JBdHRycy5hZGQoYXR0ci5sb2NhbE5hbWUoKS5pbXBs KCkpOwotICAgICAgICAgICAgfQotICAgICAgICAgICAgZWxzZSBpZiAodmFsLT5wcmltaXRpdmVU eXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfVVJJKSB7CisgICAgICAgICAgICB9IGVsc2Ug aWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgewog ICAgICAgICAgICAgICAgIENTU0ltYWdlVmFsdWUgKmltYWdlID0gc3RhdGljX2Nhc3Q8Q1NTSW1h Z2VWYWx1ZSo+KHZhbCk7CiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoaW1hZ2Ut PmltYWdlKGVsZW1lbnQtPmRvY3VtZW50KCktPmRvY0xvYWRlcigpKSwgaSAhPSAwKTsKLSAgICAg ICAgICAgIH0KKyAgICAgICAgICAgIH0gZWxzZSBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNT U1ByaW1pdGl2ZVZhbHVlOjpDU1NfQ09VTlRFUikgeworICAgICAgICAgICAgICAgIENvdW50ZXIq IGNvdW50ZXJWYWx1ZSA9IHZhbC0+Z2V0Q291bnRlclZhbHVlKCk7CisgICAgICAgICAgICAgICAg Q291bnRlckRhdGEgY291bnRlcihjb3VudGVyVmFsdWUtPmlkZW50aWZpZXIoKSwKKyAgICAgICAg ICAgICAgICAgICAgKEVMaXN0U3R5bGVUeXBlKWNvdW50ZXJWYWx1ZS0+bGlzdFN0eWxlTnVtYmVy KCksIGNvdW50ZXJWYWx1ZS0+c2VwYXJhdG9yKCkpOworICAgICAgICAgICAgICAgIHN0eWxlLT5z ZXRDb250ZW50KG5ldyBDb3VudGVyRGF0YShjb3VudGVyKSwgaSAhPSAwKTsKKyAgICAgICAgICAg fQogICAgICAgICB9CiAgICAgICAgIGJyZWFrOwogICAgIH0KIAogICAgIGNhc2UgQ1NTX1BST1Bf Q09VTlRFUl9JTkNSRU1FTlQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJJbmNyZW1l bnQKKyAgICAgICAgaWYgKCF2YWx1ZS0+aXNWYWx1ZUxpc3QoKSkKKyAgICAgICAgICAgIHJldHVy bjsKKyAgICAgICAgc3R5bGUtPnNldENvdW50ZXJJbmNyZW1lbnRMaXN0KHN0YXRpY19jYXN0PENT U1ZhbHVlTGlzdCo+KHZhbHVlKSk7CisgICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1Bf Q09VTlRFUl9SRVNFVDoKLSAgICAgICAgLy8gbGlzdCBvZiBDU1MyQ291bnRlclJlc2V0CisgICAg ICAgIGlmICghdmFsdWUtPmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIHN0eWxlLT5zZXRDb3VudGVyUmVzZXRMaXN0KHN0YXRpY19jYXN0PENTU1ZhbHVlTGlzdCo+ KHZhbHVlKSk7CiAgICAgICAgIGJyZWFrOwogICAgIGNhc2UgQ1NTX1BST1BfRk9OVF9GQU1JTFk6 IHsKICAgICAgICAgLy8gbGlzdCBvZiBzdHJpbmdzIGFuZCBpZHMKSW5kZXg6IGNzcy9DU1NQcmlt aXRpdmVWYWx1ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAko cmV2aXNpb24gMTY1MjgpCisrKyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC01MjQsNyArNTI0LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAgICAgICAgICAg IGJyZWFrOwogICAgICAgICBjYXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAgLy8gIyMjCisg ICAgICAgICAgICB0ZXh0ID0gImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQgKz0gU3RyaW5n OjpudW1iZXIobV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7CisgICAgICAg ICAgICAvLyBGSVhNRTogQWRkIGxpc3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAgICAgICAgICAg YnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJlY3RJbXBsKiBy ZWN0VmFsID0gZ2V0UmVjdFZhbHVlKCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGNzcy9Db3VudGVyLmgJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL0NvdW50ZXIuaAkod29y a2luZyBjb3B5KQpAQCAtMjMsMjMgKzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJfSAogI2RlZmlu ZSBDb3VudGVyX0gKIAorI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVkZSAi UGxhdGZvcm1TdHJpbmcuaCIKICNpbmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRlICJQbGF0Zm9y bVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAogY2xhc3MgQ291bnRlciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4gewogcHVibGlj OgotICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVyOyB9 Ci0gICAgU3RyaW5nIGxpc3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9Ci0g ICAgU3RyaW5nIHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisgICAg Q291bnRlcigpIDogbV9pZGVudGlmaWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9zZXBhcmF0b3Io MCkgeyB9CisgICAgQ291bnRlcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVudGlm aWVyLCBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisgICAgICAgIFBh c3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAgOiBtX2lkZW50 aWZpZXIoaWRlbnRpZmllciksIG1fbGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2VwYXJhdG9yKHNl cGFyYXRvcikgeyB9CisgICAgfkNvdW50ZXIoKSB7IH0KIAotcHJpdmF0ZToKLSAgICBTdHJpbmcg bV9pZGVudGlmaWVyOwotICAgIFN0cmluZyBtX2xpc3RTdHlsZTsKLSAgICBTdHJpbmcgbV9zZXBh cmF0b3I7Ci19OworICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVu dGlmaWVyID8gbV9pZGVudGlmaWVyLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0KKyAg ICBTdHJpbmcgbGlzdFN0eWxlKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUgPyBtX2xpc3RT dHlsZS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5nIHNlcGFyYXRv cigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yID8gbV9zZXBhcmF0b3ItPmdldFN0cmluZ1Zh bHVlKCkgOiBTdHJpbmcoKTsgfQogCi19IC8vIG5hbWVzcGFjZQorICAgIGludCBsaXN0U3R5bGVO dW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZSA/IChpbnQpIG1fbGlzdFN0eWxlLT5n ZXRGbG9hdFZhbHVlKCkgOiAwOyB9CisgICAgCisgICAgdm9pZCBzZXRJZGVudGlmaWVyKFBhc3NS ZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGlkZW50aWZpZXIpIHsgbV9pZGVudGlmaWVyID0gaWRl bnRpZmllcjsgfQorICAgIHZvaWQgc2V0TGlzdFN0eWxlKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZl VmFsdWU+IGxpc3RTdHlsZSkgeyBtX2xpc3RTdHlsZSA9IGxpc3RTdHlsZTsgfQorICAgIHZvaWQg c2V0U2VwYXJhdG9yKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikgeyBt X3NlcGFyYXRvciA9IHNlcGFyYXRvcjsgfQorIAorcHJvdGVjdGVkOgorICAgIFJlZlB0cjxDU1NQ cmltaXRpdmVWYWx1ZT4gbV9pZGVudGlmaWVyOyAvLyBTdHJpbmcKKyAgICBSZWZQdHI8Q1NTUHJp bWl0aXZlVmFsdWU+IG1fbGlzdFN0eWxlOyAgLy8gaW50CisgICAgUmVmUHRyPENTU1ByaW1pdGl2 ZVZhbHVlPiBtX3NlcGFyYXRvcjsgIC8vIFN0cmluZworIH07CiAKK30gLy9uYW1lc3BhY2UKKwog I2VuZGlmCkluZGV4OiBjc3MvY3NzcGFyc2VyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3NzcGFy c2VyLmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBjc3MvY3NzcGFyc2VyLmNwcAkod29ya2luZyBj b3B5KQpAQCAtNDIsNiArNDIsNyBAQAogI2luY2x1ZGUgIkNTU1F1aXJrUHJpbWl0aXZlVmFsdWUu aCIKICNpbmNsdWRlICJDU1NWYWx1ZUtleXdvcmRzLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWVMaXN0 LmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgogI2luY2x1ZGUgIkRhc2hib2FyZFJlZ2lvbi5oIgog I2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRm9udEZhbWlseVZhbHVlLmgiCkBAIC0z MzQsNyArMzM1LDcgQEAKIH0KIAogCi12b2lkIENTU1BhcnNlcjo6YWRkUHJvcGVydHkoaW50IHBy b3BJZCwgQ1NTVmFsdWUgKnZhbHVlLCBib29sIGltcG9ydGFudCkKK3ZvaWQgQ1NTUGFyc2VyOjph ZGRQcm9wZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiB2YWx1ZSwgYm9vbCBp bXBvcnRhbnQpCiB7CiAgICAgQ1NTUHJvcGVydHkgKnByb3AgPSBuZXcgQ1NTUHJvcGVydHkocHJv cElkLCB2YWx1ZSwgaW1wb3J0YW50LCBtX2N1cnJlbnRTaG9ydGhhbmQsIG1faW1wbGljaXRTaG9y dGhhbmQpOwogICAgIGlmIChudW1QYXJzZWRQcm9wZXJ0aWVzID49IG1heFBhcnNlZFByb3BlcnRp ZXMpIHsKQEAgLTg3MCw2ICs4NzEsMTYgQEAKICAgICAgICAgZWxzZQogICAgICAgICAgICAgdmFs aWRfcHJpbWl0aXZlID0gKCFpZCAmJiB2YWxpZFVuaXQodmFsdWUsIEZOdW1iZXJ8Rkxlbmd0aHxG UGVyY2VudCwgc3RyaWN0KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgQ1NTX1BST1BfQ09V TlRFUl9JTkNSRU1FTlQ6ICAgIC8vIFsgPGlkZW50aWZpZXI+IDxpbnRlZ2VyPj8gXSsgfCBub25l IHwgaW5oZXJpdAorICAgICAgICBpZiAoaWQgIT0gQ1NTX1ZBTF9OT05FKQorICAgICAgICAgICAg cmV0dXJuIHBhcnNlQ291bnRlcihwcm9wSWQsIDEsIGltcG9ydGFudCk7CisgICAgICAgIHZhbGlk X3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGJyZWFrOworICAgICBjYXNlIENTU19QUk9QX0NP VU5URVJfUkVTRVQ6ICAgICAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwgbm9u ZSB8IGluaGVyaXQKKyAgICAgICAgaWYgKGlkICE9IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAg IHJldHVybiBwYXJzZUNvdW50ZXIocHJvcElkLCAwLCBpbXBvcnRhbnQpOworICAgICAgICB2YWxp ZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0ZP TlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5 PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5Pl0gfCBpbmhlcml0CiAgICAg ewpAQCAtMTUyMywyOCArMTUzNCwzOCBAQAogLy8gWyA8c3RyaW5nPiB8IGF0dHIoWCkgfCBvcGVu LXF1b3RlIHwgY2xvc2UtcXVvdGUgfCBuby1vcGVuLXF1b3RlIHwgbm8tY2xvc2UtcXVvdGUgXSsg fCBpbmhlcml0CiBib29sIENTU1BhcnNlcjo6cGFyc2VDb250ZW50KGludCBwcm9wSWQsIGJvb2wg aW1wb3J0YW50KQogewotICAgIENTU1ZhbHVlTGlzdCogdmFsdWVzID0gbmV3IENTU1ZhbHVlTGlz dDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiB2YWx1ZXMgPSBuZXcgQ1NTVmFsdWVMaXN0Owor ICAgIFJlZlB0cjxDU1NWYWx1ZT4gcGFyc2VkVmFsdWU7CiAKICAgICB3aGlsZSAoVmFsdWUqIHZh bCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpKSB7Ci0gICAgICAgIENTU1ZhbHVlKiBwYXJzZWRWYWx1 ZSA9IDA7CiAgICAgICAgIGlmICh2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19V UkkpIHsKICAgICAgICAgICAgIC8vIHVybAogICAgICAgICAgICAgU3RyaW5nIHZhbHVlID0gcGFy c2VVUkwoZG9tU3RyaW5nKHZhbC0+c3RyaW5nKSk7CiAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9 IG5ldyBDU1NJbWFnZVZhbHVlKAogICAgICAgICAgICAgICAgIFN0cmluZyhLVVJMKHN0eWxlRWxl bWVudC0+YmFzZVVSTCgpLmRlcHJlY2F0ZWRTdHJpbmcoKSwgdmFsdWUuZGVwcmVjYXRlZFN0cmlu ZygpKS51cmwoKSksIHN0eWxlRWxlbWVudCk7CiAgICAgICAgIH0gZWxzZSBpZiAodmFsLT51bml0 ID09IFZhbHVlOjpGdW5jdGlvbikgewotICAgICAgICAgICAgLy8gYXR0cihYKQorICAgICAgICAg ICAgLy8gYXR0cihYKSB8IGNvdW50ZXIoWCBbLFldKSB8IGNvdW50ZXJzKFgsIFksIFssWl0pCiAg ICAgICAgICAgICBWYWx1ZUxpc3QgKmFyZ3MgPSB2YWwtPmZ1bmN0aW9uLT5hcmdzOwogICAgICAg ICAgICAgU3RyaW5nIGZuYW1lID0gZG9tU3RyaW5nKHZhbC0+ZnVuY3Rpb24tPm5hbWUpLmxvd2Vy KCk7Ci0gICAgICAgICAgICBpZiAoZm5hbWUgIT0gImF0dHIoIiB8fCAhYXJncykKKyAgICAgICAg ICAgIGlmICghYXJncykKICAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgICAg ICBpZiAoYXJncy0+c2l6ZSgpICE9IDEpCisgICAgICAgICAgICBpZiAoZm5hbWUgPT0gImF0dHIo IikgeworICAgICAgICAgICAgICAgIGlmIChhcmdzLT5zaXplKCkgIT0gMSkKKyAgICAgICAgICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgICAgIFZhbHVlKiBhID0gYXJncy0+ Y3VycmVudCgpOworICAgICAgICAgICAgICAgIFN0cmluZyBhdHRyTmFtZSA9IGRvbVN0cmluZyhh LT5zdHJpbmcpOworICAgICAgICAgICAgICAgIGlmIChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVu dCgpKQorICAgICAgICAgICAgICAgICAgICBhdHRyTmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7Cisg ICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoYXR0ck5h bWUsIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfQVRUUik7CisgICAgICAgICAgICB9IGVsc2UgaWYg KGZuYW1lID09ICJjb3VudGVyKCIpIHsKKyAgICAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IHBh cnNlQ291bnRlckNvbnRlbnQoYXJncywgZmFsc2UpOworICAgICAgICAgICAgICAgIGlmICghcGFy c2VkVmFsdWUpIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIH0gZWxzZSBpZiAoZm5hbWUgPT0g ImNvdW50ZXJzKCIpIHsKKyAgICAgICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IHBhcnNlQ291bnRl ckNvbnRlbnQoYXJncywgdHJ1ZSk7CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkK KyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgfSBlbHNlCiAg ICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAgICAgVmFsdWUgKmEgPSBhcmdz LT5jdXJyZW50KCk7Ci0gICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUgPSBkb21TdHJpbmcoYS0+ c3RyaW5nKTsKLSAgICAgICAgICAgIGlmIChkb2N1bWVudCgpLT5pc0hUTUxEb2N1bWVudCgpKQot ICAgICAgICAgICAgICAgIGF0dHJOYW1lID0gYXR0ck5hbWUubG93ZXIoKTsKLSAgICAgICAgICAg IHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRp dmVWYWx1ZTo6Q1NTX0FUVFIpOwogICAgICAgICB9IGVsc2UgaWYgKHZhbC0+dW5pdCA9PSBDU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKSB7CiAgICAgICAgICAgICAvLyBvcGVuLXF1b3RlCiAg ICAgICAgICAgICAvLyBjbG9zZS1xdW90ZQpAQCAtMTU2Niw3ICsxNTg3LDYgQEAKICAgICAgICAg cmV0dXJuIHRydWU7CiAgICAgfQogCi0gICAgZGVsZXRlIHZhbHVlczsKICAgICByZXR1cm4gZmFs c2U7CiB9CiAKQEAgLTE5NzgsNiArMTk5OCw1OSBAQAogfQogI2VuZGlmCiAKK1Bhc3NSZWZQdHI8 Q1NTVmFsdWU+IENTU1BhcnNlcjo6cGFyc2VDb3VudGVyQ29udGVudChWYWx1ZUxpc3QgKmFyZ3Ms IGJvb2wgY291bnRlcnMpCit7CisgICAgdW5zaWduZWQgbnVtQXJncyA9IGFyZ3MtPnNpemUoKTsK KyAgICBpZiAoY291bnRlcnMgJiYgbnVtQXJncyAhPSAzICYmIG51bUFyZ3MgIT0gNSkKKyAgICAg ICAgcmV0dXJuIDA7CisgICAgaWYgKCFjb3VudGVycyAmJiBudW1BcmdzICE9IDEgJiYgbnVtQXJn cyAhPSAzKQorICAgICAgICByZXR1cm4gMDsKKyAgICAKKyAgICBWYWx1ZSAqaSA9IGFyZ3MtPmN1 cnJlbnQoKTsKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGlkZW50aWZpZXIgPSBuZXcg Q1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5nKGktPnN0cmluZyksCisgICAgICAgIENTU1ByaW1p dGl2ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4g c2VwYXJhdG9yOworICAgIGlmICghY291bnRlcnMpCisgICAgICAgIHNlcGFyYXRvciA9IG5ldyBD U1NQcmltaXRpdmVWYWx1ZShTdHJpbmcoKSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcp OworICAgIGVsc2UgeworICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+ dW5pdCAhPSBWYWx1ZTo6T3BlcmF0b3IgfHwgaS0+aVZhbHVlICE9ICcsJykKKyAgICAgICAgICAg IHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICAgICAg aWYgKGktPnVuaXQgIT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIHNlcGFyYXRvciA9IG5ldyBDU1NQcmltaXRp dmVWYWx1ZShkb21TdHJpbmcoaS0+c3RyaW5nKSwgKENTU1ByaW1pdGl2ZVZhbHVlOjpVbml0VHlw ZXMpIGktPnVuaXQpOworICAgIH0KKworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbGlz dFN0eWxlOworICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgaWYgKCFpKSAvLyBNYWtlIHRoZSBs aXN0IHN0eWxlIGRlZmF1bHQgZGVjaW1hbAorICAgICAgICBsaXN0U3R5bGUgPSBuZXcgQ1NTUHJp bWl0aXZlVmFsdWUoQ1NTX1ZBTF9ERUNJTUFMIC0gQ1NTX1ZBTF9ESVNDLCBDU1NQcmltaXRpdmVW YWx1ZTo6Q1NTX05VTUJFUik7CisgICAgZWxzZSB7CisgICAgICAgIGlmIChpLT51bml0ICE9IFZh bHVlOjpPcGVyYXRvciB8fCBpLT5pVmFsdWUgIT0gJywnKQorICAgICAgICAgICAgcmV0dXJuIDA7 CisgICAgICAgIAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBpZiAoaS0+dW5p dCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKQorICAgICAgICAgICAgcmV0dXJuIDA7 CisgICAgICAgIAorICAgICAgICBzaG9ydCBscyA9IDA7CisgICAgICAgIGlmIChpLT5pZCA9PSBD U1NfVkFMX05PTkUpCisgICAgICAgICAgICBscyA9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEgLSBD U1NfVkFMX0RJU0MgKyAxOworICAgICAgICBlbHNlIGlmIChpLT5pZCA+PSBDU1NfVkFMX0RJU0Mg JiYgaS0+aWQgPD0gQ1NTX1ZBTF9LQVRBS0FOQV9JUk9IQSkKKyAgICAgICAgICAgIGxzID0gaS0+ aWQgLSBDU1NfVkFMX0RJU0M7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJldHVybiAwOwor CisgICAgICAgIGxpc3RTdHlsZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShscywgKENTU1ByaW1p dGl2ZVZhbHVlOjpVbml0VHlwZXMpIGktPnVuaXQpOworICAgIH0KKworICAgIHJldHVybiBuZXcg Q1NTUHJpbWl0aXZlVmFsdWUobmV3IENvdW50ZXIoaWRlbnRpZmllci5yZWxlYXNlKCksIGxpc3RT dHlsZS5yZWxlYXNlKCksIHNlcGFyYXRvci5yZWxlYXNlKCkpKTsKK30KKwogYm9vbCBDU1NQYXJz ZXI6OnBhcnNlU2hhcGUoaW50IHByb3BJZCwgYm9vbCBpbXBvcnRhbnQpCiB7CiAgICAgVmFsdWUg KnZhbHVlID0gdmFsdWVMaXN0LT5jdXJyZW50KCk7CkBAIC0yNjc2LDYgKzI3NDksNDggQEAKICAg ICByZXR1cm4gY29udGV4dC5mYWlsZWQoKTsKIH0KIAorYm9vbCBDU1NQYXJzZXI6OnBhcnNlQ291 bnRlcihpbnQgcHJvcElkLCBpbnQgZGVmYXVsdFZhbHVlLCBib29sIGltcG9ydGFudCkKK3sKKyAg ICBlbnVtIHsgSUQsIFZBTCB9IHN0YXRlID0gSUQ7CisKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0 PiBsaXN0ID0gbmV3IENTU1ZhbHVlTGlzdDsKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+ IGNvdW50ZXJOYW1lOworICAgIAorICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgIFZhbHVlKiB2 YWwgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKTsKKyAgICAgICAgc3dpdGNoIChzdGF0ZSkgeworICAg ICAgICAgICAgY2FzZSBJRDoKKyAgICAgICAgICAgICAgICBpZiAodmFsICYmIHZhbC0+dW5pdCA9 PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0lERU5UKSB7CisgICAgICAgICAgICAgICAgICAgIGNv dW50ZXJOYW1lID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyh2YWwtPnN0cmluZyks IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKyAgICAgICAgICAgICAgICAgICAgc3Rh dGUgPSBWQUw7CisgICAgICAgICAgICAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOworICAgICAg ICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgICAgICBjYXNlIFZBTDogeworICAgICAgICAgICAgICAgIGludCBp ID0gZGVmYXVsdFZhbHVlOworICAgICAgICAgICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09 IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKSB7CisgICAgICAgICAgICAgICAgICAgIGkg PSAoaW50KXZhbC0+ZlZhbHVlOworICAgICAgICAgICAgICAgICAgICB2YWx1ZUxpc3QtPm5leHQo KTsKKyAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICBsaXN0LT5hcHBlbmQobmV3 IENTU1ByaW1pdGl2ZVZhbHVlKG5ldyBQYWlyKGNvdW50ZXJOYW1lLnJlbGVhc2UoKSwKKyAgICAg ICAgICAgICAgICAgICAgbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGksIENTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfTlVNQkVSKSkpKTsKKyAgICAgICAgICAgICAgICBzdGF0ZSA9IElEOworICAgICAgICAg ICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIGJyZWFr OworICAgIH0KKyAgICAKKyAgICBpZiAobGlzdC0+bGVuZ3RoKCkgPiAwKSB7CisgICAgICAgIGFk ZFByb3BlcnR5KHByb3BJZCwgbGlzdC5yZWxlYXNlKCksIGltcG9ydGFudCk7CisgICAgICAgIHJl dHVybiB0cnVlOworICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKwogI2lmZGVmIENTU19E RUJVRwogCiBzdGF0aWMgaW5saW5lIGludCB5eWVycm9yKGNvbnN0IGNoYXIgKnN0cikK 10857 2006-10-01 16:07:19 -0700 2006-10-02 11:59:03 -0700 Most newest...est sunday.txt text/plain 72896 bdakin SW5kZXg6IHBsYXRmb3JtL1N0cmluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vU3RyaW5n LmNwcAkocmV2aXNpb24gMTY1MjgpCisrKyBwbGF0Zm9ybS9TdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xNTcsNiArMTU3LDE0IEBACiAgICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ci5tX2lt cGwuZ2V0KCksIHBvcyk7CiB9CiAKK3ZvaWQgU3RyaW5nOjppbnNlcnQoY29uc3QgVUNoYXIqIHN0 ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpCit7CisgICAgaWYgKCFtX2ltcGwpCisg ICAgICAgIG1faW1wbCA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICBlbHNlCisg ICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ciwgbGVuZ3RoLCBwb3MpOworfQorCiBVQ2hhciBTdHJp bmc6Om9wZXJhdG9yW10odW5zaWduZWQgaSkgY29uc3QKIHsKICAgICBpZiAoIW1faW1wbCB8fCBp ID49IG1faW1wbC0+bGVuZ3RoKCkpCkluZGV4OiBwbGF0Zm9ybS9QbGF0Zm9ybVN0cmluZy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHBsYXRmb3JtL1BsYXRmb3JtU3RyaW5nLmgJKHJldmlzaW9uIDE2NTI4KQor KysgcGxhdGZvcm0vUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5KQpAQCAtOTAsNiArOTAs NyBAQAogICAgIHZvaWQgYXBwZW5kKGNoYXIpOwogICAgIHZvaWQgYXBwZW5kKFVDaGFyKTsKICAg ICB2b2lkIGluc2VydChjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBwb3MpOworICAgIHZvaWQgaW5z ZXJ0KGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpOwogCiAgICAg U3RyaW5nJiByZXBsYWNlKFVDaGFyIGEsIFVDaGFyIGIpIHsgaWYgKG1faW1wbCkgbV9pbXBsID0g bV9pbXBsLT5yZXBsYWNlKGEsIGIpOyByZXR1cm4gKnRoaXM7IH0KICAgICBTdHJpbmcmIHJlcGxh Y2UoVUNoYXIgYSwgY29uc3QgU3RyaW5nJiBiKSB7IGlmIChtX2ltcGwpIG1faW1wbCA9IG1faW1w bC0+cmVwbGFjZShhLCBiLmltcGwoKSk7IHJldHVybiAqdGhpczsgfQpJbmRleDogcGxhdGZvcm0v U3RyaW5nSW1wbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuaAkocmV2aXNp b24gMTY1MjgpCisrKyBwbGF0Zm9ybS9TdHJpbmdJbXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTgw LDYgKzgwLDcgQEAKICAgICB2b2lkIGFwcGVuZChjaGFyKTsKICAgICB2b2lkIGFwcGVuZChVQ2hh cik7CiAgICAgdm9pZCBpbnNlcnQoY29uc3QgU3RyaW5nSW1wbCosIHVuc2lnbmVkIHBvcyk7Cisg ICAgdm9pZCBpbnNlcnQoY29uc3QgVUNoYXIqIHN0ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBwb3MpOwogICAgIHZvaWQgdHJ1bmNhdGUoaW50IGxlbik7CiAgICAgdm9pZCByZW1vdmUodW5z aWduZWQgcG9zLCBpbnQgbGVuID0gMSk7CiAKSW5kZXg6IHBsYXRmb3JtL1N0cmluZ0ltcGwuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCShyZXZpc2lvbiAxNjUyOCkK KysrIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xOTcsNiArMTk3 LDI2IEBACiAgICAgfQogfQogCit2b2lkIFN0cmluZ0ltcGw6Omluc2VydChjb25zdCBVQ2hhciog c3RyLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIHBvcykKK3sKKyAgICBhc3NlcnQoIW1faW5U YWJsZSk7CisgICAgaWYgKHBvcyA+PSBtX2xlbmd0aCkgeworICAgICAgICBhcHBlbmQobmV3IFN0 cmluZ0ltcGwoc3RyLCBsZW5ndGgpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBpZiAo c3RyICYmIGxlbmd0aCAhPSAwKSB7CisgICAgICAgIHNpemVfdCBuZXdsZW4gPSBtX2xlbmd0aCAr IGxlbmd0aDsKKyAgICAgICAgVUNoYXIqIGMgPSBuZXdVQ2hhclZlY3RvcihuZXdsZW4pOworICAg ICAgICBtZW1jcHkoYywgbV9kYXRhLCBwb3MgKiBzaXplb2YoVUNoYXIpKTsKKyAgICAgICAgbWVt Y3B5KGMgKyBwb3MsIHN0ciwgbGVuZ3RoICogc2l6ZW9mKFVDaGFyKSk7CisgICAgICAgIG1lbWNw eShjICsgcG9zICsgbGVuZ3RoLCBtX2RhdGEgKyBwb3MsIChtX2xlbmd0aCAtIHBvcykgKiBzaXpl b2YoVUNoYXIpKTsKKyAgICAgICAgZGVsZXRlVUNoYXJWZWN0b3IobV9kYXRhKTsKKyAgICAgICAg bV9kYXRhID0gYzsKKyAgICAgICAgbV9sZW5ndGggPSBuZXdsZW47CisgICAgICAgIG1faGFzVGVy bWluYXRpbmdOdWxsQ2hhcmFjdGVyID0gZmFsc2U7CisgICAgfQorfQorCiB2b2lkIFN0cmluZ0lt cGw6OnRydW5jYXRlKGludCBsZW4pCiB7CiAgICAgYXNzZXJ0KCFtX2luVGFibGUpOwpJbmRleDog cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRl ck9iamVjdC5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysgcmVuZGVyaW5nL1JlbmRlck9iamVjdC5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTQsNiArNCw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkg TGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBL b2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBEaXJrIE11 ZWxsZXIgKG11ZWxsZXJAa2RlLm9yZykKKyAqICAgICAgICAgICAoQykgMjAwNCBBbGxhbiBTYW5k ZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDQsIDIw MDUsIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0yOSw2ICszMCw4 IEBACiAjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIiAKICNpbmNsdWRlICJBZmZpbmVUcmFuc2Zv cm0uaCIKICNpbmNsdWRlICJDYWNoZWRJbWFnZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgi CisjaW5jbHVkZSAiQ291bnRlclJlc2V0Tm9kZS5oIgogI2luY2x1ZGUgIkRlY29kZXIuaCIKICNp bmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkVsZW1lbnQuaCIKQEAgLTM3LDYgKzQwLDcg QEAKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2lu Y2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxPTGlzdEVsZW1lbnQuaCIKICNpbmNs dWRlICJQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlJlbmRlckFyZW5hLmgiCiAjaW5jbHVkZSAiUmVu ZGVyRmxleGlibGVCb3guaCIKQEAgLTY1LDYgKzY5LDE1IEBACiBzdGF0aWMgdm9pZCAqYmFzZU9m UmVuZGVyT2JqZWN0QmVpbmdEZWxldGVkOwogI2VuZGlmCiAKK3R5cGVkZWYgSGFzaE1hcDxTdHJp bmcsIENvdW50ZXJOb2RlKj4gQ291bnRlck5vZGVNYXA7Cit0eXBlZGVmIEhhc2hNYXA8Y29uc3Qg UmVuZGVyT2JqZWN0KiwgQ291bnRlck5vZGVNYXAqPiBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9k ZU1hcHM7CisKK3N0YXRpYyBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMqIGdldFJlbmRl ck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcygpCit7CisgICAgc3RhdGljIFJlbmRlck9iamVjdHNU b0NvdW50ZXJOb2RlTWFwcyBvYmplY3RzTWFwOworICAgIHJldHVybiAmb2JqZWN0c01hcDsKK30K Kwogdm9pZCogUmVuZGVyT2JqZWN0OjpvcGVyYXRvciBuZXcoc2l6ZV90IHN6LCBSZW5kZXJBcmVu YSogcmVuZGVyQXJlbmEpIHRocm93KCkKIHsKICAgICByZXR1cm4gcmVuZGVyQXJlbmEtPmFsbG9j YXRlKHN6KTsKQEAgLTE3Nyw3ICsxOTAsOCBAQAogCiBtX3JlcGxhY2VkKCBmYWxzZSApLAogbV9p c0RyYWdnaW5nKCBmYWxzZSApLAotbV9oYXNPdmVyZmxvd0NsaXAoZmFsc2UpCittX2hhc092ZXJm bG93Q2xpcChmYWxzZSksCittX2hhc0NvdW50ZXJOb2RlTWFwKGZhbHNlKQogewogI2lmbmRlZiBO REVCVUcKICAgICArK1JlbmRlck9iamVjdENvdW50ZXI6OmNvdW50OwpAQCAtMjM5NSw2ICsyNDA5 LDIxIEBACiAKIHZvaWQgUmVuZGVyT2JqZWN0OjpkZXN0cm95KCkKIHsKKyAgICBpZiAobV9oYXND b3VudGVyTm9kZU1hcCkgeworICAgICAgICBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMq IG9iamVjdHNNYXAgPSBnZXRSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMoKTsKKyAgICAg ICAgaWYgKENvdW50ZXJOb2RlTWFwKiBjb3VudGVyTm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQo dGhpcykpIHsKKyAgICAgICAgICAgIENvdW50ZXJOb2RlTWFwOjpjb25zdF9pdGVyYXRvciBlbmQg PSBjb3VudGVyTm9kZXNNYXAtPmVuZCgpOworICAgICAgICAgICAgZm9yIChDb3VudGVyTm9kZU1h cDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBjb3VudGVyTm9kZXNNYXAtPmJlZ2luKCk7IGl0ICE9IGVu ZDsgKytpdCkgeworICAgICAgICAgICAgICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9IGl0 LT5zZWNvbmQ7CisgICAgICAgICAgICAgICAgY291bnRlck5vZGUtPnJlbW92ZSgpOworICAgICAg ICAgICAgICAgIGRlbGV0ZSBjb3VudGVyTm9kZTsKKyAgICAgICAgICAgICAgICBjb3VudGVyTm9k ZSA9IDA7CisgICAgICAgICAgICB9CisgICAgICAgICAgICBvYmplY3RzTWFwLT5yZW1vdmUodGhp cyk7CisgICAgICAgICAgICBkZWxldGUgY291bnRlck5vZGVzTWFwOworICAgICAgICB9CisgICAg fQorICAgIAogICAgIGRvY3VtZW50KCktPmF4T2JqZWN0Q2FjaGUoKS0+cmVtb3ZlKHRoaXMpOwog CiAgICAgLy8gQnkgZGVmYXVsdCBubyByZWYtY291bnRpbmcuIFJlbmRlcldpZGdldDo6ZGVzdHJv eSgpIGRvZXNuJ3QgY2FsbApAQCAtMjgzNyw2ICsyODY2LDE1NiBAQAogICAgIHJldHVybiAoYXZv aWRzRmxvYXRzKCkgJiYgKHN0eWxlKCktPndpZHRoKCkuaXNBdXRvKCkgfHwgaXNIUigpIHx8IChz dHlsZSgpLT5odG1sSGFja3MoKSAmJiAhaXNUYWJsZSgpKSkpOwogfQogCitib29sIFJlbmRlck9i amVjdDo6aGFzQ291bnRlcihjb25zdCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAg IGlmIChzdHlsZSgpKSB7CisgICAgICAgIGlmIChzdHlsZSgpLT5oYXNDb3VudGVyUmVzZXQoY291 bnRlck5hbWUpIHx8IHN0eWxlKCktPmhhc0NvdW50ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpKQor ICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIGlmIChtX2hhc0NvdW50ZXJOb2RlTWFw KSB7CisgICAgICAgICAgICBSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMqIG9iamVjdHNN YXAgPSBnZXRSZW5kZXJPYmplY3RzVG9Db3VudGVyTm9kZU1hcHMoKTsKKyAgICAgICAgICAgIENv dW50ZXJOb2RlTWFwKiBjb3VudGVyTm9kZXNNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7Cisg ICAgICAgICAgICBpZiAoY291bnRlck5vZGVzTWFwICYmIGNvdW50ZXJOb2Rlc01hcC0+Z2V0KGNv dW50ZXJOYW1lKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAg IH0KKyAgICAKKyAgICBpZiAoY291bnRlck5hbWUgPT0gImxpc3QtaXRlbSIpCisgICAgICAgIGlm IChpc0xpc3RJdGVtKCkgfHwgKGVsZW1lbnQoKSAmJiAoCisgICAgICAgICAgICAgICAgZWxlbWVu dCgpLT5oYXNUYWdOYW1lKG9sVGFnKSB8fAorICAgICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFz VGFnTmFtZSh1bFRhZykgfHwKKyAgICAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUo bWVudVRhZykgfHwKKyAgICAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUoZGlyVGFn KSkpKQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K0NvdW50ZXJOb2RlKiBSZW5kZXJPYmplY3Q6OmZpbmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291 bnRlck5hbWUsIGJvb2wgd2lsbE5lZWRMYXlvdXQsIGJvb2wgdXNlc1NlcGFyYXRvcikKK3sKKyAg ICBpZiAoIXN0eWxlKCkpCisgICAgICAgIHJldHVybiAwOworCisgICAgUmVuZGVyT2JqZWN0c1Rv Q291bnRlck5vZGVNYXBzKiBvYmplY3RzTWFwID0gZ2V0UmVuZGVyT2JqZWN0c1RvQ291bnRlck5v ZGVNYXBzKCk7CisgICAgQ291bnRlck5vZGUqIG5ld05vZGUgPSAwOworICAgIGlmIChDb3VudGVy Tm9kZU1hcCogY291bnRlck5vZGVzTWFwID0gb2JqZWN0c01hcC0+Z2V0KHRoaXMpKQorICAgICAg ICBpZiAoY291bnRlck5vZGVzTWFwKQorICAgICAgICAgICAgbmV3Tm9kZSA9IGNvdW50ZXJOb2Rl c01hcC0+Z2V0KGNvdW50ZXJOYW1lKTsKKyAgICAgICAgCisgICAgaWYgKG5ld05vZGUpCisgICAg ICAgIHJldHVybiBuZXdOb2RlOworCisgICAgaW50IHZhbCA9IDA7CisgICAgaWYgKHN0eWxlKCkt Pmhhc0NvdW50ZXJSZXNldChjb3VudGVyTmFtZSkgfHwgaXNSb290KCkpIHsKKyAgICAgICAgbmV3 Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICB2YWwgPSBzdHlsZSgp LT5jb3VudGVyUmVzZXQoY291bnRlck5hbWUpOworICAgICAgICBpZiAoc3R5bGUoKS0+aGFzQ291 bnRlckluY3JlbWVudChjb3VudGVyTmFtZSkpCisgICAgICAgICAgICB2YWwgKz0gc3R5bGUoKS0+ Y291bnRlckluY3JlbWVudChjb3VudGVyTmFtZSk7CisgICAgICAgIG5ld05vZGUtPnNldFZhbHVl KHZhbCk7CisgICAgfSBlbHNlIGlmIChzdHlsZSgpLT5oYXNDb3VudGVySW5jcmVtZW50KGNvdW50 ZXJOYW1lKSkgeworICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKHRoaXMpOworICAg ICAgICBuZXdOb2RlLT5zZXRWYWx1ZShzdHlsZSgpLT5jb3VudGVySW5jcmVtZW50KGNvdW50ZXJO YW1lKSk7CisgICAgfSBlbHNlIGlmIChjb3VudGVyTmFtZSA9PSAibGlzdC1pdGVtIikgeworICAg ICAgICBpZiAoaXNMaXN0SXRlbSgpKSB7CisgICAgICAgICAgICBpZiAoZWxlbWVudCgpKSB7Cisg ICAgICAgICAgICAgICAgU3RyaW5nIHYgPSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4oZWxlbWVudCgp KS0+Z2V0QXR0cmlidXRlKCJ2YWx1ZSIpOworICAgICAgICAgICAgICAgIGlmICghdi5pc0VtcHR5 KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXROb2Rl KHRoaXMpOworICAgICAgICAgICAgICAgICAgICB2YWwgPSB2LnRvSW50KCk7CisgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgfSAKKyAgICAgICAgICAgIAorICAgICAgICAgICAgaWYgKCFu ZXdOb2RlKSB7CisgICAgICAgICAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlz KTsKKyAgICAgICAgICAgICAgICB2YWwgPSAxOworICAgICAgICAgICAgfQorCisgICAgICAgICAg ICBuZXdOb2RlLT5zZXRWYWx1ZSh2YWwpOworICAgICAgICB9IGVsc2UgaWYgKGVsZW1lbnQoKSAm JiBlbGVtZW50KCktPmhhc1RhZ05hbWUob2xUYWcpKSB7CisgICAgICAgICAgICBuZXdOb2RlID0g bmV3IENvdW50ZXJSZXNldE5vZGUodGhpcyk7CisgICAgICAgICAgICBuZXdOb2RlLT5zZXRWYWx1 ZShzdGF0aWNfY2FzdDxIVE1MT0xpc3RFbGVtZW50Kj4oZWxlbWVudCgpKS0+c3RhcnQoKSk7Cisg ICAgICAgIH0gZWxzZSBpZiAoZWxlbWVudCgpICYmCisgICAgICAgICAgICAoZWxlbWVudCgpLT5o YXNUYWdOYW1lKHVsVGFnKSB8fAorICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFtZSht ZW51VGFnKSB8fAorICAgICAgICAgICAgIGVsZW1lbnQoKS0+aGFzVGFnTmFtZShkaXJUYWcpKSkg eworICAgICAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAg ICAgICAgICAgbmV3Tm9kZS0+c2V0VmFsdWUoMCk7CisgICAgICAgIH0KKyAgICB9IAorICAgIAor ICAgIGlmICghbmV3Tm9kZSkgeworICAgICAgICBuZXdOb2RlID0gbmV3IENvdW50ZXJOb2RlKHRo aXMpOworICAgICAgICBuZXdOb2RlLT5zZXRWYWx1ZSgwKTsKKyAgICB9CisKKyAgICBpZiAod2ls bE5lZWRMYXlvdXQpCisgICAgICAgIG5ld05vZGUtPnNldFdpbGxOZWVkTGF5b3V0KCk7CisgICAg aWYgKHVzZXNTZXBhcmF0b3IpCisgICAgICAgIG5ld05vZGUtPnNldFVzZXNTZXBhcmF0b3IoKTsK KworICAgIENvdW50ZXJOb2RlTWFwKiBub2RlTWFwOworICAgIGlmIChtX2hhc0NvdW50ZXJOb2Rl TWFwKQorICAgICAgICBub2RlTWFwID0gb2JqZWN0c01hcC0+Z2V0KHRoaXMpOworICAgIGVsc2Ug eworICAgICAgICBub2RlTWFwID0gbmV3IENvdW50ZXJOb2RlTWFwOworICAgICAgICBvYmplY3Rz TWFwLT5zZXQodGhpcywgbm9kZU1hcCk7CisgICAgICAgIG1faGFzQ291bnRlck5vZGVNYXAgPSB0 cnVlOworICAgIH0KKyAgICAKKyAgICBub2RlTWFwLT5zZXQoY291bnRlck5hbWUsIG5ld05vZGUp OworCisgICAgaWYgKCFpc1Jvb3QoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IDA7 CisgICAgICAgIENvdW50ZXJOb2RlKiBjdXJyZW50ID0gMDsKKyAgICAgICAgUmVuZGVyT2JqZWN0 KiBuID0gIWlzTGlzdEl0ZW0oKSAmJiBwcmV2aW91c1NpYmxpbmcoKQorICAgICAgICAgICAgPyBw cmV2aW91c1NpYmxpbmcoKS0+cHJldmlvdXNTaWJsaW5nKCkgOiBwcmV2aW91c1NpYmxpbmcoKTsK KworICAgICAgICBmb3IgKDsgbjsgbiA9IG4tPnByZXZpb3VzU2libGluZygpKQorICAgICAgICBp ZiAobi0+aGFzQ291bnRlcihjb3VudGVyTmFtZSkpIHsKKyAgICAgICAgICAgIGN1cnJlbnQgPSBu LT5maW5kQ291bnRlcihjb3VudGVyTmFtZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAg fQorICAgICAgICAKKyAgICAgICAgbGFzdCA9IGN1cnJlbnQ7CisgICAgICAgIENvdW50ZXJOb2Rl KiBzaWJsaW5nID0gY3VycmVudDsKKyAgICAgICAgaWYgKGxhc3QgJiYgIW5ld05vZGUtPmlzUmVz ZXQoKSkgeworICAgICAgICAgICAgLy8gRm91bmQgcmVuZGVyLXNpYmxpbmcsIG5vdyBzZWFyY2gg Zm9yIGxhdGVyIGNvdW50ZXItc2libGluZ3MgYW1vbmcgaXRzIHJlbmRlci1jaGlsZHJlbgorICAg ICAgICAgICAgbiA9IG4tPmxhc3RDaGlsZCgpOworICAgICAgICAgICAgd2hpbGUgKG4pIHsKKyAg ICAgICAgICAgICAgICBpZiAobi0+aGFzQ291bnRlcihjb3VudGVyTmFtZSkpIHsKKyAgICAgICAg ICAgICAgICAgICAgY3VycmVudCA9IG4tPmZpbmRDb3VudGVyKGNvdW50ZXJOYW1lKTsKKyAgICAg ICAgICAgICAgICAgICAgaWYgKGxhc3QtPnBhcmVudCgpID09IGN1cnJlbnQtPnBhcmVudCgpIHx8 IHNpYmxpbmcgPT0gY3VycmVudC0+cGFyZW50KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAg IGxhc3QgPSBjdXJyZW50OworICAgICAgICAgICAgICAgICAgICAgICAgLy8gSWYgdGhlIGN1cnJl bnQgY291bnRlciBpcyBub3QgdGhlIGxhc3QsIHNlYXJjaCBkZWVwZXIKKyAgICAgICAgICAgICAg ICAgICAgICAgIGlmIChjdXJyZW50LT5uZXh0U2libGluZygpKSB7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgbiA9IG4tPmxhc3RDaGlsZCgpOworICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICAgICAgfSBlbHNlCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgbiA9IG4tPnByZXZpb3VzU2libGluZygpOworICAg ICAgICAgICAgfQorICAgICAgICAgICAgCisgICAgICAgICAgICBpZiAoc2libGluZy0+aXNSZXNl dCgpKSB7CisgICAgICAgICAgICAgICAgaWYgKGxhc3QgIT0gc2libGluZykKKyAgICAgICAgICAg ICAgICAgICAgc2libGluZy0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7CisgICAgICAgICAg ICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICBzaWJsaW5nLT5pbnNlcnRBZnRlcihuZXdO b2RlLCAwKTsKKyAgICAgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgICAgIGxhc3QtPnBhcmVu dCgpLT5pbnNlcnRBZnRlcihuZXdOb2RlLCBsYXN0KTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAg ICAgICAgIC8vIE5vdGhpbmcgZm91bmQgYW1vbmcgc2libGluZ3MsIGxldCBvdXIgcGFyZW50IHNl YXJjaAorICAgICAgICAgICAgbGFzdCA9IHBhcmVudCgpLT5maW5kQ291bnRlcihjb3VudGVyTmFt ZSwgZmFsc2UpOworICAgICAgICAgICAgaWYgKGxhc3QtPmlzUmVzZXQoKSkKKyAgICAgICAgICAg ICAgICBsYXN0LT5pbnNlcnRBZnRlcihuZXdOb2RlLCAwKTsKKyAgICAgICAgICAgIGVsc2UKKyAg ICAgICAgICAgICAgICBsYXN0LT5wYXJlbnQoKS0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgbGFzdCk7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gbmV3Tm9kZTsKK30KKwogVUNoYXIgUmVu ZGVyT2JqZWN0OjpiYWNrc2xhc2hBc0N1cnJlbmN5U3ltYm9sKCkgY29uc3QKIHsKICAgICBpZiAo Tm9kZSAqbm9kZSA9IGVsZW1lbnQoKSkKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJPYmplY3QuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgJKHJldmlzaW9uIDE2NTI4KQor KysgcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQsNyBA QAogICogQ29weXJpZ2h0IChDKSAyMDAwIExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAgKiAg ICAgICAgICAgKEMpIDIwMDAgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAgKiAg ICAgICAgICAgKEMpIDIwMDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAgICAg ICAgICAgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQog ICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVyLCBJ bmMuCiAgKgogICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgpAQCAtMzEsNiArMzIsNyBAQAogI2luY2x1ZGUgIlJlbmRlclN0eWxl LmgiCiAjaW5jbHVkZSAiU2Nyb2xsQmFyLmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgi CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KIAogLyoKICAqICBUaGUgcGFpbnRpbmcgb2YgYSBs YXllciBvY2N1cnMgaW4gdGhyZWUgZGlzdGluY3QgcGhhc2VzLiAgRWFjaCBwaGFzZSBpbnZvbHZl cwpAQCAtNTQsNiArNTYsNyBAQAogY2xhc3MgSFRNTEFyZWFFbGVtZW50OwogY2xhc3MgSW5saW5l Qm94OwogY2xhc3MgSW5saW5lRmxvd0JveDsKK2NsYXNzIENvdW50ZXJOb2RlOwogY2xhc3MgUG9z aXRpb247CiBjbGFzcyBSZW5kZXJBcmVuYTsKIGNsYXNzIFJlbmRlckJsb2NrOwpAQCAtMTkyLDYg KzE5NSwxMCBAQAogICAgIHZpcnR1YWwgaW50IHN0YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9 CiAgICAgdmlydHVhbCBpbnQgc3RhdGljWSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAg ICBib29sIGhhc0NvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyKSBjb25zdDsKKyAgICBDb3Vu dGVyTm9kZSogZmluZENvdW50ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSwgYm9vbCB3aWxs TmVlZExheW91dCA9IGZhbHNlLCBib29sIHVzZXNTZXBhcmF0b3IgPSBmYWxzZSk7CisKK3B1Ymxp YzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJlZSBtYW5pcHVsYXRpb24KICAgICAvLy8vLy8vLy8v Ly8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAgICB2aXJ0dWFsIGJvb2wgY2FuSGF2 ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTMsNiArMjYwLDcgQEAKICAgICAKICAgICB2aXJ0dWFs IGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBi b29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBi b29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29s IGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgYm9vbCBpc1Jvb3Qo KSBjb25zdDsKICAgICBib29sIGlzQm9keSgpIGNvbnN0OwpAQCAtOTI0LDggKzkzMiw5IEBACiAg ICAgYm9vbCBtX2lzRHJhZ2dpbmcgICAgICAgICAgICAgICAgOiAxOwogICAgIAogICAgIGJvb2wg bV9oYXNPdmVyZmxvd0NsaXAgICAgICAgICAgIDogMTsKKyAgICAKKyAgICBib29sIG1faGFzQ291 bnRlck5vZGVNYXAgICAgICAgICA6IDE7CiAKLSAgICAvLyBub3RlOiBkbyBub3QgYWRkIHVubmVj ZXNzYXJ5IGJpdGZsYWdzLCB3ZSBoYXZlIDMyIGJpdCBhbHJlYWR5IQogICAgIGZyaWVuZCBjbGFz cyBSZW5kZXJMaXN0SXRlbTsKICAgICBmcmllbmQgY2xhc3MgUmVuZGVyQ29udGFpbmVyOwogICAg IGZyaWVuZCBjbGFzcyBSZW5kZXJWaWV3OwpJbmRleDogcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIu aAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5oCShyZXZpc2lvbiAwKQor KysgcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1NCBA QAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUg Zm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2Vu IChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVy LCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRo ZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRo aXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNl ZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3 cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxl IFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgor ICovCisjaWZuZGVmIFJFTkRFUl9DT1VOVEVSX0hfCisjZGVmaW5lIFJFTkRFUl9DT1VOVEVSX0hf CisKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKyAgICBj bGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworY2xhc3MgUmVu ZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0IHsKKworcHVibGljOgorICAgIFJlbmRlckNv dW50ZXIoTm9kZSosIENvdW50ZXJEYXRhKik7CisgICAgCisgICAgdmlydHVhbCBjb25zdCBjaGFy KiByZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4gIlJlbmRlckNvdW50ZXIiOyB9CisKKyAgICB2 aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorICAgIHZpcnR1 YWwgdm9pZCBsYXlvdXQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgY2FsY01pbk1heFdpZHRoKCk7CisK K3ByaXZhdGU6CisgICAgU3RyaW5nIGNvbnZlcnRWYWx1ZVRvVHlwZShpbnQgdmFsdWUsIGludCB0 b3RhbCwgRUxpc3RTdHlsZVR5cGUpOworCisgICAgU3RyaW5nIG1faXRlbTsKKyAgICBDb3VudGVy RGF0YSogbV9jb3VudGVyOworICAgIENvdW50ZXJOb2RlKiBtX2NvdW50ZXJOb2RlOworfTsKKwor fSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2Rl LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuaAkocmV2aXNpb24g MCkKKysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJKHJldmlzaW9uIDApCkBAIC0wLDAg KzEsNjIgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgSFRNTCByZW5kZXJpbmcg ZW5naW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1IEFsbGFuIFNhbmRmZWxk IEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAoQykgMjAwNiBBcHBsZSBD b21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNlbnNlIGFzIHB1Ymxpc2hl ZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAqIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAq CisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJl Y2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQor ICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBDT1BZSU5HLkxJQi4gIElm IG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDU5 IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNB LgorICoKKyovCisjaWZuZGVmIENvdW50ZXJfUmVzZXRfTm9kZV9oXworI2RlZmluZSBDb3VudGVy X1Jlc2V0X05vZGVfaF8KKworI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3VudGVyLXRyZWUgdGhhdCBp cyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJzKCkgbG9va3VwLAorLy8g YW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9kZXMgYXJlIGFkZGVkIG9y IHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRlci1yZXNldCBhbmQgcm9v dCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJlZSBwYXJlbnRzCisvLyBh cmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVtZW50YXRpb24gb2YgY291 bnRlci1yZXNldCBhbmQgcm9vdAorY2xhc3MgQ291bnRlclJlc2V0Tm9kZSA6IHB1YmxpYyBDb3Vu dGVyTm9kZSB7CisKK3B1YmxpYzoKKyAgICBDb3VudGVyUmVzZXROb2RlKFJlbmRlck9iamVjdCop OworCisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogZmlyc3RDaGlsZCgpIGNvbnN0IHsgcmV0dXJu IG1fZmlyc3Q7IH07CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogbGFzdENoaWxkKCkgY29uc3Qg eyByZXR1cm4gbV9sYXN0OyB9OworICAgIHZpcnR1YWwgdm9pZCBpbnNlcnRBZnRlcihDb3VudGVy Tm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGlsZCk7CisgICAgdmlydHVhbCB2b2lk IHJlbW92ZUNoaWxkIChDb3VudGVyTm9kZSopOworCisgICAgdmlydHVhbCBib29sIGlzUmVzZXQo KSBjb25zdCB7IHJldHVybiB0cnVlOyB9OworICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIHJlY291 bnRBbmRHZXROZXh0KGJvb2wgc2V0RGlydHkgPSB0cnVlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0 UGFyZW50RGlydHkoKTsKKworICAgIHZvaWQgdXBkYXRlVG90YWwoaW50IHZhbHVlKTsKKyAgICAv LyBUaGUgaGlnaGVzdCB2YWx1ZSBhbW9uZyBjaGlsZHJlbgorICAgIGludCB0b3RhbCgpIGNvbnN0 IHsgcmV0dXJuIG1fdG90YWw7IH07CisKK3ByaXZhdGU6CisgICAgaW50IG1fdG90YWw7CisgICAg Q291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAgQ291bnRlck5vZGUqIG1fbGFzdDsKK307CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENvdW50ZXJSZXNldE5vZGVfaApJbmRl eDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9D b3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0 ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBw YXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRpb24gZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQg KEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29w eXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5 IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9k aWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMK KyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24p IGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdB UlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5U QUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05V CisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAq CisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRo ZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdh cmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9z dG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisgCisjaWZuZGVmIENvdW50ZXJMaXN0 SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0SXRlbV9ICisKKyNpbmNsdWRlICJDb3VudGVyTm9k ZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50ZXJMaXN0SXRlbSA6IHB1 YmxpYyBDb3VudGVyTm9kZQoreworcHVibGljOgorICAgIGludCBjb3VudCgpIGNvbnN0OworCisg ICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBzZXREaXJ0eSA9IHRydWUpOworICAgIHZpcnR1 YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKworfTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYK SW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJp bmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQ1IEBACisvKioKKyAqIFRoaXMgZmls ZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBD b3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29t KQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v cgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91 ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAq IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0 YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFy eTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMw LAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCisKKyNpbmNsdWRlICJDb3VudGVy Tm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKyNpbmNsdWRlICJEb2N1bWVu dC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor Y29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworUmVuZGVyQ291bnRlcjo6UmVuZGVyQ291 bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRlcikKKyAgICA6IFJlbmRlclRleHQo bm9kZSwgMCksIG1fY291bnRlcihjb3VudGVyKSwgbV9jb3VudGVyTm9kZSgwKQoreworfQorCit2 b2lkIFJlbmRlckNvdW50ZXI6OmxheW91dCgpCit7CisgICAgQVNTRVJUKG5lZWRzTGF5b3V0KCkp OworCisgICAgaWYgKCFtaW5NYXhLbm93bigpKQorICAgICAgICBjYWxjTWluTWF4V2lkdGgoKTsK KworICAgIFJlbmRlclRleHQ6OmxheW91dCgpOworfQorCitzdGF0aWMgU3RyaW5nIHRvUm9tYW4o aW50IG51bWJlciwgYm9vbCB1cHBlcikKK3sgCisgICAgU3RyaW5nIHJvbWFuOworICAgIGNvbnN0 IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAndicsICd4JywgJ2wnLCAnYycsICdkJywgJ20nIH07 CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1tdID0geyAnSScsICdWJywgJ1gnLCAnTCcsICdDJywg J0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hhciogZGlnaXRzID0gdXBwZXIgPyB1ZGlnaXRzIDog bGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8geworICAgICAgICBpbnQgbnVtID0gbnVt YmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkKKyAgICAgICAgICAgIGZvciAoaW50 IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQorICAgICAgICAgICAgICAgIHJvbWFuLmluc2VydCgm ZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA+PSA0ICYmIG51bSA8PSA4KQorICAg ICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdpdHNbZCArIDFdLCAxLCAwKTsKKyAgICAgICAgaWYg KG51bSA9PSA5KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdpdHNbZCArIDJdLCAxLCAw KTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAgICAgICAgICAgIHJvbWFuLmluc2VydCgm ZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgbnVtYmVyIC89IDEwOworICAgICAgICBkICs9IDI7 CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAgICByZXR1cm4gcm9tYW47Cit9CisKK3N0YXRpYyBT dHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJlciwgVUNoYXIgbGV0dGVyQSkKK3sgCisgICAg aWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVybiBTdHJpbmcoJmxldHRlckEsIDEpOyAvLyBt YXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94ICgwLikKKworICAgIFN0cmluZyBsZXR0ZXJTdHJp bmc7CisgICAgVUNoYXIgYzsKKyAgICB3aGlsZSAobnVtYmVyID4gMCkgeworICAgICAgICBpbnQg b25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7CisgICAgICAgIGMgPSBsZXR0ZXJBICsgb25l c0RpZ2l0OworICAgICAgICBsZXR0ZXJTdHJpbmcgPSBTdHJpbmcoJmMsIDEpICsgbGV0dGVyU3Ry aW5nOworICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0OworICAgICAgICBudW1iZXIgLz0gMjY7 CisgICAgfQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsKK30KKworc3RhdGljIFN0cmluZyB0 b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAgIGlmIChudW1iZXIgPCAxKQorICAgICAgICByZXR1 cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsKKyAgICAKKyAgICBzdGF0aWMgY29uc3QgVUNoYXIg dGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAxNTAwLCAxNTAyLCAxNTA0LCAxNTA1LCAxNTA2LCAx NTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBsZXR0ZXI7CisgICAgVUNoYXIgYzsKKyAgICBpZiAo bnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxldHRlciA9IHRvSGVicmV3KG51bWJlciAvIDEwMDAp ICsgIiciOworICAgICAgICBudW1iZXIgPSBudW1iZXIgJSAxMDAwOworICAgIH0KKyAgICBpbnQg Zm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAwOworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgZm91 ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAgYyA9IDE1MTEgKyAzOworICAgICAgICBsZXR0ZXIu YXBwZW5kKGMpOworICAgIH0KKyAgICBudW1iZXIgJT0gNDAwOworICAgIGlmIChudW1iZXIgLyAx MDApIHsKKyAgICAgICAgYyA9IDE1MTEgKyAobnVtYmVyIC8gMTAwKSAtIDE7CisgICAgICAgIGxl dHRlci5hcHBlbmQoYyk7CisgICAgfQorICAgIG51bWJlciAlPSAxMDA7CisgICAgaWYgKG51bWJl ciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAgYyA9IDE0ODcgKyA5OworICAgICAg ICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICBjID0gMTQ4NyArIG51bWJlciAtIDk7CisgICAg ICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfSBlbHNlIHsKKyAgICAgICAgaW50IHRlbnMgPSBu dW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRlbnMpIHsKKyAgICAgICAgICAgIGMgPSB0ZW5EaWdp dFt0ZW5zIC0gMV07CisgICAgICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICB9Cisg ICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAgICBpZiAobnVtYmVyKSB7CisgICAg ICAgICAgICBjID0gMTQ4NyArIG51bWJlcjsKKyAgICAgICAgICAgIGxldHRlci5hcHBlbmQoYyk7 CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIGxldHRlcjsKK30KKworU3RyaW5nIFJlbmRl ckNvdW50ZXI6OmNvbnZlcnRWYWx1ZVRvVHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RT dHlsZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJpbmcgaXRlbTsKKyAgICBVQ2hhciBjOworICAgIHN3 aXRjaCh0eXBlKSB7CisgICAgICAgIGNhc2UgTE5PTkU6CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgLy8gR2x5cGhzOgorICAgICAgICBjYXNlIERJU0M6CisgICAgICAgICAgICBjID0gMHgy MDIyOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVh azsKKyAgICAgICAgY2FzZSBDSVJDTEU6CisgICAgICAgICAgICBjID0gMHgyNWU2OworICAgICAg ICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAg Y2FzZSBTUVVBUkU6CisgICAgICAgICAgICBjID0gMHgyNWEwOworICAgICAgICAgICAgaXRlbSA9 IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBBUk1FTklB TjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoKKyAgICAgICAgY2FzZSBDSktfSURFT0dSQVBISUM6 CisgICAgICAgIGNhc2UgSElSQUdBTkE6CisgICAgICAgIGNhc2UgS0FUQUtBTkE6CisgICAgICAg IGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgS0FUQUtBTkFfSVJPSEE6CisgICAg ICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pFUk86CisgICAgICAgICAgICAvLyBGSVhNRTogVGhl c2UgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gRm9yIG5vdyB3ZSdsbCB1c2UgZGVjaW1hbCBp bnN0ZWFkLgorICAgICAgICBjYXNlIExERUNJTUFMOgorICAgICAgICAgICAgaXRlbSA9IFN0cmlu Zzo6bnVtYmVyKHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICAvLyBBbGdvcml0 bWljOgorICAgICAgICBjYXNlIExPV0VSX1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9t YW4odmFsdWUsIGZhbHNlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIFVQUEVS X1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9tYW4odmFsdWUsIHRydWUpOworICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgTE9XRVJfR1JFRUs6IHsKKyAgICAgICAgICAgIGlu dCBudW1iZXIgPSB2YWx1ZSAtIDE7CisgICAgICAgICAgICBpbnQgbCA9IChudW1iZXIgJSAyNCk7 CisgICAgICAgICAgICBpZiAobCA+IDE2KQorICAgICAgICAgICAgICAgIGwrKzsgLy8gU2tpcCBH UkVFSyBTTUFMTCBMRVRURVIgRklOQUwgU0lHTUEKKyAgICAgICAgICAgIGMgPSA5NDUgKyBsOwor ICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBmb3IgKGludCBp ID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkrKykKKyAgICAgICAgICAgICAgICBpdGVtICs9ICIn IjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgICAgIGNhc2UgSEVCUkVXOgor ICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3KHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgorICAgICAgICBjYXNlIExPV0VSX0xBVElOOgorICAg ICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVlLCAnYScpOworICAgICAgICAgICAg YnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJfQUxQSEE6CisgICAgICAgIGNhc2UgVVBQRVJfTEFU SU46CisgICAgICAgICAgICBpdGVtID0gdG9MZXR0ZXJTdHJpbmcodmFsdWUsICdBJyk7CisgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGl0ZW0gPSBTdHJp bmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAgICB9CisgICAgcmV0dXJu IGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6Y2FsY01pbk1heFdpZHRoKCkKK3sKKyAg ICBBU1NFUlQoIW1pbk1heEtub3duKCkpOworCisgICAgaWYgKCFzdHlsZSgpKQorICAgICAgICBy ZXR1cm47CisKKyAgICBib29sIGhhc1NlcGFyYXRvciA9ICFtX2NvdW50ZXItPnNlcGFyYXRvcigp LmlzTnVsbCgpOworCisgICAgaWYgKCFtX2NvdW50ZXJOb2RlICYmIHBhcmVudCgpLT5wYXJlbnQo KSkKKyAgICAgICAgbV9jb3VudGVyTm9kZSA9IHBhcmVudCgpLT5wYXJlbnQoKS0+ZmluZENvdW50 ZXIobV9jb3VudGVyLT5pZGVudGlmaWVyKCksIHRydWUsIGhhc1NlcGFyYXRvcik7CisKKyAgICBp bnQgdmFsdWUgPSBtX2NvdW50ZXJOb2RlLT5jb3VudCgpOworICAgIGlmIChtX2NvdW50ZXJOb2Rl LT5pc1Jlc2V0KCkpCisgICAgICAgIHZhbHVlID0gbV9jb3VudGVyTm9kZS0+dmFsdWUoKTsKKyAg ICAKKyAgICBpbnQgdG90YWwgPSB2YWx1ZTsKKyAgICBpZiAobV9jb3VudGVyTm9kZS0+cGFyZW50 KCkpCisgICAgICAgIHRvdGFsID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCktPnRvdGFsKCk7Cisg ICAgCisgICAgbV9pdGVtID0gY29udmVydFZhbHVlVG9UeXBlKHZhbHVlLCB0b3RhbCwgbV9jb3Vu dGVyLT5saXN0U3R5bGUoKSk7CisKKyAgICBpZiAoaGFzU2VwYXJhdG9yKSB7CisgICAgICAgIENv dW50ZXJOb2RlKiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+cGFyZW50KCk7CisgICAgICAgIGJv b2wgZmlyc3QgPSB0cnVlOworICAgICAgICB3aGlsZSAgKGNvdW50ZXItPnBhcmVudCgpICYmIChm aXJzdCB8fCAhKGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3VudGVyLT5wYXJlbnQoKS0+aXNSb290 KCkpKSkgeworICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVyLT5jb3VudCgpID8gY291bnRlci0+ Y291bnQoKSA6IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNvdW50ZXItPnBhcmVudCgpLT50b3Rh bCgpOworICAgICAgICAgICAgbV9pdGVtID0gY29udmVydFZhbHVlVG9UeXBlKHZhbHVlLCB0b3Rh bCwgbV9jb3VudGVyLT5saXN0U3R5bGUoKSkgCisgICAgICAgICAgICAgICAgKyBtX2NvdW50ZXIt PnNlcGFyYXRvcigpICsgbV9pdGVtOworICAgICAgICAgICAgY291bnRlciA9IGNvdW50ZXItPnBh cmVudCgpOworICAgICAgICAgICAgZmlyc3QgPSBmYWxzZTsKKyAgICAgICAgfQorICAgIH0KKwor ICAgIHN0ciA9IG5ldyBTdHJpbmdJbXBsKG1faXRlbS5jaGFyYWN0ZXJzKCksIG1faXRlbS5sZW5n dGgoKSk7CisgICAgCisgICAgUmVuZGVyVGV4dDo6Y2FsY01pbk1heFdpZHRoKCk7Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2aXNpb24gMCkKKysrIHJl bmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTExIEBACisv KgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3Ig S0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtk ZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIElu Yy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg TGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vu c2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBs aWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdp dGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRl IHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxh Y2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8K KworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgiCisKKyNpbmNs dWRlICJDb3VudGVyUmVzZXROb2RlLmgiCisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworQ291bnRlck5vZGU6OkNvdW50ZXJOb2RlKFJlbmRlck9iamVj dCAqbykKKyAgICA6IG1faGFzU2VwYXJhdG9yKGZhbHNlKQorICAgICwgbV93aWxsTmVlZExheW91 dChmYWxzZSkKKyAgICAsIG1fdmFsdWUoMCkKKyAgICAsIG1fY291bnQgKDApCisgICAgLCBtX3Bh cmVudCgwKQorICAgICwgbV9wcmV2aW91cygwKQorICAgICwgbV9uZXh0KDApCisgICAgLCBtX3Jl bmRlcmVyKG8pCit7ICAgCit9CisKK3ZvaWQgQ291bnRlck5vZGU6Omluc2VydEFmdGVyKENvdW50 ZXJOb2RlKiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VSVChmYWxzZSk7Cit9CisKK3ZvaWQg Q291bnRlck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKikKK3sKKyAgICBBU1NFUlQoZmFs c2UpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmUoKQoreworICAgIGlmIChtX3BhcmVu dCkKKyAgICAgICAgbV9wYXJlbnQtPnJlbW92ZUNoaWxkKHRoaXMpOworICAgIGVsc2UgeworICAg ICAgICBBU1NFUlQoaXNSZXNldCgpKTsKKyAgICAgICAgQVNTRVJUKCFmaXJzdENoaWxkKCkpOwor ICAgICAgICBBU1NFUlQoIWxhc3RDaGlsZCgpKTsKKyAgICB9Cit9CisKK3ZvaWQgQ291bnRlck5v ZGU6OnNldFVzZXNTZXBhcmF0b3IoKQoreworICAgIGZvciAoQ291bnRlck5vZGUqIGMgPSB0aGlz OyBjOyBjID0gYy0+cGFyZW50KCkpCisgICAgICAgIGMtPnNldEhhc1NlcGFyYXRvcigpOworfQor CitDb3VudGVyTm9kZSogQ291bnRlck5vZGU6OnJlY291bnRBbmRHZXROZXh0KGJvb2wgc2V0RGly dHkpCit7CisgICAgaW50IG9sZF9jb3VudCA9IG1fY291bnQ7CisgICAgaWYgKG1fcHJldmlvdXMp CisgICAgICAgIG1fY291bnQgPSBtX3ByZXZpb3VzLT5jb3VudCgpICsgbV92YWx1ZTsKKyAgICBl bHNlIHsKKyAgICAgICAgYXNzZXJ0KG1fcGFyZW50LT5maXJzdENoaWxkKCkgPT0gdGhpcyk7Cisg ICAgICAgIG1fY291bnQgPSBtX3BhcmVudC0+dmFsdWUoKSArIG1fdmFsdWU7CisgICAgfQorICAg IAorICAgIGlmIChvbGRfY291bnQgIT0gbV9jb3VudCAmJiBzZXREaXJ0eSkKKyAgICAgICAgc2V0 U2VsZkRpcnR5KCk7CisgICAgaWYgKG9sZF9jb3VudCAhPSBtX2NvdW50IHx8ICFzZXREaXJ0eSkg eworICAgICAgICBpZiAobV9wYXJlbnQpCisgICAgICAgICAgICBtX3BhcmVudC0+dXBkYXRlVG90 YWwobV9jb3VudCk7CisgICAgICAgIHJldHVybiBtX25leHQ7CisgICAgfQorICAgIAorICAgIHJl dHVybiAwOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50VHJlZShib29sIHNldERpcnR5 KQoreworICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9IHRoaXM7CisgICAgd2hpbGUgKGNv dW50ZXJOb2RlKQorICAgICAgICBjb3VudGVyTm9kZSA9IGNvdW50ZXJOb2RlLT5yZWNvdW50QW5k R2V0TmV4dChzZXREaXJ0eSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNldFNlbGZEaXJ0eSgp Cit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV93aWxsTmVlZExheW91dCkKKyAgICAgICAgbV9y ZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNhbGMoKTsKK30KKwordm9pZCBDb3Vu dGVyTm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlmIChtX3JlbmRlcmVyICYmIG1fd2ls bE5lZWRMYXlvdXQgJiYgbV9oYXNTZXBhcmF0b3IpCisgICAgICAgIG1fcmVuZGVyZXItPnNldE5l ZWRzTGF5b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlCkluZGV4OiBy ZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5 bGUuaAkocmV2aXNpb24gMTY1MjgpCisrKyByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAkod29ya2lu ZyBjb3B5KQpAQCAtMzUsMTIgKzM1LDE1IEBACiAgKiBhbmQgcHJvZHVjZSBpbnZhbGl1ZCByZXN1 bHRzLgogICovCiAKKyNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIkNT U1ZhbHVlTGlzdC5oIgogI2luY2x1ZGUgIkNvbG9yLmgiCiAjaW5jbHVkZSAiRGF0YVJlZi5oIgog I2luY2x1ZGUgIkZvbnQuaCIKICNpbmNsdWRlICJHcmFwaGljc1R5cGVzLmgiCiAjaW5jbHVkZSAi SW50UmVjdC5oIgogI2luY2x1ZGUgIkxlbmd0aC5oIgorI2luY2x1ZGUgIlBhaXIuaCIKICNpbmNs dWRlICJTaGFyZWQuaCIKICNpbmNsdWRlICJUZXh0RGlyZWN0aW9uLmgiCiAjaW5jbHVkZSA8d3Rm L1ZlY3Rvci5oPgpAQCAtNTksOSArNjIsMTEgQEAKIAogdXNpbmcgc3RkOjptYXg7CiAKLWNsYXNz IENTU1N0eWxlU2VsZWN0b3I7CiBjbGFzcyBDYWNoZWRJbWFnZTsKIGNsYXNzIENhY2hlZFJlc291 cmNlOworY2xhc3MgQ1NTU3R5bGVTZWxlY3RvcjsKK2NsYXNzIENTU1ZhbHVlTGlzdDsKK2NsYXNz IFBhaXI7CiBjbGFzcyBSZW5kZXJBcmVuYTsKIGNsYXNzIFNoYWRvd1ZhbHVlOwogY2xhc3MgU3Ry aW5nSW1wbDsKQEAgLTQwNyw4ICs0MTIsOCBAQAogICAgICAgICByZXR1cm4gKCBjbGlwID09IG8u Y2xpcCAmJgogICAgICAgICAgICAgICAgICBoYXNDbGlwID09IG8uaGFzQ2xpcCAmJgogICAgICAg ICAgICAgICAgICBjb2xzcGFuID09IG8uY29sc3BhbiAmJgotICAgICAgICAgICAgICAgICBjb3Vu dGVyX2luY3JlbWVudCA9PSBvLmNvdW50ZXJfaW5jcmVtZW50ICYmCi0gICAgICAgICAgICAgICAg IGNvdW50ZXJfcmVzZXQgPT0gby5jb3VudGVyX3Jlc2V0ICYmCisgICAgICAgICAgICAgICAgIGNv dW50ZXJJbmNyZW1lbnQgPT0gby5jb3VudGVySW5jcmVtZW50ICYmCisgICAgICAgICAgICAgICAg IGNvdW50ZXJSZXNldCA9PSBvLmNvdW50ZXJSZXNldCAmJgogICAgICAgICAgICAgICAgICB0ZXh0 RGVjb3JhdGlvbiA9PSBvLnRleHREZWNvcmF0aW9uKTsKICAgICB9CiAgICAgYm9vbCBvcGVyYXRv ciE9KCBjb25zdCBTdHlsZVZpc3VhbERhdGEgJm8gKSBjb25zdCB7CkBAIC00MjEsOCArNDI2LDgg QEAKICAgICAKICAgICBzaG9ydCBjb2xzcGFuOyAvLyBmb3IgaHRtbCwgbm90IGEgY3NzMiBhdHRy aWJ1dGUKIAotICAgIHNob3J0IGNvdW50ZXJfaW5jcmVtZW50OyAvL29rLCBzbyB0aGVzZSBhcmUg bm90IHZpc3VhbCBtb2RlIHNwZXNpZmljCi0gICAgc2hvcnQgY291bnRlcl9yZXNldDsgICAgIC8v Y2FuJ3QgZ28gdG8gaW5oZXJpdGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAorICAg IHNob3J0IGNvdW50ZXJJbmNyZW1lbnQ7IC8vIG9rLCBzbyB0aGVzZSBhcmUgbm90IHZpc3VhbCBt b2RlIHNwZWNpZmljCisgICAgc2hvcnQgY291bnRlclJlc2V0OyAgICAgLy8gY2FuJ3QgZ28gdG8g aW5oZXJpdGVkLCBzaW5jZSB0aGVzZSBhcmUgbm90IGluaGVyaXRlZAogCiB9OwogCkBAIC04NzIs NiArODc3LDIzIEBACiAgICAgQ09OVEVOVF9OT05FLCBDT05URU5UX09CSkVDVCwgQ09OVEVOVF9U RVhULCBDT05URU5UX0NPVU5URVIKIH07CiAKK2NsYXNzIENvdW50ZXJEYXRhIHsKKyAgICAKK3B1 YmxpYzoKKyAgICBDb3VudGVyRGF0YSgpIHt9CisgICAgQ291bnRlckRhdGEoY29uc3QgU3RyaW5n JiBpLCBFTGlzdFN0eWxlVHlwZSBsLCBjb25zdCBTdHJpbmcmIHMpCisgICAgICAgIDogbV9pZGVu dGlmaWVyKGkpLCBtX2xpc3RTdHlsZShsKSwgbV9zZXBhcmF0b3Iocykge30KKyAgICAKKyAgICBT dHJpbmcgaWRlbnRpZmllcigpIHsgcmV0dXJuIG1faWRlbnRpZmllcjsgfQorICAgIEVMaXN0U3R5 bGVUeXBlIGxpc3RTdHlsZSgpIHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9CisgICAgU3RyaW5nIHNl cGFyYXRvcigpIHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9CisKK3ByaXZhdGU6CisgICAgU3RyaW5n IG1faWRlbnRpZmllcjsKKyAgICBFTGlzdFN0eWxlVHlwZSBtX2xpc3RTdHlsZTsKKyAgICBTdHJp bmcgbV9zZXBhcmF0b3I7Cit9OworCiBzdHJ1Y3QgQ29udGVudERhdGEgewogICAgIENvbnRlbnRE YXRhKCkgOl9jb250ZW50VHlwZShDT05URU5UX05PTkUpLCBfbmV4dENvbnRlbnQoMCkge30KICAg ICB+Q29udGVudERhdGEoKTsKQEAgLTg4MSwxMyArOTAzLDE0IEBACiAKICAgICBTdHJpbmdJbXBs KiBjb250ZW50VGV4dCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9URVhUKSByZXR1 cm4gX2NvbnRlbnQudGV4dDsgcmV0dXJuIDA7IH0KICAgICBDYWNoZWRSZXNvdXJjZSogY29udGVu dE9iamVjdCgpIHsgaWYgKGNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpIHJldHVybiBf Y29udGVudC5vYmplY3Q7IHJldHVybiAwOyB9CisgICAgQ291bnRlckRhdGEqIGNvbnRlbnRDb3Vu dGVyKCkgeyBpZiAoY29udGVudFR5cGUoKSA9PSBDT05URU5UX0NPVU5URVIpIHJldHVybiBfY29u dGVudC5jb3VudGVyOyByZXR1cm4gMDsgfQogICAgIAogICAgIENvbnRlbnRUeXBlIF9jb250ZW50 VHlwZTsKIAogICAgIHVuaW9uIHsKICAgICAgICAgQ2FjaGVkUmVzb3VyY2UqIG9iamVjdDsKICAg ICAgICAgU3RyaW5nSW1wbCogdGV4dDsKLSAgICAgICAgLy8gY291bnRlcnMuLi4KKyAgICAgICAg Q291bnRlckRhdGEqIGNvdW50ZXI7CiAgICAgfSBfY29udGVudCA7CiAKICAgICBDb250ZW50RGF0 YSogX25leHRDb250ZW50OwpAQCAtMTA0NSw3ICsxMDY4LDkgQEAKICAgICAKICAgICAvLyBhZGRl ZCB0aGlzIGhlcmUsIHNvIHdlIGNhbiBnZXQgcmlkIG9mIHRoZSB2cHRyIGluIHRoaXMgY2xhc3Mu CiAgICAgLy8gbWFrZXMgdXAgZm9yIHRoZSBzYW1lIHNpemUuCi0gICAgQ29udGVudERhdGEgKmNv bnRlbnQ7CisgICAgQ29udGVudERhdGEqIGNvbnRlbnQ7CisgICAgUmVmUHRyPENTU1ZhbHVlTGlz dD4gY291bnRlclJlc2V0TGlzdDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiBjb3VudGVySW5j cmVtZW50TGlzdDsKIAogICAgIHVuc2lnbmVkIG1fcHNldWRvU3RhdGUgOiAzOyAvLyBQc2V1ZG9T dGF0ZQogICAgIGJvb2wgbV9hZmZlY3RlZEJ5QXR0cmlidXRlU2VsZWN0b3JzIDogMTsKQEAgLTEy OTUsOCArMTMyMCw4IEBACiAgICAgRUVtcHR5Q2VsbCBlbXB0eUNlbGxzKCkgY29uc3QgeyByZXR1 cm4gc3RhdGljX2Nhc3Q8RUVtcHR5Q2VsbD4oaW5oZXJpdGVkX2ZsYWdzLl9lbXB0eV9jZWxscyk7 IH0KICAgICBFQ2FwdGlvblNpZGUgY2FwdGlvblNpZGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNf Y2FzdDxFQ2FwdGlvblNpZGU+KGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlKTsgfQogCi0g ICAgc2hvcnQgY291bnRlckluY3JlbWVudCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRl cl9pbmNyZW1lbnQ7IH0KLSAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVybiB2 aXN1YWwtPmNvdW50ZXJfcmVzZXQ7IH0KKyAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkgY29u c3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVySW5jcmVtZW50OyB9CisgICAgc2hvcnQgY291bnRl clJlc2V0KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyUmVzZXQ7IH0KIAogICAgIEVM aXN0U3R5bGVUeXBlIGxpc3RTdHlsZVR5cGUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxF TGlzdFN0eWxlVHlwZT4oaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUpOyB9CiAgICAg Q2FjaGVkSW1hZ2UgKmxpc3RTdHlsZUltYWdlKCkgY29uc3QgeyByZXR1cm4gaW5oZXJpdGVkLT5z dHlsZV9pbWFnZTsgfQpAQCAtMTUwMSw4ICsxNTI2LDggQEAKICAgICB2b2lkIHNldENhcHRpb25T aWRlKEVDYXB0aW9uU2lkZSB2KSB7IGluaGVyaXRlZF9mbGFncy5fY2FwdGlvbl9zaWRlID0gdjsg fQogCiAKLSAgICB2b2lkIHNldENvdW50ZXJJbmNyZW1lbnQoc2hvcnQgdikgeyAgU0VUX1ZBUih2 aXN1YWwsY291bnRlcl9pbmNyZW1lbnQsdikgfQotICAgIHZvaWQgc2V0Q291bnRlclJlc2V0KHNo b3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJfcmVzZXQsdikgfQorICAgIHZvaWQgc2V0 Q291bnRlckluY3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVySW5jcmVt ZW50LHYpIH0KKyAgICB2b2lkIHNldENvdW50ZXJSZXNldChzaG9ydCB2KSB7ICBTRVRfVkFSKHZp c3VhbCxjb3VudGVyUmVzZXQsdikgfQogCiAgICAgdm9pZCBzZXRMaXN0U3R5bGVUeXBlKEVMaXN0 U3R5bGVUeXBlIHYpIHsgaW5oZXJpdGVkX2ZsYWdzLl9saXN0X3N0eWxlX3R5cGUgPSB2OyB9CiAg ICAgdm9pZCBzZXRMaXN0U3R5bGVJbWFnZShDYWNoZWRJbWFnZSAqdikgeyAgU0VUX1ZBUihpbmhl cml0ZWQsc3R5bGVfaW1hZ2Usdil9CkBAIC0xNTk3LDcgKzE2MjIsMTggQEAKICAgICBib29sIGNv bnRlbnREYXRhRXF1aXZhbGVudChjb25zdCBSZW5kZXJTdHlsZSAqb3RoZXJTdHlsZSkgY29uc3Q7 CiAgICAgdm9pZCBzZXRDb250ZW50KFN0cmluZ0ltcGwqIHMsIGJvb2wgYWRkID0gZmFsc2UpOwog ICAgIHZvaWQgc2V0Q29udGVudChDYWNoZWRSZXNvdXJjZSogbywgYm9vbCBhZGQgPSBmYWxzZSk7 CisgICAgdm9pZCBzZXRDb250ZW50KENvdW50ZXJEYXRhKiwgYm9vbCBhZGQgPSBmYWxzZSk7CiAK KyAgICBib29sIGNvdW50ZXJEYXRhRXF1aXZhbGVudChSZW5kZXJTdHlsZSopOworICAgIHZvaWQg c2V0Q291bnRlclJlc2V0TGlzdChQYXNzUmVmUHRyPENTU1ZhbHVlTGlzdD4gbCkgeyBjb3VudGVy UmVzZXRMaXN0ID0gbDsgfQorICAgIHZvaWQgc2V0Q291bnRlckluY3JlbWVudExpc3QoUGFzc1Jl ZlB0cjxDU1NWYWx1ZUxpc3Q+IGwpIHsgY291bnRlckluY3JlbWVudExpc3QgPSBsOyB9CisgICAg Ym9vbCBoYXNDb3VudGVyUmVzZXQoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgYm9vbCBoYXND b3VudGVySW5jcmVtZW50KGNvbnN0IFN0cmluZyYpIGNvbnN0OworICAgIGludCBjb3VudGVyUmVz ZXQoY29uc3QgU3RyaW5nJikgY29uc3Q7CisgICAgaW50IGNvdW50ZXJJbmNyZW1lbnQoY29uc3Qg U3RyaW5nJikgY29uc3Q7CisgICAgQ1NTVmFsdWVMaXN0KiBjb3VudGVyUmVzZXRWYWx1ZUxpc3Qo KSB7IHJldHVybiBjb3VudGVyUmVzZXRMaXN0LmdldCgpOyB9CisgICAgQ1NTVmFsdWVMaXN0KiBj b3VudGVySW5jcmVtZW50VmFsdWVMaXN0KCkgeyByZXR1cm4gY291bnRlckluY3JlbWVudExpc3Qu Z2V0KCk7IH0KKwogICAgIGJvb2wgaW5oZXJpdGVkTm90RXF1YWwoIFJlbmRlclN0eWxlICpvdGhl ciApIGNvbnN0OwogCiAgICAgLy8gVGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0d28gc3R5bGVzLiAg VGhlIGZvbGxvd2luZyB2YWx1ZXMgYXJlIHVzZWQ6CkluZGV4OiByZW5kZXJpbmcvQ291bnRlclJl c2V0Tm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3Bw CShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5vZGUuY3BwCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDE1NiBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBI VE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUg QWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChD KSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAw MjExMS0xMzA3LCBVU0EuCisgKgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRl ICJDb3VudGVyUmVzZXROb2RlLmgiCisKKyNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKworbmFt ZXNwYWNlIFdlYkNvcmUgeworCitDb3VudGVyUmVzZXROb2RlOjpDb3VudGVyUmVzZXROb2RlKFJl bmRlck9iamVjdCogbykKKyAgICA6IENvdW50ZXJOb2RlKG8pCisgICAgLCBtX3RvdGFsKDApCisg ICAgLCBtX2ZpcnN0KDApCisgICAgLCBtX2xhc3QoMCkKK3sKK30KKwordm9pZCBDb3VudGVyUmVz ZXROb2RlOjppbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiBy ZWZDaGlsZCkKK3sKKyAgICBBU1NFUlQobmV3Q2hpbGQpOworICAgIEFTU0VSVCghcmVmQ2hpbGQg fHwgcmVmQ2hpbGQtPnBhcmVudCgpID09IHRoaXMpOworCisgICAgbmV3Q2hpbGQtPm1fcGFyZW50 ID0gdGhpczsKKyAgICBuZXdDaGlsZC0+bV9wcmV2aW91cyA9IHJlZkNoaWxkOworCisgICAgaWYg KHJlZkNoaWxkKSB7CisgICAgICAgIG5ld0NoaWxkLT5tX25leHQgPSByZWZDaGlsZC0+bV9uZXh0 OworICAgICAgICByZWZDaGlsZC0+bV9uZXh0ID0gbmV3Q2hpbGQ7CisgICAgfSBlbHNlIHsKKyAg ICAgICAgbmV3Q2hpbGQtPm1fbmV4dCA9IG1fZmlyc3Q7CisgICAgICAgIG1fZmlyc3QgPSBuZXdD aGlsZDsKKyAgICB9CisKKyAgICBpZiAobmV3Q2hpbGQtPm1fbmV4dCkgeworICAgICAgICBBU1NF UlQobmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9PSByZWZDaGlsZCk7CisgICAgICAgIG5l d0NoaWxkLT5tX25leHQtPm1fcHJldmlvdXMgPSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAg ICAgICBBU1NFUlQobV9sYXN0ID09IHJlZkNoaWxkKTsKKyAgICAgICAgbV9sYXN0ID0gbmV3Q2hp bGQ7CisgICAgfQorCisgICAgbmV3Q2hpbGQtPnJlY291bnRBbmRHZXROZXh0KGZhbHNlKTsKK30K Kwordm9pZCBDb3VudGVyUmVzZXROb2RlOjpyZW1vdmVDaGlsZChDb3VudGVyTm9kZSogb2xkQ2hp bGQpCit7CisgICAgQVNTRVJUKG9sZENoaWxkKTsKKworICAgIENvdW50ZXJOb2RlKiBuZXh0ID0g b2xkQ2hpbGQtPm1fbmV4dDsKKyAgICBDb3VudGVyTm9kZSogcHJldiA9IG9sZENoaWxkLT5tX3By ZXZpb3VzOworCisgICAgaWYgKG9sZENoaWxkLT5maXJzdENoaWxkKCkpIHsKKyAgICAgICAgQ291 bnRlck5vZGUqIGZpcnN0ID0gb2xkQ2hpbGQtPmZpcnN0Q2hpbGQoKTsKKyAgICAgICAgQ291bnRl ck5vZGUqIGxhc3QgPSBvbGRDaGlsZC0+bGFzdENoaWxkKCk7CisgICAgICAgIGlmIChwcmV2KSB7 CisgICAgICAgICAgICBwcmV2LT5tX25leHQgPSBmaXJzdDsKKyAgICAgICAgICAgIGZpcnN0LT5t X3ByZXZpb3VzID0gcHJldjsKKyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBtX2ZpcnN0ID0g Zmlyc3Q7CisKKyAgICAgICAgaWYgKG5leHQpIHsKKyAgICAgICAgICAgIG5leHQtPm1fcHJldmlv dXMgPSBsYXN0OworICAgICAgICAgICAgbGFzdC0+bV9uZXh0ID0gbmV4dDsKKyAgICAgICAgfSBl bHNlCisgICAgICAgICAgICBtX2xhc3QgPSBsYXN0OworCisgICAgICAgIG5leHQgPSBmaXJzdDsK KyAgICAgICAgd2hpbGUgKG5leHQpIHsKKyAgICAgICAgICAgIG5leHQtPm1fcGFyZW50ID0gdGhp czsKKyAgICAgICAgICAgIG5leHQgPSBuZXh0LT5tX25leHQ7CisgICAgICAgIH0KKworICAgICAg ICBmaXJzdC0+cmVjb3VudEFuZEdldE5leHQodHJ1ZSk7CisgICAgfSBlbHNlIHsKKyAgICAgICAg aWYgKHByZXYpIAorICAgICAgICAgICAgcHJldi0+bV9uZXh0ID0gbmV4dDsKKyAgICAgICAgZWxz ZSB7CisgICAgICAgICAgICBhc3NlcnQgKCBtX2ZpcnN0ID09IG9sZENoaWxkICk7CisgICAgICAg ICAgICBtX2ZpcnN0ID0gbmV4dDsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgaWYgKG5l eHQpCisgICAgICAgICAgICBuZXh0LT5tX3ByZXZpb3VzID0gcHJldjsKKyAgICAgICAgZWxzZSB7 CisgICAgICAgICAgICBhc3NlcnQgKCBtX2xhc3QgPT0gb2xkQ2hpbGQgKTsKKyAgICAgICAgICAg IG1fbGFzdCA9IHByZXY7CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIGlmIChuZXh0KQor ICAgICAgICAgICAgbmV4dC0+cmVjb3VudFRyZWUoKTsKKyAgICB9CisKKworICAgIG9sZENoaWxk LT5tX25leHQgPSAwOworICAgIG9sZENoaWxkLT5tX3ByZXZpb3VzID0gMDsKKyAgICBvbGRDaGls ZC0+bV9wYXJlbnQgPSAwOworfQorCitDb3VudGVyTm9kZSogQ291bnRlclJlc2V0Tm9kZTo6cmVj b3VudEFuZEdldE5leHQoYm9vbCBzZXREaXJ0eSkKK3sKKyAgICBpbnQgb2xkX2NvdW50ID0gbV9j b3VudDsKKyAgICBpZiAobV9wcmV2aW91cykKKyAgICAgICAgbV9jb3VudCA9IG1fcHJldmlvdXMt PmNvdW50KCk7CisgICAgZWxzZSBpZiAobV9wYXJlbnQpCisgICAgICAgIG1fY291bnQgPSBtX3Bh cmVudC0+dmFsdWUoKTsKKyAgICBlbHNlCisgICAgICAgIG1fY291bnQgPSAwOworCisgICAgdXBk YXRlVG90YWwobV92YWx1ZSk7CisgICAgCisgICAgaWYgKHNldERpcnR5KQorICAgICAgICBzZXRT ZWxmRGlydHkoKTsKKyAgICBpZiAoIXNldERpcnR5IHx8IG1fY291bnQgIT0gb2xkX2NvdW50KQor ICAgICAgICByZXR1cm4gbV9uZXh0OworICAgIAorICAgIHJldHVybiAwOworfQorCit2b2lkIENv dW50ZXJSZXNldE5vZGU6OnNldFBhcmVudERpcnR5KCkKK3sKKyAgICBpZiAoaGFzU2VwYXJhdG9y KCkpCisgICAgICAgIHNldFNlbGZEaXJ0eSgpOworICAgICAgICAKKyAgICBmb3IgKENvdW50ZXJO b2RlKiBuID0gZmlyc3RDaGlsZCgpOyBuOyBuID0gbi0+bmV4dFNpYmxpbmcoKSkKKyAgICAgICAg aWYgKG4tPmhhc1NlcGFyYXRvcigpKQorICAgICAgICAgICAgbi0+c2V0U2VsZkRpcnR5KCk7Cit9 CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6dXBkYXRlVG90YWwoaW50IHZhbHVlKQoreworICAg IGlmICh2YWx1ZSA+IG1fdG90YWwpCisgICAgICAgIG1fdG90YWwgPSB2YWx1ZTsKK30KKworfSAv LyBuYW1lc3BhY2UKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb250YWluZXIuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIHJlbmRlcmluZy9SZW5kZXJDb250YWluZXIuY3BwCShyZXZpc2lvbiAxNjUyOCkKKysr IHJlbmRlcmluZy9SZW5kZXJDb250YWluZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00LDYgKzQs NyBAQAogICogQ29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtkZS5vcmcpCiAg KiAgICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtkZS5vcmcpCiAg KiAgICAgICAgICAgKEMpIDIwMDAgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5vcmcpCisgKiAg ICAgICAgICAgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29t KQogICogQ29weXJpZ2h0IChDKSAyMDAzLCAyMDA0LCAyMDA1LCAyMDA2IEFwcGxlIENvbXB1dGVy LCBJbmMuCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQW5kcmV3IFdlbGxpbmd0b24gKHByb3RvbkB3 aXJldGFwcGVkLm5ldCkKICAqCkBAIC0yOCw2ICsyOSw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQ29u dGFpbmVyLmgiCiAKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgorI2luY2x1ZGUgIlJlbmRlckNv dW50ZXIuaCIKICNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogI2luY2x1ZGUgIlJlbmRlclRh YmxlLmgiCiAjaW5jbHVkZSAiUmVuZGVyVGV4dEZyYWdtZW50LmgiCkBAIC0yOTYsNyArMjk4LDcg QEAKICAgICAgICAgLy8gZGV0ZXJtaW5lZCB0aGF0IHRoZSBwc2V1ZG8gaXMgbm90IGRpc3BsYXkg Tk9ORSwgYW55IGRpc3BsYXkgb3RoZXIgdGhhbgogICAgICAgICAvLyBpbmxpbmUgc2hvdWxkIGJl IG11dGF0ZWQgdG8gSU5MSU5FLgogICAgICAgICBwc2V1ZG8tPnNldERpc3BsYXkoSU5MSU5FKTsK LSAgICAKKwogICAgIGlmIChvbGRDb250ZW50UHJlc2VudCkgewogICAgICAgICBpZiAoY2hpbGQg JiYgY2hpbGQtPnN0eWxlKCktPnN0eWxlVHlwZSgpID09IHR5cGUpIHsKICAgICAgICAgICAgIC8v IFdlIGhhdmUgZ2VuZXJhdGVkIGNvbnRlbnQgcHJlc2VudCBzdGlsbC4gIFdlIHdhbnQgdG8gd2Fs ayB0aGlzIGNvbnRlbnQgYW5kIHVwZGF0ZSBvdXIKQEAgLTMzNCwyMCArMzM2LDI0IEBACiAgICAg ICAgIGlmICghcHNldWRvQ29udGFpbmVyKQogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyID0g UmVuZGVyRmxvdzo6Y3JlYXRlQW5vbnltb3VzRmxvdyhkb2N1bWVudCgpLCBwc2V1ZG8pOyAvKiBh bm9ueW1vdXMgYm94ICovCiAgICAgICAgIAotICAgICAgICBpZiAoY29udGVudERhdGEtPmNvbnRl bnRUeXBlKCkgPT0gQ09OVEVOVF9URVhUKQotICAgICAgICB7CisgICAgICAgIGlmIChjb250ZW50 RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHsKICAgICAgICAgICAgIFJlbmRl clRleHQqIHQgPSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclRleHRGcmFnbWVudChkb2N1bWVu dCgpIC8qYW5vbnltb3VzIG9iamVjdCAqLywgY29udGVudERhdGEtPmNvbnRlbnRUZXh0KCkpOwog ICAgICAgICAgICAgdC0+c2V0U3R5bGUocHNldWRvKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRh aW5lci0+YWRkQ2hpbGQodCk7Ci0gICAgICAgIH0KLSAgICAgICAgZWxzZSBpZiAoY29udGVudERh dGEtPmNvbnRlbnRUeXBlKCkgPT0gQ09OVEVOVF9PQkpFQ1QpCi0gICAgICAgIHsKKyAgICAgICAg fSBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkg ewogICAgICAgICAgICAgUmVuZGVySW1hZ2UqIGltZyA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVu ZGVySW1hZ2UoZG9jdW1lbnQoKSk7IC8qIEFub255bW91cyBvYmplY3QgKi8KICAgICAgICAgICAg IFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5bGUoKTsK ICAgICAgICAgICAgIHN0eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOwogICAgICAgICAgICAgaW1n LT5zZXRTdHlsZShzdHlsZSk7CiAgICAgICAgICAgICBpbWctPnNldENvbnRlbnRPYmplY3QoY29u dGVudERhdGEtPmNvbnRlbnRPYmplY3QoKSk7CiAgICAgICAgICAgICBwc2V1ZG9Db250YWluZXIt PmFkZENoaWxkKGltZyk7CisgICAgICAgIH0gZWxzZSBpZiAoY29udGVudERhdGEtPl9jb250ZW50 VHlwZSA9PSBDT05URU5UX0NPVU5URVIpIHsKKyAgICAgICAgICAgIFJlbmRlckNvdW50ZXIqIGMg PSBuZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlckNvdW50ZXIoZWxlbWVudCgpLCBjb250ZW50RGF0 YS0+Y29udGVudENvdW50ZXIoKSk7CisgICAgICAgICAgICBSZW5kZXJTdHlsZSogc3R5bGUgPSBu ZXcgKHJlbmRlckFyZW5hKCkpIFJlbmRlclN0eWxlKCk7CisgICAgICAgICAgICBzdHlsZS0+aW5o ZXJpdEZyb20ocHNldWRvKTsKKyAgICAgICAgICAgIGMtPnNldElzQW5vbnltb3VzKHRydWUpOwor ICAgICAgICAgICAgYy0+c2V0U3R5bGUoc3R5bGUpOworICAgICAgICAgICAgcHNldWRvQ29udGFp bmVyLT5hZGRDaGlsZChjKTsKICAgICAgICAgfQogICAgIH0KIApJbmRleDogcmVuZGVyaW5nL0Nv dW50ZXJOb2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmgJKHJldmlz aW9uIDApCisrKyByZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCAr MSw4NiBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBl bmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQg SmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENv bXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBv ZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoK KyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVj ZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisg KiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYg bm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkg VGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0Eu CisgKgorKi8KKyNpZm5kZWYgQ291bnRlcl9Ob2RlX2hfCisjZGVmaW5lIENvdW50ZXJfTm9kZV9o XworCisjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwor Y2xhc3MgQ291bnRlclJlc2V0Tm9kZTsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3Vu dGVyLXRyZWUgdGhhdCBpcyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJz KCkgbG9va3VwLAorLy8gYW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9k ZXMgYXJlIGFkZGVkIG9yIHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRl ci1yZXNldCBhbmQgcm9vdCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJl ZSBwYXJlbnRzCisvLyBhcmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworY2xhc3MgQ291 bnRlck5vZGUgeworcHVibGljOgorICAgIENvdW50ZXJOb2RlKFJlbmRlck9iamVjdCopOworICAg IHZpcnR1YWwgfkNvdW50ZXJOb2RlKCkge30KKworICAgIENvdW50ZXJSZXNldE5vZGUqIHBhcmVu dCgpIGNvbnN0IHsgcmV0dXJuIG1fcGFyZW50OyB9CisgICAgQ291bnRlck5vZGUqIHByZXZpb3Vz U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fcHJldmlvdXM7IH0KKyAgICB2aXJ0dWFsIENvdW50 ZXJOb2RlKiBuZXh0U2libGluZygpIGNvbnN0IHsgcmV0dXJuIG1fbmV4dDsgfQorICAgIHZpcnR1 YWwgQ291bnRlck5vZGUqIGZpcnN0Q2hpbGQoKSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmly dHVhbCBDb3VudGVyTm9kZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gMDsgfQorICAgIHZp cnR1YWwgdm9pZCBpbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2Rl KiByZWZDaGlsZCk7CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZUNoaWxkIChDb3VudGVyTm9kZSog b2xkQ2hpbGQpOworICAgIHZvaWQgcmVtb3ZlKCk7CisKKyAgICBpbnQgdmFsdWUoKSBjb25zdCB7 IHJldHVybiBtX3ZhbHVlOyB9CisgICAgdm9pZCBzZXRWYWx1ZShpbnQgdikgeyBtX3ZhbHVlID0g djsgfQorICAgIGludCBjb3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fY291bnQ7IH0KKyAgICB2b2lk IHNldENvdW50KGludCBjKSB7IG1fY291bnQgPSBjOyB9CisgICAgdm9pZCBzZXRIYXNTZXBhcmF0 b3IoKSB7IG1faGFzU2VwYXJhdG9yID0gdHJ1ZTsgfQorCisgICAgdmlydHVhbCBib29sIGlzUmVz ZXQoKSBjb25zdHsgcmV0dXJuIGZhbHNlOyB9CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogcmVj b3VudEFuZEdldE5leHQoYm9vbCBzZXREaXJ0eSA9IHRydWUpOworICAgIHZpcnR1YWwgdm9pZCBy ZWNvdW50VHJlZShib29sIHNldERpcnR5ID0gdHJ1ZSk7CisgICAgdmlydHVhbCB2b2lkIHNldFNl bGZEaXJ0eSgpOworICAgIHZpcnR1YWwgdm9pZCBzZXRQYXJlbnREaXJ0eSgpOworCisgICAgYm9v bCBoYXNTZXBhcmF0b3IoKSBjb25zdCB7IHJldHVybiBtX2hhc1NlcGFyYXRvcjsgfQorICAgIGJv b2wgd2lsbE5lZWRMYXlvdXQoKSBjb25zdCB7IHJldHVybiBtX3dpbGxOZWVkTGF5b3V0OyB9Cisg ICAgdm9pZCBzZXRVc2VzU2VwYXJhdG9yKCk7CisgICAgdm9pZCBzZXRXaWxsTmVlZExheW91dCgp IHsgbV93aWxsTmVlZExheW91dCA9IHRydWU7IH0KKyAgICBib29sIGlzUm9vdCgpIGNvbnN0IHsg cmV0dXJuIG1fcmVuZGVyZXIgJiYgbV9yZW5kZXJlci0+aXNSb290KCk7IH0KKworICAgIHZvaWQg c2V0UmVuZGVyZXIoUmVuZGVyT2JqZWN0KiBvKSB7IG1fcmVuZGVyZXIgPSBvOyB9CisgICAgUmVu ZGVyT2JqZWN0KiByZW5kZXJlcigpIGNvbnN0IHsgcmV0dXJuIG1fcmVuZGVyZXI7IH0KKworICAg IGZyaWVuZCBjbGFzcyBDb3VudGVyUmVzZXROb2RlOworcHJvdGVjdGVkOgorICAgIGJvb2wgbV9o YXNTZXBhcmF0b3I7CisgICAgYm9vbCBtX3dpbGxOZWVkTGF5b3V0OworICAgIGludCBtX3ZhbHVl OworICAgIGludCBtX2NvdW50OworICAgIENvdW50ZXJSZXNldE5vZGUqIG1fcGFyZW50OworICAg IENvdW50ZXJOb2RlKiBtX3ByZXZpb3VzOworICAgIENvdW50ZXJOb2RlKiBtX25leHQ7CisgICAg UmVuZGVyT2JqZWN0KiBtX3JlbmRlcmVyOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQor CisjZW5kaWYgLy8gQ291bnRlck5vZGVfaApJbmRleDogcmVuZGVyaW5nL1JlbmRlclN0eWxlLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3BwCShyZXZpc2lvbiAxNjUy OCkKKysrIHJlbmRlcmluZy9SZW5kZXJTdHlsZS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTkwLDgg KzkwLDggQEAKICAgICA6IGhhc0NsaXAoZmFsc2UpCiAgICAgLCB0ZXh0RGVjb3JhdGlvbihSZW5k ZXJTdHlsZTo6aW5pdGlhbFRleHREZWNvcmF0aW9uKCkpCiAgICAgLCBjb2xzcGFuKDEpCi0gICAg LCBjb3VudGVyX2luY3JlbWVudCgwKQotICAgICwgY291bnRlcl9yZXNldCgwKQorICAgICwgY291 bnRlckluY3JlbWVudCgwKQorICAgICwgY291bnRlclJlc2V0KDApCiB7CiB9CiAKQEAgLTEwNSw4 ICsxMDUsOCBAQAogICAgICwgaGFzQ2xpcChvLmhhc0NsaXApCiAgICAgLCB0ZXh0RGVjb3JhdGlv bihvLnRleHREZWNvcmF0aW9uKQogICAgICwgY29sc3BhbihvLmNvbHNwYW4pCi0gICAgLCBjb3Vu dGVyX2luY3JlbWVudChvLmNvdW50ZXJfaW5jcmVtZW50KQotICAgICwgY291bnRlcl9yZXNldChv LmNvdW50ZXJfcmVzZXQpCisgICAgLCBjb3VudGVySW5jcmVtZW50KG8uY291bnRlckluY3JlbWVu dCkKKyAgICAsIGNvdW50ZXJSZXNldChvLmNvdW50ZXJSZXNldCkKIHsKIH0KIApAQCAtNTc3LDcg KzU3Nyw2IEBACiAgICAgICAgIHByZXYtPmRlcmVmKGFyZW5hKTsKICAgICB9CiAgICAgZGVsZXRl IGNvbnRlbnQ7Ci0gICAgCiAgICAgZGVsZXRlIHRoaXM7CiAgICAgCiAgICAgLy8gUmVjb3ZlciB0 aGUgc2l6ZSBsZWZ0IHRoZXJlIGZvciB1cyBieSBvcGVyYXRvciBkZWxldGUgYW5kIGZyZWUgdGhl IG1lbW9yeS4KQEAgLTY0OSw2ICs2NDgsOCBAQAogICAgICwgaW5oZXJpdGVkKG8uaW5oZXJpdGVk KQogICAgICwgcHNldWRvU3R5bGUoMCkKICAgICAsIGNvbnRlbnQoby5jb250ZW50KQorICAgICwg Y291bnRlclJlc2V0TGlzdChvLmNvdW50ZXJSZXNldExpc3QpCisgICAgLCBjb3VudGVySW5jcmVt ZW50TGlzdChvLmNvdW50ZXJJbmNyZW1lbnRMaXN0KQogICAgICwgbV9wc2V1ZG9TdGF0ZShvLm1f cHNldWRvU3RhdGUpCiAgICAgLCBtX2FmZmVjdGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMoZmFsc2Up CiAgICAgLCBtX3VuaXF1ZShmYWxzZSkKQEAgLTgzOCw4ICs4MzksOCBAQAogICAgICAgICAhKG5v bmluaGVyaXRlZF9mbGFncy5fZmxvYXRpbmcgPT0gb3RoZXItPm5vbmluaGVyaXRlZF9mbGFncy5f ZmxvYXRpbmcpIHx8CiAgICAgICAgICEobm9uaW5oZXJpdGVkX2ZsYWdzLl9vcmlnaW5hbERpc3Bs YXkgPT0gb3RoZXItPm5vbmluaGVyaXRlZF9mbGFncy5fb3JpZ2luYWxEaXNwbGF5KSB8fAogICAg ICAgICAgdmlzdWFsLT5jb2xzcGFuICE9IG90aGVyLT52aXN1YWwtPmNvbHNwYW4gfHwKLSAgICAg ICAgIHZpc3VhbC0+Y291bnRlcl9pbmNyZW1lbnQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlcl9p bmNyZW1lbnQgfHwKLSAgICAgICAgIHZpc3VhbC0+Y291bnRlcl9yZXNldCAhPSBvdGhlci0+dmlz dWFsLT5jb3VudGVyX3Jlc2V0IHx8CisgICAgICAgICB2aXN1YWwtPmNvdW50ZXJJbmNyZW1lbnQg IT0gb3RoZXItPnZpc3VhbC0+Y291bnRlckluY3JlbWVudCB8fAorICAgICAgICAgdmlzdWFsLT5j b3VudGVyUmVzZXQgIT0gb3RoZXItPnZpc3VhbC0+Y291bnRlclJlc2V0IHx8CiAgICAgICAgICBj c3MzTm9uSW5oZXJpdGVkRGF0YS0+dGV4dE92ZXJmbG93ICE9IG90aGVyLT5jc3MzTm9uSW5oZXJp dGVkRGF0YS0+dGV4dE92ZXJmbG93IHx8CiAgICAgICAgICAoY3NzM0luaGVyaXRlZERhdGEtPnRl eHRTZWN1cml0eSAhPSBvdGhlci0+Y3NzM0luaGVyaXRlZERhdGEtPnRleHRTZWN1cml0eSkpCiAg ICAgICAgIHJldHVybiBMYXlvdXQ7CkBAIC05MjUsNiArOTI2LDEwIEBACiAgICAgLy8gSWYgcmVn aW9ucyBjaGFuZ2UgdHJpZ2dlciBhIHJlbGF5b3V0IHRvIHJlLWNhbGMgcmVnaW9ucy4KICAgICBp ZiAoIShjc3MzTm9uSW5oZXJpdGVkRGF0YS0+bV9kYXNoYm9hcmRSZWdpb25zID09IG90aGVyLT5j c3MzTm9uSW5oZXJpdGVkRGF0YS0+bV9kYXNoYm9hcmRSZWdpb25zKSkKICAgICAgICAgcmV0dXJu IExheW91dDsKKyAgICAKKyAgICAvLyBJZiB0aGUgY291bnRlciBsaXN0cyBjaGFuZ2UsIHRyaWdn ZXIgYSByZWxheW91dCB0byByZS1jYWxjIENvdW50ZXJOb2Rlcy4KKyAgICBpZiAoY291bnRlclJl c2V0TGlzdCAhPSBvdGhlci0+Y291bnRlclJlc2V0TGlzdCB8fCBjb3VudGVySW5jcmVtZW50TGlz dCAhPSBvdGhlci0+Y291bnRlckluY3JlbWVudExpc3QpCisgICAgICAgIHJldHVybiBMYXlvdXQ7 CiAKICAgICAvLyBNYWtlIHN1cmUgdGhlc2UgbGVmdC90b3AvcmlnaHQvYm90dG9tIGNoZWNrcyBz dGF5IGJlbG93IGFsbCBsYXlvdXQgY2hlY2tzIGFuZCBhYm92ZQogICAgIC8vIGFsbCB2aXNpYmxl IGNoZWNrcy4KQEAgLTEwODAsNiArMTA4NSwzMiBAQAogICAgIG5ld0NvbnRlbnREYXRhLT5fY29u dGVudFR5cGUgPSBDT05URU5UX1RFWFQ7CiB9CiAKK3ZvaWQgUmVuZGVyU3R5bGU6OnNldENvbnRl bnQoQ291bnRlckRhdGEqIGMsIGJvb2wgYWRkKQoreworICAgIGlmICghYykKKyAgICAgICAgcmV0 dXJuOworCisgICAgQ29udGVudERhdGEqIGxhc3RDb250ZW50ID0gY29udGVudDsKKyAgICB3aGls ZSAobGFzdENvbnRlbnQgJiYgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVudCkKKyAgICAgICAgbGFz dENvbnRlbnQgPSBsYXN0Q29udGVudC0+X25leHRDb250ZW50OworCisgICAgYm9vbCByZXVzZUNv bnRlbnQgPSAhYWRkOworICAgIENvbnRlbnREYXRhKiBuZXdDb250ZW50RGF0YSA9IDA7CisgICAg aWYgKHJldXNlQ29udGVudCAmJiBjb250ZW50KSB7CisgICAgICAgIGNvbnRlbnQtPmNsZWFyQ29u dGVudCgpOworICAgICAgICBuZXdDb250ZW50RGF0YSA9IGNvbnRlbnQ7CisgICAgfSBlbHNlCisg ICAgICAgIG5ld0NvbnRlbnREYXRhID0gbmV3IENvbnRlbnREYXRhOworCisgICAgaWYgKGxhc3RD b250ZW50ICYmICFyZXVzZUNvbnRlbnQpCisgICAgICAgIGxhc3RDb250ZW50LT5fbmV4dENvbnRl bnQgPSBuZXdDb250ZW50RGF0YTsKKyAgICBlbHNlCisgICAgICAgIGNvbnRlbnQgPSBuZXdDb250 ZW50RGF0YTsKKworICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudC5jb3VudGVyID0gYzsKKyAg ICBuZXdDb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID0gQ09OVEVOVF9DT1VOVEVSOworfQorCiBD b250ZW50RGF0YTo6fkNvbnRlbnREYXRhKCkKIHsKICAgICBjbGVhckNvbnRlbnQoKTsKQEAgLTEw OTgsNiArMTEyOSwxMSBAQAogICAgICAgICBjYXNlIENPTlRFTlRfVEVYVDoKICAgICAgICAgICAg IF9jb250ZW50LnRleHQtPmRlcmVmKCk7CiAgICAgICAgICAgICBfY29udGVudC50ZXh0ID0gMDsK KyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIENPTlRFTlRfQ09VTlRFUjoKKyAgICAg ICAgICAgIGRlbGV0ZSBfY29udGVudC5jb3VudGVyOworICAgICAgICAgICAgX2NvbnRlbnQuY291 bnRlciA9IDA7CisgICAgICAgICAgICBicmVhazsKICAgICAgICAgZGVmYXVsdDoKICAgICAgICAg ICAgIDsKICAgICB9CkBAIC0xMTg1LDYgKzEyMjEsODIgQEAKICAgICByZXR1cm4geCA9PSBvLngg JiYgeSA9PSBvLnkgJiYgYmx1ciA9PSBvLmJsdXIgJiYgY29sb3IgPT0gby5jb2xvcjsKIH0KIAor Ym9vbCBSZW5kZXJTdHlsZTo6Y291bnRlckRhdGFFcXVpdmFsZW50KFJlbmRlclN0eWxlKiBvdGhl clN0eWxlKQoreworICAgIC8vIEZJWE1FOiBTaG91bGQgd2UgYWxzbyBjb21wYXJlIHRoZSBDb3Vu dGVyRGF0YT8gCisgICAgcmV0dXJuIGNvdW50ZXJSZXNldExpc3QgPT0gb3RoZXJTdHlsZS0+Y291 bnRlclJlc2V0TGlzdCAmJgorICAgICAgICAgICBjb3VudGVySW5jcmVtZW50TGlzdCA9PSBvdGhl clN0eWxlLT5jb3VudGVySW5jcmVtZW50TGlzdDsKK30KKworc3RhdGljIGJvb2wgaGFzQ291bnRl cihjb25zdCBTdHJpbmcmIGMsIENTU1ZhbHVlTGlzdCogbCkKK3sKKyAgICBpbnQgbGVuID0gbC0+ bGVuZ3RoKCk7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBsZW47IGkrKykgeworICAgICAgICBD U1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0aXZlVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRp dmVWYWx1ZSo+KGwtPml0ZW0oaSkpOworICAgICAgICBQYWlyKiBwYWlyID0gcHJpbWl0aXZlVmFs dWUtPmdldFBhaXJWYWx1ZSgpOworICAgICAgICBBU1NFUlQocGFpcik7CisgICAgICAgIENTU1By aW1pdGl2ZVZhbHVlKiBjb3VudGVyTmFtZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVl Kj4ocGFpci0+Zmlyc3QoKSk7CisgICAgICAgIEFTU0VSVChjb3VudGVyTmFtZSk7CisgICAgICAg IGlmIChjb3VudGVyTmFtZS0+Z2V0U3RyaW5nVmFsdWUoKSA9PSBjKQorICAgICAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5kZXJTdHls ZTo6aGFzQ291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0Cit7Cisg ICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiBoYXNDb3VudGVyKGNvdW50 ZXJOYW1lLCBjb3VudGVyUmVzZXRMaXN0LmdldCgpKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K2Jvb2wgUmVuZGVyU3R5bGU6Omhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5nJiBjb3Vu dGVyTmFtZSkgY29uc3QKK3sKKyAgICBpZiAoY291bnRlckluY3JlbWVudExpc3QpCisgICAgICAg IHJldHVybiBoYXNDb3VudGVyKGNvdW50ZXJOYW1lLCBjb3VudGVySW5jcmVtZW50TGlzdC5nZXQo KSk7CisgICAgcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW50IHJlYWRDb3VudGVyKGNvbnN0 IFN0cmluZyYgYywgQ1NTVmFsdWVMaXN0KiBsLCBib29sIGlzUmVzZXQpCit7CisgICAgaW50IGxl biA9IGwtPmxlbmd0aCgpOworICAgIGludCB0b3RhbCA9IDA7CisgICAgCisgICAgZm9yIChpbnQg aSA9IDA7IGkgPCBsZW47IGkrKykgeworICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZSogcHJpbWl0 aXZlVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmltaXRpdmVWYWx1ZSo+KGwtPml0ZW0oaSkpOwor ICAgICAgICBQYWlyKiBwYWlyID0gcHJpbWl0aXZlVmFsdWUtPmdldFBhaXJWYWx1ZSgpOworICAg ICAgICBBU1NFUlQocGFpcik7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBjb3VudGVyTmFt ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4ocGFpci0+Zmlyc3QoKSk7CisgICAg ICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBjb3VudGVyVmFsdWUgPSBzdGF0aWNfY2FzdDxDU1NQcmlt aXRpdmVWYWx1ZSo+KHBhaXItPnNlY29uZCgpKTsKKyAgICAgICAgQVNTRVJUKGNvdW50ZXJOYW1l KTsKKyAgICAgICAgQVNTRVJUKGNvdW50ZXJWYWx1ZSk7CisKKyAgICAgICAgaWYgKGNvdW50ZXJO YW1lLT5nZXRTdHJpbmdWYWx1ZSgpID09IGMpIHsKKyAgICAgICAgICAgIHRvdGFsICs9IChpbnQp Y291bnRlclZhbHVlLT5nZXRGbG9hdFZhbHVlKCk7CisgICAgICAgICAgICBpZiAoaXNSZXNldCkK KyAgICAgICAgICAgICAgICByZXR1cm4gdG90YWw7CisgICAgICAgIH0KKyAgICB9CisgICAgCisg ICAgcmV0dXJuIHRvdGFsOworfQorCitpbnQgUmVuZGVyU3R5bGU6OmNvdW50ZXJSZXNldChjb25z dCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAgIGlmIChjb3VudGVyUmVzZXRMaXN0 KQorICAgICAgICByZXR1cm4gcmVhZENvdW50ZXIoY291bnRlck5hbWUsIGNvdW50ZXJSZXNldExp c3QuZ2V0KCksIHRydWUpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKK2ludCBS ZW5kZXJTdHlsZTo6Y291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBj b25zdAoreworICAgIGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIHJl YWRDb3VudGVyKGNvdW50ZXJOYW1lLCBjb3VudGVySW5jcmVtZW50TGlzdC5nZXQoKSwgZmFsc2Up OworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIDA7Cit9CisKIGNvbnN0IFZlY3RvcjxTdHlsZURh c2hib2FyZFJlZ2lvbj4mIFJlbmRlclN0eWxlOjppbml0aWFsRGFzaGJvYXJkUmVnaW9ucygpCiB7 IAogICAgIHN0YXRpYyBWZWN0b3I8U3R5bGVEYXNoYm9hcmRSZWdpb24+IGVtcHR5TGlzdDsKSW5k ZXg6IFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvago9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJKHJldmlzaW9uIDE2NTI4KQorKysgV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC04NTcsNiArODU3 LDEzIEBACiAJCTkzNUZCQ0YyMDlCQTE0M0IwMEUyMzBCMSAvKiBFeGNlcHRpb25Db2RlLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzVGQkNGMTA5QkEx NDNCMDBFMjMwQjEgLyogRXhjZXB0aW9uQ29kZS5oICovOyB9OwogCQk5MzZCNDI0RTA5QTQzNkNE MDBCQUE4MjAgLyogU1ZHQ1NTUGFyc2VyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IEE4QzBGNkY2MDg5NzAxRjEwMEJBNTExNCAvKiBTVkdDU1NQYXJz ZXIuY3BwICovOyB9OwogCQk5MzZCREQxRDBBMDMxQUVCMDA0REY0QUIgLyogR3JhcGhpY3NDb250 ZXh0Q0cuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g OTM2QkREMUMwQTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAqLzsgfTsK KwkJOTM3MUJCNzEwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjcwMEFDNDdGQUUwMENE NEE3QiAvKiBSZW5kZXJDb3VudGVyLmggKi87IH07CisJCTkzNzFCQjczMEFDNDdGQjgwMENENEE3 QiAvKiBSZW5kZXJDb3VudGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDkzNzFCQjcyMEFDNDdGQjgwMENENEE3QiAvKiBSZW5kZXJDb3VudGVyLmNw cCAqLzsgfTsKKwkJOTM3MUJCNzUwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc0 MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmggKi87IH07CisJCTkzNzFCQjc3 MEFDNDdGRDAwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjc2MEFDNDdGRDAwMENENEE3QiAv KiBDb3VudGVyUmVzZXROb2RlLmNwcCAqLzsgfTsKKwkJOTM3MUJCNzkwQUM0N0ZENzAwQ0Q0QTdC IC8qIENvdW50ZXJOb2RlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA5MzcxQkI3ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLzsgfTsK KwkJOTM3MUJCN0IwQUM0N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzNzFCQjdBMEFDNDdGREUwMENE NEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgKi87IH07CisJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3 QiAvKiBDb3VudGVyTGlzdEl0ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDkzNzFCQjdDMEFDNDdGRTcwMENENEE3QiAvKiBDb3VudGVyTGlzdEl0ZW0u aCAqLzsgfTsKIAkJOTM3MjU2MTAwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNxbGl0ZTMuZHlsaWIg aW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzcyNTYw RjBBNjE1NjQyMDBCMDUzQjkgLyogbGlic3FsaXRlMy5keWxpYiAqLzsgfTsKIAkJOTM4MEY0NzMw OUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA5MzgwRjQ3MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNw cCAqLzsgfTsKIAkJOTM4MEY0NzQwOUExMUFCNDAwMUZEQjM0IC8qIFdpZGdldC5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4MEY0NzIwOUExMUFCNDAw MUZEQjM0IC8qIFdpZGdldC5oICovOyB9OwpAQCAtMzE4Myw2ICszMTkwLDEzIEBACiAJCTkzNUZC Q0YxMDlCQTE0M0IwMEUyMzBCMSAvKiBFeGNlcHRpb25Db2RlLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgcGF0aCA9IEV4Y2VwdGlvbkNvZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJOTM2QkREMUMwQTAzMUFFQjAwNERGNEFCIC8qIEdyYXBoaWNzQ29udGV4dENHLmNwcCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEdyYXBoaWNzQ29udGV4dENHLmNw cDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM2REQwM0EwOUNFQUMyNzAwNTZBRThD IC8qIFJhbmdlLmlkbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBSYW5nZS5pZGw7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjcwMEFDNDdGQUUwMENENEE3QiAvKiBSZW5kZXJD b3VudGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBSZW5kZXJDb3VudGVy Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjcyMEFDNDdGQjgwMENENEE3 QiAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBh dGggPSBSZW5kZXJDb3VudGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM3 MUJCNzQwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJSZXNldE5vZGUuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJOTM3MUJCNzYwQUM0N0ZEMDAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5v ZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IENvdW50ZXJSZXNl dE5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzcxQkI3ODBBQzQ3RkQ3 MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IENvdW50ZXJOb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzNzFCQjdB MEFDNDdGREUwMENENEE3QiAvKiBDb3VudGVyTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jcHAuY3BwOyBwYXRoID0gQ291bnRlck5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OworCQk5MzcxQkI3QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVtLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3VudGVyTGlzdEl0ZW0uaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM3MjU2MEYwQTYxNTY0MjAwQjA1M0I5IC8qIGxpYnNx bGl0ZTMuZHlsaWIgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSAiY29tcGlsZWQubWFjaC1vLmR5bGliIjsgbmFtZSA9IGxpYnNxbGl0ZTMuZHlsaWI7IHBh dGggPSAvdXNyL2xpYi9saWJzcWxpdGUzLmR5bGliOyBzb3VyY2VUcmVlID0gIjxhYnNvbHV0ZT4i OyB9OwogCQk5MzgwRjQ3MTA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBXaWRnZXQuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQk5MzgwRjQ3MjA5QTExQUI0MDAxRkRCMzQgLyogV2lkZ2V0LmggKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXaWRnZXQuaDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKQEAgLTcxNjYsNiArNzE4MCwxMSBAQAogCQkJCUJDRUE0ODE0MDk3RDkzMDIwMDk0 QzlFNCAvKiBiaWRpLmggKi8sCiAJCQkJQkNFQTQ4MTUwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFr X2xpbmVzLmNwcCAqLywKIAkJCQlCQ0VBNDgxNjA5N0Q5MzAyMDA5NEM5RTQgLyogYnJlYWtfbGlu ZXMuaCAqLywKKwkJCQk5MzcxQkI3QzBBQzQ3RkU3MDBDRDRBN0IgLyogQ291bnRlckxpc3RJdGVt LmggKi8sCisJCQkJOTM3MUJCN0EwQUM0N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCAq LywKKwkJCQk5MzcxQkI3ODBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRlck5vZGUuaCAqLywKKwkJ CQk5MzcxQkI3NjBBQzQ3RkQwMDBDRDRBN0IgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgKi8sCisJ CQkJOTM3MUJCNzQwQUM0N0ZDODAwQ0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLywKIAkJ CQlCQ0VBNDgxNzA5N0Q5MzAyMDA5NEM5RTQgLyogRGF0YVJlZi5oICovLAogCQkJCUFCRTdCNTIx MEE0ODlGODMwMDMxODgxQyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmNwcCAqLywKIAkJCQlB QkU3QjUyMjBBNDg5RjgzMDAzMTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5oICovLApA QCAtNzIwMiw2ICs3MjIxLDggQEAKIAkJCQlCQ0VBNDgyOTA5N0Q5MzAyMDA5NEM5RTQgLyogUmVu ZGVyVmlldy5oICovLAogCQkJCUJDRUE0ODJDMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250 YWluZXIuY3BwICovLAogCQkJCUJDRUE0ODJEMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250 YWluZXIuaCAqLywKKwkJCQk5MzcxQkI3MjBBQzQ3RkI4MDBDRDRBN0IgLyogUmVuZGVyQ291bnRl ci5jcHAgKi8sCisJCQkJOTM3MUJCNzAwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIu aCAqLywKIAkJCQlBOEVBNzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuY3Bw ICovLAogCQkJCUE4RUE3M0IwMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNldC5oICov LAogCQkJCTA2NkM3NzJFMEFCNjAzRkQwMDIzOENDNCAvKiBSZW5kZXJGaWxlVXBsb2FkQ29udHJv bC5jcHAgKi8sCkBAIC04NDUwLDYgKzg0NzEsMTAgQEAKIAkJCQlBODQxNUY5RTBBQzEwQzVEMDBG N0QwREYgLyogS0NhbnZhc01hc2tlci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTg0MTVGQTAwQUMx MEM1RDAwRjdEMERGIC8qIEtDYW52YXNNYXJrZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCUJDM0ZD QUE5MEFDM0RCNTgwMEJBNTRBRCAvKiBQbGF0Zm9ybVNjcm9sbEJhci5oIGluIEhlYWRlcnMgKi8s CisJCQkJOTM3MUJCNzEwQUM0N0ZBRTAwQ0Q0QTdCIC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFk ZXJzICovLAorCQkJCTkzNzFCQjc1MEFDNDdGQzgwMENENEE3QiAvKiBDb3VudGVyUmVzZXROb2Rl LmggaW4gSGVhZGVycyAqLywKKwkJCQk5MzcxQkI3OTBBQzQ3RkQ3MDBDRDRBN0IgLyogQ291bnRl ck5vZGUuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzNzFCQjdEMEFDNDdGRTcwMENENEE3QiAvKiBD b3VudGVyTGlzdEl0ZW0uaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBs b3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtOTUzOCw2ICs5NTYzLDkgQEAKIAkJ CQlBODQxNUY5RjBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc01hc2tlci5jcHAgaW4gU291cmNl cyAqLywKIAkJCQlBODQxNUZBMTBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc01hcmtlci5jcHAg aW4gU291cmNlcyAqLywKIAkJCQlBODQxNUZBMjBBQzEwQzVEMDBGN0QwREYgLyogS0NhbnZhc0Zp bHRlcnMuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCNzMwQUM0N0ZCODAwQ0Q0QTdCIC8q IFJlbmRlckNvdW50ZXIuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJCNzcwQUM0N0ZEMDAw Q0Q0QTdCIC8qIENvdW50ZXJSZXNldE5vZGUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM3MUJC N0IwQUM0N0ZERTAwQ0Q0QTdCIC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJ KTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRl eDogY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3Nz L0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysgY3Nz L0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYwMiwx MSArNjAyLDkgQEAKICAgICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50ZWQKICAgICAgICAgYnJl YWs7CiAgICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX0lOQ1JFTUVOVDoKLSAgICAgICAgLy8gRklY TUU6IHVuaW1wbGVtZW50ZWQKLSAgICAgICAgYnJlYWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+ Y291bnRlckluY3JlbWVudFZhbHVlTGlzdCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9S RVNFVDoKLSAgICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50ZWQKLSAgICAgICAgYnJlYWs7Cisg ICAgICAgIHJldHVybiBzdHlsZS0+Y291bnRlclJlc2V0VmFsdWVMaXN0KCk7CiAgICAgY2FzZSBD U1NfUFJPUF9DVVJTT1I6CiAgICAgICAgIGlmIChzdHlsZS0+Y3Vyc29ySW1hZ2UoKSkKICAgICAg ICAgICAgIHJldHVybiBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoc3R5bGUtPmN1cnNvckltYWdlKCkt PnVybCgpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSk7CkluZGV4OiBjc3MvY3NzcGFyc2Vy LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5oCShyZXZpc2lvbiAxNjUyOCkKKysrIGNz cy9jc3NwYXJzZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMTIwLDcgKzEyMCw3IEBACiAKICAgICAg ICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3Q7CiAKLSAgICAgICAgdm9pZCBhZGRQcm9wZXJ0 eShpbnQgcHJvcElkLCBDU1NWYWx1ZSosIGJvb2wgaW1wb3J0YW50KTsKKyAgICAgICAgdm9pZCBh ZGRQcm9wZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiwgYm9vbCBpbXBvcnRh bnQpOwogICAgICAgICB2b2lkIHJvbGxiYWNrTGFzdFByb3BlcnRpZXMoaW50IG51bSk7CiAgICAg ICAgIGJvb2wgaGFzUHJvcGVydGllcygpIGNvbnN0IHsgcmV0dXJuIG51bVBhcnNlZFByb3BlcnRp ZXMgPiAwOyB9CiAKQEAgLTE0NiwxMSArMTQ2LDEzIEBACiAKICAgICAgICAgYm9vbCBwYXJzZVNo YXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgYm9vbCBwYXJzZUZvbnQo Ym9vbCBpbXBvcnRhbnQpOworICAgICAgICBib29sIHBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBp bnQgZGVmYXVsdFZhbHVlLCBib29sIGltcG9ydGFudCk7CiAgICAgICAgIENTU1ZhbHVlTGlzdCog cGFyc2VGb250RmFtaWx5KCk7CiAgICAgICAgIGJvb2wgcGFyc2VDb2xvclBhcmFtZXRlcnMoVmFs dWUqLCBpbnQqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBib29sIHBh cnNlSFNMUGFyYW1ldGVycyhWYWx1ZSosIGRvdWJsZSogY29sb3JWYWx1ZXMsIGJvb2wgcGFyc2VB bHBoYSk7CiAgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yKCk7CiAgICAgICAg IENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yRnJvbVZhbHVlKFZhbHVlKik7CisgICAgICAg IFBhc3NSZWZQdHI8Q1NTVmFsdWU+IHBhcnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0KiBhcmdz LCBib29sIGNvdW50ZXJzKTsKICAgICAgICAgCiAjaWZkZWYgU1ZHX1NVUFBPUlQKICAgICAgICAg Ym9vbCBwYXJzZVNWR1ZhbHVlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKSW5kZXg6IGNz cy9jc3NzdHlsZXNlbGVjdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3Nzc3R5bGVzZWxlY3Rv ci5jcHAJKHJldmlzaW9uIDE2NTI4KQorKysgY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCSh3b3Jr aW5nIGNvcHkpCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiQ1NTU3R5bGVTaGVldC5oIgog I2luY2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKICNpbmNsdWRlICJDU1NWYWx1ZUxpc3QuaCIK KyNpbmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKICNpbmNsdWRl ICJEYXNoYm9hcmRSZWdpb24uaCIKICNpbmNsdWRlICJGb250RmFtaWx5VmFsdWUuaCIKQEAgLTc0 NiwxOCArNzQ3LDE2IEBACiAKIHZvaWQgQ1NTU3R5bGVTZWxlY3Rvcjo6bWF0Y2hVQVJ1bGVzKGlu dCYgZmlyc3RVQVJ1bGUsIGludCYgbGFzdFVBUnVsZSkKIHsKLSAgICAvLyAxLiBGaXJzdCB3ZSBt YXRjaCBydWxlcyBmcm9tIHRoZSB1c2VyIGFnZW50IHNoZWV0LgotICAgIG1hdGNoUnVsZXMoZGVm YXVsdFN0eWxlLCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CisgICAgLy8gRmlyc3Qgd2UgbWF0 Y2ggcnVsZXMgZnJvbSB0aGUgdXNlciBhZ2VudCBzaGVldC4KKyAgICBDU1NSdWxlU2V0KiB1c2Vy QWdlbnRTdHlsZVNoZWV0ID0gbV9tZWRpdW0tPm1lZGlhVHlwZU1hdGNoKCJwcmludCIpCisgICAg ICAgID8gZGVmYXVsdFByaW50U3R5bGUgOiBkZWZhdWx0U3R5bGU7CisgICAgbWF0Y2hSdWxlcyh1 c2VyQWdlbnRTdHlsZVNoZWV0LCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CiAKLSAgICAvLyAy LiBJbiBxdWlya3MgbW9kZSwgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgcXVpcmtzIHVzZXIgYWdl bnQgc2hlZXQuCisgICAgLy8gSW4gcXVpcmtzIG1vZGUsIHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhl IHF1aXJrcyB1c2VyIGFnZW50IHNoZWV0LgogICAgIGlmICghc3RyaWN0UGFyc2luZykKICAgICAg ICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtzU3R5bGUsIGZpcnN0VUFSdWxlLCBsYXN0VUFSdWxl KTsKLQotICAgIC8vIDMuIElmIG91ciBtZWRpdW0gaXMgcHJpbnQsIHRoZW4gd2UgbWF0Y2ggcnVs ZXMgZnJvbSB0aGUgcHJpbnQgc2hlZXQuCi0gICAgaWYgKG1fbWVkaXVtLT5tZWRpYVR5cGVNYXRj aCgicHJpbnQiKSkKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UHJpbnRTdHlsZSwgZmlyc3RV QVJ1bGUsIGxhc3RVQVJ1bGUpOwogICAgICAgICAKLSAgICAvLyA0LiBJZiB3ZSdyZSBpbiB2aWV3 IHNvdXJjZSBtb2RlLCB0aGVuIHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhlIHZpZXcgc291cmNlIHN0 eWxlIHNoZWV0LgorICAgIC8vIElmIHdlJ3JlIGluIHZpZXcgc291cmNlIG1vZGUsIHRoZW4gd2Ug bWF0Y2ggcnVsZXMgZnJvbSB0aGUgdmlldyBzb3VyY2Ugc3R5bGUgc2hlZXQuCiAgICAgaWYgKHZp ZXcgJiYgdmlldy0+ZnJhbWUoKSAmJiB2aWV3LT5mcmFtZSgpLT5pblZpZXdTb3VyY2VNb2RlKCkp CiAgICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdTb3VyY2VTdHlsZSwgZmlyc3RVQVJ1bGUs IGxhc3RVQVJ1bGUpOwogfQpAQCAtMzE0OCw3ICszMTQ3LDkgQEAKIAogICAgICAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CiAgICAgICAgICAgICBDU1NWYWx1ZSAqaXRlbSA9IGxp c3QtPml0ZW0oaSk7Ci0gICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZlVmFsdWUoKSkg Y29udGludWU7CisgICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZlVmFsdWUoKSkKKyAg ICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIAogICAgICAgICAgICAgQ1NTUHJp bWl0aXZlVmFsdWUgKnZhbCA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4oaXRlbSk7 CiAgICAgICAgICAgICBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfU1RSSU5HKQogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KHZhbC0+Z2V0 U3RyaW5nVmFsdWUoKS5pbXBsKCksIGkgIT0gMCk7CkBAIC0zMTYyLDE5ICszMTYzLDI4IEBACiAg ICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoZWxlbWVudC0+Z2V0QXR0cmlidXRlKGF0 dHIpLmltcGwoKSwgaSAhPSAwKTsKICAgICAgICAgICAgICAgICAvLyByZWdpc3RlciB0aGUgZmFj dCB0aGF0IHRoZSBhdHRyaWJ1dGUgdmFsdWUgYWZmZWN0cyB0aGUgc3R5bGUKICAgICAgICAgICAg ICAgICBtX3NlbGVjdG9yQXR0cnMuYWRkKGF0dHIubG9jYWxOYW1lKCkuaW1wbCgpKTsKLSAgICAg ICAgICAgIH0KLSAgICAgICAgICAgIGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgeworICAgICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnBy aW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKICAgICAgICAgICAg ICAgICBDU1NJbWFnZVZhbHVlICppbWFnZSA9IHN0YXRpY19jYXN0PENTU0ltYWdlVmFsdWUqPih2 YWwpOwogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KGltYWdlLT5pbWFnZShlbGVt ZW50LT5kb2N1bWVudCgpLT5kb2NMb2FkZXIoKSksIGkgIT0gMCk7Ci0gICAgICAgICAgICB9Cisg ICAgICAgICAgICB9IGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRpdmVW YWx1ZTo6Q1NTX0NPVU5URVIpIHsKKyAgICAgICAgICAgICAgICBDb3VudGVyKiBjb3VudGVyVmFs dWUgPSB2YWwtPmdldENvdW50ZXJWYWx1ZSgpOworICAgICAgICAgICAgICAgIENvdW50ZXJEYXRh IGNvdW50ZXIoY291bnRlclZhbHVlLT5pZGVudGlmaWVyKCksCisgICAgICAgICAgICAgICAgICAg IChFTGlzdFN0eWxlVHlwZSljb3VudGVyVmFsdWUtPmxpc3RTdHlsZU51bWJlcigpLCBjb3VudGVy VmFsdWUtPnNlcGFyYXRvcigpKTsKKyAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVudChu ZXcgQ291bnRlckRhdGEoY291bnRlciksIGkgIT0gMCk7CisgICAgICAgICAgIH0KICAgICAgICAg fQogICAgICAgICBicmVhazsKICAgICB9CiAKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfSU5D UkVNRU5UOgotICAgICAgICAvLyBsaXN0IG9mIENTUzJDb3VudGVySW5jcmVtZW50CisgICAgICAg IGlmICghdmFsdWUtPmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAg IHN0eWxlLT5zZXRDb3VudGVySW5jcmVtZW50TGlzdChzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3Qq Pih2YWx1ZSkpOworICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfUkVT RVQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNldAorICAgICAgICBpZiAoIXZh bHVlLT5pc1ZhbHVlTGlzdCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBzdHlsZS0+ c2V0Q291bnRlclJlc2V0TGlzdChzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QqPih2YWx1ZSkpOwog ICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOiB7CiAgICAgICAg IC8vIGxpc3Qgb2Ygc3RyaW5ncyBhbmQgaWRzCkluZGV4OiBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUu Y3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGNzcy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAJKHJldmlzaW9uIDE2 NTI4KQorKysgY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTI0 LDcgKzUyNCwxMCBAQAogICAgICAgICAgICAgLy8gIyMjCiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgY2FzZSBDU1NfQ09VTlRFUjoKLSAgICAgICAgICAgIC8vICMjIworICAgICAgICAgICAg dGV4dCA9ICJjb3VudGVyKCI7CisgICAgICAgICAgICB0ZXh0ICs9IFN0cmluZzo6bnVtYmVyKG1f dmFsdWUubnVtKTsKKyAgICAgICAgICAgIHRleHQgKz0gIikiOworICAgICAgICAgICAgLy8gRklY TUU6IEFkZCBsaXN0LXN0eWxlIGFuZCBzZXBhcmF0b3IKICAgICAgICAgICAgIGJyZWFrOwogICAg ICAgICBjYXNlIENTU19SRUNUOiB7CiAgICAgICAgICAgICBSZWN0SW1wbCogcmVjdFZhbCA9IGdl dFJlY3RWYWx1ZSgpOwpJbmRleDogY3NzL0NvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvQ291 bnRlci5oCShyZXZpc2lvbiAxNjUyOCkKKysrIGNzcy9Db3VudGVyLmgJKHdvcmtpbmcgY29weSkK QEAgLTIzLDIzICsyMywzNyBAQAogI2lmbmRlZiBDb3VudGVyX0gKICNkZWZpbmUgQ291bnRlcl9I CiAKKyNpbmNsdWRlICJDU1NQcmltaXRpdmVWYWx1ZS5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3Ry aW5nLmgiCiAjaW5jbHVkZSAiU2hhcmVkLmgiCi0jaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIK KyNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNs YXNzIENvdW50ZXIgOiBwdWJsaWMgU2hhcmVkPENvdW50ZXI+IHsKIHB1YmxpYzoKLSAgICBTdHJp bmcgaWRlbnRpZmllcigpIGNvbnN0IHsgcmV0dXJuIG1faWRlbnRpZmllcjsgfQotICAgIFN0cmlu ZyBsaXN0U3R5bGUoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZTsgfQotICAgIFN0cmluZyBz ZXBhcmF0b3IoKSBjb25zdCB7IHJldHVybiBtX3NlcGFyYXRvcjsgfQorICAgIENvdW50ZXIoKSA6 IG1faWRlbnRpZmllcigwKSwgbV9saXN0U3R5bGUoMCksIG1fc2VwYXJhdG9yKDApIHsgfQorICAg IENvdW50ZXIoUGFzc1JlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gaWRlbnRpZmllciwgUGFzc1Jl ZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbGlzdFN0eWxlLAorICAgICAgICBQYXNzUmVmUHRyPENT U1ByaW1pdGl2ZVZhbHVlPiBzZXBhcmF0b3IpCisgICAgICAgIDogbV9pZGVudGlmaWVyKGlkZW50 aWZpZXIpLCBtX2xpc3RTdHlsZShsaXN0U3R5bGUpLCBtX3NlcGFyYXRvcihzZXBhcmF0b3IpIHsg fQorICAgIH5Db3VudGVyKCkgeyB9CiAKLXByaXZhdGU6Ci0gICAgU3RyaW5nIG1faWRlbnRpZmll cjsKLSAgICBTdHJpbmcgbV9saXN0U3R5bGU7Ci0gICAgU3RyaW5nIG1fc2VwYXJhdG9yOwotfTsK KyAgICBTdHJpbmcgaWRlbnRpZmllcigpIGNvbnN0IHsgcmV0dXJuIG1faWRlbnRpZmllciA/IG1f aWRlbnRpZmllci0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5nIGxp c3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlID8gbV9saXN0U3R5bGUtPmdldFN0 cmluZ1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQorICAgIFN0cmluZyBzZXBhcmF0b3IoKSBjb25zdCB7 IHJldHVybiBtX3NlcGFyYXRvciA/IG1fc2VwYXJhdG9yLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3Ry aW5nKCk7IH0KIAotfSAvLyBuYW1lc3BhY2UKKyAgICBpbnQgbGlzdFN0eWxlTnVtYmVyKCkgY29u c3QgeyByZXR1cm4gbV9saXN0U3R5bGUgPyAoaW50KSBtX2xpc3RTdHlsZS0+Z2V0RmxvYXRWYWx1 ZSgpIDogMDsgfQorICAgIAorICAgIHZvaWQgc2V0SWRlbnRpZmllcihQYXNzUmVmUHRyPENTU1By aW1pdGl2ZVZhbHVlPiBpZGVudGlmaWVyKSB7IG1faWRlbnRpZmllciA9IGlkZW50aWZpZXI7IH0K KyAgICB2b2lkIHNldExpc3RTdHlsZShQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0 U3R5bGUpIHsgbV9saXN0U3R5bGUgPSBsaXN0U3R5bGU7IH0KKyAgICB2b2lkIHNldFNlcGFyYXRv cihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBzZXBhcmF0b3IpIHsgbV9zZXBhcmF0b3Ig PSBzZXBhcmF0b3I7IH0KKyAKK3Byb3RlY3RlZDoKKyAgICBSZWZQdHI8Q1NTUHJpbWl0aXZlVmFs dWU+IG1faWRlbnRpZmllcjsgLy8gU3RyaW5nCisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBtX2xpc3RTdHlsZTsgIC8vIGludAorICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbV9z ZXBhcmF0b3I7ICAvLyBTdHJpbmcKKyB9OwogCit9IC8vbmFtZXNwYWNlCisKICNlbmRpZgpJbmRl eDogY3NzL2Nzc3BhcnNlci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5jcHAJKHJl dmlzaW9uIDE2NTI4KQorKysgY3NzL2Nzc3BhcnNlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQy LDYgKzQyLDcgQEAKICNpbmNsdWRlICJDU1NRdWlya1ByaW1pdGl2ZVZhbHVlLmgiCiAjaW5jbHVk ZSAiQ1NTVmFsdWVLZXl3b3Jkcy5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlTGlzdC5oIgorI2luY2x1 ZGUgIkNvdW50ZXIuaCIKICNpbmNsdWRlICJEYXNoYm9hcmRSZWdpb24uaCIKICNpbmNsdWRlICJE b2N1bWVudC5oIgogI2luY2x1ZGUgIkZvbnRGYW1pbHlWYWx1ZS5oIgpAQCAtMzM0LDcgKzMzNSw3 IEBACiB9CiAKIAotdm9pZCBDU1NQYXJzZXI6OmFkZFByb3BlcnR5KGludCBwcm9wSWQsIENTU1Zh bHVlICp2YWx1ZSwgYm9vbCBpbXBvcnRhbnQpCit2b2lkIENTU1BhcnNlcjo6YWRkUHJvcGVydHko aW50IHByb3BJZCwgUGFzc1JlZlB0cjxDU1NWYWx1ZT4gdmFsdWUsIGJvb2wgaW1wb3J0YW50KQog ewogICAgIENTU1Byb3BlcnR5ICpwcm9wID0gbmV3IENTU1Byb3BlcnR5KHByb3BJZCwgdmFsdWUs IGltcG9ydGFudCwgbV9jdXJyZW50U2hvcnRoYW5kLCBtX2ltcGxpY2l0U2hvcnRoYW5kKTsKICAg ICBpZiAobnVtUGFyc2VkUHJvcGVydGllcyA+PSBtYXhQYXJzZWRQcm9wZXJ0aWVzKSB7CkBAIC04 NzAsNiArODcxLDE2IEBACiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIHZhbGlkX3ByaW1pdGl2 ZSA9ICghaWQgJiYgdmFsaWRVbml0KHZhbHVlLCBGTnVtYmVyfEZMZW5ndGh8RlBlcmNlbnQsIHN0 cmljdCkpOwogICAgICAgICBicmVhazsKKyAgICBjYXNlIENTU19QUk9QX0NPVU5URVJfSU5DUkVN RU5UOiAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwgbm9uZSB8IGluaGVyaXQK KyAgICAgICAgaWYgKGlkICE9IENTU19WQUxfTk9ORSkKKyAgICAgICAgICAgIHJldHVybiBwYXJz ZUNvdW50ZXIocHJvcElkLCAxLCBpbXBvcnRhbnQpOworICAgICAgICB2YWxpZF9wcmltaXRpdmUg PSB0cnVlOworICAgICAgICBicmVhazsKKyAgICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVSX1JFU0VU OiAgICAgICAgLy8gWyA8aWRlbnRpZmllcj4gPGludGVnZXI+PyBdKyB8IG5vbmUgfCBpbmhlcml0 CisgICAgICAgIGlmIChpZCAhPSBDU1NfVkFMX05PTkUpCisgICAgICAgICAgICByZXR1cm4gcGFy c2VDb3VudGVyKHByb3BJZCwgMCwgaW1wb3J0YW50KTsKKyAgICAgICAgdmFsaWRfcHJpbWl0aXZl ID0gdHJ1ZTsKKyAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBDU1NfUFJPUF9GT05UX0ZBTUlMWToK ICAgICAgICAgLy8gW1sgPGZhbWlseS1uYW1lPiB8IDxnZW5lcmljLWZhbWlseT4gXSxdKiBbPGZh bWlseS1uYW1lPiB8IDxnZW5lcmljLWZhbWlseT5dIHwgaW5oZXJpdAogICAgIHsKQEAgLTE1MjMs MjggKzE1MzQsMzggQEAKIC8vIFsgPHN0cmluZz4gfCBhdHRyKFgpIHwgb3Blbi1xdW90ZSB8IGNs b3NlLXF1b3RlIHwgbm8tb3Blbi1xdW90ZSB8IG5vLWNsb3NlLXF1b3RlIF0rIHwgaW5oZXJpdAog Ym9vbCBDU1NQYXJzZXI6OnBhcnNlQ29udGVudChpbnQgcHJvcElkLCBib29sIGltcG9ydGFudCkK IHsKLSAgICBDU1NWYWx1ZUxpc3QqIHZhbHVlcyA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgUmVm UHRyPENTU1ZhbHVlTGlzdD4gdmFsdWVzID0gbmV3IENTU1ZhbHVlTGlzdDsKIAogICAgIHdoaWxl IChWYWx1ZSogdmFsID0gdmFsdWVMaXN0LT5jdXJyZW50KCkpIHsKLSAgICAgICAgQ1NTVmFsdWUq IHBhcnNlZFZhbHVlID0gMDsKKyAgICAgICAgUmVmUHRyPENTU1ZhbHVlPiBwYXJzZWRWYWx1ZTsK ICAgICAgICAgaWYgKHZhbC0+dW5pdCA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgewog ICAgICAgICAgICAgLy8gdXJsCiAgICAgICAgICAgICBTdHJpbmcgdmFsdWUgPSBwYXJzZVVSTChk b21TdHJpbmcodmFsLT5zdHJpbmcpKTsKICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENT U0ltYWdlVmFsdWUoCiAgICAgICAgICAgICAgICAgU3RyaW5nKEtVUkwoc3R5bGVFbGVtZW50LT5i YXNlVVJMKCkuZGVwcmVjYXRlZFN0cmluZygpLCB2YWx1ZS5kZXByZWNhdGVkU3RyaW5nKCkpLnVy bCgpKSwgc3R5bGVFbGVtZW50KTsKICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnVuaXQgPT0gVmFs dWU6OkZ1bmN0aW9uKSB7Ci0gICAgICAgICAgICAvLyBhdHRyKFgpCisgICAgICAgICAgICAvLyBh dHRyKFgpIHwgY291bnRlcihYIFssWV0pIHwgY291bnRlcnMoWCwgWSwgWyxaXSkKICAgICAgICAg ICAgIFZhbHVlTGlzdCAqYXJncyA9IHZhbC0+ZnVuY3Rpb24tPmFyZ3M7CiAgICAgICAgICAgICBT dHJpbmcgZm5hbWUgPSBkb21TdHJpbmcodmFsLT5mdW5jdGlvbi0+bmFtZSkubG93ZXIoKTsKLSAg ICAgICAgICAgIGlmIChmbmFtZSAhPSAiYXR0cigiIHx8ICFhcmdzKQorICAgICAgICAgICAgaWYg KCFhcmdzKQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAgICAgICAgIGlmIChh cmdzLT5zaXplKCkgIT0gMSkKKyAgICAgICAgICAgIGlmIChmbmFtZSA9PSAiYXR0cigiKSB7Cisg ICAgICAgICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAgICAgICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICAgICAgVmFsdWUqIGEgPSBhcmdzLT5jdXJyZW50 KCk7CisgICAgICAgICAgICAgICAgU3RyaW5nIGF0dHJOYW1lID0gZG9tU3RyaW5nKGEtPnN0cmlu Zyk7CisgICAgICAgICAgICAgICAgaWYgKGRvY3VtZW50KCktPmlzSFRNTERvY3VtZW50KCkpCisg ICAgICAgICAgICAgICAgICAgIGF0dHJOYW1lID0gYXR0ck5hbWUubG93ZXIoKTsKKyAgICAgICAg ICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShhdHRyTmFtZSwgQ1NT UHJpbWl0aXZlVmFsdWU6OkNTU19BVFRSKTsKKyAgICAgICAgICAgIH0gZWxzZSBpZiAoZm5hbWUg PT0gImNvdW50ZXIoIikgeworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3Vu dGVyQ29udGVudChhcmdzLCBmYWxzZSk7CisgICAgICAgICAgICAgICAgaWYgKCFwYXJzZWRWYWx1 ZSkgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgfSBlbHNlIGlmIChmbmFtZSA9PSAiY291bnRl cnMoIikgeworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gcGFyc2VDb3VudGVyQ29udGVu dChhcmdzLCB0cnVlKTsKKyAgICAgICAgICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKQorICAgICAg ICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9IGVsc2UKICAgICAgICAg ICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgICAgICBWYWx1ZSAqYSA9IGFyZ3MtPmN1cnJl bnQoKTsKLSAgICAgICAgICAgIFN0cmluZyBhdHRyTmFtZSA9IGRvbVN0cmluZyhhLT5zdHJpbmcp OwotICAgICAgICAgICAgaWYgKGRvY3VtZW50KCktPmlzSFRNTERvY3VtZW50KCkpCi0gICAgICAg ICAgICAgICAgYXR0ck5hbWUgPSBhdHRyTmFtZS5sb3dlcigpOwotICAgICAgICAgICAgcGFyc2Vk VmFsdWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoYXR0ck5hbWUsIENTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfQVRUUik7CiAgICAgICAgIH0gZWxzZSBpZiAodmFsLT51bml0ID09IENTU1ByaW1pdGl2 ZVZhbHVlOjpDU1NfSURFTlQpIHsKICAgICAgICAgICAgIC8vIG9wZW4tcXVvdGUKICAgICAgICAg ICAgIC8vIGNsb3NlLXF1b3RlCkBAIC0xNTU2LDE3ICsxNTc3LDE2IEBACiAgICAgICAgIH0KICAg ICAgICAgaWYgKCFwYXJzZWRWYWx1ZSkKICAgICAgICAgICAgIGJyZWFrOwotICAgICAgICB2YWx1 ZXMtPmFwcGVuZChwYXJzZWRWYWx1ZSk7CisgICAgICAgIHZhbHVlcy0+YXBwZW5kKHBhcnNlZFZh bHVlLnJlbGVhc2UoKSk7CiAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOwogICAgIH0KIAogICAg IGlmICh2YWx1ZXMtPmxlbmd0aCgpKSB7Ci0gICAgICAgIGFkZFByb3BlcnR5KHByb3BJZCwgdmFs dWVzLCBpbXBvcnRhbnQpOworICAgICAgICBhZGRQcm9wZXJ0eShwcm9wSWQsIHZhbHVlcy5yZWxl YXNlKCksIGltcG9ydGFudCk7CiAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgpOwogICAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICB9CiAKLSAgICBkZWxldGUgdmFsdWVzOwogICAgIHJldHVybiBmYWxz ZTsKIH0KIApAQCAtMTk3OCw2ICsxOTk4LDU5IEBACiB9CiAjZW5kaWYKIAorUGFzc1JlZlB0cjxD U1NWYWx1ZT4gQ1NTUGFyc2VyOjpwYXJzZUNvdW50ZXJDb250ZW50KFZhbHVlTGlzdCAqYXJncywg Ym9vbCBjb3VudGVycykKK3sKKyAgICB1bnNpZ25lZCBudW1BcmdzID0gYXJncy0+c2l6ZSgpOwor ICAgIGlmIChjb3VudGVycyAmJiBudW1BcmdzICE9IDMgJiYgbnVtQXJncyAhPSA1KQorICAgICAg ICByZXR1cm4gMDsKKyAgICBpZiAoIWNvdW50ZXJzICYmIG51bUFyZ3MgIT0gMSAmJiBudW1Bcmdz ICE9IDMpCisgICAgICAgIHJldHVybiAwOworICAgIAorICAgIFZhbHVlICppID0gYXJncy0+Y3Vy cmVudCgpOworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gaWRlbnRpZmllciA9IG5ldyBD U1NQcmltaXRpdmVWYWx1ZShkb21TdHJpbmcoaS0+c3RyaW5nKSwKKyAgICAgICAgQ1NTUHJpbWl0 aXZlVmFsdWU6OkNTU19TVFJJTkcpOworCisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBz ZXBhcmF0b3I7CisgICAgaWYgKCFjb3VudGVycykKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENT U1ByaW1pdGl2ZVZhbHVlKFN0cmluZygpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7 CisgICAgZWxzZSB7CisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51 bml0ICE9IFZhbHVlOjpPcGVyYXRvciB8fCBpLT5pVmFsdWUgIT0gJywnKQorICAgICAgICAgICAg cmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBpID0gYXJncy0+bmV4dCgpOworICAgICAgICBp ZiAoaS0+dW5pdCAhPSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORykKKyAgICAgICAgICAg IHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgc2VwYXJhdG9yID0gbmV3IENTU1ByaW1pdGl2 ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLCAoQ1NTUHJpbWl0aXZlVmFsdWU6OlVuaXRUeXBl cykgaS0+dW5pdCk7CisgICAgfQorCisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0 U3R5bGU7CisgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICBpZiAoIWkpIC8vIE1ha2UgdGhlIGxp c3Qgc3R5bGUgZGVmYXVsdCBkZWNpbWFsCisgICAgICAgIGxpc3RTdHlsZSA9IG5ldyBDU1NQcmlt aXRpdmVWYWx1ZShDU1NfVkFMX0RFQ0lNQUwgLSBDU1NfVkFMX0RJU0MsIENTU1ByaW1pdGl2ZVZh bHVlOjpDU1NfTlVNQkVSKTsKKyAgICBlbHNlIHsKKyAgICAgICAgaWYgKGktPnVuaXQgIT0gVmFs dWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcpCisgICAgICAgICAgICByZXR1cm4gMDsK KyAgICAgICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51bml0 ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpCisgICAgICAgICAgICByZXR1cm4gMDsK KyAgICAgICAgCisgICAgICAgIHNob3J0IGxzID0gMDsKKyAgICAgICAgaWYgKGktPmlkID09IENT U19WQUxfTk9ORSkKKyAgICAgICAgICAgIGxzID0gQ1NTX1ZBTF9LQVRBS0FOQV9JUk9IQSAtIENT U19WQUxfRElTQyArIDE7CisgICAgICAgIGVsc2UgaWYgKGktPmlkID49IENTU19WQUxfRElTQyAm JiBpLT5pZCA8PSBDU1NfVkFMX0tBVEFLQU5BX0lST0hBKQorICAgICAgICAgICAgbHMgPSBpLT5p ZCAtIENTU19WQUxfRElTQzsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgcmV0dXJuIDA7CisK KyAgICAgICAgbGlzdFN0eWxlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGxzLCAoQ1NTUHJpbWl0 aXZlVmFsdWU6OlVuaXRUeXBlcykgaS0+dW5pdCk7CisgICAgfQorCisgICAgcmV0dXJuIG5ldyBD U1NQcmltaXRpdmVWYWx1ZShuZXcgQ291bnRlcihpZGVudGlmaWVyLnJlbGVhc2UoKSwgbGlzdFN0 eWxlLnJlbGVhc2UoKSwgc2VwYXJhdG9yLnJlbGVhc2UoKSkpOworfQorCiBib29sIENTU1BhcnNl cjo6cGFyc2VTaGFwZShpbnQgcHJvcElkLCBib29sIGltcG9ydGFudCkKIHsKICAgICBWYWx1ZSAq dmFsdWUgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKTsKQEAgLTI2NzYsNiArMjc0OSw0OCBAQAogICAg IHJldHVybiBjb250ZXh0LmZhaWxlZCgpOwogfQogCitib29sIENTU1BhcnNlcjo6cGFyc2VDb3Vu dGVyKGludCBwcm9wSWQsIGludCBkZWZhdWx0VmFsdWUsIGJvb2wgaW1wb3J0YW50KQoreworICAg IGVudW0geyBJRCwgVkFMIH0gc3RhdGUgPSBJRDsKKworICAgIFJlZlB0cjxDU1NWYWx1ZUxpc3Q+ IGxpc3QgPSBuZXcgQ1NTVmFsdWVMaXN0OworICAgIFJlZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4g Y291bnRlck5hbWU7CisgICAgCisgICAgd2hpbGUgKHRydWUpIHsKKyAgICAgICAgVmFsdWUqIHZh bCA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOworICAgICAgICBzd2l0Y2ggKHN0YXRlKSB7CisgICAg ICAgICAgICBjYXNlIElEOgorICAgICAgICAgICAgICAgIGlmICh2YWwgJiYgdmFsLT51bml0ID09 IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfSURFTlQpIHsKKyAgICAgICAgICAgICAgICAgICAgY291 bnRlck5hbWUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5nKHZhbC0+c3RyaW5nKSwg Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19TVFJJTkcpOworICAgICAgICAgICAgICAgICAgICBzdGF0 ZSA9IFZBTDsKKyAgICAgICAgICAgICAgICAgICAgdmFsdWVMaXN0LT5uZXh0KCk7CisgICAgICAg ICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgICAgIGNhc2UgVkFMOiB7CisgICAgICAgICAgICAgICAgaW50IGkg PSBkZWZhdWx0VmFsdWU7CisgICAgICAgICAgICAgICAgaWYgKHZhbCAmJiB2YWwtPnVuaXQgPT0g Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpIHsKKyAgICAgICAgICAgICAgICAgICAgaSA9 IChpbnQpdmFsLT5mVmFsdWU7CisgICAgICAgICAgICAgICAgICAgIHZhbHVlTGlzdC0+bmV4dCgp OworICAgICAgICAgICAgICAgIH0KKworICAgICAgICAgICAgICAgIGxpc3QtPmFwcGVuZChuZXcg Q1NTUHJpbWl0aXZlVmFsdWUobmV3IFBhaXIoY291bnRlck5hbWUucmVsZWFzZSgpLAorICAgICAg ICAgICAgICAgICAgICBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoaSwgQ1NTUHJpbWl0aXZlVmFsdWU6 OkNTU19OVU1CRVIpKSkpOworICAgICAgICAgICAgICAgIHN0YXRlID0gSUQ7CisgICAgICAgICAg ICAgICAgY29udGludWU7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgYnJlYWs7 CisgICAgfQorICAgIAorICAgIGlmIChsaXN0LT5sZW5ndGgoKSA+IDApIHsKKyAgICAgICAgYWRk UHJvcGVydHkocHJvcElkLCBsaXN0LnJlbGVhc2UoKSwgaW1wb3J0YW50KTsKKyAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOworfQorCiAjaWZkZWYgQ1NTX0RF QlVHCiAKIHN0YXRpYyBpbmxpbmUgaW50IHl5ZXJyb3IoY29uc3QgY2hhciAqc3RyKQo= 10869 2006-10-02 11:59:03 -0700 2006-10-02 12:11:03 -0700 Yet another patch mondayay.txt text/plain 72232 bdakin SW5kZXg6IHBsYXRmb3JtL1N0cmluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vU3RyaW5n LmNwcAkocmV2aXNpb24gMTY3MTcpCisrKyBwbGF0Zm9ybS9TdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xNTcsNiArMTU3LDE0IEBACiAgICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ci5tX2lt cGwuZ2V0KCksIHBvcyk7CiB9CiAKK3ZvaWQgU3RyaW5nOjppbnNlcnQoY29uc3QgVUNoYXIqIHN0 ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpCit7CisgICAgaWYgKCFtX2ltcGwpCisg ICAgICAgIG1faW1wbCA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICBlbHNlCisg ICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ciwgbGVuZ3RoLCBwb3MpOworfQorCiBVQ2hhciBTdHJp bmc6Om9wZXJhdG9yW10odW5zaWduZWQgaSkgY29uc3QKIHsKICAgICBpZiAoIW1faW1wbCB8fCBp ID49IG1faW1wbC0+bGVuZ3RoKCkpCkluZGV4OiBwbGF0Zm9ybS9QbGF0Zm9ybVN0cmluZy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHBsYXRmb3JtL1BsYXRmb3JtU3RyaW5nLmgJKHJldmlzaW9uIDE2NzE3KQor KysgcGxhdGZvcm0vUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5KQpAQCAtOTEsNiArOTEs NyBAQAogICAgIHZvaWQgYXBwZW5kKGNoYXIpOwogICAgIHZvaWQgYXBwZW5kKFVDaGFyKTsKICAg ICB2b2lkIGluc2VydChjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBwb3MpOworICAgIHZvaWQgaW5z ZXJ0KGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpOwogCiAgICAg U3RyaW5nJiByZXBsYWNlKFVDaGFyIGEsIFVDaGFyIGIpIHsgaWYgKG1faW1wbCkgbV9pbXBsID0g bV9pbXBsLT5yZXBsYWNlKGEsIGIpOyByZXR1cm4gKnRoaXM7IH0KICAgICBTdHJpbmcmIHJlcGxh Y2UoVUNoYXIgYSwgY29uc3QgU3RyaW5nJiBiKSB7IGlmIChtX2ltcGwpIG1faW1wbCA9IG1faW1w bC0+cmVwbGFjZShhLCBiLmltcGwoKSk7IHJldHVybiAqdGhpczsgfQpJbmRleDogcGxhdGZvcm0v U3RyaW5nSW1wbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuaAkocmV2aXNp b24gMTY3MTcpCisrKyBwbGF0Zm9ybS9TdHJpbmdJbXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTgz LDYgKzgzLDcgQEAKICAgICB2b2lkIGFwcGVuZChjaGFyKTsKICAgICB2b2lkIGFwcGVuZChVQ2hh cik7CiAgICAgdm9pZCBpbnNlcnQoY29uc3QgU3RyaW5nSW1wbCosIHVuc2lnbmVkIHBvcyk7Cisg ICAgdm9pZCBpbnNlcnQoY29uc3QgVUNoYXIqIHN0ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBwb3MpOwogICAgIHZvaWQgdHJ1bmNhdGUoaW50IGxlbik7CiAgICAgdm9pZCByZW1vdmUodW5z aWduZWQgcG9zLCBpbnQgbGVuID0gMSk7CiAKSW5kZXg6IHBsYXRmb3JtL1N0cmluZ0ltcGwuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCShyZXZpc2lvbiAxNjcxNykK KysrIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDAsNiArMjAw LDI3IEBACiAgICAgfQogfQogCit2b2lkIFN0cmluZ0ltcGw6Omluc2VydChjb25zdCBVQ2hhciog c3RyLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIHBvcykKK3sKKyAgICBhc3NlcnQoIW1faW5U YWJsZSk7CisgICAgaWYgKHBvcyA+PSBtX2xlbmd0aCkgeworICAgICAgICBSZWZQdHI8U3RyaW5n SW1wbD4gcyA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICAgICAgYXBwZW5kKHMu Z2V0KCkpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlmIChzdHIgJiYgbGVuZ3RoICE9 IDApIHsKKyAgICAgICAgc2l6ZV90IG5ld2xlbiA9IG1fbGVuZ3RoICsgbGVuZ3RoOworICAgICAg ICBVQ2hhciogYyA9IG5ld1VDaGFyVmVjdG9yKG5ld2xlbik7CisgICAgICAgIG1lbWNweShjLCBt X2RhdGEsIHBvcyAqIHNpemVvZihVQ2hhcikpOworICAgICAgICBtZW1jcHkoYyArIHBvcywgc3Ry LCBsZW5ndGggKiBzaXplb2YoVUNoYXIpKTsKKyAgICAgICAgbWVtY3B5KGMgKyBwb3MgKyBsZW5n dGgsIG1fZGF0YSArIHBvcywgKG1fbGVuZ3RoIC0gcG9zKSAqIHNpemVvZihVQ2hhcikpOworICAg ICAgICBkZWxldGVVQ2hhclZlY3RvcihtX2RhdGEpOworICAgICAgICBtX2RhdGEgPSBjOworICAg ICAgICBtX2xlbmd0aCA9IG5ld2xlbjsKKyAgICAgICAgbV9oYXNUZXJtaW5hdGluZ051bGxDaGFy YWN0ZXIgPSBmYWxzZTsKKyAgICB9Cit9CisKIHZvaWQgU3RyaW5nSW1wbDo6dHJ1bmNhdGUoaW50 IGxlbikKIHsKICAgICBhc3NlcnQoIW1faW5UYWJsZSk7CkluZGV4OiByZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkocmV2 aXNpb24gMTY3MTcpCisrKyByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9s bEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0 b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVlbGxlckBr ZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2Rl QGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBD b21wdXRlciwgSW5jLgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTI5LDYgKzMwLDggQEAKICNpbmNsdWRlICJB WE9iamVjdENhY2hlLmgiIAogI2luY2x1ZGUgIkFmZmluZVRyYW5zZm9ybS5oIgogI2luY2x1ZGUg IkNhY2hlZEltYWdlLmgiCisjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKKyNpbmNsdWRlICJDb3Vu dGVyUmVzZXROb2RlLmgiCiAjaW5jbHVkZSAiRGVjb2Rlci5oIgogI2luY2x1ZGUgIkRvY3VtZW50 LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgpAQCAtMzcsNiArNDAsNyBAQAogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCisjaW5jbHVkZSAiSFRNTE9MaXN0RWxlbWVudC5oIgogI2luY2x1ZGUgIlBvc2l0aW9uLmgi CiAjaW5jbHVkZSAiUmVuZGVyQXJlbmEuaCIKICNpbmNsdWRlICJSZW5kZXJGbGV4aWJsZUJveC5o IgpAQCAtNjUsNiArNjksMTUgQEAKIHN0YXRpYyB2b2lkICpiYXNlT2ZSZW5kZXJPYmplY3RCZWlu Z0RlbGV0ZWQ7CiAjZW5kaWYKIAordHlwZWRlZiBIYXNoTWFwPFN0cmluZywgQ291bnRlck5vZGUq PiBDb3VudGVyTm9kZU1hcDsKK3R5cGVkZWYgSGFzaE1hcDxjb25zdCBSZW5kZXJPYmplY3QqLCBD b3VudGVyTm9kZU1hcCo+IFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwczsKKworc3RhdGlj IFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyogZ2V0UmVuZGVyT2JqZWN0c1RvQ291bnRl ck5vZGVNYXBzKCkKK3sKKyAgICBzdGF0aWMgUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBz IG9iamVjdHNNYXA7CisgICAgcmV0dXJuICZvYmplY3RzTWFwOworfQorCiB2b2lkKiBSZW5kZXJP YmplY3Q6Om9wZXJhdG9yIG5ldyhzaXplX3Qgc3osIFJlbmRlckFyZW5hKiByZW5kZXJBcmVuYSkg dGhyb3coKQogewogICAgIHJldHVybiByZW5kZXJBcmVuYS0+YWxsb2NhdGUoc3opOwpAQCAtMTc3 LDcgKzE5MCw4IEBACiAKIG1fcmVwbGFjZWQoIGZhbHNlICksCiBtX2lzRHJhZ2dpbmcoIGZhbHNl ICksCi1tX2hhc092ZXJmbG93Q2xpcChmYWxzZSkKK21faGFzT3ZlcmZsb3dDbGlwKGZhbHNlKSwK K21faGFzQ291bnRlck5vZGVNYXAoZmFsc2UpCiB7CiAjaWZuZGVmIE5ERUJVRwogICAgICsrUmVu ZGVyT2JqZWN0Q291bnRlcjo6Y291bnQ7CkBAIC0yNDA2LDYgKzI0MjAsMjEgQEAKIAogdm9pZCBS ZW5kZXJPYmplY3Q6OmRlc3Ryb3koKQogeworICAgIGlmIChtX2hhc0NvdW50ZXJOb2RlTWFwKSB7 CisgICAgICAgIFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyogb2JqZWN0c01hcCA9IGdl dFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcygpOworICAgICAgICBpZiAoQ291bnRlck5v ZGVNYXAqIGNvdW50ZXJOb2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKSkgeworICAgICAg ICAgICAgQ291bnRlck5vZGVNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGNvdW50ZXJOb2Rlc01h cC0+ZW5kKCk7CisgICAgICAgICAgICBmb3IgKENvdW50ZXJOb2RlTWFwOjpjb25zdF9pdGVyYXRv ciBpdCA9IGNvdW50ZXJOb2Rlc01hcC0+YmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAg ICAgICAgICAgICAgQ291bnRlck5vZGUqIGNvdW50ZXJOb2RlID0gaXQtPnNlY29uZDsKKyAgICAg ICAgICAgICAgICBjb3VudGVyTm9kZS0+cmVtb3ZlKCk7CisgICAgICAgICAgICAgICAgZGVsZXRl IGNvdW50ZXJOb2RlOworICAgICAgICAgICAgICAgIGNvdW50ZXJOb2RlID0gMDsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIG9iamVjdHNNYXAtPnJlbW92ZSh0aGlzKTsKKyAgICAgICAgICAg IGRlbGV0ZSBjb3VudGVyTm9kZXNNYXA7CisgICAgICAgIH0KKyAgICB9CisgICAgCiAgICAgZG9j dW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5yZW1vdmUodGhpcyk7CiAKICAgICAvLyBCeSBkZWZh dWx0IG5vIHJlZi1jb3VudGluZy4gUmVuZGVyV2lkZ2V0OjpkZXN0cm95KCkgZG9lc24ndCBjYWxs CkBAIC0yODQ4LDYgKzI4NzcsMTI5IEBACiAgICAgcmV0dXJuIChhdm9pZHNGbG9hdHMoKSAmJiAo c3R5bGUoKS0+d2lkdGgoKS5pc0F1dG8oKSB8fCBpc0hSKCkgfHwgKHN0eWxlKCktPmh0bWxIYWNr cygpICYmICFpc1RhYmxlKCkpKSk7CiB9CiAKK0NvdW50ZXJOb2RlKiBSZW5kZXJPYmplY3Q6OmZp bmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUsIGJvb2wgd2lsbE5lZWRMYXlvdXQs CisgICAgYm9vbCB1c2VzU2VwYXJhdG9yLCBib29sIGNyZWF0ZUlmTm90Rm91bmQpCit7CisgICAg aWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIFJlbmRlck9iamVjdHNUb0Nv dW50ZXJOb2RlTWFwcyogb2JqZWN0c01hcCA9IGdldFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2Rl TWFwcygpOworICAgIENvdW50ZXJOb2RlKiBuZXdOb2RlID0gMDsKKyAgICBpZiAoQ291bnRlck5v ZGVNYXAqIGNvdW50ZXJOb2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKSkKKyAgICAgICAg aWYgKGNvdW50ZXJOb2Rlc01hcCkKKyAgICAgICAgICAgIG5ld05vZGUgPSBjb3VudGVyTm9kZXNN YXAtPmdldChjb3VudGVyTmFtZSk7CisgICAgICAgIAorICAgIGlmIChuZXdOb2RlKQorICAgICAg ICByZXR1cm4gbmV3Tm9kZTsKKworICAgIGludCB2YWwgPSAwOworICAgIGlmIChzdHlsZSgpLT5o YXNDb3VudGVyUmVzZXQoY291bnRlck5hbWUpIHx8IGlzUm9vdCgpKSB7CisgICAgICAgIG5ld05v ZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0aGlzKTsKKyAgICAgICAgdmFsID0gc3R5bGUoKS0+ Y291bnRlclJlc2V0KGNvdW50ZXJOYW1lKTsKKyAgICAgICAgaWYgKHN0eWxlKCktPmhhc0NvdW50 ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpKQorICAgICAgICAgICAgdmFsICs9IHN0eWxlKCktPmNv dW50ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpOworICAgICAgICBuZXdOb2RlLT5zZXRWYWx1ZSh2 YWwpOworICAgIH0gZWxzZSBpZiAoc3R5bGUoKS0+aGFzQ291bnRlckluY3JlbWVudChjb3VudGVy TmFtZSkpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAg ICAgbmV3Tm9kZS0+c2V0VmFsdWUoc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChjb3VudGVyTmFt ZSkpOworICAgIH0gZWxzZSBpZiAoY291bnRlck5hbWUgPT0gImxpc3QtaXRlbSIpIHsKKyAgICAg ICAgaWYgKGlzTGlzdEl0ZW0oKSkgeworICAgICAgICAgICAgaWYgKGVsZW1lbnQoKSkgeworICAg ICAgICAgICAgICAgIFN0cmluZyB2ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KGVsZW1lbnQoKSkt PmdldEF0dHJpYnV0ZSgidmFsdWUiKTsKKyAgICAgICAgICAgICAgICBpZiAoIXYuaXNFbXB0eSgp KSB7CisgICAgICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0 aGlzKTsKKyAgICAgICAgICAgICAgICAgICAgdmFsID0gdi50b0ludCgpOworICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIH0gCisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmICghbmV3 Tm9kZSkgeworICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUodGhpcyk7 CisgICAgICAgICAgICAgICAgdmFsID0gMTsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAg bmV3Tm9kZS0+c2V0VmFsdWUodmFsKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVtZW50KCkgJiYg ZWxlbWVudCgpLT5oYXNUYWdOYW1lKG9sVGFnKSkgeworICAgICAgICAgICAgbmV3Tm9kZSA9IG5l dyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgbmV3Tm9kZS0+c2V0VmFsdWUo c3RhdGljX2Nhc3Q8SFRNTE9MaXN0RWxlbWVudCo+KGVsZW1lbnQoKSktPnN0YXJ0KCkpOworICAg ICAgICB9IGVsc2UgaWYgKGVsZW1lbnQoKSAmJgorICAgICAgICAgICAgKGVsZW1lbnQoKS0+aGFz VGFnTmFtZSh1bFRhZykgfHwKKyAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUobWVu dVRhZykgfHwKKyAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUoZGlyVGFnKSkpIHsK KyAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0aGlzKTsKKyAgICAg ICAgICAgIG5ld05vZGUtPnNldFZhbHVlKDApOworICAgICAgICB9CisgICAgfSAKKyAgICAKKyAg ICBpZiAoIW5ld05vZGUgJiYgIWNyZWF0ZUlmTm90Rm91bmQpCisgICAgICAgIHJldHVybiAwOwor ICAgIGVsc2UgaWYgKCFuZXdOb2RlKSB7CisgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5v ZGUodGhpcyk7CisgICAgICAgIG5ld05vZGUtPnNldFZhbHVlKDApOworICAgIH0KKworICAgIGlm ICh3aWxsTmVlZExheW91dCkKKyAgICAgICAgbmV3Tm9kZS0+c2V0V2lsbE5lZWRMYXlvdXQoKTsK KyAgICBpZiAodXNlc1NlcGFyYXRvcikKKyAgICAgICAgbmV3Tm9kZS0+c2V0VXNlc1NlcGFyYXRv cigpOworCisgICAgQ291bnRlck5vZGVNYXAqIG5vZGVNYXA7CisgICAgaWYgKG1faGFzQ291bnRl ck5vZGVNYXApCisgICAgICAgIG5vZGVNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7CisgICAg ZWxzZSB7CisgICAgICAgIG5vZGVNYXAgPSBuZXcgQ291bnRlck5vZGVNYXA7CisgICAgICAgIG9i amVjdHNNYXAtPnNldCh0aGlzLCBub2RlTWFwKTsKKyAgICAgICAgbV9oYXNDb3VudGVyTm9kZU1h cCA9IHRydWU7CisgICAgfQorICAgIAorICAgIG5vZGVNYXAtPnNldChjb3VudGVyTmFtZSwgbmV3 Tm9kZSk7CisKKyAgICBpZiAoIWlzUm9vdCgpKSB7CisgICAgICAgIFJlbmRlck9iamVjdCogbiA9 ICFpc0xpc3RJdGVtKCkgJiYgcHJldmlvdXNTaWJsaW5nKCkKKyAgICAgICAgICAgID8gcHJldmlv dXNTaWJsaW5nKCktPnByZXZpb3VzU2libGluZygpIDogcHJldmlvdXNTaWJsaW5nKCk7CisKKyAg ICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnQgPSAwOworICAgICAgICBmb3IgKDsgbiAmJiAhY3Vy cmVudDsgbiA9IG4tPnByZXZpb3VzU2libGluZygpKQorICAgICAgICAgICAgY3VycmVudCA9IG4t PmZpbmRDb3VudGVyKGNvdW50ZXJOYW1lLCBmYWxzZSwgZmFsc2UsIGZhbHNlKTsKKyAgICAgICAg CisgICAgICAgIENvdW50ZXJOb2RlKiBsYXN0ID0gY3VycmVudDsKKyAgICAgICAgQ291bnRlck5v ZGUqIHNpYmxpbmcgPSBjdXJyZW50OworICAgICAgICBpZiAobGFzdCAmJiAhbmV3Tm9kZS0+aXNS ZXNldCgpKSB7CisgICAgICAgICAgICAvLyBGb3VuZCByZW5kZXItc2libGluZywgbm93IHNlYXJj aCBmb3IgbGF0ZXIgY291bnRlci1zaWJsaW5ncyBhbW9uZyBpdHMgcmVuZGVyLWNoaWxkcmVuCisg ICAgICAgICAgICBuID0gbi0+bGFzdENoaWxkKCk7CisgICAgICAgICAgICB3aGlsZSAobikgewor ICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBuLT5maW5kQ291bnRlcihjb3VudGVyTmFtZSwgZmFs c2UsIGZhbHNlLCBmYWxzZSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnQgJiYgKGxhc3Qt PnBhcmVudCgpID09IGN1cnJlbnQtPnBhcmVudCgpIHx8IHNpYmxpbmcgPT0gY3VycmVudC0+cGFy ZW50KCkpKSB7CisgICAgICAgICAgICAgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAgICAg ICAgICAgICAgICAvLyBJZiB0aGUgY3VycmVudCBjb3VudGVyIGlzIG5vdCB0aGUgbGFzdCwgc2Vh cmNoIGRlZXBlcgorICAgICAgICAgICAgICAgICAgICBpZiAoY3VycmVudC0+bmV4dFNpYmxpbmco KSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbiA9IG4tPmxhc3RDaGlsZCgpOworICAgICAg ICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIH0gZWxzZQor ICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAg ICAgICAgICAgIG4gPSBuLT5wcmV2aW91c1NpYmxpbmcoKTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIAorICAgICAgICAgICAgaWYgKHNpYmxpbmctPmlzUmVzZXQoKSkgeworICAgICAgICAg ICAgICAgIGlmIChsYXN0ICE9IHNpYmxpbmcpCisgICAgICAgICAgICAgICAgICAgIHNpYmxpbmct Pmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICAgICAgc2libGluZy0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAg ICAgICB9IGVsc2UKKyAgICAgICAgICAgICAgICBsYXN0LT5wYXJlbnQoKS0+aW5zZXJ0QWZ0ZXIo bmV3Tm9kZSwgbGFzdCk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAvLyBOb3RoaW5n IGZvdW5kIGFtb25nIHNpYmxpbmdzLCBsZXQgb3VyIHBhcmVudCBzZWFyY2gKKyAgICAgICAgICAg IGxhc3QgPSBwYXJlbnQoKS0+ZmluZENvdW50ZXIoY291bnRlck5hbWUsIGZhbHNlKTsKKyAgICAg ICAgICAgIGlmIChsYXN0LT5pc1Jlc2V0KCkpCisgICAgICAgICAgICAgICAgbGFzdC0+aW5zZXJ0 QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgbGFz dC0+cGFyZW50KCktPmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICB9CisgICAg fQorCisgICAgcmV0dXJuIG5ld05vZGU7Cit9CisKIFVDaGFyIFJlbmRlck9iamVjdDo6YmFja3Ns YXNoQXNDdXJyZW5jeVN5bWJvbCgpIGNvbnN0CiB7CiAgICAgaWYgKE5vZGUgKm5vZGUgPSBlbGVt ZW50KCkpCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5oCShyZXZpc2lvbiAxNjcxNykKKysrIHJlbmRlcmluZy9SZW5k ZXJPYmplY3QuaAkod29ya2luZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAo QykgMjAwMCBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAw IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAw IERpcmsgTXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFs bGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykg MjAwMywgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICoKICAqIFRoaXMg bGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK QEAgLTMxLDYgKzMyLDcgQEAKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlNj cm9sbEJhci5oIgogI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgorI2luY2x1ZGUgPHd0Zi9I YXNoTWFwLmg+CiAKIC8qCiAgKiAgVGhlIHBhaW50aW5nIG9mIGEgbGF5ZXIgb2NjdXJzIGluIHRo cmVlIGRpc3RpbmN0IHBoYXNlcy4gIEVhY2ggcGhhc2UgaW52b2x2ZXMKQEAgLTQ2LDYgKzQ4LDcg QEAKIGNsYXNzIEFmZmluZVRyYW5zZm9ybTsKIGNsYXNzIENvbGxhcHNlZEJvcmRlclZhbHVlOwog Y2xhc3MgQ29sb3I7CitjbGFzcyBDb3VudGVyTm9kZTsKIGNsYXNzIERvY3VtZW50OwogY2xhc3Mg RWxlbWVudDsKIGNsYXNzIEV2ZW50OwpAQCAtMTkzLDYgKzE5NiwxMCBAQAogICAgIHZpcnR1YWwg aW50IHN0YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBpbnQgc3RhdGlj WSgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAgICBDb3VudGVyTm9kZSogZmluZENvdW50 ZXIoY29uc3QgU3RyaW5nJiBjb3VudGVyTmFtZSwgYm9vbCB3aWxsTmVlZExheW91dCA9IGZhbHNl LAorICAgICAgICBib29sIHVzZXNTZXBhcmF0b3IgPSBmYWxzZSwgYm9vbCBjcmVhdGVJZk5vdEZv dW5kID0gdHJ1ZSk7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJlZSBtYW5pcHVs YXRpb24KICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAg ICB2aXJ0dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTQsNiArMjYxLDcg QEAKICAgICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CiAgICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0dXJuIGZhbHNl OyB9CiAgICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlzQm9keSgpIGNvbnN0OwpA QCAtOTMyLDggKzk0MCw5IEBACiAgICAgYm9vbCBtX2lzRHJhZ2dpbmcgICAgICAgICAgICAgICAg OiAxOwogICAgIAogICAgIGJvb2wgbV9oYXNPdmVyZmxvd0NsaXAgICAgICAgICAgIDogMTsKKyAg ICAKKyAgICBib29sIG1faGFzQ291bnRlck5vZGVNYXAgICAgICAgICA6IDE7CiAKLSAgICAvLyBu b3RlOiBkbyBub3QgYWRkIHVubmVjZXNzYXJ5IGJpdGZsYWdzLCB3ZSBoYXZlIDMyIGJpdCBhbHJl YWR5IQogICAgIGZyaWVuZCBjbGFzcyBSZW5kZXJMaXN0SXRlbTsKICAgICBmcmllbmQgY2xhc3Mg UmVuZGVyQ29udGFpbmVyOwogICAgIGZyaWVuZCBjbGFzcyBSZW5kZXJWaWV3OwpJbmRleDogcmVu ZGVyaW5nL1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291 bnRlci5oCShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNp b24gMCkKQEAgLTAsMCArMSw1NCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBI VE1MIHJlbmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQg QWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChD KSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUg c29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgor ICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRl ciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENP UFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAw MjExMS0xMzA3LCBVU0EuCisgKgorICovCisjaWZuZGVmIFJFTkRFUl9DT1VOVEVSX0hfCisjZGVm aW5lIFJFTkRFUl9DT1VOVEVSX0hfCisKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KKworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0IHsKKwor cHVibGljOgorICAgIFJlbmRlckNvdW50ZXIoTm9kZSosIENvdW50ZXJEYXRhKik7CisgICAgCisg ICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4gIlJlbmRl ckNvdW50ZXIiOyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1 cm4gdHJ1ZTsgfQorICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKTsKKyAgICB2aXJ0dWFsIHZvaWQg Y2FsY01pbk1heFdpZHRoKCk7CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIGNvbnZlcnRWYWx1ZVRv VHlwZShpbnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUpOworCisgICAgU3RyaW5n IG1faXRlbTsKKyAgICBDb3VudGVyRGF0YSogbV9jb3VudGVyOworICAgIENvdW50ZXJOb2RlKiBt X2NvdW50ZXJOb2RlOworfTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRl cmluZy9Db3VudGVyUmVzZXROb2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJS ZXNldE5vZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJ KHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNjIgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBv ZiB0aGUgSFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChD KSAyMDA1IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHly aWdodCAoQykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlm eSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisg KiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBl aXRoZXIKKyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBh bnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICogTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgor ICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUg ZmlsZSBDT1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3Rv biwgTUEgMDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZuZGVmIENvdW50ZXJfUmVzZXRfTm9k ZV9oXworI2RlZmluZSBDb3VudGVyX1Jlc2V0X05vZGVfaF8KKworI2luY2x1ZGUgIkNvdW50ZXJO b2RlLmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMg YSBjb3VudGVyLXRyZWUgdGhhdCBpcyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNv dW50ZXJzKCkgbG9va3VwLAorLy8gYW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdo ZW4gbm9kZXMgYXJlIGFkZGVkIG9yIHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkg Y291bnRlci1yZXNldCBhbmQgcm9vdCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5k ZXItdHJlZSBwYXJlbnRzCisvLyBhcmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8g SW1wbGVtZW50YXRpb24gb2YgY291bnRlci1yZXNldCBhbmQgcm9vdAorY2xhc3MgQ291bnRlclJl c2V0Tm9kZSA6IHB1YmxpYyBDb3VudGVyTm9kZSB7CisKK3B1YmxpYzoKKyAgICBDb3VudGVyUmVz ZXROb2RlKFJlbmRlck9iamVjdCopOworCisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogZmlyc3RD aGlsZCgpIGNvbnN0IHsgcmV0dXJuIG1fZmlyc3Q7IH07CisgICAgdmlydHVhbCBDb3VudGVyTm9k ZSogbGFzdENoaWxkKCkgY29uc3QgeyByZXR1cm4gbV9sYXN0OyB9OworICAgIHZpcnR1YWwgdm9p ZCBpbnNlcnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGls ZCk7CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZUNoaWxkIChDb3VudGVyTm9kZSopOworCisgICAg dmlydHVhbCBib29sIGlzUmVzZXQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9OworICAgIHZpcnR1 YWwgQ291bnRlck5vZGUqIHJlY291bnRBbmRHZXROZXh0KGJvb2wgc2V0RGlydHkgPSB0cnVlKTsK KyAgICB2aXJ0dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKworICAgIHZvaWQgdXBkYXRlVG90 YWwoaW50IHZhbHVlKTsKKyAgICAvLyBUaGUgaGlnaGVzdCB2YWx1ZSBhbW9uZyBjaGlsZHJlbgor ICAgIGludCB0b3RhbCgpIGNvbnN0IHsgcmV0dXJuIG1fdG90YWw7IH07CisKK3ByaXZhdGU6Cisg ICAgaW50IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAgQ291bnRlck5v ZGUqIG1fbGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENv dW50ZXJSZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKKysrIHJl bmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MyBAQAor LyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRpb24gZm9yIEtE RS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVA Y2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMu CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExp YnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGli cmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor ICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2Fy cmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIg UFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRo IHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0 bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNl IC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisg CisjaWZuZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0SXRlbV9ICisK KyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNz IENvdW50ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVyTm9kZQoreworcHVibGljOgorICAgIGlu dCBjb3VudCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBzZXREaXJ0 eSA9IHRydWUpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKworfTsKKworfSAv L25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCisr KyByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQ1 IEBACisvKioKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdp bmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVu c2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1 dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAq IFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGlt cGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBh bG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90 LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVt cGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisg KgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgi CisKKyNpbmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUu aCIKKyNpbmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCisKK25h bWVzcGFjZSBXZWJDb3JlIHsKKworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworUmVu ZGVyQ291bnRlcjo6UmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRl cikKKyAgICA6IFJlbmRlclRleHQobm9kZSwgMCksIG1fY291bnRlcihjb3VudGVyKSwgbV9jb3Vu dGVyTm9kZSgwKQoreworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmxheW91dCgpCit7CisgICAg QVNTRVJUKG5lZWRzTGF5b3V0KCkpOworCisgICAgaWYgKCFtaW5NYXhLbm93bigpKQorICAgICAg ICBjYWxjTWluTWF4V2lkdGgoKTsKKworICAgIFJlbmRlclRleHQ6OmxheW91dCgpOworfQorCitz dGF0aWMgU3RyaW5nIHRvUm9tYW4oaW50IG51bWJlciwgYm9vbCB1cHBlcikKK3sgCisgICAgU3Ry aW5nIHJvbWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAndicsICd4Jywg J2wnLCAnYycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1tdID0geyAnSScs ICdWJywgJ1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hhciogZGlnaXRz ID0gdXBwZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8gewor ICAgICAgICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkK KyAgICAgICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQorICAgICAgICAg ICAgICAgIHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA+ PSA0ICYmIG51bSA8PSA4KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdpdHNbZCArIDFd LCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA9PSA5KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0 KCZkaWdpdHNbZCArIDJdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAgICAg ICAgICAgIHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgbnVtYmVyIC89 IDEwOworICAgICAgICBkICs9IDI7CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAgICByZXR1cm4g cm9tYW47Cit9CisKK3N0YXRpYyBTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJlciwgVUNo YXIgbGV0dGVyQSkKK3sgCisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVybiBTdHJp bmcoJmxldHRlckEsIDEpOyAvLyBtYXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94ICgwLikKKwor ICAgIFN0cmluZyBsZXR0ZXJTdHJpbmc7CisgICAgVUNoYXIgYzsKKyAgICB3aGlsZSAobnVtYmVy ID4gMCkgeworICAgICAgICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7CisgICAg ICAgIGMgPSBsZXR0ZXJBICsgb25lc0RpZ2l0OworICAgICAgICBsZXR0ZXJTdHJpbmcgPSBTdHJp bmcoJmMsIDEpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0Owor ICAgICAgICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsK K30KKworc3RhdGljIFN0cmluZyB0b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAgIGlmIChudW1i ZXIgPCAxKQorICAgICAgICByZXR1cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsKKyAgICAKKyAg ICBzdGF0aWMgY29uc3QgVUNoYXIgdGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAxNTAwLCAxNTAy LCAxNTA0LCAxNTA1LCAxNTA2LCAxNTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBsZXR0ZXI7Cisg ICAgVUNoYXIgYzsKKyAgICBpZiAobnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxldHRlciA9IHRv SGVicmV3KG51bWJlciAvIDEwMDApICsgIiciOworICAgICAgICBudW1iZXIgPSBudW1iZXIgJSAx MDAwOworICAgIH0KKyAgICBpbnQgZm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAwOworICAgIGZv ciAoaW50IGkgPSAwOyBpIDwgZm91ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAgYyA9IDE1MTEg KyAzOworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgIH0KKyAgICBudW1iZXIgJT0gNDAw OworICAgIGlmIChudW1iZXIgLyAxMDApIHsKKyAgICAgICAgYyA9IDE1MTEgKyAobnVtYmVyIC8g MTAwKSAtIDE7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfQorICAgIG51bWJlciAl PSAxMDA7CisgICAgaWYgKG51bWJlciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAg YyA9IDE0ODcgKyA5OworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICBjID0gMTQ4 NyArIG51bWJlciAtIDk7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfSBlbHNlIHsK KyAgICAgICAgaW50IHRlbnMgPSBudW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRlbnMpIHsKKyAg ICAgICAgICAgIGMgPSB0ZW5EaWdpdFt0ZW5zIC0gMV07CisgICAgICAgICAgICBsZXR0ZXIuYXBw ZW5kKGMpOworICAgICAgICB9CisgICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAg ICBpZiAobnVtYmVyKSB7CisgICAgICAgICAgICBjID0gMTQ4NyArIG51bWJlcjsKKyAgICAgICAg ICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIGxldHRl cjsKK30KKworU3RyaW5nIFJlbmRlckNvdW50ZXI6OmNvbnZlcnRWYWx1ZVRvVHlwZShpbnQgdmFs dWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJpbmcgaXRlbTsK KyAgICBVQ2hhciBjOworICAgIHN3aXRjaCh0eXBlKSB7CisgICAgICAgIGNhc2UgTE5PTkU6Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgLy8gR2x5cGhzOgorICAgICAgICBjYXNlIERJU0M6 CisgICAgICAgICAgICBjID0gMHgyMDIyOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywg MSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBDSVJDTEU6CisgICAgICAgICAg ICBjID0gMHgyNWU2OworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBjID0gMHgyNWEw OworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsK KyAgICAgICAgY2FzZSBBUk1FTklBTjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoKKyAgICAgICAg Y2FzZSBDSktfSURFT0dSQVBISUM6CisgICAgICAgIGNhc2UgSElSQUdBTkE6CisgICAgICAgIGNh c2UgS0FUQUtBTkE6CisgICAgICAgIGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAgICAgIGNhc2Ug S0FUQUtBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pFUk86CisgICAg ICAgICAgICAvLyBGSVhNRTogVGhlc2UgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gRm9yIG5v dyB3ZSdsbCB1c2UgZGVjaW1hbCBpbnN0ZWFkLgorICAgICAgICBjYXNlIExERUNJTUFMOgorICAg ICAgICAgICAgaXRlbSA9IFN0cmluZzo6bnVtYmVyKHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICAvLyBBbGdvcml0bWljOgorICAgICAgICBjYXNlIExPV0VSX1JPTUFOOgorICAg ICAgICAgICAgaXRlbSA9IHRvUm9tYW4odmFsdWUsIGZhbHNlKTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICBjYXNlIFVQUEVSX1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9tYW4o dmFsdWUsIHRydWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgTE9XRVJfR1JF RUs6IHsKKyAgICAgICAgICAgIGludCBudW1iZXIgPSB2YWx1ZSAtIDE7CisgICAgICAgICAgICBp bnQgbCA9IChudW1iZXIgJSAyNCk7CisgICAgICAgICAgICBpZiAobCA+IDE2KQorICAgICAgICAg ICAgICAgIGwrKzsgLy8gU2tpcCBHUkVFSyBTTUFMTCBMRVRURVIgRklOQUwgU0lHTUEKKyAgICAg ICAgICAgIGMgPSA5NDUgKyBsOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7Cisg ICAgICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkrKykKKyAgICAg ICAgICAgICAgICBpdGVtICs9ICInIjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9Cisg ICAgICAgIGNhc2UgSEVCUkVXOgorICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3KHZhbHVlKTsK KyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgorICAgICAgICBj YXNlIExPV0VSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVl LCAnYScpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJfQUxQSEE6Cisg ICAgICAgIGNhc2UgVVBQRVJfTEFUSU46CisgICAgICAgICAgICBpdGVtID0gdG9MZXR0ZXJTdHJp bmcodmFsdWUsICdBJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAg ICAgICAgICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAgICAgICBicmVh azsKKyAgICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6Y2Fs Y01pbk1heFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkpOworCisgICAgaWYg KCFzdHlsZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGhhc1NlcGFyYXRvciA9ICFt X2NvdW50ZXItPnNlcGFyYXRvcigpLmlzTnVsbCgpOworCisgICAgaWYgKCFtX2NvdW50ZXJOb2Rl ICYmIHBhcmVudCgpLT5wYXJlbnQoKSkKKyAgICAgICAgbV9jb3VudGVyTm9kZSA9IHBhcmVudCgp LT5wYXJlbnQoKS0+ZmluZENvdW50ZXIobV9jb3VudGVyLT5pZGVudGlmaWVyKCksIHRydWUsIGhh c1NlcGFyYXRvcik7CisKKyAgICBpbnQgdmFsdWUgPSBtX2NvdW50ZXJOb2RlLT5jb3VudCgpOwor ICAgIGlmIChtX2NvdW50ZXJOb2RlLT5pc1Jlc2V0KCkpCisgICAgICAgIHZhbHVlID0gbV9jb3Vu dGVyTm9kZS0+dmFsdWUoKTsKKyAgICAKKyAgICBpbnQgdG90YWwgPSB2YWx1ZTsKKyAgICBpZiAo bV9jb3VudGVyTm9kZS0+cGFyZW50KCkpCisgICAgICAgIHRvdGFsID0gbV9jb3VudGVyTm9kZS0+ cGFyZW50KCktPnRvdGFsKCk7CisgICAgCisgICAgbV9pdGVtID0gY29udmVydFZhbHVlVG9UeXBl KHZhbHVlLCB0b3RhbCwgbV9jb3VudGVyLT5saXN0U3R5bGUoKSk7CisKKyAgICBpZiAoaGFzU2Vw YXJhdG9yKSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+ cGFyZW50KCk7CisgICAgICAgIGJvb2wgZmlyc3QgPSB0cnVlOworICAgICAgICB3aGlsZSAgKGNv dW50ZXItPnBhcmVudCgpICYmIChmaXJzdCB8fCAhKGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3Vu dGVyLT5wYXJlbnQoKS0+aXNSb290KCkpKSkgeworICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVy LT5jb3VudCgpID8gY291bnRlci0+Y291bnQoKSA6IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNv dW50ZXItPnBhcmVudCgpLT50b3RhbCgpOworICAgICAgICAgICAgbV9pdGVtID0gY29udmVydFZh bHVlVG9UeXBlKHZhbHVlLCB0b3RhbCwgbV9jb3VudGVyLT5saXN0U3R5bGUoKSkgCisgICAgICAg ICAgICAgICAgKyBtX2NvdW50ZXItPnNlcGFyYXRvcigpICsgbV9pdGVtOworICAgICAgICAgICAg Y291bnRlciA9IGNvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAgZmlyc3QgPSBmYWxzZTsK KyAgICAgICAgfQorICAgIH0KKworICAgIHN0ciA9IG5ldyBTdHJpbmdJbXBsKG1faXRlbS5jaGFy YWN0ZXJzKCksIG1faXRlbS5sZW5ndGgoKSk7CisgICAgCisgICAgUmVuZGVyVGV4dDo6Y2FsY01p bk1heFdpZHRoKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IHJlbmRlcmlu Zy9Db3VudGVyTm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNw cAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMTExIEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwg cmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxh biBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIw MDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2 ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRo YXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJ VE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91 bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGlj IExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlO Ry5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTEx LTEzMDcsIFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNv dW50ZXJOb2RlLmgiCisKKyNpbmNsdWRlICJDb3VudGVyUmVzZXROb2RlLmgiCisjaW5jbHVkZSAi UmVuZGVyT2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworQ291bnRlck5vZGU6OkNv dW50ZXJOb2RlKFJlbmRlck9iamVjdCogbykKKyAgICA6IG1faGFzU2VwYXJhdG9yKGZhbHNlKQor ICAgICwgbV93aWxsTmVlZExheW91dChmYWxzZSkKKyAgICAsIG1fdmFsdWUoMCkKKyAgICAsIG1f Y291bnQgKDApCisgICAgLCBtX3BhcmVudCgwKQorICAgICwgbV9wcmV2aW91cygwKQorICAgICwg bV9uZXh0KDApCisgICAgLCBtX3JlbmRlcmVyKG8pCit7ICAgCit9CisKK3ZvaWQgQ291bnRlck5v ZGU6Omluc2VydEFmdGVyKENvdW50ZXJOb2RlKiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VS VChmYWxzZSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2Rl KikKK3sKKyAgICBBU1NFUlQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmUo KQoreworICAgIGlmIChtX3BhcmVudCkKKyAgICAgICAgbV9wYXJlbnQtPnJlbW92ZUNoaWxkKHRo aXMpOworICAgIGVsc2UgeworICAgICAgICBBU1NFUlQoaXNSZXNldCgpKTsKKyAgICAgICAgQVNT RVJUKCFmaXJzdENoaWxkKCkpOworICAgICAgICBBU1NFUlQoIWxhc3RDaGlsZCgpKTsKKyAgICB9 Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnNldFVzZXNTZXBhcmF0b3IoKQoreworICAgIGZvciAo Q291bnRlck5vZGUqIGMgPSB0aGlzOyBjOyBjID0gYy0+cGFyZW50KCkpCisgICAgICAgIGMtPnNl dEhhc1NlcGFyYXRvcigpOworfQorCitDb3VudGVyTm9kZSogQ291bnRlck5vZGU6OnJlY291bnRB bmRHZXROZXh0KGJvb2wgc2V0RGlydHkpCit7CisgICAgaW50IG9sZF9jb3VudCA9IG1fY291bnQ7 CisgICAgaWYgKG1fcHJldmlvdXMpCisgICAgICAgIG1fY291bnQgPSBtX3ByZXZpb3VzLT5jb3Vu dCgpICsgbV92YWx1ZTsKKyAgICBlbHNlIHsKKyAgICAgICAgYXNzZXJ0KG1fcGFyZW50LT5maXJz dENoaWxkKCkgPT0gdGhpcyk7CisgICAgICAgIG1fY291bnQgPSBtX3BhcmVudC0+dmFsdWUoKSAr IG1fdmFsdWU7CisgICAgfQorICAgIAorICAgIGlmIChvbGRfY291bnQgIT0gbV9jb3VudCAmJiBz ZXREaXJ0eSkKKyAgICAgICAgc2V0U2VsZkRpcnR5KCk7CisgICAgaWYgKG9sZF9jb3VudCAhPSBt X2NvdW50IHx8ICFzZXREaXJ0eSkgeworICAgICAgICBpZiAobV9wYXJlbnQpCisgICAgICAgICAg ICBtX3BhcmVudC0+dXBkYXRlVG90YWwobV9jb3VudCk7CisgICAgICAgIHJldHVybiBtX25leHQ7 CisgICAgfQorICAgIAorICAgIHJldHVybiAwOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZWNv dW50VHJlZShib29sIHNldERpcnR5KQoreworICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9 IHRoaXM7CisgICAgd2hpbGUgKGNvdW50ZXJOb2RlKQorICAgICAgICBjb3VudGVyTm9kZSA9IGNv dW50ZXJOb2RlLT5yZWNvdW50QW5kR2V0TmV4dChzZXREaXJ0eSk7Cit9CisKK3ZvaWQgQ291bnRl ck5vZGU6OnNldFNlbGZEaXJ0eSgpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV93aWxsTmVl ZExheW91dCkKKyAgICAgICAgbV9yZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNh bGMoKTsKK30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlm IChtX3JlbmRlcmVyICYmIG1fd2lsbE5lZWRMYXlvdXQgJiYgbV9oYXNTZXBhcmF0b3IpCisgICAg ICAgIG1fcmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK30g Ly8gbmFtZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAkocmV2aXNpb24gMTY3MTcpCisrKyByZW5kZXJpbmcv UmVuZGVyU3R5bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsOCBAQAogICogYW5kIHBy b2R1Y2UgaW52YWxpdWQgcmVzdWx0cy4KICAqLwogCisjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFs dWUuaCIKKyNpbmNsdWRlICJDU1NWYWx1ZUxpc3QuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2lu Y2x1ZGUgIkNTU0N1cnNvckltYWdlVmFsdWUuaCIKICNpbmNsdWRlICJEYXRhUmVmLmgiCkBAIC00 Miw2ICs0NCw3IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFJl Y3QuaCIKICNpbmNsdWRlICJMZW5ndGguaCIKKyNpbmNsdWRlICJQYWlyLmgiCiAjaW5jbHVkZSAi U2hhcmVkLmgiCiAjaW5jbHVkZSAiVGV4dERpcmVjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KQEAgLTYwLDExICs2MywxMyBAQAogCiB1c2luZyBzdGQ6Om1heDsKIAotY2xhc3MgQ1NT U3R5bGVTZWxlY3RvcjsKIGNsYXNzIENhY2hlZEltYWdlOwogY2xhc3MgQ2FjaGVkUmVzb3VyY2U7 CitjbGFzcyBDU1NTdHlsZVNlbGVjdG9yOworY2xhc3MgQ1NTVmFsdWVMaXN0Owogc3RydWN0IEN1 cnNvckRhdGE7CiBjbGFzcyBDdXJzb3JMaXN0OworY2xhc3MgUGFpcjsKIGNsYXNzIFJlbmRlckFy ZW5hOwogY2xhc3MgU2hhZG93VmFsdWU7CiBjbGFzcyBTdHJpbmdJbXBsOwpAQCAtNDEwLDggKzQx NSw4IEBACiAgICAgICAgIHJldHVybiAoIGNsaXAgPT0gby5jbGlwICYmCiAgICAgICAgICAgICAg ICAgIGhhc0NsaXAgPT0gby5oYXNDbGlwICYmCiAgICAgICAgICAgICAgICAgIGNvbHNwYW4gPT0g by5jb2xzcGFuICYmCi0gICAgICAgICAgICAgICAgIGNvdW50ZXJfaW5jcmVtZW50ID09IG8uY291 bnRlcl9pbmNyZW1lbnQgJiYKLSAgICAgICAgICAgICAgICAgY291bnRlcl9yZXNldCA9PSBvLmNv dW50ZXJfcmVzZXQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlckluY3JlbWVudCA9PSBvLmNv dW50ZXJJbmNyZW1lbnQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlclJlc2V0ID09IG8uY291 bnRlclJlc2V0ICYmCiAgICAgICAgICAgICAgICAgIHRleHREZWNvcmF0aW9uID09IG8udGV4dERl Y29yYXRpb24pOwogICAgIH0KICAgICBib29sIG9wZXJhdG9yIT0oIGNvbnN0IFN0eWxlVmlzdWFs RGF0YSAmbyApIGNvbnN0IHsKQEAgLTQyNCw4ICs0MjksOCBAQAogICAgIAogICAgIHNob3J0IGNv bHNwYW47IC8vIGZvciBodG1sLCBub3QgYSBjc3MyIGF0dHJpYnV0ZQogCi0gICAgc2hvcnQgY291 bnRlcl9pbmNyZW1lbnQ7IC8vb2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUgc3Blc2lm aWMKLSAgICBzaG9ydCBjb3VudGVyX3Jlc2V0OyAgICAgLy9jYW4ndCBnbyB0byBpbmhlcml0ZWQs IHNpbmNlIHRoZXNlIGFyZSBub3QgaW5oZXJpdGVkCisgICAgc2hvcnQgY291bnRlckluY3JlbWVu dDsgLy8gb2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUgc3BlY2lmaWMKKyAgICBzaG9y dCBjb3VudGVyUmVzZXQ7ICAgICAvLyBjYW4ndCBnbyB0byBpbmhlcml0ZWQsIHNpbmNlIHRoZXNl IGFyZSBub3QgaW5oZXJpdGVkCiAKIH07CiAKQEAgLTg5OCw2ICs5MDMsMjMgQEAKICAgICBDT05U RU5UX05PTkUsIENPTlRFTlRfT0JKRUNULCBDT05URU5UX1RFWFQsIENPTlRFTlRfQ09VTlRFUgog fTsKIAorY2xhc3MgQ291bnRlckRhdGEgeworICAgIAorcHVibGljOgorICAgIENvdW50ZXJEYXRh KCkge30KKyAgICBDb3VudGVyRGF0YShjb25zdCBTdHJpbmcmIGksIEVMaXN0U3R5bGVUeXBlIGws IGNvbnN0IFN0cmluZyYgcykKKyAgICAgICAgOiBtX2lkZW50aWZpZXIoaSksIG1fbGlzdFN0eWxl KGwpLCBtX3NlcGFyYXRvcihzKSB7fQorICAgIAorICAgIFN0cmluZyBpZGVudGlmaWVyKCkgeyBy ZXR1cm4gbV9pZGVudGlmaWVyOyB9CisgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0eWxlKCkgeyBy ZXR1cm4gbV9saXN0U3R5bGU7IH0KKyAgICBTdHJpbmcgc2VwYXJhdG9yKCkgeyByZXR1cm4gbV9z ZXBhcmF0b3I7IH0KKworcHJpdmF0ZToKKyAgICBTdHJpbmcgbV9pZGVudGlmaWVyOworICAgIEVM aXN0U3R5bGVUeXBlIG1fbGlzdFN0eWxlOworICAgIFN0cmluZyBtX3NlcGFyYXRvcjsKK307CisK IHN0cnVjdCBDb250ZW50RGF0YSB7CiAgICAgQ29udGVudERhdGEoKSA6X2NvbnRlbnRUeXBlKENP TlRFTlRfTk9ORSksIF9uZXh0Q29udGVudCgwKSB7fQogICAgIH5Db250ZW50RGF0YSgpOwpAQCAt OTA3LDEzICs5MjksMTQgQEAKIAogICAgIFN0cmluZ0ltcGwqIGNvbnRlbnRUZXh0KCkgeyBpZiAo Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHJldHVybiBfY29udGVudC50ZXh0OyByZXR1 cm4gMDsgfQogICAgIENhY2hlZFJlc291cmNlKiBjb250ZW50T2JqZWN0KCkgeyBpZiAoY29udGVu dFR5cGUoKSA9PSBDT05URU5UX09CSkVDVCkgcmV0dXJuIF9jb250ZW50Lm9iamVjdDsgcmV0dXJu IDA7IH0KKyAgICBDb3VudGVyRGF0YSogY29udGVudENvdW50ZXIoKSB7IGlmIChjb250ZW50VHlw ZSgpID09IENPTlRFTlRfQ09VTlRFUikgcmV0dXJuIF9jb250ZW50LmNvdW50ZXI7IHJldHVybiAw OyB9CiAgICAgCiAgICAgQ29udGVudFR5cGUgX2NvbnRlbnRUeXBlOwogCiAgICAgdW5pb24gewog ICAgICAgICBDYWNoZWRSZXNvdXJjZSogb2JqZWN0OwogICAgICAgICBTdHJpbmdJbXBsKiB0ZXh0 OwotICAgICAgICAvLyBjb3VudGVycy4uLgorICAgICAgICBDb3VudGVyRGF0YSogY291bnRlcjsK ICAgICB9IF9jb250ZW50IDsKIAogICAgIENvbnRlbnREYXRhKiBfbmV4dENvbnRlbnQ7CkBAIC0x MDcxLDcgKzEwOTQsOSBAQAogICAgIAogICAgIC8vIGFkZGVkIHRoaXMgaGVyZSwgc28gd2UgY2Fu IGdldCByaWQgb2YgdGhlIHZwdHIgaW4gdGhpcyBjbGFzcy4KICAgICAvLyBtYWtlcyB1cCBmb3Ig dGhlIHNhbWUgc2l6ZS4KLSAgICBDb250ZW50RGF0YSAqY29udGVudDsKKyAgICBDb250ZW50RGF0 YSogY29udGVudDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiBjb3VudGVyUmVzZXRMaXN0Owor ICAgIFJlZlB0cjxDU1NWYWx1ZUxpc3Q+IGNvdW50ZXJJbmNyZW1lbnRMaXN0OwogCiAgICAgdW5z aWduZWQgbV9wc2V1ZG9TdGF0ZSA6IDM7IC8vIFBzZXVkb1N0YXRlCiAgICAgYm9vbCBtX2FmZmVj dGVkQnlBdHRyaWJ1dGVTZWxlY3RvcnMgOiAxOwpAQCAtMTMyMSw4ICsxMzQ2LDggQEAKICAgICBF RW1wdHlDZWxsIGVtcHR5Q2VsbHMoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFRW1wdHlD ZWxsPihpbmhlcml0ZWRfZmxhZ3MuX2VtcHR5X2NlbGxzKTsgfQogICAgIEVDYXB0aW9uU2lkZSBj YXB0aW9uU2lkZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVDYXB0aW9uU2lkZT4oaW5o ZXJpdGVkX2ZsYWdzLl9jYXB0aW9uX3NpZGUpOyB9CiAKLSAgICBzaG9ydCBjb3VudGVySW5jcmVt ZW50KCkgY29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyX2luY3JlbWVudDsgfQotICAgIHNo b3J0IGNvdW50ZXJSZXNldCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlcl9yZXNldDsg fQorICAgIHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNv dW50ZXJJbmNyZW1lbnQ7IH0KKyAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVy biB2aXN1YWwtPmNvdW50ZXJSZXNldDsgfQogCiAgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0eWxl VHlwZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVMaXN0U3R5bGVUeXBlPihpbmhlcml0 ZWRfZmxhZ3MuX2xpc3Rfc3R5bGVfdHlwZSk7IH0KICAgICBDYWNoZWRJbWFnZSAqbGlzdFN0eWxl SW1hZ2UoKSBjb25zdCB7IHJldHVybiBpbmhlcml0ZWQtPnN0eWxlX2ltYWdlOyB9CkBAIC0xNTI3 LDggKzE1NTIsOCBAQAogICAgIHZvaWQgc2V0Q2FwdGlvblNpZGUoRUNhcHRpb25TaWRlIHYpIHsg aW5oZXJpdGVkX2ZsYWdzLl9jYXB0aW9uX3NpZGUgPSB2OyB9CiAKIAotICAgIHZvaWQgc2V0Q291 bnRlckluY3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVyX2luY3JlbWVu dCx2KSB9Ci0gICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1 YWwsY291bnRlcl9yZXNldCx2KSB9CisgICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50KHNob3J0 IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJJbmNyZW1lbnQsdikgfQorICAgIHZvaWQgc2V0 Q291bnRlclJlc2V0KHNob3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJSZXNldCx2KSB9 CiAKICAgICB2b2lkIHNldExpc3RTdHlsZVR5cGUoRUxpc3RTdHlsZVR5cGUgdikgeyBpbmhlcml0 ZWRfZmxhZ3MuX2xpc3Rfc3R5bGVfdHlwZSA9IHY7IH0KICAgICB2b2lkIHNldExpc3RTdHlsZUlt YWdlKENhY2hlZEltYWdlICp2KSB7ICBTRVRfVkFSKGluaGVyaXRlZCxzdHlsZV9pbWFnZSx2KX0K QEAgLTE2MjYsNyArMTY1MSwxOCBAQAogICAgIGJvb2wgY29udGVudERhdGFFcXVpdmFsZW50KGNv bnN0IFJlbmRlclN0eWxlICpvdGhlclN0eWxlKSBjb25zdDsKICAgICB2b2lkIHNldENvbnRlbnQo U3RyaW5nSW1wbCogcywgYm9vbCBhZGQgPSBmYWxzZSk7CiAgICAgdm9pZCBzZXRDb250ZW50KENh Y2hlZFJlc291cmNlKiBvLCBib29sIGFkZCA9IGZhbHNlKTsKKyAgICB2b2lkIHNldENvbnRlbnQo Q291bnRlckRhdGEqLCBib29sIGFkZCA9IGZhbHNlKTsKIAorICAgIGJvb2wgY291bnRlckRhdGFF cXVpdmFsZW50KFJlbmRlclN0eWxlKik7CisgICAgdm9pZCBzZXRDb3VudGVyUmVzZXRMaXN0KFBh c3NSZWZQdHI8Q1NTVmFsdWVMaXN0PiBsKSB7IGNvdW50ZXJSZXNldExpc3QgPSBsOyB9CisgICAg dm9pZCBzZXRDb3VudGVySW5jcmVtZW50TGlzdChQYXNzUmVmUHRyPENTU1ZhbHVlTGlzdD4gbCkg eyBjb3VudGVySW5jcmVtZW50TGlzdCA9IGw7IH0KKyAgICBib29sIGhhc0NvdW50ZXJSZXNldChj b25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICBib29sIGhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3Qg U3RyaW5nJikgY29uc3Q7CisgICAgaW50IGNvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmKSBjb25z dDsKKyAgICBpbnQgY291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICBD U1NWYWx1ZUxpc3QqIGNvdW50ZXJSZXNldFZhbHVlTGlzdCgpIHsgcmV0dXJuIGNvdW50ZXJSZXNl dExpc3QuZ2V0KCk7IH0KKyAgICBDU1NWYWx1ZUxpc3QqIGNvdW50ZXJJbmNyZW1lbnRWYWx1ZUxp c3QoKSB7IHJldHVybiBjb3VudGVySW5jcmVtZW50TGlzdC5nZXQoKTsgfQorCiAgICAgYm9vbCBp bmhlcml0ZWROb3RFcXVhbCggUmVuZGVyU3R5bGUgKm90aGVyICkgY29uc3Q7CiAKICAgICAvLyBU aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIHR3byBzdHlsZXMuICBUaGUgZm9sbG93aW5nIHZhbHVlcyBh cmUgdXNlZDoKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSByZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5jcHAJKHJldmlzaW9uIDApCisrKyByZW5k ZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTU2IEBA CisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBm b3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4g KGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIs IEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRp c3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBH TlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhp cyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGll ZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBh IGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25n IHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdy aXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUg UGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIK KworI2luY2x1ZGUgIlJlbmRlck9iamVjdC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0Nv dW50ZXJSZXNldE5vZGU6OkNvdW50ZXJSZXNldE5vZGUoUmVuZGVyT2JqZWN0KiBvKQorICAgIDog Q291bnRlck5vZGUobykKKyAgICAsIG1fdG90YWwoMCkKKyAgICAsIG1fZmlyc3QoMCkKKyAgICAs IG1fbGFzdCgwKQoreworfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6Omluc2VydEFmdGVyKENv dW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKQoreworICAgIEFTU0VS VChuZXdDaGlsZCk7CisgICAgQVNTRVJUKCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+cGFyZW50KCkg PT0gdGhpcyk7CisKKyAgICBuZXdDaGlsZC0+bV9wYXJlbnQgPSB0aGlzOworICAgIG5ld0NoaWxk LT5tX3ByZXZpb3VzID0gcmVmQ2hpbGQ7CisKKyAgICBpZiAocmVmQ2hpbGQpIHsKKyAgICAgICAg bmV3Q2hpbGQtPm1fbmV4dCA9IHJlZkNoaWxkLT5tX25leHQ7CisgICAgICAgIHJlZkNoaWxkLT5t X25leHQgPSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAgICAgICBuZXdDaGlsZC0+bV9uZXh0 ID0gbV9maXJzdDsKKyAgICAgICAgbV9maXJzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIGlm IChuZXdDaGlsZC0+bV9uZXh0KSB7CisgICAgICAgIEFTU0VSVChuZXdDaGlsZC0+bV9uZXh0LT5t X3ByZXZpb3VzID09IHJlZkNoaWxkKTsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2 aW91cyA9IG5ld0NoaWxkOworICAgIH0gZWxzZSB7CisgICAgICAgIEFTU0VSVChtX2xhc3QgPT0g cmVmQ2hpbGQpOworICAgICAgICBtX2xhc3QgPSBuZXdDaGlsZDsKKyAgICB9CisKKyAgICBuZXdD aGlsZC0+cmVjb3VudEFuZEdldE5leHQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJSZXNldE5v ZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKiBvbGRDaGlsZCkKK3sKKyAgICBBU1NFUlQob2xk Q2hpbGQpOworCisgICAgQ291bnRlck5vZGUqIG5leHQgPSBvbGRDaGlsZC0+bV9uZXh0OworICAg IENvdW50ZXJOb2RlKiBwcmV2ID0gb2xkQ2hpbGQtPm1fcHJldmlvdXM7CisKKyAgICBpZiAob2xk Q2hpbGQtPmZpcnN0Q2hpbGQoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogZmlyc3QgPSBvbGRD aGlsZC0+Zmlyc3RDaGlsZCgpOworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IG9sZENoaWxk LT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgaWYgKHByZXYpIHsKKyAgICAgICAgICAgIHByZXYtPm1f bmV4dCA9IGZpcnN0OworICAgICAgICAgICAgZmlyc3QtPm1fcHJldmlvdXMgPSBwcmV2OworICAg ICAgICB9IGVsc2UKKyAgICAgICAgICAgIG1fZmlyc3QgPSBmaXJzdDsKKworICAgICAgICBpZiAo bmV4dCkgeworICAgICAgICAgICAgbmV4dC0+bV9wcmV2aW91cyA9IGxhc3Q7CisgICAgICAgICAg ICBsYXN0LT5tX25leHQgPSBuZXh0OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIG1fbGFz dCA9IGxhc3Q7CisKKyAgICAgICAgbmV4dCA9IGZpcnN0OworICAgICAgICB3aGlsZSAobmV4dCkg eworICAgICAgICAgICAgbmV4dC0+bV9wYXJlbnQgPSB0aGlzOworICAgICAgICAgICAgbmV4dCA9 IG5leHQtPm1fbmV4dDsKKyAgICAgICAgfQorCisgICAgICAgIGZpcnN0LT5yZWNvdW50QW5kR2V0 TmV4dCh0cnVlKTsKKyAgICB9IGVsc2UgeworICAgICAgICBpZiAocHJldikgCisgICAgICAgICAg ICBwcmV2LT5tX25leHQgPSBuZXh0OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGFzc2Vy dCAoIG1fZmlyc3QgPT0gb2xkQ2hpbGQgKTsKKyAgICAgICAgICAgIG1fZmlyc3QgPSBuZXh0Owor ICAgICAgICB9CisgICAgICAgIAorICAgICAgICBpZiAobmV4dCkKKyAgICAgICAgICAgIG5leHQt Pm1fcHJldmlvdXMgPSBwcmV2OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGFzc2VydCAo IG1fbGFzdCA9PSBvbGRDaGlsZCApOworICAgICAgICAgICAgbV9sYXN0ID0gcHJldjsKKyAgICAg ICAgfQorICAgICAgICAKKyAgICAgICAgaWYgKG5leHQpCisgICAgICAgICAgICBuZXh0LT5yZWNv dW50VHJlZSgpOworICAgIH0KKworCisgICAgb2xkQ2hpbGQtPm1fbmV4dCA9IDA7CisgICAgb2xk Q2hpbGQtPm1fcHJldmlvdXMgPSAwOworICAgIG9sZENoaWxkLT5tX3BhcmVudCA9IDA7Cit9CisK K0NvdW50ZXJOb2RlKiBDb3VudGVyUmVzZXROb2RlOjpyZWNvdW50QW5kR2V0TmV4dChib29sIHNl dERpcnR5KQoreworICAgIGludCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3ByZXZp b3VzKQorICAgICAgICBtX2NvdW50ID0gbV9wcmV2aW91cy0+Y291bnQoKTsKKyAgICBlbHNlIGlm IChtX3BhcmVudCkKKyAgICAgICAgbV9jb3VudCA9IG1fcGFyZW50LT52YWx1ZSgpOworICAgIGVs c2UKKyAgICAgICAgbV9jb3VudCA9IDA7CisKKyAgICB1cGRhdGVUb3RhbChtX3ZhbHVlKTsKKyAg ICAKKyAgICBpZiAoc2V0RGlydHkpCisgICAgICAgIHNldFNlbGZEaXJ0eSgpOworICAgIGlmICgh c2V0RGlydHkgfHwgbV9jb3VudCAhPSBvbGRfY291bnQpCisgICAgICAgIHJldHVybiBtX25leHQ7 CisgICAgCisgICAgcmV0dXJuIDA7Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6c2V0UGFy ZW50RGlydHkoKQoreworICAgIGlmIChoYXNTZXBhcmF0b3IoKSkKKyAgICAgICAgc2V0U2VsZkRp cnR5KCk7CisgICAgICAgIAorICAgIGZvciAoQ291bnRlck5vZGUqIG4gPSBmaXJzdENoaWxkKCk7 IG47IG4gPSBuLT5uZXh0U2libGluZygpKQorICAgICAgICBpZiAobi0+aGFzU2VwYXJhdG9yKCkp CisgICAgICAgICAgICBuLT5zZXRTZWxmRGlydHkoKTsKK30KKwordm9pZCBDb3VudGVyUmVzZXRO b2RlOjp1cGRhdGVUb3RhbChpbnQgdmFsdWUpCit7CisgICAgaWYgKHZhbHVlID4gbV90b3RhbCkK KyAgICAgICAgbV90b3RhbCA9IHZhbHVlOworfQorCit9IC8vIG5hbWVzcGFjZQpJbmRleDogcmVu ZGVyaW5nL1JlbmRlckNvbnRhaW5lci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRl ckNvbnRhaW5lci5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgcmVuZGVyaW5nL1JlbmRlckNvbnRh aW5lci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQsNiArNCw3IEBACiAgKiBDb3B5cmlnaHQgKEMp IDE5OTkgTGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBB bnR0aSBLb2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBE aXJrIE11ZWxsZXIgKG11ZWxsZXJAa2RlLm9yZykKKyAqICAgICAgICAgICAoQykgMjAwNCBBbGxh biBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCiAgKiBDb3B5cmlnaHQgKEMpIDIw MDMsIDIwMDQsIDIwMDUsIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KICAqIENvcHlyaWdodCAo QykgMjAwNiBBbmRyZXcgV2VsbGluZ3RvbiAocHJvdG9uQHdpcmV0YXBwZWQubmV0KQogICoKQEAg LTI4LDYgKzI5LDcgQEAKICNpbmNsdWRlICJSZW5kZXJDb250YWluZXIuaCIKIAogI2luY2x1ZGUg Imh0bWxlZGl0aW5nLmgiCisjaW5jbHVkZSAiUmVuZGVyQ291bnRlci5oIgogI2luY2x1ZGUgIlJl bmRlckxpc3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFibGUuaCIKICNpbmNsdWRlICJSZW5k ZXJUZXh0RnJhZ21lbnQuaCIKQEAgLTI5Niw3ICsyOTgsNyBAQAogICAgICAgICAvLyBkZXRlcm1p bmVkIHRoYXQgdGhlIHBzZXVkbyBpcyBub3QgZGlzcGxheSBOT05FLCBhbnkgZGlzcGxheSBvdGhl ciB0aGFuCiAgICAgICAgIC8vIGlubGluZSBzaG91bGQgYmUgbXV0YXRlZCB0byBJTkxJTkUuCiAg ICAgICAgIHBzZXVkby0+c2V0RGlzcGxheShJTkxJTkUpOwotICAgIAorCiAgICAgaWYgKG9sZENv bnRlbnRQcmVzZW50KSB7CiAgICAgICAgIGlmIChjaGlsZCAmJiBjaGlsZC0+c3R5bGUoKS0+c3R5 bGVUeXBlKCkgPT0gdHlwZSkgewogICAgICAgICAgICAgLy8gV2UgaGF2ZSBnZW5lcmF0ZWQgY29u dGVudCBwcmVzZW50IHN0aWxsLiAgV2Ugd2FudCB0byB3YWxrIHRoaXMgY29udGVudCBhbmQgdXBk YXRlIG91cgpAQCAtMzM0LDIwICszMzYsMjQgQEAKICAgICAgICAgaWYgKCFwc2V1ZG9Db250YWlu ZXIpCiAgICAgICAgICAgICBwc2V1ZG9Db250YWluZXIgPSBSZW5kZXJGbG93OjpjcmVhdGVBbm9u eW1vdXNGbG93KGRvY3VtZW50KCksIHBzZXVkbyk7IC8qIGFub255bW91cyBib3ggKi8KICAgICAg ICAgCi0gICAgICAgIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RF WFQpCi0gICAgICAgIHsKKyAgICAgICAgaWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09 IENPTlRFTlRfVEVYVCkgewogICAgICAgICAgICAgUmVuZGVyVGV4dCogdCA9IG5ldyAocmVuZGVy QXJlbmEoKSkgUmVuZGVyVGV4dEZyYWdtZW50KGRvY3VtZW50KCkgLyphbm9ueW1vdXMgb2JqZWN0 ICovLCBjb250ZW50RGF0YS0+Y29udGVudFRleHQoKSk7CiAgICAgICAgICAgICB0LT5zZXRTdHls ZShwc2V1ZG8pOwogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRDaGlsZCh0KTsKLSAg ICAgICAgfQotICAgICAgICBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBD T05URU5UX09CSkVDVCkKLSAgICAgICAgeworICAgICAgICB9IGVsc2UgaWYgKGNvbnRlbnREYXRh LT5jb250ZW50VHlwZSgpID09IENPTlRFTlRfT0JKRUNUKSB7CiAgICAgICAgICAgICBSZW5kZXJJ bWFnZSogaW1nID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJJbWFnZShkb2N1bWVudCgpKTsg LyogQW5vbnltb3VzIG9iamVjdCAqLwogICAgICAgICAgICAgUmVuZGVyU3R5bGUqIHN0eWxlID0g bmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJTdHlsZSgpOwogICAgICAgICAgICAgc3R5bGUtPmlu aGVyaXRGcm9tKHBzZXVkbyk7CiAgICAgICAgICAgICBpbWctPnNldFN0eWxlKHN0eWxlKTsKICAg ICAgICAgICAgIGltZy0+c2V0Q29udGVudE9iamVjdChjb250ZW50RGF0YS0+Y29udGVudE9iamVj dCgpKTsKICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQoaW1nKTsKKyAgICAg ICAgfSBlbHNlIGlmIChjb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID09IENPTlRFTlRfQ09VTlRF UikgeworICAgICAgICAgICAgUmVuZGVyQ291bnRlciogYyA9IG5ldyAocmVuZGVyQXJlbmEoKSkg UmVuZGVyQ291bnRlcihlbGVtZW50KCksIGNvbnRlbnREYXRhLT5jb250ZW50Q291bnRlcigpKTsK KyAgICAgICAgICAgIFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVu ZGVyU3R5bGUoKTsKKyAgICAgICAgICAgIHN0eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOworICAg ICAgICAgICAgYy0+c2V0SXNBbm9ueW1vdXModHJ1ZSk7CisgICAgICAgICAgICBjLT5zZXRTdHls ZShzdHlsZSk7CisgICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKGMpOwogICAg ICAgICB9CiAgICAgfQogCkluZGV4OiByZW5kZXJpbmcvQ291bnRlck5vZGUuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSByZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9D b3VudGVyTm9kZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg2IEBACisvKgorICogVGhpcyBm aWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAq IENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5j b20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBU aGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5k L29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5l cmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5 b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAg U2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBk ZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJy YXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAz MzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisqLworI2lmbmRlZiBDb3Vu dGVyX05vZGVfaF8KKyNkZWZpbmUgQ291bnRlcl9Ob2RlX2hfCisKKyNpbmNsdWRlICJSZW5kZXJP YmplY3QuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBDb3VudGVyUmVzZXROb2Rl OworCisvLyBUaGlzIGZpbGUgaW1wbGVtZW50cyBhIGNvdW50ZXItdHJlZSB0aGF0IGlzIHVzZWQg Zm9yIGZpbmRpbmcgYWxsIHBhcmVudHMgaW4gY291bnRlcnMoKSBsb29rdXAsCisvLyBhbmQgZm9y IHByb3BhZ2F0aW5nIGNvdW50LWNoYW5nZXMgd2hlbiBub2RlcyBhcmUgYWRkZWQgb3IgcmVtb3Zl ZC4KKy8vIFBsZWFzZSBub3RlIHRoYXQgb25seSBjb3VudGVyLXJlc2V0IGFuZCByb290IGNhbiBi ZSBwYXJlbnRzIGhlcmUsIGFuZCB0aGF0IHJlbmRlci10cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0 IGNvdW50ZXItdHJlZSBzaWJsaW5ncworCitjbGFzcyBDb3VudGVyTm9kZSB7CitwdWJsaWM6Cisg ICAgQ291bnRlck5vZGUoUmVuZGVyT2JqZWN0Kik7CisgICAgdmlydHVhbCB+Q291bnRlck5vZGUo KSB7fQorCisgICAgQ291bnRlclJlc2V0Tm9kZSogcGFyZW50KCkgY29uc3QgeyByZXR1cm4gbV9w YXJlbnQ7IH0KKyAgICBDb3VudGVyTm9kZSogcHJldmlvdXNTaWJsaW5nKCkgY29uc3QgeyByZXR1 cm4gbV9wcmV2aW91czsgfQorICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIG5leHRTaWJsaW5nKCkg Y29uc3QgeyByZXR1cm4gbV9uZXh0OyB9CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogZmlyc3RD aGlsZCgpIGNvbnN0IHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBsYXN0 Q2hpbGQoKSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCB2b2lkIGluc2VydEFmdGVy KENvdW50ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKTsKKyAgICB2aXJ0 dWFsIHZvaWQgcmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGlsZCk7CisgICAgdm9pZCBy ZW1vdmUoKTsKKworICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFsdWU7IH0KKyAg ICB2b2lkIHNldFZhbHVlKGludCB2KSB7IG1fdmFsdWUgPSB2OyB9CisgICAgaW50IGNvdW50KCkg Y29uc3QgeyByZXR1cm4gbV9jb3VudDsgfQorICAgIHZvaWQgc2V0Q291bnQoaW50IGMpIHsgbV9j b3VudCA9IGM7IH0KKyAgICB2b2lkIHNldEhhc1NlcGFyYXRvcigpIHsgbV9oYXNTZXBhcmF0b3Ig PSB0cnVlOyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNSZXNldCgpIGNvbnN0eyByZXR1cm4gZmFs c2U7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiByZWNvdW50QW5kR2V0TmV4dChib29sIHNl dERpcnR5ID0gdHJ1ZSk7CisgICAgdmlydHVhbCB2b2lkIHJlY291bnRUcmVlKGJvb2wgc2V0RGly dHkgPSB0cnVlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisgICAgdmlydHVh bCB2b2lkIHNldFBhcmVudERpcnR5KCk7CisKKyAgICBib29sIGhhc1NlcGFyYXRvcigpIGNvbnN0 IHsgcmV0dXJuIG1faGFzU2VwYXJhdG9yOyB9CisgICAgYm9vbCB3aWxsTmVlZExheW91dCgpIGNv bnN0IHsgcmV0dXJuIG1fd2lsbE5lZWRMYXlvdXQ7IH0KKyAgICB2b2lkIHNldFVzZXNTZXBhcmF0 b3IoKTsKKyAgICB2b2lkIHNldFdpbGxOZWVkTGF5b3V0KCkgeyBtX3dpbGxOZWVkTGF5b3V0ID0g dHJ1ZTsgfQorICAgIGJvb2wgaXNSb290KCkgY29uc3QgeyByZXR1cm4gbV9yZW5kZXJlciAmJiBt X3JlbmRlcmVyLT5pc1Jvb3QoKTsgfQorCisgICAgdm9pZCBzZXRSZW5kZXJlcihSZW5kZXJPYmpl Y3QqIG8pIHsgbV9yZW5kZXJlciA9IG87IH0KKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKCkg Y29uc3QgeyByZXR1cm4gbV9yZW5kZXJlcjsgfQorCisgICAgZnJpZW5kIGNsYXNzIENvdW50ZXJS ZXNldE5vZGU7Citwcm90ZWN0ZWQ6CisgICAgYm9vbCBtX2hhc1NlcGFyYXRvcjsKKyAgICBib29s IG1fd2lsbE5lZWRMYXlvdXQ7CisgICAgaW50IG1fdmFsdWU7CisgICAgaW50IG1fY291bnQ7Cisg ICAgQ291bnRlclJlc2V0Tm9kZSogbV9wYXJlbnQ7CisgICAgQ291bnRlck5vZGUqIG1fcHJldmlv dXM7CisgICAgQ291bnRlck5vZGUqIG1fbmV4dDsKKyAgICBSZW5kZXJPYmplY3QqIG1fcmVuZGVy ZXI7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDb3VudGVyTm9k ZV9oCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRl cmluZy9SZW5kZXJTdHlsZS5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgcmVuZGVyaW5nL1JlbmRl clN0eWxlLmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTAsOCArOTAsOCBAQAogICAgIDogaGFzQ2xp cChmYWxzZSkKICAgICAsIHRleHREZWNvcmF0aW9uKFJlbmRlclN0eWxlOjppbml0aWFsVGV4dERl Y29yYXRpb24oKSkKICAgICAsIGNvbHNwYW4oMSkKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KDAp Ci0gICAgLCBjb3VudGVyX3Jlc2V0KDApCisgICAgLCBjb3VudGVySW5jcmVtZW50KDApCisgICAg LCBjb3VudGVyUmVzZXQoMCkKIHsKIH0KIApAQCAtMTA1LDggKzEwNSw4IEBACiAgICAgLCBoYXND bGlwKG8uaGFzQ2xpcCkKICAgICAsIHRleHREZWNvcmF0aW9uKG8udGV4dERlY29yYXRpb24pCiAg ICAgLCBjb2xzcGFuKG8uY29sc3BhbikKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KG8uY291bnRl cl9pbmNyZW1lbnQpCi0gICAgLCBjb3VudGVyX3Jlc2V0KG8uY291bnRlcl9yZXNldCkKKyAgICAs IGNvdW50ZXJJbmNyZW1lbnQoby5jb3VudGVySW5jcmVtZW50KQorICAgICwgY291bnRlclJlc2V0 KG8uY291bnRlclJlc2V0KQogewogfQogCkBAIC01NzcsNyArNTc3LDYgQEAKICAgICAgICAgcHJl di0+ZGVyZWYoYXJlbmEpOwogICAgIH0KICAgICBkZWxldGUgY29udGVudDsKLSAgICAKICAgICBk ZWxldGUgdGhpczsKICAgICAKICAgICAvLyBSZWNvdmVyIHRoZSBzaXplIGxlZnQgdGhlcmUgZm9y IHVzIGJ5IG9wZXJhdG9yIGRlbGV0ZSBhbmQgZnJlZSB0aGUgbWVtb3J5LgpAQCAtNjQ5LDYgKzY0 OCw4IEBACiAgICAgLCBpbmhlcml0ZWQoby5pbmhlcml0ZWQpCiAgICAgLCBwc2V1ZG9TdHlsZSgw KQogICAgICwgY29udGVudChvLmNvbnRlbnQpCisgICAgLCBjb3VudGVyUmVzZXRMaXN0KG8uY291 bnRlclJlc2V0TGlzdCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KG8uY291bnRlckluY3Jl bWVudExpc3QpCiAgICAgLCBtX3BzZXVkb1N0YXRlKG8ubV9wc2V1ZG9TdGF0ZSkKICAgICAsIG1f YWZmZWN0ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyhmYWxzZSkKICAgICAsIG1fdW5pcXVlKGZhbHNl KQpAQCAtODM4LDggKzgzOSw4IEBACiAgICAgICAgICEobm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9h dGluZyA9PSBvdGhlci0+bm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZykgfHwKICAgICAgICAg IShub25pbmhlcml0ZWRfZmxhZ3MuX29yaWdpbmFsRGlzcGxheSA9PSBvdGhlci0+bm9uaW5oZXJp dGVkX2ZsYWdzLl9vcmlnaW5hbERpc3BsYXkpIHx8CiAgICAgICAgICB2aXN1YWwtPmNvbHNwYW4g IT0gb3RoZXItPnZpc3VhbC0+Y29sc3BhbiB8fAotICAgICAgICAgdmlzdWFsLT5jb3VudGVyX2lu Y3JlbWVudCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVyX2luY3JlbWVudCB8fAotICAgICAgICAg dmlzdWFsLT5jb3VudGVyX3Jlc2V0ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJfcmVzZXQgfHwK KyAgICAgICAgIHZpc3VhbC0+Y291bnRlckluY3JlbWVudCAhPSBvdGhlci0+dmlzdWFsLT5jb3Vu dGVySW5jcmVtZW50IHx8CisgICAgICAgICB2aXN1YWwtPmNvdW50ZXJSZXNldCAhPSBvdGhlci0+ dmlzdWFsLT5jb3VudGVyUmVzZXQgfHwKICAgICAgICAgIGNzczNOb25Jbmhlcml0ZWREYXRhLT50 ZXh0T3ZlcmZsb3cgIT0gb3RoZXItPmNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cg fHwKICAgICAgICAgIChjc3MzSW5oZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5ICE9IG90aGVyLT5j c3MzSW5oZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5KSkKICAgICAgICAgcmV0dXJuIExheW91dDsK QEAgLTkyNSw2ICs5MjYsMTAgQEAKICAgICAvLyBJZiByZWdpb25zIGNoYW5nZSB0cmlnZ2VyIGEg cmVsYXlvdXQgdG8gcmUtY2FsYyByZWdpb25zLgogICAgIGlmICghKGNzczNOb25Jbmhlcml0ZWRE YXRhLT5tX2Rhc2hib2FyZFJlZ2lvbnMgPT0gb3RoZXItPmNzczNOb25Jbmhlcml0ZWREYXRhLT5t X2Rhc2hib2FyZFJlZ2lvbnMpKQogICAgICAgICByZXR1cm4gTGF5b3V0OworICAgIAorICAgIC8v IElmIHRoZSBjb3VudGVyIGxpc3RzIGNoYW5nZSwgdHJpZ2dlciBhIHJlbGF5b3V0IHRvIHJlLWNh bGMgQ291bnRlck5vZGVzLgorICAgIGlmIChjb3VudGVyUmVzZXRMaXN0ICE9IG90aGVyLT5jb3Vu dGVyUmVzZXRMaXN0IHx8IGNvdW50ZXJJbmNyZW1lbnRMaXN0ICE9IG90aGVyLT5jb3VudGVySW5j cmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIExheW91dDsKIAogICAgIC8vIE1ha2Ugc3VyZSB0 aGVzZSBsZWZ0L3RvcC9yaWdodC9ib3R0b20gY2hlY2tzIHN0YXkgYmVsb3cgYWxsIGxheW91dCBj aGVja3MgYW5kIGFib3ZlCiAgICAgLy8gYWxsIHZpc2libGUgY2hlY2tzLgpAQCAtMTEwOSw2ICsx MTE0LDMyIEBACiAgICAgbmV3Q29udGVudERhdGEtPl9jb250ZW50VHlwZSA9IENPTlRFTlRfVEVY VDsKIH0KIAordm9pZCBSZW5kZXJTdHlsZTo6c2V0Q29udGVudChDb3VudGVyRGF0YSogYywgYm9v bCBhZGQpCit7CisgICAgaWYgKCFjKQorICAgICAgICByZXR1cm47CisKKyAgICBDb250ZW50RGF0 YSogbGFzdENvbnRlbnQgPSBjb250ZW50OworICAgIHdoaWxlIChsYXN0Q29udGVudCAmJiBsYXN0 Q29udGVudC0+X25leHRDb250ZW50KQorICAgICAgICBsYXN0Q29udGVudCA9IGxhc3RDb250ZW50 LT5fbmV4dENvbnRlbnQ7CisKKyAgICBib29sIHJldXNlQ29udGVudCA9ICFhZGQ7CisgICAgQ29u dGVudERhdGEqIG5ld0NvbnRlbnREYXRhID0gMDsKKyAgICBpZiAocmV1c2VDb250ZW50ICYmIGNv bnRlbnQpIHsKKyAgICAgICAgY29udGVudC0+Y2xlYXJDb250ZW50KCk7CisgICAgICAgIG5ld0Nv bnRlbnREYXRhID0gY29udGVudDsKKyAgICB9IGVsc2UKKyAgICAgICAgbmV3Q29udGVudERhdGEg PSBuZXcgQ29udGVudERhdGE7CisKKyAgICBpZiAobGFzdENvbnRlbnQgJiYgIXJldXNlQ29udGVu dCkKKyAgICAgICAgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVudCA9IG5ld0NvbnRlbnREYXRhOwor ICAgIGVsc2UKKyAgICAgICAgY29udGVudCA9IG5ld0NvbnRlbnREYXRhOworCisgICAgbmV3Q29u dGVudERhdGEtPl9jb250ZW50LmNvdW50ZXIgPSBjOworICAgIG5ld0NvbnRlbnREYXRhLT5fY29u dGVudFR5cGUgPSBDT05URU5UX0NPVU5URVI7Cit9CisKIENvbnRlbnREYXRhOjp+Q29udGVudERh dGEoKQogewogICAgIGNsZWFyQ29udGVudCgpOwpAQCAtMTEyNyw2ICsxMTU4LDExIEBACiAgICAg ICAgIGNhc2UgQ09OVEVOVF9URVhUOgogICAgICAgICAgICAgX2NvbnRlbnQudGV4dC0+ZGVyZWYo KTsKICAgICAgICAgICAgIF9jb250ZW50LnRleHQgPSAwOworICAgICAgICAgICAgYnJlYWs7Cisg ICAgICAgIGNhc2UgQ09OVEVOVF9DT1VOVEVSOgorICAgICAgICAgICAgZGVsZXRlIF9jb250ZW50 LmNvdW50ZXI7CisgICAgICAgICAgICBfY29udGVudC5jb3VudGVyID0gMDsKKyAgICAgICAgICAg IGJyZWFrOwogICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgOwogICAgIH0KQEAgLTEyMTQs NiArMTI1MCw4MiBAQAogICAgIHJldHVybiB4ID09IG8ueCAmJiB5ID09IG8ueSAmJiBibHVyID09 IG8uYmx1ciAmJiBjb2xvciA9PSBvLmNvbG9yOwogfQogCitib29sIFJlbmRlclN0eWxlOjpjb3Vu dGVyRGF0YUVxdWl2YWxlbnQoUmVuZGVyU3R5bGUqIG90aGVyU3R5bGUpCit7CisgICAgLy8gRklY TUU6IFNob3VsZCB3ZSBhbHNvIGNvbXBhcmUgdGhlIENvdW50ZXJEYXRhPyAKKyAgICByZXR1cm4g Y291bnRlclJlc2V0TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVyUmVzZXRMaXN0ICYmCisgICAg ICAgICAgIGNvdW50ZXJJbmNyZW1lbnRMaXN0ID09IG90aGVyU3R5bGUtPmNvdW50ZXJJbmNyZW1l bnRMaXN0OworfQorCitzdGF0aWMgYm9vbCBoYXNDb3VudGVyKGNvbnN0IFN0cmluZyYgYywgQ1NT VmFsdWVMaXN0KiBsKQoreworICAgIGludCBsZW4gPSBsLT5sZW5ndGgoKTsKKyAgICBmb3IgKGlu dCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmlt aXRpdmVWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7 CisgICAgICAgIFBhaXIqIHBhaXIgPSBwcmltaXRpdmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7Cisg ICAgICAgIEFTU0VSVChwYWlyKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJO YW1lID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAg ICAgICAgQVNTRVJUKGNvdW50ZXJOYW1lKTsKKyAgICAgICAgaWYgKGNvdW50ZXJOYW1lLT5nZXRT dHJpbmdWYWx1ZSgpID09IGMpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAg cmV0dXJuIGZhbHNlOworfQorCitib29sIFJlbmRlclN0eWxlOjpoYXNDb3VudGVyUmVzZXQoY29u c3QgU3RyaW5nJiBjb3VudGVyTmFtZSkgY29uc3QKK3sKKyAgICBpZiAoY291bnRlclJlc2V0TGlz dCkKKyAgICAgICAgcmV0dXJuIGhhc0NvdW50ZXIoY291bnRlck5hbWUsIGNvdW50ZXJSZXNldExp c3QuZ2V0KCkpOworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5kZXJTdHlsZTo6aGFz Q291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAg IGlmIChjb3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIGhhc0NvdW50ZXIoY291 bnRlck5hbWUsIGNvdW50ZXJJbmNyZW1lbnRMaXN0LmdldCgpKTsKKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKK3N0YXRpYyBpbnQgcmVhZENvdW50ZXIoY29uc3QgU3RyaW5nJiBjLCBDU1NWYWx1ZUxp c3QqIGwsIGJvb2wgaXNSZXNldCkKK3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAg aW50IHRvdGFsID0gMDsKKyAgICAKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7 CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmltaXRpdmVWYWx1ZSA9IHN0YXRpY19jYXN0 PENTU1ByaW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7CisgICAgICAgIFBhaXIqIHBhaXIgPSBw cmltaXRpdmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7CisgICAgICAgIEFTU0VSVChwYWlyKTsKKyAg ICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nhc3Q8Q1NTUHJp bWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUq IGNvdW50ZXJWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4ocGFpci0+c2Vj b25kKCkpOworICAgICAgICBBU1NFUlQoY291bnRlck5hbWUpOworICAgICAgICBBU1NFUlQoY291 bnRlclZhbHVlKTsKKworICAgICAgICBpZiAoY291bnRlck5hbWUtPmdldFN0cmluZ1ZhbHVlKCkg PT0gYykgeworICAgICAgICAgICAgdG90YWwgKz0gKGludCljb3VudGVyVmFsdWUtPmdldEZsb2F0 VmFsdWUoKTsKKyAgICAgICAgICAgIGlmIChpc1Jlc2V0KQorICAgICAgICAgICAgICAgIHJldHVy biB0b3RhbDsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gdG90YWw7Cit9CisK K2ludCBSZW5kZXJTdHlsZTo6Y291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUp IGNvbnN0Cit7CisgICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiByZWFk Q291bnRlcihjb3VudGVyTmFtZSwgY291bnRlclJlc2V0TGlzdC5nZXQoKSwgdHJ1ZSk7CisgICAg ZWxzZQorICAgICAgICByZXR1cm4gMDsKK30KKworaW50IFJlbmRlclN0eWxlOjpjb3VudGVySW5j cmVtZW50KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0Cit7CisgICAgaWYgKGNvdW50 ZXJJbmNyZW1lbnRMaXN0KQorICAgICAgICByZXR1cm4gcmVhZENvdW50ZXIoY291bnRlck5hbWUs IGNvdW50ZXJJbmNyZW1lbnRMaXN0LmdldCgpLCBmYWxzZSk7CisgICAgZWxzZQorICAgICAgICBy ZXR1cm4gMDsKK30KKwogY29uc3QgVmVjdG9yPFN0eWxlRGFzaGJvYXJkUmVnaW9uPiYgUmVuZGVy U3R5bGU6OmluaXRpYWxEYXNoYm9hcmRSZWdpb25zKCkKIHsgCiAgICAgc3RhdGljIFZlY3RvcjxT dHlsZURhc2hib2FyZFJlZ2lvbj4gZW1wdHlMaXN0OwpJbmRleDogV2ViQ29yZS54Y29kZXByb2ov cHJvamVjdC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagkocmV2aXNpb24gMTY3MTcpCisrKyBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oJKHdvcmtpbmcgY29weSkKQEAgLTEwODgsNiArMTA4OCwxMyBAQAogCQk5MzhFNjY2MjA5 RjA5Qjg3MDA4QTQ4RUMgLyogSlNIVE1MQ2FudmFzRWxlbWVudC5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4RTY2NjEwOUYwOUI4NzAwOEE0OEVDIC8q IEpTSFRNTENhbnZhc0VsZW1lbnQuaCAqLzsgfTsKIAkJOTM4RTY4M0MwOUYwQkQ3QjAwOEE0OEVD IC8qIEdyYXBoaWNzVHlwZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDkzOEU2ODNCMDlGMEJEN0EwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmggKi87 IH07CiAJCTkzOEU2ODU0MDlGMEJFMDQwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOEU2ODUzMDlGMEJF MDQwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmNwcCAqLzsgfTsKKwkJOTM5MkYxNDIwQUQxODVG NDAwNjkxQkQ0IC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTQxMEFEMTg1RjQwMDY5MUJENCAvKiBSZW5kZXJDb3Vu dGVyLmggKi87IH07CisJCTkzOTJGMTQ0MEFEMTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVy LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJG MTQzMEFEMTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLzsgfTsKKwkJOTM5MkYx NDYwQUQxODYwQzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICovID0g e2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTQ1MEFEMTg2MEMwMDY5MUJENCAv KiBDb3VudGVyUmVzZXROb2RlLmggKi87IH07CisJCTkzOTJGMTRBMEFEMTg2MTMwMDY5MUJENCAv KiBDb3VudGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDkzOTJGMTQ5MEFEMTg2MTMwMDY5MUJENCAvKiBDb3VudGVyUmVzZXROb2Rl LmNwcCAqLzsgfTsKKwkJOTM5MkYxNEMwQUQxODYxQjAwNjkxQkQ0IC8qIENvdW50ZXJOb2RlLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzkyRjE0QjBB RDE4NjFCMDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAqLzsgfTsKKwkJOTM5MkYxNTAwQUQxODYy MzAwNjkxQkQ0IC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTRGMEFEMTg2MjMwMDY5MUJENCAvKiBDb3VudGVyTm9k ZS5jcHAgKi87IH07CisJCTkzOTJGMTUyMEFEMTg2MkIwMDY5MUJENCAvKiBDb3VudGVyTGlzdEl0 ZW0uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJG MTUxMEFEMTg2MkIwMDY5MUJENCAvKiBDb3VudGVyTGlzdEl0ZW0uaCAqLzsgfTsKIAkJOTM5ODg1 QzMwOEI3RTNEMTAwRTcwN0M0IC8qIEV2ZW50TmFtZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM5ODg1QzEwOEI3RTNEMTAwRTcwN0M0IC8qIEV2 ZW50TmFtZXMuY3BwICovOyB9OwogCQk5Mzk4ODVDNDA4QjdFM0QxMDBFNzA3QzQgLyogRXZlbnRO YW1lcy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM5 ODg1QzIwOEI3RTNEMTAwRTcwN0M0IC8qIEV2ZW50TmFtZXMuaCAqLzsgfTsKIAkJOTNBMUVBQTAw QTU2MzRDOTAwNjk2MEEwIC8qIEltYWdlRG9jdW1lbnRNYWMubW0gaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0ExRUE5RjBBNTYzNEM5MDA2OTYwQTAgLyog SW1hZ2VEb2N1bWVudE1hYy5tbSAqLzsgfTsKQEAgLTM2MzYsNiArMzY0MywxMyBAQAogCQk5MzhF NjY2MTA5RjA5Qjg3MDA4QTQ4RUMgLyogSlNIVE1MQ2FudmFzRWxlbWVudC5oICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBKU0hUTUxDYW52YXNFbGVtZW50Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTkzOEU2ODNCMDlGMEJEN0EwMDhBNDhFQyAvKiBHcmFwaGljc1R5 cGVzLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFz dEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEdyYXBoaWNzVHlwZXMuaDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM4RTY4NTMwOUYwQkUwNDAwOEE0OEVDIC8q IEdyYXBoaWNzVHlwZXMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g R3JhcGhpY3NUeXBlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzOTJGMTQx MEFEMTg1RjQwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IHBhdGggPSBSZW5kZXJDb3VudGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCTkzOTJGMTQzMEFEMTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW5kZXJDb3VudGVyLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM5MkYxNDUwQUQxODYwQzAwNjkxQkQ0IC8qIENvdW50 ZXJSZXNldE5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJS ZXNldE5vZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM5MkYxNDkwQUQxODYx MzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Y3BwLmNwcDsgcGF0aCA9IENvdW50ZXJSZXNldE5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQk5MzkyRjE0QjBBRDE4NjFCMDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJOb2RlLmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CisJCTkzOTJGMTRGMEFEMTg2MjMwMDY5MUJENCAvKiBDb3VudGVyTm9k ZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ291bnRlck5vZGUu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzkyRjE1MTBBRDE4NjJCMDA2OTFC RDQgLyogQ291bnRlckxpc3RJdGVtLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmls ZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBDb3VudGVyTGlzdEl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM5NEUw QTQwM0FBNUJCRTAwODYzNUNFIC8qIFdlYkNvcmVQYWdlU3RhdGUuaCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBpbmRlbnRXaWR0aCA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWJDb3JlUGFnZVN0YXRlLmg7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IHRhYldpZHRoID0gODsgdXNlc1RhYnMgPSAwOyB9OwogCQk5 Mzk0RTBBNTAzQUE1QkJFMDA4NjM1Q0UgLyogV2ViQ29yZVBhZ2VTdGF0ZS5tbSAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBpbmRlbnRXaWR0aCA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV2ViQ29yZVBh Z2VTdGF0ZS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgdGFiV2lkdGggPSA4OyB1c2VzVGFi cyA9IDA7IH07CiAJCTkzOTU1QTQxMDNENzI5MzIwMDg2MzVDRSAvKiBSZW5kZXJUcmVlQXNUZXh0 LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgaW5kZW50 V2lkdGggPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVu ZGVyVHJlZUFzVGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB0YWJXaWR0aCA9IDg7IHVz ZXNUYWJzID0gMDsgfTsKQEAgLTc4NTMsNiArNzg2NywxMSBAQAogCQkJCUJDRUE0ODE0MDk3RDkz MDIwMDk0QzlFNCAvKiBiaWRpLmggKi8sCiAJCQkJQkNFQTQ4MTUwOTdEOTMwMjAwOTRDOUU0IC8q IGJyZWFrX2xpbmVzLmNwcCAqLywKIAkJCQlCQ0VBNDgxNjA5N0Q5MzAyMDA5NEM5RTQgLyogYnJl YWtfbGluZXMuaCAqLywKKwkJCQk5MzkyRjE1MTBBRDE4NjJCMDA2OTFCRDQgLyogQ291bnRlckxp c3RJdGVtLmggKi8sCisJCQkJOTM5MkYxNEYwQUQxODYyMzAwNjkxQkQ0IC8qIENvdW50ZXJOb2Rl LmNwcCAqLywKKwkJCQk5MzkyRjE0QjBBRDE4NjFCMDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAq LywKKwkJCQk5MzkyRjE0OTBBRDE4NjEzMDA2OTFCRDQgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAg Ki8sCisJCQkJOTM5MkYxNDUwQUQxODYwQzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuaCAq LywKIAkJCQlCQ0VBNDgxNzA5N0Q5MzAyMDA5NEM5RTQgLyogRGF0YVJlZi5oICovLAogCQkJCUFC RTdCNTIxMEE0ODlGODMwMDMxODgxQyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmNwcCAqLywK IAkJCQlBQkU3QjUyMjBBNDg5RjgzMDAzMTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5o ICovLApAQCAtNzg4OSw2ICs3OTA4LDggQEAKIAkJCQlCQ0VBNDgyOTA5N0Q5MzAyMDA5NEM5RTQg LyogUmVuZGVyVmlldy5oICovLAogCQkJCUJDRUE0ODJDMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5k ZXJDb250YWluZXIuY3BwICovLAogCQkJCUJDRUE0ODJEMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5k ZXJDb250YWluZXIuaCAqLywKKwkJCQk5MzkyRjE0MzBBRDE4NUZFMDA2OTFCRDQgLyogUmVuZGVy Q291bnRlci5jcHAgKi8sCisJCQkJOTM5MkYxNDEwQUQxODVGNDAwNjkxQkQ0IC8qIFJlbmRlckNv dW50ZXIuaCAqLywKIAkJCQlBOEVBNzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRz ZXQuY3BwICovLAogCQkJCUE4RUE3M0IwMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNl dC5oICovLAogCQkJCTA2NkM3NzJFMEFCNjAzRkQwMDIzOENDNCAvKiBSZW5kZXJGaWxlVXBsb2Fk Q29udHJvbC5jcHAgKi8sCkBAIC05MzE5LDYgKzkzNDAsMTAgQEAKIAkJCQk4NTAwNERBNjBBQ0VF QjVBMDBDNDM4RjYgLyogRE9NU1ZHRG9jdW1lbnRJbnRlcm5hbC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJODUwMDREQTcwQUNFRUI1QTAwQzQzOEY2IC8qIERPTVNWR0VsbGlwc2VFbGVtZW50SW50ZXJu YWwuaCBpbiBIZWFkZXJzICovLAogCQkJCUFCQjU0MTlGMEFDRERGRTQwMDI4MjBFQiAvKiBSZW5k ZXJMaXN0Qm94LmggaW4gSGVhZGVycyAqLywKKwkJCQk5MzkyRjE0MjBBRDE4NUY0MDA2OTFCRDQg LyogUmVuZGVyQ291bnRlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM5MkYxNDYwQUQxODYwQzAw NjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzOTJGMTRD MEFEMTg2MUIwMDY5MUJENCAvKiBDb3VudGVyTm9kZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM5 MkYxNTIwQUQxODYyQjAwNjkxQkQ0IC8qIENvdW50ZXJMaXN0SXRlbS5oIGluIEhlYWRlcnMgKi8s CiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07 CkBAIC0xMDQ0Niw2ICsxMDQ3MSw5IEBACiAJCQkJODUwMDREOTkwQUNFRUFFRjAwQzQzOEY2IC8q IERPTVNWR0RvY3VtZW50Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJODUwMDREOUIwQUNFRUFFRjAw QzQzOEY2IC8qIERPTVNWR0VsbGlwc2VFbGVtZW50Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJQUJC NTQxOUUwQUNEREZFNDAwMjgyMEVCIC8qIFJlbmRlckxpc3RCb3guY3BwIGluIFNvdXJjZXMgKi8s CisJCQkJOTM5MkYxNDQwQUQxODVGRTAwNjkxQkQ0IC8qIFJlbmRlckNvdW50ZXIuY3BwIGluIFNv dXJjZXMgKi8sCisJCQkJOTM5MkYxNEEwQUQxODYxMzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5v ZGUuY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJOTM5MkYxNTAwQUQxODYyMzAwNjkxQkQ0IC8qIENv dW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3lt ZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogY3NzL0NTU0NvbXB1dGVkU3R5bGVE ZWNsYXJhdGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJh dGlvbi5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJh dGlvbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTYwMiwxMSArNjAyLDkgQEAKICAgICAgICAgLy8g RklYTUU6IHVuaW1wbGVtZW50ZWQKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBDU1NfUFJPUF9D T1VOVEVSX0lOQ1JFTUVOVDoKLSAgICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50ZWQKLSAgICAg ICAgYnJlYWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+Y291bnRlckluY3JlbWVudFZhbHVlTGlz dCgpOwogICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNFVDoKLSAgICAgICAgLy8gRklYTUU6 IHVuaW1wbGVtZW50ZWQKLSAgICAgICAgYnJlYWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+Y291 bnRlclJlc2V0VmFsdWVMaXN0KCk7CiAgICAgY2FzZSBDU1NfUFJPUF9DVVJTT1I6IHsKICAgICAg ICAgQ1NTVmFsdWVMaXN0KiBsaXN0ID0gMDsKICAgICAgICAgQ1NTVmFsdWUqIHZhbHVlID0gMDsK SW5kZXg6IGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3Nzc3R5 bGVzZWxlY3Rvci5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL2Nzc3N0eWxlc2VsZWN0b3Iu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAiQ1NTU3R5bGVT aGVldC5oIgogI2luY2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKICNpbmNsdWRlICJDU1NWYWx1 ZUxpc3QuaCIKKyNpbmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIK ICNpbmNsdWRlICJEYXNoYm9hcmRSZWdpb24uaCIKICNpbmNsdWRlICJGb250RmFtaWx5VmFsdWUu aCIKQEAgLTc1NywxOCArNzU4LDE2IEBACiAKIHZvaWQgQ1NTU3R5bGVTZWxlY3Rvcjo6bWF0Y2hV QVJ1bGVzKGludCYgZmlyc3RVQVJ1bGUsIGludCYgbGFzdFVBUnVsZSkKIHsKLSAgICAvLyAxLiBG aXJzdCB3ZSBtYXRjaCBydWxlcyBmcm9tIHRoZSB1c2VyIGFnZW50IHNoZWV0LgotICAgIG1hdGNo UnVsZXMoZGVmYXVsdFN0eWxlLCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CisgICAgLy8gRmly c3Qgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgdXNlciBhZ2VudCBzaGVldC4KKyAgICBDU1NSdWxl U2V0KiB1c2VyQWdlbnRTdHlsZVNoZWV0ID0gbV9tZWRpdW0tPm1lZGlhVHlwZU1hdGNoKCJwcmlu dCIpCisgICAgICAgID8gZGVmYXVsdFByaW50U3R5bGUgOiBkZWZhdWx0U3R5bGU7CisgICAgbWF0 Y2hSdWxlcyh1c2VyQWdlbnRTdHlsZVNoZWV0LCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CiAK LSAgICAvLyAyLiBJbiBxdWlya3MgbW9kZSwgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgcXVpcmtz IHVzZXIgYWdlbnQgc2hlZXQuCisgICAgLy8gSW4gcXVpcmtzIG1vZGUsIHdlIG1hdGNoIHJ1bGVz IGZyb20gdGhlIHF1aXJrcyB1c2VyIGFnZW50IHNoZWV0LgogICAgIGlmICghc3RyaWN0UGFyc2lu ZykKICAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtzU3R5bGUsIGZpcnN0VUFSdWxlLCBs YXN0VUFSdWxlKTsKLQotICAgIC8vIDMuIElmIG91ciBtZWRpdW0gaXMgcHJpbnQsIHRoZW4gd2Ug bWF0Y2ggcnVsZXMgZnJvbSB0aGUgcHJpbnQgc2hlZXQuCi0gICAgaWYgKG1fbWVkaXVtLT5tZWRp YVR5cGVNYXRjaCgicHJpbnQiKSkKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UHJpbnRTdHls ZSwgZmlyc3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogICAgICAgICAKLSAgICAvLyA0LiBJZiB3ZSdy ZSBpbiB2aWV3IHNvdXJjZSBtb2RlLCB0aGVuIHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhlIHZpZXcg c291cmNlIHN0eWxlIHNoZWV0LgorICAgIC8vIElmIHdlJ3JlIGluIHZpZXcgc291cmNlIG1vZGUs IHRoZW4gd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgdmlldyBzb3VyY2Ugc3R5bGUgc2hlZXQuCiAg ICAgaWYgKHZpZXcgJiYgdmlldy0+ZnJhbWUoKSAmJiB2aWV3LT5mcmFtZSgpLT5pblZpZXdTb3Vy Y2VNb2RlKCkpCiAgICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdTb3VyY2VTdHlsZSwgZmly c3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogfQpAQCAtMzE3Niw3ICszMTc1LDkgQEAKIAogICAgICAg ICBmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CiAgICAgICAgICAgICBDU1NWYWx1ZSAq aXRlbSA9IGxpc3QtPml0ZW0oaSk7Ci0gICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZl VmFsdWUoKSkgY29udGludWU7CisgICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZlVmFs dWUoKSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIAogICAgICAgICAg ICAgQ1NTUHJpbWl0aXZlVmFsdWUgKnZhbCA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVl Kj4oaXRlbSk7CiAgICAgICAgICAgICBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1p dGl2ZVZhbHVlOjpDU1NfU1RSSU5HKQogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50 KHZhbC0+Z2V0U3RyaW5nVmFsdWUoKS5pbXBsKCksIGkgIT0gMCk7CkBAIC0zMTkwLDE5ICszMTkx LDI4IEBACiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoZWxlbWVudC0+Z2V0QXR0 cmlidXRlKGF0dHIpLmltcGwoKSwgaSAhPSAwKTsKICAgICAgICAgICAgICAgICAvLyByZWdpc3Rl ciB0aGUgZmFjdCB0aGF0IHRoZSBhdHRyaWJ1dGUgdmFsdWUgYWZmZWN0cyB0aGUgc3R5bGUKICAg ICAgICAgICAgICAgICBtX3NlbGVjdG9yQXR0cnMuYWRkKGF0dHIubG9jYWxOYW1lKCkuaW1wbCgp KTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlw ZSgpPT1DU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgeworICAgICAgICAgICAgfSBlbHNlIGlm ICh2YWwtPnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKICAg ICAgICAgICAgICAgICBDU1NJbWFnZVZhbHVlICppbWFnZSA9IHN0YXRpY19jYXN0PENTU0ltYWdl VmFsdWUqPih2YWwpOwogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KGltYWdlLT5p bWFnZShlbGVtZW50LT5kb2N1bWVudCgpLT5kb2NMb2FkZXIoKSksIGkgIT0gMCk7Ci0gICAgICAg ICAgICB9CisgICAgICAgICAgICB9IGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX0NPVU5URVIpIHsKKyAgICAgICAgICAgICAgICBDb3VudGVyKiBj b3VudGVyVmFsdWUgPSB2YWwtPmdldENvdW50ZXJWYWx1ZSgpOworICAgICAgICAgICAgICAgIENv dW50ZXJEYXRhIGNvdW50ZXIoY291bnRlclZhbHVlLT5pZGVudGlmaWVyKCksCisgICAgICAgICAg ICAgICAgICAgIChFTGlzdFN0eWxlVHlwZSljb3VudGVyVmFsdWUtPmxpc3RTdHlsZU51bWJlcigp LCBjb3VudGVyVmFsdWUtPnNlcGFyYXRvcigpKTsKKyAgICAgICAgICAgICAgICBzdHlsZS0+c2V0 Q29udGVudChuZXcgQ291bnRlckRhdGEoY291bnRlciksIGkgIT0gMCk7CisgICAgICAgICAgIH0K ICAgICAgICAgfQogICAgICAgICBicmVhazsKICAgICB9CiAKICAgICBjYXNlIENTU19QUk9QX0NP VU5URVJfSU5DUkVNRU5UOgotICAgICAgICAvLyBsaXN0IG9mIENTUzJDb3VudGVySW5jcmVtZW50 CisgICAgICAgIGlmICghdmFsdWUtPmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47 CisgICAgICAgIHN0eWxlLT5zZXRDb3VudGVySW5jcmVtZW50TGlzdChzdGF0aWNfY2FzdDxDU1NW YWx1ZUxpc3QqPih2YWx1ZSkpOworICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0NP VU5URVJfUkVTRVQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNldAorICAgICAg ICBpZiAoIXZhbHVlLT5pc1ZhbHVlTGlzdCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAg ICBzdHlsZS0+c2V0Q291bnRlclJlc2V0TGlzdChzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QqPih2 YWx1ZSkpOwogICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOiB7 CiAgICAgICAgIC8vIGxpc3Qgb2Ygc3RyaW5ncyBhbmQgaWRzCkluZGV4OiBjc3MvY3NzcGFyc2Vy LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5oCShyZXZpc2lvbiAxNjcxNykKKysrIGNz cy9jc3NwYXJzZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMTIwLDcgKzEyMCw3IEBACiAKICAgICAg ICAgRG9jdW1lbnQqIGRvY3VtZW50KCkgY29uc3Q7CiAKLSAgICAgICAgdm9pZCBhZGRQcm9wZXJ0 eShpbnQgcHJvcElkLCBDU1NWYWx1ZSosIGJvb2wgaW1wb3J0YW50KTsKKyAgICAgICAgdm9pZCBh ZGRQcm9wZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiwgYm9vbCBpbXBvcnRh bnQpOwogICAgICAgICB2b2lkIHJvbGxiYWNrTGFzdFByb3BlcnRpZXMoaW50IG51bSk7CiAgICAg ICAgIGJvb2wgaGFzUHJvcGVydGllcygpIGNvbnN0IHsgcmV0dXJuIG51bVBhcnNlZFByb3BlcnRp ZXMgPiAwOyB9CiAKQEAgLTE0NiwxMSArMTQ2LDEzIEBACiAKICAgICAgICAgYm9vbCBwYXJzZVNo YXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgYm9vbCBwYXJzZUZvbnQo Ym9vbCBpbXBvcnRhbnQpOworICAgICAgICBib29sIHBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBp bnQgZGVmYXVsdFZhbHVlLCBib29sIGltcG9ydGFudCk7CiAgICAgICAgIENTU1ZhbHVlTGlzdCog cGFyc2VGb250RmFtaWx5KCk7CiAgICAgICAgIGJvb2wgcGFyc2VDb2xvclBhcmFtZXRlcnMoVmFs dWUqLCBpbnQqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBib29sIHBh cnNlSFNMUGFyYW1ldGVycyhWYWx1ZSosIGRvdWJsZSogY29sb3JWYWx1ZXMsIGJvb2wgcGFyc2VB bHBoYSk7CiAgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yKCk7CiAgICAgICAg IENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yRnJvbVZhbHVlKFZhbHVlKik7CisgICAgICAg IFBhc3NSZWZQdHI8Q1NTVmFsdWU+IHBhcnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0KiBhcmdz LCBib29sIGNvdW50ZXJzKTsKICAgICAgICAgCiAjaWZkZWYgU1ZHX1NVUFBPUlQKICAgICAgICAg Ym9vbCBwYXJzZVNWR1ZhbHVlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKSW5kZXg6IGNz cy9DU1NQcmltaXRpdmVWYWx1ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZh bHVlLmNwcAkocmV2aXNpb24gMTY3MTcpCisrKyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC01MjQsNyArNTI0LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAg ICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAg Ly8gIyMjCisgICAgICAgICAgICB0ZXh0ID0gImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQg Kz0gU3RyaW5nOjpudW1iZXIobV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7 CisgICAgICAgICAgICAvLyBGSVhNRTogQWRkIGxpc3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAg ICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJl Y3RJbXBsKiByZWN0VmFsID0gZ2V0UmVjdFZhbHVlKCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIGNzcy9Db3VudGVyLmgJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL0NvdW50 ZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMjMsMjMgKzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJf SAogI2RlZmluZSBDb3VudGVyX0gKIAorI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisj aW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIKICNpbmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRl ICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ291bnRlciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4g ewogcHVibGljOgotICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVu dGlmaWVyOyB9Ci0gICAgU3RyaW5nIGxpc3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0 eWxlOyB9Ci0gICAgU3RyaW5nIHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9y OyB9CisgICAgQ291bnRlcigpIDogbV9pZGVudGlmaWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9z ZXBhcmF0b3IoMCkgeyB9CisgICAgQ291bnRlcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBpZGVudGlmaWVyLCBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisg ICAgICAgIFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAg OiBtX2lkZW50aWZpZXIoaWRlbnRpZmllciksIG1fbGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2Vw YXJhdG9yKHNlcGFyYXRvcikgeyB9CisgICAgfkNvdW50ZXIoKSB7IH0KIAotcHJpdmF0ZToKLSAg ICBTdHJpbmcgbV9pZGVudGlmaWVyOwotICAgIFN0cmluZyBtX2xpc3RTdHlsZTsKLSAgICBTdHJp bmcgbV9zZXBhcmF0b3I7Ci19OworICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1 cm4gbV9pZGVudGlmaWVyID8gbV9pZGVudGlmaWVyLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5n KCk7IH0KKyAgICBTdHJpbmcgbGlzdFN0eWxlKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUg PyBtX2xpc3RTdHlsZS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5n IHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yID8gbV9zZXBhcmF0b3ItPmdl dFN0cmluZ1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQogCi19IC8vIG5hbWVzcGFjZQorICAgIGludCBs aXN0U3R5bGVOdW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZSA/IChpbnQpIG1fbGlz dFN0eWxlLT5nZXRGbG9hdFZhbHVlKCkgOiAwOyB9CisgICAgCisgICAgdm9pZCBzZXRJZGVudGlm aWVyKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGlkZW50aWZpZXIpIHsgbV9pZGVudGlm aWVyID0gaWRlbnRpZmllcjsgfQorICAgIHZvaWQgc2V0TGlzdFN0eWxlKFBhc3NSZWZQdHI8Q1NT UHJpbWl0aXZlVmFsdWU+IGxpc3RTdHlsZSkgeyBtX2xpc3RTdHlsZSA9IGxpc3RTdHlsZTsgfQor ICAgIHZvaWQgc2V0U2VwYXJhdG9yKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFy YXRvcikgeyBtX3NlcGFyYXRvciA9IHNlcGFyYXRvcjsgfQorIAorcHJvdGVjdGVkOgorICAgIFJl ZlB0cjxDU1NQcmltaXRpdmVWYWx1ZT4gbV9pZGVudGlmaWVyOyAvLyBTdHJpbmcKKyAgICBSZWZQ dHI8Q1NTUHJpbWl0aXZlVmFsdWU+IG1fbGlzdFN0eWxlOyAgLy8gaW50CisgICAgUmVmUHRyPENT U1ByaW1pdGl2ZVZhbHVlPiBtX3NlcGFyYXRvcjsgIC8vIFN0cmluZworIH07CiAKK30gLy9uYW1l c3BhY2UKKwogI2VuZGlmCkluZGV4OiBjc3MvY3NzcGFyc2VyLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBj c3MvY3NzcGFyc2VyLmNwcAkocmV2aXNpb24gMTY3MTcpCisrKyBjc3MvY3NzcGFyc2VyLmNwcAko d29ya2luZyBjb3B5KQpAQCAtNDMsNiArNDMsNyBAQAogI2luY2x1ZGUgIkNTU1F1aXJrUHJpbWl0 aXZlVmFsdWUuaCIKICNpbmNsdWRlICJDU1NWYWx1ZUtleXdvcmRzLmgiCiAjaW5jbHVkZSAiQ1NT VmFsdWVMaXN0LmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgogI2luY2x1ZGUgIkRhc2hib2FyZFJl Z2lvbi5oIgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRm9udEZhbWlseVZhbHVl LmgiCkBAIC0zMzUsNyArMzM2LDcgQEAKIH0KIAogCi12b2lkIENTU1BhcnNlcjo6YWRkUHJvcGVy dHkoaW50IHByb3BJZCwgQ1NTVmFsdWUgKnZhbHVlLCBib29sIGltcG9ydGFudCkKK3ZvaWQgQ1NT UGFyc2VyOjphZGRQcm9wZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiB2YWx1 ZSwgYm9vbCBpbXBvcnRhbnQpCiB7CiAgICAgQ1NTUHJvcGVydHkgKnByb3AgPSBuZXcgQ1NTUHJv cGVydHkocHJvcElkLCB2YWx1ZSwgaW1wb3J0YW50LCBtX2N1cnJlbnRTaG9ydGhhbmQsIG1faW1w bGljaXRTaG9ydGhhbmQpOwogICAgIGlmIChudW1QYXJzZWRQcm9wZXJ0aWVzID49IG1heFBhcnNl ZFByb3BlcnRpZXMpIHsKQEAgLTkxMyw2ICs5MTQsMTYgQEAKICAgICAgICAgZWxzZQogICAgICAg ICAgICAgdmFsaWRfcHJpbWl0aXZlID0gKCFpZCAmJiB2YWxpZFVuaXQodmFsdWUsIEZOdW1iZXJ8 Rkxlbmd0aHxGUGVyY2VudCwgc3RyaWN0KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgQ1NT X1BST1BfQ09VTlRFUl9JTkNSRU1FTlQ6ICAgIC8vIFsgPGlkZW50aWZpZXI+IDxpbnRlZ2VyPj8g XSsgfCBub25lIHwgaW5oZXJpdAorICAgICAgICBpZiAoaWQgIT0gQ1NTX1ZBTF9OT05FKQorICAg ICAgICAgICAgcmV0dXJuIHBhcnNlQ291bnRlcihwcm9wSWQsIDEsIGltcG9ydGFudCk7CisgICAg ICAgIHZhbGlkX3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGJyZWFrOworICAgICBjYXNlIENT U19QUk9QX0NPVU5URVJfUkVTRVQ6ICAgICAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/ IF0rIHwgbm9uZSB8IGluaGVyaXQKKyAgICAgICAgaWYgKGlkICE9IENTU19WQUxfTk9ORSkKKyAg ICAgICAgICAgIHJldHVybiBwYXJzZUNvdW50ZXIocHJvcElkLCAwLCBpbXBvcnRhbnQpOworICAg ICAgICB2YWxpZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAgICBicmVhazsKICAgICBjYXNlIENT U19QUk9QX0ZPTlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFtaWx5LW5hbWU+IHwgPGdlbmVy aWMtZmFtaWx5PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5Pl0gfCBpbmhl cml0CiAgICAgewpAQCAtMTU2NiwyOCArMTU3NywzOCBAQAogLy8gWyA8c3RyaW5nPiB8IGF0dHIo WCkgfCBvcGVuLXF1b3RlIHwgY2xvc2UtcXVvdGUgfCBuby1vcGVuLXF1b3RlIHwgbm8tY2xvc2Ut cXVvdGUgXSsgfCBpbmhlcml0CiBib29sIENTU1BhcnNlcjo6cGFyc2VDb250ZW50KGludCBwcm9w SWQsIGJvb2wgaW1wb3J0YW50KQogewotICAgIENTU1ZhbHVlTGlzdCogdmFsdWVzID0gbmV3IENT U1ZhbHVlTGlzdDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiB2YWx1ZXMgPSBuZXcgQ1NTVmFs dWVMaXN0OwogCiAgICAgd2hpbGUgKFZhbHVlKiB2YWwgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKSkg ewotICAgICAgICBDU1NWYWx1ZSogcGFyc2VkVmFsdWUgPSAwOworICAgICAgICBSZWZQdHI8Q1NT VmFsdWU+IHBhcnNlZFZhbHVlOwogICAgICAgICBpZiAodmFsLT51bml0ID09IENTU1ByaW1pdGl2 ZVZhbHVlOjpDU1NfVVJJKSB7CiAgICAgICAgICAgICAvLyB1cmwKICAgICAgICAgICAgIFN0cmlu ZyB2YWx1ZSA9IHBhcnNlVVJMKGRvbVN0cmluZyh2YWwtPnN0cmluZykpOwogICAgICAgICAgICAg cGFyc2VkVmFsdWUgPSBuZXcgQ1NTSW1hZ2VWYWx1ZSgKICAgICAgICAgICAgICAgICBTdHJpbmco S1VSTChzdHlsZUVsZW1lbnQtPmJhc2VVUkwoKS5kZXByZWNhdGVkU3RyaW5nKCksIHZhbHVlLmRl cHJlY2F0ZWRTdHJpbmcoKSkudXJsKCkpLCBzdHlsZUVsZW1lbnQpOwogICAgICAgICB9IGVsc2Ug aWYgKHZhbC0+dW5pdCA9PSBWYWx1ZTo6RnVuY3Rpb24pIHsKLSAgICAgICAgICAgIC8vIGF0dHIo WCkKKyAgICAgICAgICAgIC8vIGF0dHIoWCkgfCBjb3VudGVyKFggWyxZXSkgfCBjb3VudGVycyhY LCBZLCBbLFpdKQogICAgICAgICAgICAgVmFsdWVMaXN0ICphcmdzID0gdmFsLT5mdW5jdGlvbi0+ YXJnczsKICAgICAgICAgICAgIFN0cmluZyBmbmFtZSA9IGRvbVN0cmluZyh2YWwtPmZ1bmN0aW9u LT5uYW1lKS5sb3dlcigpOwotICAgICAgICAgICAgaWYgKGZuYW1lICE9ICJhdHRyKCIgfHwgIWFy Z3MpCisgICAgICAgICAgICBpZiAoIWFyZ3MpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNl OwotICAgICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAgICAgaWYgKGZu YW1lID09ICJhdHRyKCIpIHsKKyAgICAgICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEp CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgICBWYWx1 ZSogYSA9IGFyZ3MtPmN1cnJlbnQoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUg PSBkb21TdHJpbmcoYS0+c3RyaW5nKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+ aXNIVE1MRG9jdW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgYXR0ck5hbWUgPSBhdHRyTmFt ZS5sb3dlcigpOworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2 ZVZhbHVlKGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0FUVFIpOworICAgICAgICAg ICAgfSBlbHNlIGlmIChmbmFtZSA9PSAiY291bnRlcigiKSB7CisgICAgICAgICAgICAgICAgcGFy c2VkVmFsdWUgPSBwYXJzZUNvdW50ZXJDb250ZW50KGFyZ3MsIGZhbHNlKTsKKyAgICAgICAgICAg ICAgICBpZiAoIXBhcnNlZFZhbHVlKSByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9IGVsc2Ug aWYgKGZuYW1lID09ICJjb3VudGVycygiKSB7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUg PSBwYXJzZUNvdW50ZXJDb250ZW50KGFyZ3MsIHRydWUpOworICAgICAgICAgICAgICAgIGlmICgh cGFyc2VkVmFsdWUpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAg ICAgIH0gZWxzZQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAgICAgICAgIFZh bHVlICphID0gYXJncy0+Y3VycmVudCgpOwotICAgICAgICAgICAgU3RyaW5nIGF0dHJOYW1lID0g ZG9tU3RyaW5nKGEtPnN0cmluZyk7Ci0gICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+aXNIVE1M RG9jdW1lbnQoKSkKLSAgICAgICAgICAgICAgICBhdHRyTmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7 Ci0gICAgICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShhdHRyTmFt ZSwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19BVFRSKTsKICAgICAgICAgfSBlbHNlIGlmICh2YWwt PnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkgewogICAgICAgICAgICAgLy8g b3Blbi1xdW90ZQogICAgICAgICAgICAgLy8gY2xvc2UtcXVvdGUKQEAgLTE1OTksMTcgKzE2MjAs MTYgQEAKICAgICAgICAgfQogICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKQogICAgICAgICAgICAg YnJlYWs7Ci0gICAgICAgIHZhbHVlcy0+YXBwZW5kKHBhcnNlZFZhbHVlKTsKKyAgICAgICAgdmFs dWVzLT5hcHBlbmQocGFyc2VkVmFsdWUucmVsZWFzZSgpKTsKICAgICAgICAgdmFsdWVMaXN0LT5u ZXh0KCk7CiAgICAgfQogCiAgICAgaWYgKHZhbHVlcy0+bGVuZ3RoKCkpIHsKLSAgICAgICAgYWRk UHJvcGVydHkocHJvcElkLCB2YWx1ZXMsIGltcG9ydGFudCk7CisgICAgICAgIGFkZFByb3BlcnR5 KHByb3BJZCwgdmFsdWVzLnJlbGVhc2UoKSwgaW1wb3J0YW50KTsKICAgICAgICAgdmFsdWVMaXN0 LT5uZXh0KCk7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIAotICAgIGRlbGV0ZSB2YWx1 ZXM7CiAgICAgcmV0dXJuIGZhbHNlOwogfQogCkBAIC0yMDIxLDYgKzIwNDEsNTkgQEAKIH0KICNl bmRpZgogCitQYXNzUmVmUHRyPENTU1ZhbHVlPiBDU1NQYXJzZXI6OnBhcnNlQ291bnRlckNvbnRl bnQoVmFsdWVMaXN0KiBhcmdzLCBib29sIGNvdW50ZXJzKQoreworICAgIHVuc2lnbmVkIG51bUFy Z3MgPSBhcmdzLT5zaXplKCk7CisgICAgaWYgKGNvdW50ZXJzICYmIG51bUFyZ3MgIT0gMyAmJiBu dW1BcmdzICE9IDUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghY291bnRlcnMgJiYgbnVt QXJncyAhPSAxICYmIG51bUFyZ3MgIT0gMykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisgICAg VmFsdWUqIGkgPSBhcmdzLT5jdXJyZW50KCk7CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVl PiBpZGVudGlmaWVyID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcp LAorICAgICAgICBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7CisKKyAgICBSZWZQdHI8 Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcjsKKyAgICBpZiAoIWNvdW50ZXJzKQorICAgICAg ICBzZXBhcmF0b3IgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoU3RyaW5nKCksIENTU1ByaW1pdGl2 ZVZhbHVlOjpDU1NfU1RSSU5HKTsKKyAgICBlbHNlIHsKKyAgICAgICAgaSA9IGFyZ3MtPm5leHQo KTsKKyAgICAgICAgaWYgKGktPnVuaXQgIT0gVmFsdWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAh PSAnLCcpCisgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIGkgPSBhcmdz LT5uZXh0KCk7CisgICAgICAgIGlmIChpLT51bml0ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1Nf U1RSSU5HKQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBzZXBhcmF0 b3IgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5nKGktPnN0cmluZyksIChDU1NQcmlt aXRpdmVWYWx1ZTo6VW5pdFR5cGVzKSBpLT51bml0KTsKKyAgICB9CisKKyAgICBSZWZQdHI8Q1NT UHJpbWl0aXZlVmFsdWU+IGxpc3RTdHlsZTsKKyAgICBpID0gYXJncy0+bmV4dCgpOworICAgIGlm ICghaSkgLy8gTWFrZSB0aGUgbGlzdCBzdHlsZSBkZWZhdWx0IGRlY2ltYWwKKyAgICAgICAgbGlz dFN0eWxlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKENTU19WQUxfREVDSU1BTCAtIENTU19WQUxf RElTQywgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpOworICAgIGVsc2UgeworICAgICAg ICBpZiAoaS0+dW5pdCAhPSBWYWx1ZTo6T3BlcmF0b3IgfHwgaS0+aVZhbHVlICE9ICcsJykKKyAg ICAgICAgICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgaSA9IGFyZ3MtPm5leHQoKTsK KyAgICAgICAgaWYgKGktPnVuaXQgIT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkKKyAg ICAgICAgICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgc2hvcnQgbHMgPSAwOworICAg ICAgICBpZiAoaS0+aWQgPT0gQ1NTX1ZBTF9OT05FKQorICAgICAgICAgICAgbHMgPSBDU1NfVkFM X0tBVEFLQU5BX0lST0hBIC0gQ1NTX1ZBTF9ESVNDICsgMTsKKyAgICAgICAgZWxzZSBpZiAoaS0+ aWQgPj0gQ1NTX1ZBTF9ESVNDICYmIGktPmlkIDw9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEpCisg ICAgICAgICAgICBscyA9IGktPmlkIC0gQ1NTX1ZBTF9ESVNDOworICAgICAgICBlbHNlCisgICAg ICAgICAgICByZXR1cm4gMDsKKworICAgICAgICBsaXN0U3R5bGUgPSBuZXcgQ1NTUHJpbWl0aXZl VmFsdWUobHMsIChDU1NQcmltaXRpdmVWYWx1ZTo6VW5pdFR5cGVzKSBpLT51bml0KTsKKyAgICB9 CisKKyAgICByZXR1cm4gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKG5ldyBDb3VudGVyKGlkZW50aWZp ZXIucmVsZWFzZSgpLCBsaXN0U3R5bGUucmVsZWFzZSgpLCBzZXBhcmF0b3IucmVsZWFzZSgpKSk7 Cit9CisKIGJvb2wgQ1NTUGFyc2VyOjpwYXJzZVNoYXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0 YW50KQogewogICAgIFZhbHVlICp2YWx1ZSA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOwpAQCAtMjcx OSw2ICsyNzkyLDQ4IEBACiAgICAgcmV0dXJuIGNvbnRleHQuZmFpbGVkKCk7CiB9CiAKK2Jvb2wg Q1NTUGFyc2VyOjpwYXJzZUNvdW50ZXIoaW50IHByb3BJZCwgaW50IGRlZmF1bHRWYWx1ZSwgYm9v bCBpbXBvcnRhbnQpCit7CisgICAgZW51bSB7IElELCBWQUwgfSBzdGF0ZSA9IElEOworCisgICAg UmVmUHRyPENTU1ZhbHVlTGlzdD4gbGlzdCA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgUmVmUHRy PENTU1ByaW1pdGl2ZVZhbHVlPiBjb3VudGVyTmFtZTsKKyAgICAKKyAgICB3aGlsZSAodHJ1ZSkg eworICAgICAgICBWYWx1ZSogdmFsID0gdmFsdWVMaXN0LT5jdXJyZW50KCk7CisgICAgICAgIHN3 aXRjaCAoc3RhdGUpIHsKKyAgICAgICAgICAgIGNhc2UgSUQ6CisgICAgICAgICAgICAgICAgaWYg KHZhbCAmJiB2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkgeworICAg ICAgICAgICAgICAgICAgICBjb3VudGVyTmFtZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShkb21T dHJpbmcodmFsLT5zdHJpbmcpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7CisgICAg ICAgICAgICAgICAgICAgIHN0YXRlID0gVkFMOworICAgICAgICAgICAgICAgICAgICB2YWx1ZUxp c3QtPm5leHQoKTsKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2FzZSBWQUw6IHsKKyAg ICAgICAgICAgICAgICBpbnQgaSA9IGRlZmF1bHRWYWx1ZTsKKyAgICAgICAgICAgICAgICBpZiAo dmFsICYmIHZhbC0+dW5pdCA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX05VTUJFUikgeworICAg ICAgICAgICAgICAgICAgICBpID0gKGludCl2YWwtPmZWYWx1ZTsKKyAgICAgICAgICAgICAgICAg ICAgdmFsdWVMaXN0LT5uZXh0KCk7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAg ICAgbGlzdC0+YXBwZW5kKG5ldyBDU1NQcmltaXRpdmVWYWx1ZShuZXcgUGFpcihjb3VudGVyTmFt ZS5yZWxlYXNlKCksCisgICAgICAgICAgICAgICAgICAgIG5ldyBDU1NQcmltaXRpdmVWYWx1ZShp LCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX05VTUJFUikpKSk7CisgICAgICAgICAgICAgICAgc3Rh dGUgPSBJRDsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgfQorICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgaWYgKGxpc3QtPmxlbmd0aCgp ID4gMCkgeworICAgICAgICBhZGRQcm9wZXJ0eShwcm9wSWQsIGxpc3QucmVsZWFzZSgpLCBpbXBv cnRhbnQpOworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7 Cit9CisKICNpZmRlZiBDU1NfREVCVUcKIAogc3RhdGljIGlubGluZSBpbnQgeXllcnJvcihjb25z dCBjaGFyICpzdHIpCg== 10870 2006-10-02 12:11:03 -0700 2006-10-02 15:47:34 -0700 Okay, this one! mondayay.txt text/plain 72283 bdakin SW5kZXg6IHBsYXRmb3JtL1N0cmluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcGxhdGZvcm0vU3RyaW5n LmNwcAkocmV2aXNpb24gMTY3MTcpCisrKyBwbGF0Zm9ybS9TdHJpbmcuY3BwCSh3b3JraW5nIGNv cHkpCkBAIC0xNTcsNiArMTU3LDE0IEBACiAgICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ci5tX2lt cGwuZ2V0KCksIHBvcyk7CiB9CiAKK3ZvaWQgU3RyaW5nOjppbnNlcnQoY29uc3QgVUNoYXIqIHN0 ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpCit7CisgICAgaWYgKCFtX2ltcGwpCisg ICAgICAgIG1faW1wbCA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICBlbHNlCisg ICAgICAgIG1faW1wbC0+aW5zZXJ0KHN0ciwgbGVuZ3RoLCBwb3MpOworfQorCiBVQ2hhciBTdHJp bmc6Om9wZXJhdG9yW10odW5zaWduZWQgaSkgY29uc3QKIHsKICAgICBpZiAoIW1faW1wbCB8fCBp ID49IG1faW1wbC0+bGVuZ3RoKCkpCkluZGV4OiBwbGF0Zm9ybS9QbGF0Zm9ybVN0cmluZy5oCj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIHBsYXRmb3JtL1BsYXRmb3JtU3RyaW5nLmgJKHJldmlzaW9uIDE2NzE3KQor KysgcGxhdGZvcm0vUGxhdGZvcm1TdHJpbmcuaAkod29ya2luZyBjb3B5KQpAQCAtOTEsNiArOTEs NyBAQAogICAgIHZvaWQgYXBwZW5kKGNoYXIpOwogICAgIHZvaWQgYXBwZW5kKFVDaGFyKTsKICAg ICB2b2lkIGluc2VydChjb25zdCBTdHJpbmcmLCB1bnNpZ25lZCBwb3MpOworICAgIHZvaWQgaW5z ZXJ0KGNvbnN0IFVDaGFyKiwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25lZCBwb3MpOwogCiAgICAg U3RyaW5nJiByZXBsYWNlKFVDaGFyIGEsIFVDaGFyIGIpIHsgaWYgKG1faW1wbCkgbV9pbXBsID0g bV9pbXBsLT5yZXBsYWNlKGEsIGIpOyByZXR1cm4gKnRoaXM7IH0KICAgICBTdHJpbmcmIHJlcGxh Y2UoVUNoYXIgYSwgY29uc3QgU3RyaW5nJiBiKSB7IGlmIChtX2ltcGwpIG1faW1wbCA9IG1faW1w bC0+cmVwbGFjZShhLCBiLmltcGwoKSk7IHJldHVybiAqdGhpczsgfQpJbmRleDogcGxhdGZvcm0v U3RyaW5nSW1wbC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuaAkocmV2aXNp b24gMTY3MTcpCisrKyBwbGF0Zm9ybS9TdHJpbmdJbXBsLmgJKHdvcmtpbmcgY29weSkKQEAgLTgz LDYgKzgzLDcgQEAKICAgICB2b2lkIGFwcGVuZChjaGFyKTsKICAgICB2b2lkIGFwcGVuZChVQ2hh cik7CiAgICAgdm9pZCBpbnNlcnQoY29uc3QgU3RyaW5nSW1wbCosIHVuc2lnbmVkIHBvcyk7Cisg ICAgdm9pZCBpbnNlcnQoY29uc3QgVUNoYXIqIHN0ciwgdW5zaWduZWQgbGVuZ3RoLCB1bnNpZ25l ZCBwb3MpOwogICAgIHZvaWQgdHJ1bmNhdGUoaW50IGxlbik7CiAgICAgdm9pZCByZW1vdmUodW5z aWduZWQgcG9zLCBpbnQgbGVuID0gMSk7CiAKSW5kZXg6IHBsYXRmb3JtL1N0cmluZ0ltcGwuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCShyZXZpc2lvbiAxNjcxNykK KysrIHBsYXRmb3JtL1N0cmluZ0ltcGwuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMDAsNiArMjAw LDI3IEBACiAgICAgfQogfQogCit2b2lkIFN0cmluZ0ltcGw6Omluc2VydChjb25zdCBVQ2hhciog c3RyLCB1bnNpZ25lZCBsZW5ndGgsIHVuc2lnbmVkIHBvcykKK3sKKyAgICBhc3NlcnQoIW1faW5U YWJsZSk7CisgICAgaWYgKHBvcyA+PSBtX2xlbmd0aCkgeworICAgICAgICBSZWZQdHI8U3RyaW5n SW1wbD4gcyA9IG5ldyBTdHJpbmdJbXBsKHN0ciwgbGVuZ3RoKTsKKyAgICAgICAgYXBwZW5kKHMu Z2V0KCkpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlmIChzdHIgJiYgbGVuZ3RoICE9 IDApIHsKKyAgICAgICAgc2l6ZV90IG5ld2xlbiA9IG1fbGVuZ3RoICsgbGVuZ3RoOworICAgICAg ICBVQ2hhciogYyA9IG5ld1VDaGFyVmVjdG9yKG5ld2xlbik7CisgICAgICAgIG1lbWNweShjLCBt X2RhdGEsIHBvcyAqIHNpemVvZihVQ2hhcikpOworICAgICAgICBtZW1jcHkoYyArIHBvcywgc3Ry LCBsZW5ndGggKiBzaXplb2YoVUNoYXIpKTsKKyAgICAgICAgbWVtY3B5KGMgKyBwb3MgKyBsZW5n dGgsIG1fZGF0YSArIHBvcywgKG1fbGVuZ3RoIC0gcG9zKSAqIHNpemVvZihVQ2hhcikpOworICAg ICAgICBkZWxldGVVQ2hhclZlY3RvcihtX2RhdGEpOworICAgICAgICBtX2RhdGEgPSBjOworICAg ICAgICBtX2xlbmd0aCA9IG5ld2xlbjsKKyAgICAgICAgbV9oYXNUZXJtaW5hdGluZ051bGxDaGFy YWN0ZXIgPSBmYWxzZTsKKyAgICB9Cit9CisKIHZvaWQgU3RyaW5nSW1wbDo6dHJ1bmNhdGUoaW50 IGxlbikKIHsKICAgICBhc3NlcnQoIW1faW5UYWJsZSk7CkluZGV4OiByZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkocmV2 aXNpb24gMTY3MTcpCisrKyByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAkod29ya2luZyBjb3B5 KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9s bEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0 b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsgTXVlbGxlciAobXVlbGxlckBr ZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2Rl QGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBD b21wdXRlciwgSW5jLgogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3Ug Y2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTI5LDYgKzMwLDggQEAKICNpbmNsdWRlICJB WE9iamVjdENhY2hlLmgiIAogI2luY2x1ZGUgIkFmZmluZVRyYW5zZm9ybS5oIgogI2luY2x1ZGUg IkNhY2hlZEltYWdlLmgiCisjaW5jbHVkZSAiQ291bnRlck5vZGUuaCIKKyNpbmNsdWRlICJDb3Vu dGVyUmVzZXROb2RlLmgiCiAjaW5jbHVkZSAiRGVjb2Rlci5oIgogI2luY2x1ZGUgIkRvY3VtZW50 LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgpAQCAtMzcsNiArNDAsNyBAQAogI2luY2x1ZGUgIkZy YW1lLmgiCiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCisjaW5jbHVkZSAiSFRNTE9MaXN0RWxlbWVudC5oIgogI2luY2x1ZGUgIlBvc2l0aW9uLmgi CiAjaW5jbHVkZSAiUmVuZGVyQXJlbmEuaCIKICNpbmNsdWRlICJSZW5kZXJGbGV4aWJsZUJveC5o IgpAQCAtNjUsNiArNjksMTUgQEAKIHN0YXRpYyB2b2lkICpiYXNlT2ZSZW5kZXJPYmplY3RCZWlu Z0RlbGV0ZWQ7CiAjZW5kaWYKIAordHlwZWRlZiBIYXNoTWFwPFN0cmluZywgQ291bnRlck5vZGUq PiBDb3VudGVyTm9kZU1hcDsKK3R5cGVkZWYgSGFzaE1hcDxjb25zdCBSZW5kZXJPYmplY3QqLCBD b3VudGVyTm9kZU1hcCo+IFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwczsKKworc3RhdGlj IFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyogZ2V0UmVuZGVyT2JqZWN0c1RvQ291bnRl ck5vZGVNYXBzKCkKK3sKKyAgICBzdGF0aWMgUmVuZGVyT2JqZWN0c1RvQ291bnRlck5vZGVNYXBz IG9iamVjdHNNYXA7CisgICAgcmV0dXJuICZvYmplY3RzTWFwOworfQorCiB2b2lkKiBSZW5kZXJP YmplY3Q6Om9wZXJhdG9yIG5ldyhzaXplX3Qgc3osIFJlbmRlckFyZW5hKiByZW5kZXJBcmVuYSkg dGhyb3coKQogewogICAgIHJldHVybiByZW5kZXJBcmVuYS0+YWxsb2NhdGUoc3opOwpAQCAtMTc3 LDcgKzE5MCw4IEBACiAKIG1fcmVwbGFjZWQoIGZhbHNlICksCiBtX2lzRHJhZ2dpbmcoIGZhbHNl ICksCi1tX2hhc092ZXJmbG93Q2xpcChmYWxzZSkKK21faGFzT3ZlcmZsb3dDbGlwKGZhbHNlKSwK K21faGFzQ291bnRlck5vZGVNYXAoZmFsc2UpCiB7CiAjaWZuZGVmIE5ERUJVRwogICAgICsrUmVu ZGVyT2JqZWN0Q291bnRlcjo6Y291bnQ7CkBAIC0yNDA2LDYgKzI0MjAsMjEgQEAKIAogdm9pZCBS ZW5kZXJPYmplY3Q6OmRlc3Ryb3koKQogeworICAgIGlmIChtX2hhc0NvdW50ZXJOb2RlTWFwKSB7 CisgICAgICAgIFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcyogb2JqZWN0c01hcCA9IGdl dFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2RlTWFwcygpOworICAgICAgICBpZiAoQ291bnRlck5v ZGVNYXAqIGNvdW50ZXJOb2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKSkgeworICAgICAg ICAgICAgQ291bnRlck5vZGVNYXA6OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IGNvdW50ZXJOb2Rlc01h cC0+ZW5kKCk7CisgICAgICAgICAgICBmb3IgKENvdW50ZXJOb2RlTWFwOjpjb25zdF9pdGVyYXRv ciBpdCA9IGNvdW50ZXJOb2Rlc01hcC0+YmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAg ICAgICAgICAgICAgQ291bnRlck5vZGUqIGNvdW50ZXJOb2RlID0gaXQtPnNlY29uZDsKKyAgICAg ICAgICAgICAgICBjb3VudGVyTm9kZS0+cmVtb3ZlKCk7CisgICAgICAgICAgICAgICAgZGVsZXRl IGNvdW50ZXJOb2RlOworICAgICAgICAgICAgICAgIGNvdW50ZXJOb2RlID0gMDsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIG9iamVjdHNNYXAtPnJlbW92ZSh0aGlzKTsKKyAgICAgICAgICAg IGRlbGV0ZSBjb3VudGVyTm9kZXNNYXA7CisgICAgICAgIH0KKyAgICB9CisgICAgCiAgICAgZG9j dW1lbnQoKS0+YXhPYmplY3RDYWNoZSgpLT5yZW1vdmUodGhpcyk7CiAKICAgICAvLyBCeSBkZWZh dWx0IG5vIHJlZi1jb3VudGluZy4gUmVuZGVyV2lkZ2V0OjpkZXN0cm95KCkgZG9lc24ndCBjYWxs CkBAIC0yODQ4LDYgKzI4NzcsMTMyIEBACiAgICAgcmV0dXJuIChhdm9pZHNGbG9hdHMoKSAmJiAo c3R5bGUoKS0+d2lkdGgoKS5pc0F1dG8oKSB8fCBpc0hSKCkgfHwgKHN0eWxlKCktPmh0bWxIYWNr cygpICYmICFpc1RhYmxlKCkpKSk7CiB9CiAKK0NvdW50ZXJOb2RlKiBSZW5kZXJPYmplY3Q6OmZp bmRDb3VudGVyKGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUsIGJvb2wgd2lsbE5lZWRMYXlvdXQs CisgICAgYm9vbCB1c2VzU2VwYXJhdG9yLCBib29sIGNyZWF0ZUlmTm90Rm91bmQpCit7CisgICAg aWYgKCFzdHlsZSgpKQorICAgICAgICByZXR1cm4gMDsKKworICAgIFJlbmRlck9iamVjdHNUb0Nv dW50ZXJOb2RlTWFwcyogb2JqZWN0c01hcCA9IGdldFJlbmRlck9iamVjdHNUb0NvdW50ZXJOb2Rl TWFwcygpOworICAgIENvdW50ZXJOb2RlKiBuZXdOb2RlID0gMDsKKyAgICBpZiAoQ291bnRlck5v ZGVNYXAqIGNvdW50ZXJOb2Rlc01hcCA9IG9iamVjdHNNYXAtPmdldCh0aGlzKSkKKyAgICAgICAg aWYgKGNvdW50ZXJOb2Rlc01hcCkKKyAgICAgICAgICAgIG5ld05vZGUgPSBjb3VudGVyTm9kZXNN YXAtPmdldChjb3VudGVyTmFtZSk7CisgICAgICAgIAorICAgIGlmIChuZXdOb2RlKQorICAgICAg ICByZXR1cm4gbmV3Tm9kZTsKKworICAgIGludCB2YWwgPSAwOworICAgIGlmIChzdHlsZSgpLT5o YXNDb3VudGVyUmVzZXQoY291bnRlck5hbWUpIHx8IGlzUm9vdCgpKSB7CisgICAgICAgIG5ld05v ZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0aGlzKTsKKyAgICAgICAgdmFsID0gc3R5bGUoKS0+ Y291bnRlclJlc2V0KGNvdW50ZXJOYW1lKTsKKyAgICAgICAgaWYgKHN0eWxlKCktPmhhc0NvdW50 ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpKQorICAgICAgICAgICAgdmFsICs9IHN0eWxlKCktPmNv dW50ZXJJbmNyZW1lbnQoY291bnRlck5hbWUpOworICAgICAgICBuZXdOb2RlLT5zZXRWYWx1ZSh2 YWwpOworICAgIH0gZWxzZSBpZiAoc3R5bGUoKS0+aGFzQ291bnRlckluY3JlbWVudChjb3VudGVy TmFtZSkpIHsKKyAgICAgICAgbmV3Tm9kZSA9IG5ldyBDb3VudGVyTm9kZSh0aGlzKTsKKyAgICAg ICAgbmV3Tm9kZS0+c2V0VmFsdWUoc3R5bGUoKS0+Y291bnRlckluY3JlbWVudChjb3VudGVyTmFt ZSkpOworICAgIH0gZWxzZSBpZiAoY291bnRlck5hbWUgPT0gImxpc3QtaXRlbSIpIHsKKyAgICAg ICAgaWYgKGlzTGlzdEl0ZW0oKSkgeworICAgICAgICAgICAgaWYgKGVsZW1lbnQoKSkgeworICAg ICAgICAgICAgICAgIFN0cmluZyB2ID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KGVsZW1lbnQoKSkt PmdldEF0dHJpYnV0ZSgidmFsdWUiKTsKKyAgICAgICAgICAgICAgICBpZiAoIXYuaXNFbXB0eSgp KSB7CisgICAgICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0 aGlzKTsKKyAgICAgICAgICAgICAgICAgICAgdmFsID0gdi50b0ludCgpOworICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgIH0gCisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmICghbmV3 Tm9kZSkgeworICAgICAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5vZGUodGhpcyk7 CisgICAgICAgICAgICAgICAgdmFsID0gMTsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAg bmV3Tm9kZS0+c2V0VmFsdWUodmFsKTsKKyAgICAgICAgfSBlbHNlIGlmIChlbGVtZW50KCkgJiYg ZWxlbWVudCgpLT5oYXNUYWdOYW1lKG9sVGFnKSkgeworICAgICAgICAgICAgbmV3Tm9kZSA9IG5l dyBDb3VudGVyUmVzZXROb2RlKHRoaXMpOworICAgICAgICAgICAgbmV3Tm9kZS0+c2V0VmFsdWUo c3RhdGljX2Nhc3Q8SFRNTE9MaXN0RWxlbWVudCo+KGVsZW1lbnQoKSktPnN0YXJ0KCkpOworICAg ICAgICB9IGVsc2UgaWYgKGVsZW1lbnQoKSAmJgorICAgICAgICAgICAgKGVsZW1lbnQoKS0+aGFz VGFnTmFtZSh1bFRhZykgfHwKKyAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUobWVu dVRhZykgfHwKKyAgICAgICAgICAgICBlbGVtZW50KCktPmhhc1RhZ05hbWUoZGlyVGFnKSkpIHsK KyAgICAgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlclJlc2V0Tm9kZSh0aGlzKTsKKyAgICAg ICAgICAgIG5ld05vZGUtPnNldFZhbHVlKDApOworICAgICAgICB9CisgICAgfSAKKyAgICAKKyAg ICBpZiAoIW5ld05vZGUgJiYgIWNyZWF0ZUlmTm90Rm91bmQpCisgICAgICAgIHJldHVybiAwOwor ICAgIGVsc2UgaWYgKCFuZXdOb2RlKSB7CisgICAgICAgIG5ld05vZGUgPSBuZXcgQ291bnRlck5v ZGUodGhpcyk7CisgICAgICAgIG5ld05vZGUtPnNldFZhbHVlKDApOworICAgIH0KKworICAgIGlm ICh3aWxsTmVlZExheW91dCkKKyAgICAgICAgbmV3Tm9kZS0+c2V0V2lsbE5lZWRMYXlvdXQoKTsK KyAgICBpZiAodXNlc1NlcGFyYXRvcikKKyAgICAgICAgbmV3Tm9kZS0+c2V0VXNlc1NlcGFyYXRv cigpOworCisgICAgQ291bnRlck5vZGVNYXAqIG5vZGVNYXA7CisgICAgaWYgKG1faGFzQ291bnRl ck5vZGVNYXApCisgICAgICAgIG5vZGVNYXAgPSBvYmplY3RzTWFwLT5nZXQodGhpcyk7CisgICAg ZWxzZSB7CisgICAgICAgIG5vZGVNYXAgPSBuZXcgQ291bnRlck5vZGVNYXA7CisgICAgICAgIG9i amVjdHNNYXAtPnNldCh0aGlzLCBub2RlTWFwKTsKKyAgICAgICAgbV9oYXNDb3VudGVyTm9kZU1h cCA9IHRydWU7CisgICAgfQorICAgIAorICAgIG5vZGVNYXAtPnNldChjb3VudGVyTmFtZSwgbmV3 Tm9kZSk7CisKKyAgICBpZiAoIWlzUm9vdCgpKSB7CisgICAgICAgIFJlbmRlck9iamVjdCogbiA9 ICFpc0xpc3RJdGVtKCkgJiYgcHJldmlvdXNTaWJsaW5nKCkKKyAgICAgICAgICAgID8gcHJldmlv dXNTaWJsaW5nKCktPnByZXZpb3VzU2libGluZygpIDogcHJldmlvdXNTaWJsaW5nKCk7CisKKyAg ICAgICAgQ291bnRlck5vZGUqIGN1cnJlbnQgPSAwOworICAgICAgICBmb3IgKDsgbjsgbiA9IG4t PnByZXZpb3VzU2libGluZygpKSB7CisgICAgICAgICAgICBjdXJyZW50ID0gbi0+ZmluZENvdW50 ZXIoY291bnRlck5hbWUsIGZhbHNlLCBmYWxzZSwgZmFsc2UpOworICAgICAgICAgICAgaWYgKGN1 cnJlbnQpCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICAgICAgCisgICAg ICAgIENvdW50ZXJOb2RlKiBsYXN0ID0gY3VycmVudDsKKyAgICAgICAgQ291bnRlck5vZGUqIHNp YmxpbmcgPSBjdXJyZW50OworICAgICAgICBpZiAobGFzdCAmJiAhbmV3Tm9kZS0+aXNSZXNldCgp KSB7CisgICAgICAgICAgICAvLyBGb3VuZCByZW5kZXItc2libGluZywgbm93IHNlYXJjaCBmb3Ig bGF0ZXIgY291bnRlci1zaWJsaW5ncyBhbW9uZyBpdHMgcmVuZGVyLWNoaWxkcmVuCisgICAgICAg ICAgICBuID0gbi0+bGFzdENoaWxkKCk7CisgICAgICAgICAgICB3aGlsZSAobikgeworICAgICAg ICAgICAgICAgIGN1cnJlbnQgPSBuLT5maW5kQ291bnRlcihjb3VudGVyTmFtZSwgZmFsc2UsIGZh bHNlLCBmYWxzZSk7CisgICAgICAgICAgICAgICAgaWYgKGN1cnJlbnQgJiYgKGxhc3QtPnBhcmVu dCgpID09IGN1cnJlbnQtPnBhcmVudCgpIHx8IHNpYmxpbmcgPT0gY3VycmVudC0+cGFyZW50KCkp KSB7CisgICAgICAgICAgICAgICAgICAgIGxhc3QgPSBjdXJyZW50OworICAgICAgICAgICAgICAg ICAgICAvLyBJZiB0aGUgY3VycmVudCBjb3VudGVyIGlzIG5vdCB0aGUgbGFzdCwgc2VhcmNoIGRl ZXBlcgorICAgICAgICAgICAgICAgICAgICBpZiAoY3VycmVudC0+bmV4dFNpYmxpbmcoKSkgewor ICAgICAgICAgICAgICAgICAgICAgICAgbiA9IG4tPmxhc3RDaGlsZCgpOworICAgICAgICAgICAg ICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIH0gZWxzZQorICAgICAg ICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg ICAgIG4gPSBuLT5wcmV2aW91c1NpYmxpbmcoKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAg IAorICAgICAgICAgICAgaWYgKHNpYmxpbmctPmlzUmVzZXQoKSkgeworICAgICAgICAgICAgICAg IGlmIChsYXN0ICE9IHNpYmxpbmcpCisgICAgICAgICAgICAgICAgICAgIHNpYmxpbmctPmluc2Vy dEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAg ICAgICAgICAgc2libGluZy0+aW5zZXJ0QWZ0ZXIobmV3Tm9kZSwgMCk7CisgICAgICAgICAgICB9 IGVsc2UKKyAgICAgICAgICAgICAgICBsYXN0LT5wYXJlbnQoKS0+aW5zZXJ0QWZ0ZXIobmV3Tm9k ZSwgbGFzdCk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAvLyBOb3RoaW5nIGZvdW5k IGFtb25nIHNpYmxpbmdzLCBsZXQgb3VyIHBhcmVudCBzZWFyY2gKKyAgICAgICAgICAgIGxhc3Qg PSBwYXJlbnQoKS0+ZmluZENvdW50ZXIoY291bnRlck5hbWUsIGZhbHNlKTsKKyAgICAgICAgICAg IGlmIChsYXN0LT5pc1Jlc2V0KCkpCisgICAgICAgICAgICAgICAgbGFzdC0+aW5zZXJ0QWZ0ZXIo bmV3Tm9kZSwgMCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgbGFzdC0+cGFy ZW50KCktPmluc2VydEFmdGVyKG5ld05vZGUsIGxhc3QpOworICAgICAgICB9CisgICAgfQorCisg ICAgcmV0dXJuIG5ld05vZGU7Cit9CisKIFVDaGFyIFJlbmRlck9iamVjdDo6YmFja3NsYXNoQXND dXJyZW5jeVN5bWJvbCgpIGNvbnN0CiB7CiAgICAgaWYgKE5vZGUgKm5vZGUgPSBlbGVtZW50KCkp CkluZGV4OiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5n L1JlbmRlck9iamVjdC5oCShyZXZpc2lvbiAxNjcxNykKKysrIHJlbmRlcmluZy9SZW5kZXJPYmpl Y3QuaAkod29ya2luZyBjb3B5KQpAQCAtNCw2ICs0LDcgQEAKICAqIENvcHlyaWdodCAoQykgMjAw MCBMYXJzIEtub2xsIChrbm9sbEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIEFudHRp IEtvaXZpc3RvIChrb2l2aXN0b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAwIERpcmsg TXVlbGxlciAobXVlbGxlckBrZGUub3JnKQorICogICAgICAgICAgIChDKSAyMDA0IEFsbGFuIFNh bmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKICAqIENvcHlyaWdodCAoQykgMjAwMywg MjAwNCwgMjAwNSwgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgogICoKICAqIFRoaXMgbGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTMx LDYgKzMyLDcgQEAKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgogI2luY2x1ZGUgIlNjcm9sbEJh ci5oIgogI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFw Lmg+CiAKIC8qCiAgKiAgVGhlIHBhaW50aW5nIG9mIGEgbGF5ZXIgb2NjdXJzIGluIHRocmVlIGRp c3RpbmN0IHBoYXNlcy4gIEVhY2ggcGhhc2UgaW52b2x2ZXMKQEAgLTQ2LDYgKzQ4LDcgQEAKIGNs YXNzIEFmZmluZVRyYW5zZm9ybTsKIGNsYXNzIENvbGxhcHNlZEJvcmRlclZhbHVlOwogY2xhc3Mg Q29sb3I7CitjbGFzcyBDb3VudGVyTm9kZTsKIGNsYXNzIERvY3VtZW50OwogY2xhc3MgRWxlbWVu dDsKIGNsYXNzIEV2ZW50OwpAQCAtMTkzLDYgKzE5NiwxMCBAQAogICAgIHZpcnR1YWwgaW50IHN0 YXRpY1goKSBjb25zdCB7IHJldHVybiAwOyB9CiAgICAgdmlydHVhbCBpbnQgc3RhdGljWSgpIGNv bnN0IHsgcmV0dXJuIDA7IH0KICAgICAKKyAgICBDb3VudGVyTm9kZSogZmluZENvdW50ZXIoY29u c3QgU3RyaW5nJiBjb3VudGVyTmFtZSwgYm9vbCB3aWxsTmVlZExheW91dCA9IGZhbHNlLAorICAg ICAgICBib29sIHVzZXNTZXBhcmF0b3IgPSBmYWxzZSwgYm9vbCBjcmVhdGVJZk5vdEZvdW5kID0g dHJ1ZSk7CisKK3B1YmxpYzoKICAgICAvLyBSZW5kZXJPYmplY3QgdHJlZSBtYW5pcHVsYXRpb24K ICAgICAvLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8vLy8KICAgICB2aXJ0 dWFsIGJvb2wgY2FuSGF2ZUNoaWxkcmVuKCkgY29uc3Q7CkBAIC0yNTQsNiArMjYxLDcgQEAKICAg ICAKICAgICB2aXJ0dWFsIGJvb2wgaXNMaXN0SXRlbSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9 CiAgICAgdmlydHVhbCBib29sIGlzTGlzdE1hcmtlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9 CisgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAg ICAgdmlydHVhbCBib29sIGlzUmVuZGVyVmlldygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAg ICAgYm9vbCBpc1Jvb3QoKSBjb25zdDsKICAgICBib29sIGlzQm9keSgpIGNvbnN0OwpAQCAtOTMy LDggKzk0MCw5IEBACiAgICAgYm9vbCBtX2lzRHJhZ2dpbmcgICAgICAgICAgICAgICAgOiAxOwog ICAgIAogICAgIGJvb2wgbV9oYXNPdmVyZmxvd0NsaXAgICAgICAgICAgIDogMTsKKyAgICAKKyAg ICBib29sIG1faGFzQ291bnRlck5vZGVNYXAgICAgICAgICA6IDE7CiAKLSAgICAvLyBub3RlOiBk byBub3QgYWRkIHVubmVjZXNzYXJ5IGJpdGZsYWdzLCB3ZSBoYXZlIDMyIGJpdCBhbHJlYWR5IQog ICAgIGZyaWVuZCBjbGFzcyBSZW5kZXJMaXN0SXRlbTsKICAgICBmcmllbmQgY2xhc3MgUmVuZGVy Q29udGFpbmVyOwogICAgIGZyaWVuZCBjbGFzcyBSZW5kZXJWaWV3OwpJbmRleDogcmVuZGVyaW5n L1JlbmRlckNvdW50ZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5o CShyZXZpc2lvbiAwKQorKysgcmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuaAkocmV2aXNpb24gMCkK QEAgLTAsMCArMSw1NCBAQAorLyoKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJl bmRlcmluZyBlbmdpbmUgZm9yIEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4g U2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2 IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdh cmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRo ZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMg cHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVy c2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJz aW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdl bmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxk IGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcu TElCLiAgSWYgbm90LCB3cml0ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0x MzA3LCBVU0EuCisgKgorICovCisjaWZuZGVmIFJFTkRFUl9DT1VOVEVSX0hfCisjZGVmaW5lIFJF TkRFUl9DT1VOVEVSX0hfCisKKyNpbmNsdWRlICJSZW5kZXJUZXh0LmgiCisKK25hbWVzcGFjZSBX ZWJDb3JlIHsKKyAgICBjbGFzcyBDb3VudGVyTm9kZTsKKworLy8gLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KKworY2xhc3MgUmVuZGVyQ291bnRlciA6IHB1YmxpYyBSZW5kZXJUZXh0IHsKKworcHVibGlj OgorICAgIFJlbmRlckNvdW50ZXIoTm9kZSosIENvdW50ZXJEYXRhKik7CisgICAgCisgICAgdmly dHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4gIlJlbmRlckNvdW50 ZXIiOyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1cm4gdHJ1 ZTsgfQorICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKTsKKyAgICB2aXJ0dWFsIHZvaWQgY2FsY01p bk1heFdpZHRoKCk7CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIGNvbnZlcnRWYWx1ZVRvVHlwZShp bnQgdmFsdWUsIGludCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUpOworCisgICAgU3RyaW5nIG1faXRl bTsKKyAgICBDb3VudGVyRGF0YSogbV9jb3VudGVyOworICAgIENvdW50ZXJOb2RlKiBtX2NvdW50 ZXJOb2RlOworfTsKKworfSAvL25hbWVzcGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9D b3VudGVyUmVzZXROb2RlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJSZXNldE5v ZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmgJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNjIgQEAKKy8qCisgKiBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUg SFRNTCByZW5kZXJpbmcgZW5naW5lIGZvciBLREUuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA1 IEFsbGFuIFNhbmRmZWxkIEplbnNlbiAoa2RlQGNhcmV3b2xmLmNvbSkKKyAqIENvcHlyaWdodCAo QykgMjAwNiBBcHBsZSBDb21wdXRlciwgSW5jLgorICoKKyAqIFRoaXMgbGlicmFyeSBpcyBmcmVl IHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1 bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljCisgKiBMaWNl bnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIK KyAqIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhv cGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsg d2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogTGli cmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91 IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQ dWJsaWMgTGljZW5zZQorICogYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IHNlZSB0aGUgZmlsZSBD T1BZSU5HLkxJQi4gIElmIG5vdCwgd3JpdGUgdG8KKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwKKyAqIEJvc3RvbiwgTUEg MDIxMTEtMTMwNywgVVNBLgorICoKKyovCisjaWZuZGVmIENvdW50ZXJfUmVzZXRfTm9kZV9oXwor I2RlZmluZSBDb3VudGVyX1Jlc2V0X05vZGVfaF8KKworI2luY2x1ZGUgIkNvdW50ZXJOb2RlLmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworLy8gVGhpcyBmaWxlIGltcGxlbWVudHMgYSBjb3Vu dGVyLXRyZWUgdGhhdCBpcyB1c2VkIGZvciBmaW5kaW5nIGFsbCBwYXJlbnRzIGluIGNvdW50ZXJz KCkgbG9va3VwLAorLy8gYW5kIGZvciBwcm9wYWdhdGluZyBjb3VudC1jaGFuZ2VzIHdoZW4gbm9k ZXMgYXJlIGFkZGVkIG9yIHJlbW92ZWQuCisvLyBQbGVhc2Ugbm90ZSB0aGF0IG9ubHkgY291bnRl ci1yZXNldCBhbmQgcm9vdCBjYW4gYmUgcGFyZW50cyBoZXJlLCBhbmQgdGhhdCByZW5kZXItdHJl ZSBwYXJlbnRzCisvLyBhcmUganVzdCBjb3VudGVyLXRyZWUgc2libGluZ3MKKworLy8gSW1wbGVt ZW50YXRpb24gb2YgY291bnRlci1yZXNldCBhbmQgcm9vdAorY2xhc3MgQ291bnRlclJlc2V0Tm9k ZSA6IHB1YmxpYyBDb3VudGVyTm9kZSB7CisKK3B1YmxpYzoKKyAgICBDb3VudGVyUmVzZXROb2Rl KFJlbmRlck9iamVjdCopOworCisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogZmlyc3RDaGlsZCgp IGNvbnN0IHsgcmV0dXJuIG1fZmlyc3Q7IH07CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogbGFz dENoaWxkKCkgY29uc3QgeyByZXR1cm4gbV9sYXN0OyB9OworICAgIHZpcnR1YWwgdm9pZCBpbnNl cnRBZnRlcihDb3VudGVyTm9kZSogbmV3Q2hpbGQsIENvdW50ZXJOb2RlKiByZWZDaGlsZCk7Cisg ICAgdmlydHVhbCB2b2lkIHJlbW92ZUNoaWxkIChDb3VudGVyTm9kZSopOworCisgICAgdmlydHVh bCBib29sIGlzUmVzZXQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9OworICAgIHZpcnR1YWwgQ291 bnRlck5vZGUqIHJlY291bnRBbmRHZXROZXh0KGJvb2wgc2V0RGlydHkgPSB0cnVlKTsKKyAgICB2 aXJ0dWFsIHZvaWQgc2V0UGFyZW50RGlydHkoKTsKKworICAgIHZvaWQgdXBkYXRlVG90YWwoaW50 IHZhbHVlKTsKKyAgICAvLyBUaGUgaGlnaGVzdCB2YWx1ZSBhbW9uZyBjaGlsZHJlbgorICAgIGlu dCB0b3RhbCgpIGNvbnN0IHsgcmV0dXJuIG1fdG90YWw7IH07CisKK3ByaXZhdGU6CisgICAgaW50 IG1fdG90YWw7CisgICAgQ291bnRlck5vZGUqIG1fZmlyc3Q7CisgICAgQ291bnRlck5vZGUqIG1f bGFzdDsKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIENvdW50ZXJS ZXNldE5vZGVfaApJbmRleDogcmVuZGVyaW5nL0NvdW50ZXJMaXN0SXRlbS5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIHJlbmRlcmluZy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmlu Zy9Db3VudGVyTGlzdEl0ZW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAq IFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBET00gaW1wbGVtZW50YXRpb24gZm9yIEtERS4KKyAq CisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChrZGVAY2FyZXdv bGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJbmMuCisgKgor ICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkg R2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgbGlicmFyeSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkg b2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1v cmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMg bGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0ZSB0bworICog dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlIC0gU3Vp dGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICovCisgCisjaWZu ZGVmIENvdW50ZXJMaXN0SXRlbV9ICisjZGVmaW5lIENvdW50ZXJMaXN0SXRlbV9ICisKKyNpbmNs dWRlICJDb3VudGVyTm9kZS5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIENvdW50 ZXJMaXN0SXRlbSA6IHB1YmxpYyBDb3VudGVyTm9kZQoreworcHVibGljOgorICAgIGludCBjb3Vu dCgpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIHJlY291bnQoYm9vbCBzZXREaXJ0eSA9IHRy dWUpOworICAgIHZpcnR1YWwgdm9pZCBzZXRTZWxmRGlydHkoKTsKKworfTsKKworfSAvL25hbWVz cGFjZQorCisjZW5kaWYKSW5kZXg6IHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCisrKyByZW5k ZXJpbmcvUmVuZGVyQ291bnRlci5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjQ1IEBACisv KioKKyAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBIVE1MIHJlbmRlcmluZyBlbmdpbmUgZm9y IEtERS4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQgQWxsYW4gU2FuZGZlbGQgSmVuc2VuIChr ZGVAY2FyZXdvbGYuY29tKQorICogQ29weXJpZ2h0IChDKSAyMDA2IEFwcGxlIENvbXB1dGVyLCBJ bmMuCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05V IExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKKyAqIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICogdmVyc2lvbiAyIG9mIHRoZSBMaWNl bnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMg bGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBj b3B5IG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3 aXRoIHRoaXMgbGlicmFyeTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuTElCLiAgSWYgbm90LCB3cml0 ZSB0bworICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBs YWNlIC0gU3VpdGUgMzMwLAorICogQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKgorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJDb3VudGVyLmgiCisKKyNp bmNsdWRlICJDb3VudGVyTm9kZS5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKyNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIlJlbmRlclN0eWxlLmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKworY29uc3QgaW50IGNNYXJrZXJQYWRkaW5nID0gNzsKKworUmVuZGVyQ291 bnRlcjo6UmVuZGVyQ291bnRlcihOb2RlKiBub2RlLCBDb3VudGVyRGF0YSogY291bnRlcikKKyAg ICA6IFJlbmRlclRleHQobm9kZSwgMCksIG1fY291bnRlcihjb3VudGVyKSwgbV9jb3VudGVyTm9k ZSgwKQoreworfQorCit2b2lkIFJlbmRlckNvdW50ZXI6OmxheW91dCgpCit7CisgICAgQVNTRVJU KG5lZWRzTGF5b3V0KCkpOworCisgICAgaWYgKCFtaW5NYXhLbm93bigpKQorICAgICAgICBjYWxj TWluTWF4V2lkdGgoKTsKKworICAgIFJlbmRlclRleHQ6OmxheW91dCgpOworfQorCitzdGF0aWMg U3RyaW5nIHRvUm9tYW4oaW50IG51bWJlciwgYm9vbCB1cHBlcikKK3sgCisgICAgU3RyaW5nIHJv bWFuOworICAgIGNvbnN0IFVDaGFyIGxkaWdpdHNbXSA9IHsgJ2knLCAndicsICd4JywgJ2wnLCAn YycsICdkJywgJ20nIH07CisgICAgY29uc3QgVUNoYXIgdWRpZ2l0c1tdID0geyAnSScsICdWJywg J1gnLCAnTCcsICdDJywgJ0QnLCAnTScgfTsKKyAgICBjb25zdCBVQ2hhciogZGlnaXRzID0gdXBw ZXIgPyB1ZGlnaXRzIDogbGRpZ2l0czsKKyAgICBpbnQgZCA9IDA7CisgICAgZG8geworICAgICAg ICBpbnQgbnVtID0gbnVtYmVyICUgMTA7CisgICAgICAgIGlmIChudW0gJSA1IDwgNCkKKyAgICAg ICAgICAgIGZvciAoaW50IGkgPSBudW0gJSA1OyBpID4gMDsgaS0tKQorICAgICAgICAgICAgICAg IHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSA+PSA0ICYm IG51bSA8PSA4KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdpdHNbZCArIDFdLCAxLCAw KTsKKyAgICAgICAgaWYgKG51bSA9PSA5KQorICAgICAgICAgICAgcm9tYW4uaW5zZXJ0KCZkaWdp dHNbZCArIDJdLCAxLCAwKTsKKyAgICAgICAgaWYgKG51bSAlIDUgPT0gNCkKKyAgICAgICAgICAg IHJvbWFuLmluc2VydCgmZGlnaXRzW2RdLCAxLCAwKTsKKyAgICAgICAgbnVtYmVyIC89IDEwOwor ICAgICAgICBkICs9IDI7CisgICAgfSB3aGlsZSAobnVtYmVyKTsKKyAgICByZXR1cm4gcm9tYW47 Cit9CisKK3N0YXRpYyBTdHJpbmcgdG9MZXR0ZXJTdHJpbmcoaW50IG51bWJlciwgVUNoYXIgbGV0 dGVyQSkKK3sgCisgICAgaWYgKG51bWJlciA8IDIpCisgICAgICAgIHJldHVybiBTdHJpbmcoJmxl dHRlckEsIDEpOyAvLyBtYXRjaCBXaW5JRSAoQS4pIG5vdCBGaXJlRm94ICgwLikKKworICAgIFN0 cmluZyBsZXR0ZXJTdHJpbmc7CisgICAgVUNoYXIgYzsKKyAgICB3aGlsZSAobnVtYmVyID4gMCkg eworICAgICAgICBpbnQgb25lc0RpZ2l0ID0gKG51bWJlciAtIDEpICUgMjY7CisgICAgICAgIGMg PSBsZXR0ZXJBICsgb25lc0RpZ2l0OworICAgICAgICBsZXR0ZXJTdHJpbmcgPSBTdHJpbmcoJmMs IDEpICsgbGV0dGVyU3RyaW5nOworICAgICAgICBudW1iZXIgLT0gb25lc0RpZ2l0OworICAgICAg ICBudW1iZXIgLz0gMjY7CisgICAgfQorCisgICAgcmV0dXJuIGxldHRlclN0cmluZzsKK30KKwor c3RhdGljIFN0cmluZyB0b0hlYnJldyhpbnQgbnVtYmVyKQoreworICAgIGlmIChudW1iZXIgPCAx KQorICAgICAgICByZXR1cm4gU3RyaW5nOjpudW1iZXIobnVtYmVyKTsKKyAgICAKKyAgICBzdGF0 aWMgY29uc3QgVUNoYXIgdGVuRGlnaXRbXSA9IHsxNDk3LCAxNDk5LCAxNTAwLCAxNTAyLCAxNTA0 LCAxNTA1LCAxNTA2LCAxNTA4LCAxNTEwfTsKKworICAgIFN0cmluZyBsZXR0ZXI7CisgICAgVUNo YXIgYzsKKyAgICBpZiAobnVtYmVyID4gOTk5KSB7CisgICAgICAgIGxldHRlciA9IHRvSGVicmV3 KG51bWJlciAvIDEwMDApICsgIiciOworICAgICAgICBudW1iZXIgPSBudW1iZXIgJSAxMDAwOwor ICAgIH0KKyAgICBpbnQgZm91ckh1bmRyZWRzID0gbnVtYmVyIC8gNDAwOworICAgIGZvciAoaW50 IGkgPSAwOyBpIDwgZm91ckh1bmRyZWRzOyBpKyspIHsKKyAgICAgICAgYyA9IDE1MTEgKyAzOwor ICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgIH0KKyAgICBudW1iZXIgJT0gNDAwOworICAg IGlmIChudW1iZXIgLyAxMDApIHsKKyAgICAgICAgYyA9IDE1MTEgKyAobnVtYmVyIC8gMTAwKSAt IDE7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfQorICAgIG51bWJlciAlPSAxMDA7 CisgICAgaWYgKG51bWJlciA9PSAxNSB8fCBudW1iZXIgPT0gMTYpIHsKKyAgICAgICAgYyA9IDE0 ODcgKyA5OworICAgICAgICBsZXR0ZXIuYXBwZW5kKGMpOworICAgICAgICBjID0gMTQ4NyArIG51 bWJlciAtIDk7CisgICAgICAgIGxldHRlci5hcHBlbmQoYyk7CisgICAgfSBlbHNlIHsKKyAgICAg ICAgaW50IHRlbnMgPSBudW1iZXIgLyAxMDsKKyAgICAgICAgaWYgKHRlbnMpIHsKKyAgICAgICAg ICAgIGMgPSB0ZW5EaWdpdFt0ZW5zIC0gMV07CisgICAgICAgICAgICBsZXR0ZXIuYXBwZW5kKGMp OworICAgICAgICB9CisgICAgICAgIG51bWJlciA9IG51bWJlciAlIDEwOworICAgICAgICBpZiAo bnVtYmVyKSB7CisgICAgICAgICAgICBjID0gMTQ4NyArIG51bWJlcjsKKyAgICAgICAgICAgIGxl dHRlci5hcHBlbmQoYyk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIGxldHRlcjsKK30K KworU3RyaW5nIFJlbmRlckNvdW50ZXI6OmNvbnZlcnRWYWx1ZVRvVHlwZShpbnQgdmFsdWUsIGlu dCB0b3RhbCwgRUxpc3RTdHlsZVR5cGUgdHlwZSkKK3sKKyAgICBTdHJpbmcgaXRlbTsKKyAgICBV Q2hhciBjOworICAgIHN3aXRjaCh0eXBlKSB7CisgICAgICAgIGNhc2UgTE5PTkU6CisgICAgICAg ICAgICBicmVhazsKKyAgICAgICAgLy8gR2x5cGhzOgorICAgICAgICBjYXNlIERJU0M6CisgICAg ICAgICAgICBjID0gMHgyMDIyOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBDSVJDTEU6CisgICAgICAgICAgICBjID0g MHgyNWU2OworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgY2FzZSBTUVVBUkU6CisgICAgICAgICAgICBjID0gMHgyNWEwOworICAg ICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAgICAgICBicmVhazsKKyAgICAg ICAgY2FzZSBBUk1FTklBTjoKKyAgICAgICAgY2FzZSBHRU9SR0lBTjoKKyAgICAgICAgY2FzZSBD SktfSURFT0dSQVBISUM6CisgICAgICAgIGNhc2UgSElSQUdBTkE6CisgICAgICAgIGNhc2UgS0FU QUtBTkE6CisgICAgICAgIGNhc2UgSElSQUdBTkFfSVJPSEE6CisgICAgICAgIGNhc2UgS0FUQUtB TkFfSVJPSEE6CisgICAgICAgIGNhc2UgREVDSU1BTF9MRUFESU5HX1pFUk86CisgICAgICAgICAg ICAvLyBGSVhNRTogVGhlc2UgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gRm9yIG5vdyB3ZSds bCB1c2UgZGVjaW1hbCBpbnN0ZWFkLgorICAgICAgICBjYXNlIExERUNJTUFMOgorICAgICAgICAg ICAgaXRlbSA9IFN0cmluZzo6bnVtYmVyKHZhbHVlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICAvLyBBbGdvcml0bWljOgorICAgICAgICBjYXNlIExPV0VSX1JPTUFOOgorICAgICAgICAg ICAgaXRlbSA9IHRvUm9tYW4odmFsdWUsIGZhbHNlKTsKKyAgICAgICAgICAgIGJyZWFrOworICAg ICAgICBjYXNlIFVQUEVSX1JPTUFOOgorICAgICAgICAgICAgaXRlbSA9IHRvUm9tYW4odmFsdWUs IHRydWUpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgTE9XRVJfR1JFRUs6IHsK KyAgICAgICAgICAgIGludCBudW1iZXIgPSB2YWx1ZSAtIDE7CisgICAgICAgICAgICBpbnQgbCA9 IChudW1iZXIgJSAyNCk7CisgICAgICAgICAgICBpZiAobCA+IDE2KQorICAgICAgICAgICAgICAg IGwrKzsgLy8gU2tpcCBHUkVFSyBTTUFMTCBMRVRURVIgRklOQUwgU0lHTUEKKyAgICAgICAgICAg IGMgPSA5NDUgKyBsOworICAgICAgICAgICAgaXRlbSA9IFN0cmluZygmYywgMSk7CisgICAgICAg ICAgICBmb3IgKGludCBpID0gMDsgaSA8IChudW1iZXIgLyAyNCk7IGkrKykKKyAgICAgICAgICAg ICAgICBpdGVtICs9ICInIjsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgICAg IGNhc2UgSEVCUkVXOgorICAgICAgICAgICAgaXRlbSA9IHRvSGVicmV3KHZhbHVlKTsKKyAgICAg ICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIExPV0VSX0FMUEhBOgorICAgICAgICBjYXNlIExP V0VSX0xBVElOOgorICAgICAgICAgICAgaXRlbSA9IHRvTGV0dGVyU3RyaW5nKHZhbHVlLCAnYScp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgVVBQRVJfQUxQSEE6CisgICAgICAg IGNhc2UgVVBQRVJfTEFUSU46CisgICAgICAgICAgICBpdGVtID0gdG9MZXR0ZXJTdHJpbmcodmFs dWUsICdBJyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAg ICAgIGl0ZW0gPSBTdHJpbmc6Om51bWJlcih2YWx1ZSk7CisgICAgICAgICAgICBicmVhazsKKyAg ICB9CisgICAgcmV0dXJuIGl0ZW07Cit9CisKK3ZvaWQgUmVuZGVyQ291bnRlcjo6Y2FsY01pbk1h eFdpZHRoKCkKK3sKKyAgICBBU1NFUlQoIW1pbk1heEtub3duKCkpOworCisgICAgaWYgKCFzdHls ZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBib29sIGhhc1NlcGFyYXRvciA9ICFtX2NvdW50 ZXItPnNlcGFyYXRvcigpLmlzTnVsbCgpOworCisgICAgaWYgKCFtX2NvdW50ZXJOb2RlICYmIHBh cmVudCgpLT5wYXJlbnQoKSkKKyAgICAgICAgbV9jb3VudGVyTm9kZSA9IHBhcmVudCgpLT5wYXJl bnQoKS0+ZmluZENvdW50ZXIobV9jb3VudGVyLT5pZGVudGlmaWVyKCksIHRydWUsIGhhc1NlcGFy YXRvcik7CisKKyAgICBpbnQgdmFsdWUgPSBtX2NvdW50ZXJOb2RlLT5jb3VudCgpOworICAgIGlm IChtX2NvdW50ZXJOb2RlLT5pc1Jlc2V0KCkpCisgICAgICAgIHZhbHVlID0gbV9jb3VudGVyTm9k ZS0+dmFsdWUoKTsKKyAgICAKKyAgICBpbnQgdG90YWwgPSB2YWx1ZTsKKyAgICBpZiAobV9jb3Vu dGVyTm9kZS0+cGFyZW50KCkpCisgICAgICAgIHRvdGFsID0gbV9jb3VudGVyTm9kZS0+cGFyZW50 KCktPnRvdGFsKCk7CisgICAgCisgICAgbV9pdGVtID0gY29udmVydFZhbHVlVG9UeXBlKHZhbHVl LCB0b3RhbCwgbV9jb3VudGVyLT5saXN0U3R5bGUoKSk7CisKKyAgICBpZiAoaGFzU2VwYXJhdG9y KSB7CisgICAgICAgIENvdW50ZXJOb2RlKiBjb3VudGVyID0gbV9jb3VudGVyTm9kZS0+cGFyZW50 KCk7CisgICAgICAgIGJvb2wgZmlyc3QgPSB0cnVlOworICAgICAgICB3aGlsZSAgKGNvdW50ZXIt PnBhcmVudCgpICYmIChmaXJzdCB8fCAhKGNvdW50ZXItPmlzUmVzZXQoKSAmJiBjb3VudGVyLT5w YXJlbnQoKS0+aXNSb290KCkpKSkgeworICAgICAgICAgICAgdmFsdWUgPSBjb3VudGVyLT5jb3Vu dCgpID8gY291bnRlci0+Y291bnQoKSA6IDE7CisgICAgICAgICAgICB0b3RhbCA9IGNvdW50ZXIt PnBhcmVudCgpLT50b3RhbCgpOworICAgICAgICAgICAgbV9pdGVtID0gY29udmVydFZhbHVlVG9U eXBlKHZhbHVlLCB0b3RhbCwgbV9jb3VudGVyLT5saXN0U3R5bGUoKSkgCisgICAgICAgICAgICAg ICAgKyBtX2NvdW50ZXItPnNlcGFyYXRvcigpICsgbV9pdGVtOworICAgICAgICAgICAgY291bnRl ciA9IGNvdW50ZXItPnBhcmVudCgpOworICAgICAgICAgICAgZmlyc3QgPSBmYWxzZTsKKyAgICAg ICAgfQorICAgIH0KKworICAgIHN0ciA9IG5ldyBTdHJpbmdJbXBsKG1faXRlbS5jaGFyYWN0ZXJz KCksIG1faXRlbS5sZW5ndGgoKSk7CisgICAgCisgICAgUmVuZGVyVGV4dDo6Y2FsY01pbk1heFdp ZHRoKCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IHJlbmRlcmluZy9Db3Vu dGVyTm9kZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL0NvdW50ZXJOb2RlLmNwcAkocmV2 aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVyTm9kZS5jcHAJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMTExIEBACisvKgorICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVy aW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5k ZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBw bGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJs aXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24u CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZl biB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJh bCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vu c2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIu ICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMu LCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcs IFVTQS4KKyAqCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJO b2RlLmgiCisKKyNpbmNsdWRlICJDb3VudGVyUmVzZXROb2RlLmgiCisjaW5jbHVkZSAiUmVuZGVy T2JqZWN0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworQ291bnRlck5vZGU6OkNvdW50ZXJO b2RlKFJlbmRlck9iamVjdCogbykKKyAgICA6IG1faGFzU2VwYXJhdG9yKGZhbHNlKQorICAgICwg bV93aWxsTmVlZExheW91dChmYWxzZSkKKyAgICAsIG1fdmFsdWUoMCkKKyAgICAsIG1fY291bnQg KDApCisgICAgLCBtX3BhcmVudCgwKQorICAgICwgbV9wcmV2aW91cygwKQorICAgICwgbV9uZXh0 KDApCisgICAgLCBtX3JlbmRlcmVyKG8pCit7ICAgCit9CisKK3ZvaWQgQ291bnRlck5vZGU6Omlu c2VydEFmdGVyKENvdW50ZXJOb2RlKiwgQ291bnRlck5vZGUqKQoreworICAgIEFTU0VSVChmYWxz ZSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6OnJlbW92ZUNoaWxkKENvdW50ZXJOb2RlKikKK3sK KyAgICBBU1NFUlQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZW1vdmUoKQorewor ICAgIGlmIChtX3BhcmVudCkKKyAgICAgICAgbV9wYXJlbnQtPnJlbW92ZUNoaWxkKHRoaXMpOwor ICAgIGVsc2UgeworICAgICAgICBBU1NFUlQoaXNSZXNldCgpKTsKKyAgICAgICAgQVNTRVJUKCFm aXJzdENoaWxkKCkpOworICAgICAgICBBU1NFUlQoIWxhc3RDaGlsZCgpKTsKKyAgICB9Cit9CisK K3ZvaWQgQ291bnRlck5vZGU6OnNldFVzZXNTZXBhcmF0b3IoKQoreworICAgIGZvciAoQ291bnRl ck5vZGUqIGMgPSB0aGlzOyBjOyBjID0gYy0+cGFyZW50KCkpCisgICAgICAgIGMtPnNldEhhc1Nl cGFyYXRvcigpOworfQorCitDb3VudGVyTm9kZSogQ291bnRlck5vZGU6OnJlY291bnRBbmRHZXRO ZXh0KGJvb2wgc2V0RGlydHkpCit7CisgICAgaW50IG9sZF9jb3VudCA9IG1fY291bnQ7CisgICAg aWYgKG1fcHJldmlvdXMpCisgICAgICAgIG1fY291bnQgPSBtX3ByZXZpb3VzLT5jb3VudCgpICsg bV92YWx1ZTsKKyAgICBlbHNlIHsKKyAgICAgICAgYXNzZXJ0KG1fcGFyZW50LT5maXJzdENoaWxk KCkgPT0gdGhpcyk7CisgICAgICAgIG1fY291bnQgPSBtX3BhcmVudC0+dmFsdWUoKSArIG1fdmFs dWU7CisgICAgfQorICAgIAorICAgIGlmIChvbGRfY291bnQgIT0gbV9jb3VudCAmJiBzZXREaXJ0 eSkKKyAgICAgICAgc2V0U2VsZkRpcnR5KCk7CisgICAgaWYgKG9sZF9jb3VudCAhPSBtX2NvdW50 IHx8ICFzZXREaXJ0eSkgeworICAgICAgICBpZiAobV9wYXJlbnQpCisgICAgICAgICAgICBtX3Bh cmVudC0+dXBkYXRlVG90YWwobV9jb3VudCk7CisgICAgICAgIHJldHVybiBtX25leHQ7CisgICAg fQorICAgIAorICAgIHJldHVybiAwOworfQorCit2b2lkIENvdW50ZXJOb2RlOjpyZWNvdW50VHJl ZShib29sIHNldERpcnR5KQoreworICAgIENvdW50ZXJOb2RlKiBjb3VudGVyTm9kZSA9IHRoaXM7 CisgICAgd2hpbGUgKGNvdW50ZXJOb2RlKQorICAgICAgICBjb3VudGVyTm9kZSA9IGNvdW50ZXJO b2RlLT5yZWNvdW50QW5kR2V0TmV4dChzZXREaXJ0eSk7Cit9CisKK3ZvaWQgQ291bnRlck5vZGU6 OnNldFNlbGZEaXJ0eSgpCit7CisgICAgaWYgKG1fcmVuZGVyZXIgJiYgbV93aWxsTmVlZExheW91 dCkKKyAgICAgICAgbV9yZW5kZXJlci0+c2V0TmVlZHNMYXlvdXRBbmRNaW5NYXhSZWNhbGMoKTsK K30KKwordm9pZCBDb3VudGVyTm9kZTo6c2V0UGFyZW50RGlydHkoKQoreworICAgIGlmIChtX3Jl bmRlcmVyICYmIG1fd2lsbE5lZWRMYXlvdXQgJiYgbV9oYXNTZXBhcmF0b3IpCisgICAgICAgIG1f cmVuZGVyZXItPnNldE5lZWRzTGF5b3V0QW5kTWluTWF4UmVjYWxjKCk7Cit9CisKK30gLy8gbmFt ZXNwYWNlCkluZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSByZW5k ZXJpbmcvUmVuZGVyU3R5bGUuaAkocmV2aXNpb24gMTY3MTcpCisrKyByZW5kZXJpbmcvUmVuZGVy U3R5bGUuaAkod29ya2luZyBjb3B5KQpAQCAtMzUsNiArMzUsOCBAQAogICogYW5kIHByb2R1Y2Ug aW52YWxpdWQgcmVzdWx0cy4KICAqLwogCisjaW5jbHVkZSAiQ1NTUHJpbWl0aXZlVmFsdWUuaCIK KyNpbmNsdWRlICJDU1NWYWx1ZUxpc3QuaCIKICNpbmNsdWRlICJDb2xvci5oIgogI2luY2x1ZGUg IkNTU0N1cnNvckltYWdlVmFsdWUuaCIKICNpbmNsdWRlICJEYXRhUmVmLmgiCkBAIC00Miw2ICs0 NCw3IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlcy5oIgogI2luY2x1ZGUgIkludFJlY3QuaCIK ICNpbmNsdWRlICJMZW5ndGguaCIKKyNpbmNsdWRlICJQYWlyLmgiCiAjaW5jbHVkZSAiU2hhcmVk LmgiCiAjaW5jbHVkZSAiVGV4dERpcmVjdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4K QEAgLTYwLDExICs2MywxMyBAQAogCiB1c2luZyBzdGQ6Om1heDsKIAotY2xhc3MgQ1NTU3R5bGVT ZWxlY3RvcjsKIGNsYXNzIENhY2hlZEltYWdlOwogY2xhc3MgQ2FjaGVkUmVzb3VyY2U7CitjbGFz cyBDU1NTdHlsZVNlbGVjdG9yOworY2xhc3MgQ1NTVmFsdWVMaXN0Owogc3RydWN0IEN1cnNvckRh dGE7CiBjbGFzcyBDdXJzb3JMaXN0OworY2xhc3MgUGFpcjsKIGNsYXNzIFJlbmRlckFyZW5hOwog Y2xhc3MgU2hhZG93VmFsdWU7CiBjbGFzcyBTdHJpbmdJbXBsOwpAQCAtNDEwLDggKzQxNSw4IEBA CiAgICAgICAgIHJldHVybiAoIGNsaXAgPT0gby5jbGlwICYmCiAgICAgICAgICAgICAgICAgIGhh c0NsaXAgPT0gby5oYXNDbGlwICYmCiAgICAgICAgICAgICAgICAgIGNvbHNwYW4gPT0gby5jb2xz cGFuICYmCi0gICAgICAgICAgICAgICAgIGNvdW50ZXJfaW5jcmVtZW50ID09IG8uY291bnRlcl9p bmNyZW1lbnQgJiYKLSAgICAgICAgICAgICAgICAgY291bnRlcl9yZXNldCA9PSBvLmNvdW50ZXJf cmVzZXQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlckluY3JlbWVudCA9PSBvLmNvdW50ZXJJ bmNyZW1lbnQgJiYKKyAgICAgICAgICAgICAgICAgY291bnRlclJlc2V0ID09IG8uY291bnRlclJl c2V0ICYmCiAgICAgICAgICAgICAgICAgIHRleHREZWNvcmF0aW9uID09IG8udGV4dERlY29yYXRp b24pOwogICAgIH0KICAgICBib29sIG9wZXJhdG9yIT0oIGNvbnN0IFN0eWxlVmlzdWFsRGF0YSAm byApIGNvbnN0IHsKQEAgLTQyNCw4ICs0MjksOCBAQAogICAgIAogICAgIHNob3J0IGNvbHNwYW47 IC8vIGZvciBodG1sLCBub3QgYSBjc3MyIGF0dHJpYnV0ZQogCi0gICAgc2hvcnQgY291bnRlcl9p bmNyZW1lbnQ7IC8vb2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUgc3Blc2lmaWMKLSAg ICBzaG9ydCBjb3VudGVyX3Jlc2V0OyAgICAgLy9jYW4ndCBnbyB0byBpbmhlcml0ZWQsIHNpbmNl IHRoZXNlIGFyZSBub3QgaW5oZXJpdGVkCisgICAgc2hvcnQgY291bnRlckluY3JlbWVudDsgLy8g b2ssIHNvIHRoZXNlIGFyZSBub3QgdmlzdWFsIG1vZGUgc3BlY2lmaWMKKyAgICBzaG9ydCBjb3Vu dGVyUmVzZXQ7ICAgICAvLyBjYW4ndCBnbyB0byBpbmhlcml0ZWQsIHNpbmNlIHRoZXNlIGFyZSBu b3QgaW5oZXJpdGVkCiAKIH07CiAKQEAgLTg5OCw2ICs5MDMsMjMgQEAKICAgICBDT05URU5UX05P TkUsIENPTlRFTlRfT0JKRUNULCBDT05URU5UX1RFWFQsIENPTlRFTlRfQ09VTlRFUgogfTsKIAor Y2xhc3MgQ291bnRlckRhdGEgeworICAgIAorcHVibGljOgorICAgIENvdW50ZXJEYXRhKCkge30K KyAgICBDb3VudGVyRGF0YShjb25zdCBTdHJpbmcmIGksIEVMaXN0U3R5bGVUeXBlIGwsIGNvbnN0 IFN0cmluZyYgcykKKyAgICAgICAgOiBtX2lkZW50aWZpZXIoaSksIG1fbGlzdFN0eWxlKGwpLCBt X3NlcGFyYXRvcihzKSB7fQorICAgIAorICAgIFN0cmluZyBpZGVudGlmaWVyKCkgeyByZXR1cm4g bV9pZGVudGlmaWVyOyB9CisgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0eWxlKCkgeyByZXR1cm4g bV9saXN0U3R5bGU7IH0KKyAgICBTdHJpbmcgc2VwYXJhdG9yKCkgeyByZXR1cm4gbV9zZXBhcmF0 b3I7IH0KKworcHJpdmF0ZToKKyAgICBTdHJpbmcgbV9pZGVudGlmaWVyOworICAgIEVMaXN0U3R5 bGVUeXBlIG1fbGlzdFN0eWxlOworICAgIFN0cmluZyBtX3NlcGFyYXRvcjsKK307CisKIHN0cnVj dCBDb250ZW50RGF0YSB7CiAgICAgQ29udGVudERhdGEoKSA6X2NvbnRlbnRUeXBlKENPTlRFTlRf Tk9ORSksIF9uZXh0Q29udGVudCgwKSB7fQogICAgIH5Db250ZW50RGF0YSgpOwpAQCAtOTA3LDEz ICs5MjksMTQgQEAKIAogICAgIFN0cmluZ0ltcGwqIGNvbnRlbnRUZXh0KCkgeyBpZiAoY29udGVu dFR5cGUoKSA9PSBDT05URU5UX1RFWFQpIHJldHVybiBfY29udGVudC50ZXh0OyByZXR1cm4gMDsg fQogICAgIENhY2hlZFJlc291cmNlKiBjb250ZW50T2JqZWN0KCkgeyBpZiAoY29udGVudFR5cGUo KSA9PSBDT05URU5UX09CSkVDVCkgcmV0dXJuIF9jb250ZW50Lm9iamVjdDsgcmV0dXJuIDA7IH0K KyAgICBDb3VudGVyRGF0YSogY29udGVudENvdW50ZXIoKSB7IGlmIChjb250ZW50VHlwZSgpID09 IENPTlRFTlRfQ09VTlRFUikgcmV0dXJuIF9jb250ZW50LmNvdW50ZXI7IHJldHVybiAwOyB9CiAg ICAgCiAgICAgQ29udGVudFR5cGUgX2NvbnRlbnRUeXBlOwogCiAgICAgdW5pb24gewogICAgICAg ICBDYWNoZWRSZXNvdXJjZSogb2JqZWN0OwogICAgICAgICBTdHJpbmdJbXBsKiB0ZXh0OwotICAg ICAgICAvLyBjb3VudGVycy4uLgorICAgICAgICBDb3VudGVyRGF0YSogY291bnRlcjsKICAgICB9 IF9jb250ZW50IDsKIAogICAgIENvbnRlbnREYXRhKiBfbmV4dENvbnRlbnQ7CkBAIC0xMDcxLDcg KzEwOTQsOSBAQAogICAgIAogICAgIC8vIGFkZGVkIHRoaXMgaGVyZSwgc28gd2UgY2FuIGdldCBy aWQgb2YgdGhlIHZwdHIgaW4gdGhpcyBjbGFzcy4KICAgICAvLyBtYWtlcyB1cCBmb3IgdGhlIHNh bWUgc2l6ZS4KLSAgICBDb250ZW50RGF0YSAqY29udGVudDsKKyAgICBDb250ZW50RGF0YSogY29u dGVudDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiBjb3VudGVyUmVzZXRMaXN0OworICAgIFJl ZlB0cjxDU1NWYWx1ZUxpc3Q+IGNvdW50ZXJJbmNyZW1lbnRMaXN0OwogCiAgICAgdW5zaWduZWQg bV9wc2V1ZG9TdGF0ZSA6IDM7IC8vIFBzZXVkb1N0YXRlCiAgICAgYm9vbCBtX2FmZmVjdGVkQnlB dHRyaWJ1dGVTZWxlY3RvcnMgOiAxOwpAQCAtMTMyMSw4ICsxMzQ2LDggQEAKICAgICBFRW1wdHlD ZWxsIGVtcHR5Q2VsbHMoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxFRW1wdHlDZWxsPihp bmhlcml0ZWRfZmxhZ3MuX2VtcHR5X2NlbGxzKTsgfQogICAgIEVDYXB0aW9uU2lkZSBjYXB0aW9u U2lkZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVDYXB0aW9uU2lkZT4oaW5oZXJpdGVk X2ZsYWdzLl9jYXB0aW9uX3NpZGUpOyB9CiAKLSAgICBzaG9ydCBjb3VudGVySW5jcmVtZW50KCkg Y29uc3QgeyByZXR1cm4gdmlzdWFsLT5jb3VudGVyX2luY3JlbWVudDsgfQotICAgIHNob3J0IGNv dW50ZXJSZXNldCgpIGNvbnN0IHsgcmV0dXJuIHZpc3VhbC0+Y291bnRlcl9yZXNldDsgfQorICAg IHNob3J0IGNvdW50ZXJJbmNyZW1lbnQoKSBjb25zdCB7IHJldHVybiB2aXN1YWwtPmNvdW50ZXJJ bmNyZW1lbnQ7IH0KKyAgICBzaG9ydCBjb3VudGVyUmVzZXQoKSBjb25zdCB7IHJldHVybiB2aXN1 YWwtPmNvdW50ZXJSZXNldDsgfQogCiAgICAgRUxpc3RTdHlsZVR5cGUgbGlzdFN0eWxlVHlwZSgp IGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PEVMaXN0U3R5bGVUeXBlPihpbmhlcml0ZWRfZmxh Z3MuX2xpc3Rfc3R5bGVfdHlwZSk7IH0KICAgICBDYWNoZWRJbWFnZSAqbGlzdFN0eWxlSW1hZ2Uo KSBjb25zdCB7IHJldHVybiBpbmhlcml0ZWQtPnN0eWxlX2ltYWdlOyB9CkBAIC0xNTI3LDggKzE1 NTIsOCBAQAogICAgIHZvaWQgc2V0Q2FwdGlvblNpZGUoRUNhcHRpb25TaWRlIHYpIHsgaW5oZXJp dGVkX2ZsYWdzLl9jYXB0aW9uX3NpZGUgPSB2OyB9CiAKIAotICAgIHZvaWQgc2V0Q291bnRlcklu Y3JlbWVudChzaG9ydCB2KSB7ICBTRVRfVkFSKHZpc3VhbCxjb3VudGVyX2luY3JlbWVudCx2KSB9 Ci0gICAgdm9pZCBzZXRDb3VudGVyUmVzZXQoc2hvcnQgdikgeyAgU0VUX1ZBUih2aXN1YWwsY291 bnRlcl9yZXNldCx2KSB9CisgICAgdm9pZCBzZXRDb3VudGVySW5jcmVtZW50KHNob3J0IHYpIHsg IFNFVF9WQVIodmlzdWFsLGNvdW50ZXJJbmNyZW1lbnQsdikgfQorICAgIHZvaWQgc2V0Q291bnRl clJlc2V0KHNob3J0IHYpIHsgIFNFVF9WQVIodmlzdWFsLGNvdW50ZXJSZXNldCx2KSB9CiAKICAg ICB2b2lkIHNldExpc3RTdHlsZVR5cGUoRUxpc3RTdHlsZVR5cGUgdikgeyBpbmhlcml0ZWRfZmxh Z3MuX2xpc3Rfc3R5bGVfdHlwZSA9IHY7IH0KICAgICB2b2lkIHNldExpc3RTdHlsZUltYWdlKENh Y2hlZEltYWdlICp2KSB7ICBTRVRfVkFSKGluaGVyaXRlZCxzdHlsZV9pbWFnZSx2KX0KQEAgLTE2 MjYsNyArMTY1MSwxOCBAQAogICAgIGJvb2wgY29udGVudERhdGFFcXVpdmFsZW50KGNvbnN0IFJl bmRlclN0eWxlICpvdGhlclN0eWxlKSBjb25zdDsKICAgICB2b2lkIHNldENvbnRlbnQoU3RyaW5n SW1wbCogcywgYm9vbCBhZGQgPSBmYWxzZSk7CiAgICAgdm9pZCBzZXRDb250ZW50KENhY2hlZFJl c291cmNlKiBvLCBib29sIGFkZCA9IGZhbHNlKTsKKyAgICB2b2lkIHNldENvbnRlbnQoQ291bnRl ckRhdGEqLCBib29sIGFkZCA9IGZhbHNlKTsKIAorICAgIGJvb2wgY291bnRlckRhdGFFcXVpdmFs ZW50KFJlbmRlclN0eWxlKik7CisgICAgdm9pZCBzZXRDb3VudGVyUmVzZXRMaXN0KFBhc3NSZWZQ dHI8Q1NTVmFsdWVMaXN0PiBsKSB7IGNvdW50ZXJSZXNldExpc3QgPSBsOyB9CisgICAgdm9pZCBz ZXRDb3VudGVySW5jcmVtZW50TGlzdChQYXNzUmVmUHRyPENTU1ZhbHVlTGlzdD4gbCkgeyBjb3Vu dGVySW5jcmVtZW50TGlzdCA9IGw7IH0KKyAgICBib29sIGhhc0NvdW50ZXJSZXNldChjb25zdCBT dHJpbmcmKSBjb25zdDsKKyAgICBib29sIGhhc0NvdW50ZXJJbmNyZW1lbnQoY29uc3QgU3RyaW5n JikgY29uc3Q7CisgICAgaW50IGNvdW50ZXJSZXNldChjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAg ICBpbnQgY291bnRlckluY3JlbWVudChjb25zdCBTdHJpbmcmKSBjb25zdDsKKyAgICBDU1NWYWx1 ZUxpc3QqIGNvdW50ZXJSZXNldFZhbHVlTGlzdCgpIHsgcmV0dXJuIGNvdW50ZXJSZXNldExpc3Qu Z2V0KCk7IH0KKyAgICBDU1NWYWx1ZUxpc3QqIGNvdW50ZXJJbmNyZW1lbnRWYWx1ZUxpc3QoKSB7 IHJldHVybiBjb3VudGVySW5jcmVtZW50TGlzdC5nZXQoKTsgfQorCiAgICAgYm9vbCBpbmhlcml0 ZWROb3RFcXVhbCggUmVuZGVyU3R5bGUgKm90aGVyICkgY29uc3Q7CiAKICAgICAvLyBUaGUgZGlm ZmVyZW5jZSBiZXR3ZWVuIHR3byBzdHlsZXMuICBUaGUgZm9sbG93aW5nIHZhbHVlcyBhcmUgdXNl ZDoKSW5kZXg6IHJlbmRlcmluZy9Db3VudGVyUmVzZXROb2RlLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBy ZW5kZXJpbmcvQ291bnRlclJlc2V0Tm9kZS5jcHAJKHJldmlzaW9uIDApCisrKyByZW5kZXJpbmcv Q291bnRlclJlc2V0Tm9kZS5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTU2IEBACisvKgor ICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RF LgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBj YXJld29sZi5jb20pCisgKiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4K KyAqCisgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGli cmFyeSBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJy YXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisg KiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJy YW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQ VVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBm b3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkg b2YgdGhlIEdOVSBMaWJyYXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGgg dGhpcyBsaWJyYXJ5OyBzZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRv CisgKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2Ug LSBTdWl0ZSAzMzAsCisgKiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkNvdW50ZXJSZXNldE5vZGUuaCIKKworI2lu Y2x1ZGUgIlJlbmRlck9iamVjdC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK0NvdW50ZXJS ZXNldE5vZGU6OkNvdW50ZXJSZXNldE5vZGUoUmVuZGVyT2JqZWN0KiBvKQorICAgIDogQ291bnRl ck5vZGUobykKKyAgICAsIG1fdG90YWwoMCkKKyAgICAsIG1fZmlyc3QoMCkKKyAgICAsIG1fbGFz dCgwKQoreworfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6Omluc2VydEFmdGVyKENvdW50ZXJO b2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKQoreworICAgIEFTU0VSVChuZXdD aGlsZCk7CisgICAgQVNTRVJUKCFyZWZDaGlsZCB8fCByZWZDaGlsZC0+cGFyZW50KCkgPT0gdGhp cyk7CisKKyAgICBuZXdDaGlsZC0+bV9wYXJlbnQgPSB0aGlzOworICAgIG5ld0NoaWxkLT5tX3By ZXZpb3VzID0gcmVmQ2hpbGQ7CisKKyAgICBpZiAocmVmQ2hpbGQpIHsKKyAgICAgICAgbmV3Q2hp bGQtPm1fbmV4dCA9IHJlZkNoaWxkLT5tX25leHQ7CisgICAgICAgIHJlZkNoaWxkLT5tX25leHQg PSBuZXdDaGlsZDsKKyAgICB9IGVsc2UgeworICAgICAgICBuZXdDaGlsZC0+bV9uZXh0ID0gbV9m aXJzdDsKKyAgICAgICAgbV9maXJzdCA9IG5ld0NoaWxkOworICAgIH0KKworICAgIGlmIChuZXdD aGlsZC0+bV9uZXh0KSB7CisgICAgICAgIEFTU0VSVChuZXdDaGlsZC0+bV9uZXh0LT5tX3ByZXZp b3VzID09IHJlZkNoaWxkKTsKKyAgICAgICAgbmV3Q2hpbGQtPm1fbmV4dC0+bV9wcmV2aW91cyA9 IG5ld0NoaWxkOworICAgIH0gZWxzZSB7CisgICAgICAgIEFTU0VSVChtX2xhc3QgPT0gcmVmQ2hp bGQpOworICAgICAgICBtX2xhc3QgPSBuZXdDaGlsZDsKKyAgICB9CisKKyAgICBuZXdDaGlsZC0+ cmVjb3VudEFuZEdldE5leHQoZmFsc2UpOworfQorCit2b2lkIENvdW50ZXJSZXNldE5vZGU6OnJl bW92ZUNoaWxkKENvdW50ZXJOb2RlKiBvbGRDaGlsZCkKK3sKKyAgICBBU1NFUlQob2xkQ2hpbGQp OworCisgICAgQ291bnRlck5vZGUqIG5leHQgPSBvbGRDaGlsZC0+bV9uZXh0OworICAgIENvdW50 ZXJOb2RlKiBwcmV2ID0gb2xkQ2hpbGQtPm1fcHJldmlvdXM7CisKKyAgICBpZiAob2xkQ2hpbGQt PmZpcnN0Q2hpbGQoKSkgeworICAgICAgICBDb3VudGVyTm9kZSogZmlyc3QgPSBvbGRDaGlsZC0+ Zmlyc3RDaGlsZCgpOworICAgICAgICBDb3VudGVyTm9kZSogbGFzdCA9IG9sZENoaWxkLT5sYXN0 Q2hpbGQoKTsKKyAgICAgICAgaWYgKHByZXYpIHsKKyAgICAgICAgICAgIHByZXYtPm1fbmV4dCA9 IGZpcnN0OworICAgICAgICAgICAgZmlyc3QtPm1fcHJldmlvdXMgPSBwcmV2OworICAgICAgICB9 IGVsc2UKKyAgICAgICAgICAgIG1fZmlyc3QgPSBmaXJzdDsKKworICAgICAgICBpZiAobmV4dCkg eworICAgICAgICAgICAgbmV4dC0+bV9wcmV2aW91cyA9IGxhc3Q7CisgICAgICAgICAgICBsYXN0 LT5tX25leHQgPSBuZXh0OworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIG1fbGFzdCA9IGxh c3Q7CisKKyAgICAgICAgbmV4dCA9IGZpcnN0OworICAgICAgICB3aGlsZSAobmV4dCkgeworICAg ICAgICAgICAgbmV4dC0+bV9wYXJlbnQgPSB0aGlzOworICAgICAgICAgICAgbmV4dCA9IG5leHQt Pm1fbmV4dDsKKyAgICAgICAgfQorCisgICAgICAgIGZpcnN0LT5yZWNvdW50QW5kR2V0TmV4dCh0 cnVlKTsKKyAgICB9IGVsc2UgeworICAgICAgICBpZiAocHJldikgCisgICAgICAgICAgICBwcmV2 LT5tX25leHQgPSBuZXh0OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGFzc2VydCAoIG1f Zmlyc3QgPT0gb2xkQ2hpbGQgKTsKKyAgICAgICAgICAgIG1fZmlyc3QgPSBuZXh0OworICAgICAg ICB9CisgICAgICAgIAorICAgICAgICBpZiAobmV4dCkKKyAgICAgICAgICAgIG5leHQtPm1fcHJl dmlvdXMgPSBwcmV2OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGFzc2VydCAoIG1fbGFz dCA9PSBvbGRDaGlsZCApOworICAgICAgICAgICAgbV9sYXN0ID0gcHJldjsKKyAgICAgICAgfQor ICAgICAgICAKKyAgICAgICAgaWYgKG5leHQpCisgICAgICAgICAgICBuZXh0LT5yZWNvdW50VHJl ZSgpOworICAgIH0KKworCisgICAgb2xkQ2hpbGQtPm1fbmV4dCA9IDA7CisgICAgb2xkQ2hpbGQt Pm1fcHJldmlvdXMgPSAwOworICAgIG9sZENoaWxkLT5tX3BhcmVudCA9IDA7Cit9CisKK0NvdW50 ZXJOb2RlKiBDb3VudGVyUmVzZXROb2RlOjpyZWNvdW50QW5kR2V0TmV4dChib29sIHNldERpcnR5 KQoreworICAgIGludCBvbGRfY291bnQgPSBtX2NvdW50OworICAgIGlmIChtX3ByZXZpb3VzKQor ICAgICAgICBtX2NvdW50ID0gbV9wcmV2aW91cy0+Y291bnQoKTsKKyAgICBlbHNlIGlmIChtX3Bh cmVudCkKKyAgICAgICAgbV9jb3VudCA9IG1fcGFyZW50LT52YWx1ZSgpOworICAgIGVsc2UKKyAg ICAgICAgbV9jb3VudCA9IDA7CisKKyAgICB1cGRhdGVUb3RhbChtX3ZhbHVlKTsKKyAgICAKKyAg ICBpZiAoc2V0RGlydHkpCisgICAgICAgIHNldFNlbGZEaXJ0eSgpOworICAgIGlmICghc2V0RGly dHkgfHwgbV9jb3VudCAhPSBvbGRfY291bnQpCisgICAgICAgIHJldHVybiBtX25leHQ7CisgICAg CisgICAgcmV0dXJuIDA7Cit9CisKK3ZvaWQgQ291bnRlclJlc2V0Tm9kZTo6c2V0UGFyZW50RGly dHkoKQoreworICAgIGlmIChoYXNTZXBhcmF0b3IoKSkKKyAgICAgICAgc2V0U2VsZkRpcnR5KCk7 CisgICAgICAgIAorICAgIGZvciAoQ291bnRlck5vZGUqIG4gPSBmaXJzdENoaWxkKCk7IG47IG4g PSBuLT5uZXh0U2libGluZygpKQorICAgICAgICBpZiAobi0+aGFzU2VwYXJhdG9yKCkpCisgICAg ICAgICAgICBuLT5zZXRTZWxmRGlydHkoKTsKK30KKwordm9pZCBDb3VudGVyUmVzZXROb2RlOjp1 cGRhdGVUb3RhbChpbnQgdmFsdWUpCit7CisgICAgaWYgKHZhbHVlID4gbV90b3RhbCkKKyAgICAg ICAgbV90b3RhbCA9IHZhbHVlOworfQorCit9IC8vIG5hbWVzcGFjZQpJbmRleDogcmVuZGVyaW5n L1JlbmRlckNvbnRhaW5lci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gcmVuZGVyaW5nL1JlbmRlckNvbnRh aW5lci5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgcmVuZGVyaW5nL1JlbmRlckNvbnRhaW5lci5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTQsNiArNCw3IEBACiAgKiBDb3B5cmlnaHQgKEMpIDE5OTkg TGFycyBLbm9sbCAoa25vbGxAa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMTk5OSBBbnR0aSBL b2l2aXN0byAoa29pdmlzdG9Aa2RlLm9yZykKICAqICAgICAgICAgICAoQykgMjAwMCBEaXJrIE11 ZWxsZXIgKG11ZWxsZXJAa2RlLm9yZykKKyAqICAgICAgICAgICAoQykgMjAwNCBBbGxhbiBTYW5k ZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDMsIDIw MDQsIDIwMDUsIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KICAqIENvcHlyaWdodCAoQykgMjAw NiBBbmRyZXcgV2VsbGluZ3RvbiAocHJvdG9uQHdpcmV0YXBwZWQubmV0KQogICoKQEAgLTI4LDYg KzI5LDcgQEAKICNpbmNsdWRlICJSZW5kZXJDb250YWluZXIuaCIKIAogI2luY2x1ZGUgImh0bWxl ZGl0aW5nLmgiCisjaW5jbHVkZSAiUmVuZGVyQ291bnRlci5oIgogI2luY2x1ZGUgIlJlbmRlckxp c3RJdGVtLmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFibGUuaCIKICNpbmNsdWRlICJSZW5kZXJUZXh0 RnJhZ21lbnQuaCIKQEAgLTI5Niw3ICsyOTgsNyBAQAogICAgICAgICAvLyBkZXRlcm1pbmVkIHRo YXQgdGhlIHBzZXVkbyBpcyBub3QgZGlzcGxheSBOT05FLCBhbnkgZGlzcGxheSBvdGhlciB0aGFu CiAgICAgICAgIC8vIGlubGluZSBzaG91bGQgYmUgbXV0YXRlZCB0byBJTkxJTkUuCiAgICAgICAg IHBzZXVkby0+c2V0RGlzcGxheShJTkxJTkUpOwotICAgIAorCiAgICAgaWYgKG9sZENvbnRlbnRQ cmVzZW50KSB7CiAgICAgICAgIGlmIChjaGlsZCAmJiBjaGlsZC0+c3R5bGUoKS0+c3R5bGVUeXBl KCkgPT0gdHlwZSkgewogICAgICAgICAgICAgLy8gV2UgaGF2ZSBnZW5lcmF0ZWQgY29udGVudCBw cmVzZW50IHN0aWxsLiAgV2Ugd2FudCB0byB3YWxrIHRoaXMgY29udGVudCBhbmQgdXBkYXRlIG91 cgpAQCAtMzM0LDIwICszMzYsMjQgQEAKICAgICAgICAgaWYgKCFwc2V1ZG9Db250YWluZXIpCiAg ICAgICAgICAgICBwc2V1ZG9Db250YWluZXIgPSBSZW5kZXJGbG93OjpjcmVhdGVBbm9ueW1vdXNG bG93KGRvY3VtZW50KCksIHBzZXVkbyk7IC8qIGFub255bW91cyBib3ggKi8KICAgICAgICAgCi0g ICAgICAgIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5UX1RFWFQpCi0g ICAgICAgIHsKKyAgICAgICAgaWYgKGNvbnRlbnREYXRhLT5jb250ZW50VHlwZSgpID09IENPTlRF TlRfVEVYVCkgewogICAgICAgICAgICAgUmVuZGVyVGV4dCogdCA9IG5ldyAocmVuZGVyQXJlbmEo KSkgUmVuZGVyVGV4dEZyYWdtZW50KGRvY3VtZW50KCkgLyphbm9ueW1vdXMgb2JqZWN0ICovLCBj b250ZW50RGF0YS0+Y29udGVudFRleHQoKSk7CiAgICAgICAgICAgICB0LT5zZXRTdHlsZShwc2V1 ZG8pOwogICAgICAgICAgICAgcHNldWRvQ29udGFpbmVyLT5hZGRDaGlsZCh0KTsKLSAgICAgICAg fQotICAgICAgICBlbHNlIGlmIChjb250ZW50RGF0YS0+Y29udGVudFR5cGUoKSA9PSBDT05URU5U X09CSkVDVCkKLSAgICAgICAgeworICAgICAgICB9IGVsc2UgaWYgKGNvbnRlbnREYXRhLT5jb250 ZW50VHlwZSgpID09IENPTlRFTlRfT0JKRUNUKSB7CiAgICAgICAgICAgICBSZW5kZXJJbWFnZSog aW1nID0gbmV3IChyZW5kZXJBcmVuYSgpKSBSZW5kZXJJbWFnZShkb2N1bWVudCgpKTsgLyogQW5v bnltb3VzIG9iamVjdCAqLwogICAgICAgICAgICAgUmVuZGVyU3R5bGUqIHN0eWxlID0gbmV3IChy ZW5kZXJBcmVuYSgpKSBSZW5kZXJTdHlsZSgpOwogICAgICAgICAgICAgc3R5bGUtPmluaGVyaXRG cm9tKHBzZXVkbyk7CiAgICAgICAgICAgICBpbWctPnNldFN0eWxlKHN0eWxlKTsKICAgICAgICAg ICAgIGltZy0+c2V0Q29udGVudE9iamVjdChjb250ZW50RGF0YS0+Y29udGVudE9iamVjdCgpKTsK ICAgICAgICAgICAgIHBzZXVkb0NvbnRhaW5lci0+YWRkQ2hpbGQoaW1nKTsKKyAgICAgICAgfSBl bHNlIGlmIChjb250ZW50RGF0YS0+X2NvbnRlbnRUeXBlID09IENPTlRFTlRfQ09VTlRFUikgewor ICAgICAgICAgICAgUmVuZGVyQ291bnRlciogYyA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVy Q291bnRlcihlbGVtZW50KCksIGNvbnRlbnREYXRhLT5jb250ZW50Q291bnRlcigpKTsKKyAgICAg ICAgICAgIFJlbmRlclN0eWxlKiBzdHlsZSA9IG5ldyAocmVuZGVyQXJlbmEoKSkgUmVuZGVyU3R5 bGUoKTsKKyAgICAgICAgICAgIHN0eWxlLT5pbmhlcml0RnJvbShwc2V1ZG8pOworICAgICAgICAg ICAgYy0+c2V0SXNBbm9ueW1vdXModHJ1ZSk7CisgICAgICAgICAgICBjLT5zZXRTdHlsZShzdHls ZSk7CisgICAgICAgICAgICBwc2V1ZG9Db250YWluZXItPmFkZENoaWxkKGMpOwogICAgICAgICB9 CiAgICAgfQogCkluZGV4OiByZW5kZXJpbmcvQ291bnRlck5vZGUuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBy ZW5kZXJpbmcvQ291bnRlck5vZGUuaAkocmV2aXNpb24gMCkKKysrIHJlbmRlcmluZy9Db3VudGVy Tm9kZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg2IEBACisvKgorICogVGhpcyBmaWxlIGlz IHBhcnQgb2YgdGhlIEhUTUwgcmVuZGVyaW5nIGVuZ2luZSBmb3IgS0RFLgorICoKKyAqIENvcHly aWdodCAoQykgMjAwNSBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gKGtkZUBjYXJld29sZi5jb20pCisg KiBDb3B5cmlnaHQgKEMpIDIwMDYgQXBwbGUgQ29tcHV0ZXIsIEluYy4KKyAqCisgKiBUaGlzIGxp YnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisg KiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1 YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9w dGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAqIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMaWJy YXJ5IEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBz ZWUgdGhlIGZpbGUgQ09QWUlORy5MSUIuICBJZiBub3QsIHdyaXRlIHRvCisgKiB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsCisg KiBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqCisqLworI2lmbmRlZiBDb3VudGVyX05v ZGVfaF8KKyNkZWZpbmUgQ291bnRlcl9Ob2RlX2hfCisKKyNpbmNsdWRlICJSZW5kZXJPYmplY3Qu aCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBDb3VudGVyUmVzZXROb2RlOworCisv LyBUaGlzIGZpbGUgaW1wbGVtZW50cyBhIGNvdW50ZXItdHJlZSB0aGF0IGlzIHVzZWQgZm9yIGZp bmRpbmcgYWxsIHBhcmVudHMgaW4gY291bnRlcnMoKSBsb29rdXAsCisvLyBhbmQgZm9yIHByb3Bh Z2F0aW5nIGNvdW50LWNoYW5nZXMgd2hlbiBub2RlcyBhcmUgYWRkZWQgb3IgcmVtb3ZlZC4KKy8v IFBsZWFzZSBub3RlIHRoYXQgb25seSBjb3VudGVyLXJlc2V0IGFuZCByb290IGNhbiBiZSBwYXJl bnRzIGhlcmUsIGFuZCB0aGF0IHJlbmRlci10cmVlIHBhcmVudHMKKy8vIGFyZSBqdXN0IGNvdW50 ZXItdHJlZSBzaWJsaW5ncworCitjbGFzcyBDb3VudGVyTm9kZSB7CitwdWJsaWM6CisgICAgQ291 bnRlck5vZGUoUmVuZGVyT2JqZWN0Kik7CisgICAgdmlydHVhbCB+Q291bnRlck5vZGUoKSB7fQor CisgICAgQ291bnRlclJlc2V0Tm9kZSogcGFyZW50KCkgY29uc3QgeyByZXR1cm4gbV9wYXJlbnQ7 IH0KKyAgICBDb3VudGVyTm9kZSogcHJldmlvdXNTaWJsaW5nKCkgY29uc3QgeyByZXR1cm4gbV9w cmV2aW91czsgfQorICAgIHZpcnR1YWwgQ291bnRlck5vZGUqIG5leHRTaWJsaW5nKCkgY29uc3Qg eyByZXR1cm4gbV9uZXh0OyB9CisgICAgdmlydHVhbCBDb3VudGVyTm9kZSogZmlyc3RDaGlsZCgp IGNvbnN0IHsgcmV0dXJuIDA7IH0KKyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiBsYXN0Q2hpbGQo KSBjb25zdCB7IHJldHVybiAwOyB9CisgICAgdmlydHVhbCB2b2lkIGluc2VydEFmdGVyKENvdW50 ZXJOb2RlKiBuZXdDaGlsZCwgQ291bnRlck5vZGUqIHJlZkNoaWxkKTsKKyAgICB2aXJ0dWFsIHZv aWQgcmVtb3ZlQ2hpbGQgKENvdW50ZXJOb2RlKiBvbGRDaGlsZCk7CisgICAgdm9pZCByZW1vdmUo KTsKKworICAgIGludCB2YWx1ZSgpIGNvbnN0IHsgcmV0dXJuIG1fdmFsdWU7IH0KKyAgICB2b2lk IHNldFZhbHVlKGludCB2KSB7IG1fdmFsdWUgPSB2OyB9CisgICAgaW50IGNvdW50KCkgY29uc3Qg eyByZXR1cm4gbV9jb3VudDsgfQorICAgIHZvaWQgc2V0Q291bnQoaW50IGMpIHsgbV9jb3VudCA9 IGM7IH0KKyAgICB2b2lkIHNldEhhc1NlcGFyYXRvcigpIHsgbV9oYXNTZXBhcmF0b3IgPSB0cnVl OyB9CisKKyAgICB2aXJ0dWFsIGJvb2wgaXNSZXNldCgpIGNvbnN0eyByZXR1cm4gZmFsc2U7IH0K KyAgICB2aXJ0dWFsIENvdW50ZXJOb2RlKiByZWNvdW50QW5kR2V0TmV4dChib29sIHNldERpcnR5 ID0gdHJ1ZSk7CisgICAgdmlydHVhbCB2b2lkIHJlY291bnRUcmVlKGJvb2wgc2V0RGlydHkgPSB0 cnVlKTsKKyAgICB2aXJ0dWFsIHZvaWQgc2V0U2VsZkRpcnR5KCk7CisgICAgdmlydHVhbCB2b2lk IHNldFBhcmVudERpcnR5KCk7CisKKyAgICBib29sIGhhc1NlcGFyYXRvcigpIGNvbnN0IHsgcmV0 dXJuIG1faGFzU2VwYXJhdG9yOyB9CisgICAgYm9vbCB3aWxsTmVlZExheW91dCgpIGNvbnN0IHsg cmV0dXJuIG1fd2lsbE5lZWRMYXlvdXQ7IH0KKyAgICB2b2lkIHNldFVzZXNTZXBhcmF0b3IoKTsK KyAgICB2b2lkIHNldFdpbGxOZWVkTGF5b3V0KCkgeyBtX3dpbGxOZWVkTGF5b3V0ID0gdHJ1ZTsg fQorICAgIGJvb2wgaXNSb290KCkgY29uc3QgeyByZXR1cm4gbV9yZW5kZXJlciAmJiBtX3JlbmRl cmVyLT5pc1Jvb3QoKTsgfQorCisgICAgdm9pZCBzZXRSZW5kZXJlcihSZW5kZXJPYmplY3QqIG8p IHsgbV9yZW5kZXJlciA9IG87IH0KKyAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKCkgY29uc3Qg eyByZXR1cm4gbV9yZW5kZXJlcjsgfQorCisgICAgZnJpZW5kIGNsYXNzIENvdW50ZXJSZXNldE5v ZGU7Citwcm90ZWN0ZWQ6CisgICAgYm9vbCBtX2hhc1NlcGFyYXRvcjsKKyAgICBib29sIG1fd2ls bE5lZWRMYXlvdXQ7CisgICAgaW50IG1fdmFsdWU7CisgICAgaW50IG1fY291bnQ7CisgICAgQ291 bnRlclJlc2V0Tm9kZSogbV9wYXJlbnQ7CisgICAgQ291bnRlck5vZGUqIG1fcHJldmlvdXM7Cisg ICAgQ291bnRlck5vZGUqIG1fbmV4dDsKKyAgICBSZW5kZXJPYmplY3QqIG1fcmVuZGVyZXI7Cit9 OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBDb3VudGVyTm9kZV9oCklu ZGV4OiByZW5kZXJpbmcvUmVuZGVyU3R5bGUuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIHJlbmRlcmluZy9S ZW5kZXJTdHlsZS5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgcmVuZGVyaW5nL1JlbmRlclN0eWxl LmNwcAkod29ya2luZyBjb3B5KQpAQCAtOTAsOCArOTAsOCBAQAogICAgIDogaGFzQ2xpcChmYWxz ZSkKICAgICAsIHRleHREZWNvcmF0aW9uKFJlbmRlclN0eWxlOjppbml0aWFsVGV4dERlY29yYXRp b24oKSkKICAgICAsIGNvbHNwYW4oMSkKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KDApCi0gICAg LCBjb3VudGVyX3Jlc2V0KDApCisgICAgLCBjb3VudGVySW5jcmVtZW50KDApCisgICAgLCBjb3Vu dGVyUmVzZXQoMCkKIHsKIH0KIApAQCAtMTA1LDggKzEwNSw4IEBACiAgICAgLCBoYXNDbGlwKG8u aGFzQ2xpcCkKICAgICAsIHRleHREZWNvcmF0aW9uKG8udGV4dERlY29yYXRpb24pCiAgICAgLCBj b2xzcGFuKG8uY29sc3BhbikKLSAgICAsIGNvdW50ZXJfaW5jcmVtZW50KG8uY291bnRlcl9pbmNy ZW1lbnQpCi0gICAgLCBjb3VudGVyX3Jlc2V0KG8uY291bnRlcl9yZXNldCkKKyAgICAsIGNvdW50 ZXJJbmNyZW1lbnQoby5jb3VudGVySW5jcmVtZW50KQorICAgICwgY291bnRlclJlc2V0KG8uY291 bnRlclJlc2V0KQogewogfQogCkBAIC01NzcsNyArNTc3LDYgQEAKICAgICAgICAgcHJldi0+ZGVy ZWYoYXJlbmEpOwogICAgIH0KICAgICBkZWxldGUgY29udGVudDsKLSAgICAKICAgICBkZWxldGUg dGhpczsKICAgICAKICAgICAvLyBSZWNvdmVyIHRoZSBzaXplIGxlZnQgdGhlcmUgZm9yIHVzIGJ5 IG9wZXJhdG9yIGRlbGV0ZSBhbmQgZnJlZSB0aGUgbWVtb3J5LgpAQCAtNjQ5LDYgKzY0OCw4IEBA CiAgICAgLCBpbmhlcml0ZWQoby5pbmhlcml0ZWQpCiAgICAgLCBwc2V1ZG9TdHlsZSgwKQogICAg ICwgY29udGVudChvLmNvbnRlbnQpCisgICAgLCBjb3VudGVyUmVzZXRMaXN0KG8uY291bnRlclJl c2V0TGlzdCkKKyAgICAsIGNvdW50ZXJJbmNyZW1lbnRMaXN0KG8uY291bnRlckluY3JlbWVudExp c3QpCiAgICAgLCBtX3BzZXVkb1N0YXRlKG8ubV9wc2V1ZG9TdGF0ZSkKICAgICAsIG1fYWZmZWN0 ZWRCeUF0dHJpYnV0ZVNlbGVjdG9ycyhmYWxzZSkKICAgICAsIG1fdW5pcXVlKGZhbHNlKQpAQCAt ODM4LDggKzgzOSw4IEBACiAgICAgICAgICEobm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZyA9 PSBvdGhlci0+bm9uaW5oZXJpdGVkX2ZsYWdzLl9mbG9hdGluZykgfHwKICAgICAgICAgIShub25p bmhlcml0ZWRfZmxhZ3MuX29yaWdpbmFsRGlzcGxheSA9PSBvdGhlci0+bm9uaW5oZXJpdGVkX2Zs YWdzLl9vcmlnaW5hbERpc3BsYXkpIHx8CiAgICAgICAgICB2aXN1YWwtPmNvbHNwYW4gIT0gb3Ro ZXItPnZpc3VhbC0+Y29sc3BhbiB8fAotICAgICAgICAgdmlzdWFsLT5jb3VudGVyX2luY3JlbWVu dCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVyX2luY3JlbWVudCB8fAotICAgICAgICAgdmlzdWFs LT5jb3VudGVyX3Jlc2V0ICE9IG90aGVyLT52aXN1YWwtPmNvdW50ZXJfcmVzZXQgfHwKKyAgICAg ICAgIHZpc3VhbC0+Y291bnRlckluY3JlbWVudCAhPSBvdGhlci0+dmlzdWFsLT5jb3VudGVySW5j cmVtZW50IHx8CisgICAgICAgICB2aXN1YWwtPmNvdW50ZXJSZXNldCAhPSBvdGhlci0+dmlzdWFs LT5jb3VudGVyUmVzZXQgfHwKICAgICAgICAgIGNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3Zl cmZsb3cgIT0gb3RoZXItPmNzczNOb25Jbmhlcml0ZWREYXRhLT50ZXh0T3ZlcmZsb3cgfHwKICAg ICAgICAgIChjc3MzSW5oZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5ICE9IG90aGVyLT5jc3MzSW5o ZXJpdGVkRGF0YS0+dGV4dFNlY3VyaXR5KSkKICAgICAgICAgcmV0dXJuIExheW91dDsKQEAgLTky NSw2ICs5MjYsMTAgQEAKICAgICAvLyBJZiByZWdpb25zIGNoYW5nZSB0cmlnZ2VyIGEgcmVsYXlv dXQgdG8gcmUtY2FsYyByZWdpb25zLgogICAgIGlmICghKGNzczNOb25Jbmhlcml0ZWREYXRhLT5t X2Rhc2hib2FyZFJlZ2lvbnMgPT0gb3RoZXItPmNzczNOb25Jbmhlcml0ZWREYXRhLT5tX2Rhc2hi b2FyZFJlZ2lvbnMpKQogICAgICAgICByZXR1cm4gTGF5b3V0OworICAgIAorICAgIC8vIElmIHRo ZSBjb3VudGVyIGxpc3RzIGNoYW5nZSwgdHJpZ2dlciBhIHJlbGF5b3V0IHRvIHJlLWNhbGMgQ291 bnRlck5vZGVzLgorICAgIGlmIChjb3VudGVyUmVzZXRMaXN0ICE9IG90aGVyLT5jb3VudGVyUmVz ZXRMaXN0IHx8IGNvdW50ZXJJbmNyZW1lbnRMaXN0ICE9IG90aGVyLT5jb3VudGVySW5jcmVtZW50 TGlzdCkKKyAgICAgICAgcmV0dXJuIExheW91dDsKIAogICAgIC8vIE1ha2Ugc3VyZSB0aGVzZSBs ZWZ0L3RvcC9yaWdodC9ib3R0b20gY2hlY2tzIHN0YXkgYmVsb3cgYWxsIGxheW91dCBjaGVja3Mg YW5kIGFib3ZlCiAgICAgLy8gYWxsIHZpc2libGUgY2hlY2tzLgpAQCAtMTEwOSw2ICsxMTE0LDMy IEBACiAgICAgbmV3Q29udGVudERhdGEtPl9jb250ZW50VHlwZSA9IENPTlRFTlRfVEVYVDsKIH0K IAordm9pZCBSZW5kZXJTdHlsZTo6c2V0Q29udGVudChDb3VudGVyRGF0YSogYywgYm9vbCBhZGQp Cit7CisgICAgaWYgKCFjKQorICAgICAgICByZXR1cm47CisKKyAgICBDb250ZW50RGF0YSogbGFz dENvbnRlbnQgPSBjb250ZW50OworICAgIHdoaWxlIChsYXN0Q29udGVudCAmJiBsYXN0Q29udGVu dC0+X25leHRDb250ZW50KQorICAgICAgICBsYXN0Q29udGVudCA9IGxhc3RDb250ZW50LT5fbmV4 dENvbnRlbnQ7CisKKyAgICBib29sIHJldXNlQ29udGVudCA9ICFhZGQ7CisgICAgQ29udGVudERh dGEqIG5ld0NvbnRlbnREYXRhID0gMDsKKyAgICBpZiAocmV1c2VDb250ZW50ICYmIGNvbnRlbnQp IHsKKyAgICAgICAgY29udGVudC0+Y2xlYXJDb250ZW50KCk7CisgICAgICAgIG5ld0NvbnRlbnRE YXRhID0gY29udGVudDsKKyAgICB9IGVsc2UKKyAgICAgICAgbmV3Q29udGVudERhdGEgPSBuZXcg Q29udGVudERhdGE7CisKKyAgICBpZiAobGFzdENvbnRlbnQgJiYgIXJldXNlQ29udGVudCkKKyAg ICAgICAgbGFzdENvbnRlbnQtPl9uZXh0Q29udGVudCA9IG5ld0NvbnRlbnREYXRhOworICAgIGVs c2UKKyAgICAgICAgY29udGVudCA9IG5ld0NvbnRlbnREYXRhOworCisgICAgbmV3Q29udGVudERh dGEtPl9jb250ZW50LmNvdW50ZXIgPSBjOworICAgIG5ld0NvbnRlbnREYXRhLT5fY29udGVudFR5 cGUgPSBDT05URU5UX0NPVU5URVI7Cit9CisKIENvbnRlbnREYXRhOjp+Q29udGVudERhdGEoKQog ewogICAgIGNsZWFyQ29udGVudCgpOwpAQCAtMTEyNyw2ICsxMTU4LDExIEBACiAgICAgICAgIGNh c2UgQ09OVEVOVF9URVhUOgogICAgICAgICAgICAgX2NvbnRlbnQudGV4dC0+ZGVyZWYoKTsKICAg ICAgICAgICAgIF9jb250ZW50LnRleHQgPSAwOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAg IGNhc2UgQ09OVEVOVF9DT1VOVEVSOgorICAgICAgICAgICAgZGVsZXRlIF9jb250ZW50LmNvdW50 ZXI7CisgICAgICAgICAgICBfY29udGVudC5jb3VudGVyID0gMDsKKyAgICAgICAgICAgIGJyZWFr OwogICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgOwogICAgIH0KQEAgLTEyMTQsNiArMTI1 MCw4MiBAQAogICAgIHJldHVybiB4ID09IG8ueCAmJiB5ID09IG8ueSAmJiBibHVyID09IG8uYmx1 ciAmJiBjb2xvciA9PSBvLmNvbG9yOwogfQogCitib29sIFJlbmRlclN0eWxlOjpjb3VudGVyRGF0 YUVxdWl2YWxlbnQoUmVuZGVyU3R5bGUqIG90aGVyU3R5bGUpCit7CisgICAgLy8gRklYTUU6IFNo b3VsZCB3ZSBhbHNvIGNvbXBhcmUgdGhlIENvdW50ZXJEYXRhPyAKKyAgICByZXR1cm4gY291bnRl clJlc2V0TGlzdCA9PSBvdGhlclN0eWxlLT5jb3VudGVyUmVzZXRMaXN0ICYmCisgICAgICAgICAg IGNvdW50ZXJJbmNyZW1lbnRMaXN0ID09IG90aGVyU3R5bGUtPmNvdW50ZXJJbmNyZW1lbnRMaXN0 OworfQorCitzdGF0aWMgYm9vbCBoYXNDb3VudGVyKGNvbnN0IFN0cmluZyYgYywgQ1NTVmFsdWVM aXN0KiBsKQoreworICAgIGludCBsZW4gPSBsLT5sZW5ndGgoKTsKKyAgICBmb3IgKGludCBpID0g MDsgaSA8IGxlbjsgaSsrKSB7CisgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmltaXRpdmVW YWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7CisgICAg ICAgIFBhaXIqIHBhaXIgPSBwcmltaXRpdmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7CisgICAgICAg IEFTU0VSVChwYWlyKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0g c3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZlVmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAg QVNTRVJUKGNvdW50ZXJOYW1lKTsKKyAgICAgICAgaWYgKGNvdW50ZXJOYW1lLT5nZXRTdHJpbmdW YWx1ZSgpID09IGMpCisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgcmV0dXJu IGZhbHNlOworfQorCitib29sIFJlbmRlclN0eWxlOjpoYXNDb3VudGVyUmVzZXQoY29uc3QgU3Ry aW5nJiBjb3VudGVyTmFtZSkgY29uc3QKK3sKKyAgICBpZiAoY291bnRlclJlc2V0TGlzdCkKKyAg ICAgICAgcmV0dXJuIGhhc0NvdW50ZXIoY291bnRlck5hbWUsIGNvdW50ZXJSZXNldExpc3QuZ2V0 KCkpOworICAgIHJldHVybiBmYWxzZTsKK30KKworYm9vbCBSZW5kZXJTdHlsZTo6aGFzQ291bnRl ckluY3JlbWVudChjb25zdCBTdHJpbmcmIGNvdW50ZXJOYW1lKSBjb25zdAoreworICAgIGlmIChj b3VudGVySW5jcmVtZW50TGlzdCkKKyAgICAgICAgcmV0dXJuIGhhc0NvdW50ZXIoY291bnRlck5h bWUsIGNvdW50ZXJJbmNyZW1lbnRMaXN0LmdldCgpKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK K3N0YXRpYyBpbnQgcmVhZENvdW50ZXIoY29uc3QgU3RyaW5nJiBjLCBDU1NWYWx1ZUxpc3QqIGws IGJvb2wgaXNSZXNldCkKK3sKKyAgICBpbnQgbGVuID0gbC0+bGVuZ3RoKCk7CisgICAgaW50IHRv dGFsID0gMDsKKyAgICAKKyAgICBmb3IgKGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisgICAg ICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwcmltaXRpdmVWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1By aW1pdGl2ZVZhbHVlKj4obC0+aXRlbShpKSk7CisgICAgICAgIFBhaXIqIHBhaXIgPSBwcmltaXRp dmVWYWx1ZS0+Z2V0UGFpclZhbHVlKCk7CisgICAgICAgIEFTU0VSVChwYWlyKTsKKyAgICAgICAg Q1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50ZXJOYW1lID0gc3RhdGljX2Nhc3Q8Q1NTUHJpbWl0aXZl VmFsdWUqPihwYWlyLT5maXJzdCgpKTsKKyAgICAgICAgQ1NTUHJpbWl0aXZlVmFsdWUqIGNvdW50 ZXJWYWx1ZSA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4ocGFpci0+c2Vjb25kKCkp OworICAgICAgICBBU1NFUlQoY291bnRlck5hbWUpOworICAgICAgICBBU1NFUlQoY291bnRlclZh bHVlKTsKKworICAgICAgICBpZiAoY291bnRlck5hbWUtPmdldFN0cmluZ1ZhbHVlKCkgPT0gYykg eworICAgICAgICAgICAgdG90YWwgKz0gKGludCljb3VudGVyVmFsdWUtPmdldEZsb2F0VmFsdWUo KTsKKyAgICAgICAgICAgIGlmIChpc1Jlc2V0KQorICAgICAgICAgICAgICAgIHJldHVybiB0b3Rh bDsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICByZXR1cm4gdG90YWw7Cit9CisKK2ludCBS ZW5kZXJTdHlsZTo6Y291bnRlclJlc2V0KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0 Cit7CisgICAgaWYgKGNvdW50ZXJSZXNldExpc3QpCisgICAgICAgIHJldHVybiByZWFkQ291bnRl cihjb3VudGVyTmFtZSwgY291bnRlclJlc2V0TGlzdC5nZXQoKSwgdHJ1ZSk7CisgICAgZWxzZQor ICAgICAgICByZXR1cm4gMDsKK30KKworaW50IFJlbmRlclN0eWxlOjpjb3VudGVySW5jcmVtZW50 KGNvbnN0IFN0cmluZyYgY291bnRlck5hbWUpIGNvbnN0Cit7CisgICAgaWYgKGNvdW50ZXJJbmNy ZW1lbnRMaXN0KQorICAgICAgICByZXR1cm4gcmVhZENvdW50ZXIoY291bnRlck5hbWUsIGNvdW50 ZXJJbmNyZW1lbnRMaXN0LmdldCgpLCBmYWxzZSk7CisgICAgZWxzZQorICAgICAgICByZXR1cm4g MDsKK30KKwogY29uc3QgVmVjdG9yPFN0eWxlRGFzaGJvYXJkUmVnaW9uPiYgUmVuZGVyU3R5bGU6 OmluaXRpYWxEYXNoYm9hcmRSZWdpb25zKCkKIHsgCiAgICAgc3RhdGljIFZlY3RvcjxTdHlsZURh c2hib2FyZFJlZ2lvbj4gZW1wdHlMaXN0OwpJbmRleDogV2ViQ29yZS54Y29kZXByb2ovcHJvamVj dC5wYnhwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agkocmV2aXNpb24gMTY3MTcpCisrKyBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oJ KHdvcmtpbmcgY29weSkKQEAgLTEwODgsNiArMTA4OCwxMyBAQAogCQk5MzhFNjY2MjA5RjA5Qjg3 MDA4QTQ4RUMgLyogSlNIVE1MQ2FudmFzRWxlbWVudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM4RTY2NjEwOUYwOUI4NzAwOEE0OEVDIC8qIEpTSFRN TENhbnZhc0VsZW1lbnQuaCAqLzsgfTsKIAkJOTM4RTY4M0MwOUYwQkQ3QjAwOEE0OEVDIC8qIEdy YXBoaWNzVHlwZXMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDkzOEU2ODNCMDlGMEJEN0EwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmggKi87IH07CiAJ CTkzOEU2ODU0MDlGMEJFMDQwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOEU2ODUzMDlGMEJFMDQwMDhB NDhFQyAvKiBHcmFwaGljc1R5cGVzLmNwcCAqLzsgfTsKKwkJOTM5MkYxNDIwQUQxODVGNDAwNjkx QkQ0IC8qIFJlbmRlckNvdW50ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDkzOTJGMTQxMEFEMTg1RjQwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmgg Ki87IH07CisJCTkzOTJGMTQ0MEFEMTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTQzMEFE MTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLzsgfTsKKwkJOTM5MkYxNDYwQUQx ODYwQzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTQ1MEFEMTg2MEMwMDY5MUJENCAvKiBDb3Vu dGVyUmVzZXROb2RlLmggKi87IH07CisJCTkzOTJGMTRBMEFEMTg2MTMwMDY5MUJENCAvKiBDb3Vu dGVyUmVzZXROb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDkzOTJGMTQ5MEFEMTg2MTMwMDY5MUJENCAvKiBDb3VudGVyUmVzZXROb2RlLmNwcCAq LzsgfTsKKwkJOTM5MkYxNEMwQUQxODYxQjAwNjkxQkQ0IC8qIENvdW50ZXJOb2RlLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5MzkyRjE0QjBBRDE4NjFC MDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAqLzsgfTsKKwkJOTM5MkYxNTAwQUQxODYyMzAwNjkx QkQ0IC8qIENvdW50ZXJOb2RlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDkzOTJGMTRGMEFEMTg2MjMwMDY5MUJENCAvKiBDb3VudGVyTm9kZS5jcHAg Ki87IH07CisJCTkzOTJGMTUyMEFEMTg2MkIwMDY5MUJENCAvKiBDb3VudGVyTGlzdEl0ZW0uaCBp biBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDkzOTJGMTUxMEFE MTg2MkIwMDY5MUJENCAvKiBDb3VudGVyTGlzdEl0ZW0uaCAqLzsgfTsKIAkJOTM5ODg1QzMwOEI3 RTNEMTAwRTcwN0M0IC8qIEV2ZW50TmFtZXMuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gOTM5ODg1QzEwOEI3RTNEMTAwRTcwN0M0IC8qIEV2ZW50TmFt ZXMuY3BwICovOyB9OwogCQk5Mzk4ODVDNDA4QjdFM0QxMDBFNzA3QzQgLyogRXZlbnROYW1lcy5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOTM5ODg1QzIw OEI3RTNEMTAwRTcwN0M0IC8qIEV2ZW50TmFtZXMuaCAqLzsgfTsKIAkJOTNBMUVBQTAwQTU2MzRD OTAwNjk2MEEwIC8qIEltYWdlRG9jdW1lbnRNYWMubW0gaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA5M0ExRUE5RjBBNTYzNEM5MDA2OTYwQTAgLyogSW1hZ2VE b2N1bWVudE1hYy5tbSAqLzsgfTsKQEAgLTM2MzYsNiArMzY0MywxMyBAQAogCQk5MzhFNjY2MTA5 RjA5Qjg3MDA4QTQ4RUMgLyogSlNIVE1MQ2FudmFzRWxlbWVudC5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBKU0hUTUxDYW52YXNFbGVtZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCTkzOEU2ODNCMDlGMEJEN0EwMDhBNDhFQyAvKiBHcmFwaGljc1R5cGVzLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEdyYXBoaWNzVHlwZXMuaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM4RTY4NTMwOUYwQkUwNDAwOEE0OEVDIC8qIEdyYXBo aWNzVHlwZXMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gR3JhcGhp Y3NUeXBlcy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkzOTJGMTQxMEFEMTg1 RjQwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7 IHBhdGggPSBSZW5kZXJDb3VudGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTkz OTJGMTQzMEFEMTg1RkUwMDY5MUJENCAvKiBSZW5kZXJDb3VudGVyLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW5kZXJDb3VudGVyLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJOTM5MkYxNDUwQUQxODYwQzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNl dE5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJSZXNldE5v ZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJOTM5MkYxNDkwQUQxODYxMzAwNjkx QkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IENvdW50ZXJSZXNldE5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OworCQk5MzkyRjE0QjBBRDE4NjFCMDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUg PSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IENvdW50ZXJOb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCTkzOTJGMTRGMEFEMTg2MjMwMDY5MUJENCAvKiBDb3VudGVyTm9kZS5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQ291bnRlck5vZGUuY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk5MzkyRjE1MTBBRDE4NjJCMDA2OTFCRDQgLyog Q291bnRlckxpc3RJdGVtLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBDb3Vu dGVyTGlzdEl0ZW0uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJOTM5NEUwQTQwM0FB NUJCRTAwODYzNUNFIC8qIFdlYkNvcmVQYWdlU3RhdGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBpbmRlbnRXaWR0aCA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXZWJDb3JlUGFnZVN0YXRlLmg7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IHRhYldpZHRoID0gODsgdXNlc1RhYnMgPSAwOyB9OwogCQk5Mzk0RTBB NTAzQUE1QkJFMDA4NjM1Q0UgLyogV2ViQ29yZVBhZ2VTdGF0ZS5tbSAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBpbmRlbnRXaWR0aCA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAub2JqY3BwOyBwYXRoID0gV2ViQ29yZVBhZ2VTdGF0 ZS5tbTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgdGFiV2lkdGggPSA4OyB1c2VzVGFicyA9IDA7 IH07CiAJCTkzOTU1QTQxMDNENzI5MzIwMDg2MzVDRSAvKiBSZW5kZXJUcmVlQXNUZXh0LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgaW5kZW50V2lkdGgg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUmVuZGVyVHJl ZUFzVGV4dC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB0YWJXaWR0aCA9IDg7IHVzZXNUYWJz ID0gMDsgfTsKQEAgLTc4NTMsNiArNzg2NywxMSBAQAogCQkJCUJDRUE0ODE0MDk3RDkzMDIwMDk0 QzlFNCAvKiBiaWRpLmggKi8sCiAJCQkJQkNFQTQ4MTUwOTdEOTMwMjAwOTRDOUU0IC8qIGJyZWFr X2xpbmVzLmNwcCAqLywKIAkJCQlCQ0VBNDgxNjA5N0Q5MzAyMDA5NEM5RTQgLyogYnJlYWtfbGlu ZXMuaCAqLywKKwkJCQk5MzkyRjE1MTBBRDE4NjJCMDA2OTFCRDQgLyogQ291bnRlckxpc3RJdGVt LmggKi8sCisJCQkJOTM5MkYxNEYwQUQxODYyMzAwNjkxQkQ0IC8qIENvdW50ZXJOb2RlLmNwcCAq LywKKwkJCQk5MzkyRjE0QjBBRDE4NjFCMDA2OTFCRDQgLyogQ291bnRlck5vZGUuaCAqLywKKwkJ CQk5MzkyRjE0OTBBRDE4NjEzMDA2OTFCRDQgLyogQ291bnRlclJlc2V0Tm9kZS5jcHAgKi8sCisJ CQkJOTM5MkYxNDUwQUQxODYwQzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuaCAqLywKIAkJ CQlCQ0VBNDgxNzA5N0Q5MzAyMDA5NEM5RTQgLyogRGF0YVJlZi5oICovLAogCQkJCUFCRTdCNTIx MEE0ODlGODMwMDMxODgxQyAvKiBEZXByZWNhdGVkUmVuZGVyU2VsZWN0LmNwcCAqLywKIAkJCQlB QkU3QjUyMjBBNDg5RjgzMDAzMTg4MUMgLyogRGVwcmVjYXRlZFJlbmRlclNlbGVjdC5oICovLApA QCAtNzg4OSw2ICs3OTA4LDggQEAKIAkJCQlCQ0VBNDgyOTA5N0Q5MzAyMDA5NEM5RTQgLyogUmVu ZGVyVmlldy5oICovLAogCQkJCUJDRUE0ODJDMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250 YWluZXIuY3BwICovLAogCQkJCUJDRUE0ODJEMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJDb250 YWluZXIuaCAqLywKKwkJCQk5MzkyRjE0MzBBRDE4NUZFMDA2OTFCRDQgLyogUmVuZGVyQ291bnRl ci5jcHAgKi8sCisJCQkJOTM5MkYxNDEwQUQxODVGNDAwNjkxQkQ0IC8qIFJlbmRlckNvdW50ZXIu aCAqLywKIAkJCQlBOEVBNzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmllbGRzZXQuY3Bw ICovLAogCQkJCUE4RUE3M0IwMEExOTAwRTMwMEE4RUY1RiAvKiBSZW5kZXJGaWVsZHNldC5oICov LAogCQkJCTA2NkM3NzJFMEFCNjAzRkQwMDIzOENDNCAvKiBSZW5kZXJGaWxlVXBsb2FkQ29udHJv bC5jcHAgKi8sCkBAIC05MzE5LDYgKzkzNDAsMTAgQEAKIAkJCQk4NTAwNERBNjBBQ0VFQjVBMDBD NDM4RjYgLyogRE9NU1ZHRG9jdW1lbnRJbnRlcm5hbC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJODUw MDREQTcwQUNFRUI1QTAwQzQzOEY2IC8qIERPTVNWR0VsbGlwc2VFbGVtZW50SW50ZXJuYWwuaCBp biBIZWFkZXJzICovLAogCQkJCUFCQjU0MTlGMEFDRERGRTQwMDI4MjBFQiAvKiBSZW5kZXJMaXN0 Qm94LmggaW4gSGVhZGVycyAqLywKKwkJCQk5MzkyRjE0MjBBRDE4NUY0MDA2OTFCRDQgLyogUmVu ZGVyQ291bnRlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM5MkYxNDYwQUQxODYwQzAwNjkxQkQ0 IC8qIENvdW50ZXJSZXNldE5vZGUuaCBpbiBIZWFkZXJzICovLAorCQkJCTkzOTJGMTRDMEFEMTg2 MUIwMDY5MUJENCAvKiBDb3VudGVyTm9kZS5oIGluIEhlYWRlcnMgKi8sCisJCQkJOTM5MkYxNTIw QUQxODYyQjAwNjkxQkQ0IC8qIENvdW50ZXJMaXN0SXRlbS5oIGluIEhlYWRlcnMgKi8sCiAJCQkp OwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CkBAIC0x MDQ0Niw2ICsxMDQ3MSw5IEBACiAJCQkJODUwMDREOTkwQUNFRUFFRjAwQzQzOEY2IC8qIERPTVNW R0RvY3VtZW50Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJODUwMDREOUIwQUNFRUFFRjAwQzQzOEY2 IC8qIERPTVNWR0VsbGlwc2VFbGVtZW50Lm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJQUJCNTQxOUUw QUNEREZFNDAwMjgyMEVCIC8qIFJlbmRlckxpc3RCb3guY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJ OTM5MkYxNDQwQUQxODVGRTAwNjkxQkQ0IC8qIFJlbmRlckNvdW50ZXIuY3BwIGluIFNvdXJjZXMg Ki8sCisJCQkJOTM5MkYxNEEwQUQxODYxMzAwNjkxQkQ0IC8qIENvdW50ZXJSZXNldE5vZGUuY3Bw IGluIFNvdXJjZXMgKi8sCisJCQkJOTM5MkYxNTAwQUQxODYyMzAwNjkxQkQ0IC8qIENvdW50ZXJO b2RlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9z dHByb2Nlc3NpbmcgPSAwOwogCQl9OwpJbmRleDogY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJh dGlvbi5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5j cHAJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL0NTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTYwMiwxMSArNjAyLDkgQEAKICAgICAgICAgLy8gRklYTUU6 IHVuaW1wbGVtZW50ZWQKICAgICAgICAgYnJlYWs7CiAgICAgY2FzZSBDU1NfUFJPUF9DT1VOVEVS X0lOQ1JFTUVOVDoKLSAgICAgICAgLy8gRklYTUU6IHVuaW1wbGVtZW50ZWQKLSAgICAgICAgYnJl YWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+Y291bnRlckluY3JlbWVudFZhbHVlTGlzdCgpOwog ICAgIGNhc2UgQ1NTX1BST1BfQ09VTlRFUl9SRVNFVDoKLSAgICAgICAgLy8gRklYTUU6IHVuaW1w bGVtZW50ZWQKLSAgICAgICAgYnJlYWs7CisgICAgICAgIHJldHVybiBzdHlsZS0+Y291bnRlclJl c2V0VmFsdWVMaXN0KCk7CiAgICAgY2FzZSBDU1NfUFJPUF9DVVJTT1I6IHsKICAgICAgICAgQ1NT VmFsdWVMaXN0KiBsaXN0ID0gMDsKICAgICAgICAgQ1NTVmFsdWUqIHZhbHVlID0gMDsKSW5kZXg6 IGNzcy9jc3NzdHlsZXNlbGVjdG9yLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3Nzc3R5bGVzZWxl Y3Rvci5jcHAJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL2Nzc3N0eWxlc2VsZWN0b3IuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAiQ1NTU3R5bGVTaGVldC5o IgogI2luY2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKICNpbmNsdWRlICJDU1NWYWx1ZUxpc3Qu aCIKKyNpbmNsdWRlICJDb3VudGVyLmgiCiAjaW5jbHVkZSAiQ2FjaGVkSW1hZ2UuaCIKICNpbmNs dWRlICJEYXNoYm9hcmRSZWdpb24uaCIKICNpbmNsdWRlICJGb250RmFtaWx5VmFsdWUuaCIKQEAg LTc1NywxOCArNzU4LDE2IEBACiAKIHZvaWQgQ1NTU3R5bGVTZWxlY3Rvcjo6bWF0Y2hVQVJ1bGVz KGludCYgZmlyc3RVQVJ1bGUsIGludCYgbGFzdFVBUnVsZSkKIHsKLSAgICAvLyAxLiBGaXJzdCB3 ZSBtYXRjaCBydWxlcyBmcm9tIHRoZSB1c2VyIGFnZW50IHNoZWV0LgotICAgIG1hdGNoUnVsZXMo ZGVmYXVsdFN0eWxlLCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CisgICAgLy8gRmlyc3Qgd2Ug bWF0Y2ggcnVsZXMgZnJvbSB0aGUgdXNlciBhZ2VudCBzaGVldC4KKyAgICBDU1NSdWxlU2V0KiB1 c2VyQWdlbnRTdHlsZVNoZWV0ID0gbV9tZWRpdW0tPm1lZGlhVHlwZU1hdGNoKCJwcmludCIpCisg ICAgICAgID8gZGVmYXVsdFByaW50U3R5bGUgOiBkZWZhdWx0U3R5bGU7CisgICAgbWF0Y2hSdWxl cyh1c2VyQWdlbnRTdHlsZVNoZWV0LCBmaXJzdFVBUnVsZSwgbGFzdFVBUnVsZSk7CiAKLSAgICAv LyAyLiBJbiBxdWlya3MgbW9kZSwgd2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgcXVpcmtzIHVzZXIg YWdlbnQgc2hlZXQuCisgICAgLy8gSW4gcXVpcmtzIG1vZGUsIHdlIG1hdGNoIHJ1bGVzIGZyb20g dGhlIHF1aXJrcyB1c2VyIGFnZW50IHNoZWV0LgogICAgIGlmICghc3RyaWN0UGFyc2luZykKICAg ICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UXVpcmtzU3R5bGUsIGZpcnN0VUFSdWxlLCBsYXN0VUFS dWxlKTsKLQotICAgIC8vIDMuIElmIG91ciBtZWRpdW0gaXMgcHJpbnQsIHRoZW4gd2UgbWF0Y2gg cnVsZXMgZnJvbSB0aGUgcHJpbnQgc2hlZXQuCi0gICAgaWYgKG1fbWVkaXVtLT5tZWRpYVR5cGVN YXRjaCgicHJpbnQiKSkKLSAgICAgICAgbWF0Y2hSdWxlcyhkZWZhdWx0UHJpbnRTdHlsZSwgZmly c3RVQVJ1bGUsIGxhc3RVQVJ1bGUpOwogICAgICAgICAKLSAgICAvLyA0LiBJZiB3ZSdyZSBpbiB2 aWV3IHNvdXJjZSBtb2RlLCB0aGVuIHdlIG1hdGNoIHJ1bGVzIGZyb20gdGhlIHZpZXcgc291cmNl IHN0eWxlIHNoZWV0LgorICAgIC8vIElmIHdlJ3JlIGluIHZpZXcgc291cmNlIG1vZGUsIHRoZW4g d2UgbWF0Y2ggcnVsZXMgZnJvbSB0aGUgdmlldyBzb3VyY2Ugc3R5bGUgc2hlZXQuCiAgICAgaWYg KHZpZXcgJiYgdmlldy0+ZnJhbWUoKSAmJiB2aWV3LT5mcmFtZSgpLT5pblZpZXdTb3VyY2VNb2Rl KCkpCiAgICAgICAgIG1hdGNoUnVsZXMoZGVmYXVsdFZpZXdTb3VyY2VTdHlsZSwgZmlyc3RVQVJ1 bGUsIGxhc3RVQVJ1bGUpOwogfQpAQCAtMzE3Niw3ICszMTc1LDkgQEAKIAogICAgICAgICBmb3Ig KGludCBpID0gMDsgaSA8IGxlbjsgaSsrKSB7CiAgICAgICAgICAgICBDU1NWYWx1ZSAqaXRlbSA9 IGxpc3QtPml0ZW0oaSk7Ci0gICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZlVmFsdWUo KSkgY29udGludWU7CisgICAgICAgICAgICBpZiAoIWl0ZW0tPmlzUHJpbWl0aXZlVmFsdWUoKSkK KyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIAogICAgICAgICAgICAgQ1NT UHJpbWl0aXZlVmFsdWUgKnZhbCA9IHN0YXRpY19jYXN0PENTU1ByaW1pdGl2ZVZhbHVlKj4oaXRl bSk7CiAgICAgICAgICAgICBpZiAodmFsLT5wcmltaXRpdmVUeXBlKCk9PUNTU1ByaW1pdGl2ZVZh bHVlOjpDU1NfU1RSSU5HKQogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KHZhbC0+ Z2V0U3RyaW5nVmFsdWUoKS5pbXBsKCksIGkgIT0gMCk7CkBAIC0zMTkwLDE5ICszMTkxLDI4IEBA CiAgICAgICAgICAgICAgICAgc3R5bGUtPnNldENvbnRlbnQoZWxlbWVudC0+Z2V0QXR0cmlidXRl KGF0dHIpLmltcGwoKSwgaSAhPSAwKTsKICAgICAgICAgICAgICAgICAvLyByZWdpc3RlciB0aGUg ZmFjdCB0aGF0IHRoZSBhdHRyaWJ1dGUgdmFsdWUgYWZmZWN0cyB0aGUgc3R5bGUKICAgICAgICAg ICAgICAgICBtX3NlbGVjdG9yQXR0cnMuYWRkKGF0dHIubG9jYWxOYW1lKCkuaW1wbCgpKTsKLSAg ICAgICAgICAgIH0KLSAgICAgICAgICAgIGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1D U1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1VSSSkgeworICAgICAgICAgICAgfSBlbHNlIGlmICh2YWwt PnByaW1pdGl2ZVR5cGUoKT09Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19VUkkpIHsKICAgICAgICAg ICAgICAgICBDU1NJbWFnZVZhbHVlICppbWFnZSA9IHN0YXRpY19jYXN0PENTU0ltYWdlVmFsdWUq Pih2YWwpOwogICAgICAgICAgICAgICAgIHN0eWxlLT5zZXRDb250ZW50KGltYWdlLT5pbWFnZShl bGVtZW50LT5kb2N1bWVudCgpLT5kb2NMb2FkZXIoKSksIGkgIT0gMCk7Ci0gICAgICAgICAgICB9 CisgICAgICAgICAgICB9IGVsc2UgaWYgKHZhbC0+cHJpbWl0aXZlVHlwZSgpPT1DU1NQcmltaXRp dmVWYWx1ZTo6Q1NTX0NPVU5URVIpIHsKKyAgICAgICAgICAgICAgICBDb3VudGVyKiBjb3VudGVy VmFsdWUgPSB2YWwtPmdldENvdW50ZXJWYWx1ZSgpOworICAgICAgICAgICAgICAgIENvdW50ZXJE YXRhIGNvdW50ZXIoY291bnRlclZhbHVlLT5pZGVudGlmaWVyKCksCisgICAgICAgICAgICAgICAg ICAgIChFTGlzdFN0eWxlVHlwZSljb3VudGVyVmFsdWUtPmxpc3RTdHlsZU51bWJlcigpLCBjb3Vu dGVyVmFsdWUtPnNlcGFyYXRvcigpKTsKKyAgICAgICAgICAgICAgICBzdHlsZS0+c2V0Q29udGVu dChuZXcgQ291bnRlckRhdGEoY291bnRlciksIGkgIT0gMCk7CisgICAgICAgICAgIH0KICAgICAg ICAgfQogICAgICAgICBicmVhazsKICAgICB9CiAKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJf SU5DUkVNRU5UOgotICAgICAgICAvLyBsaXN0IG9mIENTUzJDb3VudGVySW5jcmVtZW50CisgICAg ICAgIGlmICghdmFsdWUtPmlzVmFsdWVMaXN0KCkpCisgICAgICAgICAgICByZXR1cm47CisgICAg ICAgIHN0eWxlLT5zZXRDb3VudGVySW5jcmVtZW50TGlzdChzdGF0aWNfY2FzdDxDU1NWYWx1ZUxp c3QqPih2YWx1ZSkpOworICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0NPVU5URVJf UkVTRVQ6Ci0gICAgICAgIC8vIGxpc3Qgb2YgQ1NTMkNvdW50ZXJSZXNldAorICAgICAgICBpZiAo IXZhbHVlLT5pc1ZhbHVlTGlzdCgpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICBzdHls ZS0+c2V0Q291bnRlclJlc2V0TGlzdChzdGF0aWNfY2FzdDxDU1NWYWx1ZUxpc3QqPih2YWx1ZSkp OwogICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9QX0ZPTlRfRkFNSUxZOiB7CiAgICAg ICAgIC8vIGxpc3Qgb2Ygc3RyaW5ncyBhbmQgaWRzCkluZGV4OiBjc3MvY3NzcGFyc2VyLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gY3NzL2Nzc3BhcnNlci5oCShyZXZpc2lvbiAxNjcxNykKKysrIGNzcy9jc3Nw YXJzZXIuaAkod29ya2luZyBjb3B5KQpAQCAtMTIwLDcgKzEyMCw3IEBACiAKICAgICAgICAgRG9j dW1lbnQqIGRvY3VtZW50KCkgY29uc3Q7CiAKLSAgICAgICAgdm9pZCBhZGRQcm9wZXJ0eShpbnQg cHJvcElkLCBDU1NWYWx1ZSosIGJvb2wgaW1wb3J0YW50KTsKKyAgICAgICAgdm9pZCBhZGRQcm9w ZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiwgYm9vbCBpbXBvcnRhbnQpOwog ICAgICAgICB2b2lkIHJvbGxiYWNrTGFzdFByb3BlcnRpZXMoaW50IG51bSk7CiAgICAgICAgIGJv b2wgaGFzUHJvcGVydGllcygpIGNvbnN0IHsgcmV0dXJuIG51bVBhcnNlZFByb3BlcnRpZXMgPiAw OyB9CiAKQEAgLTE0NiwxMSArMTQ2LDEzIEBACiAKICAgICAgICAgYm9vbCBwYXJzZVNoYXBlKGlu dCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKICAgICAgICAgYm9vbCBwYXJzZUZvbnQoYm9vbCBp bXBvcnRhbnQpOworICAgICAgICBib29sIHBhcnNlQ291bnRlcihpbnQgcHJvcElkLCBpbnQgZGVm YXVsdFZhbHVlLCBib29sIGltcG9ydGFudCk7CiAgICAgICAgIENTU1ZhbHVlTGlzdCogcGFyc2VG b250RmFtaWx5KCk7CiAgICAgICAgIGJvb2wgcGFyc2VDb2xvclBhcmFtZXRlcnMoVmFsdWUqLCBp bnQqIGNvbG9yVmFsdWVzLCBib29sIHBhcnNlQWxwaGEpOwogICAgICAgICBib29sIHBhcnNlSFNM UGFyYW1ldGVycyhWYWx1ZSosIGRvdWJsZSogY29sb3JWYWx1ZXMsIGJvb2wgcGFyc2VBbHBoYSk7 CiAgICAgICAgIENTU1ByaW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yKCk7CiAgICAgICAgIENTU1By aW1pdGl2ZVZhbHVlKiBwYXJzZUNvbG9yRnJvbVZhbHVlKFZhbHVlKik7CisgICAgICAgIFBhc3NS ZWZQdHI8Q1NTVmFsdWU+IHBhcnNlQ291bnRlckNvbnRlbnQoVmFsdWVMaXN0KiBhcmdzLCBib29s IGNvdW50ZXJzKTsKICAgICAgICAgCiAjaWZkZWYgU1ZHX1NVUFBPUlQKICAgICAgICAgYm9vbCBw YXJzZVNWR1ZhbHVlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KTsKSW5kZXg6IGNzcy9DU1NQ cmltaXRpdmVWYWx1ZS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gY3NzL0NTU1ByaW1pdGl2ZVZhbHVlLmNw cAkocmV2aXNpb24gMTY3MTcpCisrKyBjc3MvQ1NTUHJpbWl0aXZlVmFsdWUuY3BwCSh3b3JraW5n IGNvcHkpCkBAIC01MjQsNyArNTI0LDEwIEBACiAgICAgICAgICAgICAvLyAjIyMKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICBjYXNlIENTU19DT1VOVEVSOgotICAgICAgICAgICAgLy8gIyMj CisgICAgICAgICAgICB0ZXh0ID0gImNvdW50ZXIoIjsKKyAgICAgICAgICAgIHRleHQgKz0gU3Ry aW5nOjpudW1iZXIobV92YWx1ZS5udW0pOworICAgICAgICAgICAgdGV4dCArPSAiKSI7CisgICAg ICAgICAgICAvLyBGSVhNRTogQWRkIGxpc3Qtc3R5bGUgYW5kIHNlcGFyYXRvcgogICAgICAgICAg ICAgYnJlYWs7CiAgICAgICAgIGNhc2UgQ1NTX1JFQ1Q6IHsKICAgICAgICAgICAgIFJlY3RJbXBs KiByZWN0VmFsID0gZ2V0UmVjdFZhbHVlKCk7CkluZGV4OiBjc3MvQ291bnRlci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIGNzcy9Db3VudGVyLmgJKHJldmlzaW9uIDE2NzE3KQorKysgY3NzL0NvdW50ZXIuaAko d29ya2luZyBjb3B5KQpAQCAtMjMsMjMgKzIzLDM3IEBACiAjaWZuZGVmIENvdW50ZXJfSAogI2Rl ZmluZSBDb3VudGVyX0gKIAorI2luY2x1ZGUgIkNTU1ByaW1pdGl2ZVZhbHVlLmgiCisjaW5jbHVk ZSAiUGxhdGZvcm1TdHJpbmcuaCIKICNpbmNsdWRlICJTaGFyZWQuaCIKLSNpbmNsdWRlICJQbGF0 Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIAogY2xhc3MgQ291bnRlciA6IHB1YmxpYyBTaGFyZWQ8Q291bnRlcj4gewogcHVi bGljOgotICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9pZGVudGlmaWVy OyB9Ci0gICAgU3RyaW5nIGxpc3RTdHlsZSgpIGNvbnN0IHsgcmV0dXJuIG1fbGlzdFN0eWxlOyB9 Ci0gICAgU3RyaW5nIHNlcGFyYXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yOyB9Cisg ICAgQ291bnRlcigpIDogbV9pZGVudGlmaWVyKDApLCBtX2xpc3RTdHlsZSgwKSwgbV9zZXBhcmF0 b3IoMCkgeyB9CisgICAgQ291bnRlcihQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVu dGlmaWVyLCBQYXNzUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBsaXN0U3R5bGUsCisgICAgICAg IFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikKKyAgICAgICAgOiBtX2lk ZW50aWZpZXIoaWRlbnRpZmllciksIG1fbGlzdFN0eWxlKGxpc3RTdHlsZSksIG1fc2VwYXJhdG9y KHNlcGFyYXRvcikgeyB9CisgICAgfkNvdW50ZXIoKSB7IH0KIAotcHJpdmF0ZToKLSAgICBTdHJp bmcgbV9pZGVudGlmaWVyOwotICAgIFN0cmluZyBtX2xpc3RTdHlsZTsKLSAgICBTdHJpbmcgbV9z ZXBhcmF0b3I7Ci19OworICAgIFN0cmluZyBpZGVudGlmaWVyKCkgY29uc3QgeyByZXR1cm4gbV9p ZGVudGlmaWVyID8gbV9pZGVudGlmaWVyLT5nZXRTdHJpbmdWYWx1ZSgpIDogU3RyaW5nKCk7IH0K KyAgICBTdHJpbmcgbGlzdFN0eWxlKCkgY29uc3QgeyByZXR1cm4gbV9saXN0U3R5bGUgPyBtX2xp c3RTdHlsZS0+Z2V0U3RyaW5nVmFsdWUoKSA6IFN0cmluZygpOyB9CisgICAgU3RyaW5nIHNlcGFy YXRvcigpIGNvbnN0IHsgcmV0dXJuIG1fc2VwYXJhdG9yID8gbV9zZXBhcmF0b3ItPmdldFN0cmlu Z1ZhbHVlKCkgOiBTdHJpbmcoKTsgfQogCi19IC8vIG5hbWVzcGFjZQorICAgIGludCBsaXN0U3R5 bGVOdW1iZXIoKSBjb25zdCB7IHJldHVybiBtX2xpc3RTdHlsZSA/IChpbnQpIG1fbGlzdFN0eWxl LT5nZXRGbG9hdFZhbHVlKCkgOiAwOyB9CisgICAgCisgICAgdm9pZCBzZXRJZGVudGlmaWVyKFBh c3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IGlkZW50aWZpZXIpIHsgbV9pZGVudGlmaWVyID0g aWRlbnRpZmllcjsgfQorICAgIHZvaWQgc2V0TGlzdFN0eWxlKFBhc3NSZWZQdHI8Q1NTUHJpbWl0 aXZlVmFsdWU+IGxpc3RTdHlsZSkgeyBtX2xpc3RTdHlsZSA9IGxpc3RTdHlsZTsgfQorICAgIHZv aWQgc2V0U2VwYXJhdG9yKFBhc3NSZWZQdHI8Q1NTUHJpbWl0aXZlVmFsdWU+IHNlcGFyYXRvcikg eyBtX3NlcGFyYXRvciA9IHNlcGFyYXRvcjsgfQorIAorcHJvdGVjdGVkOgorICAgIFJlZlB0cjxD U1NQcmltaXRpdmVWYWx1ZT4gbV9pZGVudGlmaWVyOyAvLyBTdHJpbmcKKyAgICBSZWZQdHI8Q1NT UHJpbWl0aXZlVmFsdWU+IG1fbGlzdFN0eWxlOyAgLy8gaW50CisgICAgUmVmUHRyPENTU1ByaW1p dGl2ZVZhbHVlPiBtX3NlcGFyYXRvcjsgIC8vIFN0cmluZworIH07CiAKK30gLy9uYW1lc3BhY2UK KwogI2VuZGlmCkluZGV4OiBjc3MvY3NzcGFyc2VyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBjc3MvY3Nz cGFyc2VyLmNwcAkocmV2aXNpb24gMTY3MTcpCisrKyBjc3MvY3NzcGFyc2VyLmNwcAkod29ya2lu ZyBjb3B5KQpAQCAtNDMsNiArNDMsNyBAQAogI2luY2x1ZGUgIkNTU1F1aXJrUHJpbWl0aXZlVmFs dWUuaCIKICNpbmNsdWRlICJDU1NWYWx1ZUtleXdvcmRzLmgiCiAjaW5jbHVkZSAiQ1NTVmFsdWVM aXN0LmgiCisjaW5jbHVkZSAiQ291bnRlci5oIgogI2luY2x1ZGUgIkRhc2hib2FyZFJlZ2lvbi5o IgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRm9udEZhbWlseVZhbHVlLmgiCkBA IC0zMzUsNyArMzM2LDcgQEAKIH0KIAogCi12b2lkIENTU1BhcnNlcjo6YWRkUHJvcGVydHkoaW50 IHByb3BJZCwgQ1NTVmFsdWUgKnZhbHVlLCBib29sIGltcG9ydGFudCkKK3ZvaWQgQ1NTUGFyc2Vy OjphZGRQcm9wZXJ0eShpbnQgcHJvcElkLCBQYXNzUmVmUHRyPENTU1ZhbHVlPiB2YWx1ZSwgYm9v bCBpbXBvcnRhbnQpCiB7CiAgICAgQ1NTUHJvcGVydHkgKnByb3AgPSBuZXcgQ1NTUHJvcGVydHko cHJvcElkLCB2YWx1ZSwgaW1wb3J0YW50LCBtX2N1cnJlbnRTaG9ydGhhbmQsIG1faW1wbGljaXRT aG9ydGhhbmQpOwogICAgIGlmIChudW1QYXJzZWRQcm9wZXJ0aWVzID49IG1heFBhcnNlZFByb3Bl cnRpZXMpIHsKQEAgLTkxMyw2ICs5MTQsMTYgQEAKICAgICAgICAgZWxzZQogICAgICAgICAgICAg dmFsaWRfcHJpbWl0aXZlID0gKCFpZCAmJiB2YWxpZFVuaXQodmFsdWUsIEZOdW1iZXJ8Rkxlbmd0 aHxGUGVyY2VudCwgc3RyaWN0KSk7CiAgICAgICAgIGJyZWFrOworICAgIGNhc2UgQ1NTX1BST1Bf Q09VTlRFUl9JTkNSRU1FTlQ6ICAgIC8vIFsgPGlkZW50aWZpZXI+IDxpbnRlZ2VyPj8gXSsgfCBu b25lIHwgaW5oZXJpdAorICAgICAgICBpZiAoaWQgIT0gQ1NTX1ZBTF9OT05FKQorICAgICAgICAg ICAgcmV0dXJuIHBhcnNlQ291bnRlcihwcm9wSWQsIDEsIGltcG9ydGFudCk7CisgICAgICAgIHZh bGlkX3ByaW1pdGl2ZSA9IHRydWU7CisgICAgICAgIGJyZWFrOworICAgICBjYXNlIENTU19QUk9Q X0NPVU5URVJfUkVTRVQ6ICAgICAgICAvLyBbIDxpZGVudGlmaWVyPiA8aW50ZWdlcj4/IF0rIHwg bm9uZSB8IGluaGVyaXQKKyAgICAgICAgaWYgKGlkICE9IENTU19WQUxfTk9ORSkKKyAgICAgICAg ICAgIHJldHVybiBwYXJzZUNvdW50ZXIocHJvcElkLCAwLCBpbXBvcnRhbnQpOworICAgICAgICB2 YWxpZF9wcmltaXRpdmUgPSB0cnVlOworICAgICAgICBicmVhazsKICAgICBjYXNlIENTU19QUk9Q X0ZPTlRfRkFNSUxZOgogICAgICAgICAvLyBbWyA8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFt aWx5PiBdLF0qIFs8ZmFtaWx5LW5hbWU+IHwgPGdlbmVyaWMtZmFtaWx5Pl0gfCBpbmhlcml0CiAg ICAgewpAQCAtMTU2NiwyOCArMTU3NywzOCBAQAogLy8gWyA8c3RyaW5nPiB8IGF0dHIoWCkgfCBv cGVuLXF1b3RlIHwgY2xvc2UtcXVvdGUgfCBuby1vcGVuLXF1b3RlIHwgbm8tY2xvc2UtcXVvdGUg XSsgfCBpbmhlcml0CiBib29sIENTU1BhcnNlcjo6cGFyc2VDb250ZW50KGludCBwcm9wSWQsIGJv b2wgaW1wb3J0YW50KQogewotICAgIENTU1ZhbHVlTGlzdCogdmFsdWVzID0gbmV3IENTU1ZhbHVl TGlzdDsKKyAgICBSZWZQdHI8Q1NTVmFsdWVMaXN0PiB2YWx1ZXMgPSBuZXcgQ1NTVmFsdWVMaXN0 OwogCiAgICAgd2hpbGUgKFZhbHVlKiB2YWwgPSB2YWx1ZUxpc3QtPmN1cnJlbnQoKSkgewotICAg ICAgICBDU1NWYWx1ZSogcGFyc2VkVmFsdWUgPSAwOworICAgICAgICBSZWZQdHI8Q1NTVmFsdWU+ IHBhcnNlZFZhbHVlOwogICAgICAgICBpZiAodmFsLT51bml0ID09IENTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfVVJJKSB7CiAgICAgICAgICAgICAvLyB1cmwKICAgICAgICAgICAgIFN0cmluZyB2YWx1 ZSA9IHBhcnNlVVJMKGRvbVN0cmluZyh2YWwtPnN0cmluZykpOwogICAgICAgICAgICAgcGFyc2Vk VmFsdWUgPSBuZXcgQ1NTSW1hZ2VWYWx1ZSgKICAgICAgICAgICAgICAgICBTdHJpbmcoS1VSTChz dHlsZUVsZW1lbnQtPmJhc2VVUkwoKS5kZXByZWNhdGVkU3RyaW5nKCksIHZhbHVlLmRlcHJlY2F0 ZWRTdHJpbmcoKSkudXJsKCkpLCBzdHlsZUVsZW1lbnQpOwogICAgICAgICB9IGVsc2UgaWYgKHZh bC0+dW5pdCA9PSBWYWx1ZTo6RnVuY3Rpb24pIHsKLSAgICAgICAgICAgIC8vIGF0dHIoWCkKKyAg ICAgICAgICAgIC8vIGF0dHIoWCkgfCBjb3VudGVyKFggWyxZXSkgfCBjb3VudGVycyhYLCBZLCBb LFpdKQogICAgICAgICAgICAgVmFsdWVMaXN0ICphcmdzID0gdmFsLT5mdW5jdGlvbi0+YXJnczsK ICAgICAgICAgICAgIFN0cmluZyBmbmFtZSA9IGRvbVN0cmluZyh2YWwtPmZ1bmN0aW9uLT5uYW1l KS5sb3dlcigpOwotICAgICAgICAgICAgaWYgKGZuYW1lICE9ICJhdHRyKCIgfHwgIWFyZ3MpCisg ICAgICAgICAgICBpZiAoIWFyZ3MpCiAgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAg ICAgICAgICAgaWYgKGFyZ3MtPnNpemUoKSAhPSAxKQorICAgICAgICAgICAgaWYgKGZuYW1lID09 ICJhdHRyKCIpIHsKKyAgICAgICAgICAgICAgICBpZiAoYXJncy0+c2l6ZSgpICE9IDEpCisgICAg ICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgICBWYWx1ZSogYSA9 IGFyZ3MtPmN1cnJlbnQoKTsKKyAgICAgICAgICAgICAgICBTdHJpbmcgYXR0ck5hbWUgPSBkb21T dHJpbmcoYS0+c3RyaW5nKTsKKyAgICAgICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+aXNIVE1M RG9jdW1lbnQoKSkKKyAgICAgICAgICAgICAgICAgICAgYXR0ck5hbWUgPSBhdHRyTmFtZS5sb3dl cigpOworICAgICAgICAgICAgICAgIHBhcnNlZFZhbHVlID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVl KGF0dHJOYW1lLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX0FUVFIpOworICAgICAgICAgICAgfSBl bHNlIGlmIChmbmFtZSA9PSAiY291bnRlcigiKSB7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFs dWUgPSBwYXJzZUNvdW50ZXJDb250ZW50KGFyZ3MsIGZhbHNlKTsKKyAgICAgICAgICAgICAgICBp ZiAoIXBhcnNlZFZhbHVlKSByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICB9IGVsc2UgaWYgKGZu YW1lID09ICJjb3VudGVycygiKSB7CisgICAgICAgICAgICAgICAgcGFyc2VkVmFsdWUgPSBwYXJz ZUNvdW50ZXJDb250ZW50KGFyZ3MsIHRydWUpOworICAgICAgICAgICAgICAgIGlmICghcGFyc2Vk VmFsdWUpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgIH0g ZWxzZQogICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAgICAgICAgIFZhbHVlICph ID0gYXJncy0+Y3VycmVudCgpOwotICAgICAgICAgICAgU3RyaW5nIGF0dHJOYW1lID0gZG9tU3Ry aW5nKGEtPnN0cmluZyk7Ci0gICAgICAgICAgICBpZiAoZG9jdW1lbnQoKS0+aXNIVE1MRG9jdW1l bnQoKSkKLSAgICAgICAgICAgICAgICBhdHRyTmFtZSA9IGF0dHJOYW1lLmxvd2VyKCk7Ci0gICAg ICAgICAgICBwYXJzZWRWYWx1ZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShhdHRyTmFtZSwgQ1NT UHJpbWl0aXZlVmFsdWU6OkNTU19BVFRSKTsKICAgICAgICAgfSBlbHNlIGlmICh2YWwtPnVuaXQg PT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkgewogICAgICAgICAgICAgLy8gb3Blbi1x dW90ZQogICAgICAgICAgICAgLy8gY2xvc2UtcXVvdGUKQEAgLTE1OTksMTcgKzE2MjAsMTYgQEAK ICAgICAgICAgfQogICAgICAgICBpZiAoIXBhcnNlZFZhbHVlKQogICAgICAgICAgICAgYnJlYWs7 Ci0gICAgICAgIHZhbHVlcy0+YXBwZW5kKHBhcnNlZFZhbHVlKTsKKyAgICAgICAgdmFsdWVzLT5h cHBlbmQocGFyc2VkVmFsdWUucmVsZWFzZSgpKTsKICAgICAgICAgdmFsdWVMaXN0LT5uZXh0KCk7 CiAgICAgfQogCiAgICAgaWYgKHZhbHVlcy0+bGVuZ3RoKCkpIHsKLSAgICAgICAgYWRkUHJvcGVy dHkocHJvcElkLCB2YWx1ZXMsIGltcG9ydGFudCk7CisgICAgICAgIGFkZFByb3BlcnR5KHByb3BJ ZCwgdmFsdWVzLnJlbGVhc2UoKSwgaW1wb3J0YW50KTsKICAgICAgICAgdmFsdWVMaXN0LT5uZXh0 KCk7CiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIAotICAgIGRlbGV0ZSB2YWx1ZXM7CiAg ICAgcmV0dXJuIGZhbHNlOwogfQogCkBAIC0yMDIxLDYgKzIwNDEsNTkgQEAKIH0KICNlbmRpZgog CitQYXNzUmVmUHRyPENTU1ZhbHVlPiBDU1NQYXJzZXI6OnBhcnNlQ291bnRlckNvbnRlbnQoVmFs dWVMaXN0KiBhcmdzLCBib29sIGNvdW50ZXJzKQoreworICAgIHVuc2lnbmVkIG51bUFyZ3MgPSBh cmdzLT5zaXplKCk7CisgICAgaWYgKGNvdW50ZXJzICYmIG51bUFyZ3MgIT0gMyAmJiBudW1Bcmdz ICE9IDUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghY291bnRlcnMgJiYgbnVtQXJncyAh PSAxICYmIG51bUFyZ3MgIT0gMykKKyAgICAgICAgcmV0dXJuIDA7CisgICAgCisgICAgVmFsdWUq IGkgPSBhcmdzLT5jdXJyZW50KCk7CisgICAgUmVmUHRyPENTU1ByaW1pdGl2ZVZhbHVlPiBpZGVu dGlmaWVyID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKGRvbVN0cmluZyhpLT5zdHJpbmcpLAorICAg ICAgICBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7CisKKyAgICBSZWZQdHI8Q1NTUHJp bWl0aXZlVmFsdWU+IHNlcGFyYXRvcjsKKyAgICBpZiAoIWNvdW50ZXJzKQorICAgICAgICBzZXBh cmF0b3IgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUoU3RyaW5nKCksIENTU1ByaW1pdGl2ZVZhbHVl OjpDU1NfU1RSSU5HKTsKKyAgICBlbHNlIHsKKyAgICAgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAg ICAgICAgaWYgKGktPnVuaXQgIT0gVmFsdWU6Ok9wZXJhdG9yIHx8IGktPmlWYWx1ZSAhPSAnLCcp CisgICAgICAgICAgICByZXR1cm4gMDsKKyAgICAgICAgCisgICAgICAgIGkgPSBhcmdzLT5uZXh0 KCk7CisgICAgICAgIGlmIChpLT51bml0ICE9IENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfU1RSSU5H KQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIAorICAgICAgICBzZXBhcmF0b3IgPSBu ZXcgQ1NTUHJpbWl0aXZlVmFsdWUoZG9tU3RyaW5nKGktPnN0cmluZyksIChDU1NQcmltaXRpdmVW YWx1ZTo6VW5pdFR5cGVzKSBpLT51bml0KTsKKyAgICB9CisKKyAgICBSZWZQdHI8Q1NTUHJpbWl0 aXZlVmFsdWU+IGxpc3RTdHlsZTsKKyAgICBpID0gYXJncy0+bmV4dCgpOworICAgIGlmICghaSkg Ly8gTWFrZSB0aGUgbGlzdCBzdHlsZSBkZWZhdWx0IGRlY2ltYWwKKyAgICAgICAgbGlzdFN0eWxl ID0gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKENTU19WQUxfREVDSU1BTCAtIENTU19WQUxfRElTQywg Q1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpOworICAgIGVsc2UgeworICAgICAgICBpZiAo aS0+dW5pdCAhPSBWYWx1ZTo6T3BlcmF0b3IgfHwgaS0+aVZhbHVlICE9ICcsJykKKyAgICAgICAg ICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgaSA9IGFyZ3MtPm5leHQoKTsKKyAgICAg ICAgaWYgKGktPnVuaXQgIT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkKKyAgICAgICAg ICAgIHJldHVybiAwOworICAgICAgICAKKyAgICAgICAgc2hvcnQgbHMgPSAwOworICAgICAgICBp ZiAoaS0+aWQgPT0gQ1NTX1ZBTF9OT05FKQorICAgICAgICAgICAgbHMgPSBDU1NfVkFMX0tBVEFL QU5BX0lST0hBIC0gQ1NTX1ZBTF9ESVNDICsgMTsKKyAgICAgICAgZWxzZSBpZiAoaS0+aWQgPj0g Q1NTX1ZBTF9ESVNDICYmIGktPmlkIDw9IENTU19WQUxfS0FUQUtBTkFfSVJPSEEpCisgICAgICAg ICAgICBscyA9IGktPmlkIC0gQ1NTX1ZBTF9ESVNDOworICAgICAgICBlbHNlCisgICAgICAgICAg ICByZXR1cm4gMDsKKworICAgICAgICBsaXN0U3R5bGUgPSBuZXcgQ1NTUHJpbWl0aXZlVmFsdWUo bHMsIChDU1NQcmltaXRpdmVWYWx1ZTo6VW5pdFR5cGVzKSBpLT51bml0KTsKKyAgICB9CisKKyAg ICByZXR1cm4gbmV3IENTU1ByaW1pdGl2ZVZhbHVlKG5ldyBDb3VudGVyKGlkZW50aWZpZXIucmVs ZWFzZSgpLCBsaXN0U3R5bGUucmVsZWFzZSgpLCBzZXBhcmF0b3IucmVsZWFzZSgpKSk7Cit9CisK IGJvb2wgQ1NTUGFyc2VyOjpwYXJzZVNoYXBlKGludCBwcm9wSWQsIGJvb2wgaW1wb3J0YW50KQog ewogICAgIFZhbHVlICp2YWx1ZSA9IHZhbHVlTGlzdC0+Y3VycmVudCgpOwpAQCAtMjcxOSw2ICsy NzkyLDQ4IEBACiAgICAgcmV0dXJuIGNvbnRleHQuZmFpbGVkKCk7CiB9CiAKK2Jvb2wgQ1NTUGFy c2VyOjpwYXJzZUNvdW50ZXIoaW50IHByb3BJZCwgaW50IGRlZmF1bHRWYWx1ZSwgYm9vbCBpbXBv cnRhbnQpCit7CisgICAgZW51bSB7IElELCBWQUwgfSBzdGF0ZSA9IElEOworCisgICAgUmVmUHRy PENTU1ZhbHVlTGlzdD4gbGlzdCA9IG5ldyBDU1NWYWx1ZUxpc3Q7CisgICAgUmVmUHRyPENTU1By aW1pdGl2ZVZhbHVlPiBjb3VudGVyTmFtZTsKKyAgICAKKyAgICB3aGlsZSAodHJ1ZSkgeworICAg ICAgICBWYWx1ZSogdmFsID0gdmFsdWVMaXN0LT5jdXJyZW50KCk7CisgICAgICAgIHN3aXRjaCAo c3RhdGUpIHsKKyAgICAgICAgICAgIGNhc2UgSUQ6CisgICAgICAgICAgICAgICAgaWYgKHZhbCAm JiB2YWwtPnVuaXQgPT0gQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19JREVOVCkgeworICAgICAgICAg ICAgICAgICAgICBjb3VudGVyTmFtZSA9IG5ldyBDU1NQcmltaXRpdmVWYWx1ZShkb21TdHJpbmco dmFsLT5zdHJpbmcpLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX1NUUklORyk7CisgICAgICAgICAg ICAgICAgICAgIHN0YXRlID0gVkFMOworICAgICAgICAgICAgICAgICAgICB2YWx1ZUxpc3QtPm5l eHQoKTsKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2FzZSBWQUw6IHsKKyAgICAgICAg ICAgICAgICBpbnQgaSA9IGRlZmF1bHRWYWx1ZTsKKyAgICAgICAgICAgICAgICBpZiAodmFsICYm IHZhbC0+dW5pdCA9PSBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX05VTUJFUikgeworICAgICAgICAg ICAgICAgICAgICBpID0gKGludCl2YWwtPmZWYWx1ZTsKKyAgICAgICAgICAgICAgICAgICAgdmFs dWVMaXN0LT5uZXh0KCk7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAgbGlz dC0+YXBwZW5kKG5ldyBDU1NQcmltaXRpdmVWYWx1ZShuZXcgUGFpcihjb3VudGVyTmFtZS5yZWxl YXNlKCksCisgICAgICAgICAgICAgICAgICAgIG5ldyBDU1NQcmltaXRpdmVWYWx1ZShpLCBDU1NQ cmltaXRpdmVWYWx1ZTo6Q1NTX05VTUJFUikpKSk7CisgICAgICAgICAgICAgICAgc3RhdGUgPSBJ RDsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQor ICAgICAgICBicmVhazsKKyAgICB9CisgICAgCisgICAgaWYgKGxpc3QtPmxlbmd0aCgpID4gMCkg eworICAgICAgICBhZGRQcm9wZXJ0eShwcm9wSWQsIGxpc3QucmVsZWFzZSgpLCBpbXBvcnRhbnQp OworICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisK ICNpZmRlZiBDU1NfREVCVUcKIAogc3RhdGljIGlubGluZSBpbnQgeXllcnJvcihjb25zdCBjaGFy ICpzdHIpCg==