45059 2010-09-01 13:44:32 -0700 Add red-black tree capable of holding plain old data (POD) 2010-09-03 00:00:24 -0700 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 44729 45060 45160 1 kbr kbr abarth cmarrin eric fishd jorlow sam simon.fraser webkit.review.bot oldest_to_newest 272983 0 kbr 2010-09-01 13:44:32 -0700 A red-black tree capable of holding plain old data (POD) is needed in support of some graphics algorithms currently being integrated. The implementation uses an arena (built using Arena.h) which is being added at the same time. 272999 1 66264 kbr 2010-09-01 14:01:49 -0700 Created attachment 66264 Patch From the ChangeLog: Adding a red-black tree capable of holding Plain Old Data (POD) and an associated PODArena which is built on Arena.h. Note that the PODArena will be used by other classes to allocate temporary structures, which is why it is not just an implementation detail of the red-black tree. To address earlier review feedback, PODArena and PODRedBlackTree can not currently be placed in WTF because Arena.h is in WebCore/platform. Unit tests for the PODRedBlackTree will be integrated separately under bug 45060. 273011 2 66269 kbr 2010-09-01 14:15:24 -0700 Created attachment 66269 Revised patch Addressed a couple of missed portions of abarth's earlier review feedback. 273097 3 66269 cmarrin 2010-09-01 16:22:22 -0700 Comment on attachment 66269 Revised patch > Index: WebCore/platform/PODArena.h > =================================================================== > --- WebCore/platform/PODArena.h (revision 0) > +++ WebCore/platform/PODArena.h (revision 0) > ... > +private: > + enum { > + DefaultArenaSize = 16384 This seems like an odd default, not necessarily appropriate for all uses of this type. Also you don't allow a size to be passed into PODArena, so this isn't a "default", it's the only allowable size. I'm not even sure there is a default size that would be appropriate for "most things". It would be better to just add a size parameter to the ctor and not have a default at all. > + }; > + > + PODArena() > + { > + // Initialize the arena pool > + INIT_ARENA_POOL(&m_pool, "PODArena", DefaultArenaSize); > + } > + > + // Underlying arena pool > + ArenaPool m_pool; > +}; > + > +} // namespace WebCore > + > +#endif // PODArena_h > Index: WebCore/platform/PODRedBlackTree.h > =================================================================== > --- WebCore/platform/PODRedBlackTree.h (revision 0) > +++ WebCore/platform/PODRedBlackTree.h (revision 0) > @@ -0,0 +1,755 @@ > ... > +// > +// The data type T that is stored in this red-black tree must be only > +// Plain Old Data (POD), or bottom out into POD. It must _not_ rely on > +// having its destructor called. This implementation internally > +// allocates storage in large chunks and does not call the destructor > +// on each object. > +// > +// Type T must supply a default constructor, a copy constructor, and > +// the "<" and "==" operators. If T is always a POD, isn't the above rule true of all PODs? And if the only issue is that you're not calling the dtor, why not just add the logic to call the dtor? Is it complex? > +// > +// In debug mode, printing of the data contained in the tree is > +// enabled. This requires the following function to be available: > +// > +// String valueToString(const T&); > +// > +// Note that when complex types are stored in this red/black tree, it > +// is possible that single invocations of the "<" and "==" operators > +// will be insufficient to describe the ordering of elements in the > +// tree during queries. As a concrete example, consider the case where > +// intervals are stored in the tree sorted by low endpoint. The "<" > +// operator on the Interval class only compares the low endpoint, but > +// the "==" operator takes into account the high endpoint as well. > +// This makes the necessary logic for querying and deletion somewhat > +// more complex. In order to properly handle such situations, the > +// property "needsFullOrderingComparisons" must be set to true on > +// the tree. But I thought this class only handles POD types. Why the info about complex types? > +// > +// This red-black tree is designed to be _augmented_; subclasses can > +// add additional and summary information to each node to efficiently > +// store and index more complex data structures. A concrete example is > +// the IntervalTree, which extends each node with a summary statistic > +// to efficiently store one-dimensional intervals. > +// > +// The design of this red-black tree comes from Cormen, Leiserson, > +// and Rivest, _Introduction to Algorithms_, MIT Press, 1990. > + > +#ifndef PODRedBlackTree_h > +#define PODRedBlackTree_h > + > +#ifndef NDEBUG > +#include "Logging.h" > +#include "PlatformString.h" > +#endif > +#include "PODArena.h" > +#ifndef DEBUG > +#include "StringBuilder.h" > +#endif > +#include <wtf/Assertions.h> > +#include <wtf/Noncopyable.h> > +#include <wtf/RefPtr.h> > +#ifndef NDEBUG > +#include <wtf/text/CString.h> > +#endif > + > +namespace WebCore { > + > +template<class T> > +class PODRedBlackTree { > +public: > + // Visitor interface for walking all of the tree's elements. > + class Visitor { > + public: > + virtual void visit(const T& data) = 0; > + protected: > + virtual ~Visitor() { } > + }; > + > + // Constructs a new red-black tree, allocating temporary objects > + // from a newly constructed PODArena. > + PODRedBlackTree() > + : m_arena(PODArena::create()) > + , m_root(0) > + , m_needsFullOrderingComparisons(false) > +#ifndef NDEBUG > + , m_verboseDebugging(false) > +#endif > + { > + } > + > + // Constructs a new red-black tree, allocating temporary objects > + // from the given PODArena. > + explicit PODRedBlackTree(PODArena* arena) > + : m_arena(arena) > + , m_root(0) > + , m_needsFullOrderingComparisons(false) > +#ifndef NDEBUG > + , m_verboseDebugging(false) > +#endif > + { > + } > + > + virtual ~PODRedBlackTree() { } > + > + void insert(const T& data) > + { > + Node* node = new Node(data); > + insertNode(node); > + } > + > + // Removes the given datum from the tree. Returns true if the datum > + // was found in the tree. > + bool remove(const T& data) > + { > + Node* node = treeSearch(data); > + if (node) { > + deleteNode(node); > + return true; > + } > + return false; > + } > + > + bool contains(const T& data) { return treeSearch(data); } > + > + void visitInorder(Visitor* visitor) > + { > + if (!m_root) > + return; > + visitInorderImpl(m_root, visitor); > + } > + > + int numElements() > + { > + Counter counter; > + visitInorder(&counter); > + return counter.count(); > + } You should use the same terminology as HashTable, size() rather than numElements(), add() rather than insert(), > + > + // See the class documentation for an explanation of this property. > + void setNeedsFullOrderingComparisons(bool needsFullOrderingComparisons) > + { > + m_needsFullOrderingComparisons = needsFullOrderingComparisons; > + } > + > + virtual bool checkInvariants() > + { > + int blackCount; > + return checkInvariantsFromNode(m_root, &blackCount); > + } > + > +#ifndef NDEBUG > + // Dumps the tree's contents to the logging info stream for > + // debugging purposes. > + void dump() > + { > + dumpFromNode(m_root, 0); > + } > + > + // Turns on or off verbose debugging of the tree, causing many > + // messages to be logged during insertion and other operations in > + // debug mode. > + void setVerboseDebugging(bool onOrOff) > + { > + m_verboseDebugging = onOrOff; > + } > +#endif > + > +protected: > + enum Color { > + kRed = 1, > + kBlack > + }; > + > + // The base Node class which is stored in the tree. Nodes are only > + // an internal concept; users of the tree deal only with the data > + // they store in it. > + class Node : public Noncopyable { > + public: > + // Constructor. Newly-created nodes are colored red. > + explicit Node(const T& data) > + : m_left(0) > + , m_right(0) > + , m_parent(0) > + , m_color(kRed) > + , m_data(data) > + { > + } > + > + virtual ~Node() { } > + > + Color color() const { return m_color; } > + void setColor(Color color) { m_color = color; } > + > + // Fetches the user data. > + T& data() { return m_data; } > + > + // Copies all user-level fields from the source node, but not > + // internal fields. For example, the base implementation of this > + // method copies the "m_data" field, but not the child or parent > + // fields. Any augmentation information also does not need to be > + // copied, as it will be recomputed. Subclasses must call the > + // superclass implementation. > + virtual void copyFrom(Node* src) { m_data = src->data(); } > + > + Node* left() const { return m_left; } > + void setLeft(Node* node) { m_left = node; } > + > + Node* right() const { return m_right; } > + void setRight(Node* node) { m_right = node; } > + > + Node* parent() const { return m_parent; } > + void setParent(Node* node) { m_parent = node; } > + > + private: > + Node* m_left; > + Node* m_right; > + Node* m_parent; > + Color m_color; > + T m_data; > + }; > + > + // Returns the root of the tree, which is needed by some subclasses. > + Node* root() const { return m_root; } > + > +private: > + // This virtual method is the hook that subclasses should use when > + // augmenting the red-black tree with additional per-node summary > + // information. For example, in the case of an interval tree, this > + // is used to compute the maximum endpoint of the subtree below the > + // given node based on the values in the left and right children. It > + // is guaranteed that this will be called in the correct order to > + // properly update such summary information based only on the values > + // in the left and right children. This method should return true if > + // the node's summary information changed. > + virtual bool updateNode(Node* node) { return false; } > + > + //---------------------------------------------------------------------- > + // Generic binary search tree operations > + // > + > + // Searches the tree for the given datum. > + Node* treeSearch(const T& data) > + { > + if (m_needsFullOrderingComparisons) > + return treeSearchFullComparisons(m_root, data); > + > + return treeSearchNormal(m_root, data); > + } > + > + // Searches the tree using the normal comparison operations, > + // suitable for simple data types such as numbers. > + Node* treeSearchNormal(Node* current, const T& data) > + { > + while (current) { > + if (current->data() == data) > + return current; > + if (data < current->data()) > + current = current->left(); > + else > + current = current->right(); > + } > + return 0; > + } > + > + // Searches the tree using multiple comparison operations, required > + // for data types with more complex behavior such as intervals. > + Node* treeSearchFullComparisons(Node* current, const T& data) > + { > + if (!current) > + return 0; > + if (data < current->data()) > + return treeSearchFullComparisons(current->left(), data); > + if (current->data() < data) > + return treeSearchFullComparisons(current->right(), data); > + if (data == current->data()) > + return current; > + > + // We may need to traverse both the left and right subtrees. > + Node* result = treeSearchFullComparisons(current->left(), data); > + if (!result) > + result = treeSearchFullComparisons(current->right(), data); > + return result; > + } > + > + void treeInsert(Node* z) > + { > + Node* y = 0; > + Node* x = m_root; > + while (x) { > + y = x; > + if (z->data() < x->data()) > + x = x->left(); > + else > + x = x->right(); > + } > + z->setParent(y); > + if (!y) > + m_root = z; > + else { > + if (z->data() < y->data()) > + y->setLeft(z); > + else > + y->setRight(z); > + } > + } > + > + // Finds the node following the given one in sequential ordering of > + // their data, or null if none exists. > + Node* treeSuccessor(Node* x) > + { > + if (x->right()) > + return treeMinimum(x->right()); > + Node* y = x->parent(); > + while (y && x == y->right()) { > + x = y; > + y = y->parent(); > + } > + return y; > + } > + > + // Finds the minimum element in the sub-tree rooted at the given > + // node. > + Node* treeMinimum(Node* x) > + { > + while (x->left()) > + x = x->left(); > + return x; > + } > + > + // Helper for maintaining the augmented red-black tree. > + void propagateUpdates(Node* start) > + { > + bool shouldContinue = true; > + while (start && shouldContinue) { > + shouldContinue = updateNode(start); > + start = start->parent(); > + } > + } > + > + //---------------------------------------------------------------------- > + // Red-Black tree operations > + // > + > + // Left-rotates the subtree rooted at x. > + void leftRotate(Node* x) > + { > + // Set y. > + Node* y = x->right(); > + // Turn y's left subtree into x's right subtree. > + x->setRight(y->left()); > + if (y->left()) > + y->left()->setParent(x); > + // Link x's parent to y. > + y->setParent(x->parent()); > + if (!x->parent()) > + m_root = y; > + else { > + if (x == x->parent()->left()) > + x->parent()->setLeft(y); > + else > + x->parent()->setRight(y); > + } > + // Put x on y's left. > + y->setLeft(x); > + x->setParent(y); Blank line before comment would make this more readable, here and other places. Sam has said he thought all this was going into WTF and thinks Arena.h should go there, too. That made me look at Arena.h and I think it is full of cruft and should not even exist. I've started a thread to discuss it on webkit-dev. Let's give that a day to pan out before the next step. 273292 4 jorlow 2010-09-02 03:15:07 -0700 Probably a stupid question: is there any reason why the AVLTree in wtf won't work for what you need? 273402 5 cmarrin 2010-09-02 08:41:14 -0700 (In reply to comment #4) > Probably a stupid question: is there any reason why the AVLTree in wtf won't work for what you need? This comment made me look up comparisons between the two. Interesting info. Here's a Dr Dobbs article that was interesting: http://www.drdobbs.com/184410531 This of course points out that STL uses RB trees. In particular it seems like std::multiset might fit the bill, since it stores its data in an RB tree and can have duplicate values. Looking at the STL implementation on Mac, map, multimap, set and multiset are all based on stl_tree, which is a RB tree implementation. I assume this is true on all platforms. 273454 6 kbr 2010-09-02 11:05:27 -0700 (In reply to comment #4) > Probably a stupid question: is there any reason why the AVLTree in wtf won't work for what you need? An AVL tree could be used, but would need to be modified to support augmenting the data structure. This specifically means allowing the recomputation of summary statistics while rebalancing the tree. This red-black tree has been specifically designed for this purpose, and is why it can so easily be subclassed into an efficient IntervalTree. I'm certainly amenable to merging these data structures, but only after checkpointing an initial working version of this code. 273475 7 kbr 2010-09-02 11:48:43 -0700 (In reply to comment #3) > This seems like an odd default, not necessarily appropriate for all uses of this type. Also you don't allow a size to be passed into PODArena, so this isn't a "default", it's the only allowable size. I'm not even sure there is a default size that would be appropriate for "most things". It would be better to just add a size parameter to the ctor and not have a default at all. The semantics of this enum have changed now that PODArena does not depend on Arena.h any more. It is entirely an implementation detail now. > > +// Type T must supply a default constructor, a copy constructor, and > > +// the "<" and "==" operators. > > If T is always a POD, isn't the above rule true of all PODs? And if the only issue is that you're not calling the dtor, why not just add the logic to call the dtor? Is it complex? T may be a class which bottoms out into only POD; i.e., does not perform dynamic memory allocation requiring its destructor to be called. It is potentially complex to call the destructors properly of the nodes in the tree. I am willing to investigate doing so, which would generalize the tree, but not before an initial checkin of this code. It is complicated and I need a baseline to work against when making changes of this nature. > > +// Note that when complex types are stored in this red/black tree, it > > +// is possible that single invocations of the "<" and "==" operators > > +// will be insufficient to describe the ordering of elements in the > > +// tree during queries. As a concrete example, consider the case where > > +// intervals are stored in the tree sorted by low endpoint. The "<" > > +// operator on the Interval class only compares the low endpoint, but > > +// the "==" operator takes into account the high endpoint as well. > > +// This makes the necessary logic for querying and deletion somewhat > > +// more complex. In order to properly handle such situations, the > > +// property "needsFullOrderingComparisons" must be set to true on > > +// the tree. > > But I thought this class only handles POD types. Why the info about complex types? No, it handles POD or classes bottoming out into POD, such as an Interval whose endpoints are floats. This will become clear in the next patch which augments this PODRedBlackTree into a PODIntervalTree. > You should use the same terminology as HashTable, size() rather than numElements(), add() rather than insert(), Done. > Blank line before comment would make this more readable, here and other places. Done. > Sam has said he thought all this was going into WTF and thinks Arena.h should go there, too. That made me look at Arena.h and I think it is full of cruft and should not even exist. I've started a thread to discuss it on webkit-dev. Let's give that a day to pan out before the next step. Per that discussion I am resubmitting this patch adding these classes into platform/graphics/gpu for the time being. 273481 8 66391 kbr 2010-09-02 11:57:56 -0700 Created attachment 66391 Revised patch Per review comments above and discussion on webkit-dev: - Made PODArena self-contained again rather than relying on Arena.h. - Adding PODArena and PODRedBlackTree into platform/graphics/gpu for the time being. If the red/black tree and forthcoming interval tree are generalized to hold fully arbitrary data types, we can consider moving them. - Changed red-black tree's numElements to size and insert to add. 273538 9 cmarrin 2010-09-02 13:48:22 -0700 (In reply to comment #7) > ... > > > +// Note that when complex types are stored in this red/black tree, it > > > +// is possible that single invocations of the "<" and "==" operators > > > +// will be insufficient to describe the ordering of elements in the > > > +// tree during queries. As a concrete example, consider the case where > > > +// intervals are stored in the tree sorted by low endpoint. The "<" > > > +// operator on the Interval class only compares the low endpoint, but > > > +// the "==" operator takes into account the high endpoint as well. > > > +// This makes the necessary logic for querying and deletion somewhat > > > +// more complex. In order to properly handle such situations, the > > > +// property "needsFullOrderingComparisons" must be set to true on > > > +// the tree. > > > > But I thought this class only handles POD types. Why the info about complex types? > > No, it handles POD or classes bottoming out into POD, such as an Interval whose endpoints are floats. This will become clear in the next patch which augments this PODRedBlackTree into a PODIntervalTree. Then this explanation is confusing. I've always hated the phrase "bottoms out in POD". I think what that means (in your case) is that all the member variables of the class must be POD, so you should say that. It would also be nice if there were some way to ensure so it fails at compile time if you violate this rule. I'm not sure how to go about doing that though. But you should at least make this description more clear about the rules for contained classes. 273557 10 kbr 2010-09-02 13:57:34 -0700 (In reply to comment #9) > Then this explanation is confusing. I've always hated the phrase "bottoms out in POD". I think what that means (in your case) is that all the member variables of the class must be POD, so you should say that. It would also be nice if there were some way to ensure so it fails at compile time if you violate this rule. I'm not sure how to go about doing that though. But you should at least make this description more clear about the rules for contained classes. It doesn't mean that -- the contained class can contain data members of class types. The requirement is that none of those contained classes dynamically allocate memory and therefore require their destructors to be run. I think the comment is pretty clear. Ideally I would also like to enforce this with compile time checking but I don't know how to do that yet. I am interested in investigating how this might be done. However, I need to checkpoint this code first. 273559 11 66391 fishd 2010-09-02 13:58:52 -0700 Comment on attachment 66391 Revised patch View in context: https://bugs.webkit.org/attachment.cgi?id=66391&action=prettypatch > WebCore/platform/graphics/gpu/PODArena.h:41 > +#include <wtf/Vector.h> perhaps you should explicitly include <stdint.h> since you use uint8_t below. > WebCore/platform/graphics/gpu/PODArena.h:56 > + virtual ~Allocator() { } nit: though it may not be that common in WebCore, I find it helpful when destructors on classes that inherit from RefCounted are made protected. To do that you need a friend declaration: friend class WTF::RefCounted<Allocator>; This way no one else can delete the object. Only the RefCounted base class can delete the object. (Ditto for PODArena itself.) > WebCore/platform/graphics/gpu/PODArena.h:84 > + static PassRefPtr<PODArena> create(Allocator* allocator) nit: this should take a PassRefPtr<Allocator> argument > WebCore/platform/graphics/gpu/PODArena.h:90 > + template<class T> nit: on member functions, it seems more common in webkit code to put the template keyword on the same line as the function name: template<class T> T* alloc() nit: perhaps allocateObject would be a better name for this method. > WebCore/platform/graphics/gpu/PODArena.h:141 > + static size_t minAlignment() wtf/Vector.h defines a macro named WTF_ALIGN_OF which can be used to determine the alignment requirements for a type using a compiler specific mechanism. perhaps minAlignment() could be rewritten like so: static size_t minAlignment() { return WTF_ALIGN_OF(T); } > WebCore/platform/graphics/gpu/PODArena.h:153 > + RefPtr<Allocator> m_allocator; nit: i think it is best to put all of the member variables together. so, i would put this member variable below the Chunk definition. > WebCore/platform/graphics/gpu/PODArena.h:200 > + size_t m_currentChunkSize; why have m_currentChunkSize and not just a size() member function on the Chunk class? (if you want to keep m_currentChunkSize, then perhaps it should at least be listed next to m_current since it is so closely related.) > WebCore/platform/graphics/gpu/PODRedBlackTree.h:53 > +// String valueToString(const T&); nit: valueToString should probably be a const method > WebCore/platform/graphics/gpu/PODRedBlackTree.h:79 > +#ifndef NDEBUG nit: I'd just make a separate section below the main set of includes for the debug-only includes. that way there will be fewer #ifndefs. > WebCore/platform/graphics/gpu/PODRedBlackTree.h:121 > + explicit PODRedBlackTree(PODArena* arena) nit: use PassRefPtr<PODArena> here > WebCore/platform/graphics/gpu/PODRedBlackTree.h:150 > + bool contains(const T& data) { return treeSearch(data); } it seems like you could slap a const on contains, visitInorder and size > WebCore/platform/graphics/gpu/PODRedBlackTree.h:189 > + void setVerboseDebugging(bool onOrOff) nit: normally, in webkit a parameter name like this is named like the method, so: void setVerboseDebugging(bool verboseDebugging) > WebCore/platform/graphics/gpu/PODRedBlackTree.h:197 > + kRed = 1, nit: enum values should be named with the "k" prefix > WebCore/platform/graphics/gpu/PODRedBlackTree.h:446 > + LOG_ERROR(" PODRedBlackTree::InsertNode"); why LOG_ERROR? wouldn't LOG(PODRedBlackTree, "InsertNode") be better? you can see an example of using LOG this way in RefCountedLeakCounter.cpp also how about writing an inline helper function that can have an empty implementation in NDEBUG builds but otherwise call LOG(...). that way the code in this function will not need #ifdefs. > WebCore/platform/graphics/gpu/PODRedBlackTree.h:688 > + Counter() nit: no line break here > WebCore/platform/graphics/gpu/PODRedBlackTree.h:750 > + LOG_ERROR("%s", builder.toString().ascii().data()); ditto about using LOG instead I know there was some discussion before about the use of x, y, z, and w variable names, but I didn't find them to be a problem. I'm not sure that calling them "node" or "newNode" or "tempNode" would really help improve readability at all. 273572 12 cmarrin 2010-09-02 14:20:24 -0700 (In reply to comment #10) > (In reply to comment #9) > > Then this explanation is confusing. I've always hated the phrase "bottoms out in POD". I think what that means (in your case) is that all the member variables of the class must be POD, so you should say that. It would also be nice if there were some way to ensure so it fails at compile time if you violate this rule. I'm not sure how to go about doing that though. But you should at least make this description more clear about the rules for contained classes. > > It doesn't mean that -- the contained class can contain data members of class types. The requirement is that none of those contained classes dynamically allocate memory and therefore require their destructors to be run. I think the comment is pretty clear. Sorry, but it's still not clear. There are more reasons to call a destructor than freeing of allocated memory. Any resources that need to be released (I/O ports, threads, sockets, etc.) can require the destructor to be called. Really POD has nothing to do with this constraint. By definition a POD doesn't have a constructor or a destructor. In fact according to http://en.wikipedia.org/wiki/Plain_old_data_structure, a POD class cannot contain a copy constructor, but you are requiring one. You're really just saying that you can use any class as long as it doesn't have a destructor. Since you do intend on making this class fully object aware at some point, it's probably not even a good idea to call this PODRedBlackTree. Just call it RedBlackTree and note the current restriction. 273587 13 fishd 2010-09-02 14:51:35 -0700 (In reply to comment #12) > Since you do intend on making this class fully object aware at some point, it's probably not even a good idea to call this PODRedBlackTree. Just call it RedBlackTree and note the current restriction. I'm not sure why we need to generalize this class to handle types with destructors. It seems like premature optimization to write code that has no intended consumer. I suggested to Ken that he add the POD prefix to these types instead of using the gpu:: namespace (to avoid collision with platform/Arena.h). So you can blame me for the strictly incorrect name. While it is true that requiring a copy-constructor means that the types used with these data structures would not be strictly POD, the POD prefix does help convey the fact that destructors will not be called. We could avoid the operators and the copy constructors by using a Traits template class. Then, the types could be strictly POD, and we could keep the POD* naming convention. Or, we could come up with a different naming convention. Anyways, one thing seems clear to me: It is nice to not have to keep track of individual allocations in the arena. That simplifies the code. Let's find a way to preserve that simplification since it meets are requirements today. Perhaps by renaming the classes or by using the Traits solution that I mentioned above. 273594 14 cmarrin 2010-09-02 15:00:36 -0700 (In reply to comment #13) > (In reply to comment #12) > > Since you do intend on making this class fully object aware at some point, it's probably not even a good idea to call this PODRedBlackTree. Just call it RedBlackTree and note the current restriction. > > I'm not sure why we need to generalize this class to handle types with destructors. It seems like premature optimization to write code that has no intended consumer. Sure, if this is always going to be an purpose written class then I think it's fine to be "incomplete" (not in a judgmental way, but in a C++ strictness way). > > I suggested to Ken that he add the POD prefix to these types instead of using the gpu:: namespace (to avoid collision with platform/Arena.h). So you can blame me for the strictly incorrect name. While it is true that requiring a copy-constructor means that the types used with these data structures would not be strictly POD, the POD prefix does help convey the fact that destructors will not be called. > > We could avoid the operators and the copy constructors by using a Traits template class. Then, the types could be strictly POD, and we could keep the POD* naming convention. Or, we could come up with a different naming convention. I think Traits would add complexity without much benefit over simply accepting the contract that classes can't require a dtor. It would be awfully nice if we could come up a way to generate a compile time error to keep future users from stepping into the briar patch. > > Anyways, one thing seems clear to me: It is nice to not have to keep track of individual allocations in the arena. That simplifies the code. Let's find a way to preserve that simplification since it meets are requirements today. Perhaps by renaming the classes or by using the Traits solution that I mentioned above. I think just renaming it would be fine. I have no problem simply calling it RedBlackTree as long as there is a clear warning about how (not) to use it. 273602 15 kbr 2010-09-02 15:13:53 -0700 (In reply to comment #14) > I think just renaming it would be fine. I have no problem simply calling it RedBlackTree as long as there is a clear warning about how (not) to use it. After reading the definition of POD, you're right, I'm misusing the term. We thought here about a different naming convention but weren't able to come up with one ("Simple", ...). I do not want to name it simply RedBlackTree while it has its current restrictions. I would like to land PODArena, PODRedBlackTree and the forthcoming PODIntervalTree with these names for now, because they are nicely grouped with the prefix. 273616 16 66421 kbr 2010-09-02 15:30:00 -0700 Created attachment 66421 Revised patch Addressed review feedback from fishd: - include stdint.h. - Made destructors protected and WTF::RefCounted<T> a friend. - Renamed alloc to allocateObject. - Used WTF_ALIGN_OF in minAlignment. - Added const to all conceptually const methods. - Grouped NDEBUG includes. - Renamed kRed and kBlack. - Added helper function for LOG_ERROR with m_verboseDebugging on. 273617 17 cmarrin 2010-09-02 15:32:05 -0700 (In reply to comment #15) > (In reply to comment #14) > > I think just renaming it would be fine. I have no problem simply calling it RedBlackTree as long as there is a clear warning about how (not) to use it. > > After reading the definition of POD, you're right, I'm misusing the term. We thought here about a different naming convention but weren't able to come up with one ("Simple", ...). > > I do not want to name it simply RedBlackTree while it has its current restrictions. > > I would like to land PODArena, PODRedBlackTree and the forthcoming PODIntervalTree with these names for now, because they are nicely grouped with the prefix. I think that's a mistake. Of all the many things a POD is, this class only adheres to one, no dtor. If nothing else you should give these classes a prefix that says "these are for the accelerated 2D renderer, everyone else stay away". It's better to use a meaningless prefix, or no prefix at all, than one that has a specific but wrong meaning. 273621 18 kbr 2010-09-02 15:38:05 -0700 (In reply to comment #11) > (From update of attachment 66391 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=66391&action=prettypatch > > > WebCore/platform/graphics/gpu/PODArena.h:41 > > +#include <wtf/Vector.h> > perhaps you should explicitly include <stdint.h> since you use uint8_t below. Done. > > WebCore/platform/graphics/gpu/PODArena.h:56 > > + virtual ~Allocator() { } > nit: though it may not be that common in WebCore, I find it helpful > when destructors on classes that inherit from RefCounted are made > protected. To do that you need a friend declaration: > > friend class WTF::RefCounted<Allocator>; > > This way no one else can delete the object. Only the RefCounted > base class can delete the object. > > (Ditto for PODArena itself.) Done. > > WebCore/platform/graphics/gpu/PODArena.h:84 > > + static PassRefPtr<PODArena> create(Allocator* allocator) > nit: this should take a PassRefPtr<Allocator> argument I don't think so according to http://webkit.org/coding/RefPtr.html under "Function arguments". Ownership isn't being transferred to the PODArena; it merely increments the reference count of the Allocator. > > WebCore/platform/graphics/gpu/PODArena.h:90 > > + template<class T> > nit: on member functions, it seems more common in webkit code to > put the template keyword on the same line as the function name: > > template<class T> T* alloc() > > nit: perhaps allocateObject would be a better name for this method. Done. > > WebCore/platform/graphics/gpu/PODArena.h:141 > > + static size_t minAlignment() > wtf/Vector.h defines a macro named WTF_ALIGN_OF which can be used to > determine the alignment requirements for a type using a compiler > specific mechanism. > > perhaps minAlignment() could be rewritten like so: > > static size_t minAlignment() > { > return WTF_ALIGN_OF(T); > } Done. > > WebCore/platform/graphics/gpu/PODArena.h:153 > > + RefPtr<Allocator> m_allocator; > nit: i think it is best to put all of the member variables together. > so, i would put this member variable below the Chunk definition. Done. > > WebCore/platform/graphics/gpu/PODArena.h:200 > > + size_t m_currentChunkSize; > why have m_currentChunkSize and not just a size() member function > on the Chunk class? (if you want to keep m_currentChunkSize, then > perhaps it should at least be listed next to m_current since it is > so closely related.) Because initially there is no Chunk, but we need to know what size it should be allocated with. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:53 > > +// String valueToString(const T&); > nit: valueToString should probably be a const method It isn't a method but a function visible at the global scope. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:79 > > +#ifndef NDEBUG > nit: I'd just make a separate section below the main set of includes > for the debug-only includes. that way there will be fewer #ifndefs. I didn't think this would pass check-webkit-style, but it does. Done. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:121 > > + explicit PODRedBlackTree(PODArena* arena) > nit: use PassRefPtr<PODArena> here See above. I think this is supposed to be a raw pointer. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:150 > > + bool contains(const T& data) { return treeSearch(data); } > it seems like you could slap a const on contains, visitInorder and size Made these and some other functions const correct. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:189 > > + void setVerboseDebugging(bool onOrOff) > nit: normally, in webkit a parameter name like this is named like the > method, so: void setVerboseDebugging(bool verboseDebugging) Done. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:197 > > + kRed = 1, > nit: enum values should be named with the "k" prefix s/should be/should not be. Done. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:446 > > + LOG_ERROR(" PODRedBlackTree::InsertNode"); > why LOG_ERROR? wouldn't LOG(PODRedBlackTree, "InsertNode") be better? > you can see an example of using LOG this way in RefCountedLeakCounter.cpp Currently there's no .cpp associated with this class and so no good place to put the WTFLogChannel. I don't think it's worth adding a lot of mechanism just for this debugging output. > also how about writing an inline helper function that can have an empty > implementation in NDEBUG builds but otherwise call LOG(...). that way > the code in this function will not need #ifdefs. Done with logIfVerbose. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:688 > > + Counter() > nit: no line break here All of the other code I've seen where the constructor is single-line breaks at the colon. > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:750 > > + LOG_ERROR("%s", builder.toString().ascii().data()); > ditto about using LOG instead I left this alone per above. > I know there was some discussion before about the use of x, y, z, and > w variable names, but I didn't find them to be a problem. I'm not sure > that calling them "node" or "newNode" or "tempNode" would really help > improve readability at all. OK. 273623 19 kbr 2010-09-02 15:40:39 -0700 (In reply to comment #17) > (In reply to comment #15) > > (In reply to comment #14) > > > I think just renaming it would be fine. I have no problem simply calling it RedBlackTree as long as there is a clear warning about how (not) to use it. > > > > After reading the definition of POD, you're right, I'm misusing the term. We thought here about a different naming convention but weren't able to come up with one ("Simple", ...). > > > > I do not want to name it simply RedBlackTree while it has its current restrictions. > > > > I would like to land PODArena, PODRedBlackTree and the forthcoming PODIntervalTree with these names for now, because they are nicely grouped with the prefix. > > I think that's a mistake. Of all the many things a POD is, this class only adheres to one, no dtor. If nothing else you should give these classes a prefix that says "these are for the accelerated 2D renderer, everyone else stay away". It's better to use a meaningless prefix, or no prefix at all, than one that has a specific but wrong meaning. I don't have a good idea right now for another prefix. If you do, please suggest one, but I'm going to aim to land these classes in their current form. We can svn rename them later, but continual renamings in my own workspaces are making it difficult to land this and subsequent patches. 273636 20 fishd 2010-09-02 15:52:53 -0700 (In reply to comment #18) > > > WebCore/platform/graphics/gpu/PODArena.h:84 > > > + static PassRefPtr<PODArena> create(Allocator* allocator) > > nit: this should take a PassRefPtr<Allocator> argument > > I don't think so according to http://webkit.org/coding/RefPtr.html under "Function arguments". Ownership isn't being transferred to the PODArena; it merely increments the reference count of the Allocator. Because you are storing the pointer into a RefPtr, you are technically giving ownership of the argument to the PODArena. (The ownership is shared.) > > > WebCore/platform/graphics/gpu/PODArena.h:200 > > > + size_t m_currentChunkSize; > > why have m_currentChunkSize and not just a size() member function > > on the Chunk class? (if you want to keep m_currentChunkSize, then > > perhaps it should at least be listed next to m_current since it is > > so closely related.) > > Because initially there is no Chunk, but we need to know what size it should be allocated with. Makes sense. > > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:53 > > > +// String valueToString(const T&); > > nit: valueToString should probably be a const method > > It isn't a method but a function visible at the global scope. Ah, right. > > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:121 > > > + explicit PODRedBlackTree(PODArena* arena) > > nit: use PassRefPtr<PODArena> here > > See above. I think this is supposed to be a raw pointer. Ditto. > > > WebCore/platform/graphics/gpu/PODRedBlackTree.h:446 > > > + LOG_ERROR(" PODRedBlackTree::InsertNode"); > > why LOG_ERROR? wouldn't LOG(PODRedBlackTree, "InsertNode") be better? > > you can see an example of using LOG this way in RefCountedLeakCounter.cpp > > Currently there's no .cpp associated with this class and so no good place to put the WTFLogChannel. I don't think it's worth adding a lot of mechanism just for this debugging output. OK > > also how about writing an inline helper function that can have an empty > > implementation in NDEBUG builds but otherwise call LOG(...). that way > > the code in this function will not need #ifdefs. > > Done with logIfVerbose. Thanks. 273641 21 66425 kbr 2010-09-02 16:01:04 -0700 Created attachment 66425 Revised patch Fixed RefCounted arguments to PODArena and PODRedBlackTree's constructors and creation functions to use PassRefPtr. 273642 22 kbr 2010-09-02 16:01:28 -0700 (In reply to comment #20) > (In reply to comment #18) > > > > WebCore/platform/graphics/gpu/PODArena.h:84 > > > > + static PassRefPtr<PODArena> create(Allocator* allocator) > > > nit: this should take a PassRefPtr<Allocator> argument > > > > I don't think so according to http://webkit.org/coding/RefPtr.html under "Function arguments". Ownership isn't being transferred to the PODArena; it merely increments the reference count of the Allocator. > > Because you are storing the pointer into a RefPtr, you are technically giving ownership of the argument to the PODArena. (The ownership is shared.) I see. Revised patch posted. 273671 23 66425 fishd 2010-09-02 16:53:38 -0700 Comment on attachment 66425 Revised patch R=me modulo the naming discussion. I think it is reasonable to land this code as-is to check point it. Any renaming patch that we settle on will be trivial to handle as a follow-up patch. 273672 24 fishd 2010-09-02 16:56:14 -0700 Just for completeness, if we were to rename PODRedBlackTree to RedBlackTree as Chris suggested, then it would mean renaming PODArena to something other than Arena. One idea I had for that is to call this class ObjectArena since it is designed to vend objects of type T. I am still a bit concerned about having no prefix given the destructors-are-not-called constraint. Another idea is to call these LeakyArena and LeakyRedBlackTree ;-) 273715 25 cmarrin 2010-09-02 18:24:46 -0700 (In reply to comment #24) > Just for completeness, if we were to rename PODRedBlackTree to RedBlackTree as Chris suggested, then it would mean renaming PODArena to something other than Arena. One idea I had for that is to call this class ObjectArena since it is designed to vend objects of type T. I am still a bit concerned about having no prefix given the destructors-are-not-called constraint. Another idea is to call these LeakyArena and LeakyRedBlackTree ;-) Seems like the Arena could pretty easily be made to ensure dtors get called 273736 26 kbr 2010-09-02 19:11:00 -0700 Committed r66704: <http://trac.webkit.org/changeset/66704> 273737 27 kbr 2010-09-02 19:17:07 -0700 (In reply to comment #25) > (In reply to comment #24) > > Just for completeness, if we were to rename PODRedBlackTree to RedBlackTree as Chris suggested, then it would mean renaming PODArena to something other than Arena. One idea I had for that is to call this class ObjectArena since it is designed to vend objects of type T. I am still a bit concerned about having no prefix given the destructors-are-not-called constraint. Another idea is to call these LeakyArena and LeakyRedBlackTree ;-) > > Seems like the Arena could pretty easily be made to ensure dtors get called I don't think that is easily possible, but it may turn out to be easy to make the red/black tree and forthcoming interval tree properly call destructors on the data they contain, thereby generalizing them. We can discuss this more after all of the initial code is checkpointed. 273810 28 webkit.review.bot 2010-09-03 00:00:24 -0700 http://trac.webkit.org/changeset/66704 might have broken Leopard Intel Debug (Tests) The following changes are on the blame list: http://trac.webkit.org/changeset/66704 http://trac.webkit.org/changeset/66705 66264 2010-09-01 14:01:49 -0700 2010-09-01 14:15:24 -0700 Patch red-black-tree.patch text/plain 32507 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjYxNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNzMgQEAKKzIwMTAtMDktMDEgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCByZWQtYmxhY2sgdHJlZSBjYXBhYmxlIG9mIGhvbGRpbmcgcGxhaW4gb2xkIGRhdGEgKFBPRCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1MDU5CisK KyAgICAgICAgQWRkaW5nIGEgcmVkLWJsYWNrIHRyZWUgY2FwYWJsZSBvZiBob2xkaW5nIFBsYWlu IE9sZCBEYXRhIChQT0QpCisgICAgICAgIGFuZCBhbiBhc3NvY2lhdGVkIFBPREFyZW5hIHdoaWNo IGlzIGJ1aWx0IG9uIEFyZW5hLmguIE5vdGUgdGhhdAorICAgICAgICB0aGUgUE9EQXJlbmEgd2ls bCBiZSB1c2VkIGJ5IG90aGVyIGNsYXNzZXMgdG8gYWxsb2NhdGUgdGVtcG9yYXJ5CisgICAgICAg IHN0cnVjdHVyZXMsIHdoaWNoIGlzIHdoeSBpdCBpcyBub3QganVzdCBhbiBpbXBsZW1lbnRhdGlv biBkZXRhaWwKKyAgICAgICAgb2YgdGhlIHJlZC1ibGFjayB0cmVlLgorCisgICAgICAgIFRvIGFk ZHJlc3MgZWFybGllciByZXZpZXcgZmVlZGJhY2ssIFBPREFyZW5hIGFuZCBQT0RSZWRCbGFja1Ry ZWUKKyAgICAgICAgY2FuIG5vdCBjdXJyZW50bHkgYmUgcGxhY2VkIGluIFdURiBiZWNhdXNlIEFy ZW5hLmggaXMgaW4KKyAgICAgICAgV2ViQ29yZS9wbGF0Zm9ybS4KKworICAgICAgICBVbml0IHRl c3RzIGZvciB0aGUgUE9EUmVkQmxhY2tUcmVlIHdpbGwgYmUgaW50ZWdyYXRlZCBzZXBhcmF0ZWx5 CisgICAgICAgIHVuZGVyIGJ1ZyA0NTA2MC4KKworICAgICAgICAqIHBsYXRmb3JtL1BPREFyZW5h Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OmNyZWF0ZSk6CisgICAgICAg IChXZWJDb3JlOjpQT0RBcmVuYTo6YWxsb2MpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6 OlBPREFyZW5hKToKKyAgICAgICAgKiBwbGF0Zm9ybS9QT0RSZWRCbGFja1RyZWUuaDogQWRkZWQu CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OlZpc2l0b3I6On5WaXNpdG9yKToK KyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6UE9EUmVkQmxhY2tUcmVlKToKKyAg ICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6flBPRFJlZEJsYWNrVHJlZSk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Omluc2VydCk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFj a1RyZWU6OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dmlz aXRJbm9yZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bnVtRWxlbWVu dHMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpzZXROZWVkc0Z1bGxPcmRl cmluZ0NvbXBhcmlzb25zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Y2hl Y2tJbnZhcmlhbnRzKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6ZHVtcCk6 CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnNldFZlcmJvc2VEZWJ1Z2dpbmcp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpOb2RlKToKKyAgICAg ICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6fk5vZGUpOgorICAgICAgICAoV2Vi Q29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpjb2xvcik6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNldENvbG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJl ZEJsYWNrVHJlZTo6Tm9kZTo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6Ok5vZGU6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6 Tm9kZTo6bGVmdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNl dExlZnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpyaWdodCk6 CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNldFJpZ2h0KToKKyAg ICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6cGFyZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0UGFyZW50KToKKyAgICAgICAgKFdl YkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cm9vdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRC bGFja1RyZWU6OnVwZGF0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVl Ojp0cmVlU2VhcmNoKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZVNl YXJjaE5vcm1hbCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnRyZWVTZWFy Y2hGdWxsQ29tcGFyaXNvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0 cmVlSW5zZXJ0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZVN1Y2Nl c3Nvcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnRyZWVNaW5pbXVtKToK KyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cHJvcGFnYXRlVXBkYXRlcyk6Cisg ICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmxlZnRSb3RhdGUpOgorICAgICAgICAo V2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyaWdodFJvdGF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6Omluc2VydE5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVk QmxhY2tUcmVlOjpkZWxldGVGaXh1cCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OmRlbGV0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp2aXNp dElub3JkZXJJbXBsKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291bnRl cjo6Q291bnRlcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OkNvdW50ZXI6 OnZpc2l0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291bnRlcjo6Y291 bnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpjaGVja0ludmFyaWFudHNG cm9tTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmR1bXBGcm9tTm9k ZSk6CisKIDIwMTAtMDktMDEgIFJvYiBCdWlzICA8cndsYnVpc0BnbWFpbC5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL1BPREFy ZW5hLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9QT0RBcmVuYS5oCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9QT0RBcmVuYS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDg0IEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgUE9EQXJlbmFfaAorI2RlZmluZSBQT0RBcmVuYV9oCisKKyNpbmNs dWRlICJBcmVuYS5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3Rm L1JlZkNvdW50ZWQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBBbiBhcmVuYSB3aGlj aCBhbGxvY2F0ZXMgb25seSBQbGFpbiBPbGQgRGF0YSAoUE9EKSwgb3IgY2xhc3NlcyBhbmQKKy8v IHN0cnVjdHMgYm90dG9taW5nIG91dCBpbiBQbGFpbiBPbGQgRGF0YS4gTk9URTogdGhlIGNvbnN0 cnVjdG9ycyBvZgorLy8gdGhlIG9iamVjdHMgYWxsb2NhdGVkIGluIHRoaXMgYXJlbmEgYXJlIGNh bGxlZCwgYnV0IF9ub3RfIHRoZWlyCisvLyBkZXN0cnVjdG9ycy4KKworY2xhc3MgUE9EQXJlbmEg OiBwdWJsaWMgUmVmQ291bnRlZDxQT0RBcmVuYT4geworcHVibGljOgorICAgIC8vIENyZWF0ZXMg YSBuZXcgUE9EQXJlbmEuCisgICAgc3RhdGljIFBhc3NSZWZQdHI8UE9EQXJlbmE+IGNyZWF0ZSgp CisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFBPREFyZW5hKTsKKyAgICB9CisK KyAgICAvLyBBbGxvY2F0ZXMgYW4gb2JqZWN0IGZyb20gdGhlIGFyZW5hLgorICAgIHRlbXBsYXRl PGNsYXNzIFQ+CisgICAgVCogYWxsb2MoKQorICAgIHsKKyAgICAgICAgdm9pZCogcHRyID0gMDsK KyAgICAgICAgQVJFTkFfQUxMT0NBVEUocHRyLCAmbV9wb29sLCBzaXplb2YoVCkpOworICAgICAg ICBpZiAocHRyKSB7CisgICAgICAgICAgICAvLyBVc2UgcGxhY2VtZW50IG9wZXJhdG9yIG5ldyB0 byBhbGxvY2F0ZSBhIFQgYXQgdGhpcyBsb2NhdGlvbgorICAgICAgICAgICAgbmV3KHB0cikgVCgp OworICAgICAgICB9CisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxUKj4ocHRyKTsKKyAgICB9 CisKK3ByaXZhdGU6CisgICAgZW51bSB7CisgICAgICAgIERlZmF1bHRBcmVuYVNpemUgPSAxNjM4 NAorICAgIH07CisKKyAgICBQT0RBcmVuYSgpCisgICAgeworICAgICAgICAvLyBJbml0aWFsaXpl IHRoZSBhcmVuYSBwb29sCisgICAgICAgIElOSVRfQVJFTkFfUE9PTCgmbV9wb29sLCAiUE9EQXJl bmEiLCBEZWZhdWx0QXJlbmFTaXplKTsKKyAgICB9CisKKyAgICAvLyBVbmRlcmx5aW5nIGFyZW5h IHBvb2wKKyAgICBBcmVuYVBvb2wgbV9wb29sOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gUE9EQXJlbmFfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9QT0RSZWRC bGFja1RyZWUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL1BPRFJlZEJsYWNrVHJl ZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9QT0RSZWRCbGFja1RyZWUuaAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw3NTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29v Z2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gQSByZWQtYmxhY2sgdHJlZSwgd2hpY2gg aXMgYSBmb3JtIG9mIGEgYmFsYW5jZWQgYmluYXJ5IHRyZWUuIEl0CisvLyBzdXBwb3J0cyBlZmZp Y2llbnQgaW5zZXJ0aW9uLCBkZWxldGlvbiBhbmQgcXVlcmllcyBvZiBjb21wYXJhYmxlCisvLyBl bGVtZW50cy4gVGhlIHNhbWUgZWxlbWVudCBtYXkgYmUgaW5zZXJ0ZWQgbXVsdGlwbGUgdGltZXMu IFRoZQorLy8gYWxnb3JpdGhtaWMgY29tcGxleGl0eSBvZiBjb21tb24gb3BlcmF0aW9ucyBpczoK Ky8vCisvLyAgIEluc2VydGlvbjogTyhsZyhuKSkKKy8vICAgRGVsZXRpb246ICBPKGxnKG4pKQor Ly8gICBRdWVyeWluZzogIE8obGcobikpCisvLworLy8gVGhlIGRhdGEgdHlwZSBUIHRoYXQgaXMg c3RvcmVkIGluIHRoaXMgcmVkLWJsYWNrIHRyZWUgbXVzdCBiZSBvbmx5CisvLyBQbGFpbiBPbGQg RGF0YSAoUE9EKSwgb3IgYm90dG9tIG91dCBpbnRvIFBPRC4gSXQgbXVzdCBfbm90XyByZWx5IG9u CisvLyBoYXZpbmcgaXRzIGRlc3RydWN0b3IgY2FsbGVkLiBUaGlzIGltcGxlbWVudGF0aW9uIGlu dGVybmFsbHkKKy8vIGFsbG9jYXRlcyBzdG9yYWdlIGluIGxhcmdlIGNodW5rcyBhbmQgZG9lcyBu b3QgY2FsbCB0aGUgZGVzdHJ1Y3RvcgorLy8gb24gZWFjaCBvYmplY3QuCisvLworLy8gVHlwZSBU IG11c3Qgc3VwcGx5IGEgZGVmYXVsdCBjb25zdHJ1Y3RvciwgYSBjb3B5IGNvbnN0cnVjdG9yLCBh bmQKKy8vIHRoZSAiPCIgYW5kICI9PSIgb3BlcmF0b3JzLgorLy8KKy8vIEluIGRlYnVnIG1vZGUs IHByaW50aW5nIG9mIHRoZSBkYXRhIGNvbnRhaW5lZCBpbiB0aGUgdHJlZSBpcworLy8gZW5hYmxl ZC4gVGhpcyByZXF1aXJlcyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRvIGJlIGF2YWlsYWJsZToK Ky8vCisvLyAgIFN0cmluZyB2YWx1ZVRvU3RyaW5nKGNvbnN0IFQmKTsKKy8vCisvLyBOb3RlIHRo YXQgd2hlbiBjb21wbGV4IHR5cGVzIGFyZSBzdG9yZWQgaW4gdGhpcyByZWQvYmxhY2sgdHJlZSwg aXQKKy8vIGlzIHBvc3NpYmxlIHRoYXQgc2luZ2xlIGludm9jYXRpb25zIG9mIHRoZSAiPCIgYW5k ICI9PSIgb3BlcmF0b3JzCisvLyB3aWxsIGJlIGluc3VmZmljaWVudCB0byBkZXNjcmliZSB0aGUg b3JkZXJpbmcgb2YgZWxlbWVudHMgaW4gdGhlCisvLyB0cmVlIGR1cmluZyBxdWVyaWVzLiBBcyBh IGNvbmNyZXRlIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBjYXNlIHdoZXJlCisvLyBpbnRlcnZhbHMg YXJlIHN0b3JlZCBpbiB0aGUgdHJlZSBzb3J0ZWQgYnkgbG93IGVuZHBvaW50LiBUaGUgIjwiCisv LyBvcGVyYXRvciBvbiB0aGUgSW50ZXJ2YWwgY2xhc3Mgb25seSBjb21wYXJlcyB0aGUgbG93IGVu ZHBvaW50LCBidXQKKy8vIHRoZSAiPT0iIG9wZXJhdG9yIHRha2VzIGludG8gYWNjb3VudCB0aGUg aGlnaCBlbmRwb2ludCBhcyB3ZWxsLgorLy8gVGhpcyBtYWtlcyB0aGUgbmVjZXNzYXJ5IGxvZ2lj IGZvciBxdWVyeWluZyBhbmQgZGVsZXRpb24gc29tZXdoYXQKKy8vIG1vcmUgY29tcGxleC4gSW4g b3JkZXIgdG8gcHJvcGVybHkgaGFuZGxlIHN1Y2ggc2l0dWF0aW9ucywgdGhlCisvLyBwcm9wZXJ0 eSAibmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyIgbXVzdCBiZSBzZXQgdG8gdHJ1ZSBvbgor Ly8gdGhlIHRyZWUuCisvLworLy8gVGhpcyByZWQtYmxhY2sgdHJlZSBpcyBkZXNpZ25lZCB0byBi ZSBfYXVnbWVudGVkXzsgc3ViY2xhc3NlcyBjYW4KKy8vIGFkZCBhZGRpdGlvbmFsIGFuZCBzdW1t YXJ5IGluZm9ybWF0aW9uIHRvIGVhY2ggbm9kZSB0byBlZmZpY2llbnRseQorLy8gc3RvcmUgYW5k IGluZGV4IG1vcmUgY29tcGxleCBkYXRhIHN0cnVjdHVyZXMuIEEgY29uY3JldGUgZXhhbXBsZSBp cworLy8gdGhlIEludGVydmFsVHJlZSwgd2hpY2ggZXh0ZW5kcyBlYWNoIG5vZGUgd2l0aCBhIHN1 bW1hcnkgc3RhdGlzdGljCisvLyB0byBlZmZpY2llbnRseSBzdG9yZSBvbmUtZGltZW5zaW9uYWwg aW50ZXJ2YWxzLgorLy8KKy8vIFRoZSBkZXNpZ24gb2YgdGhpcyByZWQtYmxhY2sgdHJlZSBjb21l cyBmcm9tIENvcm1lbiwgTGVpc2Vyc29uLAorLy8gYW5kIFJpdmVzdCwgX0ludHJvZHVjdGlvbiB0 byBBbGdvcml0aG1zXywgTUlUIFByZXNzLCAxOTkwLgorCisjaWZuZGVmIFBPRFJlZEJsYWNrVHJl ZV9oCisjZGVmaW5lIFBPRFJlZEJsYWNrVHJlZV9oCisKKyNpZm5kZWYgTkRFQlVHCisjaW5jbHVk ZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjZW5kaWYKKyNpbmNs dWRlICJQT0RBcmVuYS5oIgorI2lmbmRlZiBERUJVRworI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIu aCIKKyNlbmRpZgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL05v bmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2lmbmRlZiBOREVCVUcKKyNp bmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCit0ZW1wbGF0ZTxjbGFzcyBUPgorY2xhc3MgUE9EUmVkQmxhY2tUcmVlIHsKK3B1YmxpYzoK KyAgICAvLyBWaXNpdG9yIGludGVyZmFjZSBmb3Igd2Fsa2luZyBhbGwgb2YgdGhlIHRyZWUncyBl bGVtZW50cy4KKyAgICBjbGFzcyBWaXNpdG9yIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1 YWwgdm9pZCB2aXNpdChjb25zdCBUJiBkYXRhKSA9IDA7CisgICAgcHJvdGVjdGVkOgorICAgICAg ICB2aXJ0dWFsIH5WaXNpdG9yKCkgeyB9CisgICAgfTsKKworICAgIC8vIENvbnN0cnVjdHMgYSBu ZXcgcmVkLWJsYWNrIHRyZWUsIGFsbG9jYXRpbmcgdGVtcG9yYXJ5IG9iamVjdHMKKyAgICAvLyBm cm9tIGEgbmV3bHkgY29uc3RydWN0ZWQgUE9EQXJlbmEuCisgICAgUE9EUmVkQmxhY2tUcmVlKCkK KyAgICAgICAgOiBtX2FyZW5hKFBPREFyZW5hOjpjcmVhdGUoKSkKKyAgICAgICAgLCBtX3Jvb3Qo MCkKKyAgICAgICAgLCBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMoZmFsc2UpCisjaWZu ZGVmIE5ERUJVRworICAgICAgICAsIG1fdmVyYm9zZURlYnVnZ2luZyhmYWxzZSkKKyNlbmRpZgor ICAgIHsKKyAgICB9CisKKyAgICAvLyBDb25zdHJ1Y3RzIGEgbmV3IHJlZC1ibGFjayB0cmVlLCBh bGxvY2F0aW5nIHRlbXBvcmFyeSBvYmplY3RzCisgICAgLy8gZnJvbSB0aGUgZ2l2ZW4gUE9EQXJl bmEuCisgICAgZXhwbGljaXQgUE9EUmVkQmxhY2tUcmVlKFBPREFyZW5hKiBhcmVuYSkKKyAgICAg ICAgOiBtX2FyZW5hKGFyZW5hKQorICAgICAgICAsIG1fcm9vdCgwKQorICAgICAgICAsIG1fbmVl ZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyhmYWxzZSkKKyNpZm5kZWYgTkRFQlVHCisgICAgICAg ICwgbV92ZXJib3NlRGVidWdnaW5nKGZhbHNlKQorI2VuZGlmCisgICAgeworICAgIH0KKworICAg IHZpcnR1YWwgflBPRFJlZEJsYWNrVHJlZSgpCisgICAgeworICAgIH0KKworICAgIHZvaWQgaW5z ZXJ0KGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICBOb2RlKiBub2RlID0gbmV3IE5vZGUo ZGF0YSk7CisgICAgICAgIGluc2VydE5vZGUobm9kZSk7CisgICAgfQorCisgICAgLy8gUmVtb3Zl cyB0aGUgZ2l2ZW4gZGF0dW0gZnJvbSB0aGUgdHJlZS4gUmV0dXJucyB0cnVlIGlmIHRoZSBkYXR1 bQorICAgIC8vIHdhcyBmb3VuZCBpbiB0aGUgdHJlZS4KKyAgICBib29sIHJlbW92ZShjb25zdCBU JiBkYXRhKQorICAgIHsKKyAgICAgICAgTm9kZSogbm9kZSA9IHRyZWVTZWFyY2goZGF0YSk7Cisg ICAgICAgIGlmIChub2RlKSB7CisgICAgICAgICAgICBkZWxldGVOb2RlKG5vZGUpOworICAgICAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAg IH0KKworICAgIGJvb2wgY29udGFpbnMoY29uc3QgVCYgZGF0YSkgeyByZXR1cm4gdHJlZVNlYXJj aChkYXRhKTsgfQorCisgICAgdm9pZCB2aXNpdElub3JkZXIoVmlzaXRvciogdmlzaXRvcikKKyAg ICB7CisgICAgICAgIGlmICghbV9yb290KQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB2 aXNpdElub3JkZXJJbXBsKG1fcm9vdCwgdmlzaXRvcik7CisgICAgfQorCisgICAgaW50IG51bUVs ZW1lbnRzKCkKKyAgICB7CisgICAgICAgIENvdW50ZXIgY291bnRlcjsKKyAgICAgICAgdmlzaXRJ bm9yZGVyKCZjb3VudGVyKTsKKyAgICAgICAgcmV0dXJuIGNvdW50ZXIuY291bnQoKTsKKyAgICB9 CisKKyAgICAvLyBTZWUgdGhlIGNsYXNzIGRvY3VtZW50YXRpb24gZm9yIGFuIGV4cGxhbmF0aW9u IG9mIHRoaXMgcHJvcGVydHkuCisgICAgdm9pZCBzZXROZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlz b25zKGJvb2wgbmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucykKKyAgICB7CisgICAgICAgIG1f bmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyA9IG5lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNv bnM7CisgICAgfQorCisgICAgdmlydHVhbCBib29sIGNoZWNrSW52YXJpYW50cygpCisgICAgewor ICAgICAgICBpbnQgYmxhY2tDb3VudDsKKyAgICAgICAgcmV0dXJuIGNoZWNrSW52YXJpYW50c0Zy b21Ob2RlKG1fcm9vdCwgJmJsYWNrQ291bnQpOworICAgIH0KKworI2lmbmRlZiBOREVCVUcKKyAg ICAvLyBEdW1wcyB0aGUgdHJlZSdzIGNvbnRlbnRzIHRvIHRoZSBsb2dnaW5nIGluZm8gc3RyZWFt IGZvcgorICAgIC8vIGRlYnVnZ2luZyBwdXJwb3Nlcy4KKyAgICB2b2lkIGR1bXAoKQorICAgIHsK KyAgICAgICAgZHVtcEZyb21Ob2RlKG1fcm9vdCwgMCk7CisgICAgfQorCisgICAgLy8gVHVybnMg b24gb3Igb2ZmIHZlcmJvc2UgZGVidWdnaW5nIG9mIHRoZSB0cmVlLCBjYXVzaW5nIG1hbnkKKyAg ICAvLyBtZXNzYWdlcyB0byBiZSBsb2dnZWQgZHVyaW5nIGluc2VydGlvbiBhbmQgb3RoZXIgb3Bl cmF0aW9ucyBpbgorICAgIC8vIGRlYnVnIG1vZGUuCisgICAgdm9pZCBzZXRWZXJib3NlRGVidWdn aW5nKGJvb2wgb25Pck9mZikKKyAgICB7CisgICAgICAgIG1fdmVyYm9zZURlYnVnZ2luZyA9IG9u T3JPZmY7CisgICAgfQorI2VuZGlmCisKK3Byb3RlY3RlZDoKKyAgICBlbnVtIENvbG9yIHsKKyAg ICAgICAga1JlZCA9IDEsCisgICAgICAgIGtCbGFjaworICAgIH07CisKKyAgICAvLyBUaGUgYmFz ZSBOb2RlIGNsYXNzIHdoaWNoIGlzIHN0b3JlZCBpbiB0aGUgdHJlZS4gTm9kZXMgYXJlIG9ubHkK KyAgICAvLyBhbiBpbnRlcm5hbCBjb25jZXB0OyB1c2VycyBvZiB0aGUgdHJlZSBkZWFsIG9ubHkg d2l0aCB0aGUgZGF0YQorICAgIC8vIHRoZXkgc3RvcmUgaW4gaXQuCisgICAgY2xhc3MgTm9kZSA6 IHB1YmxpYyBOb25jb3B5YWJsZSB7CisgICAgcHVibGljOgorICAgICAgICAvLyBDb25zdHJ1Y3Rv ci4gTmV3bHktY3JlYXRlZCBub2RlcyBhcmUgY29sb3JlZCByZWQuCisgICAgICAgIGV4cGxpY2l0 IE5vZGUoY29uc3QgVCYgZGF0YSkKKyAgICAgICAgICAgIDogbV9sZWZ0KDApCisgICAgICAgICAg ICAsIG1fcmlnaHQoMCkKKyAgICAgICAgICAgICwgbV9wYXJlbnQoMCkKKyAgICAgICAgICAgICwg bV9jb2xvcihrUmVkKQorICAgICAgICAgICAgLCBtX2RhdGEoZGF0YSkKKyAgICAgICAgeworICAg ICAgICB9CisKKyAgICAgICAgdmlydHVhbCB+Tm9kZSgpIHsgfQorCisgICAgICAgIENvbG9yIGNv bG9yKCkgY29uc3QgeyByZXR1cm4gbV9jb2xvcjsgfQorICAgICAgICB2b2lkIHNldENvbG9yKENv bG9yIGNvbG9yKSB7IG1fY29sb3IgPSBjb2xvcjsgfQorCisgICAgICAgIC8vIEZldGNoZXMgdGhl IHVzZXIgZGF0YS4KKyAgICAgICAgVCYgZGF0YSgpIHsgcmV0dXJuIG1fZGF0YTsgfQorCisgICAg ICAgIC8vIENvcGllcyBhbGwgdXNlci1sZXZlbCBmaWVsZHMgZnJvbSB0aGUgc291cmNlIG5vZGUs IGJ1dCBub3QKKyAgICAgICAgLy8gaW50ZXJuYWwgZmllbGRzLiBGb3IgZXhhbXBsZSwgdGhlIGJh c2UgaW1wbGVtZW50YXRpb24gb2YgdGhpcworICAgICAgICAvLyBtZXRob2QgY29waWVzIHRoZSAi bV9kYXRhIiBmaWVsZCwgYnV0IG5vdCB0aGUgY2hpbGQgb3IgcGFyZW50CisgICAgICAgIC8vIGZp ZWxkcy4gQW55IGF1Z21lbnRhdGlvbiBpbmZvcm1hdGlvbiBhbHNvIGRvZXMgbm90IG5lZWQgdG8g YmUKKyAgICAgICAgLy8gY29waWVkLCBhcyBpdCB3aWxsIGJlIHJlY29tcHV0ZWQuIFN1YmNsYXNz ZXMgbXVzdCBjYWxsIHRoZQorICAgICAgICAvLyBzdXBlcmNsYXNzIGltcGxlbWVudGF0aW9uLgor ICAgICAgICB2aXJ0dWFsIHZvaWQgY29weUZyb20oTm9kZSogc3JjKSB7IG1fZGF0YSA9IHNyYy0+ ZGF0YSgpOyB9CisKKyAgICAgICAgTm9kZSogbGVmdCgpIGNvbnN0IHsgcmV0dXJuIG1fbGVmdDsg fQorICAgICAgICB2b2lkIHNldExlZnQoTm9kZSogbm9kZSkgeyBtX2xlZnQgPSBub2RlOyB9CisK KyAgICAgICAgTm9kZSogcmlnaHQoKSBjb25zdCB7IHJldHVybiBtX3JpZ2h0OyB9CisgICAgICAg IHZvaWQgc2V0UmlnaHQoTm9kZSogbm9kZSkgeyBtX3JpZ2h0ID0gbm9kZTsgfQorCisgICAgICAg IE5vZGUqIHBhcmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fcGFyZW50OyB9CisgICAgICAgIHZvaWQg c2V0UGFyZW50KE5vZGUqIG5vZGUpIHsgbV9wYXJlbnQgPSBub2RlOyB9CisKKyAgICBwcml2YXRl OgorICAgICAgICBOb2RlKiBtX2xlZnQ7CisgICAgICAgIE5vZGUqIG1fcmlnaHQ7CisgICAgICAg IE5vZGUqIG1fcGFyZW50OworICAgICAgICBDb2xvciBtX2NvbG9yOworICAgICAgICBUIG1fZGF0 YTsKKyAgICB9OworCisgICAgLy8gUmV0dXJucyB0aGUgcm9vdCBvZiB0aGUgdHJlZSwgd2hpY2gg aXMgbmVlZGVkIGJ5IHNvbWUgc3ViY2xhc3Nlcy4KKyAgICBOb2RlKiByb290KCkgY29uc3QgeyBy ZXR1cm4gbV9yb290OyB9CisKK3ByaXZhdGU6CisgICAgLy8gVGhpcyB2aXJ0dWFsIG1ldGhvZCBp cyB0aGUgaG9vayB0aGF0IHN1YmNsYXNzZXMgc2hvdWxkIHVzZSB3aGVuCisgICAgLy8gYXVnbWVu dGluZyB0aGUgcmVkLWJsYWNrIHRyZWUgd2l0aCBhZGRpdGlvbmFsIHBlci1ub2RlIHN1bW1hcnkK KyAgICAvLyBpbmZvcm1hdGlvbi4gRm9yIGV4YW1wbGUsIGluIHRoZSBjYXNlIG9mIGFuIGludGVy dmFsIHRyZWUsIHRoaXMKKyAgICAvLyBpcyB1c2VkIHRvIGNvbXB1dGUgdGhlIG1heGltdW0gZW5k cG9pbnQgb2YgdGhlIHN1YnRyZWUgYmVsb3cgdGhlCisgICAgLy8gZ2l2ZW4gbm9kZSBiYXNlZCBv biB0aGUgdmFsdWVzIGluIHRoZSBsZWZ0IGFuZCByaWdodCBjaGlsZHJlbi4gSXQKKyAgICAvLyBp cyBndWFyYW50ZWVkIHRoYXQgdGhpcyB3aWxsIGJlIGNhbGxlZCBpbiB0aGUgY29ycmVjdCBvcmRl ciB0bworICAgIC8vIHByb3Blcmx5IHVwZGF0ZSBzdWNoIHN1bW1hcnkgaW5mb3JtYXRpb24gYmFz ZWQgb25seSBvbiB0aGUgdmFsdWVzCisgICAgLy8gaW4gdGhlIGxlZnQgYW5kIHJpZ2h0IGNoaWxk cmVuLiBUaGlzIG1ldGhvZCBzaG91bGQgcmV0dXJuIHRydWUgaWYKKyAgICAvLyB0aGUgbm9kZSdz IHN1bW1hcnkgaW5mb3JtYXRpb24gY2hhbmdlZC4KKyAgICB2aXJ0dWFsIGJvb2wgdXBkYXRlTm9k ZShOb2RlKiBub2RlKSB7IHJldHVybiBmYWxzZTsgfQorCisgICAgLy8tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg ICAgLy8gR2VuZXJpYyBiaW5hcnkgc2VhcmNoIHRyZWUgb3BlcmF0aW9ucworICAgIC8vCisKKyAg ICAvLyBTZWFyY2hlcyB0aGUgdHJlZSBmb3IgdGhlIGdpdmVuIGRhdHVtLgorICAgIE5vZGUqIHRy ZWVTZWFyY2goY29uc3QgVCYgZGF0YSkKKyAgICB7CisgICAgICAgIGlmIChtX25lZWRzRnVsbE9y ZGVyaW5nQ29tcGFyaXNvbnMpCisgICAgICAgICAgICByZXR1cm4gdHJlZVNlYXJjaEZ1bGxDb21w YXJpc29ucyhtX3Jvb3QsIGRhdGEpOworCisgICAgICAgIHJldHVybiB0cmVlU2VhcmNoTm9ybWFs KG1fcm9vdCwgZGF0YSk7CisgICAgfQorCisgICAgLy8gU2VhcmNoZXMgdGhlIHRyZWUgdXNpbmcg dGhlIG5vcm1hbCBjb21wYXJpc29uIG9wZXJhdGlvbnMsCisgICAgLy8gc3VpdGFibGUgZm9yIHNp bXBsZSBkYXRhIHR5cGVzIHN1Y2ggYXMgbnVtYmVycy4KKyAgICBOb2RlKiB0cmVlU2VhcmNoTm9y bWFsKE5vZGUqIGN1cnJlbnQsIGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICB3aGlsZSAo Y3VycmVudCkgeworICAgICAgICAgICAgaWYgKGN1cnJlbnQtPmRhdGEoKSA9PSBkYXRhKQorICAg ICAgICAgICAgICAgIHJldHVybiBjdXJyZW50OworICAgICAgICAgICAgaWYgKGRhdGEgPCBjdXJy ZW50LT5kYXRhKCkpCisgICAgICAgICAgICAgICAgY3VycmVudCA9IGN1cnJlbnQtPmxlZnQoKTsK KyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBjdXJyZW50ID0gY3VycmVudC0+cmln aHQoKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICAvLyBTZWFy Y2hlcyB0aGUgdHJlZSB1c2luZyBtdWx0aXBsZSBjb21wYXJpc29uIG9wZXJhdGlvbnMsIHJlcXVp cmVkCisgICAgLy8gZm9yIGRhdGEgdHlwZXMgd2l0aCBtb3JlIGNvbXBsZXggYmVoYXZpb3Igc3Vj aCBhcyBpbnRlcnZhbHMuCisgICAgTm9kZSogdHJlZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhOb2Rl KiBjdXJyZW50LCBjb25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgaWYgKCFjdXJyZW50KQor ICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgIGlmIChkYXRhIDwgY3VycmVudC0+ZGF0YSgp KQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoY3VycmVudC0+ bGVmdCgpLCBkYXRhKTsKKyAgICAgICAgaWYgKGN1cnJlbnQtPmRhdGEoKSA8IGRhdGEpCisgICAg ICAgICAgICByZXR1cm4gdHJlZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhjdXJyZW50LT5yaWdodCgp LCBkYXRhKTsKKyAgICAgICAgaWYgKGRhdGEgPT0gY3VycmVudC0+ZGF0YSgpKQorICAgICAgICAg ICAgcmV0dXJuIGN1cnJlbnQ7CisKKyAgICAgICAgLy8gV2UgbWF5IG5lZWQgdG8gdHJhdmVyc2Ug Ym90aCB0aGUgbGVmdCBhbmQgcmlnaHQgc3VidHJlZXMuCisgICAgICAgIE5vZGUqIHJlc3VsdCA9 IHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoY3VycmVudC0+bGVmdCgpLCBkYXRhKTsKKyAgICAg ICAgaWYgKCFyZXN1bHQpCisgICAgICAgICAgICByZXN1bHQgPSB0cmVlU2VhcmNoRnVsbENvbXBh cmlzb25zKGN1cnJlbnQtPnJpZ2h0KCksIGRhdGEpOworICAgICAgICByZXR1cm4gcmVzdWx0Owor ICAgIH0KKworICAgIHZvaWQgdHJlZUluc2VydChOb2RlKiB6KQorICAgIHsKKyAgICAgICAgTm9k ZSogeSA9IDA7CisgICAgICAgIE5vZGUqIHggPSBtX3Jvb3Q7CisgICAgICAgIHdoaWxlICh4KSB7 CisgICAgICAgICAgICB5ID0geDsKKyAgICAgICAgICAgIGlmICh6LT5kYXRhKCkgPCB4LT5kYXRh KCkpCisgICAgICAgICAgICAgICAgeCA9IHgtPmxlZnQoKTsKKyAgICAgICAgICAgIGVsc2UKKyAg ICAgICAgICAgICAgICB4ID0geC0+cmlnaHQoKTsKKyAgICAgICAgfQorICAgICAgICB6LT5zZXRQ YXJlbnQoeSk7CisgICAgICAgIGlmICgheSkKKyAgICAgICAgICAgIG1fcm9vdCA9IHo7CisgICAg ICAgIGVsc2UgeworICAgICAgICAgICAgaWYgKHotPmRhdGEoKSA8IHktPmRhdGEoKSkKKyAgICAg ICAgICAgICAgICB5LT5zZXRMZWZ0KHopOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAg ICAgIHktPnNldFJpZ2h0KHopOworICAgICAgICB9CisgICAgfQorCisgICAgLy8gRmluZHMgdGhl IG5vZGUgZm9sbG93aW5nIHRoZSBnaXZlbiBvbmUgaW4gc2VxdWVudGlhbCBvcmRlcmluZyBvZgor ICAgIC8vIHRoZWlyIGRhdGEsIG9yIG51bGwgaWYgbm9uZSBleGlzdHMuCisgICAgTm9kZSogdHJl ZVN1Y2Nlc3NvcihOb2RlKiB4KQorICAgIHsKKyAgICAgICAgaWYgKHgtPnJpZ2h0KCkpCisgICAg ICAgICAgICByZXR1cm4gdHJlZU1pbmltdW0oeC0+cmlnaHQoKSk7CisgICAgICAgIE5vZGUqIHkg PSB4LT5wYXJlbnQoKTsKKyAgICAgICAgd2hpbGUgKHkgJiYgeCA9PSB5LT5yaWdodCgpKSB7Cisg ICAgICAgICAgICB4ID0geTsKKyAgICAgICAgICAgIHkgPSB5LT5wYXJlbnQoKTsKKyAgICAgICAg fQorICAgICAgICByZXR1cm4geTsKKyAgICB9CisKKyAgICAvLyBGaW5kcyB0aGUgbWluaW11bSBl bGVtZW50IGluIHRoZSBzdWItdHJlZSByb290ZWQgYXQgdGhlIGdpdmVuCisgICAgLy8gbm9kZS4K KyAgICBOb2RlKiB0cmVlTWluaW11bShOb2RlKiB4KQorICAgIHsKKyAgICAgICAgd2hpbGUgKHgt PmxlZnQoKSkKKyAgICAgICAgICAgIHggPSB4LT5sZWZ0KCk7CisgICAgICAgIHJldHVybiB4Owor ICAgIH0KKworICAgIC8vIEhlbHBlciBmb3IgbWFpbnRhaW5pbmcgdGhlIGF1Z21lbnRlZCByZWQt YmxhY2sgdHJlZS4KKyAgICB2b2lkIHByb3BhZ2F0ZVVwZGF0ZXMoTm9kZSogc3RhcnQpCisgICAg eworICAgICAgICBib29sIHNob3VsZENvbnRpbnVlID0gdHJ1ZTsKKyAgICAgICAgd2hpbGUgKHN0 YXJ0ICYmIHNob3VsZENvbnRpbnVlKSB7CisgICAgICAgICAgICBzaG91bGRDb250aW51ZSA9IHVw ZGF0ZU5vZGUoc3RhcnQpOworICAgICAgICAgICAgc3RhcnQgPSBzdGFydC0+cGFyZW50KCk7Cisg ICAgICAgIH0KKyAgICB9CisKKyAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBSZWQtQmxhY2sg dHJlZSBvcGVyYXRpb25zCisgICAgLy8KKworICAgIC8vIExlZnQtcm90YXRlcyB0aGUgc3VidHJl ZSByb290ZWQgYXQgeC4KKyAgICB2b2lkIGxlZnRSb3RhdGUoTm9kZSogeCkKKyAgICB7CisgICAg ICAgIC8vIFNldCB5LgorICAgICAgICBOb2RlKiB5ID0geC0+cmlnaHQoKTsKKyAgICAgICAgLy8g VHVybiB5J3MgbGVmdCBzdWJ0cmVlIGludG8geCdzIHJpZ2h0IHN1YnRyZWUuCisgICAgICAgIHgt PnNldFJpZ2h0KHktPmxlZnQoKSk7CisgICAgICAgIGlmICh5LT5sZWZ0KCkpCisgICAgICAgICAg ICB5LT5sZWZ0KCktPnNldFBhcmVudCh4KTsKKyAgICAgICAgLy8gTGluayB4J3MgcGFyZW50IHRv IHkuCisgICAgICAgIHktPnNldFBhcmVudCh4LT5wYXJlbnQoKSk7CisgICAgICAgIGlmICgheC0+ cGFyZW50KCkpCisgICAgICAgICAgICBtX3Jvb3QgPSB5OworICAgICAgICBlbHNlIHsKKyAgICAg ICAgICAgIGlmICh4ID09IHgtPnBhcmVudCgpLT5sZWZ0KCkpCisgICAgICAgICAgICAgICAgeC0+ cGFyZW50KCktPnNldExlZnQoeSk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAg eC0+cGFyZW50KCktPnNldFJpZ2h0KHkpOworICAgICAgICB9CisgICAgICAgIC8vIFB1dCB4IG9u IHkncyBsZWZ0LgorICAgICAgICB5LT5zZXRMZWZ0KHgpOworICAgICAgICB4LT5zZXRQYXJlbnQo eSk7CisgICAgICAgIC8vIFVwZGF0ZSBub2RlcyBsb3dlc3QgdG8gaGlnaGVzdC4KKyAgICAgICAg dXBkYXRlTm9kZSh4KTsKKyAgICAgICAgdXBkYXRlTm9kZSh5KTsKKyAgICB9CisKKyAgICAvLyBS aWdodC1yb3RhdGVzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB5LgorICAgIHZvaWQgcmlnaHRSb3Rh dGUoTm9kZSogeSkKKyAgICB7CisgICAgICAgIC8vIFNldCB4LgorICAgICAgICBOb2RlKiB4ID0g eS0+bGVmdCgpOworICAgICAgICAvLyBUdXJuIHgncyByaWdodCBzdWJ0cmVlIGludG8geSdzIGxl ZnQgc3VidHJlZS4KKyAgICAgICAgeS0+c2V0TGVmdCh4LT5yaWdodCgpKTsKKyAgICAgICAgaWYg KHgtPnJpZ2h0KCkpCisgICAgICAgICAgICB4LT5yaWdodCgpLT5zZXRQYXJlbnQoeSk7CisgICAg ICAgIC8vIExpbmsgeSdzIHBhcmVudCB0byB4LgorICAgICAgICB4LT5zZXRQYXJlbnQoeS0+cGFy ZW50KCkpOworICAgICAgICBpZiAoIXktPnBhcmVudCgpKQorICAgICAgICAgICAgbV9yb290ID0g eDsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBpZiAoeSA9PSB5LT5wYXJlbnQoKS0+bGVm dCgpKQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRMZWZ0KHgpOworICAgICAgICAg ICAgZWxzZQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRSaWdodCh4KTsKKyAgICAg ICAgfQorICAgICAgICAvLyBQdXQgeSBvbiB4J3MgcmlnaHQuCisgICAgICAgIHgtPnNldFJpZ2h0 KHkpOworICAgICAgICB5LT5zZXRQYXJlbnQoeCk7CisgICAgICAgIC8vIFVwZGF0ZSBub2RlcyBs b3dlc3QgdG8gaGlnaGVzdC4KKyAgICAgICAgdXBkYXRlTm9kZSh5KTsKKyAgICAgICAgdXBkYXRl Tm9kZSh4KTsKKyAgICB9CisKKyAgICAvLyBJbnNlcnRzIHRoZSBnaXZlbiBub2RlIGludG8gdGhl IHRyZWUuCisgICAgdm9pZCBpbnNlcnROb2RlKE5vZGUqIHgpCisgICAgeworICAgICAgICB0cmVl SW5zZXJ0KHgpOworICAgICAgICB4LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgdXBkYXRlTm9k ZSh4KTsKKworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2luZykK KyAgICAgICAgICAgIExPR19FUlJPUigiICBQT0RSZWRCbGFja1RyZWU6Okluc2VydE5vZGUiKTsK KyNlbmRpZgorCisgICAgICAgIC8vIFRoZSBub2RlIGZyb20gd2hpY2ggdG8gc3RhcnQgcHJvcGFn YXRpbmcgdXBkYXRlcyB1cHdhcmRzLgorICAgICAgICBOb2RlKiB1cGRhdGVTdGFydCA9IHgtPnBh cmVudCgpOworCisgICAgICAgIHdoaWxlICh4ICE9IG1fcm9vdCAmJiB4LT5wYXJlbnQoKS0+Y29s b3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICBpZiAoeC0+cGFyZW50KCkgPT0geC0+cGFyZW50 KCktPnBhcmVudCgpLT5sZWZ0KCkpIHsKKyAgICAgICAgICAgICAgICBOb2RlKiB5ID0geC0+cGFy ZW50KCktPnBhcmVudCgpLT5yaWdodCgpOworICAgICAgICAgICAgICAgIGlmICh5ICYmIHktPmNv bG9yKCkgPT0ga1JlZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDEKKyNpZm5kZWYg TkRFQlVHCisgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dpbmcpCisgICAg ICAgICAgICAgICAgICAgICAgICBMT0dfRVJST1IoIiAgQ2FzZSAxLzEiKTsKKyNlbmRpZgorICAg ICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAg ICAgICAgICAgICAgeS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeC0+ cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAg dXBkYXRlTm9kZSh4LT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHggPSB4LT5wYXJl bnQoKS0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZU5vZGUoeCk7CisgICAg ICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAg ICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHggPT0geC0+cGFyZW50KCktPnJp Z2h0KCkpIHsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobV92 ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgIExPR19FUlJPUigi ICBDYXNlIDEvMiIpOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDIK KyAgICAgICAgICAgICAgICAgICAgICAgIHggPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIGxlZnRSb3RhdGUoeCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICAgICAgLy8gQ2FzZSAzCisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgICAgICAg ICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgICAgICAgICAgICAgTE9HX0VS Uk9SKCIgIENhc2UgMS8zIik7CisjZW5kaWYKKyAgICAgICAgICAgICAgICAgICAgeC0+cGFyZW50 KCktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5w YXJlbnQoKS0+c2V0Q29sb3Ioa1JlZCk7CisgICAgICAgICAgICAgICAgICAgIHJpZ2h0Um90YXRl KHgtPnBhcmVudCgpLT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0 ID0geC0+cGFyZW50KCktPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAg IH0gZWxzZSB7CisgICAgICAgICAgICAgICAgLy8gU2FtZSBhcyAidGhlbiIgY2xhdXNlIHdpdGgg InJpZ2h0IiBhbmQgImxlZnQiIGV4Y2hhbmdlZC4KKyAgICAgICAgICAgICAgICBOb2RlKiB5ID0g eC0+cGFyZW50KCktPnBhcmVudCgpLT5sZWZ0KCk7CisgICAgICAgICAgICAgICAgaWYgKHkgJiYg eS0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorI2lm bmRlZiBOREVCVUcKKyAgICAgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2luZykK KyAgICAgICAgICAgICAgICAgICAgICAgIExPR19FUlJPUigiICBDYXNlIDIvMSIpOworI2VuZGlm CisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5zZXRDb2xvcihrQmxhY2spOworICAg ICAgICAgICAgICAgICAgICB5LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAg ICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAg ICAgICB1cGRhdGVOb2RlKHgtPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHgt PnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlTm9kZSh4KTsK KyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAg ICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoeCA9PSB4LT5wYXJlbnQo KS0+bGVmdCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDIKKyNpZm5kZWYg TkRFQlVHCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIExPR19FUlJPUigiICBDYXNlIDIvMiIpOworI2Vu ZGlmCisgICAgICAgICAgICAgICAgICAgICAgICB4ID0geC0+cGFyZW50KCk7CisgICAgICAgICAg ICAgICAgICAgICAgICByaWdodFJvdGF0ZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAg ICAgICAgICAgICAgICAgICAvLyBDYXNlIDMKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAg ICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dpbmcpCisgICAgICAgICAgICAgICAgICAgICAgICBM T0dfRVJST1IoIiAgQ2FzZSAyLzMiKTsKKyNlbmRpZgorICAgICAgICAgICAgICAgICAgICB4LT5w YXJlbnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeC0+cGFyZW50 KCktPnBhcmVudCgpLT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgbGVmdFJv dGF0ZSh4LT5wYXJlbnQoKS0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVT dGFydCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICB9CisgICAgICAgIH0KKworICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHVwZGF0ZVN0YXJ0 KTsKKworICAgICAgICBtX3Jvb3QtPnNldENvbG9yKGtCbGFjayk7CisgICAgfQorCisgICAgLy8g UmVzdG9yZXMgdGhlIHJlZC1ibGFjayBwcm9wZXJ0eSB0byB0aGUgdHJlZSBhZnRlciBzcGxpY2lu ZyBvdXQKKyAgICAvLyBhIG5vZGUuIE5vdGUgdGhhdCB4IG1heSBiZSBudWxsLCB3aGljaCBpcyB3 aHkgeFBhcmVudCBtdXN0IGJlCisgICAgLy8gc3VwcGxpZWQuCisgICAgdm9pZCBkZWxldGVGaXh1 cChOb2RlKiB4LCBOb2RlKiB4UGFyZW50KQorICAgIHsKKyAgICAgICAgd2hpbGUgKHggIT0gbV9y b290ICYmICgheCB8fCB4LT5jb2xvcigpID09IGtCbGFjaykpIHsKKyAgICAgICAgICAgIGlmICh4 ID09IHhQYXJlbnQtPmxlZnQoKSkgeworICAgICAgICAgICAgICAgIC8vIE5vdGU6IHRoZSB0ZXh0 IHBvaW50cyBvdXQgdGhhdCB3IGNhbiBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAgICAvLyBU aGUgcmVhc29uIGlzIG5vdCBvYnZpb3VzIGZyb20gc2ltcGx5IGxvb2tpbmcgYXQKKyAgICAgICAg ICAgICAgICAvLyB0aGUgY29kZTsgaXQgY29tZXMgYWJvdXQgZnJvbSB0aGUgcHJvcGVydGllcyBv ZiB0aGUKKyAgICAgICAgICAgICAgICAvLyByZWQtYmxhY2sgdHJlZS4KKyAgICAgICAgICAgICAg ICBOb2RlKiB3ID0geFBhcmVudC0+cmlnaHQoKTsKKyAgICAgICAgICAgICAgICBBU1NFUlQodyk7 IC8vIHgncyBzaWJsaW5nIHNob3VsZCBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAgICBpZiAo dy0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorICAg ICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAg ICB4UGFyZW50LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgbGVmdFJvdGF0 ZSh4UGFyZW50KTsKKyAgICAgICAgICAgICAgICAgICAgdyA9IHhQYXJlbnQtPnJpZ2h0KCk7Cisg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGlmICgoIXctPmxlZnQoKSB8fCB3LT5s ZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKQorICAgICAgICAgICAgICAgICAgICAmJiAoIXctPnJp Z2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spKSB7CisgICAgICAgICAgICAg ICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsK KyAgICAgICAgICAgICAgICAgICAgeCA9IHhQYXJlbnQ7CisgICAgICAgICAgICAgICAgICAgIHhQ YXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgICAgICAgICBpZiAoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxh Y2spIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMworICAgICAgICAgICAgICAg ICAgICAgICAgdy0+bGVmdCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAg ICAgICAgdy0+c2V0Q29sb3Ioa1JlZCk7CisgICAgICAgICAgICAgICAgICAgICAgICByaWdodFJv dGF0ZSh3KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5yaWdodCgpOwor ICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgNAorICAg ICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcih4UGFyZW50LT5jb2xvcigpKTsKKyAgICAgICAg ICAgICAgICAgICAgeFBhcmVudC0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAg ICAgaWYgKHctPnJpZ2h0KCkpCisgICAgICAgICAgICAgICAgICAgICAgICB3LT5yaWdodCgpLT5z ZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICBsZWZ0Um90YXRlKHhQYXJlbnQp OworICAgICAgICAgICAgICAgICAgICB4ID0gbV9yb290OworICAgICAgICAgICAgICAgICAgICB4 UGFyZW50ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBl bHNlIHsKKyAgICAgICAgICAgICAgICAvLyBTYW1lIGFzICJ0aGVuIiBjbGF1c2Ugd2l0aCAicmln aHQiIGFuZCAibGVmdCIKKyAgICAgICAgICAgICAgICAvLyBleGNoYW5nZWQuCisKKyAgICAgICAg ICAgICAgICAvLyBOb3RlOiB0aGUgdGV4dCBwb2ludHMgb3V0IHRoYXQgdyBjYW4gbm90IGJlIG51 bGwuCisgICAgICAgICAgICAgICAgLy8gVGhlIHJlYXNvbiBpcyBub3Qgb2J2aW91cyBmcm9tIHNp bXBseSBsb29raW5nIGF0CisgICAgICAgICAgICAgICAgLy8gdGhlIGNvZGU7IGl0IGNvbWVzIGFi b3V0IGZyb20gdGhlIHByb3BlcnRpZXMgb2YgdGhlCisgICAgICAgICAgICAgICAgLy8gcmVkLWJs YWNrIHRyZWUuCisgICAgICAgICAgICAgICAgTm9kZSogdyA9IHhQYXJlbnQtPmxlZnQoKTsKKyAg ICAgICAgICAgICAgICBBU1NFUlQodyk7IC8vIHgncyBzaWJsaW5nIHNob3VsZCBub3QgYmUgbnVs bC4KKyAgICAgICAgICAgICAgICBpZiAody0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAg ICAgICAgICAgIC8vIENhc2UgMQorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrQmxh Y2spOworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihrUmVkKTsKKyAgICAg ICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAgICAgICAg IHcgPSB4UGFyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAg IGlmICgoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spCisgICAg ICAgICAgICAgICAgICAgICYmICghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29sb3IoKSA9PSBr QmxhY2spKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAg ICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHhQYXJlbnQ7 CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAg ICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoIXctPmxlZnQoKSB8fCB3LT5s ZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBD YXNlIDMKKyAgICAgICAgICAgICAgICAgICAgICAgIHctPnJpZ2h0KCktPnNldENvbG9yKGtCbGFj ayk7CisgICAgICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUodyk7CisgICAgICAgICAgICAgICAgICAgICAgICB3 ID0geFBhcmVudC0+bGVmdCgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgICAgIC8vIENhc2UgNAorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcih4UGFyZW50 LT5jb2xvcigpKTsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0Q29sb3Ioa0JsYWNr KTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHctPmxlZnQoKSkKKyAgICAgICAgICAgICAgICAg ICAgICAgIHctPmxlZnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAg cmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAgICAgICAgIHggPSBtX3Jvb3Q7Cisg ICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgICAgaWYgKHgpCisgICAgICAgICAg ICB4LT5zZXRDb2xvcihrQmxhY2spOworICAgIH0KKworICAgIC8vIERlbGV0ZXMgdGhlIGdpdmVu IG5vZGUgZnJvbSB0aGUgdHJlZS4gTm90ZSB0aGF0IHRoaXMKKyAgICAvLyBwYXJ0aWN1bGFyIG5v ZGUgbWF5IG5vdCBhY3R1YWxseSBiZSByZW1vdmVkIGZyb20gdGhlIHRyZWU7CisgICAgLy8gaW5z dGVhZCwgYW5vdGhlciBub2RlIG1pZ2h0IGJlIHJlbW92ZWQgYW5kIGl0cyBjb250ZW50cworICAg IC8vIGNvcGllZCBpbnRvIHouCisgICAgdm9pZCBkZWxldGVOb2RlKE5vZGUqIHopCisgICAgewor ICAgICAgICAvLyBZIGlzIHRoZSBub2RlIHRvIGJlIHVubGlua2VkIGZyb20gdGhlIHRyZWUuCisg ICAgICAgIE5vZGUqIHk7CisgICAgICAgIGlmICghei0+bGVmdCgpIHx8ICF6LT5yaWdodCgpKQor ICAgICAgICAgICAgeSA9IHo7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHkgPSB0cmVlU3Vj Y2Vzc29yKHopOworICAgICAgICAvLyBZIGlzIGd1YXJhbnRlZWQgdG8gYmUgbm9uLTAgYXQgdGhp cyBwb2ludC4KKyAgICAgICAgTm9kZSogeDsKKyAgICAgICAgaWYgKHktPmxlZnQoKSkKKyAgICAg ICAgICAgIHggPSB5LT5sZWZ0KCk7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHggPSB5LT5y aWdodCgpOworICAgICAgICAvLyBYIGlzIHRoZSBjaGlsZCBvZiB5IHdoaWNoIG1pZ2h0IHBvdGVu dGlhbGx5IHJlcGxhY2UgeSBpbgorICAgICAgICAvLyB0aGUgdHJlZS4gWCBtaWdodCBiZSBudWxs IGF0IHRoaXMgcG9pbnQuCisgICAgICAgIE5vZGUqIHhQYXJlbnQ7CisgICAgICAgIGlmICh4KSB7 CisgICAgICAgICAgICB4LT5zZXRQYXJlbnQoeS0+cGFyZW50KCkpOworICAgICAgICAgICAgeFBh cmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICB9IGVsc2UKKyAgICAgICAgICAgIHhQYXJlbnQg PSB5LT5wYXJlbnQoKTsKKyAgICAgICAgaWYgKCF5LT5wYXJlbnQoKSkKKyAgICAgICAgICAgIG1f cm9vdCA9IHg7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgaWYgKHkgPT0geS0+cGFyZW50 KCktPmxlZnQoKSkKKyAgICAgICAgICAgICAgICB5LT5wYXJlbnQoKS0+c2V0TGVmdCh4KTsKKyAg ICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB5LT5wYXJlbnQoKS0+c2V0UmlnaHQoeCk7 CisgICAgICAgIH0KKyAgICAgICAgLy8gSXQgaGFzIGJlZW4gZm91bmQgZW1waXJpY2FsbHkgdGhh dCBib3RoIG9mIHRoZXNlIHVwd2FyZAorICAgICAgICAvLyBwcm9wYWdhdGlvbnMgYXJlIG5lY2Vz c2FyeS4KKyAgICAgICAgaWYgKHkgIT0geikgeworICAgICAgICAgICAgei0+Y29weUZyb20oeSk7 CisgICAgICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHopOworICAgICAgICB9CisgICAgICAgIGlm ICh4UGFyZW50KQorICAgICAgICAgICAgcHJvcGFnYXRlVXBkYXRlcyh4UGFyZW50KTsKKyAgICAg ICAgaWYgKHktPmNvbG9yKCkgPT0ga0JsYWNrKQorICAgICAgICAgICAgZGVsZXRlRml4dXAoeCwg eFBhcmVudCk7CisgICAgfQorCisgICAgLy8gVmlzaXRzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB0 aGUgZ2l2ZW4gbm9kZSBpbiBvcmRlci4KKyAgICB2b2lkIHZpc2l0SW5vcmRlckltcGwoTm9kZSog bm9kZSwgVmlzaXRvciogdmlzaXRvcikKKyAgICB7CisgICAgICAgIGlmIChub2RlLT5sZWZ0KCkp CisgICAgICAgICAgICB2aXNpdElub3JkZXJJbXBsKG5vZGUtPmxlZnQoKSwgdmlzaXRvcik7Cisg ICAgICAgIHZpc2l0b3ItPnZpc2l0KG5vZGUtPmRhdGEoKSk7CisgICAgICAgIGlmIChub2RlLT5y aWdodCgpKQorICAgICAgICAgICAgdmlzaXRJbm9yZGVySW1wbChub2RlLT5yaWdodCgpLCB2aXNp dG9yKTsKKyAgICB9CisKKyAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBIZWxwZXIgY2xhc3Mg Zm9yIE51bUVsZW1lbnRzKCkKKworICAgIC8vIEEgVmlzaXRvciB3aGljaCBzaW1wbHkgY291bnRz IHRoZSBudW1iZXIgb2YgdmlzaXRlZCBlbGVtZW50cy4KKyAgICBjbGFzcyBDb3VudGVyIDogcHVi bGljIFZpc2l0b3IsIHB1YmxpYyBOb25jb3B5YWJsZSB7CisgICAgcHVibGljOgorICAgICAgICBD b3VudGVyKCkKKyAgICAgICAgICAgIDogbV9jb3VudCgwKSB7IH0KKworICAgICAgICB2aXJ0dWFs IHZvaWQgdmlzaXQoY29uc3QgVCYgZGF0YSkgeyArK21fY291bnQ7IH0KKyAgICAgICAgaW50IGNv dW50KCkgeyByZXR1cm4gbV9jb3VudDsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgaW50IG1f Y291bnQ7CisgICAgfTsKKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIFZlcmlmaWNhdGlv biBhbmQgZGVidWdnaW5nIHJvdXRpbmVzCisgICAgLy8KKworICAgIC8vIFJldHVybnMgaW4gdGhl ICJibGFja0NvdW50IiBwYXJhbWV0ZXIgdGhlIG51bWJlciBvZiBibGFjaworICAgIC8vIGNoaWxk cmVuIGFsb25nIGFsbCBwYXRocyB0byBhbGwgbGVhdmVzIG9mIHRoZSBnaXZlbiBub2RlLgorICAg IGJvb2wgY2hlY2tJbnZhcmlhbnRzRnJvbU5vZGUoTm9kZSogbm9kZSwgaW50KiBibGFja0NvdW50 KQorICAgIHsKKyAgICAgICAgLy8gQmFzZSBjYXNlIGlzIGEgbGVhZiBub2RlLgorICAgICAgICBp ZiAoIW5vZGUpIHsKKyAgICAgICAgICAgICpibGFja0NvdW50ID0gMTsKKyAgICAgICAgICAgIHJl dHVybiB0cnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gRWFjaCBub2RlIGlzIGVpdGhlciBy ZWQgb3IgYmxhY2suCisgICAgICAgIGlmICghKG5vZGUtPmNvbG9yKCkgPT0ga1JlZCB8fCBub2Rl LT5jb2xvcigpID09IGtCbGFjaykpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAg ICAgLy8gRXZlcnkgbGVhZiAob3IgbnVsbCkgaXMgYmxhY2suCisKKyAgICAgICAgaWYgKG5vZGUt PmNvbG9yKCkgPT0ga1JlZCkgeworICAgICAgICAgICAgLy8gQm90aCBvZiBpdHMgY2hpbGRyZW4g YXJlIGJsYWNrLgorICAgICAgICAgICAgaWYgKCEoKCFub2RlLT5sZWZ0KCkgfHwgbm9kZS0+bGVm dCgpLT5jb2xvcigpID09IGtCbGFjaykpKQorICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsK KyAgICAgICAgICAgIGlmICghKCghbm9kZS0+cmlnaHQoKSB8fCBub2RlLT5yaWdodCgpLT5jb2xv cigpID09IGtCbGFjaykpKQorICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAg fQorCisgICAgICAgIC8vIEV2ZXJ5IHNpbXBsZSBwYXRoIHRvIGEgbGVhZiBub2RlIGNvbnRhaW5z IHRoZSBzYW1lIG51bWJlciBvZgorICAgICAgICAvLyBibGFjayBub2Rlcy4KKyAgICAgICAgaW50 IGxlZnRDb3VudCA9IDAsIHJpZ2h0Q291bnQgPSAwOworICAgICAgICBib29sIGxlZnRWYWxpZCA9 IGNoZWNrSW52YXJpYW50c0Zyb21Ob2RlKG5vZGUtPmxlZnQoKSwgJmxlZnRDb3VudCk7CisgICAg ICAgIGJvb2wgcmlnaHRWYWxpZCA9IGNoZWNrSW52YXJpYW50c0Zyb21Ob2RlKG5vZGUtPnJpZ2h0 KCksICZyaWdodENvdW50KTsKKyAgICAgICAgaWYgKCFsZWZ0VmFsaWQgfHwgIXJpZ2h0VmFsaWQp CisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICpibGFja0NvdW50ID0gbGVmdENv dW50ICsgKG5vZGUtPmNvbG9yKCkgPT0ga0JsYWNrID8gMSA6IDApOworICAgICAgICByZXR1cm4g bGVmdENvdW50ID09IHJpZ2h0Q291bnQ7CisgICAgfQorCisjaWZuZGVmIE5ERUJVRworICAgIC8v IER1bXBzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB0aGUgZ2l2ZW4gbm9kZS4KKyAgICB2b2lkIGR1 bXBGcm9tTm9kZShOb2RlKiBub2RlLCBpbnQgaW5kZW50YXRpb24pCisgICAgeworICAgICAgICBT dHJpbmdCdWlsZGVyIGJ1aWxkZXI7CisgICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgaW5kZW50 YXRpb247IGkrKykKKyAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCIgIik7CisgICAgICAgIGJ1 aWxkZXIuYXBwZW5kKCItIik7CisgICAgICAgIGlmIChub2RlKSB7CisgICAgICAgICAgICBidWls ZGVyLmFwcGVuZCgiICIpOworICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQodmFsdWVUb1N0cmlu Zyhub2RlLT5kYXRhKCkpKTsKKyAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKChub2RlLT5jb2xv cigpID09IGtCbGFjaykgPyAiIChibGFjaykiIDogIiAocmVkKSIpOworICAgICAgICB9CisgICAg ICAgIExPR19FUlJPUigiJXMiLCBidWlsZGVyLnRvU3RyaW5nKCkuYXNjaWkoKS5kYXRhKCkpOwor ICAgICAgICBpZiAobm9kZSkgeworICAgICAgICAgICAgZHVtcEZyb21Ob2RlKG5vZGUtPmxlZnQo KSwgaW5kZW50YXRpb24gKyAyKTsKKyAgICAgICAgICAgIGR1bXBGcm9tTm9kZShub2RlLT5yaWdo dCgpLCBpbmRlbnRhdGlvbiArIDIpOworICAgICAgICB9CisgICAgfQorI2VuZGlmCisKKyAgICAv Ly0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KKyAgICAvLyBEYXRhIG1lbWJlcnMKKworICAgIFJlZlB0cjxQT0RBcmVu YT4gbV9hcmVuYTsKKyAgICBOb2RlKiBtX3Jvb3Q7CisgICAgYm9vbCBtX25lZWRzRnVsbE9yZGVy aW5nQ29tcGFyaXNvbnM7CisjaWZuZGVmIE5ERUJVRworICAgIGJvb2wgbV92ZXJib3NlRGVidWdn aW5nOworI2VuZGlmCit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBQ T0RSZWRCbGFja1RyZWVfaAo= 66269 2010-09-01 14:15:24 -0700 2010-09-02 11:57:56 -0700 Revised patch red-black-tree.patch text/plain 32503 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjYxNikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNzMgQEAKKzIwMTAtMDktMDEgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCByZWQtYmxhY2sgdHJlZSBjYXBhYmxlIG9mIGhvbGRpbmcgcGxhaW4gb2xkIGRhdGEgKFBPRCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1MDU5CisK KyAgICAgICAgQWRkaW5nIGEgcmVkLWJsYWNrIHRyZWUgY2FwYWJsZSBvZiBob2xkaW5nIFBsYWlu IE9sZCBEYXRhIChQT0QpCisgICAgICAgIGFuZCBhbiBhc3NvY2lhdGVkIFBPREFyZW5hIHdoaWNo IGlzIGJ1aWx0IG9uIEFyZW5hLmguIE5vdGUgdGhhdAorICAgICAgICB0aGUgUE9EQXJlbmEgd2ls bCBiZSB1c2VkIGJ5IG90aGVyIGNsYXNzZXMgdG8gYWxsb2NhdGUgdGVtcG9yYXJ5CisgICAgICAg IHN0cnVjdHVyZXMsIHdoaWNoIGlzIHdoeSBpdCBpcyBub3QganVzdCBhbiBpbXBsZW1lbnRhdGlv biBkZXRhaWwKKyAgICAgICAgb2YgdGhlIHJlZC1ibGFjayB0cmVlLgorCisgICAgICAgIFRvIGFk ZHJlc3MgZWFybGllciByZXZpZXcgZmVlZGJhY2ssIFBPREFyZW5hIGFuZCBQT0RSZWRCbGFja1Ry ZWUKKyAgICAgICAgY2FuIG5vdCBjdXJyZW50bHkgYmUgcGxhY2VkIGluIFdURiBiZWNhdXNlIEFy ZW5hLmggaXMgaW4KKyAgICAgICAgV2ViQ29yZS9wbGF0Zm9ybS4KKworICAgICAgICBVbml0IHRl c3RzIGZvciB0aGUgUE9EUmVkQmxhY2tUcmVlIHdpbGwgYmUgaW50ZWdyYXRlZCBzZXBhcmF0ZWx5 CisgICAgICAgIHVuZGVyIGJ1ZyA0NTA2MC4KKworICAgICAgICAqIHBsYXRmb3JtL1BPREFyZW5h Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OmNyZWF0ZSk6CisgICAgICAg IChXZWJDb3JlOjpQT0RBcmVuYTo6YWxsb2MpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6 OlBPREFyZW5hKToKKyAgICAgICAgKiBwbGF0Zm9ybS9QT0RSZWRCbGFja1RyZWUuaDogQWRkZWQu CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OlZpc2l0b3I6On5WaXNpdG9yKToK KyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6UE9EUmVkQmxhY2tUcmVlKToKKyAg ICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6flBPRFJlZEJsYWNrVHJlZSk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Omluc2VydCk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFj a1RyZWU6OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dmlz aXRJbm9yZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bnVtRWxlbWVu dHMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpzZXROZWVkc0Z1bGxPcmRl cmluZ0NvbXBhcmlzb25zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Y2hl Y2tJbnZhcmlhbnRzKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6ZHVtcCk6 CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnNldFZlcmJvc2VEZWJ1Z2dpbmcp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpOb2RlKToKKyAgICAg ICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6fk5vZGUpOgorICAgICAgICAoV2Vi Q29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpjb2xvcik6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNldENvbG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJl ZEJsYWNrVHJlZTo6Tm9kZTo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6Ok5vZGU6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6 Tm9kZTo6bGVmdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNl dExlZnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpyaWdodCk6 CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNldFJpZ2h0KToKKyAg ICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6cGFyZW50KToKKyAgICAgICAg KFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0UGFyZW50KToKKyAgICAgICAgKFdl YkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cm9vdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRC bGFja1RyZWU6OnVwZGF0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVl Ojp0cmVlU2VhcmNoKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZVNl YXJjaE5vcm1hbCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnRyZWVTZWFy Y2hGdWxsQ29tcGFyaXNvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0 cmVlSW5zZXJ0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZVN1Y2Nl c3Nvcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnRyZWVNaW5pbXVtKToK KyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cHJvcGFnYXRlVXBkYXRlcyk6Cisg ICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmxlZnRSb3RhdGUpOgorICAgICAgICAo V2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyaWdodFJvdGF0ZSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6Omluc2VydE5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVk QmxhY2tUcmVlOjpkZWxldGVGaXh1cCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OmRlbGV0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp2aXNp dElub3JkZXJJbXBsKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291bnRl cjo6Q291bnRlcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OkNvdW50ZXI6 OnZpc2l0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291bnRlcjo6Y291 bnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpjaGVja0ludmFyaWFudHNG cm9tTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmR1bXBGcm9tTm9k ZSk6CisKIDIwMTAtMDktMDEgIFJvYiBCdWlzICA8cndsYnVpc0BnbWFpbC5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL1BPREFy ZW5hLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9QT0RBcmVuYS5oCShyZXZpc2lv biAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9QT0RBcmVuYS5oCShyZXZpc2lvbiAwKQpAQCAtMCww ICsxLDg0IEBACisvKgorICogQ29weXJpZ2h0IDIwMTAsIEdvb2dsZSBJbmMuCisgKiBBbGwgcmln aHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFu ZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVy bWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0 OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg aW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy CisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJl IHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhp cyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBB TkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERB VEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpZm5kZWYgUE9EQXJlbmFfaAorI2RlZmluZSBQT0RBcmVuYV9oCisKKyNpbmNs dWRlICJBcmVuYS5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3Rm L1JlZkNvdW50ZWQuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisvLyBBbiBhcmVuYSB3aGlj aCBhbGxvY2F0ZXMgb25seSBQbGFpbiBPbGQgRGF0YSAoUE9EKSwgb3IgY2xhc3NlcyBhbmQKKy8v IHN0cnVjdHMgYm90dG9taW5nIG91dCBpbiBQbGFpbiBPbGQgRGF0YS4gTk9URTogdGhlIGNvbnN0 cnVjdG9ycyBvZgorLy8gdGhlIG9iamVjdHMgYWxsb2NhdGVkIGluIHRoaXMgYXJlbmEgYXJlIGNh bGxlZCwgYnV0IF9ub3RfIHRoZWlyCisvLyBkZXN0cnVjdG9ycy4KKworY2xhc3MgUE9EQXJlbmEg OiBwdWJsaWMgUmVmQ291bnRlZDxQT0RBcmVuYT4geworcHVibGljOgorICAgIC8vIENyZWF0ZXMg YSBuZXcgUE9EQXJlbmEuCisgICAgc3RhdGljIFBhc3NSZWZQdHI8UE9EQXJlbmE+IGNyZWF0ZSgp CisgICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFBPREFyZW5hKTsKKyAgICB9CisK KyAgICAvLyBBbGxvY2F0ZXMgYW4gb2JqZWN0IGZyb20gdGhlIGFyZW5hLgorICAgIHRlbXBsYXRl PGNsYXNzIFQ+CisgICAgVCogYWxsb2MoKQorICAgIHsKKyAgICAgICAgdm9pZCogcHRyID0gMDsK KyAgICAgICAgQVJFTkFfQUxMT0NBVEUocHRyLCAmbV9wb29sLCBzaXplb2YoVCkpOworICAgICAg ICBpZiAocHRyKSB7CisgICAgICAgICAgICAvLyBVc2UgcGxhY2VtZW50IG9wZXJhdG9yIG5ldyB0 byBhbGxvY2F0ZSBhIFQgYXQgdGhpcyBsb2NhdGlvbgorICAgICAgICAgICAgbmV3KHB0cikgVCgp OworICAgICAgICB9CisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxUKj4ocHRyKTsKKyAgICB9 CisKK3ByaXZhdGU6CisgICAgZW51bSB7CisgICAgICAgIERlZmF1bHRBcmVuYVNpemUgPSAxNjM4 NAorICAgIH07CisKKyAgICBQT0RBcmVuYSgpCisgICAgeworICAgICAgICAvLyBJbml0aWFsaXpl IHRoZSBhcmVuYSBwb29sCisgICAgICAgIElOSVRfQVJFTkFfUE9PTCgmbV9wb29sLCAiUE9EQXJl bmEiLCBEZWZhdWx0QXJlbmFTaXplKTsKKyAgICB9CisKKyAgICAvLyBVbmRlcmx5aW5nIGFyZW5h IHBvb2wKKyAgICBBcmVuYVBvb2wgbV9wb29sOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQorCisjZW5kaWYgLy8gUE9EQXJlbmFfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9QT0RSZWRC bGFja1RyZWUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL1BPRFJlZEJsYWNrVHJl ZS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9ybS9QT0RSZWRCbGFja1RyZWUuaAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw3NTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29v Z2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAq IGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMg ZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3Jp dHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhF IENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1J VEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gQSByZWQtYmxhY2sgdHJlZSwgd2hpY2gg aXMgYSBmb3JtIG9mIGEgYmFsYW5jZWQgYmluYXJ5IHRyZWUuIEl0CisvLyBzdXBwb3J0cyBlZmZp Y2llbnQgaW5zZXJ0aW9uLCBkZWxldGlvbiBhbmQgcXVlcmllcyBvZiBjb21wYXJhYmxlCisvLyBl bGVtZW50cy4gVGhlIHNhbWUgZWxlbWVudCBtYXkgYmUgaW5zZXJ0ZWQgbXVsdGlwbGUgdGltZXMu IFRoZQorLy8gYWxnb3JpdGhtaWMgY29tcGxleGl0eSBvZiBjb21tb24gb3BlcmF0aW9ucyBpczoK Ky8vCisvLyAgIEluc2VydGlvbjogTyhsZyhuKSkKKy8vICAgRGVsZXRpb246ICBPKGxnKG4pKQor Ly8gICBRdWVyeWluZzogIE8obGcobikpCisvLworLy8gVGhlIGRhdGEgdHlwZSBUIHRoYXQgaXMg c3RvcmVkIGluIHRoaXMgcmVkLWJsYWNrIHRyZWUgbXVzdCBiZSBvbmx5CisvLyBQbGFpbiBPbGQg RGF0YSAoUE9EKSwgb3IgYm90dG9tIG91dCBpbnRvIFBPRC4gSXQgbXVzdCBfbm90XyByZWx5IG9u CisvLyBoYXZpbmcgaXRzIGRlc3RydWN0b3IgY2FsbGVkLiBUaGlzIGltcGxlbWVudGF0aW9uIGlu dGVybmFsbHkKKy8vIGFsbG9jYXRlcyBzdG9yYWdlIGluIGxhcmdlIGNodW5rcyBhbmQgZG9lcyBu b3QgY2FsbCB0aGUgZGVzdHJ1Y3RvcgorLy8gb24gZWFjaCBvYmplY3QuCisvLworLy8gVHlwZSBU IG11c3Qgc3VwcGx5IGEgZGVmYXVsdCBjb25zdHJ1Y3RvciwgYSBjb3B5IGNvbnN0cnVjdG9yLCBh bmQKKy8vIHRoZSAiPCIgYW5kICI9PSIgb3BlcmF0b3JzLgorLy8KKy8vIEluIGRlYnVnIG1vZGUs IHByaW50aW5nIG9mIHRoZSBkYXRhIGNvbnRhaW5lZCBpbiB0aGUgdHJlZSBpcworLy8gZW5hYmxl ZC4gVGhpcyByZXF1aXJlcyB0aGUgZm9sbG93aW5nIGZ1bmN0aW9uIHRvIGJlIGF2YWlsYWJsZToK Ky8vCisvLyAgIFN0cmluZyB2YWx1ZVRvU3RyaW5nKGNvbnN0IFQmKTsKKy8vCisvLyBOb3RlIHRo YXQgd2hlbiBjb21wbGV4IHR5cGVzIGFyZSBzdG9yZWQgaW4gdGhpcyByZWQvYmxhY2sgdHJlZSwg aXQKKy8vIGlzIHBvc3NpYmxlIHRoYXQgc2luZ2xlIGludm9jYXRpb25zIG9mIHRoZSAiPCIgYW5k ICI9PSIgb3BlcmF0b3JzCisvLyB3aWxsIGJlIGluc3VmZmljaWVudCB0byBkZXNjcmliZSB0aGUg b3JkZXJpbmcgb2YgZWxlbWVudHMgaW4gdGhlCisvLyB0cmVlIGR1cmluZyBxdWVyaWVzLiBBcyBh IGNvbmNyZXRlIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBjYXNlIHdoZXJlCisvLyBpbnRlcnZhbHMg YXJlIHN0b3JlZCBpbiB0aGUgdHJlZSBzb3J0ZWQgYnkgbG93IGVuZHBvaW50LiBUaGUgIjwiCisv LyBvcGVyYXRvciBvbiB0aGUgSW50ZXJ2YWwgY2xhc3Mgb25seSBjb21wYXJlcyB0aGUgbG93IGVu ZHBvaW50LCBidXQKKy8vIHRoZSAiPT0iIG9wZXJhdG9yIHRha2VzIGludG8gYWNjb3VudCB0aGUg aGlnaCBlbmRwb2ludCBhcyB3ZWxsLgorLy8gVGhpcyBtYWtlcyB0aGUgbmVjZXNzYXJ5IGxvZ2lj IGZvciBxdWVyeWluZyBhbmQgZGVsZXRpb24gc29tZXdoYXQKKy8vIG1vcmUgY29tcGxleC4gSW4g b3JkZXIgdG8gcHJvcGVybHkgaGFuZGxlIHN1Y2ggc2l0dWF0aW9ucywgdGhlCisvLyBwcm9wZXJ0 eSAibmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyIgbXVzdCBiZSBzZXQgdG8gdHJ1ZSBvbgor Ly8gdGhlIHRyZWUuCisvLworLy8gVGhpcyByZWQtYmxhY2sgdHJlZSBpcyBkZXNpZ25lZCB0byBi ZSBfYXVnbWVudGVkXzsgc3ViY2xhc3NlcyBjYW4KKy8vIGFkZCBhZGRpdGlvbmFsIGFuZCBzdW1t YXJ5IGluZm9ybWF0aW9uIHRvIGVhY2ggbm9kZSB0byBlZmZpY2llbnRseQorLy8gc3RvcmUgYW5k IGluZGV4IG1vcmUgY29tcGxleCBkYXRhIHN0cnVjdHVyZXMuIEEgY29uY3JldGUgZXhhbXBsZSBp cworLy8gdGhlIEludGVydmFsVHJlZSwgd2hpY2ggZXh0ZW5kcyBlYWNoIG5vZGUgd2l0aCBhIHN1 bW1hcnkgc3RhdGlzdGljCisvLyB0byBlZmZpY2llbnRseSBzdG9yZSBvbmUtZGltZW5zaW9uYWwg aW50ZXJ2YWxzLgorLy8KKy8vIFRoZSBkZXNpZ24gb2YgdGhpcyByZWQtYmxhY2sgdHJlZSBjb21l cyBmcm9tIENvcm1lbiwgTGVpc2Vyc29uLAorLy8gYW5kIFJpdmVzdCwgX0ludHJvZHVjdGlvbiB0 byBBbGdvcml0aG1zXywgTUlUIFByZXNzLCAxOTkwLgorCisjaWZuZGVmIFBPRFJlZEJsYWNrVHJl ZV9oCisjZGVmaW5lIFBPRFJlZEJsYWNrVHJlZV9oCisKKyNpZm5kZWYgTkRFQlVHCisjaW5jbHVk ZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5nLmgiCisjZW5kaWYKKyNpbmNs dWRlICJQT0RBcmVuYS5oIgorI2lmbmRlZiBERUJVRworI2luY2x1ZGUgIlN0cmluZ0J1aWxkZXIu aCIKKyNlbmRpZgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL05v bmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2lmbmRlZiBOREVCVUcKKyNp bmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCit0ZW1wbGF0ZTxjbGFzcyBUPgorY2xhc3MgUE9EUmVkQmxhY2tUcmVlIHsKK3B1YmxpYzoK KyAgICAvLyBWaXNpdG9yIGludGVyZmFjZSBmb3Igd2Fsa2luZyBhbGwgb2YgdGhlIHRyZWUncyBl bGVtZW50cy4KKyAgICBjbGFzcyBWaXNpdG9yIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1 YWwgdm9pZCB2aXNpdChjb25zdCBUJiBkYXRhKSA9IDA7CisgICAgcHJvdGVjdGVkOgorICAgICAg ICB2aXJ0dWFsIH5WaXNpdG9yKCkgeyB9CisgICAgfTsKKworICAgIC8vIENvbnN0cnVjdHMgYSBu ZXcgcmVkLWJsYWNrIHRyZWUsIGFsbG9jYXRpbmcgdGVtcG9yYXJ5IG9iamVjdHMKKyAgICAvLyBm cm9tIGEgbmV3bHkgY29uc3RydWN0ZWQgUE9EQXJlbmEuCisgICAgUE9EUmVkQmxhY2tUcmVlKCkK KyAgICAgICAgOiBtX2FyZW5hKFBPREFyZW5hOjpjcmVhdGUoKSkKKyAgICAgICAgLCBtX3Jvb3Qo MCkKKyAgICAgICAgLCBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMoZmFsc2UpCisjaWZu ZGVmIE5ERUJVRworICAgICAgICAsIG1fdmVyYm9zZURlYnVnZ2luZyhmYWxzZSkKKyNlbmRpZgor ICAgIHsKKyAgICB9CisKKyAgICAvLyBDb25zdHJ1Y3RzIGEgbmV3IHJlZC1ibGFjayB0cmVlLCBh bGxvY2F0aW5nIHRlbXBvcmFyeSBvYmplY3RzCisgICAgLy8gZnJvbSB0aGUgZ2l2ZW4gUE9EQXJl bmEuCisgICAgZXhwbGljaXQgUE9EUmVkQmxhY2tUcmVlKFBPREFyZW5hKiBhcmVuYSkKKyAgICAg ICAgOiBtX2FyZW5hKGFyZW5hKQorICAgICAgICAsIG1fcm9vdCgwKQorICAgICAgICAsIG1fbmVl ZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyhmYWxzZSkKKyNpZm5kZWYgTkRFQlVHCisgICAgICAg ICwgbV92ZXJib3NlRGVidWdnaW5nKGZhbHNlKQorI2VuZGlmCisgICAgeworICAgIH0KKworICAg IHZpcnR1YWwgflBPRFJlZEJsYWNrVHJlZSgpIHsgfQorCisgICAgdm9pZCBpbnNlcnQoY29uc3Qg VCYgZGF0YSkKKyAgICB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBuZXcgTm9kZShkYXRhKTsKKyAg ICAgICAgaW5zZXJ0Tm9kZShub2RlKTsKKyAgICB9CisKKyAgICAvLyBSZW1vdmVzIHRoZSBnaXZl biBkYXR1bSBmcm9tIHRoZSB0cmVlLiBSZXR1cm5zIHRydWUgaWYgdGhlIGRhdHVtCisgICAgLy8g d2FzIGZvdW5kIGluIHRoZSB0cmVlLgorICAgIGJvb2wgcmVtb3ZlKGNvbnN0IFQmIGRhdGEpCisg ICAgeworICAgICAgICBOb2RlKiBub2RlID0gdHJlZVNlYXJjaChkYXRhKTsKKyAgICAgICAgaWYg KG5vZGUpIHsKKyAgICAgICAgICAgIGRlbGV0ZU5vZGUobm9kZSk7CisgICAgICAgICAgICByZXR1 cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAg Ym9vbCBjb250YWlucyhjb25zdCBUJiBkYXRhKSB7IHJldHVybiB0cmVlU2VhcmNoKGRhdGEpOyB9 CisKKyAgICB2b2lkIHZpc2l0SW5vcmRlcihWaXNpdG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAg ICAgaWYgKCFtX3Jvb3QpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIHZpc2l0SW5vcmRl ckltcGwobV9yb290LCB2aXNpdG9yKTsKKyAgICB9CisKKyAgICBpbnQgbnVtRWxlbWVudHMoKQor ICAgIHsKKyAgICAgICAgQ291bnRlciBjb3VudGVyOworICAgICAgICB2aXNpdElub3JkZXIoJmNv dW50ZXIpOworICAgICAgICByZXR1cm4gY291bnRlci5jb3VudCgpOworICAgIH0KKworICAgIC8v IFNlZSB0aGUgY2xhc3MgZG9jdW1lbnRhdGlvbiBmb3IgYW4gZXhwbGFuYXRpb24gb2YgdGhpcyBw cm9wZXJ0eS4KKyAgICB2b2lkIHNldE5lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMoYm9vbCBu ZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKQorICAgIHsKKyAgICAgICAgbV9uZWVkc0Z1bGxP cmRlcmluZ0NvbXBhcmlzb25zID0gbmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29uczsKKyAgICB9 CisKKyAgICB2aXJ0dWFsIGJvb2wgY2hlY2tJbnZhcmlhbnRzKCkKKyAgICB7CisgICAgICAgIGlu dCBibGFja0NvdW50OworICAgICAgICByZXR1cm4gY2hlY2tJbnZhcmlhbnRzRnJvbU5vZGUobV9y b290LCAmYmxhY2tDb3VudCk7CisgICAgfQorCisjaWZuZGVmIE5ERUJVRworICAgIC8vIER1bXBz IHRoZSB0cmVlJ3MgY29udGVudHMgdG8gdGhlIGxvZ2dpbmcgaW5mbyBzdHJlYW0gZm9yCisgICAg Ly8gZGVidWdnaW5nIHB1cnBvc2VzLgorICAgIHZvaWQgZHVtcCgpCisgICAgeworICAgICAgICBk dW1wRnJvbU5vZGUobV9yb290LCAwKTsKKyAgICB9CisKKyAgICAvLyBUdXJucyBvbiBvciBvZmYg dmVyYm9zZSBkZWJ1Z2dpbmcgb2YgdGhlIHRyZWUsIGNhdXNpbmcgbWFueQorICAgIC8vIG1lc3Nh Z2VzIHRvIGJlIGxvZ2dlZCBkdXJpbmcgaW5zZXJ0aW9uIGFuZCBvdGhlciBvcGVyYXRpb25zIGlu CisgICAgLy8gZGVidWcgbW9kZS4KKyAgICB2b2lkIHNldFZlcmJvc2VEZWJ1Z2dpbmcoYm9vbCBv bk9yT2ZmKQorICAgIHsKKyAgICAgICAgbV92ZXJib3NlRGVidWdnaW5nID0gb25Pck9mZjsKKyAg ICB9CisjZW5kaWYKKworcHJvdGVjdGVkOgorICAgIGVudW0gQ29sb3IgeworICAgICAgICBrUmVk ID0gMSwKKyAgICAgICAga0JsYWNrCisgICAgfTsKKworICAgIC8vIFRoZSBiYXNlIE5vZGUgY2xh c3Mgd2hpY2ggaXMgc3RvcmVkIGluIHRoZSB0cmVlLiBOb2RlcyBhcmUgb25seQorICAgIC8vIGFu IGludGVybmFsIGNvbmNlcHQ7IHVzZXJzIG9mIHRoZSB0cmVlIGRlYWwgb25seSB3aXRoIHRoZSBk YXRhCisgICAgLy8gdGhleSBzdG9yZSBpbiBpdC4KKyAgICBjbGFzcyBOb2RlIDogcHVibGljIE5v bmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIC8vIENvbnN0cnVjdG9yLiBOZXdseS1j cmVhdGVkIG5vZGVzIGFyZSBjb2xvcmVkIHJlZC4KKyAgICAgICAgZXhwbGljaXQgTm9kZShjb25z dCBUJiBkYXRhKQorICAgICAgICAgICAgOiBtX2xlZnQoMCkKKyAgICAgICAgICAgICwgbV9yaWdo dCgwKQorICAgICAgICAgICAgLCBtX3BhcmVudCgwKQorICAgICAgICAgICAgLCBtX2NvbG9yKGtS ZWQpCisgICAgICAgICAgICAsIG1fZGF0YShkYXRhKQorICAgICAgICB7CisgICAgICAgIH0KKwor ICAgICAgICB2aXJ0dWFsIH5Ob2RlKCkgeyB9CisKKyAgICAgICAgQ29sb3IgY29sb3IoKSBjb25z dCB7IHJldHVybiBtX2NvbG9yOyB9CisgICAgICAgIHZvaWQgc2V0Q29sb3IoQ29sb3IgY29sb3Ip IHsgbV9jb2xvciA9IGNvbG9yOyB9CisKKyAgICAgICAgLy8gRmV0Y2hlcyB0aGUgdXNlciBkYXRh LgorICAgICAgICBUJiBkYXRhKCkgeyByZXR1cm4gbV9kYXRhOyB9CisKKyAgICAgICAgLy8gQ29w aWVzIGFsbCB1c2VyLWxldmVsIGZpZWxkcyBmcm9tIHRoZSBzb3VyY2Ugbm9kZSwgYnV0IG5vdAor ICAgICAgICAvLyBpbnRlcm5hbCBmaWVsZHMuIEZvciBleGFtcGxlLCB0aGUgYmFzZSBpbXBsZW1l bnRhdGlvbiBvZiB0aGlzCisgICAgICAgIC8vIG1ldGhvZCBjb3BpZXMgdGhlICJtX2RhdGEiIGZp ZWxkLCBidXQgbm90IHRoZSBjaGlsZCBvciBwYXJlbnQKKyAgICAgICAgLy8gZmllbGRzLiBBbnkg YXVnbWVudGF0aW9uIGluZm9ybWF0aW9uIGFsc28gZG9lcyBub3QgbmVlZCB0byBiZQorICAgICAg ICAvLyBjb3BpZWQsIGFzIGl0IHdpbGwgYmUgcmVjb21wdXRlZC4gU3ViY2xhc3NlcyBtdXN0IGNh bGwgdGhlCisgICAgICAgIC8vIHN1cGVyY2xhc3MgaW1wbGVtZW50YXRpb24uCisgICAgICAgIHZp cnR1YWwgdm9pZCBjb3B5RnJvbShOb2RlKiBzcmMpIHsgbV9kYXRhID0gc3JjLT5kYXRhKCk7IH0K KworICAgICAgICBOb2RlKiBsZWZ0KCkgY29uc3QgeyByZXR1cm4gbV9sZWZ0OyB9CisgICAgICAg IHZvaWQgc2V0TGVmdChOb2RlKiBub2RlKSB7IG1fbGVmdCA9IG5vZGU7IH0KKworICAgICAgICBO b2RlKiByaWdodCgpIGNvbnN0IHsgcmV0dXJuIG1fcmlnaHQ7IH0KKyAgICAgICAgdm9pZCBzZXRS aWdodChOb2RlKiBub2RlKSB7IG1fcmlnaHQgPSBub2RlOyB9CisKKyAgICAgICAgTm9kZSogcGFy ZW50KCkgY29uc3QgeyByZXR1cm4gbV9wYXJlbnQ7IH0KKyAgICAgICAgdm9pZCBzZXRQYXJlbnQo Tm9kZSogbm9kZSkgeyBtX3BhcmVudCA9IG5vZGU7IH0KKworICAgIHByaXZhdGU6CisgICAgICAg IE5vZGUqIG1fbGVmdDsKKyAgICAgICAgTm9kZSogbV9yaWdodDsKKyAgICAgICAgTm9kZSogbV9w YXJlbnQ7CisgICAgICAgIENvbG9yIG1fY29sb3I7CisgICAgICAgIFQgbV9kYXRhOworICAgIH07 CisKKyAgICAvLyBSZXR1cm5zIHRoZSByb290IG9mIHRoZSB0cmVlLCB3aGljaCBpcyBuZWVkZWQg Ynkgc29tZSBzdWJjbGFzc2VzLgorICAgIE5vZGUqIHJvb3QoKSBjb25zdCB7IHJldHVybiBtX3Jv b3Q7IH0KKworcHJpdmF0ZToKKyAgICAvLyBUaGlzIHZpcnR1YWwgbWV0aG9kIGlzIHRoZSBob29r IHRoYXQgc3ViY2xhc3NlcyBzaG91bGQgdXNlIHdoZW4KKyAgICAvLyBhdWdtZW50aW5nIHRoZSBy ZWQtYmxhY2sgdHJlZSB3aXRoIGFkZGl0aW9uYWwgcGVyLW5vZGUgc3VtbWFyeQorICAgIC8vIGlu Zm9ybWF0aW9uLiBGb3IgZXhhbXBsZSwgaW4gdGhlIGNhc2Ugb2YgYW4gaW50ZXJ2YWwgdHJlZSwg dGhpcworICAgIC8vIGlzIHVzZWQgdG8gY29tcHV0ZSB0aGUgbWF4aW11bSBlbmRwb2ludCBvZiB0 aGUgc3VidHJlZSBiZWxvdyB0aGUKKyAgICAvLyBnaXZlbiBub2RlIGJhc2VkIG9uIHRoZSB2YWx1 ZXMgaW4gdGhlIGxlZnQgYW5kIHJpZ2h0IGNoaWxkcmVuLiBJdAorICAgIC8vIGlzIGd1YXJhbnRl ZWQgdGhhdCB0aGlzIHdpbGwgYmUgY2FsbGVkIGluIHRoZSBjb3JyZWN0IG9yZGVyIHRvCisgICAg Ly8gcHJvcGVybHkgdXBkYXRlIHN1Y2ggc3VtbWFyeSBpbmZvcm1hdGlvbiBiYXNlZCBvbmx5IG9u IHRoZSB2YWx1ZXMKKyAgICAvLyBpbiB0aGUgbGVmdCBhbmQgcmlnaHQgY2hpbGRyZW4uIFRoaXMg bWV0aG9kIHNob3VsZCByZXR1cm4gdHJ1ZSBpZgorICAgIC8vIHRoZSBub2RlJ3Mgc3VtbWFyeSBp bmZvcm1hdGlvbiBjaGFuZ2VkLgorICAgIHZpcnR1YWwgYm9vbCB1cGRhdGVOb2RlKE5vZGUqIG5v ZGUpIHsgcmV0dXJuIGZhbHNlOyB9CisKKyAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBHZW5l cmljIGJpbmFyeSBzZWFyY2ggdHJlZSBvcGVyYXRpb25zCisgICAgLy8KKworICAgIC8vIFNlYXJj aGVzIHRoZSB0cmVlIGZvciB0aGUgZ2l2ZW4gZGF0dW0uCisgICAgTm9kZSogdHJlZVNlYXJjaChj b25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgaWYgKG1fbmVlZHNGdWxsT3JkZXJpbmdDb21w YXJpc29ucykKKyAgICAgICAgICAgIHJldHVybiB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKG1f cm9vdCwgZGF0YSk7CisKKyAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hOb3JtYWwobV9yb290LCBk YXRhKTsKKyAgICB9CisKKyAgICAvLyBTZWFyY2hlcyB0aGUgdHJlZSB1c2luZyB0aGUgbm9ybWFs IGNvbXBhcmlzb24gb3BlcmF0aW9ucywKKyAgICAvLyBzdWl0YWJsZSBmb3Igc2ltcGxlIGRhdGEg dHlwZXMgc3VjaCBhcyBudW1iZXJzLgorICAgIE5vZGUqIHRyZWVTZWFyY2hOb3JtYWwoTm9kZSog Y3VycmVudCwgY29uc3QgVCYgZGF0YSkKKyAgICB7CisgICAgICAgIHdoaWxlIChjdXJyZW50KSB7 CisgICAgICAgICAgICBpZiAoY3VycmVudC0+ZGF0YSgpID09IGRhdGEpCisgICAgICAgICAgICAg ICAgcmV0dXJuIGN1cnJlbnQ7CisgICAgICAgICAgICBpZiAoZGF0YSA8IGN1cnJlbnQtPmRhdGEo KSkKKyAgICAgICAgICAgICAgICBjdXJyZW50ID0gY3VycmVudC0+bGVmdCgpOworICAgICAgICAg ICAgZWxzZQorICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50LT5yaWdodCgpOworICAg ICAgICB9CisgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIC8vIFNlYXJjaGVzIHRoZSB0 cmVlIHVzaW5nIG11bHRpcGxlIGNvbXBhcmlzb24gb3BlcmF0aW9ucywgcmVxdWlyZWQKKyAgICAv LyBmb3IgZGF0YSB0eXBlcyB3aXRoIG1vcmUgY29tcGxleCBiZWhhdmlvciBzdWNoIGFzIGludGVy dmFscy4KKyAgICBOb2RlKiB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKE5vZGUqIGN1cnJlbnQs IGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICBpZiAoIWN1cnJlbnQpCisgICAgICAgICAg ICByZXR1cm4gMDsKKyAgICAgICAgaWYgKGRhdGEgPCBjdXJyZW50LT5kYXRhKCkpCisgICAgICAg ICAgICByZXR1cm4gdHJlZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhjdXJyZW50LT5sZWZ0KCksIGRh dGEpOworICAgICAgICBpZiAoY3VycmVudC0+ZGF0YSgpIDwgZGF0YSkKKyAgICAgICAgICAgIHJl dHVybiB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKGN1cnJlbnQtPnJpZ2h0KCksIGRhdGEpOwor ICAgICAgICBpZiAoZGF0YSA9PSBjdXJyZW50LT5kYXRhKCkpCisgICAgICAgICAgICByZXR1cm4g Y3VycmVudDsKKworICAgICAgICAvLyBXZSBtYXkgbmVlZCB0byB0cmF2ZXJzZSBib3RoIHRoZSBs ZWZ0IGFuZCByaWdodCBzdWJ0cmVlcy4KKyAgICAgICAgTm9kZSogcmVzdWx0ID0gdHJlZVNlYXJj aEZ1bGxDb21wYXJpc29ucyhjdXJyZW50LT5sZWZ0KCksIGRhdGEpOworICAgICAgICBpZiAoIXJl c3VsdCkKKyAgICAgICAgICAgIHJlc3VsdCA9IHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoY3Vy cmVudC0+cmlnaHQoKSwgZGF0YSk7CisgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgfQorCisg ICAgdm9pZCB0cmVlSW5zZXJ0KE5vZGUqIHopCisgICAgeworICAgICAgICBOb2RlKiB5ID0gMDsK KyAgICAgICAgTm9kZSogeCA9IG1fcm9vdDsKKyAgICAgICAgd2hpbGUgKHgpIHsKKyAgICAgICAg ICAgIHkgPSB4OworICAgICAgICAgICAgaWYgKHotPmRhdGEoKSA8IHgtPmRhdGEoKSkKKyAgICAg ICAgICAgICAgICB4ID0geC0+bGVmdCgpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAg ICAgIHggPSB4LT5yaWdodCgpOworICAgICAgICB9CisgICAgICAgIHotPnNldFBhcmVudCh5KTsK KyAgICAgICAgaWYgKCF5KQorICAgICAgICAgICAgbV9yb290ID0gejsKKyAgICAgICAgZWxzZSB7 CisgICAgICAgICAgICBpZiAoei0+ZGF0YSgpIDwgeS0+ZGF0YSgpKQorICAgICAgICAgICAgICAg IHktPnNldExlZnQoeik7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeS0+c2V0 UmlnaHQoeik7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAvLyBGaW5kcyB0aGUgbm9kZSBmb2xs b3dpbmcgdGhlIGdpdmVuIG9uZSBpbiBzZXF1ZW50aWFsIG9yZGVyaW5nIG9mCisgICAgLy8gdGhl aXIgZGF0YSwgb3IgbnVsbCBpZiBub25lIGV4aXN0cy4KKyAgICBOb2RlKiB0cmVlU3VjY2Vzc29y KE5vZGUqIHgpCisgICAgeworICAgICAgICBpZiAoeC0+cmlnaHQoKSkKKyAgICAgICAgICAgIHJl dHVybiB0cmVlTWluaW11bSh4LT5yaWdodCgpKTsKKyAgICAgICAgTm9kZSogeSA9IHgtPnBhcmVu dCgpOworICAgICAgICB3aGlsZSAoeSAmJiB4ID09IHktPnJpZ2h0KCkpIHsKKyAgICAgICAgICAg IHggPSB5OworICAgICAgICAgICAgeSA9IHktPnBhcmVudCgpOworICAgICAgICB9CisgICAgICAg IHJldHVybiB5OworICAgIH0KKworICAgIC8vIEZpbmRzIHRoZSBtaW5pbXVtIGVsZW1lbnQgaW4g dGhlIHN1Yi10cmVlIHJvb3RlZCBhdCB0aGUgZ2l2ZW4KKyAgICAvLyBub2RlLgorICAgIE5vZGUq IHRyZWVNaW5pbXVtKE5vZGUqIHgpCisgICAgeworICAgICAgICB3aGlsZSAoeC0+bGVmdCgpKQor ICAgICAgICAgICAgeCA9IHgtPmxlZnQoKTsKKyAgICAgICAgcmV0dXJuIHg7CisgICAgfQorCisg ICAgLy8gSGVscGVyIGZvciBtYWludGFpbmluZyB0aGUgYXVnbWVudGVkIHJlZC1ibGFjayB0cmVl LgorICAgIHZvaWQgcHJvcGFnYXRlVXBkYXRlcyhOb2RlKiBzdGFydCkKKyAgICB7CisgICAgICAg IGJvb2wgc2hvdWxkQ29udGludWUgPSB0cnVlOworICAgICAgICB3aGlsZSAoc3RhcnQgJiYgc2hv dWxkQ29udGludWUpIHsKKyAgICAgICAgICAgIHNob3VsZENvbnRpbnVlID0gdXBkYXRlTm9kZShz dGFydCk7CisgICAgICAgICAgICBzdGFydCA9IHN0YXJ0LT5wYXJlbnQoKTsKKyAgICAgICAgfQor ICAgIH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIFJlZC1CbGFjayB0cmVlIG9wZXJh dGlvbnMKKyAgICAvLworCisgICAgLy8gTGVmdC1yb3RhdGVzIHRoZSBzdWJ0cmVlIHJvb3RlZCBh dCB4LgorICAgIHZvaWQgbGVmdFJvdGF0ZShOb2RlKiB4KQorICAgIHsKKyAgICAgICAgLy8gU2V0 IHkuCisgICAgICAgIE5vZGUqIHkgPSB4LT5yaWdodCgpOworICAgICAgICAvLyBUdXJuIHkncyBs ZWZ0IHN1YnRyZWUgaW50byB4J3MgcmlnaHQgc3VidHJlZS4KKyAgICAgICAgeC0+c2V0UmlnaHQo eS0+bGVmdCgpKTsKKyAgICAgICAgaWYgKHktPmxlZnQoKSkKKyAgICAgICAgICAgIHktPmxlZnQo KS0+c2V0UGFyZW50KHgpOworICAgICAgICAvLyBMaW5rIHgncyBwYXJlbnQgdG8geS4KKyAgICAg ICAgeS0+c2V0UGFyZW50KHgtPnBhcmVudCgpKTsKKyAgICAgICAgaWYgKCF4LT5wYXJlbnQoKSkK KyAgICAgICAgICAgIG1fcm9vdCA9IHk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgaWYg KHggPT0geC0+cGFyZW50KCktPmxlZnQoKSkKKyAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+ c2V0TGVmdCh5KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB4LT5wYXJlbnQo KS0+c2V0UmlnaHQoeSk7CisgICAgICAgIH0KKyAgICAgICAgLy8gUHV0IHggb24geSdzIGxlZnQu CisgICAgICAgIHktPnNldExlZnQoeCk7CisgICAgICAgIHgtPnNldFBhcmVudCh5KTsKKyAgICAg ICAgLy8gVXBkYXRlIG5vZGVzIGxvd2VzdCB0byBoaWdoZXN0LgorICAgICAgICB1cGRhdGVOb2Rl KHgpOworICAgICAgICB1cGRhdGVOb2RlKHkpOworICAgIH0KKworICAgIC8vIFJpZ2h0LXJvdGF0 ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHkuCisgICAgdm9pZCByaWdodFJvdGF0ZShOb2RlKiB5 KQorICAgIHsKKyAgICAgICAgLy8gU2V0IHguCisgICAgICAgIE5vZGUqIHggPSB5LT5sZWZ0KCk7 CisgICAgICAgIC8vIFR1cm4geCdzIHJpZ2h0IHN1YnRyZWUgaW50byB5J3MgbGVmdCBzdWJ0cmVl LgorICAgICAgICB5LT5zZXRMZWZ0KHgtPnJpZ2h0KCkpOworICAgICAgICBpZiAoeC0+cmlnaHQo KSkKKyAgICAgICAgICAgIHgtPnJpZ2h0KCktPnNldFBhcmVudCh5KTsKKyAgICAgICAgLy8gTGlu ayB5J3MgcGFyZW50IHRvIHguCisgICAgICAgIHgtPnNldFBhcmVudCh5LT5wYXJlbnQoKSk7Cisg ICAgICAgIGlmICgheS0+cGFyZW50KCkpCisgICAgICAgICAgICBtX3Jvb3QgPSB4OworICAgICAg ICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh5ID09IHktPnBhcmVudCgpLT5sZWZ0KCkpCisgICAg ICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldExlZnQoeCk7CisgICAgICAgICAgICBlbHNlCisg ICAgICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldFJpZ2h0KHgpOworICAgICAgICB9CisgICAg ICAgIC8vIFB1dCB5IG9uIHgncyByaWdodC4KKyAgICAgICAgeC0+c2V0UmlnaHQoeSk7CisgICAg ICAgIHktPnNldFBhcmVudCh4KTsKKyAgICAgICAgLy8gVXBkYXRlIG5vZGVzIGxvd2VzdCB0byBo aWdoZXN0LgorICAgICAgICB1cGRhdGVOb2RlKHkpOworICAgICAgICB1cGRhdGVOb2RlKHgpOwor ICAgIH0KKworICAgIC8vIEluc2VydHMgdGhlIGdpdmVuIG5vZGUgaW50byB0aGUgdHJlZS4KKyAg ICB2b2lkIGluc2VydE5vZGUoTm9kZSogeCkKKyAgICB7CisgICAgICAgIHRyZWVJbnNlcnQoeCk7 CisgICAgICAgIHgtPnNldENvbG9yKGtSZWQpOworICAgICAgICB1cGRhdGVOb2RlKHgpOworCisj aWZuZGVmIE5ERUJVRworICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAg ICAgTE9HX0VSUk9SKCIgIFBPRFJlZEJsYWNrVHJlZTo6SW5zZXJ0Tm9kZSIpOworI2VuZGlmCisK KyAgICAgICAgLy8gVGhlIG5vZGUgZnJvbSB3aGljaCB0byBzdGFydCBwcm9wYWdhdGluZyB1cGRh dGVzIHVwd2FyZHMuCisgICAgICAgIE5vZGUqIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisK KyAgICAgICAgd2hpbGUgKHggIT0gbV9yb290ICYmIHgtPnBhcmVudCgpLT5jb2xvcigpID09IGtS ZWQpIHsKKyAgICAgICAgICAgIGlmICh4LT5wYXJlbnQoKSA9PSB4LT5wYXJlbnQoKS0+cGFyZW50 KCktPmxlZnQoKSkgeworICAgICAgICAgICAgICAgIE5vZGUqIHkgPSB4LT5wYXJlbnQoKS0+cGFy ZW50KCktPnJpZ2h0KCk7CisgICAgICAgICAgICAgICAgaWYgKHkgJiYgeS0+Y29sb3IoKSA9PSBr UmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorI2lmbmRlZiBOREVCVUcKKyAg ICAgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2luZykKKyAgICAgICAgICAgICAg ICAgICAgICAgIExPR19FUlJPUigiICBDYXNlIDEvMSIpOworI2VuZGlmCisgICAgICAgICAgICAg ICAgICAgIHgtPnBhcmVudCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAg ICB5LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+ cGFyZW50KCktPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVOb2Rl KHgtPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpLT5wYXJl bnQoKTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAgICAgICAgICAg ICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2Ug eworICAgICAgICAgICAgICAgICAgICBpZiAoeCA9PSB4LT5wYXJlbnQoKS0+cmlnaHQoKSkgewor I2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1 Z2dpbmcpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgTE9HX0VSUk9SKCIgIENhc2UgMS8y Iik7CisjZW5kaWYKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAg ICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAgICAg bGVmdFJvdGF0ZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAg ICAvLyBDYXNlIDMKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgIGlmIChtX3Zl cmJvc2VEZWJ1Z2dpbmcpCisgICAgICAgICAgICAgICAgICAgICAgICBMT0dfRVJST1IoIiAgQ2Fz ZSAxLzMiKTsKKyNlbmRpZgorICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29s b3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnBhcmVudCgpLT5z ZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeC0+cGFyZW50 KCktPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJl bnQoKS0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgICAgICAvLyBTYW1lIGFzICJ0aGVuIiBjbGF1c2Ugd2l0aCAicmlnaHQiIGFu ZCAibGVmdCIgZXhjaGFuZ2VkLgorICAgICAgICAgICAgICAgIE5vZGUqIHkgPSB4LT5wYXJlbnQo KS0+cGFyZW50KCktPmxlZnQoKTsKKyAgICAgICAgICAgICAgICBpZiAoeSAmJiB5LT5jb2xvcigp ID09IGtSZWQpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAxCisjaWZuZGVmIE5ERUJV RworICAgICAgICAgICAgICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAg ICAgICAgICAgICAgICAgTE9HX0VSUk9SKCIgIENhc2UgMi8xIik7CisjZW5kaWYKKyAgICAgICAg ICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAg ICAgICAgIHktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVu dCgpLT5wYXJlbnQoKS0+c2V0Q29sb3Ioa1JlZCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0 ZU5vZGUoeC0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB4ID0geC0+cGFyZW50KCkt PnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVOb2RlKHgpOworICAgICAgICAg ICAgICAgICAgICB1cGRhdGVTdGFydCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0g ZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGlmICh4ID09IHgtPnBhcmVudCgpLT5sZWZ0KCkp IHsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorI2lmbmRlZiBOREVCVUcKKyAg ICAgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dpbmcpCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgTE9HX0VSUk9SKCIgIENhc2UgMi8yIik7CisjZW5kaWYKKyAgICAg ICAgICAgICAgICAgICAgICAgIHggPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAg ICAgIHJpZ2h0Um90YXRlKHgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgICAgIC8vIENhc2UgMworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAgICAgICAgICAgaWYg KG1fdmVyYm9zZURlYnVnZ2luZykKKyAgICAgICAgICAgICAgICAgICAgICAgIExPR19FUlJPUigi ICBDYXNlIDIvMyIpOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5z ZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50 KCktPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICBsZWZ0Um90YXRlKHgtPnBh cmVudCgpLT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0ID0geC0+ cGFyZW50KCktPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorCisgICAgICAgIHByb3BhZ2F0ZVVwZGF0ZXModXBkYXRlU3RhcnQpOworCisgICAg ICAgIG1fcm9vdC0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICB9CisKKyAgICAvLyBSZXN0b3JlcyB0 aGUgcmVkLWJsYWNrIHByb3BlcnR5IHRvIHRoZSB0cmVlIGFmdGVyIHNwbGljaW5nIG91dAorICAg IC8vIGEgbm9kZS4gTm90ZSB0aGF0IHggbWF5IGJlIG51bGwsIHdoaWNoIGlzIHdoeSB4UGFyZW50 IG11c3QgYmUKKyAgICAvLyBzdXBwbGllZC4KKyAgICB2b2lkIGRlbGV0ZUZpeHVwKE5vZGUqIHgs IE5vZGUqIHhQYXJlbnQpCisgICAgeworICAgICAgICB3aGlsZSAoeCAhPSBtX3Jvb3QgJiYgKCF4 IHx8IHgtPmNvbG9yKCkgPT0ga0JsYWNrKSkgeworICAgICAgICAgICAgaWYgKHggPT0geFBhcmVu dC0+bGVmdCgpKSB7CisgICAgICAgICAgICAgICAgLy8gTm90ZTogdGhlIHRleHQgcG9pbnRzIG91 dCB0aGF0IHcgY2FuIG5vdCBiZSBudWxsLgorICAgICAgICAgICAgICAgIC8vIFRoZSByZWFzb24g aXMgbm90IG9idmlvdXMgZnJvbSBzaW1wbHkgbG9va2luZyBhdAorICAgICAgICAgICAgICAgIC8v IHRoZSBjb2RlOyBpdCBjb21lcyBhYm91dCBmcm9tIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZQorICAg ICAgICAgICAgICAgIC8vIHJlZC1ibGFjayB0cmVlLgorICAgICAgICAgICAgICAgIE5vZGUqIHcg PSB4UGFyZW50LT5yaWdodCgpOworICAgICAgICAgICAgICAgIEFTU0VSVCh3KTsgLy8geCdzIHNp Ymxpbmcgc2hvdWxkIG5vdCBiZSBudWxsLgorICAgICAgICAgICAgICAgIGlmICh3LT5jb2xvcigp ID09IGtSZWQpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAxCisgICAgICAgICAgICAg ICAgICAgIHctPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQt PnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICBsZWZ0Um90YXRlKHhQYXJlbnQp OworICAgICAgICAgICAgICAgICAgICB3ID0geFBhcmVudC0+cmlnaHQoKTsKKyAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICAgICAgaWYgKCghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29s b3IoKSA9PSBrQmxhY2spCisgICAgICAgICAgICAgICAgICAgICYmICghdy0+cmlnaHQoKSB8fCB3 LT5yaWdodCgpLT5jb2xvcigpID09IGtCbGFjaykpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8g Q2FzZSAyCisgICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKGtSZWQpOworICAgICAgICAg ICAgICAgICAgICB4ID0geFBhcmVudDsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudCA9IHgt PnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAg IGlmICghdy0+cmlnaHQoKSB8fCB3LT5yaWdodCgpLT5jb2xvcigpID09IGtCbGFjaykgeworICAg ICAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAzCisgICAgICAgICAgICAgICAgICAgICAgICB3 LT5sZWZ0KCktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgICAgICB3LT5z ZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJpZ2h0Um90YXRlKHcpOwor ICAgICAgICAgICAgICAgICAgICAgICAgdyA9IHhQYXJlbnQtPnJpZ2h0KCk7CisgICAgICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSA0CisgICAgICAgICAgICAg ICAgICAgIHctPnNldENvbG9yKHhQYXJlbnQtPmNvbG9yKCkpOworICAgICAgICAgICAgICAgICAg ICB4UGFyZW50LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICBpZiAody0+ cmlnaHQoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIHctPnJpZ2h0KCktPnNldENvbG9yKGtC bGFjayk7CisgICAgICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUoeFBhcmVudCk7CisgICAgICAg ICAgICAgICAgICAgIHggPSBtX3Jvb3Q7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4 LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAg ICAgICAgICAgICAgIC8vIFNhbWUgYXMgInRoZW4iIGNsYXVzZSB3aXRoICJyaWdodCIgYW5kICJs ZWZ0IgorICAgICAgICAgICAgICAgIC8vIGV4Y2hhbmdlZC4KKworICAgICAgICAgICAgICAgIC8v IE5vdGU6IHRoZSB0ZXh0IHBvaW50cyBvdXQgdGhhdCB3IGNhbiBub3QgYmUgbnVsbC4KKyAgICAg ICAgICAgICAgICAvLyBUaGUgcmVhc29uIGlzIG5vdCBvYnZpb3VzIGZyb20gc2ltcGx5IGxvb2tp bmcgYXQKKyAgICAgICAgICAgICAgICAvLyB0aGUgY29kZTsgaXQgY29tZXMgYWJvdXQgZnJvbSB0 aGUgcHJvcGVydGllcyBvZiB0aGUKKyAgICAgICAgICAgICAgICAvLyByZWQtYmxhY2sgdHJlZS4K KyAgICAgICAgICAgICAgICBOb2RlKiB3ID0geFBhcmVudC0+bGVmdCgpOworICAgICAgICAgICAg ICAgIEFTU0VSVCh3KTsgLy8geCdzIHNpYmxpbmcgc2hvdWxkIG5vdCBiZSBudWxsLgorICAgICAg ICAgICAgICAgIGlmICh3LT5jb2xvcigpID09IGtSZWQpIHsKKyAgICAgICAgICAgICAgICAgICAg Ly8gQ2FzZSAxCisgICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKGtCbGFjayk7CisgICAg ICAgICAgICAgICAgICAgIHhQYXJlbnQtPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAg ICAgICByaWdodFJvdGF0ZSh4UGFyZW50KTsKKyAgICAgICAgICAgICAgICAgICAgdyA9IHhQYXJl bnQtPmxlZnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgaWYgKCghdy0+ cmlnaHQoKSB8fCB3LT5yaWdodCgpLT5jb2xvcigpID09IGtCbGFjaykKKyAgICAgICAgICAgICAg ICAgICAgJiYgKCF3LT5sZWZ0KCkgfHwgdy0+bGVmdCgpLT5jb2xvcigpID09IGtCbGFjaykpIHsK KyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAyCisgICAgICAgICAgICAgICAgICAgIHctPnNl dENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICB4ID0geFBhcmVudDsKKyAgICAgICAg ICAgICAgICAgICAgeFBhcmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICAgICAgICAgIGlmICghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29s b3IoKSA9PSBrQmxhY2spIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMworICAg ICAgICAgICAgICAgICAgICAgICAgdy0+cmlnaHQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAg ICAgICAgbGVmdFJvdGF0ZSh3KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50 LT5sZWZ0KCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgLy8g Q2FzZSA0CisgICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKHhQYXJlbnQtPmNvbG9yKCkp OworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihrQmxhY2spOworICAgICAg ICAgICAgICAgICAgICBpZiAody0+bGVmdCgpKQorICAgICAgICAgICAgICAgICAgICAgICAgdy0+ bGVmdCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICByaWdodFJvdGF0 ZSh4UGFyZW50KTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IG1fcm9vdDsKKyAgICAgICAgICAg ICAgICAgICAgeFBhcmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBpZiAoeCkKKyAgICAgICAgICAgIHgtPnNldENv bG9yKGtCbGFjayk7CisgICAgfQorCisgICAgLy8gRGVsZXRlcyB0aGUgZ2l2ZW4gbm9kZSBmcm9t IHRoZSB0cmVlLiBOb3RlIHRoYXQgdGhpcworICAgIC8vIHBhcnRpY3VsYXIgbm9kZSBtYXkgbm90 IGFjdHVhbGx5IGJlIHJlbW92ZWQgZnJvbSB0aGUgdHJlZTsKKyAgICAvLyBpbnN0ZWFkLCBhbm90 aGVyIG5vZGUgbWlnaHQgYmUgcmVtb3ZlZCBhbmQgaXRzIGNvbnRlbnRzCisgICAgLy8gY29waWVk IGludG8gei4KKyAgICB2b2lkIGRlbGV0ZU5vZGUoTm9kZSogeikKKyAgICB7CisgICAgICAgIC8v IFkgaXMgdGhlIG5vZGUgdG8gYmUgdW5saW5rZWQgZnJvbSB0aGUgdHJlZS4KKyAgICAgICAgTm9k ZSogeTsKKyAgICAgICAgaWYgKCF6LT5sZWZ0KCkgfHwgIXotPnJpZ2h0KCkpCisgICAgICAgICAg ICB5ID0gejsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgeSA9IHRyZWVTdWNjZXNzb3Ioeik7 CisgICAgICAgIC8vIFkgaXMgZ3VhcmFudGVlZCB0byBiZSBub24tMCBhdCB0aGlzIHBvaW50Lgor ICAgICAgICBOb2RlKiB4OworICAgICAgICBpZiAoeS0+bGVmdCgpKQorICAgICAgICAgICAgeCA9 IHktPmxlZnQoKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgeCA9IHktPnJpZ2h0KCk7Cisg ICAgICAgIC8vIFggaXMgdGhlIGNoaWxkIG9mIHkgd2hpY2ggbWlnaHQgcG90ZW50aWFsbHkgcmVw bGFjZSB5IGluCisgICAgICAgIC8vIHRoZSB0cmVlLiBYIG1pZ2h0IGJlIG51bGwgYXQgdGhpcyBw b2ludC4KKyAgICAgICAgTm9kZSogeFBhcmVudDsKKyAgICAgICAgaWYgKHgpIHsKKyAgICAgICAg ICAgIHgtPnNldFBhcmVudCh5LT5wYXJlbnQoKSk7CisgICAgICAgICAgICB4UGFyZW50ID0geC0+ cGFyZW50KCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgeFBhcmVudCA9IHktPnBhcmVu dCgpOworICAgICAgICBpZiAoIXktPnBhcmVudCgpKQorICAgICAgICAgICAgbV9yb290ID0geDsK KyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBpZiAoeSA9PSB5LT5wYXJlbnQoKS0+bGVmdCgp KQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRMZWZ0KHgpOworICAgICAgICAgICAg ZWxzZQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRSaWdodCh4KTsKKyAgICAgICAg fQorICAgICAgICAvLyBJdCBoYXMgYmVlbiBmb3VuZCBlbXBpcmljYWxseSB0aGF0IGJvdGggb2Yg dGhlc2UgdXB3YXJkCisgICAgICAgIC8vIHByb3BhZ2F0aW9ucyBhcmUgbmVjZXNzYXJ5LgorICAg ICAgICBpZiAoeSAhPSB6KSB7CisgICAgICAgICAgICB6LT5jb3B5RnJvbSh5KTsKKyAgICAgICAg ICAgIHByb3BhZ2F0ZVVwZGF0ZXMoeik7CisgICAgICAgIH0KKyAgICAgICAgaWYgKHhQYXJlbnQp CisgICAgICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHhQYXJlbnQpOworICAgICAgICBpZiAoeS0+ Y29sb3IoKSA9PSBrQmxhY2spCisgICAgICAgICAgICBkZWxldGVGaXh1cCh4LCB4UGFyZW50KTsK KyAgICB9CisKKyAgICAvLyBWaXNpdHMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHRoZSBnaXZlbiBu b2RlIGluIG9yZGVyLgorICAgIHZvaWQgdmlzaXRJbm9yZGVySW1wbChOb2RlKiBub2RlLCBWaXNp dG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAgICAgaWYgKG5vZGUtPmxlZnQoKSkKKyAgICAgICAg ICAgIHZpc2l0SW5vcmRlckltcGwobm9kZS0+bGVmdCgpLCB2aXNpdG9yKTsKKyAgICAgICAgdmlz aXRvci0+dmlzaXQobm9kZS0+ZGF0YSgpKTsKKyAgICAgICAgaWYgKG5vZGUtPnJpZ2h0KCkpCisg ICAgICAgICAgICB2aXNpdElub3JkZXJJbXBsKG5vZGUtPnJpZ2h0KCksIHZpc2l0b3IpOworICAg IH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEhlbHBlciBjbGFzcyBmb3IgbnVtRWxl bWVudHMoKQorCisgICAgLy8gQSBWaXNpdG9yIHdoaWNoIHNpbXBseSBjb3VudHMgdGhlIG51bWJl ciBvZiB2aXNpdGVkIGVsZW1lbnRzLgorICAgIGNsYXNzIENvdW50ZXIgOiBwdWJsaWMgVmlzaXRv ciwgcHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIENvdW50ZXIoKQor ICAgICAgICAgICAgOiBtX2NvdW50KDApIHsgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCB2aXNp dChjb25zdCBUJiBkYXRhKSB7ICsrbV9jb3VudDsgfQorICAgICAgICBpbnQgY291bnQoKSBjb25z dCB7IHJldHVybiBtX2NvdW50OyB9CisKKyAgICBwcml2YXRlOgorICAgICAgICBpbnQgbV9jb3Vu dDsKKyAgICB9OworCisgICAgLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgLy8gVmVyaWZpY2F0aW9uIGFu ZCBkZWJ1Z2dpbmcgcm91dGluZXMKKyAgICAvLworCisgICAgLy8gUmV0dXJucyBpbiB0aGUgImJs YWNrQ291bnQiIHBhcmFtZXRlciB0aGUgbnVtYmVyIG9mIGJsYWNrCisgICAgLy8gY2hpbGRyZW4g YWxvbmcgYWxsIHBhdGhzIHRvIGFsbCBsZWF2ZXMgb2YgdGhlIGdpdmVuIG5vZGUuCisgICAgYm9v bCBjaGVja0ludmFyaWFudHNGcm9tTm9kZShOb2RlKiBub2RlLCBpbnQqIGJsYWNrQ291bnQpCisg ICAgeworICAgICAgICAvLyBCYXNlIGNhc2UgaXMgYSBsZWFmIG5vZGUuCisgICAgICAgIGlmICgh bm9kZSkgeworICAgICAgICAgICAgKmJsYWNrQ291bnQgPSAxOworICAgICAgICAgICAgcmV0dXJu IHRydWU7CisgICAgICAgIH0KKworICAgICAgICAvLyBFYWNoIG5vZGUgaXMgZWl0aGVyIHJlZCBv ciBibGFjay4KKyAgICAgICAgaWYgKCEobm9kZS0+Y29sb3IoKSA9PSBrUmVkIHx8IG5vZGUtPmNv bG9yKCkgPT0ga0JsYWNrKSkKKyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICAgICAv LyBFdmVyeSBsZWFmIChvciBudWxsKSBpcyBibGFjay4KKworICAgICAgICBpZiAobm9kZS0+Y29s b3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAvLyBCb3RoIG9mIGl0cyBjaGlsZHJlbiBhcmUg YmxhY2suCisgICAgICAgICAgICBpZiAoISgoIW5vZGUtPmxlZnQoKSB8fCBub2RlLT5sZWZ0KCkt PmNvbG9yKCkgPT0ga0JsYWNrKSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAg ICAgICAgICAgaWYgKCEoKCFub2RlLT5yaWdodCgpIHx8IG5vZGUtPnJpZ2h0KCktPmNvbG9yKCkg PT0ga0JsYWNrKSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICB9CisK KyAgICAgICAgLy8gRXZlcnkgc2ltcGxlIHBhdGggdG8gYSBsZWFmIG5vZGUgY29udGFpbnMgdGhl IHNhbWUgbnVtYmVyIG9mCisgICAgICAgIC8vIGJsYWNrIG5vZGVzLgorICAgICAgICBpbnQgbGVm dENvdW50ID0gMCwgcmlnaHRDb3VudCA9IDA7CisgICAgICAgIGJvb2wgbGVmdFZhbGlkID0gY2hl Y2tJbnZhcmlhbnRzRnJvbU5vZGUobm9kZS0+bGVmdCgpLCAmbGVmdENvdW50KTsKKyAgICAgICAg Ym9vbCByaWdodFZhbGlkID0gY2hlY2tJbnZhcmlhbnRzRnJvbU5vZGUobm9kZS0+cmlnaHQoKSwg JnJpZ2h0Q291bnQpOworICAgICAgICBpZiAoIWxlZnRWYWxpZCB8fCAhcmlnaHRWYWxpZCkKKyAg ICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgKmJsYWNrQ291bnQgPSBsZWZ0Q291bnQg KyAobm9kZS0+Y29sb3IoKSA9PSBrQmxhY2sgPyAxIDogMCk7CisgICAgICAgIHJldHVybiBsZWZ0 Q291bnQgPT0gcmlnaHRDb3VudDsKKyAgICB9CisKKyNpZm5kZWYgTkRFQlVHCisgICAgLy8gRHVt cHMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHRoZSBnaXZlbiBub2RlLgorICAgIHZvaWQgZHVtcEZy b21Ob2RlKE5vZGUqIG5vZGUsIGludCBpbmRlbnRhdGlvbikKKyAgICB7CisgICAgICAgIFN0cmlu Z0J1aWxkZXIgYnVpbGRlcjsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBpbmRlbnRhdGlv bjsgaSsrKQorICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIiAiKTsKKyAgICAgICAgYnVpbGRl ci5hcHBlbmQoIi0iKTsKKyAgICAgICAgaWYgKG5vZGUpIHsKKyAgICAgICAgICAgIGJ1aWxkZXIu YXBwZW5kKCIgIik7CisgICAgICAgICAgICBidWlsZGVyLmFwcGVuZCh2YWx1ZVRvU3RyaW5nKG5v ZGUtPmRhdGEoKSkpOworICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoKG5vZGUtPmNvbG9yKCkg PT0ga0JsYWNrKSA/ICIgKGJsYWNrKSIgOiAiIChyZWQpIik7CisgICAgICAgIH0KKyAgICAgICAg TE9HX0VSUk9SKCIlcyIsIGJ1aWxkZXIudG9TdHJpbmcoKS5hc2NpaSgpLmRhdGEoKSk7CisgICAg ICAgIGlmIChub2RlKSB7CisgICAgICAgICAgICBkdW1wRnJvbU5vZGUobm9kZS0+bGVmdCgpLCBp bmRlbnRhdGlvbiArIDIpOworICAgICAgICAgICAgZHVtcEZyb21Ob2RlKG5vZGUtPnJpZ2h0KCks IGluZGVudGF0aW9uICsgMik7CisgICAgICAgIH0KKyAgICB9CisjZW5kaWYKKworICAgIC8vLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorICAgIC8vIERhdGEgbWVtYmVycworCisgICAgUmVmUHRyPFBPREFyZW5hPiBt X2FyZW5hOworICAgIE5vZGUqIG1fcm9vdDsKKyAgICBib29sIG1fbmVlZHNGdWxsT3JkZXJpbmdD b21wYXJpc29uczsKKyNpZm5kZWYgTkRFQlVHCisgICAgYm9vbCBtX3ZlcmJvc2VEZWJ1Z2dpbmc7 CisjZW5kaWYKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFBPRFJl ZEJsYWNrVHJlZV9oCg== 66391 2010-09-02 11:57:56 -0700 2010-09-02 15:30:00 -0700 Revised patch red-black-tree.patch text/plain 38145 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjY3NikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODUgQEAKKzIwMTAtMDktMDIgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCByZWQtYmxhY2sgdHJlZSBjYXBhYmxlIG9mIGhvbGRpbmcgcGxhaW4gb2xkIGRhdGEgKFBPRCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1MDU5CisK KyAgICAgICAgQWRkaW5nIGFuIGF1Z21lbnRhYmxlIHJlZC1ibGFjayB0cmVlIGNhcGFibGUgb2Yg aG9sZGluZyBQbGFpbiBPbGQKKyAgICAgICAgRGF0YSAoUE9EKSwgb3IgY2xhc3NlcyBib3R0b21p bmcgb3V0IGludG8gb25seSBQT0QsIGFuZCBhbgorICAgICAgICBhc3NvY2lhdGVkIFBPREFyZW5h LiBOb3RlIHRoYXQgdGhlIFBPREFyZW5hIHdpbGwgYmUgdXNlZCBieSBvdGhlcgorICAgICAgICBj bGFzc2VzIHRvIGFsbG9jYXRlIHRlbXBvcmFyeSBzdHJ1Y3R1cmVzLCB3aGljaCBpcyB3aHkgaXQg aXMgbm90CisgICAgICAgIGp1c3QgYW4gaW1wbGVtZW50YXRpb24gZGV0YWlsIG9mIHRoZSByZWQt YmxhY2sgdHJlZS4KKworICAgICAgICBUaGVzZSBjbGFzc2VzIGFyZSBiZWluZyBwbGFjZWQgdW5k ZXIgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUKKyAgICAgICAgZm9yIHRoZSB0aW1lIGJl aW5nLiBJZiB0aGV5IGFyZSBnZW5lcmFsaXplZCB0byBob2xkIGV2ZW4gZGF0YQorICAgICAgICB0 eXBlcyB3aGljaCBpbnRlcm5hbGx5IHBlcmZvcm0gZHluYW1pYyBtZW1vcnkgYWxsb2NhdGlvbiwg d2UgbWF5CisgICAgICAgIGNvbnNpZGVyIG1vdmluZyB0aGVtIHRvIFdURiBpbiB0aGUgZnV0dXJl LgorCisgICAgICAgIFVuaXQgdGVzdHMgZm9yIHRoZSBQT0RSZWRCbGFja1RyZWUgd2lsbCBiZSBp bnRlZ3JhdGVkIHNlcGFyYXRlbHkKKyAgICAgICAgdW5kZXIgYnVnIDQ1MDYwLgorCisgICAgICAg ICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RBcmVu YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5hOjpBbGxvY2F0b3I6On5BbGxv Y2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxvY2F0b3I6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6RmFzdE1hbGxvY0FsbG9jYXRv cjo6YWxsb2NhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OmZyZWUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OkZhc3RNYWxsb2NBbGxvY2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6YWxsb2MpOgorICAgICAgICAo V2ViQ29yZTo6UE9EQXJlbmE6OlBPREFyZW5hKToKKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5h OjptaW5BbGlnbm1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OnJvdW5kVXApOgor ICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkNodW5rOjpDaHVuayk6CisgICAgICAgIChXZWJD b3JlOjpQT0RBcmVuYTo6Q2h1bms6On5DaHVuayk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVu YTo6Q2h1bms6OmFsbG9jYXRlKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9E UmVkQmxhY2tUcmVlLmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVl OjpWaXNpdG9yOjp+VmlzaXRvcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6 OlBPRFJlZEJsYWNrVHJlZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6On5Q T0RSZWRCbGFja1RyZWUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjphZGQp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyZW1vdmUpOgorICAgICAgICAo V2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpjb250YWlucyk6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6OnZpc2l0SW5vcmRlcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRC bGFja1RyZWU6OnNpemUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpzZXRO ZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6Y2hlY2tJbnZhcmlhbnRzKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNr VHJlZTo6ZHVtcCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnNldFZlcmJv c2VEZWJ1Z2dpbmcpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpO b2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6fk5vZGUpOgor ICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpjb2xvcik6CisgICAgICAg IChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNldENvbG9yKToKKyAgICAgICAgKFdl YkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6ZGF0YSk6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6Ok5vZGU6OmNvcHlGcm9tKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJl ZEJsYWNrVHJlZTo6Tm9kZTo6bGVmdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6Ok5vZGU6OnNldExlZnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpO b2RlOjpyaWdodCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnNl dFJpZ2h0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6cGFyZW50 KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0UGFyZW50KToK KyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cm9vdCk6CisgICAgICAgIChXZWJD b3JlOjpQT0RSZWRCbGFja1RyZWU6OnVwZGF0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9E UmVkQmxhY2tUcmVlOjp0cmVlU2VhcmNoKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNr VHJlZTo6dHJlZVNlYXJjaE5vcm1hbCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OnRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVk QmxhY2tUcmVlOjp0cmVlSW5zZXJ0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJl ZTo6dHJlZVN1Y2Nlc3Nvcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnRy ZWVNaW5pbXVtKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6cHJvcGFnYXRl VXBkYXRlcyk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmxlZnRSb3RhdGUp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyaWdodFJvdGF0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Omluc2VydE5vZGUpOgorICAgICAgICAoV2Vi Q29yZTo6UE9EUmVkQmxhY2tUcmVlOjpkZWxldGVGaXh1cCk6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6OmRlbGV0ZU5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxh Y2tUcmVlOjp2aXNpdElub3JkZXJJbXBsKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNr VHJlZTo6Q291bnRlcjo6Q291bnRlcik6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OkNvdW50ZXI6OnZpc2l0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6 Q291bnRlcjo6Y291bnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpjaGVj a0ludmFyaWFudHNGcm9tTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6 OmR1bXBGcm9tTm9kZSk6CisKIDIwMTAtMDktMDEgIFpoZW55YW8gTW8gIDx6bW9AZ29vZ2xlLmNv bT4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJ1c3NlbGwuCkluZGV4OiBXZWJDb3Jl L1dlYkNvcmUuZ3lwaQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNvcmUuZ3lwaQkocmV2aXNp b24gNjY2NzUpCisrKyBXZWJDb3JlL1dlYkNvcmUuZ3lwaQkod29ya2luZyBjb3B5KQpAQCAtMjM0 MSw2ICsyMzQxLDggQEAKICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL1Nv dXJjZUFscGhhLmgnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvU291 cmNlR3JhcGhpYy5jcHAnLAogICAgICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMv U291cmNlR3JhcGhpYy5oJywKKyAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9E QXJlbmEuaCcsCisgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BPRFJlZEJsYWNr VHJlZS5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvU2hhZGVyLmNwcCcs CiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlci5oJywKICAgICAgICAg ICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvU29saWRGaWxsU2hhZGVyLmNwcCcsCkluZGV4OiBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RBcmVuYS5oCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BPREFyZW5hLmgJKHJldmlzaW9uIDApCisrKyBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RBcmVuYS5oCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDIwNSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAq IG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0 IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFt ZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAq IHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERF UlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQ QVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBD T1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisg KiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaWZuZGVmIFBPREFyZW5hX2gKKyNkZWZpbmUgUE9EQXJlbmFfaAorCisj aW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvRmFzdE1hbGxvYy5oPgor I2luY2x1ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+Cisj aW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIEFuIGFy ZW5hIHdoaWNoIGFsbG9jYXRlcyBvbmx5IFBsYWluIE9sZCBEYXRhIChQT0QpLCBvciBjbGFzc2Vz IGFuZAorLy8gc3RydWN0cyBib3R0b21pbmcgb3V0IGluIFBsYWluIE9sZCBEYXRhLiBOT1RFOiB0 aGUgY29uc3RydWN0b3JzIG9mCisvLyB0aGUgb2JqZWN0cyBhbGxvY2F0ZWQgaW4gdGhpcyBhcmVu YSBhcmUgY2FsbGVkLCBidXQgX25vdF8gdGhlaXIKKy8vIGRlc3RydWN0b3JzLgorCitjbGFzcyBQ T0RBcmVuYSA6IHB1YmxpYyBSZWZDb3VudGVkPFBPREFyZW5hPiB7CitwdWJsaWM6CisgICAgLy8g VGhlIGFyZW5hIGlzIGNvbmZpZ3VyZWQgd2l0aCBhbiBhbGxvY2F0b3IsIHdoaWNoIGlzIHJlc3Bv bnNpYmxlCisgICAgLy8gZm9yIGFsbG9jYXRpbmcgYW5kIGZyZWVpbmcgY2h1bmtzIG9mIG1lbW9y eSBhdCBhIHRpbWUuCisgICAgY2xhc3MgQWxsb2NhdG9yIDogcHVibGljIFJlZkNvdW50ZWQ8QWxs b2NhdG9yPiB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIH5BbGxvY2F0b3IoKSB7IH0K KyAgICAgICAgdmlydHVhbCB2b2lkKiBhbGxvY2F0ZShzaXplX3Qgc2l6ZSkgPSAwOworICAgICAg ICB2aXJ0dWFsIHZvaWQgZnJlZSh2b2lkKiBwdHIpID0gMDsKKyAgICB9OworCisgICAgLy8gVGhl IEFyZW5hJ3MgZGVmYXVsdCBhbGxvY2F0b3IsIHdoaWNoIHVzZXMgZmFzdE1hbGxvYyBhbmQKKyAg ICAvLyBmYXN0RnJlZSB0byBhbGxvY2F0ZSBjaHVua3Mgb2Ygc3RvcmFnZS4KKyAgICBjbGFzcyBG YXN0TWFsbG9jQWxsb2NhdG9yIDogcHVibGljIEFsbG9jYXRvciB7CisgICAgcHVibGljOgorICAg ICAgICBzdGF0aWMgUGFzc1JlZlB0cjxGYXN0TWFsbG9jQWxsb2NhdG9yPiBjcmVhdGUoKQorICAg ICAgICB7CisgICAgICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEZhc3RNYWxsb2NBbGxvY2F0 b3IpOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkKiBhbGxvY2F0ZShzaXplX3Qg c2l6ZSkgeyByZXR1cm4gZmFzdE1hbGxvYyhzaXplKTsgfQorICAgICAgICB2aXJ0dWFsIHZvaWQg ZnJlZSh2b2lkKiBwdHIpIHsgZmFzdEZyZWUocHRyKTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAg ICAgRmFzdE1hbGxvY0FsbG9jYXRvcigpIHsgfQorICAgIH07CisKKyAgICAvLyBDcmVhdGVzIGEg bmV3IFBPREFyZW5hIGNvbmZpZ3VyZWQgd2l0aCBhIEZhc3RNYWxsb2NBbGxvY2F0b3IuCisgICAg c3RhdGljIFBhc3NSZWZQdHI8UE9EQXJlbmE+IGNyZWF0ZSgpCisgICAgeworICAgICAgICByZXR1 cm4gYWRvcHRSZWYobmV3IFBPREFyZW5hKTsKKyAgICB9CisKKyAgICAvLyBDcmVhdGVzIGEgbmV3 IFBPREFyZW5hIGNvbmZpZ3VyZWQgd2l0aCB0aGUgZ2l2ZW4gQWxsb2NhdG9yLgorICAgIHN0YXRp YyBQYXNzUmVmUHRyPFBPREFyZW5hPiBjcmVhdGUoQWxsb2NhdG9yKiBhbGxvY2F0b3IpCisgICAg eworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFBPREFyZW5hKGFsbG9jYXRvcikpOworICAg IH0KKworICAgIC8vIEFsbG9jYXRlcyBhbiBvYmplY3QgZnJvbSB0aGUgYXJlbmEuCisgICAgdGVt cGxhdGU8Y2xhc3MgVD4KKyAgICBUKiBhbGxvYygpCisgICAgeworICAgICAgICB2b2lkKiBwdHIg PSAwOworICAgICAgICBzaXplX3Qgcm91bmRlZFNpemUgPSByb3VuZFVwKHNpemVvZihUKSwgbWlu QWxpZ25tZW50KCkpOworICAgICAgICBpZiAobV9jdXJyZW50KQorICAgICAgICAgICAgcHRyID0g bV9jdXJyZW50LT5hbGxvY2F0ZShyb3VuZGVkU2l6ZSk7CisKKyAgICAgICAgaWYgKCFwdHIpIHsK KyAgICAgICAgICAgIGlmIChyb3VuZGVkU2l6ZSA+IG1fY3VycmVudENodW5rU2l6ZSkKKyAgICAg ICAgICAgICAgICBtX2N1cnJlbnRDaHVua1NpemUgPSByb3VuZGVkU2l6ZTsKKyAgICAgICAgICAg IG1fY2h1bmtzLmFwcGVuZChhZG9wdFB0cihuZXcgQ2h1bmsobV9hbGxvY2F0b3IuZ2V0KCksIG1f Y3VycmVudENodW5rU2l6ZSkpKTsKKyAgICAgICAgICAgIG1fY3VycmVudCA9IG1fY2h1bmtzLmxh c3QoKS5nZXQoKTsKKyAgICAgICAgICAgIHB0ciA9IG1fY3VycmVudC0+YWxsb2NhdGUocm91bmRl ZFNpemUpOworICAgICAgICB9CisKKyAgICAgICAgaWYgKHB0cikgeworICAgICAgICAgICAgLy8g VXNlIHBsYWNlbWVudCBvcGVyYXRvciBuZXcgdG8gYWxsb2NhdGUgYSBUIGF0IHRoaXMgbG9jYXRp b24uCisgICAgICAgICAgICBuZXcocHRyKSBUKCk7CisgICAgICAgIH0KKworICAgICAgICByZXR1 cm4gc3RhdGljX2Nhc3Q8VCo+KHB0cik7CisgICAgfQorCitwcml2YXRlOgorICAgIFBPREFyZW5h KCkKKyAgICAgICAgOiBtX2FsbG9jYXRvcihGYXN0TWFsbG9jQWxsb2NhdG9yOjpjcmVhdGUoKSkK KyAgICAgICAgLCBtX2N1cnJlbnQoMCkKKyAgICAgICAgLCBtX2N1cnJlbnRDaHVua1NpemUoRGVm YXVsdENodW5rU2l6ZSkgeyB9CisKKyAgICBleHBsaWNpdCBQT0RBcmVuYShBbGxvY2F0b3IqIGFs bG9jYXRvcikKKyAgICAgICAgOiBtX2FsbG9jYXRvcihhbGxvY2F0b3IpCisgICAgICAgICwgbV9j dXJyZW50KDApCisgICAgICAgICwgbV9jdXJyZW50Q2h1bmtTaXplKERlZmF1bHRDaHVua1NpemUp IHsgfQorCisgICAgZW51bSB7CisgICAgICAgIERlZmF1bHRDaHVua1NpemUgPSAxNjM4NAorICAg IH07CisKKyAgICAvLyBUaGUgZm9sbG93aW5nIHR3byBzdHJ1Y3R1cmVzIGFyZSBpbnRlbmRlZCB0 byBhdXRvbWF0aWNhbGx5CisgICAgLy8gZGV0ZXJtaW5lIHRoZSBwbGF0Zm9ybSdzIGFsaWdubWVu dCBjb25zdHJhaW50IGZvciBzdHJ1Y3R1cmVzLgorICAgIHN0cnVjdCBBbGlnbm1lbnRJbm5lciB7 CisgICAgICAgIGludDY0X3QgeDsKKyAgICB9OworICAgIHN0cnVjdCBBbGlnbm1lbnRTdHJ1Y3Qg eworICAgICAgICBjaGFyIGYxOworICAgICAgICBBbGlnbm1lbnRJbm5lciBmMjsKKyAgICB9Owor CisgICAgLy8gUmV0dXJucyB0aGUgYWxpZ25tZW50IHJlcXVpcmVtZW50IGZvciBjbGFzc2VzIGFu ZCBzdHJ1Y3RzIG9uIHRoZQorICAgIC8vIGN1cnJlbnQgcGxhdGZvcm0uCisgICAgc3RhdGljIHNp emVfdCBtaW5BbGlnbm1lbnQoKQorICAgIHsKKyAgICAgICAgcmV0dXJuIG9mZnNldG9mKEFsaWdu bWVudFN0cnVjdCwgZjIpOworICAgIH0KKworICAgIC8vIFJvdW5kcyB1cCB0aGUgZ2l2ZW4gYWxs b2NhdGlvbiBzaXplIHRvIHRoZSBzcGVjaWZpZWQgYWxpZ25tZW50LgorICAgIHNpemVfdCByb3Vu ZFVwKHNpemVfdCBzaXplLCBzaXplX3QgYWxpZ25tZW50KQorICAgIHsKKyAgICAgICAgQVNTRVJU KCEoYWxpZ25tZW50ICUgMikpOworICAgICAgICByZXR1cm4gKHNpemUgKyBhbGlnbm1lbnQgLSAx KSAmIH4oYWxpZ25tZW50IC0gMSk7CisgICAgfQorCisgICAgUmVmUHRyPEFsbG9jYXRvcj4gbV9h bGxvY2F0b3I7CisKKyAgICAvLyBNYW5hZ2VzIGEgY2h1bmsgb2YgbWVtb3J5IGFuZCBpbmRpdmlk dWFsIGFsbG9jYXRpb25zIG91dCBvZiBpdC4KKyAgICBjbGFzcyBDaHVuayA6IHB1YmxpYyBOb25j b3B5YWJsZSB7CisgICAgcHVibGljOgorICAgICAgICAvLyBBbGxvY2F0ZXMgYSBibG9jayBvZiBt ZW1vcnkgb2YgdGhlIGdpdmVuIHNpemUgZnJvbSB0aGUgcGFzc2VkCisgICAgICAgIC8vIEFsbG9j YXRvci4KKyAgICAgICAgQ2h1bmsoQWxsb2NhdG9yKiBhbGxvY2F0b3IsIHNpemVfdCBzaXplKQor ICAgICAgICAgICAgOiBtX2FsbG9jYXRvcihhbGxvY2F0b3IpCisgICAgICAgICAgICAsIG1fc2l6 ZShzaXplKQorICAgICAgICAgICAgLCBtX2N1cnJlbnRPZmZzZXQoMCkKKyAgICAgICAgeworICAg ICAgICAgICAgbV9iYXNlID0gc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fYWxsb2NhdG9yLT5hbGxv Y2F0ZShzaXplKSk7CisgICAgICAgIH0KKworICAgICAgICAvLyBGcmVlcyB0aGUgbWVtb3J5IGFs bG9jYXRlZCBmcm9tIHRoZSBBbGxvY2F0b3IgaW4gdGhlCisgICAgICAgIC8vIGNvbnN0cnVjdG9y LgorICAgICAgICB+Q2h1bmsoKQorICAgICAgICB7CisgICAgICAgICAgICBtX2FsbG9jYXRvci0+ ZnJlZShtX2Jhc2UpOworICAgICAgICB9CisKKyAgICAgICAgLy8gUmV0dXJucyBhIHBvaW50ZXIg dG8gInNpemUiIGJ5dGVzIG9mIHN0b3JhZ2UsIG9yIDAgaWYgdGhpcworICAgICAgICAvLyBDaHVu ayBjb3VsZCBub3Qgc2F0aXNmeSB0aGUgYWxsb2NhdGlvbi4KKyAgICAgICAgdm9pZCogYWxsb2Nh dGUoc2l6ZV90IHNpemUpCisgICAgICAgIHsKKyAgICAgICAgICAgIC8vIENoZWNrIGZvciBvdmVy ZmxvdworICAgICAgICAgICAgaWYgKG1fY3VycmVudE9mZnNldCArIHNpemUgPCBtX2N1cnJlbnRP ZmZzZXQpCisgICAgICAgICAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgICAgICAgIGlmIChtX2N1 cnJlbnRPZmZzZXQgKyBzaXplID4gbV9zaXplKQorICAgICAgICAgICAgICAgIHJldHVybiAwOwor CisgICAgICAgICAgICB2b2lkKiByZXN1bHQgPSBtX2Jhc2UgKyBtX2N1cnJlbnRPZmZzZXQ7Cisg ICAgICAgICAgICBtX2N1cnJlbnRPZmZzZXQgKz0gc2l6ZTsKKyAgICAgICAgICAgIHJldHVybiBy ZXN1bHQ7CisgICAgICAgIH0KKworICAgIHByaXZhdGU6CisgICAgICAgIEFsbG9jYXRvciogbV9h bGxvY2F0b3I7CisgICAgICAgIHVpbnQ4X3QqIG1fYmFzZTsKKyAgICAgICAgc2l6ZV90IG1fc2l6 ZTsKKyAgICAgICAgc2l6ZV90IG1fY3VycmVudE9mZnNldDsKKyAgICB9OworCisgICAgQ2h1bmsq IG1fY3VycmVudDsKKyAgICBWZWN0b3I8T3duUHRyPENodW5rPiA+IG1fY2h1bmtzOworICAgIHNp emVfdCBtX2N1cnJlbnRDaHVua1NpemU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBQT0RBcmVuYV9oCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9QT0RSZWRCbGFja1RyZWUuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2dwdS9QT0RSZWRCbGFja1RyZWUuaAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvZ3B1L1BPRFJlZEJsYWNrVHJlZS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsx LDc3MSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0 cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1p dHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoK KyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor ICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBH b29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1 c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5E IENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJS QU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdB UlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRB LCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisvLyBBIHJlZC1ibGFjayB0cmVlLCB3aGljaCBpcyBhIGZvcm0gb2YgYSBiYWxhbmNl ZCBiaW5hcnkgdHJlZS4gSXQKKy8vIHN1cHBvcnRzIGVmZmljaWVudCBpbnNlcnRpb24sIGRlbGV0 aW9uIGFuZCBxdWVyaWVzIG9mIGNvbXBhcmFibGUKKy8vIGVsZW1lbnRzLiBUaGUgc2FtZSBlbGVt ZW50IG1heSBiZSBpbnNlcnRlZCBtdWx0aXBsZSB0aW1lcy4gVGhlCisvLyBhbGdvcml0aG1pYyBj b21wbGV4aXR5IG9mIGNvbW1vbiBvcGVyYXRpb25zIGlzOgorLy8KKy8vICAgSW5zZXJ0aW9uOiBP KGxnKG4pKQorLy8gICBEZWxldGlvbjogIE8obGcobikpCisvLyAgIFF1ZXJ5aW5nOiAgTyhsZyhu KSkKKy8vCisvLyBUaGUgZGF0YSB0eXBlIFQgdGhhdCBpcyBzdG9yZWQgaW4gdGhpcyByZWQtYmxh Y2sgdHJlZSBtdXN0IGJlIG9ubHkKKy8vIFBsYWluIE9sZCBEYXRhIChQT0QpLCBvciBib3R0b20g b3V0IGludG8gUE9ELiBJdCBtdXN0IF9ub3RfIHJlbHkgb24KKy8vIGhhdmluZyBpdHMgZGVzdHJ1 Y3RvciBjYWxsZWQuIFRoaXMgaW1wbGVtZW50YXRpb24gaW50ZXJuYWxseQorLy8gYWxsb2NhdGVz IHN0b3JhZ2UgaW4gbGFyZ2UgY2h1bmtzIGFuZCBkb2VzIG5vdCBjYWxsIHRoZSBkZXN0cnVjdG9y CisvLyBvbiBlYWNoIG9iamVjdC4KKy8vCisvLyBUeXBlIFQgbXVzdCBzdXBwbHkgYSBkZWZhdWx0 IGNvbnN0cnVjdG9yLCBhIGNvcHkgY29uc3RydWN0b3IsIGFuZAorLy8gdGhlICI8IiBhbmQgIj09 IiBvcGVyYXRvcnMuCisvLworLy8gSW4gZGVidWcgbW9kZSwgcHJpbnRpbmcgb2YgdGhlIGRhdGEg Y29udGFpbmVkIGluIHRoZSB0cmVlIGlzCisvLyBlbmFibGVkLiBUaGlzIHJlcXVpcmVzIHRoZSBm b2xsb3dpbmcgZnVuY3Rpb24gdG8gYmUgYXZhaWxhYmxlOgorLy8KKy8vICAgU3RyaW5nIHZhbHVl VG9TdHJpbmcoY29uc3QgVCYpOworLy8KKy8vIE5vdGUgdGhhdCB3aGVuIGNvbXBsZXggdHlwZXMg YXJlIHN0b3JlZCBpbiB0aGlzIHJlZC9ibGFjayB0cmVlLCBpdAorLy8gaXMgcG9zc2libGUgdGhh dCBzaW5nbGUgaW52b2NhdGlvbnMgb2YgdGhlICI8IiBhbmQgIj09IiBvcGVyYXRvcnMKKy8vIHdp bGwgYmUgaW5zdWZmaWNpZW50IHRvIGRlc2NyaWJlIHRoZSBvcmRlcmluZyBvZiBlbGVtZW50cyBp biB0aGUKKy8vIHRyZWUgZHVyaW5nIHF1ZXJpZXMuIEFzIGEgY29uY3JldGUgZXhhbXBsZSwgY29u c2lkZXIgdGhlIGNhc2Ugd2hlcmUKKy8vIGludGVydmFscyBhcmUgc3RvcmVkIGluIHRoZSB0cmVl IHNvcnRlZCBieSBsb3cgZW5kcG9pbnQuIFRoZSAiPCIKKy8vIG9wZXJhdG9yIG9uIHRoZSBJbnRl cnZhbCBjbGFzcyBvbmx5IGNvbXBhcmVzIHRoZSBsb3cgZW5kcG9pbnQsIGJ1dAorLy8gdGhlICI9 PSIgb3BlcmF0b3IgdGFrZXMgaW50byBhY2NvdW50IHRoZSBoaWdoIGVuZHBvaW50IGFzIHdlbGwu CisvLyBUaGlzIG1ha2VzIHRoZSBuZWNlc3NhcnkgbG9naWMgZm9yIHF1ZXJ5aW5nIGFuZCBkZWxl dGlvbiBzb21ld2hhdAorLy8gbW9yZSBjb21wbGV4LiBJbiBvcmRlciB0byBwcm9wZXJseSBoYW5k bGUgc3VjaCBzaXR1YXRpb25zLCB0aGUKKy8vIHByb3BlcnR5ICJuZWVkc0Z1bGxPcmRlcmluZ0Nv bXBhcmlzb25zIiBtdXN0IGJlIHNldCB0byB0cnVlIG9uCisvLyB0aGUgdHJlZS4KKy8vCisvLyBU aGlzIHJlZC1ibGFjayB0cmVlIGlzIGRlc2lnbmVkIHRvIGJlIF9hdWdtZW50ZWRfOyBzdWJjbGFz c2VzIGNhbgorLy8gYWRkIGFkZGl0aW9uYWwgYW5kIHN1bW1hcnkgaW5mb3JtYXRpb24gdG8gZWFj aCBub2RlIHRvIGVmZmljaWVudGx5CisvLyBzdG9yZSBhbmQgaW5kZXggbW9yZSBjb21wbGV4IGRh dGEgc3RydWN0dXJlcy4gQSBjb25jcmV0ZSBleGFtcGxlIGlzCisvLyB0aGUgSW50ZXJ2YWxUcmVl LCB3aGljaCBleHRlbmRzIGVhY2ggbm9kZSB3aXRoIGEgc3VtbWFyeSBzdGF0aXN0aWMKKy8vIHRv IGVmZmljaWVudGx5IHN0b3JlIG9uZS1kaW1lbnNpb25hbCBpbnRlcnZhbHMuCisvLworLy8gVGhl IGRlc2lnbiBvZiB0aGlzIHJlZC1ibGFjayB0cmVlIGNvbWVzIGZyb20gQ29ybWVuLCBMZWlzZXJz b24sCisvLyBhbmQgUml2ZXN0LCBfSW50cm9kdWN0aW9uIHRvIEFsZ29yaXRobXNfLCBNSVQgUHJl c3MsIDE5OTAuCisKKyNpZm5kZWYgUE9EUmVkQmxhY2tUcmVlX2gKKyNkZWZpbmUgUE9EUmVkQmxh Y2tUcmVlX2gKKworI2lmbmRlZiBOREVCVUcKKyNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVk ZSAiUGxhdGZvcm1TdHJpbmcuaCIKKyNlbmRpZgorI2luY2x1ZGUgIlBPREFyZW5hLmgiCisjaWZu ZGVmIERFQlVHCisjaW5jbHVkZSAiU3RyaW5nQnVpbGRlci5oIgorI2VuZGlmCisjaW5jbHVkZSA8 d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRl IDx3dGYvUmVmUHRyLmg+CisjaWZuZGVmIE5ERUJVRworI2luY2x1ZGUgPHd0Zi90ZXh0L0NTdHJp bmcuaD4KKyNlbmRpZgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3RlbXBsYXRlPGNsYXNzIFQ+ CitjbGFzcyBQT0RSZWRCbGFja1RyZWUgeworcHVibGljOgorICAgIC8vIFZpc2l0b3IgaW50ZXJm YWNlIGZvciB3YWxraW5nIGFsbCBvZiB0aGUgdHJlZSdzIGVsZW1lbnRzLgorICAgIGNsYXNzIFZp c2l0b3IgeworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB2b2lkIHZpc2l0KGNvbnN0IFQm IGRhdGEpID0gMDsKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIHZpcnR1YWwgflZpc2l0b3IoKSB7 IH0KKyAgICB9OworCisgICAgLy8gQ29uc3RydWN0cyBhIG5ldyByZWQtYmxhY2sgdHJlZSwgYWxs b2NhdGluZyB0ZW1wb3Jhcnkgb2JqZWN0cworICAgIC8vIGZyb20gYSBuZXdseSBjb25zdHJ1Y3Rl ZCBQT0RBcmVuYS4KKyAgICBQT0RSZWRCbGFja1RyZWUoKQorICAgICAgICA6IG1fYXJlbmEoUE9E QXJlbmE6OmNyZWF0ZSgpKQorICAgICAgICAsIG1fcm9vdCgwKQorICAgICAgICAsIG1fbmVlZHNG dWxsT3JkZXJpbmdDb21wYXJpc29ucyhmYWxzZSkKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICwg bV92ZXJib3NlRGVidWdnaW5nKGZhbHNlKQorI2VuZGlmCisgICAgeworICAgIH0KKworICAgIC8v IENvbnN0cnVjdHMgYSBuZXcgcmVkLWJsYWNrIHRyZWUsIGFsbG9jYXRpbmcgdGVtcG9yYXJ5IG9i amVjdHMKKyAgICAvLyBmcm9tIHRoZSBnaXZlbiBQT0RBcmVuYS4KKyAgICBleHBsaWNpdCBQT0RS ZWRCbGFja1RyZWUoUE9EQXJlbmEqIGFyZW5hKQorICAgICAgICA6IG1fYXJlbmEoYXJlbmEpCisg ICAgICAgICwgbV9yb290KDApCisgICAgICAgICwgbV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlz b25zKGZhbHNlKQorI2lmbmRlZiBOREVCVUcKKyAgICAgICAgLCBtX3ZlcmJvc2VEZWJ1Z2dpbmco ZmFsc2UpCisjZW5kaWYKKyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB+UE9EUmVkQmxhY2tU cmVlKCkgeyB9CisKKyAgICB2b2lkIGFkZChjb25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAg Tm9kZSogbm9kZSA9IG5ldyBOb2RlKGRhdGEpOworICAgICAgICBpbnNlcnROb2RlKG5vZGUpOwor ICAgIH0KKworICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgZGF0dW0gd2FzIGZvdW5kIGluIHRo ZSB0cmVlLgorICAgIGJvb2wgcmVtb3ZlKGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICBO b2RlKiBub2RlID0gdHJlZVNlYXJjaChkYXRhKTsKKyAgICAgICAgaWYgKG5vZGUpIHsKKyAgICAg ICAgICAgIGRlbGV0ZU5vZGUobm9kZSk7CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAg ICAgfQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgYm9vbCBjb250YWlucyhj b25zdCBUJiBkYXRhKSB7IHJldHVybiB0cmVlU2VhcmNoKGRhdGEpOyB9CisKKyAgICB2b2lkIHZp c2l0SW5vcmRlcihWaXNpdG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAgICAgaWYgKCFtX3Jvb3Qp CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIHZpc2l0SW5vcmRlckltcGwobV9yb290LCB2 aXNpdG9yKTsKKyAgICB9CisKKyAgICBpbnQgc2l6ZSgpCisgICAgeworICAgICAgICBDb3VudGVy IGNvdW50ZXI7CisgICAgICAgIHZpc2l0SW5vcmRlcigmY291bnRlcik7CisgICAgICAgIHJldHVy biBjb3VudGVyLmNvdW50KCk7CisgICAgfQorCisgICAgLy8gU2VlIHRoZSBjbGFzcyBkb2N1bWVu dGF0aW9uIGZvciBhbiBleHBsYW5hdGlvbiBvZiB0aGlzIHByb3BlcnR5LgorICAgIHZvaWQgc2V0 TmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyhib29sIG5lZWRzRnVsbE9yZGVyaW5nQ29tcGFy aXNvbnMpCisgICAgeworICAgICAgICBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMgPSBu ZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBj aGVja0ludmFyaWFudHMoKQorICAgIHsKKyAgICAgICAgaW50IGJsYWNrQ291bnQ7CisgICAgICAg IHJldHVybiBjaGVja0ludmFyaWFudHNGcm9tTm9kZShtX3Jvb3QsICZibGFja0NvdW50KTsKKyAg ICB9CisKKyNpZm5kZWYgTkRFQlVHCisgICAgLy8gRHVtcHMgdGhlIHRyZWUncyBjb250ZW50cyB0 byB0aGUgbG9nZ2luZyBpbmZvIHN0cmVhbSBmb3IKKyAgICAvLyBkZWJ1Z2dpbmcgcHVycG9zZXMu CisgICAgdm9pZCBkdW1wKCkKKyAgICB7CisgICAgICAgIGR1bXBGcm9tTm9kZShtX3Jvb3QsIDAp OworICAgIH0KKworICAgIC8vIFR1cm5zIG9uIG9yIG9mZiB2ZXJib3NlIGRlYnVnZ2luZyBvZiB0 aGUgdHJlZSwgY2F1c2luZyBtYW55CisgICAgLy8gbWVzc2FnZXMgdG8gYmUgbG9nZ2VkIGR1cmlu ZyBpbnNlcnRpb24gYW5kIG90aGVyIG9wZXJhdGlvbnMgaW4KKyAgICAvLyBkZWJ1ZyBtb2RlLgor ICAgIHZvaWQgc2V0VmVyYm9zZURlYnVnZ2luZyhib29sIG9uT3JPZmYpCisgICAgeworICAgICAg ICBtX3ZlcmJvc2VEZWJ1Z2dpbmcgPSBvbk9yT2ZmOworICAgIH0KKyNlbmRpZgorCitwcm90ZWN0 ZWQ6CisgICAgZW51bSBDb2xvciB7CisgICAgICAgIGtSZWQgPSAxLAorICAgICAgICBrQmxhY2sK KyAgICB9OworCisgICAgLy8gVGhlIGJhc2UgTm9kZSBjbGFzcyB3aGljaCBpcyBzdG9yZWQgaW4g dGhlIHRyZWUuIE5vZGVzIGFyZSBvbmx5CisgICAgLy8gYW4gaW50ZXJuYWwgY29uY2VwdDsgdXNl cnMgb2YgdGhlIHRyZWUgZGVhbCBvbmx5IHdpdGggdGhlIGRhdGEKKyAgICAvLyB0aGV5IHN0b3Jl IGluIGl0LgorICAgIGNsYXNzIE5vZGUgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgIHB1Ymxp YzoKKyAgICAgICAgLy8gQ29uc3RydWN0b3IuIE5ld2x5LWNyZWF0ZWQgbm9kZXMgYXJlIGNvbG9y ZWQgcmVkLgorICAgICAgICBleHBsaWNpdCBOb2RlKGNvbnN0IFQmIGRhdGEpCisgICAgICAgICAg ICA6IG1fbGVmdCgwKQorICAgICAgICAgICAgLCBtX3JpZ2h0KDApCisgICAgICAgICAgICAsIG1f cGFyZW50KDApCisgICAgICAgICAgICAsIG1fY29sb3Ioa1JlZCkKKyAgICAgICAgICAgICwgbV9k YXRhKGRhdGEpCisgICAgICAgIHsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgfk5vZGUo KSB7IH0KKworICAgICAgICBDb2xvciBjb2xvcigpIGNvbnN0IHsgcmV0dXJuIG1fY29sb3I7IH0K KyAgICAgICAgdm9pZCBzZXRDb2xvcihDb2xvciBjb2xvcikgeyBtX2NvbG9yID0gY29sb3I7IH0K KworICAgICAgICAvLyBGZXRjaGVzIHRoZSB1c2VyIGRhdGEuCisgICAgICAgIFQmIGRhdGEoKSB7 IHJldHVybiBtX2RhdGE7IH0KKworICAgICAgICAvLyBDb3BpZXMgYWxsIHVzZXItbGV2ZWwgZmll bGRzIGZyb20gdGhlIHNvdXJjZSBub2RlLCBidXQgbm90CisgICAgICAgIC8vIGludGVybmFsIGZp ZWxkcy4gRm9yIGV4YW1wbGUsIHRoZSBiYXNlIGltcGxlbWVudGF0aW9uIG9mIHRoaXMKKyAgICAg ICAgLy8gbWV0aG9kIGNvcGllcyB0aGUgIm1fZGF0YSIgZmllbGQsIGJ1dCBub3QgdGhlIGNoaWxk IG9yIHBhcmVudAorICAgICAgICAvLyBmaWVsZHMuIEFueSBhdWdtZW50YXRpb24gaW5mb3JtYXRp b24gYWxzbyBkb2VzIG5vdCBuZWVkIHRvIGJlCisgICAgICAgIC8vIGNvcGllZCwgYXMgaXQgd2ls bCBiZSByZWNvbXB1dGVkLiBTdWJjbGFzc2VzIG11c3QgY2FsbCB0aGUKKyAgICAgICAgLy8gc3Vw ZXJjbGFzcyBpbXBsZW1lbnRhdGlvbi4KKyAgICAgICAgdmlydHVhbCB2b2lkIGNvcHlGcm9tKE5v ZGUqIHNyYykgeyBtX2RhdGEgPSBzcmMtPmRhdGEoKTsgfQorCisgICAgICAgIE5vZGUqIGxlZnQo KSBjb25zdCB7IHJldHVybiBtX2xlZnQ7IH0KKyAgICAgICAgdm9pZCBzZXRMZWZ0KE5vZGUqIG5v ZGUpIHsgbV9sZWZ0ID0gbm9kZTsgfQorCisgICAgICAgIE5vZGUqIHJpZ2h0KCkgY29uc3QgeyBy ZXR1cm4gbV9yaWdodDsgfQorICAgICAgICB2b2lkIHNldFJpZ2h0KE5vZGUqIG5vZGUpIHsgbV9y aWdodCA9IG5vZGU7IH0KKworICAgICAgICBOb2RlKiBwYXJlbnQoKSBjb25zdCB7IHJldHVybiBt X3BhcmVudDsgfQorICAgICAgICB2b2lkIHNldFBhcmVudChOb2RlKiBub2RlKSB7IG1fcGFyZW50 ID0gbm9kZTsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgTm9kZSogbV9sZWZ0OworICAgICAg ICBOb2RlKiBtX3JpZ2h0OworICAgICAgICBOb2RlKiBtX3BhcmVudDsKKyAgICAgICAgQ29sb3Ig bV9jb2xvcjsKKyAgICAgICAgVCBtX2RhdGE7CisgICAgfTsKKworICAgIC8vIFJldHVybnMgdGhl IHJvb3Qgb2YgdGhlIHRyZWUsIHdoaWNoIGlzIG5lZWRlZCBieSBzb21lIHN1YmNsYXNzZXMuCisg ICAgTm9kZSogcm9vdCgpIGNvbnN0IHsgcmV0dXJuIG1fcm9vdDsgfQorCitwcml2YXRlOgorICAg IC8vIFRoaXMgdmlydHVhbCBtZXRob2QgaXMgdGhlIGhvb2sgdGhhdCBzdWJjbGFzc2VzIHNob3Vs ZCB1c2Ugd2hlbgorICAgIC8vIGF1Z21lbnRpbmcgdGhlIHJlZC1ibGFjayB0cmVlIHdpdGggYWRk aXRpb25hbCBwZXItbm9kZSBzdW1tYXJ5CisgICAgLy8gaW5mb3JtYXRpb24uIEZvciBleGFtcGxl LCBpbiB0aGUgY2FzZSBvZiBhbiBpbnRlcnZhbCB0cmVlLCB0aGlzCisgICAgLy8gaXMgdXNlZCB0 byBjb21wdXRlIHRoZSBtYXhpbXVtIGVuZHBvaW50IG9mIHRoZSBzdWJ0cmVlIGJlbG93IHRoZQor ICAgIC8vIGdpdmVuIG5vZGUgYmFzZWQgb24gdGhlIHZhbHVlcyBpbiB0aGUgbGVmdCBhbmQgcmln aHQgY2hpbGRyZW4uIEl0CisgICAgLy8gaXMgZ3VhcmFudGVlZCB0aGF0IHRoaXMgd2lsbCBiZSBj YWxsZWQgaW4gdGhlIGNvcnJlY3Qgb3JkZXIgdG8KKyAgICAvLyBwcm9wZXJseSB1cGRhdGUgc3Vj aCBzdW1tYXJ5IGluZm9ybWF0aW9uIGJhc2VkIG9ubHkgb24gdGhlIHZhbHVlcworICAgIC8vIGlu IHRoZSBsZWZ0IGFuZCByaWdodCBjaGlsZHJlbi4gVGhpcyBtZXRob2Qgc2hvdWxkIHJldHVybiB0 cnVlIGlmCisgICAgLy8gdGhlIG5vZGUncyBzdW1tYXJ5IGluZm9ybWF0aW9uIGNoYW5nZWQuCisg ICAgdmlydHVhbCBib29sIHVwZGF0ZU5vZGUoTm9kZSogbm9kZSkgeyByZXR1cm4gZmFsc2U7IH0K KworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEdlbmVyaWMgYmluYXJ5IHNlYXJjaCB0cmVl IG9wZXJhdGlvbnMKKyAgICAvLworCisgICAgLy8gU2VhcmNoZXMgdGhlIHRyZWUgZm9yIHRoZSBn aXZlbiBkYXR1bS4KKyAgICBOb2RlKiB0cmVlU2VhcmNoKGNvbnN0IFQmIGRhdGEpCisgICAgewor ICAgICAgICBpZiAobV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKQorICAgICAgICAgICAg cmV0dXJuIHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMobV9yb290LCBkYXRhKTsKKworICAgICAg ICByZXR1cm4gdHJlZVNlYXJjaE5vcm1hbChtX3Jvb3QsIGRhdGEpOworICAgIH0KKworICAgIC8v IFNlYXJjaGVzIHRoZSB0cmVlIHVzaW5nIHRoZSBub3JtYWwgY29tcGFyaXNvbiBvcGVyYXRpb25z LAorICAgIC8vIHN1aXRhYmxlIGZvciBzaW1wbGUgZGF0YSB0eXBlcyBzdWNoIGFzIG51bWJlcnMu CisgICAgTm9kZSogdHJlZVNlYXJjaE5vcm1hbChOb2RlKiBjdXJyZW50LCBjb25zdCBUJiBkYXRh KQorICAgIHsKKyAgICAgICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAgICAgIGlmIChjdXJy ZW50LT5kYXRhKCkgPT0gZGF0YSkKKyAgICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAg ICAgICAgICAgIGlmIChkYXRhIDwgY3VycmVudC0+ZGF0YSgpKQorICAgICAgICAgICAgICAgIGN1 cnJlbnQgPSBjdXJyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAg ICAgY3VycmVudCA9IGN1cnJlbnQtPnJpZ2h0KCk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJu IDA7CisgICAgfQorCisgICAgLy8gU2VhcmNoZXMgdGhlIHRyZWUgdXNpbmcgbXVsdGlwbGUgY29t cGFyaXNvbiBvcGVyYXRpb25zLCByZXF1aXJlZAorICAgIC8vIGZvciBkYXRhIHR5cGVzIHdpdGgg bW9yZSBjb21wbGV4IGJlaGF2aW9yIHN1Y2ggYXMgaW50ZXJ2YWxzLgorICAgIE5vZGUqIHRyZWVT ZWFyY2hGdWxsQ29tcGFyaXNvbnMoTm9kZSogY3VycmVudCwgY29uc3QgVCYgZGF0YSkKKyAgICB7 CisgICAgICAgIGlmICghY3VycmVudCkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICBp ZiAoZGF0YSA8IGN1cnJlbnQtPmRhdGEoKSkKKyAgICAgICAgICAgIHJldHVybiB0cmVlU2VhcmNo RnVsbENvbXBhcmlzb25zKGN1cnJlbnQtPmxlZnQoKSwgZGF0YSk7CisgICAgICAgIGlmIChjdXJy ZW50LT5kYXRhKCkgPCBkYXRhKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hGdWxsQ29t cGFyaXNvbnMoY3VycmVudC0+cmlnaHQoKSwgZGF0YSk7CisgICAgICAgIGlmIChkYXRhID09IGN1 cnJlbnQtPmRhdGEoKSkKKyAgICAgICAgICAgIHJldHVybiBjdXJyZW50OworCisgICAgICAgIC8v IFdlIG1heSBuZWVkIHRvIHRyYXZlcnNlIGJvdGggdGhlIGxlZnQgYW5kIHJpZ2h0IHN1YnRyZWVz LgorICAgICAgICBOb2RlKiByZXN1bHQgPSB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKGN1cnJl bnQtPmxlZnQoKSwgZGF0YSk7CisgICAgICAgIGlmICghcmVzdWx0KQorICAgICAgICAgICAgcmVz dWx0ID0gdHJlZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhjdXJyZW50LT5yaWdodCgpLCBkYXRhKTsK KyAgICAgICAgcmV0dXJuIHJlc3VsdDsKKyAgICB9CisKKyAgICB2b2lkIHRyZWVJbnNlcnQoTm9k ZSogeikKKyAgICB7CisgICAgICAgIE5vZGUqIHkgPSAwOworICAgICAgICBOb2RlKiB4ID0gbV9y b290OworICAgICAgICB3aGlsZSAoeCkgeworICAgICAgICAgICAgeSA9IHg7CisgICAgICAgICAg ICBpZiAoei0+ZGF0YSgpIDwgeC0+ZGF0YSgpKQorICAgICAgICAgICAgICAgIHggPSB4LT5sZWZ0 KCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeCA9IHgtPnJpZ2h0KCk7Cisg ICAgICAgIH0KKyAgICAgICAgei0+c2V0UGFyZW50KHkpOworICAgICAgICBpZiAoIXkpCisgICAg ICAgICAgICBtX3Jvb3QgPSB6OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh6LT5k YXRhKCkgPCB5LT5kYXRhKCkpCisgICAgICAgICAgICAgICAgeS0+c2V0TGVmdCh6KTsKKyAgICAg ICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB5LT5zZXRSaWdodCh6KTsKKyAgICAgICAgfQor ICAgIH0KKworICAgIC8vIEZpbmRzIHRoZSBub2RlIGZvbGxvd2luZyB0aGUgZ2l2ZW4gb25lIGlu IHNlcXVlbnRpYWwgb3JkZXJpbmcgb2YKKyAgICAvLyB0aGVpciBkYXRhLCBvciBudWxsIGlmIG5v bmUgZXhpc3RzLgorICAgIE5vZGUqIHRyZWVTdWNjZXNzb3IoTm9kZSogeCkKKyAgICB7CisgICAg ICAgIGlmICh4LT5yaWdodCgpKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVNaW5pbXVtKHgtPnJp Z2h0KCkpOworICAgICAgICBOb2RlKiB5ID0geC0+cGFyZW50KCk7CisgICAgICAgIHdoaWxlICh5 ICYmIHggPT0geS0+cmlnaHQoKSkgeworICAgICAgICAgICAgeCA9IHk7CisgICAgICAgICAgICB5 ID0geS0+cGFyZW50KCk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHk7CisgICAgfQorCisg ICAgLy8gRmluZHMgdGhlIG1pbmltdW0gZWxlbWVudCBpbiB0aGUgc3ViLXRyZWUgcm9vdGVkIGF0 IHRoZSBnaXZlbgorICAgIC8vIG5vZGUuCisgICAgTm9kZSogdHJlZU1pbmltdW0oTm9kZSogeCkK KyAgICB7CisgICAgICAgIHdoaWxlICh4LT5sZWZ0KCkpCisgICAgICAgICAgICB4ID0geC0+bGVm dCgpOworICAgICAgICByZXR1cm4geDsKKyAgICB9CisKKyAgICAvLyBIZWxwZXIgZm9yIG1haW50 YWluaW5nIHRoZSBhdWdtZW50ZWQgcmVkLWJsYWNrIHRyZWUuCisgICAgdm9pZCBwcm9wYWdhdGVV cGRhdGVzKE5vZGUqIHN0YXJ0KQorICAgIHsKKyAgICAgICAgYm9vbCBzaG91bGRDb250aW51ZSA9 IHRydWU7CisgICAgICAgIHdoaWxlIChzdGFydCAmJiBzaG91bGRDb250aW51ZSkgeworICAgICAg ICAgICAgc2hvdWxkQ29udGludWUgPSB1cGRhdGVOb2RlKHN0YXJ0KTsKKyAgICAgICAgICAgIHN0 YXJ0ID0gc3RhcnQtPnBhcmVudCgpOworICAgICAgICB9CisgICAgfQorCisgICAgLy8tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCisgICAgLy8gUmVkLUJsYWNrIHRyZWUgb3BlcmF0aW9ucworICAgIC8vCisKKyAgICAv LyBMZWZ0LXJvdGF0ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHguCisgICAgLy8gUmV0dXJucyB0 aGUgbmV3IHJvb3Qgb2YgdGhlIHN1YnRyZWUgKHgncyByaWdodCBjaGlsZCkuCisgICAgTm9kZSog bGVmdFJvdGF0ZShOb2RlKiB4KQorICAgIHsKKyAgICAgICAgLy8gU2V0IHkuCisgICAgICAgIE5v ZGUqIHkgPSB4LT5yaWdodCgpOworCisgICAgICAgIC8vIFR1cm4geSdzIGxlZnQgc3VidHJlZSBp bnRvIHgncyByaWdodCBzdWJ0cmVlLgorICAgICAgICB4LT5zZXRSaWdodCh5LT5sZWZ0KCkpOwor ICAgICAgICBpZiAoeS0+bGVmdCgpKQorICAgICAgICAgICAgeS0+bGVmdCgpLT5zZXRQYXJlbnQo eCk7CisKKyAgICAgICAgLy8gTGluayB4J3MgcGFyZW50IHRvIHkuCisgICAgICAgIHktPnNldFBh cmVudCh4LT5wYXJlbnQoKSk7CisgICAgICAgIGlmICgheC0+cGFyZW50KCkpCisgICAgICAgICAg ICBtX3Jvb3QgPSB5OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh4ID09IHgtPnBh cmVudCgpLT5sZWZ0KCkpCisgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldExlZnQoeSk7 CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldFJpZ2h0 KHkpOworICAgICAgICB9CisKKyAgICAgICAgLy8gUHV0IHggb24geSdzIGxlZnQuCisgICAgICAg IHktPnNldExlZnQoeCk7CisgICAgICAgIHgtPnNldFBhcmVudCh5KTsKKworICAgICAgICAvLyBV cGRhdGUgbm9kZXMgbG93ZXN0IHRvIGhpZ2hlc3QuCisgICAgICAgIHVwZGF0ZU5vZGUoeCk7Cisg ICAgICAgIHVwZGF0ZU5vZGUoeSk7CisgICAgICAgIHJldHVybiB5OworICAgIH0KKworICAgIC8v IFJpZ2h0LXJvdGF0ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHkuCisgICAgLy8gUmV0dXJucyB0 aGUgbmV3IHJvb3Qgb2YgdGhlIHN1YnRyZWUgKHkncyBsZWZ0IGNoaWxkKS4KKyAgICBOb2RlKiBy aWdodFJvdGF0ZShOb2RlKiB5KQorICAgIHsKKyAgICAgICAgLy8gU2V0IHguCisgICAgICAgIE5v ZGUqIHggPSB5LT5sZWZ0KCk7CisKKyAgICAgICAgLy8gVHVybiB4J3MgcmlnaHQgc3VidHJlZSBp bnRvIHkncyBsZWZ0IHN1YnRyZWUuCisgICAgICAgIHktPnNldExlZnQoeC0+cmlnaHQoKSk7Cisg ICAgICAgIGlmICh4LT5yaWdodCgpKQorICAgICAgICAgICAgeC0+cmlnaHQoKS0+c2V0UGFyZW50 KHkpOworCisgICAgICAgIC8vIExpbmsgeSdzIHBhcmVudCB0byB4LgorICAgICAgICB4LT5zZXRQ YXJlbnQoeS0+cGFyZW50KCkpOworICAgICAgICBpZiAoIXktPnBhcmVudCgpKQorICAgICAgICAg ICAgbV9yb290ID0geDsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBpZiAoeSA9PSB5LT5w YXJlbnQoKS0+bGVmdCgpKQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRMZWZ0KHgp OworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRSaWdo dCh4KTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFB1dCB5IG9uIHgncyByaWdodC4KKyAgICAg ICAgeC0+c2V0UmlnaHQoeSk7CisgICAgICAgIHktPnNldFBhcmVudCh4KTsKKworICAgICAgICAv LyBVcGRhdGUgbm9kZXMgbG93ZXN0IHRvIGhpZ2hlc3QuCisgICAgICAgIHVwZGF0ZU5vZGUoeSk7 CisgICAgICAgIHVwZGF0ZU5vZGUoeCk7CisgICAgICAgIHJldHVybiB4OworICAgIH0KKworICAg IC8vIEluc2VydHMgdGhlIGdpdmVuIG5vZGUgaW50byB0aGUgdHJlZS4KKyAgICB2b2lkIGluc2Vy dE5vZGUoTm9kZSogeCkKKyAgICB7CisgICAgICAgIHRyZWVJbnNlcnQoeCk7CisgICAgICAgIHgt PnNldENvbG9yKGtSZWQpOworICAgICAgICB1cGRhdGVOb2RlKHgpOworCisjaWZuZGVmIE5ERUJV RworICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgTE9HX0VSUk9S KCIgIFBPRFJlZEJsYWNrVHJlZTo6SW5zZXJ0Tm9kZSIpOworI2VuZGlmCisKKyAgICAgICAgLy8g VGhlIG5vZGUgZnJvbSB3aGljaCB0byBzdGFydCBwcm9wYWdhdGluZyB1cGRhdGVzIHVwd2FyZHMu CisgICAgICAgIE5vZGUqIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisKKyAgICAgICAgd2hp bGUgKHggIT0gbV9yb290ICYmIHgtPnBhcmVudCgpLT5jb2xvcigpID09IGtSZWQpIHsKKyAgICAg ICAgICAgIGlmICh4LT5wYXJlbnQoKSA9PSB4LT5wYXJlbnQoKS0+cGFyZW50KCktPmxlZnQoKSkg eworICAgICAgICAgICAgICAgIE5vZGUqIHkgPSB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnJpZ2h0 KCk7CisgICAgICAgICAgICAgICAgaWYgKHkgJiYgeS0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAg ICAgICAgICAgICAgICAgIC8vIENhc2UgMQorI2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAgICAg ICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2luZykKKyAgICAgICAgICAgICAgICAgICAgICAgIExP R19FUlJPUigiICBDYXNlIDEvMSIpOworI2VuZGlmCisgICAgICAgICAgICAgICAgICAgIHgtPnBh cmVudCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB5LT5zZXRDb2xv cihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNl dENvbG9yKGtSZWQpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVOb2RlKHgtPnBhcmVudCgp KTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAg ICAgICAgICAgICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRl U3RhcnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAg ICAgICAgICAgICBpZiAoeCA9PSB4LT5wYXJlbnQoKS0+cmlnaHQoKSkgeworI2lmbmRlZiBOREVC VUcKKyAgICAgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dpbmcpCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgTE9HX0VSUk9SKCIgIENhc2UgMS8yIik7CisjZW5kaWYK KyAgICAgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICAg ICAgeCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAgICAgbGVmdFJvdGF0ZSh4 KTsKKyAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDMK KyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dp bmcpCisgICAgICAgICAgICAgICAgICAgICAgICBMT0dfRVJST1IoIiAgQ2FzZSAxLzMiKTsKKyNl bmRpZgorICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsK KyAgICAgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihrUmVk KTsKKyAgICAgICAgICAgICAgICAgICAgTm9kZSogbmV3U3ViVHJlZVJvb3QgPSByaWdodFJvdGF0 ZSh4LT5wYXJlbnQoKS0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVTdGFy dCA9IG5ld1N1YlRyZWVSb290LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8vIFNhbWUgYXMgInRoZW4iIGNsYXVzZSB3 aXRoICJyaWdodCIgYW5kICJsZWZ0IiBleGNoYW5nZWQuCisgICAgICAgICAgICAgICAgTm9kZSog eSA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKS0+bGVmdCgpOworICAgICAgICAgICAgICAgIGlmICh5 ICYmIHktPmNvbG9yKCkgPT0ga1JlZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDEK KyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICAgICAgICAgIGlmIChtX3ZlcmJvc2VEZWJ1Z2dp bmcpCisgICAgICAgICAgICAgICAgICAgICAgICBMT0dfRVJST1IoIiAgQ2FzZSAyLzEiKTsKKyNl bmRpZgorICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3Ioa0JsYWNrKTsK KyAgICAgICAgICAgICAgICAgICAgeS0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAg ICAgICAgeC0+cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAg ICAgICAgICAgdXBkYXRlTm9kZSh4LT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHgg PSB4LT5wYXJlbnQoKS0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZU5vZGUo eCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisgICAg ICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHggPT0geC0+cGFy ZW50KCktPmxlZnQoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAyCisjaWZu ZGVmIE5ERUJVRworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVnZ2lu ZykKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBMT0dfRVJST1IoIiAgQ2FzZSAyLzIiKTsK KyNlbmRpZgorICAgICAgICAgICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVudCgpOworICAgICAg ICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeCk7CisgICAgICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAzCisjaWZuZGVmIE5ERUJVRworICAgICAgICAg ICAgICAgICAgICBpZiAobV92ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgICAgICAgICAg ICAgTE9HX0VSUk9SKCIgIENhc2UgMi8zIik7CisjZW5kaWYKKyAgICAgICAgICAgICAgICAgICAg eC0+cGFyZW50KCktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHgtPnBh cmVudCgpLT5wYXJlbnQoKS0+c2V0Q29sb3Ioa1JlZCk7CisgICAgICAgICAgICAgICAgICAgIE5v ZGUqIG5ld1N1YlRyZWVSb290ID0gbGVmdFJvdGF0ZSh4LT5wYXJlbnQoKS0+cGFyZW50KCkpOwor ICAgICAgICAgICAgICAgICAgICB1cGRhdGVTdGFydCA9IG5ld1N1YlRyZWVSb290LT5wYXJlbnQo KTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAg ICBwcm9wYWdhdGVVcGRhdGVzKHVwZGF0ZVN0YXJ0KTsKKworICAgICAgICBtX3Jvb3QtPnNldENv bG9yKGtCbGFjayk7CisgICAgfQorCisgICAgLy8gUmVzdG9yZXMgdGhlIHJlZC1ibGFjayBwcm9w ZXJ0eSB0byB0aGUgdHJlZSBhZnRlciBzcGxpY2luZyBvdXQKKyAgICAvLyBhIG5vZGUuIE5vdGUg dGhhdCB4IG1heSBiZSBudWxsLCB3aGljaCBpcyB3aHkgeFBhcmVudCBtdXN0IGJlCisgICAgLy8g c3VwcGxpZWQuCisgICAgdm9pZCBkZWxldGVGaXh1cChOb2RlKiB4LCBOb2RlKiB4UGFyZW50KQor ICAgIHsKKyAgICAgICAgd2hpbGUgKHggIT0gbV9yb290ICYmICgheCB8fCB4LT5jb2xvcigpID09 IGtCbGFjaykpIHsKKyAgICAgICAgICAgIGlmICh4ID09IHhQYXJlbnQtPmxlZnQoKSkgeworICAg ICAgICAgICAgICAgIC8vIE5vdGU6IHRoZSB0ZXh0IHBvaW50cyBvdXQgdGhhdCB3IGNhbiBub3Qg YmUgbnVsbC4KKyAgICAgICAgICAgICAgICAvLyBUaGUgcmVhc29uIGlzIG5vdCBvYnZpb3VzIGZy b20gc2ltcGx5IGxvb2tpbmcgYXQKKyAgICAgICAgICAgICAgICAvLyB0aGUgY29kZTsgaXQgY29t ZXMgYWJvdXQgZnJvbSB0aGUgcHJvcGVydGllcyBvZiB0aGUKKyAgICAgICAgICAgICAgICAvLyBy ZWQtYmxhY2sgdHJlZS4KKyAgICAgICAgICAgICAgICBOb2RlKiB3ID0geFBhcmVudC0+cmlnaHQo KTsKKyAgICAgICAgICAgICAgICBBU1NFUlQodyk7IC8vIHgncyBzaWJsaW5nIHNob3VsZCBub3Qg YmUgbnVsbC4KKyAgICAgICAgICAgICAgICBpZiAody0+Y29sb3IoKSA9PSBrUmVkKSB7CisgICAg ICAgICAgICAgICAgICAgIC8vIENhc2UgMQorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xv cihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihrUmVkKTsK KyAgICAgICAgICAgICAgICAgICAgbGVmdFJvdGF0ZSh4UGFyZW50KTsKKyAgICAgICAgICAgICAg ICAgICAgdyA9IHhQYXJlbnQtPnJpZ2h0KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgICAgIGlmICgoIXctPmxlZnQoKSB8fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKQor ICAgICAgICAgICAgICAgICAgICAmJiAoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3Io KSA9PSBrQmxhY2spKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAg ICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHhQ YXJlbnQ7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAg ICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoIXctPnJpZ2h0KCkg fHwgdy0+cmlnaHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgIC8vIENhc2UgMworICAgICAgICAgICAgICAgICAgICAgICAgdy0+bGVmdCgpLT5zZXRDb2xv cihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICAgICAgdy0+c2V0Q29sb3Ioa1JlZCk7Cisg ICAgICAgICAgICAgICAgICAgICAgICByaWdodFJvdGF0ZSh3KTsKKyAgICAgICAgICAgICAgICAg ICAgICAgIHcgPSB4UGFyZW50LT5yaWdodCgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICAgICAgICAgIC8vIENhc2UgNAorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xv cih4UGFyZW50LT5jb2xvcigpKTsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0Q29s b3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHctPnJpZ2h0KCkpCisgICAgICAg ICAgICAgICAgICAgICAgICB3LT5yaWdodCgpLT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAg ICAgICAgICAgICBsZWZ0Um90YXRlKHhQYXJlbnQpOworICAgICAgICAgICAgICAgICAgICB4ID0g bV9yb290OworICAgICAgICAgICAgICAgICAgICB4UGFyZW50ID0geC0+cGFyZW50KCk7CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvLyBT YW1lIGFzICJ0aGVuIiBjbGF1c2Ugd2l0aCAicmlnaHQiIGFuZCAibGVmdCIKKyAgICAgICAgICAg ICAgICAvLyBleGNoYW5nZWQuCisKKyAgICAgICAgICAgICAgICAvLyBOb3RlOiB0aGUgdGV4dCBw b2ludHMgb3V0IHRoYXQgdyBjYW4gbm90IGJlIG51bGwuCisgICAgICAgICAgICAgICAgLy8gVGhl IHJlYXNvbiBpcyBub3Qgb2J2aW91cyBmcm9tIHNpbXBseSBsb29raW5nIGF0CisgICAgICAgICAg ICAgICAgLy8gdGhlIGNvZGU7IGl0IGNvbWVzIGFib3V0IGZyb20gdGhlIHByb3BlcnRpZXMgb2Yg dGhlCisgICAgICAgICAgICAgICAgLy8gcmVkLWJsYWNrIHRyZWUuCisgICAgICAgICAgICAgICAg Tm9kZSogdyA9IHhQYXJlbnQtPmxlZnQoKTsKKyAgICAgICAgICAgICAgICBBU1NFUlQodyk7IC8v IHgncyBzaWJsaW5nIHNob3VsZCBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAgICBpZiAody0+ Y29sb3IoKSA9PSBrUmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorICAgICAg ICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4 UGFyZW50LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUo eFBhcmVudCk7CisgICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5sZWZ0KCk7CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIGlmICgoIXctPnJpZ2h0KCkgfHwgdy0+cmln aHQoKS0+Y29sb3IoKSA9PSBrQmxhY2spCisgICAgICAgICAgICAgICAgICAgICYmICghdy0+bGVm dCgpIHx8IHctPmxlZnQoKS0+Y29sb3IoKSA9PSBrQmxhY2spKSB7CisgICAgICAgICAgICAgICAg ICAgIC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihrUmVkKTsKKyAg ICAgICAgICAgICAgICAgICAgeCA9IHhQYXJlbnQ7CisgICAgICAgICAgICAgICAgICAgIHhQYXJl bnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAg ICAgICAgICBpZiAoIXctPmxlZnQoKSB8fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0ga0JsYWNrKSB7 CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDMKKyAgICAgICAgICAgICAgICAgICAg ICAgIHctPnJpZ2h0KCktPnNldENvbG9yKGtCbGFjayk7CisgICAgICAgICAgICAgICAgICAgICAg ICB3LT5zZXRDb2xvcihrUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUo dyk7CisgICAgICAgICAgICAgICAgICAgICAgICB3ID0geFBhcmVudC0+bGVmdCgpOworICAgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgNAorICAgICAgICAg ICAgICAgICAgICB3LT5zZXRDb2xvcih4UGFyZW50LT5jb2xvcigpKTsKKyAgICAgICAgICAgICAg ICAgICAgeFBhcmVudC0+c2V0Q29sb3Ioa0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgaWYg KHctPmxlZnQoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIHctPmxlZnQoKS0+c2V0Q29sb3Io a0JsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAg ICAgICAgICAgICAgICAgIHggPSBtX3Jvb3Q7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQg PSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAg IH0KKyAgICAgICAgaWYgKHgpCisgICAgICAgICAgICB4LT5zZXRDb2xvcihrQmxhY2spOworICAg IH0KKworICAgIC8vIERlbGV0ZXMgdGhlIGdpdmVuIG5vZGUgZnJvbSB0aGUgdHJlZS4gTm90ZSB0 aGF0IHRoaXMKKyAgICAvLyBwYXJ0aWN1bGFyIG5vZGUgbWF5IG5vdCBhY3R1YWxseSBiZSByZW1v dmVkIGZyb20gdGhlIHRyZWU7CisgICAgLy8gaW5zdGVhZCwgYW5vdGhlciBub2RlIG1pZ2h0IGJl IHJlbW92ZWQgYW5kIGl0cyBjb250ZW50cworICAgIC8vIGNvcGllZCBpbnRvIHouCisgICAgdm9p ZCBkZWxldGVOb2RlKE5vZGUqIHopCisgICAgeworICAgICAgICAvLyBZIGlzIHRoZSBub2RlIHRv IGJlIHVubGlua2VkIGZyb20gdGhlIHRyZWUuCisgICAgICAgIE5vZGUqIHk7CisgICAgICAgIGlm ICghei0+bGVmdCgpIHx8ICF6LT5yaWdodCgpKQorICAgICAgICAgICAgeSA9IHo7CisgICAgICAg IGVsc2UKKyAgICAgICAgICAgIHkgPSB0cmVlU3VjY2Vzc29yKHopOworCisgICAgICAgIC8vIFkg aXMgZ3VhcmFudGVlZCB0byBiZSBub24tbnVsbCBhdCB0aGlzIHBvaW50LgorICAgICAgICBOb2Rl KiB4OworICAgICAgICBpZiAoeS0+bGVmdCgpKQorICAgICAgICAgICAgeCA9IHktPmxlZnQoKTsK KyAgICAgICAgZWxzZQorICAgICAgICAgICAgeCA9IHktPnJpZ2h0KCk7CisKKyAgICAgICAgLy8g WCBpcyB0aGUgY2hpbGQgb2YgeSB3aGljaCBtaWdodCBwb3RlbnRpYWxseSByZXBsYWNlIHkgaW4K KyAgICAgICAgLy8gdGhlIHRyZWUuIFggbWlnaHQgYmUgbnVsbCBhdCB0aGlzIHBvaW50LgorICAg ICAgICBOb2RlKiB4UGFyZW50OworICAgICAgICBpZiAoeCkgeworICAgICAgICAgICAgeC0+c2V0 UGFyZW50KHktPnBhcmVudCgpKTsKKyAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsK KyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICB4UGFyZW50ID0geS0+cGFyZW50KCk7CisgICAg ICAgIGlmICgheS0+cGFyZW50KCkpCisgICAgICAgICAgICBtX3Jvb3QgPSB4OworICAgICAgICBl bHNlIHsKKyAgICAgICAgICAgIGlmICh5ID09IHktPnBhcmVudCgpLT5sZWZ0KCkpCisgICAgICAg ICAgICAgICAgeS0+cGFyZW50KCktPnNldExlZnQoeCk7CisgICAgICAgICAgICBlbHNlCisgICAg ICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldFJpZ2h0KHgpOworICAgICAgICB9CisgICAgICAg IGlmICh5ICE9IHopIHsKKyAgICAgICAgICAgIHotPmNvcHlGcm9tKHkpOworICAgICAgICAgICAg Ly8gVGhpcyBub2RlIGhhcyBjaGFuZ2VkIGxvY2F0aW9uIGluIHRoZSB0cmVlIGFuZCBtdXN0IGJl IHVwZGF0ZWQuCisgICAgICAgICAgICB1cGRhdGVOb2RlKHopOworICAgICAgICAgICAgLy8gVGhl IHBhcmVudCBhbmQgaXRzIHBhcmVudHMgbWF5IG5vdyBiZSBvdXQgb2YgZGF0ZS4KKyAgICAgICAg ICAgIHByb3BhZ2F0ZVVwZGF0ZXMoei0+cGFyZW50KCkpOworICAgICAgICB9CisKKyAgICAgICAg Ly8gSWYgd2UgaGF2ZW4ndCBhbHJlYWR5IHVwZGF0ZWQgc3RhcnRpbmcgZnJvbSB4UGFyZW50LCBk byBzbyBub3cuCisgICAgICAgIGlmICh4UGFyZW50ICYmIHhQYXJlbnQgIT0geSAmJiB4UGFyZW50 ICE9IHopCisgICAgICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHhQYXJlbnQpOworICAgICAgICBp ZiAoeS0+Y29sb3IoKSA9PSBrQmxhY2spCisgICAgICAgICAgICBkZWxldGVGaXh1cCh4LCB4UGFy ZW50KTsKKyAgICB9CisKKyAgICAvLyBWaXNpdHMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHRoZSBn aXZlbiBub2RlIGluIG9yZGVyLgorICAgIHZvaWQgdmlzaXRJbm9yZGVySW1wbChOb2RlKiBub2Rl LCBWaXNpdG9yKiB2aXNpdG9yKQorICAgIHsKKyAgICAgICAgaWYgKG5vZGUtPmxlZnQoKSkKKyAg ICAgICAgICAgIHZpc2l0SW5vcmRlckltcGwobm9kZS0+bGVmdCgpLCB2aXNpdG9yKTsKKyAgICAg ICAgdmlzaXRvci0+dmlzaXQobm9kZS0+ZGF0YSgpKTsKKyAgICAgICAgaWYgKG5vZGUtPnJpZ2h0 KCkpCisgICAgICAgICAgICB2aXNpdElub3JkZXJJbXBsKG5vZGUtPnJpZ2h0KCksIHZpc2l0b3Ip OworICAgIH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIEhlbHBlciBjbGFzcyBmb3Ig c2l6ZSgpCisKKyAgICAvLyBBIFZpc2l0b3Igd2hpY2ggc2ltcGx5IGNvdW50cyB0aGUgbnVtYmVy IG9mIHZpc2l0ZWQgZWxlbWVudHMuCisgICAgY2xhc3MgQ291bnRlciA6IHB1YmxpYyBWaXNpdG9y LCBwdWJsaWMgTm9uY29weWFibGUgeworICAgIHB1YmxpYzoKKyAgICAgICAgQ291bnRlcigpCisg ICAgICAgICAgICA6IG1fY291bnQoMCkgeyB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkIHZpc2l0 KGNvbnN0IFQmIGRhdGEpIHsgKyttX2NvdW50OyB9CisgICAgICAgIGludCBjb3VudCgpIGNvbnN0 IHsgcmV0dXJuIG1fY291bnQ7IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIGludCBtX2NvdW50 OworICAgIH07CisKKyAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBWZXJpZmljYXRpb24gYW5k IGRlYnVnZ2luZyByb3V0aW5lcworICAgIC8vCisKKyAgICAvLyBSZXR1cm5zIGluIHRoZSAiYmxh Y2tDb3VudCIgcGFyYW1ldGVyIHRoZSBudW1iZXIgb2YgYmxhY2sKKyAgICAvLyBjaGlsZHJlbiBh bG9uZyBhbGwgcGF0aHMgdG8gYWxsIGxlYXZlcyBvZiB0aGUgZ2l2ZW4gbm9kZS4KKyAgICBib29s IGNoZWNrSW52YXJpYW50c0Zyb21Ob2RlKE5vZGUqIG5vZGUsIGludCogYmxhY2tDb3VudCkKKyAg ICB7CisgICAgICAgIC8vIEJhc2UgY2FzZSBpcyBhIGxlYWYgbm9kZS4KKyAgICAgICAgaWYgKCFu b2RlKSB7CisgICAgICAgICAgICAqYmxhY2tDb3VudCA9IDE7CisgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIEVhY2ggbm9kZSBpcyBlaXRoZXIgcmVkIG9y IGJsYWNrLgorICAgICAgICBpZiAoIShub2RlLT5jb2xvcigpID09IGtSZWQgfHwgbm9kZS0+Y29s b3IoKSA9PSBrQmxhY2spKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIC8v IEV2ZXJ5IGxlYWYgKG9yIG51bGwpIGlzIGJsYWNrLgorCisgICAgICAgIGlmIChub2RlLT5jb2xv cigpID09IGtSZWQpIHsKKyAgICAgICAgICAgIC8vIEJvdGggb2YgaXRzIGNoaWxkcmVuIGFyZSBi bGFjay4KKyAgICAgICAgICAgIGlmICghKCghbm9kZS0+bGVmdCgpIHx8IG5vZGUtPmxlZnQoKS0+ Y29sb3IoKSA9PSBrQmxhY2spKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAg ICAgICAgICBpZiAoISgoIW5vZGUtPnJpZ2h0KCkgfHwgbm9kZS0+cmlnaHQoKS0+Y29sb3IoKSA9 PSBrQmxhY2spKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKwor ICAgICAgICAvLyBFdmVyeSBzaW1wbGUgcGF0aCB0byBhIGxlYWYgbm9kZSBjb250YWlucyB0aGUg c2FtZSBudW1iZXIgb2YKKyAgICAgICAgLy8gYmxhY2sgbm9kZXMuCisgICAgICAgIGludCBsZWZ0 Q291bnQgPSAwLCByaWdodENvdW50ID0gMDsKKyAgICAgICAgYm9vbCBsZWZ0VmFsaWQgPSBjaGVj a0ludmFyaWFudHNGcm9tTm9kZShub2RlLT5sZWZ0KCksICZsZWZ0Q291bnQpOworICAgICAgICBi b29sIHJpZ2h0VmFsaWQgPSBjaGVja0ludmFyaWFudHNGcm9tTm9kZShub2RlLT5yaWdodCgpLCAm cmlnaHRDb3VudCk7CisgICAgICAgIGlmICghbGVmdFZhbGlkIHx8ICFyaWdodFZhbGlkKQorICAg ICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAqYmxhY2tDb3VudCA9IGxlZnRDb3VudCAr IChub2RlLT5jb2xvcigpID09IGtCbGFjayA/IDEgOiAwKTsKKyAgICAgICAgcmV0dXJuIGxlZnRD b3VudCA9PSByaWdodENvdW50OworICAgIH0KKworI2lmbmRlZiBOREVCVUcKKyAgICAvLyBEdW1w cyB0aGUgc3VidHJlZSByb290ZWQgYXQgdGhlIGdpdmVuIG5vZGUuCisgICAgdm9pZCBkdW1wRnJv bU5vZGUoTm9kZSogbm9kZSwgaW50IGluZGVudGF0aW9uKQorICAgIHsKKyAgICAgICAgU3RyaW5n QnVpbGRlciBidWlsZGVyOworICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IGluZGVudGF0aW9u OyBpKyspCisgICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiICIpOworICAgICAgICBidWlsZGVy LmFwcGVuZCgiLSIpOworICAgICAgICBpZiAobm9kZSkgeworICAgICAgICAgICAgYnVpbGRlci5h cHBlbmQoIiAiKTsKKyAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKHZhbHVlVG9TdHJpbmcobm9k ZS0+ZGF0YSgpKSk7CisgICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgobm9kZS0+Y29sb3IoKSA9 PSBrQmxhY2spID8gIiAoYmxhY2spIiA6ICIgKHJlZCkiKTsKKyAgICAgICAgfQorICAgICAgICBM T0dfRVJST1IoIiVzIiwgYnVpbGRlci50b1N0cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAg ICAgaWYgKG5vZGUpIHsKKyAgICAgICAgICAgIGR1bXBGcm9tTm9kZShub2RlLT5sZWZ0KCksIGlu ZGVudGF0aW9uICsgMik7CisgICAgICAgICAgICBkdW1wRnJvbU5vZGUobm9kZS0+cmlnaHQoKSwg aW5kZW50YXRpb24gKyAyKTsKKyAgICAgICAgfQorICAgIH0KKyNlbmRpZgorCisgICAgLy8tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisgICAgLy8gRGF0YSBtZW1iZXJzCisKKyAgICBSZWZQdHI8UE9EQXJlbmE+IG1f YXJlbmE7CisgICAgTm9kZSogbV9yb290OworICAgIGJvb2wgbV9uZWVkc0Z1bGxPcmRlcmluZ0Nv bXBhcmlzb25zOworI2lmbmRlZiBOREVCVUcKKyAgICBib29sIG1fdmVyYm9zZURlYnVnZ2luZzsK KyNlbmRpZgorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUE9EUmVk QmxhY2tUcmVlX2gK 66421 2010-09-02 15:30:00 -0700 2010-09-02 16:01:04 -0700 Revised patch red-black-tree.patch text/plain 37908 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjY4NykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODcgQEAKKzIwMTAtMDktMDIgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCByZWQtYmxhY2sgdHJlZSBjYXBhYmxlIG9mIGhvbGRpbmcgcGxhaW4gb2xkIGRhdGEgKFBPRCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1MDU5CisK KyAgICAgICAgQWRkaW5nIGFuIGF1Z21lbnRhYmxlIHJlZC1ibGFjayB0cmVlIGNhcGFibGUgb2Yg aG9sZGluZyBQbGFpbiBPbGQKKyAgICAgICAgRGF0YSAoUE9EKSwgb3IgY2xhc3NlcyBib3R0b21p bmcgb3V0IGludG8gb25seSBQT0QsIGFuZCBhbgorICAgICAgICBhc3NvY2lhdGVkIFBPREFyZW5h LiBOb3RlIHRoYXQgdGhlIFBPREFyZW5hIHdpbGwgYmUgdXNlZCBieSBvdGhlcgorICAgICAgICBj bGFzc2VzIHRvIGFsbG9jYXRlIHRlbXBvcmFyeSBzdHJ1Y3R1cmVzLCB3aGljaCBpcyB3aHkgaXQg aXMgbm90CisgICAgICAgIGp1c3QgYW4gaW1wbGVtZW50YXRpb24gZGV0YWlsIG9mIHRoZSByZWQt YmxhY2sgdHJlZS4KKworICAgICAgICBUaGVzZSBjbGFzc2VzIGFyZSBiZWluZyBwbGFjZWQgdW5k ZXIgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUKKyAgICAgICAgZm9yIHRoZSB0aW1lIGJl aW5nLiBJZiB0aGV5IGFyZSBnZW5lcmFsaXplZCB0byBob2xkIGV2ZW4gZGF0YQorICAgICAgICB0 eXBlcyB3aGljaCBpbnRlcm5hbGx5IHBlcmZvcm0gZHluYW1pYyBtZW1vcnkgYWxsb2NhdGlvbiwg d2UgbWF5CisgICAgICAgIGNvbnNpZGVyIG1vdmluZyB0aGVtIHRvIFdURiBpbiB0aGUgZnV0dXJl LgorCisgICAgICAgIFVuaXQgdGVzdHMgZm9yIHRoZSBQT0RSZWRCbGFja1RyZWUgd2lsbCBiZSBp bnRlZ3JhdGVkIHNlcGFyYXRlbHkKKyAgICAgICAgdW5kZXIgYnVnIDQ1MDYwLgorCisgICAgICAg ICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RBcmVu YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5hOjpBbGxvY2F0b3I6On5BbGxv Y2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxvY2F0b3I6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6RmFzdE1hbGxvY0FsbG9jYXRv cjo6YWxsb2NhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OmZyZWUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OkZhc3RNYWxsb2NBbGxvY2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6YWxsb2NhdGVPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6On5QT0RBcmVuYSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RBcmVuYTo6UE9EQXJlbmEpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6Om1pbkFs aWdubWVudCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6cm91bmRVcCk6CisgICAgICAg IChXZWJDb3JlOjpQT0RBcmVuYTo6Q2h1bms6OkNodW5rKToKKyAgICAgICAgKFdlYkNvcmU6OlBP REFyZW5hOjpDaHVuazo6fkNodW5rKToKKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5hOjpDaHVu azo6YWxsb2NhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RSZWRCbGFj a1RyZWUuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OlZpc2l0 b3I6On5WaXNpdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6UE9EUmVk QmxhY2tUcmVlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6flBPRFJlZEJs YWNrVHJlZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmFkZCk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6dmlzaXRJbm9yZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJl ZTo6c2l6ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnNldE5lZWRzRnVs bE9yZGVyaW5nQ29tcGFyaXNvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVl OjpjaGVja0ludmFyaWFudHMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpk dW1wKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6c2V0VmVyYm9zZURlYnVn Z2luZyk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6Ok5vZGUpOgor ICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjp+Tm9kZSk6CisgICAgICAg IChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OmNvbG9yKToKKyAgICAgICAgKFdlYkNv cmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0Q29sb3IpOgorICAgICAgICAoV2ViQ29yZTo6 UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6Tm9kZTo6Y29weUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tU cmVlOjpOb2RlOjpsZWZ0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9k ZTo6c2V0TGVmdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnJp Z2h0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0UmlnaHQp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpwYXJlbnQpOgorICAg ICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpzZXRQYXJlbnQpOgorICAgICAg ICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyb290KToKKyAgICAgICAgKFdlYkNvcmU6OlBP RFJlZEJsYWNrVHJlZTo6dXBkYXRlTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFj a1RyZWU6OnRyZWVTZWFyY2gpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0 cmVlU2VhcmNoTm9ybWFsKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJl ZVNlYXJjaEZ1bGxDb21wYXJpc29ucyk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OnRyZWVJbnNlcnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0cmVl U3VjY2Vzc29yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZU1pbmlt dW0pOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpwcm9wYWdhdGVVcGRhdGVz KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bGVmdFJvdGF0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnJpZ2h0Um90YXRlKToKKyAgICAgICAgKFdl YkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6aW5zZXJ0Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6OmRlbGV0ZUZpeHVwKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6ZGVsZXRlTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6 OnZpc2l0SW5vcmRlckltcGwpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpD b3VudGVyOjpDb3VudGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291 bnRlcjo6dmlzaXQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpDb3VudGVy Ojpjb3VudCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmNoZWNrSW52YXJp YW50c0Zyb21Ob2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bG9nSWZW ZXJib3NlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6ZHVtcEZyb21Ob2Rl KToKKwogMjAxMC0wOS0wMiAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBsZS5jb20+CiAKICAgICAg ICAgRmlsbCB0aGUgc2Nyb2xsIGNvcm5lciB3aXRoIHdoaXRlIHdoZW4gc2hvdWxkUGFpbnRDdXN0 b21TY3JvbGxiYXJzIGlzCkluZGV4OiBXZWJDb3JlL1dlYkNvcmUuZ3lwaQo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL1dlYkNvcmUuZ3lwaQkocmV2aXNpb24gNjY2NzUpCisrKyBXZWJDb3JlL1dlYkNv cmUuZ3lwaQkod29ya2luZyBjb3B5KQpAQCAtMjM0MSw2ICsyMzQxLDggQEAKICAgICAgICAgICAg ICdwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL1NvdXJjZUFscGhhLmgnLAogICAgICAgICAgICAg J3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvU291cmNlR3JhcGhpYy5jcHAnLAogICAgICAgICAg ICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2ZpbHRlcnMvU291cmNlR3JhcGhpYy5oJywKKyAgICAgICAg ICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9EQXJlbmEuaCcsCisgICAgICAgICAgICAncGxh dGZvcm0vZ3JhcGhpY3MvZ3B1L1BPRFJlZEJsYWNrVHJlZS5oJywKICAgICAgICAgICAgICdwbGF0 Zm9ybS9ncmFwaGljcy9ncHUvU2hhZGVyLmNwcCcsCiAgICAgICAgICAgICAncGxhdGZvcm0vZ3Jh cGhpY3MvZ3B1L1NoYWRlci5oJywKICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9ncHUv U29saWRGaWxsU2hhZGVyLmNwcCcsCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9QT0RBcmVuYS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1 L1BPREFyZW5hLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9QT0RBcmVuYS5oCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDIwMCBAQAorLyoKKyAqIENvcHly aWdodCAyMDEwLCBHb29nbGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFBPREFy ZW5hX2gKKyNkZWZpbmUgUE9EQXJlbmFfaAorCisjaW5jbHVkZSA8c3RkaW50Lmg+CisjaW5jbHVk ZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvRmFzdE1hbGxvYy5oPgorI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNpbmNsdWRl IDx3dGYvUGFzc093blB0ci5oPgorI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CisjaW5jbHVk ZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKKy8vIEFuIGFyZW5hIHdo aWNoIGFsbG9jYXRlcyBvbmx5IFBsYWluIE9sZCBEYXRhIChQT0QpLCBvciBjbGFzc2VzIGFuZAor Ly8gc3RydWN0cyBib3R0b21pbmcgb3V0IGluIFBsYWluIE9sZCBEYXRhLiBOT1RFOiB0aGUgY29u c3RydWN0b3JzIG9mCisvLyB0aGUgb2JqZWN0cyBhbGxvY2F0ZWQgaW4gdGhpcyBhcmVuYSBhcmUg Y2FsbGVkLCBidXQgX25vdF8gdGhlaXIKKy8vIGRlc3RydWN0b3JzLgorCitjbGFzcyBQT0RBcmVu YSA6IHB1YmxpYyBSZWZDb3VudGVkPFBPREFyZW5hPiB7CitwdWJsaWM6CisgICAgLy8gVGhlIGFy ZW5hIGlzIGNvbmZpZ3VyZWQgd2l0aCBhbiBhbGxvY2F0b3IsIHdoaWNoIGlzIHJlc3BvbnNpYmxl CisgICAgLy8gZm9yIGFsbG9jYXRpbmcgYW5kIGZyZWVpbmcgY2h1bmtzIG9mIG1lbW9yeSBhdCBh IHRpbWUuCisgICAgY2xhc3MgQWxsb2NhdG9yIDogcHVibGljIFJlZkNvdW50ZWQ8QWxsb2NhdG9y PiB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQqIGFsbG9jYXRlKHNpemVfdCBz aXplKSA9IDA7CisgICAgICAgIHZpcnR1YWwgdm9pZCBmcmVlKHZvaWQqIHB0cikgPSAwOworICAg IHByb3RlY3RlZDoKKyAgICAgICAgdmlydHVhbCB+QWxsb2NhdG9yKCkgeyB9CisgICAgICAgIGZy aWVuZCBjbGFzcyBXVEY6OlJlZkNvdW50ZWQ8QWxsb2NhdG9yPjsKKyAgICB9OworCisgICAgLy8g VGhlIEFyZW5hJ3MgZGVmYXVsdCBhbGxvY2F0b3IsIHdoaWNoIHVzZXMgZmFzdE1hbGxvYyBhbmQK KyAgICAvLyBmYXN0RnJlZSB0byBhbGxvY2F0ZSBjaHVua3Mgb2Ygc3RvcmFnZS4KKyAgICBjbGFz cyBGYXN0TWFsbG9jQWxsb2NhdG9yIDogcHVibGljIEFsbG9jYXRvciB7CisgICAgcHVibGljOgor ICAgICAgICBzdGF0aWMgUGFzc1JlZlB0cjxGYXN0TWFsbG9jQWxsb2NhdG9yPiBjcmVhdGUoKQor ICAgICAgICB7CisgICAgICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IEZhc3RNYWxsb2NBbGxv Y2F0b3IpOworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB2b2lkKiBhbGxvY2F0ZShzaXpl X3Qgc2l6ZSkgeyByZXR1cm4gZmFzdE1hbGxvYyhzaXplKTsgfQorICAgICAgICB2aXJ0dWFsIHZv aWQgZnJlZSh2b2lkKiBwdHIpIHsgZmFzdEZyZWUocHRyKTsgfQorCisgICAgcHJvdGVjdGVkOgor ICAgICAgICBGYXN0TWFsbG9jQWxsb2NhdG9yKCkgeyB9CisgICAgfTsKKworICAgIC8vIENyZWF0 ZXMgYSBuZXcgUE9EQXJlbmEgY29uZmlndXJlZCB3aXRoIGEgRmFzdE1hbGxvY0FsbG9jYXRvci4K KyAgICBzdGF0aWMgUGFzc1JlZlB0cjxQT0RBcmVuYT4gY3JlYXRlKCkKKyAgICB7CisgICAgICAg IHJldHVybiBhZG9wdFJlZihuZXcgUE9EQXJlbmEpOworICAgIH0KKworICAgIC8vIENyZWF0ZXMg YSBuZXcgUE9EQXJlbmEgY29uZmlndXJlZCB3aXRoIHRoZSBnaXZlbiBBbGxvY2F0b3IuCisgICAg c3RhdGljIFBhc3NSZWZQdHI8UE9EQXJlbmE+IGNyZWF0ZShBbGxvY2F0b3IqIGFsbG9jYXRvcikK KyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihuZXcgUE9EQXJlbmEoYWxsb2NhdG9yKSk7 CisgICAgfQorCisgICAgLy8gQWxsb2NhdGVzIGFuIG9iamVjdCBmcm9tIHRoZSBhcmVuYS4KKyAg ICB0ZW1wbGF0ZTxjbGFzcyBUPiBUKiBhbGxvY2F0ZU9iamVjdCgpCisgICAgeworICAgICAgICB2 b2lkKiBwdHIgPSAwOworICAgICAgICBzaXplX3Qgcm91bmRlZFNpemUgPSByb3VuZFVwKHNpemVv ZihUKSwgbWluQWxpZ25tZW50PFQ+KCkpOworICAgICAgICBpZiAobV9jdXJyZW50KQorICAgICAg ICAgICAgcHRyID0gbV9jdXJyZW50LT5hbGxvY2F0ZShyb3VuZGVkU2l6ZSk7CisKKyAgICAgICAg aWYgKCFwdHIpIHsKKyAgICAgICAgICAgIGlmIChyb3VuZGVkU2l6ZSA+IG1fY3VycmVudENodW5r U2l6ZSkKKyAgICAgICAgICAgICAgICBtX2N1cnJlbnRDaHVua1NpemUgPSByb3VuZGVkU2l6ZTsK KyAgICAgICAgICAgIG1fY2h1bmtzLmFwcGVuZChhZG9wdFB0cihuZXcgQ2h1bmsobV9hbGxvY2F0 b3IuZ2V0KCksIG1fY3VycmVudENodW5rU2l6ZSkpKTsKKyAgICAgICAgICAgIG1fY3VycmVudCA9 IG1fY2h1bmtzLmxhc3QoKS5nZXQoKTsKKyAgICAgICAgICAgIHB0ciA9IG1fY3VycmVudC0+YWxs b2NhdGUocm91bmRlZFNpemUpOworICAgICAgICB9CisKKyAgICAgICAgaWYgKHB0cikgeworICAg ICAgICAgICAgLy8gVXNlIHBsYWNlbWVudCBvcGVyYXRvciBuZXcgdG8gYWxsb2NhdGUgYSBUIGF0 IHRoaXMgbG9jYXRpb24uCisgICAgICAgICAgICBuZXcocHRyKSBUKCk7CisgICAgICAgIH0KKwor ICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+KHB0cik7CisgICAgfQorCitwcm90ZWN0ZWQ6 CisgICAgflBPREFyZW5hKCkgeyB9CisgICAgZnJpZW5kIGNsYXNzIFdURjo6UmVmQ291bnRlZDxQ T0RBcmVuYT47CisKK3ByaXZhdGU6CisgICAgUE9EQXJlbmEoKQorICAgICAgICA6IG1fYWxsb2Nh dG9yKEZhc3RNYWxsb2NBbGxvY2F0b3I6OmNyZWF0ZSgpKQorICAgICAgICAsIG1fY3VycmVudCgw KQorICAgICAgICAsIG1fY3VycmVudENodW5rU2l6ZShEZWZhdWx0Q2h1bmtTaXplKSB7IH0KKwor ICAgIGV4cGxpY2l0IFBPREFyZW5hKEFsbG9jYXRvciogYWxsb2NhdG9yKQorICAgICAgICA6IG1f YWxsb2NhdG9yKGFsbG9jYXRvcikKKyAgICAgICAgLCBtX2N1cnJlbnQoMCkKKyAgICAgICAgLCBt X2N1cnJlbnRDaHVua1NpemUoRGVmYXVsdENodW5rU2l6ZSkgeyB9CisKKyAgICBlbnVtIHsKKyAg ICAgICAgRGVmYXVsdENodW5rU2l6ZSA9IDE2Mzg0CisgICAgfTsKKworICAgIC8vIFJldHVybnMg dGhlIGFsaWdubWVudCByZXF1aXJlbWVudCBmb3IgY2xhc3NlcyBhbmQgc3RydWN0cyBvbiB0aGUK KyAgICAvLyBjdXJyZW50IHBsYXRmb3JtLgorICAgIHRlbXBsYXRlIDxjbGFzcyBUPiBzdGF0aWMg c2l6ZV90IG1pbkFsaWdubWVudCgpCisgICAgeworICAgICAgICByZXR1cm4gV1RGX0FMSUdOX09G KFQpOworICAgIH0KKworICAgIC8vIFJvdW5kcyB1cCB0aGUgZ2l2ZW4gYWxsb2NhdGlvbiBzaXpl IHRvIHRoZSBzcGVjaWZpZWQgYWxpZ25tZW50LgorICAgIHNpemVfdCByb3VuZFVwKHNpemVfdCBz aXplLCBzaXplX3QgYWxpZ25tZW50KQorICAgIHsKKyAgICAgICAgQVNTRVJUKCEoYWxpZ25tZW50 ICUgMikpOworICAgICAgICByZXR1cm4gKHNpemUgKyBhbGlnbm1lbnQgLSAxKSAmIH4oYWxpZ25t ZW50IC0gMSk7CisgICAgfQorCisgICAgLy8gTWFuYWdlcyBhIGNodW5rIG9mIG1lbW9yeSBhbmQg aW5kaXZpZHVhbCBhbGxvY2F0aW9ucyBvdXQgb2YgaXQuCisgICAgY2xhc3MgQ2h1bmsgOiBwdWJs aWMgTm9uY29weWFibGUgeworICAgIHB1YmxpYzoKKyAgICAgICAgLy8gQWxsb2NhdGVzIGEgYmxv Y2sgb2YgbWVtb3J5IG9mIHRoZSBnaXZlbiBzaXplIGZyb20gdGhlIHBhc3NlZAorICAgICAgICAv LyBBbGxvY2F0b3IuCisgICAgICAgIENodW5rKEFsbG9jYXRvciogYWxsb2NhdG9yLCBzaXplX3Qg c2l6ZSkKKyAgICAgICAgICAgIDogbV9hbGxvY2F0b3IoYWxsb2NhdG9yKQorICAgICAgICAgICAg LCBtX3NpemUoc2l6ZSkKKyAgICAgICAgICAgICwgbV9jdXJyZW50T2Zmc2V0KDApCisgICAgICAg IHsKKyAgICAgICAgICAgIG1fYmFzZSA9IHN0YXRpY19jYXN0PHVpbnQ4X3QqPihtX2FsbG9jYXRv ci0+YWxsb2NhdGUoc2l6ZSkpOworICAgICAgICB9CisKKyAgICAgICAgLy8gRnJlZXMgdGhlIG1l bW9yeSBhbGxvY2F0ZWQgZnJvbSB0aGUgQWxsb2NhdG9yIGluIHRoZQorICAgICAgICAvLyBjb25z dHJ1Y3Rvci4KKyAgICAgICAgfkNodW5rKCkKKyAgICAgICAgeworICAgICAgICAgICAgbV9hbGxv Y2F0b3ItPmZyZWUobV9iYXNlKTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIFJldHVybnMgYSBw b2ludGVyIHRvICJzaXplIiBieXRlcyBvZiBzdG9yYWdlLCBvciAwIGlmIHRoaXMKKyAgICAgICAg Ly8gQ2h1bmsgY291bGQgbm90IHNhdGlzZnkgdGhlIGFsbG9jYXRpb24uCisgICAgICAgIHZvaWQq IGFsbG9jYXRlKHNpemVfdCBzaXplKQorICAgICAgICB7CisgICAgICAgICAgICAvLyBDaGVjayBm b3Igb3ZlcmZsb3cKKyAgICAgICAgICAgIGlmIChtX2N1cnJlbnRPZmZzZXQgKyBzaXplIDwgbV9j dXJyZW50T2Zmc2V0KQorICAgICAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgICAgICBp ZiAobV9jdXJyZW50T2Zmc2V0ICsgc2l6ZSA+IG1fc2l6ZSkKKyAgICAgICAgICAgICAgICByZXR1 cm4gMDsKKworICAgICAgICAgICAgdm9pZCogcmVzdWx0ID0gbV9iYXNlICsgbV9jdXJyZW50T2Zm c2V0OworICAgICAgICAgICAgbV9jdXJyZW50T2Zmc2V0ICs9IHNpemU7CisgICAgICAgICAgICBy ZXR1cm4gcmVzdWx0OworICAgICAgICB9CisKKyAgICBwcml2YXRlOgorICAgICAgICBBbGxvY2F0 b3IqIG1fYWxsb2NhdG9yOworICAgICAgICB1aW50OF90KiBtX2Jhc2U7CisgICAgICAgIHNpemVf dCBtX3NpemU7CisgICAgICAgIHNpemVfdCBtX2N1cnJlbnRPZmZzZXQ7CisgICAgfTsKKworICAg IFJlZlB0cjxBbGxvY2F0b3I+IG1fYWxsb2NhdG9yOworICAgIENodW5rKiBtX2N1cnJlbnQ7Cisg ICAgc2l6ZV90IG1fY3VycmVudENodW5rU2l6ZTsKKyAgICBWZWN0b3I8T3duUHRyPENodW5rPiA+ IG1fY2h1bmtzOworfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUE9E QXJlbmFfaApJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9EUmVkQmxhY2tU cmVlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUvUE9EUmVk QmxhY2tUcmVlLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dw dS9QT0RSZWRCbGFja1RyZWUuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw3NTYgQEAKKy8qCisg KiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICog UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRp c3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9y IHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNl IG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhv dXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMK KyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBP UiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURF TlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRV VEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBU SEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZ LCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5H IElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYg QURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworLy8gQSBy ZWQtYmxhY2sgdHJlZSwgd2hpY2ggaXMgYSBmb3JtIG9mIGEgYmFsYW5jZWQgYmluYXJ5IHRyZWUu IEl0CisvLyBzdXBwb3J0cyBlZmZpY2llbnQgaW5zZXJ0aW9uLCBkZWxldGlvbiBhbmQgcXVlcmll cyBvZiBjb21wYXJhYmxlCisvLyBlbGVtZW50cy4gVGhlIHNhbWUgZWxlbWVudCBtYXkgYmUgaW5z ZXJ0ZWQgbXVsdGlwbGUgdGltZXMuIFRoZQorLy8gYWxnb3JpdGhtaWMgY29tcGxleGl0eSBvZiBj b21tb24gb3BlcmF0aW9ucyBpczoKKy8vCisvLyAgIEluc2VydGlvbjogTyhsZyhuKSkKKy8vICAg RGVsZXRpb246ICBPKGxnKG4pKQorLy8gICBRdWVyeWluZzogIE8obGcobikpCisvLworLy8gVGhl IGRhdGEgdHlwZSBUIHRoYXQgaXMgc3RvcmVkIGluIHRoaXMgcmVkLWJsYWNrIHRyZWUgbXVzdCBi ZSBvbmx5CisvLyBQbGFpbiBPbGQgRGF0YSAoUE9EKSwgb3IgYm90dG9tIG91dCBpbnRvIFBPRC4g SXQgbXVzdCBfbm90XyByZWx5IG9uCisvLyBoYXZpbmcgaXRzIGRlc3RydWN0b3IgY2FsbGVkLiBU aGlzIGltcGxlbWVudGF0aW9uIGludGVybmFsbHkKKy8vIGFsbG9jYXRlcyBzdG9yYWdlIGluIGxh cmdlIGNodW5rcyBhbmQgZG9lcyBub3QgY2FsbCB0aGUgZGVzdHJ1Y3RvcgorLy8gb24gZWFjaCBv YmplY3QuCisvLworLy8gVHlwZSBUIG11c3Qgc3VwcGx5IGEgZGVmYXVsdCBjb25zdHJ1Y3Rvciwg YSBjb3B5IGNvbnN0cnVjdG9yLCBhbmQKKy8vIHRoZSAiPCIgYW5kICI9PSIgb3BlcmF0b3JzLgor Ly8KKy8vIEluIGRlYnVnIG1vZGUsIHByaW50aW5nIG9mIHRoZSBkYXRhIGNvbnRhaW5lZCBpbiB0 aGUgdHJlZSBpcworLy8gZW5hYmxlZC4gVGhpcyByZXF1aXJlcyB0aGUgZm9sbG93aW5nIGZ1bmN0 aW9uIHRvIGJlIGF2YWlsYWJsZToKKy8vCisvLyAgIFN0cmluZyB2YWx1ZVRvU3RyaW5nKGNvbnN0 IFQmKTsKKy8vCisvLyBOb3RlIHRoYXQgd2hlbiBjb21wbGV4IHR5cGVzIGFyZSBzdG9yZWQgaW4g dGhpcyByZWQvYmxhY2sgdHJlZSwgaXQKKy8vIGlzIHBvc3NpYmxlIHRoYXQgc2luZ2xlIGludm9j YXRpb25zIG9mIHRoZSAiPCIgYW5kICI9PSIgb3BlcmF0b3JzCisvLyB3aWxsIGJlIGluc3VmZmlj aWVudCB0byBkZXNjcmliZSB0aGUgb3JkZXJpbmcgb2YgZWxlbWVudHMgaW4gdGhlCisvLyB0cmVl IGR1cmluZyBxdWVyaWVzLiBBcyBhIGNvbmNyZXRlIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBjYXNl IHdoZXJlCisvLyBpbnRlcnZhbHMgYXJlIHN0b3JlZCBpbiB0aGUgdHJlZSBzb3J0ZWQgYnkgbG93 IGVuZHBvaW50LiBUaGUgIjwiCisvLyBvcGVyYXRvciBvbiB0aGUgSW50ZXJ2YWwgY2xhc3Mgb25s eSBjb21wYXJlcyB0aGUgbG93IGVuZHBvaW50LCBidXQKKy8vIHRoZSAiPT0iIG9wZXJhdG9yIHRh a2VzIGludG8gYWNjb3VudCB0aGUgaGlnaCBlbmRwb2ludCBhcyB3ZWxsLgorLy8gVGhpcyBtYWtl cyB0aGUgbmVjZXNzYXJ5IGxvZ2ljIGZvciBxdWVyeWluZyBhbmQgZGVsZXRpb24gc29tZXdoYXQK Ky8vIG1vcmUgY29tcGxleC4gSW4gb3JkZXIgdG8gcHJvcGVybHkgaGFuZGxlIHN1Y2ggc2l0dWF0 aW9ucywgdGhlCisvLyBwcm9wZXJ0eSAibmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyIgbXVz dCBiZSBzZXQgdG8gdHJ1ZSBvbgorLy8gdGhlIHRyZWUuCisvLworLy8gVGhpcyByZWQtYmxhY2sg dHJlZSBpcyBkZXNpZ25lZCB0byBiZSBfYXVnbWVudGVkXzsgc3ViY2xhc3NlcyBjYW4KKy8vIGFk ZCBhZGRpdGlvbmFsIGFuZCBzdW1tYXJ5IGluZm9ybWF0aW9uIHRvIGVhY2ggbm9kZSB0byBlZmZp Y2llbnRseQorLy8gc3RvcmUgYW5kIGluZGV4IG1vcmUgY29tcGxleCBkYXRhIHN0cnVjdHVyZXMu IEEgY29uY3JldGUgZXhhbXBsZSBpcworLy8gdGhlIEludGVydmFsVHJlZSwgd2hpY2ggZXh0ZW5k cyBlYWNoIG5vZGUgd2l0aCBhIHN1bW1hcnkgc3RhdGlzdGljCisvLyB0byBlZmZpY2llbnRseSBz dG9yZSBvbmUtZGltZW5zaW9uYWwgaW50ZXJ2YWxzLgorLy8KKy8vIFRoZSBkZXNpZ24gb2YgdGhp cyByZWQtYmxhY2sgdHJlZSBjb21lcyBmcm9tIENvcm1lbiwgTGVpc2Vyc29uLAorLy8gYW5kIFJp dmVzdCwgX0ludHJvZHVjdGlvbiB0byBBbGdvcml0aG1zXywgTUlUIFByZXNzLCAxOTkwLgorCisj aWZuZGVmIFBPRFJlZEJsYWNrVHJlZV9oCisjZGVmaW5lIFBPRFJlZEJsYWNrVHJlZV9oCisKKyNp bmNsdWRlICJQT0RBcmVuYS5oIgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVk ZSA8d3RmL05vbmNvcHlhYmxlLmg+CisjaW5jbHVkZSA8d3RmL1JlZlB0ci5oPgorI2lmbmRlZiBO REVCVUcKKyNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAiUGxhdGZvcm1TdHJpbmcuaCIK KyNpbmNsdWRlICJTdHJpbmdCdWlsZGVyLmgiCisjaW5jbHVkZSA8d3RmL3RleHQvQ1N0cmluZy5o PgorI2VuZGlmCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordGVtcGxhdGU8Y2xhc3MgVD4KK2Ns YXNzIFBPRFJlZEJsYWNrVHJlZSB7CitwdWJsaWM6CisgICAgLy8gVmlzaXRvciBpbnRlcmZhY2Ug Zm9yIHdhbGtpbmcgYWxsIG9mIHRoZSB0cmVlJ3MgZWxlbWVudHMuCisgICAgY2xhc3MgVmlzaXRv ciB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQgdmlzaXQoY29uc3QgVCYgZGF0 YSkgPSAwOworICAgIHByb3RlY3RlZDoKKyAgICAgICAgdmlydHVhbCB+VmlzaXRvcigpIHsgfQor ICAgIH07CisKKyAgICAvLyBDb25zdHJ1Y3RzIGEgbmV3IHJlZC1ibGFjayB0cmVlLCBhbGxvY2F0 aW5nIHRlbXBvcmFyeSBvYmplY3RzCisgICAgLy8gZnJvbSBhIG5ld2x5IGNvbnN0cnVjdGVkIFBP REFyZW5hLgorICAgIFBPRFJlZEJsYWNrVHJlZSgpCisgICAgICAgIDogbV9hcmVuYShQT0RBcmVu YTo6Y3JlYXRlKCkpCisgICAgICAgICwgbV9yb290KDApCisgICAgICAgICwgbV9uZWVkc0Z1bGxP cmRlcmluZ0NvbXBhcmlzb25zKGZhbHNlKQorI2lmbmRlZiBOREVCVUcKKyAgICAgICAgLCBtX3Zl cmJvc2VEZWJ1Z2dpbmcoZmFsc2UpCisjZW5kaWYKKyAgICB7CisgICAgfQorCisgICAgLy8gQ29u c3RydWN0cyBhIG5ldyByZWQtYmxhY2sgdHJlZSwgYWxsb2NhdGluZyB0ZW1wb3Jhcnkgb2JqZWN0 cworICAgIC8vIGZyb20gdGhlIGdpdmVuIFBPREFyZW5hLgorICAgIGV4cGxpY2l0IFBPRFJlZEJs YWNrVHJlZShQT0RBcmVuYSogYXJlbmEpCisgICAgICAgIDogbV9hcmVuYShhcmVuYSkKKyAgICAg ICAgLCBtX3Jvb3QoMCkKKyAgICAgICAgLCBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMo ZmFsc2UpCisjaWZuZGVmIE5ERUJVRworICAgICAgICAsIG1fdmVyYm9zZURlYnVnZ2luZyhmYWxz ZSkKKyNlbmRpZgorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIH5QT0RSZWRCbGFja1RyZWUo KSB7IH0KKworICAgIHZvaWQgYWRkKGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICBOb2Rl KiBub2RlID0gbmV3IE5vZGUoZGF0YSk7CisgICAgICAgIGluc2VydE5vZGUobm9kZSk7CisgICAg fQorCisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoZSBkYXR1bSB3YXMgZm91bmQgaW4gdGhlIHRy ZWUuCisgICAgYm9vbCByZW1vdmUoY29uc3QgVCYgZGF0YSkKKyAgICB7CisgICAgICAgIE5vZGUq IG5vZGUgPSB0cmVlU2VhcmNoKGRhdGEpOworICAgICAgICBpZiAobm9kZSkgeworICAgICAgICAg ICAgZGVsZXRlTm9kZShub2RlKTsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9 CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKKyAgICBib29sIGNvbnRhaW5zKGNvbnN0 IFQmIGRhdGEpIGNvbnN0IHsgcmV0dXJuIHRyZWVTZWFyY2goZGF0YSk7IH0KKworICAgIHZvaWQg dmlzaXRJbm9yZGVyKFZpc2l0b3IqIHZpc2l0b3IpIGNvbnN0CisgICAgeworICAgICAgICBpZiAo IW1fcm9vdCkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgdmlzaXRJbm9yZGVySW1wbCht X3Jvb3QsIHZpc2l0b3IpOworICAgIH0KKworICAgIGludCBzaXplKCkgY29uc3QKKyAgICB7Cisg ICAgICAgIENvdW50ZXIgY291bnRlcjsKKyAgICAgICAgdmlzaXRJbm9yZGVyKCZjb3VudGVyKTsK KyAgICAgICAgcmV0dXJuIGNvdW50ZXIuY291bnQoKTsKKyAgICB9CisKKyAgICAvLyBTZWUgdGhl IGNsYXNzIGRvY3VtZW50YXRpb24gZm9yIGFuIGV4cGxhbmF0aW9uIG9mIHRoaXMgcHJvcGVydHku CisgICAgdm9pZCBzZXROZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKGJvb2wgbmVlZHNGdWxs T3JkZXJpbmdDb21wYXJpc29ucykKKyAgICB7CisgICAgICAgIG1fbmVlZHNGdWxsT3JkZXJpbmdD b21wYXJpc29ucyA9IG5lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnM7CisgICAgfQorCisgICAg dmlydHVhbCBib29sIGNoZWNrSW52YXJpYW50cygpIGNvbnN0CisgICAgeworICAgICAgICBpbnQg YmxhY2tDb3VudDsKKyAgICAgICAgcmV0dXJuIGNoZWNrSW52YXJpYW50c0Zyb21Ob2RlKG1fcm9v dCwgJmJsYWNrQ291bnQpOworICAgIH0KKworI2lmbmRlZiBOREVCVUcKKyAgICAvLyBEdW1wcyB0 aGUgdHJlZSdzIGNvbnRlbnRzIHRvIHRoZSBsb2dnaW5nIGluZm8gc3RyZWFtIGZvcgorICAgIC8v IGRlYnVnZ2luZyBwdXJwb3Nlcy4KKyAgICB2b2lkIGR1bXAoKSBjb25zdAorICAgIHsKKyAgICAg ICAgZHVtcEZyb21Ob2RlKG1fcm9vdCwgMCk7CisgICAgfQorCisgICAgLy8gVHVybnMgb24gb3Ig b2ZmIHZlcmJvc2UgZGVidWdnaW5nIG9mIHRoZSB0cmVlLCBjYXVzaW5nIG1hbnkKKyAgICAvLyBt ZXNzYWdlcyB0byBiZSBsb2dnZWQgZHVyaW5nIGluc2VydGlvbiBhbmQgb3RoZXIgb3BlcmF0aW9u cyBpbgorICAgIC8vIGRlYnVnIG1vZGUuCisgICAgdm9pZCBzZXRWZXJib3NlRGVidWdnaW5nKGJv b2wgdmVyYm9zZURlYnVnZ2luZykKKyAgICB7CisgICAgICAgIG1fdmVyYm9zZURlYnVnZ2luZyA9 IHZlcmJvc2VEZWJ1Z2dpbmc7CisgICAgfQorI2VuZGlmCisKK3Byb3RlY3RlZDoKKyAgICBlbnVt IENvbG9yIHsKKyAgICAgICAgUmVkID0gMSwKKyAgICAgICAgQmxhY2sKKyAgICB9OworCisgICAg Ly8gVGhlIGJhc2UgTm9kZSBjbGFzcyB3aGljaCBpcyBzdG9yZWQgaW4gdGhlIHRyZWUuIE5vZGVz IGFyZSBvbmx5CisgICAgLy8gYW4gaW50ZXJuYWwgY29uY2VwdDsgdXNlcnMgb2YgdGhlIHRyZWUg ZGVhbCBvbmx5IHdpdGggdGhlIGRhdGEKKyAgICAvLyB0aGV5IHN0b3JlIGluIGl0LgorICAgIGNs YXNzIE5vZGUgOiBwdWJsaWMgTm9uY29weWFibGUgeworICAgIHB1YmxpYzoKKyAgICAgICAgLy8g Q29uc3RydWN0b3IuIE5ld2x5LWNyZWF0ZWQgbm9kZXMgYXJlIGNvbG9yZWQgcmVkLgorICAgICAg ICBleHBsaWNpdCBOb2RlKGNvbnN0IFQmIGRhdGEpCisgICAgICAgICAgICA6IG1fbGVmdCgwKQor ICAgICAgICAgICAgLCBtX3JpZ2h0KDApCisgICAgICAgICAgICAsIG1fcGFyZW50KDApCisgICAg ICAgICAgICAsIG1fY29sb3IoUmVkKQorICAgICAgICAgICAgLCBtX2RhdGEoZGF0YSkKKyAgICAg ICAgeworICAgICAgICB9CisKKyAgICAgICAgdmlydHVhbCB+Tm9kZSgpIHsgfQorCisgICAgICAg IENvbG9yIGNvbG9yKCkgY29uc3QgeyByZXR1cm4gbV9jb2xvcjsgfQorICAgICAgICB2b2lkIHNl dENvbG9yKENvbG9yIGNvbG9yKSB7IG1fY29sb3IgPSBjb2xvcjsgfQorCisgICAgICAgIC8vIEZl dGNoZXMgdGhlIHVzZXIgZGF0YS4KKyAgICAgICAgVCYgZGF0YSgpIHsgcmV0dXJuIG1fZGF0YTsg fQorCisgICAgICAgIC8vIENvcGllcyBhbGwgdXNlci1sZXZlbCBmaWVsZHMgZnJvbSB0aGUgc291 cmNlIG5vZGUsIGJ1dCBub3QKKyAgICAgICAgLy8gaW50ZXJuYWwgZmllbGRzLiBGb3IgZXhhbXBs ZSwgdGhlIGJhc2UgaW1wbGVtZW50YXRpb24gb2YgdGhpcworICAgICAgICAvLyBtZXRob2QgY29w aWVzIHRoZSAibV9kYXRhIiBmaWVsZCwgYnV0IG5vdCB0aGUgY2hpbGQgb3IgcGFyZW50CisgICAg ICAgIC8vIGZpZWxkcy4gQW55IGF1Z21lbnRhdGlvbiBpbmZvcm1hdGlvbiBhbHNvIGRvZXMgbm90 IG5lZWQgdG8gYmUKKyAgICAgICAgLy8gY29waWVkLCBhcyBpdCB3aWxsIGJlIHJlY29tcHV0ZWQu IFN1YmNsYXNzZXMgbXVzdCBjYWxsIHRoZQorICAgICAgICAvLyBzdXBlcmNsYXNzIGltcGxlbWVu dGF0aW9uLgorICAgICAgICB2aXJ0dWFsIHZvaWQgY29weUZyb20oTm9kZSogc3JjKSB7IG1fZGF0 YSA9IHNyYy0+ZGF0YSgpOyB9CisKKyAgICAgICAgTm9kZSogbGVmdCgpIGNvbnN0IHsgcmV0dXJu IG1fbGVmdDsgfQorICAgICAgICB2b2lkIHNldExlZnQoTm9kZSogbm9kZSkgeyBtX2xlZnQgPSBu b2RlOyB9CisKKyAgICAgICAgTm9kZSogcmlnaHQoKSBjb25zdCB7IHJldHVybiBtX3JpZ2h0OyB9 CisgICAgICAgIHZvaWQgc2V0UmlnaHQoTm9kZSogbm9kZSkgeyBtX3JpZ2h0ID0gbm9kZTsgfQor CisgICAgICAgIE5vZGUqIHBhcmVudCgpIGNvbnN0IHsgcmV0dXJuIG1fcGFyZW50OyB9CisgICAg ICAgIHZvaWQgc2V0UGFyZW50KE5vZGUqIG5vZGUpIHsgbV9wYXJlbnQgPSBub2RlOyB9CisKKyAg ICBwcml2YXRlOgorICAgICAgICBOb2RlKiBtX2xlZnQ7CisgICAgICAgIE5vZGUqIG1fcmlnaHQ7 CisgICAgICAgIE5vZGUqIG1fcGFyZW50OworICAgICAgICBDb2xvciBtX2NvbG9yOworICAgICAg ICBUIG1fZGF0YTsKKyAgICB9OworCisgICAgLy8gUmV0dXJucyB0aGUgcm9vdCBvZiB0aGUgdHJl ZSwgd2hpY2ggaXMgbmVlZGVkIGJ5IHNvbWUgc3ViY2xhc3Nlcy4KKyAgICBOb2RlKiByb290KCkg Y29uc3QgeyByZXR1cm4gbV9yb290OyB9CisKK3ByaXZhdGU6CisgICAgLy8gVGhpcyB2aXJ0dWFs IG1ldGhvZCBpcyB0aGUgaG9vayB0aGF0IHN1YmNsYXNzZXMgc2hvdWxkIHVzZSB3aGVuCisgICAg Ly8gYXVnbWVudGluZyB0aGUgcmVkLWJsYWNrIHRyZWUgd2l0aCBhZGRpdGlvbmFsIHBlci1ub2Rl IHN1bW1hcnkKKyAgICAvLyBpbmZvcm1hdGlvbi4gRm9yIGV4YW1wbGUsIGluIHRoZSBjYXNlIG9m IGFuIGludGVydmFsIHRyZWUsIHRoaXMKKyAgICAvLyBpcyB1c2VkIHRvIGNvbXB1dGUgdGhlIG1h eGltdW0gZW5kcG9pbnQgb2YgdGhlIHN1YnRyZWUgYmVsb3cgdGhlCisgICAgLy8gZ2l2ZW4gbm9k ZSBiYXNlZCBvbiB0aGUgdmFsdWVzIGluIHRoZSBsZWZ0IGFuZCByaWdodCBjaGlsZHJlbi4gSXQK KyAgICAvLyBpcyBndWFyYW50ZWVkIHRoYXQgdGhpcyB3aWxsIGJlIGNhbGxlZCBpbiB0aGUgY29y cmVjdCBvcmRlciB0bworICAgIC8vIHByb3Blcmx5IHVwZGF0ZSBzdWNoIHN1bW1hcnkgaW5mb3Jt YXRpb24gYmFzZWQgb25seSBvbiB0aGUgdmFsdWVzCisgICAgLy8gaW4gdGhlIGxlZnQgYW5kIHJp Z2h0IGNoaWxkcmVuLiBUaGlzIG1ldGhvZCBzaG91bGQgcmV0dXJuIHRydWUgaWYKKyAgICAvLyB0 aGUgbm9kZSdzIHN1bW1hcnkgaW5mb3JtYXRpb24gY2hhbmdlZC4KKyAgICB2aXJ0dWFsIGJvb2wg dXBkYXRlTm9kZShOb2RlKiBub2RlKSB7IHJldHVybiBmYWxzZTsgfQorCisgICAgLy8tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCisgICAgLy8gR2VuZXJpYyBiaW5hcnkgc2VhcmNoIHRyZWUgb3BlcmF0aW9ucworICAg IC8vCisKKyAgICAvLyBTZWFyY2hlcyB0aGUgdHJlZSBmb3IgdGhlIGdpdmVuIGRhdHVtLgorICAg IE5vZGUqIHRyZWVTZWFyY2goY29uc3QgVCYgZGF0YSkgY29uc3QKKyAgICB7CisgICAgICAgIGlm IChtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMpCisgICAgICAgICAgICByZXR1cm4gdHJl ZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhtX3Jvb3QsIGRhdGEpOworCisgICAgICAgIHJldHVybiB0 cmVlU2VhcmNoTm9ybWFsKG1fcm9vdCwgZGF0YSk7CisgICAgfQorCisgICAgLy8gU2VhcmNoZXMg dGhlIHRyZWUgdXNpbmcgdGhlIG5vcm1hbCBjb21wYXJpc29uIG9wZXJhdGlvbnMsCisgICAgLy8g c3VpdGFibGUgZm9yIHNpbXBsZSBkYXRhIHR5cGVzIHN1Y2ggYXMgbnVtYmVycy4KKyAgICBOb2Rl KiB0cmVlU2VhcmNoTm9ybWFsKE5vZGUqIGN1cnJlbnQsIGNvbnN0IFQmIGRhdGEpIGNvbnN0Cisg ICAgeworICAgICAgICB3aGlsZSAoY3VycmVudCkgeworICAgICAgICAgICAgaWYgKGN1cnJlbnQt PmRhdGEoKSA9PSBkYXRhKQorICAgICAgICAgICAgICAgIHJldHVybiBjdXJyZW50OworICAgICAg ICAgICAgaWYgKGRhdGEgPCBjdXJyZW50LT5kYXRhKCkpCisgICAgICAgICAgICAgICAgY3VycmVu dCA9IGN1cnJlbnQtPmxlZnQoKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICBj dXJyZW50ID0gY3VycmVudC0+cmlnaHQoKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4gMDsK KyAgICB9CisKKyAgICAvLyBTZWFyY2hlcyB0aGUgdHJlZSB1c2luZyBtdWx0aXBsZSBjb21wYXJp c29uIG9wZXJhdGlvbnMsIHJlcXVpcmVkCisgICAgLy8gZm9yIGRhdGEgdHlwZXMgd2l0aCBtb3Jl IGNvbXBsZXggYmVoYXZpb3Igc3VjaCBhcyBpbnRlcnZhbHMuCisgICAgTm9kZSogdHJlZVNlYXJj aEZ1bGxDb21wYXJpc29ucyhOb2RlKiBjdXJyZW50LCBjb25zdCBUJiBkYXRhKSBjb25zdAorICAg IHsKKyAgICAgICAgaWYgKCFjdXJyZW50KQorICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAg IGlmIChkYXRhIDwgY3VycmVudC0+ZGF0YSgpKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFy Y2hGdWxsQ29tcGFyaXNvbnMoY3VycmVudC0+bGVmdCgpLCBkYXRhKTsKKyAgICAgICAgaWYgKGN1 cnJlbnQtPmRhdGEoKSA8IGRhdGEpCisgICAgICAgICAgICByZXR1cm4gdHJlZVNlYXJjaEZ1bGxD b21wYXJpc29ucyhjdXJyZW50LT5yaWdodCgpLCBkYXRhKTsKKyAgICAgICAgaWYgKGRhdGEgPT0g Y3VycmVudC0+ZGF0YSgpKQorICAgICAgICAgICAgcmV0dXJuIGN1cnJlbnQ7CisKKyAgICAgICAg Ly8gV2UgbWF5IG5lZWQgdG8gdHJhdmVyc2UgYm90aCB0aGUgbGVmdCBhbmQgcmlnaHQgc3VidHJl ZXMuCisgICAgICAgIE5vZGUqIHJlc3VsdCA9IHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMoY3Vy cmVudC0+bGVmdCgpLCBkYXRhKTsKKyAgICAgICAgaWYgKCFyZXN1bHQpCisgICAgICAgICAgICBy ZXN1bHQgPSB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKGN1cnJlbnQtPnJpZ2h0KCksIGRhdGEp OworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKworICAgIHZvaWQgdHJlZUluc2VydChO b2RlKiB6KQorICAgIHsKKyAgICAgICAgTm9kZSogeSA9IDA7CisgICAgICAgIE5vZGUqIHggPSBt X3Jvb3Q7CisgICAgICAgIHdoaWxlICh4KSB7CisgICAgICAgICAgICB5ID0geDsKKyAgICAgICAg ICAgIGlmICh6LT5kYXRhKCkgPCB4LT5kYXRhKCkpCisgICAgICAgICAgICAgICAgeCA9IHgtPmxl ZnQoKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB4ID0geC0+cmlnaHQoKTsK KyAgICAgICAgfQorICAgICAgICB6LT5zZXRQYXJlbnQoeSk7CisgICAgICAgIGlmICgheSkKKyAg ICAgICAgICAgIG1fcm9vdCA9IHo7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgaWYgKHot PmRhdGEoKSA8IHktPmRhdGEoKSkKKyAgICAgICAgICAgICAgICB5LT5zZXRMZWZ0KHopOworICAg ICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHktPnNldFJpZ2h0KHopOworICAgICAgICB9 CisgICAgfQorCisgICAgLy8gRmluZHMgdGhlIG5vZGUgZm9sbG93aW5nIHRoZSBnaXZlbiBvbmUg aW4gc2VxdWVudGlhbCBvcmRlcmluZyBvZgorICAgIC8vIHRoZWlyIGRhdGEsIG9yIG51bGwgaWYg bm9uZSBleGlzdHMuCisgICAgTm9kZSogdHJlZVN1Y2Nlc3NvcihOb2RlKiB4KQorICAgIHsKKyAg ICAgICAgaWYgKHgtPnJpZ2h0KCkpCisgICAgICAgICAgICByZXR1cm4gdHJlZU1pbmltdW0oeC0+ cmlnaHQoKSk7CisgICAgICAgIE5vZGUqIHkgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgd2hpbGUg KHkgJiYgeCA9PSB5LT5yaWdodCgpKSB7CisgICAgICAgICAgICB4ID0geTsKKyAgICAgICAgICAg IHkgPSB5LT5wYXJlbnQoKTsKKyAgICAgICAgfQorICAgICAgICByZXR1cm4geTsKKyAgICB9CisK KyAgICAvLyBGaW5kcyB0aGUgbWluaW11bSBlbGVtZW50IGluIHRoZSBzdWItdHJlZSByb290ZWQg YXQgdGhlIGdpdmVuCisgICAgLy8gbm9kZS4KKyAgICBOb2RlKiB0cmVlTWluaW11bShOb2RlKiB4 KQorICAgIHsKKyAgICAgICAgd2hpbGUgKHgtPmxlZnQoKSkKKyAgICAgICAgICAgIHggPSB4LT5s ZWZ0KCk7CisgICAgICAgIHJldHVybiB4OworICAgIH0KKworICAgIC8vIEhlbHBlciBmb3IgbWFp bnRhaW5pbmcgdGhlIGF1Z21lbnRlZCByZWQtYmxhY2sgdHJlZS4KKyAgICB2b2lkIHByb3BhZ2F0 ZVVwZGF0ZXMoTm9kZSogc3RhcnQpCisgICAgeworICAgICAgICBib29sIHNob3VsZENvbnRpbnVl ID0gdHJ1ZTsKKyAgICAgICAgd2hpbGUgKHN0YXJ0ICYmIHNob3VsZENvbnRpbnVlKSB7CisgICAg ICAgICAgICBzaG91bGRDb250aW51ZSA9IHVwZGF0ZU5vZGUoc3RhcnQpOworICAgICAgICAgICAg c3RhcnQgPSBzdGFydC0+cGFyZW50KCk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICAvLy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KKyAgICAvLyBSZWQtQmxhY2sgdHJlZSBvcGVyYXRpb25zCisgICAgLy8KKworICAg IC8vIExlZnQtcm90YXRlcyB0aGUgc3VidHJlZSByb290ZWQgYXQgeC4KKyAgICAvLyBSZXR1cm5z IHRoZSBuZXcgcm9vdCBvZiB0aGUgc3VidHJlZSAoeCdzIHJpZ2h0IGNoaWxkKS4KKyAgICBOb2Rl KiBsZWZ0Um90YXRlKE5vZGUqIHgpCisgICAgeworICAgICAgICAvLyBTZXQgeS4KKyAgICAgICAg Tm9kZSogeSA9IHgtPnJpZ2h0KCk7CisKKyAgICAgICAgLy8gVHVybiB5J3MgbGVmdCBzdWJ0cmVl IGludG8geCdzIHJpZ2h0IHN1YnRyZWUuCisgICAgICAgIHgtPnNldFJpZ2h0KHktPmxlZnQoKSk7 CisgICAgICAgIGlmICh5LT5sZWZ0KCkpCisgICAgICAgICAgICB5LT5sZWZ0KCktPnNldFBhcmVu dCh4KTsKKworICAgICAgICAvLyBMaW5rIHgncyBwYXJlbnQgdG8geS4KKyAgICAgICAgeS0+c2V0 UGFyZW50KHgtPnBhcmVudCgpKTsKKyAgICAgICAgaWYgKCF4LT5wYXJlbnQoKSkKKyAgICAgICAg ICAgIG1fcm9vdCA9IHk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgaWYgKHggPT0geC0+ cGFyZW50KCktPmxlZnQoKSkKKyAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0TGVmdCh5 KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Umln aHQoeSk7CisgICAgICAgIH0KKworICAgICAgICAvLyBQdXQgeCBvbiB5J3MgbGVmdC4KKyAgICAg ICAgeS0+c2V0TGVmdCh4KTsKKyAgICAgICAgeC0+c2V0UGFyZW50KHkpOworCisgICAgICAgIC8v IFVwZGF0ZSBub2RlcyBsb3dlc3QgdG8gaGlnaGVzdC4KKyAgICAgICAgdXBkYXRlTm9kZSh4KTsK KyAgICAgICAgdXBkYXRlTm9kZSh5KTsKKyAgICAgICAgcmV0dXJuIHk7CisgICAgfQorCisgICAg Ly8gUmlnaHQtcm90YXRlcyB0aGUgc3VidHJlZSByb290ZWQgYXQgeS4KKyAgICAvLyBSZXR1cm5z IHRoZSBuZXcgcm9vdCBvZiB0aGUgc3VidHJlZSAoeSdzIGxlZnQgY2hpbGQpLgorICAgIE5vZGUq IHJpZ2h0Um90YXRlKE5vZGUqIHkpCisgICAgeworICAgICAgICAvLyBTZXQgeC4KKyAgICAgICAg Tm9kZSogeCA9IHktPmxlZnQoKTsKKworICAgICAgICAvLyBUdXJuIHgncyByaWdodCBzdWJ0cmVl IGludG8geSdzIGxlZnQgc3VidHJlZS4KKyAgICAgICAgeS0+c2V0TGVmdCh4LT5yaWdodCgpKTsK KyAgICAgICAgaWYgKHgtPnJpZ2h0KCkpCisgICAgICAgICAgICB4LT5yaWdodCgpLT5zZXRQYXJl bnQoeSk7CisKKyAgICAgICAgLy8gTGluayB5J3MgcGFyZW50IHRvIHguCisgICAgICAgIHgtPnNl dFBhcmVudCh5LT5wYXJlbnQoKSk7CisgICAgICAgIGlmICgheS0+cGFyZW50KCkpCisgICAgICAg ICAgICBtX3Jvb3QgPSB4OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh5ID09IHkt PnBhcmVudCgpLT5sZWZ0KCkpCisgICAgICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldExlZnQo eCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeS0+cGFyZW50KCktPnNldFJp Z2h0KHgpOworICAgICAgICB9CisKKyAgICAgICAgLy8gUHV0IHkgb24geCdzIHJpZ2h0LgorICAg ICAgICB4LT5zZXRSaWdodCh5KTsKKyAgICAgICAgeS0+c2V0UGFyZW50KHgpOworCisgICAgICAg IC8vIFVwZGF0ZSBub2RlcyBsb3dlc3QgdG8gaGlnaGVzdC4KKyAgICAgICAgdXBkYXRlTm9kZSh5 KTsKKyAgICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAgICAgcmV0dXJuIHg7CisgICAgfQorCisg ICAgLy8gSW5zZXJ0cyB0aGUgZ2l2ZW4gbm9kZSBpbnRvIHRoZSB0cmVlLgorICAgIHZvaWQgaW5z ZXJ0Tm9kZShOb2RlKiB4KQorICAgIHsKKyAgICAgICAgdHJlZUluc2VydCh4KTsKKyAgICAgICAg eC0+c2V0Q29sb3IoUmVkKTsKKyAgICAgICAgdXBkYXRlTm9kZSh4KTsKKworICAgICAgICBsb2dJ ZlZlcmJvc2UoIiAgUE9EUmVkQmxhY2tUcmVlOjpJbnNlcnROb2RlIik7CisKKyAgICAgICAgLy8g VGhlIG5vZGUgZnJvbSB3aGljaCB0byBzdGFydCBwcm9wYWdhdGluZyB1cGRhdGVzIHVwd2FyZHMu CisgICAgICAgIE5vZGUqIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisKKyAgICAgICAgd2hp bGUgKHggIT0gbV9yb290ICYmIHgtPnBhcmVudCgpLT5jb2xvcigpID09IFJlZCkgeworICAgICAg ICAgICAgaWYgKHgtPnBhcmVudCgpID09IHgtPnBhcmVudCgpLT5wYXJlbnQoKS0+bGVmdCgpKSB7 CisgICAgICAgICAgICAgICAgTm9kZSogeSA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKS0+cmlnaHQo KTsKKyAgICAgICAgICAgICAgICBpZiAoeSAmJiB5LT5jb2xvcigpID09IFJlZCkgeworICAgICAg ICAgICAgICAgICAgICAvLyBDYXNlIDEKKyAgICAgICAgICAgICAgICAgICAgbG9nSWZWZXJib3Nl KCIgIENhc2UgMS8xIik7CisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5zZXRDb2xv cihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHktPnNldENvbG9yKEJsYWNrKTsKKyAgICAg ICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihSZWQpOworICAg ICAgICAgICAgICAgICAgICB1cGRhdGVOb2RlKHgtPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAg ICAgICAgeCA9IHgtPnBhcmVudCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgdXBk YXRlTm9kZSh4KTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJlbnQo KTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoeCA9 PSB4LT5wYXJlbnQoKS0+cmlnaHQoKSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbG9nSWZW ZXJib3NlKCIgIENhc2UgMS8yIik7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDIK KyAgICAgICAgICAgICAgICAgICAgICAgIHggPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAg ICAgICAgICAgIGxlZnRSb3RhdGUoeCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAg ICAgICAgICAgICAgLy8gQ2FzZSAzCisgICAgICAgICAgICAgICAgICAgIGxvZ0lmVmVyYm9zZSgi ICBDYXNlIDEvMyIpOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3Io QmxhY2spOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNldENv bG9yKFJlZCk7CisgICAgICAgICAgICAgICAgICAgIE5vZGUqIG5ld1N1YlRyZWVSb290ID0gcmln aHRSb3RhdGUoeC0+cGFyZW50KCktPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAgICAgICAgdXBk YXRlU3RhcnQgPSBuZXdTdWJUcmVlUm9vdC0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvLyBTYW1lIGFzICJ0aGVuIiBj bGF1c2Ugd2l0aCAicmlnaHQiIGFuZCAibGVmdCIgZXhjaGFuZ2VkLgorICAgICAgICAgICAgICAg IE5vZGUqIHkgPSB4LT5wYXJlbnQoKS0+cGFyZW50KCktPmxlZnQoKTsKKyAgICAgICAgICAgICAg ICBpZiAoeSAmJiB5LT5jb2xvcigpID09IFJlZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBD YXNlIDEKKyAgICAgICAgICAgICAgICAgICAgbG9nSWZWZXJib3NlKCIgIENhc2UgMi8xIik7Cisg ICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5zZXRDb2xvcihCbGFjayk7CisgICAgICAg ICAgICAgICAgICAgIHktPnNldENvbG9yKEJsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeC0+ cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihSZWQpOworICAgICAgICAgICAgICAgICAgICB1 cGRhdGVOb2RlKHgtPnBhcmVudCgpKTsKKyAgICAgICAgICAgICAgICAgICAgeCA9IHgtPnBhcmVu dCgpLT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlTm9kZSh4KTsKKyAgICAg ICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAg ICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoeCA9PSB4LT5wYXJlbnQoKS0+bGVm dCgpKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDIKKyAgICAgICAgICAgICAg ICAgICAgICAgIGxvZ0lmVmVyYm9zZSgiICBDYXNlIDIvMiIpOworICAgICAgICAgICAgICAgICAg ICAgICAgeCA9IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3Rh dGUoeCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgLy8gQ2Fz ZSAzCisgICAgICAgICAgICAgICAgICAgIGxvZ0lmVmVyYm9zZSgiICBDYXNlIDIvMyIpOworICAg ICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3IoQmxhY2spOworICAgICAgICAg ICAgICAgICAgICB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnNldENvbG9yKFJlZCk7CisgICAgICAg ICAgICAgICAgICAgIE5vZGUqIG5ld1N1YlRyZWVSb290ID0gbGVmdFJvdGF0ZSh4LT5wYXJlbnQo KS0+cGFyZW50KCkpOworICAgICAgICAgICAgICAgICAgICB1cGRhdGVTdGFydCA9IG5ld1N1YlRy ZWVSb290LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAg ICAgIH0KKworICAgICAgICBwcm9wYWdhdGVVcGRhdGVzKHVwZGF0ZVN0YXJ0KTsKKworICAgICAg ICBtX3Jvb3QtPnNldENvbG9yKEJsYWNrKTsKKyAgICB9CisKKyAgICAvLyBSZXN0b3JlcyB0aGUg cmVkLWJsYWNrIHByb3BlcnR5IHRvIHRoZSB0cmVlIGFmdGVyIHNwbGljaW5nIG91dAorICAgIC8v IGEgbm9kZS4gTm90ZSB0aGF0IHggbWF5IGJlIG51bGwsIHdoaWNoIGlzIHdoeSB4UGFyZW50IG11 c3QgYmUKKyAgICAvLyBzdXBwbGllZC4KKyAgICB2b2lkIGRlbGV0ZUZpeHVwKE5vZGUqIHgsIE5v ZGUqIHhQYXJlbnQpCisgICAgeworICAgICAgICB3aGlsZSAoeCAhPSBtX3Jvb3QgJiYgKCF4IHx8 IHgtPmNvbG9yKCkgPT0gQmxhY2spKSB7CisgICAgICAgICAgICBpZiAoeCA9PSB4UGFyZW50LT5s ZWZ0KCkpIHsKKyAgICAgICAgICAgICAgICAvLyBOb3RlOiB0aGUgdGV4dCBwb2ludHMgb3V0IHRo YXQgdyBjYW4gbm90IGJlIG51bGwuCisgICAgICAgICAgICAgICAgLy8gVGhlIHJlYXNvbiBpcyBu b3Qgb2J2aW91cyBmcm9tIHNpbXBseSBsb29raW5nIGF0CisgICAgICAgICAgICAgICAgLy8gdGhl IGNvZGU7IGl0IGNvbWVzIGFib3V0IGZyb20gdGhlIHByb3BlcnRpZXMgb2YgdGhlCisgICAgICAg ICAgICAgICAgLy8gcmVkLWJsYWNrIHRyZWUuCisgICAgICAgICAgICAgICAgTm9kZSogdyA9IHhQ YXJlbnQtPnJpZ2h0KCk7CisgICAgICAgICAgICAgICAgQVNTRVJUKHcpOyAvLyB4J3Mgc2libGlu ZyBzaG91bGQgbm90IGJlIG51bGwuCisgICAgICAgICAgICAgICAgaWYgKHctPmNvbG9yKCkgPT0g UmVkKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMQorICAgICAgICAgICAgICAgICAg ICB3LT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQtPnNldENv bG9yKFJlZCk7CisgICAgICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUoeFBhcmVudCk7CisgICAg ICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5yaWdodCgpOworICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgICAgICBpZiAoKCF3LT5sZWZ0KCkgfHwgdy0+bGVmdCgpLT5jb2xvcigpID09 IEJsYWNrKQorICAgICAgICAgICAgICAgICAgICAmJiAoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQo KS0+Y29sb3IoKSA9PSBCbGFjaykpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAyCisg ICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKFJlZCk7CisgICAgICAgICAgICAgICAgICAg IHggPSB4UGFyZW50OworICAgICAgICAgICAgICAgICAgICB4UGFyZW50ID0geC0+cGFyZW50KCk7 CisgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKCF3LT5y aWdodCgpIHx8IHctPnJpZ2h0KCktPmNvbG9yKCkgPT0gQmxhY2spIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgIC8vIENhc2UgMworICAgICAgICAgICAgICAgICAgICAgICAgdy0+bGVmdCgpLT5z ZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihSZWQp OworICAgICAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUodyk7CisgICAgICAgICAgICAg ICAgICAgICAgICB3ID0geFBhcmVudC0+cmlnaHQoKTsKKyAgICAgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDQKKyAgICAgICAgICAgICAgICAgICAgdy0+c2V0 Q29sb3IoeFBhcmVudC0+Y29sb3IoKSk7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQtPnNl dENvbG9yKEJsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHctPnJpZ2h0KCkpCisgICAg ICAgICAgICAgICAgICAgICAgICB3LT5yaWdodCgpLT5zZXRDb2xvcihCbGFjayk7CisgICAgICAg ICAgICAgICAgICAgIGxlZnRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAgICAgICAgIHgg PSBtX3Jvb3Q7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgIC8v IFNhbWUgYXMgInRoZW4iIGNsYXVzZSB3aXRoICJyaWdodCIgYW5kICJsZWZ0IgorICAgICAgICAg ICAgICAgIC8vIGV4Y2hhbmdlZC4KKworICAgICAgICAgICAgICAgIC8vIE5vdGU6IHRoZSB0ZXh0 IHBvaW50cyBvdXQgdGhhdCB3IGNhbiBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAgICAvLyBU aGUgcmVhc29uIGlzIG5vdCBvYnZpb3VzIGZyb20gc2ltcGx5IGxvb2tpbmcgYXQKKyAgICAgICAg ICAgICAgICAvLyB0aGUgY29kZTsgaXQgY29tZXMgYWJvdXQgZnJvbSB0aGUgcHJvcGVydGllcyBv ZiB0aGUKKyAgICAgICAgICAgICAgICAvLyByZWQtYmxhY2sgdHJlZS4KKyAgICAgICAgICAgICAg ICBOb2RlKiB3ID0geFBhcmVudC0+bGVmdCgpOworICAgICAgICAgICAgICAgIEFTU0VSVCh3KTsg Ly8geCdzIHNpYmxpbmcgc2hvdWxkIG5vdCBiZSBudWxsLgorICAgICAgICAgICAgICAgIGlmICh3 LT5jb2xvcigpID09IFJlZCkgeworICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDEKKyAgICAg ICAgICAgICAgICAgICAgdy0+c2V0Q29sb3IoQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4 UGFyZW50LT5zZXRDb2xvcihSZWQpOworICAgICAgICAgICAgICAgICAgICByaWdodFJvdGF0ZSh4 UGFyZW50KTsKKyAgICAgICAgICAgICAgICAgICAgdyA9IHhQYXJlbnQtPmxlZnQoKTsKKyAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgaWYgKCghdy0+cmlnaHQoKSB8fCB3LT5yaWdo dCgpLT5jb2xvcigpID09IEJsYWNrKQorICAgICAgICAgICAgICAgICAgICAmJiAoIXctPmxlZnQo KSB8fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0gQmxhY2spKSB7CisgICAgICAgICAgICAgICAgICAg IC8vIENhc2UgMgorICAgICAgICAgICAgICAgICAgICB3LT5zZXRDb2xvcihSZWQpOworICAgICAg ICAgICAgICAgICAgICB4ID0geFBhcmVudDsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudCA9 IHgtPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAg ICAgIGlmICghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29sb3IoKSA9PSBCbGFjaykgeworICAg ICAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAzCisgICAgICAgICAgICAgICAgICAgICAgICB3 LT5yaWdodCgpLT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgICAgICB3LT5z ZXRDb2xvcihSZWQpOworICAgICAgICAgICAgICAgICAgICAgICAgbGVmdFJvdGF0ZSh3KTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSA0CisgICAgICAgICAgICAgICAg ICAgIHctPnNldENvbG9yKHhQYXJlbnQtPmNvbG9yKCkpOworICAgICAgICAgICAgICAgICAgICB4 UGFyZW50LT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIGlmICh3LT5sZWZ0 KCkpCisgICAgICAgICAgICAgICAgICAgICAgICB3LT5sZWZ0KCktPnNldENvbG9yKEJsYWNrKTsK KyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7CisgICAgICAgICAgICAg ICAgICAgIHggPSBtX3Jvb3Q7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJl bnQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAg ICAgaWYgKHgpCisgICAgICAgICAgICB4LT5zZXRDb2xvcihCbGFjayk7CisgICAgfQorCisgICAg Ly8gRGVsZXRlcyB0aGUgZ2l2ZW4gbm9kZSBmcm9tIHRoZSB0cmVlLiBOb3RlIHRoYXQgdGhpcwor ICAgIC8vIHBhcnRpY3VsYXIgbm9kZSBtYXkgbm90IGFjdHVhbGx5IGJlIHJlbW92ZWQgZnJvbSB0 aGUgdHJlZTsKKyAgICAvLyBpbnN0ZWFkLCBhbm90aGVyIG5vZGUgbWlnaHQgYmUgcmVtb3ZlZCBh bmQgaXRzIGNvbnRlbnRzCisgICAgLy8gY29waWVkIGludG8gei4KKyAgICB2b2lkIGRlbGV0ZU5v ZGUoTm9kZSogeikKKyAgICB7CisgICAgICAgIC8vIFkgaXMgdGhlIG5vZGUgdG8gYmUgdW5saW5r ZWQgZnJvbSB0aGUgdHJlZS4KKyAgICAgICAgTm9kZSogeTsKKyAgICAgICAgaWYgKCF6LT5sZWZ0 KCkgfHwgIXotPnJpZ2h0KCkpCisgICAgICAgICAgICB5ID0gejsKKyAgICAgICAgZWxzZQorICAg ICAgICAgICAgeSA9IHRyZWVTdWNjZXNzb3Ioeik7CisKKyAgICAgICAgLy8gWSBpcyBndWFyYW50 ZWVkIHRvIGJlIG5vbi1udWxsIGF0IHRoaXMgcG9pbnQuCisgICAgICAgIE5vZGUqIHg7CisgICAg ICAgIGlmICh5LT5sZWZ0KCkpCisgICAgICAgICAgICB4ID0geS0+bGVmdCgpOworICAgICAgICBl bHNlCisgICAgICAgICAgICB4ID0geS0+cmlnaHQoKTsKKworICAgICAgICAvLyBYIGlzIHRoZSBj aGlsZCBvZiB5IHdoaWNoIG1pZ2h0IHBvdGVudGlhbGx5IHJlcGxhY2UgeSBpbgorICAgICAgICAv LyB0aGUgdHJlZS4gWCBtaWdodCBiZSBudWxsIGF0IHRoaXMgcG9pbnQuCisgICAgICAgIE5vZGUq IHhQYXJlbnQ7CisgICAgICAgIGlmICh4KSB7CisgICAgICAgICAgICB4LT5zZXRQYXJlbnQoeS0+ cGFyZW50KCkpOworICAgICAgICAgICAgeFBhcmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICB9 IGVsc2UKKyAgICAgICAgICAgIHhQYXJlbnQgPSB5LT5wYXJlbnQoKTsKKyAgICAgICAgaWYgKCF5 LT5wYXJlbnQoKSkKKyAgICAgICAgICAgIG1fcm9vdCA9IHg7CisgICAgICAgIGVsc2UgeworICAg ICAgICAgICAgaWYgKHkgPT0geS0+cGFyZW50KCktPmxlZnQoKSkKKyAgICAgICAgICAgICAgICB5 LT5wYXJlbnQoKS0+c2V0TGVmdCh4KTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAg ICB5LT5wYXJlbnQoKS0+c2V0UmlnaHQoeCk7CisgICAgICAgIH0KKyAgICAgICAgaWYgKHkgIT0g eikgeworICAgICAgICAgICAgei0+Y29weUZyb20oeSk7CisgICAgICAgICAgICAvLyBUaGlzIG5v ZGUgaGFzIGNoYW5nZWQgbG9jYXRpb24gaW4gdGhlIHRyZWUgYW5kIG11c3QgYmUgdXBkYXRlZC4K KyAgICAgICAgICAgIHVwZGF0ZU5vZGUoeik7CisgICAgICAgICAgICAvLyBUaGUgcGFyZW50IGFu ZCBpdHMgcGFyZW50cyBtYXkgbm93IGJlIG91dCBvZiBkYXRlLgorICAgICAgICAgICAgcHJvcGFn YXRlVXBkYXRlcyh6LT5wYXJlbnQoKSk7CisgICAgICAgIH0KKworICAgICAgICAvLyBJZiB3ZSBo YXZlbid0IGFscmVhZHkgdXBkYXRlZCBzdGFydGluZyBmcm9tIHhQYXJlbnQsIGRvIHNvIG5vdy4K KyAgICAgICAgaWYgKHhQYXJlbnQgJiYgeFBhcmVudCAhPSB5ICYmIHhQYXJlbnQgIT0geikKKyAg ICAgICAgICAgIHByb3BhZ2F0ZVVwZGF0ZXMoeFBhcmVudCk7CisgICAgICAgIGlmICh5LT5jb2xv cigpID09IEJsYWNrKQorICAgICAgICAgICAgZGVsZXRlRml4dXAoeCwgeFBhcmVudCk7CisgICAg fQorCisgICAgLy8gVmlzaXRzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB0aGUgZ2l2ZW4gbm9kZSBp biBvcmRlci4KKyAgICB2b2lkIHZpc2l0SW5vcmRlckltcGwoTm9kZSogbm9kZSwgVmlzaXRvciog dmlzaXRvcikgY29uc3QKKyAgICB7CisgICAgICAgIGlmIChub2RlLT5sZWZ0KCkpCisgICAgICAg ICAgICB2aXNpdElub3JkZXJJbXBsKG5vZGUtPmxlZnQoKSwgdmlzaXRvcik7CisgICAgICAgIHZp c2l0b3ItPnZpc2l0KG5vZGUtPmRhdGEoKSk7CisgICAgICAgIGlmIChub2RlLT5yaWdodCgpKQor ICAgICAgICAgICAgdmlzaXRJbm9yZGVySW1wbChub2RlLT5yaWdodCgpLCB2aXNpdG9yKTsKKyAg ICB9CisKKyAgICAvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAvLyBIZWxwZXIgY2xhc3MgZm9yIHNpemUo KQorCisgICAgLy8gQSBWaXNpdG9yIHdoaWNoIHNpbXBseSBjb3VudHMgdGhlIG51bWJlciBvZiB2 aXNpdGVkIGVsZW1lbnRzLgorICAgIGNsYXNzIENvdW50ZXIgOiBwdWJsaWMgVmlzaXRvciwgcHVi bGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIENvdW50ZXIoKQorICAgICAg ICAgICAgOiBtX2NvdW50KDApIHsgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCB2aXNpdChjb25z dCBUJiBkYXRhKSB7ICsrbV9jb3VudDsgfQorICAgICAgICBpbnQgY291bnQoKSBjb25zdCB7IHJl dHVybiBtX2NvdW50OyB9CisKKyAgICBwcml2YXRlOgorICAgICAgICBpbnQgbV9jb3VudDsKKyAg ICB9OworCisgICAgLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgICAgLy8gVmVyaWZpY2F0aW9uIGFuZCBkZWJ1 Z2dpbmcgcm91dGluZXMKKyAgICAvLworCisgICAgLy8gUmV0dXJucyBpbiB0aGUgImJsYWNrQ291 bnQiIHBhcmFtZXRlciB0aGUgbnVtYmVyIG9mIGJsYWNrCisgICAgLy8gY2hpbGRyZW4gYWxvbmcg YWxsIHBhdGhzIHRvIGFsbCBsZWF2ZXMgb2YgdGhlIGdpdmVuIG5vZGUuCisgICAgYm9vbCBjaGVj a0ludmFyaWFudHNGcm9tTm9kZShOb2RlKiBub2RlLCBpbnQqIGJsYWNrQ291bnQpIGNvbnN0Cisg ICAgeworICAgICAgICAvLyBCYXNlIGNhc2UgaXMgYSBsZWFmIG5vZGUuCisgICAgICAgIGlmICgh bm9kZSkgeworICAgICAgICAgICAgKmJsYWNrQ291bnQgPSAxOworICAgICAgICAgICAgcmV0dXJu IHRydWU7CisgICAgICAgIH0KKworICAgICAgICAvLyBFYWNoIG5vZGUgaXMgZWl0aGVyIHJlZCBv ciBibGFjay4KKyAgICAgICAgaWYgKCEobm9kZS0+Y29sb3IoKSA9PSBSZWQgfHwgbm9kZS0+Y29s b3IoKSA9PSBCbGFjaykpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAgICAgLy8g RXZlcnkgbGVhZiAob3IgbnVsbCkgaXMgYmxhY2suCisKKyAgICAgICAgaWYgKG5vZGUtPmNvbG9y KCkgPT0gUmVkKSB7CisgICAgICAgICAgICAvLyBCb3RoIG9mIGl0cyBjaGlsZHJlbiBhcmUgYmxh Y2suCisgICAgICAgICAgICBpZiAoISgoIW5vZGUtPmxlZnQoKSB8fCBub2RlLT5sZWZ0KCktPmNv bG9yKCkgPT0gQmxhY2spKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAg ICAgICBpZiAoISgoIW5vZGUtPnJpZ2h0KCkgfHwgbm9kZS0+cmlnaHQoKS0+Y29sb3IoKSA9PSBC bGFjaykpKQorICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgfQorCisgICAg ICAgIC8vIEV2ZXJ5IHNpbXBsZSBwYXRoIHRvIGEgbGVhZiBub2RlIGNvbnRhaW5zIHRoZSBzYW1l IG51bWJlciBvZgorICAgICAgICAvLyBibGFjayBub2Rlcy4KKyAgICAgICAgaW50IGxlZnRDb3Vu dCA9IDAsIHJpZ2h0Q291bnQgPSAwOworICAgICAgICBib29sIGxlZnRWYWxpZCA9IGNoZWNrSW52 YXJpYW50c0Zyb21Ob2RlKG5vZGUtPmxlZnQoKSwgJmxlZnRDb3VudCk7CisgICAgICAgIGJvb2wg cmlnaHRWYWxpZCA9IGNoZWNrSW52YXJpYW50c0Zyb21Ob2RlKG5vZGUtPnJpZ2h0KCksICZyaWdo dENvdW50KTsKKyAgICAgICAgaWYgKCFsZWZ0VmFsaWQgfHwgIXJpZ2h0VmFsaWQpCisgICAgICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICpibGFja0NvdW50ID0gbGVmdENvdW50ICsgKG5v ZGUtPmNvbG9yKCkgPT0gQmxhY2sgPyAxIDogMCk7CisgICAgICAgIHJldHVybiBsZWZ0Q291bnQg PT0gcmlnaHRDb3VudDsKKyAgICB9CisKKyNpZmRlZiBOREVCVUcKKyAgICB2b2lkIGxvZ0lmVmVy Ym9zZShjb25zdCBjaGFyKiBvdXRwdXQpIGNvbnN0IHsgfQorI2Vsc2UKKyAgICB2b2lkIGxvZ0lm VmVyYm9zZShjb25zdCBjaGFyKiBvdXRwdXQpIGNvbnN0CisgICAgeworICAgICAgICBpZiAobV92 ZXJib3NlRGVidWdnaW5nKQorICAgICAgICAgICAgTE9HX0VSUk9SKCIlcyIsIG91dHB1dCk7Cisg ICAgfQorI2VuZGlmCisKKyNpZm5kZWYgTkRFQlVHCisgICAgLy8gRHVtcHMgdGhlIHN1YnRyZWUg cm9vdGVkIGF0IHRoZSBnaXZlbiBub2RlLgorICAgIHZvaWQgZHVtcEZyb21Ob2RlKE5vZGUqIG5v ZGUsIGludCBpbmRlbnRhdGlvbikgY29uc3QKKyAgICB7CisgICAgICAgIFN0cmluZ0J1aWxkZXIg YnVpbGRlcjsKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBpbmRlbnRhdGlvbjsgaSsrKQor ICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoIiAiKTsKKyAgICAgICAgYnVpbGRlci5hcHBlbmQo Ii0iKTsKKyAgICAgICAgaWYgKG5vZGUpIHsKKyAgICAgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCIg Iik7CisgICAgICAgICAgICBidWlsZGVyLmFwcGVuZCh2YWx1ZVRvU3RyaW5nKG5vZGUtPmRhdGEo KSkpOworICAgICAgICAgICAgYnVpbGRlci5hcHBlbmQoKG5vZGUtPmNvbG9yKCkgPT0gQmxhY2sp ID8gIiAoYmxhY2spIiA6ICIgKHJlZCkiKTsKKyAgICAgICAgfQorICAgICAgICBMT0dfRVJST1Io IiVzIiwgYnVpbGRlci50b1N0cmluZygpLmFzY2lpKCkuZGF0YSgpKTsKKyAgICAgICAgaWYgKG5v ZGUpIHsKKyAgICAgICAgICAgIGR1bXBGcm9tTm9kZShub2RlLT5sZWZ0KCksIGluZGVudGF0aW9u ICsgMik7CisgICAgICAgICAgICBkdW1wRnJvbU5vZGUobm9kZS0+cmlnaHQoKSwgaW5kZW50YXRp b24gKyAyKTsKKyAgICAgICAgfQorICAgIH0KKyNlbmRpZgorCisgICAgLy8tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CisgICAgLy8gRGF0YSBtZW1iZXJzCisKKyAgICBSZWZQdHI8UE9EQXJlbmE+IG1fYXJlbmE7Cisg ICAgTm9kZSogbV9yb290OworICAgIGJvb2wgbV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25z OworI2lmbmRlZiBOREVCVUcKKyAgICBib29sIG1fdmVyYm9zZURlYnVnZ2luZzsKKyNlbmRpZgor fTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gUE9EUmVkQmxhY2tUcmVl X2gK 66425 2010-09-02 16:01:04 -0700 2010-09-02 16:53:38 -0700 Revised patch red-black-tree.patch text/plain 37897 kbr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjY4OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsODcgQEAKKzIwMTAtMDktMDIgIEtlbm5ldGggUnVzc2VsbCAgPGtickBnb29nbGUu Y29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFk ZCByZWQtYmxhY2sgdHJlZSBjYXBhYmxlIG9mIGhvbGRpbmcgcGxhaW4gb2xkIGRhdGEgKFBPRCkK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQ1MDU5CisK KyAgICAgICAgQWRkaW5nIGFuIGF1Z21lbnRhYmxlIHJlZC1ibGFjayB0cmVlIGNhcGFibGUgb2Yg aG9sZGluZyBQbGFpbiBPbGQKKyAgICAgICAgRGF0YSAoUE9EKSwgb3IgY2xhc3NlcyBib3R0b21p bmcgb3V0IGludG8gb25seSBQT0QsIGFuZCBhbgorICAgICAgICBhc3NvY2lhdGVkIFBPREFyZW5h LiBOb3RlIHRoYXQgdGhlIFBPREFyZW5hIHdpbGwgYmUgdXNlZCBieSBvdGhlcgorICAgICAgICBj bGFzc2VzIHRvIGFsbG9jYXRlIHRlbXBvcmFyeSBzdHJ1Y3R1cmVzLCB3aGljaCBpcyB3aHkgaXQg aXMgbm90CisgICAgICAgIGp1c3QgYW4gaW1wbGVtZW50YXRpb24gZGV0YWlsIG9mIHRoZSByZWQt YmxhY2sgdHJlZS4KKworICAgICAgICBUaGVzZSBjbGFzc2VzIGFyZSBiZWluZyBwbGFjZWQgdW5k ZXIgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9ncHUKKyAgICAgICAgZm9yIHRoZSB0aW1lIGJl aW5nLiBJZiB0aGV5IGFyZSBnZW5lcmFsaXplZCB0byBob2xkIGV2ZW4gZGF0YQorICAgICAgICB0 eXBlcyB3aGljaCBpbnRlcm5hbGx5IHBlcmZvcm0gZHluYW1pYyBtZW1vcnkgYWxsb2NhdGlvbiwg d2UgbWF5CisgICAgICAgIGNvbnNpZGVyIG1vdmluZyB0aGVtIHRvIFdURiBpbiB0aGUgZnV0dXJl LgorCisgICAgICAgIFVuaXQgdGVzdHMgZm9yIHRoZSBQT0RSZWRCbGFja1RyZWUgd2lsbCBiZSBp bnRlZ3JhdGVkIHNlcGFyYXRlbHkKKyAgICAgICAgdW5kZXIgYnVnIDQ1MDYwLgorCisgICAgICAg ICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RBcmVu YS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5hOjpBbGxvY2F0b3I6On5BbGxv Y2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxvY2F0b3I6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6RmFzdE1hbGxvY0FsbG9jYXRv cjo6YWxsb2NhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OmZyZWUpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6OkZhc3RNYWxsb2NBbGxv Y2F0b3I6OkZhc3RNYWxsb2NBbGxvY2F0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6 OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6YWxsb2NhdGVPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6On5QT0RBcmVuYSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RBcmVuYTo6UE9EQXJlbmEpOgorICAgICAgICAoV2ViQ29yZTo6UE9EQXJlbmE6Om1pbkFs aWdubWVudCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RBcmVuYTo6cm91bmRVcCk6CisgICAgICAg IChXZWJDb3JlOjpQT0RBcmVuYTo6Q2h1bms6OkNodW5rKToKKyAgICAgICAgKFdlYkNvcmU6OlBP REFyZW5hOjpDaHVuazo6fkNodW5rKToKKyAgICAgICAgKFdlYkNvcmU6OlBPREFyZW5hOjpDaHVu azo6YWxsb2NhdGUpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RSZWRCbGFj a1RyZWUuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OlZpc2l0 b3I6On5WaXNpdG9yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6UE9EUmVk QmxhY2tUcmVlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6flBPRFJlZEJs YWNrVHJlZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmFkZCk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnJlbW92ZSk6CisgICAgICAgIChXZWJDb3Jl OjpQT0RSZWRCbGFja1RyZWU6OmNvbnRhaW5zKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6dmlzaXRJbm9yZGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJl ZTo6c2l6ZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnNldE5lZWRzRnVs bE9yZGVyaW5nQ29tcGFyaXNvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVl OjpjaGVja0ludmFyaWFudHMpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpk dW1wKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6c2V0VmVyYm9zZURlYnVn Z2luZyk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6Ok5vZGUpOgor ICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjp+Tm9kZSk6CisgICAgICAg IChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OmNvbG9yKToKKyAgICAgICAgKFdlYkNv cmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0Q29sb3IpOgorICAgICAgICAoV2ViQ29yZTo6 UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpkYXRhKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6Tm9kZTo6Y29weUZyb20pOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tU cmVlOjpOb2RlOjpsZWZ0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9k ZTo6c2V0TGVmdCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6Ok5vZGU6OnJp Z2h0KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Tm9kZTo6c2V0UmlnaHQp OgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpwYXJlbnQpOgorICAg ICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpOb2RlOjpzZXRQYXJlbnQpOgorICAgICAg ICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpyb290KToKKyAgICAgICAgKFdlYkNvcmU6OlBP RFJlZEJsYWNrVHJlZTo6dXBkYXRlTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFj a1RyZWU6OnRyZWVTZWFyY2gpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0 cmVlU2VhcmNoTm9ybWFsKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJl ZVNlYXJjaEZ1bGxDb21wYXJpc29ucyk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1Ry ZWU6OnRyZWVJbnNlcnQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjp0cmVl U3VjY2Vzc29yKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6dHJlZU1pbmlt dW0pOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpwcm9wYWdhdGVVcGRhdGVz KToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bGVmdFJvdGF0ZSk6CisgICAg ICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OnJpZ2h0Um90YXRlKToKKyAgICAgICAgKFdl YkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6aW5zZXJ0Tm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQ T0RSZWRCbGFja1RyZWU6OmRlbGV0ZUZpeHVwKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJs YWNrVHJlZTo6ZGVsZXRlTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6 OnZpc2l0SW5vcmRlckltcGwpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpD b3VudGVyOjpDb3VudGVyKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6Q291 bnRlcjo6dmlzaXQpOgorICAgICAgICAoV2ViQ29yZTo6UE9EUmVkQmxhY2tUcmVlOjpDb3VudGVy Ojpjb3VudCk6CisgICAgICAgIChXZWJDb3JlOjpQT0RSZWRCbGFja1RyZWU6OmNoZWNrSW52YXJp YW50c0Zyb21Ob2RlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6bG9nSWZW ZXJib3NlKToKKyAgICAgICAgKFdlYkNvcmU6OlBPRFJlZEJsYWNrVHJlZTo6ZHVtcEZyb21Ob2Rl KToKKwogMjAxMC0wOS0wMiAgQWRhbSBMYW5nbGV5ICA8YWdsQGNocm9taXVtLm9yZz4KIAogICAg ICAgICBSZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpJbmRleDogV2ViQ29yZS9XZWJDb3JlLmd5cGkK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHJldmlzaW9uIDY2Njc1KQorKysg V2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtpbmcgY29weSkKQEAgLTIzNDEsNiArMjM0MSw4IEBA CiAgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZmlsdGVycy9Tb3VyY2VBbHBoYS5oJywK ICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL1NvdXJjZUdyYXBoaWMuY3Bw JywKICAgICAgICAgICAgICdwbGF0Zm9ybS9ncmFwaGljcy9maWx0ZXJzL1NvdXJjZUdyYXBoaWMu aCcsCisgICAgICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BPREFyZW5hLmgnLAorICAg ICAgICAgICAgJ3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RSZWRCbGFja1RyZWUuaCcsCiAgICAg ICAgICAgICAncGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1NoYWRlci5jcHAnLAogICAgICAgICAgICAg J3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9TaGFkZXIuaCcsCiAgICAgICAgICAgICAncGxhdGZvcm0v Z3JhcGhpY3MvZ3B1L1NvbGlkRmlsbFNoYWRlci5jcHAnLApJbmRleDogV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9ncHUvUE9EQXJlbmEuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2dwdS9QT0RBcmVuYS5oCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9ncHUvUE9EQXJlbmEuaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMDAgQEAK Ky8qCisgKiBDb3B5cmlnaHQgMjAxMCwgR29vZ2xlIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICog ICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkg Zm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRo ZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUK KyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIElu Yy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBl bmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJl IHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMg U09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklC VVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBP V05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwg SU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5Z CisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2lmbmRlZiBQT0RBcmVuYV9oCisjZGVmaW5lIFBPREFyZW5hX2gKKworI2luY2x1ZGUgPHN0ZGlu dC5oPgorI2luY2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CisjaW5jbHVkZSA8d3RmL0Zhc3RNYWxs b2MuaD4KKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRy Lmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRl ZC5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCisv LyBBbiBhcmVuYSB3aGljaCBhbGxvY2F0ZXMgb25seSBQbGFpbiBPbGQgRGF0YSAoUE9EKSwgb3Ig Y2xhc3NlcyBhbmQKKy8vIHN0cnVjdHMgYm90dG9taW5nIG91dCBpbiBQbGFpbiBPbGQgRGF0YS4g Tk9URTogdGhlIGNvbnN0cnVjdG9ycyBvZgorLy8gdGhlIG9iamVjdHMgYWxsb2NhdGVkIGluIHRo aXMgYXJlbmEgYXJlIGNhbGxlZCwgYnV0IF9ub3RfIHRoZWlyCisvLyBkZXN0cnVjdG9ycy4KKwor Y2xhc3MgUE9EQXJlbmEgOiBwdWJsaWMgUmVmQ291bnRlZDxQT0RBcmVuYT4geworcHVibGljOgor ICAgIC8vIFRoZSBhcmVuYSBpcyBjb25maWd1cmVkIHdpdGggYW4gYWxsb2NhdG9yLCB3aGljaCBp cyByZXNwb25zaWJsZQorICAgIC8vIGZvciBhbGxvY2F0aW5nIGFuZCBmcmVlaW5nIGNodW5rcyBv ZiBtZW1vcnkgYXQgYSB0aW1lLgorICAgIGNsYXNzIEFsbG9jYXRvciA6IHB1YmxpYyBSZWZDb3Vu dGVkPEFsbG9jYXRvcj4geworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB2b2lkKiBhbGxv Y2F0ZShzaXplX3Qgc2l6ZSkgPSAwOworICAgICAgICB2aXJ0dWFsIHZvaWQgZnJlZSh2b2lkKiBw dHIpID0gMDsKKyAgICBwcm90ZWN0ZWQ6CisgICAgICAgIHZpcnR1YWwgfkFsbG9jYXRvcigpIHsg fQorICAgICAgICBmcmllbmQgY2xhc3MgV1RGOjpSZWZDb3VudGVkPEFsbG9jYXRvcj47CisgICAg fTsKKworICAgIC8vIFRoZSBBcmVuYSdzIGRlZmF1bHQgYWxsb2NhdG9yLCB3aGljaCB1c2VzIGZh c3RNYWxsb2MgYW5kCisgICAgLy8gZmFzdEZyZWUgdG8gYWxsb2NhdGUgY2h1bmtzIG9mIHN0b3Jh Z2UuCisgICAgY2xhc3MgRmFzdE1hbGxvY0FsbG9jYXRvciA6IHB1YmxpYyBBbGxvY2F0b3Igewor ICAgIHB1YmxpYzoKKyAgICAgICAgc3RhdGljIFBhc3NSZWZQdHI8RmFzdE1hbGxvY0FsbG9jYXRv cj4gY3JlYXRlKCkKKyAgICAgICAgeworICAgICAgICAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBG YXN0TWFsbG9jQWxsb2NhdG9yKTsKKyAgICAgICAgfQorCisgICAgICAgIHZpcnR1YWwgdm9pZCog YWxsb2NhdGUoc2l6ZV90IHNpemUpIHsgcmV0dXJuIGZhc3RNYWxsb2Moc2l6ZSk7IH0KKyAgICAg ICAgdmlydHVhbCB2b2lkIGZyZWUodm9pZCogcHRyKSB7IGZhc3RGcmVlKHB0cik7IH0KKworICAg IHByb3RlY3RlZDoKKyAgICAgICAgRmFzdE1hbGxvY0FsbG9jYXRvcigpIHsgfQorICAgIH07CisK KyAgICAvLyBDcmVhdGVzIGEgbmV3IFBPREFyZW5hIGNvbmZpZ3VyZWQgd2l0aCBhIEZhc3RNYWxs b2NBbGxvY2F0b3IuCisgICAgc3RhdGljIFBhc3NSZWZQdHI8UE9EQXJlbmE+IGNyZWF0ZSgpCisg ICAgeworICAgICAgICByZXR1cm4gYWRvcHRSZWYobmV3IFBPREFyZW5hKTsKKyAgICB9CisKKyAg ICAvLyBDcmVhdGVzIGEgbmV3IFBPREFyZW5hIGNvbmZpZ3VyZWQgd2l0aCB0aGUgZ2l2ZW4gQWxs b2NhdG9yLgorICAgIHN0YXRpYyBQYXNzUmVmUHRyPFBPREFyZW5hPiBjcmVhdGUoUGFzc1JlZlB0 cjxBbGxvY2F0b3I+IGFsbG9jYXRvcikKKyAgICB7CisgICAgICAgIHJldHVybiBhZG9wdFJlZihu ZXcgUE9EQXJlbmEoYWxsb2NhdG9yKSk7CisgICAgfQorCisgICAgLy8gQWxsb2NhdGVzIGFuIG9i amVjdCBmcm9tIHRoZSBhcmVuYS4KKyAgICB0ZW1wbGF0ZTxjbGFzcyBUPiBUKiBhbGxvY2F0ZU9i amVjdCgpCisgICAgeworICAgICAgICB2b2lkKiBwdHIgPSAwOworICAgICAgICBzaXplX3Qgcm91 bmRlZFNpemUgPSByb3VuZFVwKHNpemVvZihUKSwgbWluQWxpZ25tZW50PFQ+KCkpOworICAgICAg ICBpZiAobV9jdXJyZW50KQorICAgICAgICAgICAgcHRyID0gbV9jdXJyZW50LT5hbGxvY2F0ZShy b3VuZGVkU2l6ZSk7CisKKyAgICAgICAgaWYgKCFwdHIpIHsKKyAgICAgICAgICAgIGlmIChyb3Vu ZGVkU2l6ZSA+IG1fY3VycmVudENodW5rU2l6ZSkKKyAgICAgICAgICAgICAgICBtX2N1cnJlbnRD aHVua1NpemUgPSByb3VuZGVkU2l6ZTsKKyAgICAgICAgICAgIG1fY2h1bmtzLmFwcGVuZChhZG9w dFB0cihuZXcgQ2h1bmsobV9hbGxvY2F0b3IuZ2V0KCksIG1fY3VycmVudENodW5rU2l6ZSkpKTsK KyAgICAgICAgICAgIG1fY3VycmVudCA9IG1fY2h1bmtzLmxhc3QoKS5nZXQoKTsKKyAgICAgICAg ICAgIHB0ciA9IG1fY3VycmVudC0+YWxsb2NhdGUocm91bmRlZFNpemUpOworICAgICAgICB9CisK KyAgICAgICAgaWYgKHB0cikgeworICAgICAgICAgICAgLy8gVXNlIHBsYWNlbWVudCBvcGVyYXRv ciBuZXcgdG8gYWxsb2NhdGUgYSBUIGF0IHRoaXMgbG9jYXRpb24uCisgICAgICAgICAgICBuZXco cHRyKSBUKCk7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VCo+KHB0 cik7CisgICAgfQorCitwcm90ZWN0ZWQ6CisgICAgflBPREFyZW5hKCkgeyB9CisgICAgZnJpZW5k IGNsYXNzIFdURjo6UmVmQ291bnRlZDxQT0RBcmVuYT47CisKK3ByaXZhdGU6CisgICAgUE9EQXJl bmEoKQorICAgICAgICA6IG1fYWxsb2NhdG9yKEZhc3RNYWxsb2NBbGxvY2F0b3I6OmNyZWF0ZSgp KQorICAgICAgICAsIG1fY3VycmVudCgwKQorICAgICAgICAsIG1fY3VycmVudENodW5rU2l6ZShE ZWZhdWx0Q2h1bmtTaXplKSB7IH0KKworICAgIGV4cGxpY2l0IFBPREFyZW5hKFBhc3NSZWZQdHI8 QWxsb2NhdG9yPiBhbGxvY2F0b3IpCisgICAgICAgIDogbV9hbGxvY2F0b3IoYWxsb2NhdG9yKQor ICAgICAgICAsIG1fY3VycmVudCgwKQorICAgICAgICAsIG1fY3VycmVudENodW5rU2l6ZShEZWZh dWx0Q2h1bmtTaXplKSB7IH0KKworICAgIGVudW0geworICAgICAgICBEZWZhdWx0Q2h1bmtTaXpl ID0gMTYzODQKKyAgICB9OworCisgICAgLy8gUmV0dXJucyB0aGUgYWxpZ25tZW50IHJlcXVpcmVt ZW50IGZvciBjbGFzc2VzIGFuZCBzdHJ1Y3RzIG9uIHRoZQorICAgIC8vIGN1cnJlbnQgcGxhdGZv cm0uCisgICAgdGVtcGxhdGUgPGNsYXNzIFQ+IHN0YXRpYyBzaXplX3QgbWluQWxpZ25tZW50KCkK KyAgICB7CisgICAgICAgIHJldHVybiBXVEZfQUxJR05fT0YoVCk7CisgICAgfQorCisgICAgLy8g Um91bmRzIHVwIHRoZSBnaXZlbiBhbGxvY2F0aW9uIHNpemUgdG8gdGhlIHNwZWNpZmllZCBhbGln bm1lbnQuCisgICAgc2l6ZV90IHJvdW5kVXAoc2l6ZV90IHNpemUsIHNpemVfdCBhbGlnbm1lbnQp CisgICAgeworICAgICAgICBBU1NFUlQoIShhbGlnbm1lbnQgJSAyKSk7CisgICAgICAgIHJldHVy biAoc2l6ZSArIGFsaWdubWVudCAtIDEpICYgfihhbGlnbm1lbnQgLSAxKTsKKyAgICB9CisKKyAg ICAvLyBNYW5hZ2VzIGEgY2h1bmsgb2YgbWVtb3J5IGFuZCBpbmRpdmlkdWFsIGFsbG9jYXRpb25z IG91dCBvZiBpdC4KKyAgICBjbGFzcyBDaHVuayA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CisgICAg cHVibGljOgorICAgICAgICAvLyBBbGxvY2F0ZXMgYSBibG9jayBvZiBtZW1vcnkgb2YgdGhlIGdp dmVuIHNpemUgZnJvbSB0aGUgcGFzc2VkCisgICAgICAgIC8vIEFsbG9jYXRvci4KKyAgICAgICAg Q2h1bmsoQWxsb2NhdG9yKiBhbGxvY2F0b3IsIHNpemVfdCBzaXplKQorICAgICAgICAgICAgOiBt X2FsbG9jYXRvcihhbGxvY2F0b3IpCisgICAgICAgICAgICAsIG1fc2l6ZShzaXplKQorICAgICAg ICAgICAgLCBtX2N1cnJlbnRPZmZzZXQoMCkKKyAgICAgICAgeworICAgICAgICAgICAgbV9iYXNl ID0gc3RhdGljX2Nhc3Q8dWludDhfdCo+KG1fYWxsb2NhdG9yLT5hbGxvY2F0ZShzaXplKSk7Cisg ICAgICAgIH0KKworICAgICAgICAvLyBGcmVlcyB0aGUgbWVtb3J5IGFsbG9jYXRlZCBmcm9tIHRo ZSBBbGxvY2F0b3IgaW4gdGhlCisgICAgICAgIC8vIGNvbnN0cnVjdG9yLgorICAgICAgICB+Q2h1 bmsoKQorICAgICAgICB7CisgICAgICAgICAgICBtX2FsbG9jYXRvci0+ZnJlZShtX2Jhc2UpOwor ICAgICAgICB9CisKKyAgICAgICAgLy8gUmV0dXJucyBhIHBvaW50ZXIgdG8gInNpemUiIGJ5dGVz IG9mIHN0b3JhZ2UsIG9yIDAgaWYgdGhpcworICAgICAgICAvLyBDaHVuayBjb3VsZCBub3Qgc2F0 aXNmeSB0aGUgYWxsb2NhdGlvbi4KKyAgICAgICAgdm9pZCogYWxsb2NhdGUoc2l6ZV90IHNpemUp CisgICAgICAgIHsKKyAgICAgICAgICAgIC8vIENoZWNrIGZvciBvdmVyZmxvdworICAgICAgICAg ICAgaWYgKG1fY3VycmVudE9mZnNldCArIHNpemUgPCBtX2N1cnJlbnRPZmZzZXQpCisgICAgICAg ICAgICAgICAgcmV0dXJuIDA7CisKKyAgICAgICAgICAgIGlmIChtX2N1cnJlbnRPZmZzZXQgKyBz aXplID4gbV9zaXplKQorICAgICAgICAgICAgICAgIHJldHVybiAwOworCisgICAgICAgICAgICB2 b2lkKiByZXN1bHQgPSBtX2Jhc2UgKyBtX2N1cnJlbnRPZmZzZXQ7CisgICAgICAgICAgICBtX2N1 cnJlbnRPZmZzZXQgKz0gc2l6ZTsKKyAgICAgICAgICAgIHJldHVybiByZXN1bHQ7CisgICAgICAg IH0KKworICAgIHByaXZhdGU6CisgICAgICAgIEFsbG9jYXRvciogbV9hbGxvY2F0b3I7CisgICAg ICAgIHVpbnQ4X3QqIG1fYmFzZTsKKyAgICAgICAgc2l6ZV90IG1fc2l6ZTsKKyAgICAgICAgc2l6 ZV90IG1fY3VycmVudE9mZnNldDsKKyAgICB9OworCisgICAgUmVmUHRyPEFsbG9jYXRvcj4gbV9h bGxvY2F0b3I7CisgICAgQ2h1bmsqIG1fY3VycmVudDsKKyAgICBzaXplX3QgbV9jdXJyZW50Q2h1 bmtTaXplOworICAgIFZlY3RvcjxPd25QdHI8Q2h1bms+ID4gbV9jaHVua3M7Cit9OworCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBQT0RBcmVuYV9oCkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RSZWRCbGFja1RyZWUuaAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dwdS9QT0RSZWRCbGFja1RyZWUuaAkocmV2aXNpb24g MCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3B1L1BPRFJlZEJsYWNrVHJlZS5oCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDc1NiBAQAorLyoKKyAqIENvcHlyaWdodCAyMDEwLCBHb29n bGUgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAg ICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICog TmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICog Y29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBk ZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0 dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUg Q09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisvLyBBIHJlZC1ibGFjayB0cmVlLCB3aGljaCBp cyBhIGZvcm0gb2YgYSBiYWxhbmNlZCBiaW5hcnkgdHJlZS4gSXQKKy8vIHN1cHBvcnRzIGVmZmlj aWVudCBpbnNlcnRpb24sIGRlbGV0aW9uIGFuZCBxdWVyaWVzIG9mIGNvbXBhcmFibGUKKy8vIGVs ZW1lbnRzLiBUaGUgc2FtZSBlbGVtZW50IG1heSBiZSBpbnNlcnRlZCBtdWx0aXBsZSB0aW1lcy4g VGhlCisvLyBhbGdvcml0aG1pYyBjb21wbGV4aXR5IG9mIGNvbW1vbiBvcGVyYXRpb25zIGlzOgor Ly8KKy8vICAgSW5zZXJ0aW9uOiBPKGxnKG4pKQorLy8gICBEZWxldGlvbjogIE8obGcobikpCisv LyAgIFF1ZXJ5aW5nOiAgTyhsZyhuKSkKKy8vCisvLyBUaGUgZGF0YSB0eXBlIFQgdGhhdCBpcyBz dG9yZWQgaW4gdGhpcyByZWQtYmxhY2sgdHJlZSBtdXN0IGJlIG9ubHkKKy8vIFBsYWluIE9sZCBE YXRhIChQT0QpLCBvciBib3R0b20gb3V0IGludG8gUE9ELiBJdCBtdXN0IF9ub3RfIHJlbHkgb24K Ky8vIGhhdmluZyBpdHMgZGVzdHJ1Y3RvciBjYWxsZWQuIFRoaXMgaW1wbGVtZW50YXRpb24gaW50 ZXJuYWxseQorLy8gYWxsb2NhdGVzIHN0b3JhZ2UgaW4gbGFyZ2UgY2h1bmtzIGFuZCBkb2VzIG5v dCBjYWxsIHRoZSBkZXN0cnVjdG9yCisvLyBvbiBlYWNoIG9iamVjdC4KKy8vCisvLyBUeXBlIFQg bXVzdCBzdXBwbHkgYSBkZWZhdWx0IGNvbnN0cnVjdG9yLCBhIGNvcHkgY29uc3RydWN0b3IsIGFu ZAorLy8gdGhlICI8IiBhbmQgIj09IiBvcGVyYXRvcnMuCisvLworLy8gSW4gZGVidWcgbW9kZSwg cHJpbnRpbmcgb2YgdGhlIGRhdGEgY29udGFpbmVkIGluIHRoZSB0cmVlIGlzCisvLyBlbmFibGVk LiBUaGlzIHJlcXVpcmVzIHRoZSBmb2xsb3dpbmcgZnVuY3Rpb24gdG8gYmUgYXZhaWxhYmxlOgor Ly8KKy8vICAgU3RyaW5nIHZhbHVlVG9TdHJpbmcoY29uc3QgVCYpOworLy8KKy8vIE5vdGUgdGhh dCB3aGVuIGNvbXBsZXggdHlwZXMgYXJlIHN0b3JlZCBpbiB0aGlzIHJlZC9ibGFjayB0cmVlLCBp dAorLy8gaXMgcG9zc2libGUgdGhhdCBzaW5nbGUgaW52b2NhdGlvbnMgb2YgdGhlICI8IiBhbmQg Ij09IiBvcGVyYXRvcnMKKy8vIHdpbGwgYmUgaW5zdWZmaWNpZW50IHRvIGRlc2NyaWJlIHRoZSBv cmRlcmluZyBvZiBlbGVtZW50cyBpbiB0aGUKKy8vIHRyZWUgZHVyaW5nIHF1ZXJpZXMuIEFzIGEg Y29uY3JldGUgZXhhbXBsZSwgY29uc2lkZXIgdGhlIGNhc2Ugd2hlcmUKKy8vIGludGVydmFscyBh cmUgc3RvcmVkIGluIHRoZSB0cmVlIHNvcnRlZCBieSBsb3cgZW5kcG9pbnQuIFRoZSAiPCIKKy8v IG9wZXJhdG9yIG9uIHRoZSBJbnRlcnZhbCBjbGFzcyBvbmx5IGNvbXBhcmVzIHRoZSBsb3cgZW5k cG9pbnQsIGJ1dAorLy8gdGhlICI9PSIgb3BlcmF0b3IgdGFrZXMgaW50byBhY2NvdW50IHRoZSBo aWdoIGVuZHBvaW50IGFzIHdlbGwuCisvLyBUaGlzIG1ha2VzIHRoZSBuZWNlc3NhcnkgbG9naWMg Zm9yIHF1ZXJ5aW5nIGFuZCBkZWxldGlvbiBzb21ld2hhdAorLy8gbW9yZSBjb21wbGV4LiBJbiBv cmRlciB0byBwcm9wZXJseSBoYW5kbGUgc3VjaCBzaXR1YXRpb25zLCB0aGUKKy8vIHByb3BlcnR5 ICJuZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zIiBtdXN0IGJlIHNldCB0byB0cnVlIG9uCisv LyB0aGUgdHJlZS4KKy8vCisvLyBUaGlzIHJlZC1ibGFjayB0cmVlIGlzIGRlc2lnbmVkIHRvIGJl IF9hdWdtZW50ZWRfOyBzdWJjbGFzc2VzIGNhbgorLy8gYWRkIGFkZGl0aW9uYWwgYW5kIHN1bW1h cnkgaW5mb3JtYXRpb24gdG8gZWFjaCBub2RlIHRvIGVmZmljaWVudGx5CisvLyBzdG9yZSBhbmQg aW5kZXggbW9yZSBjb21wbGV4IGRhdGEgc3RydWN0dXJlcy4gQSBjb25jcmV0ZSBleGFtcGxlIGlz CisvLyB0aGUgSW50ZXJ2YWxUcmVlLCB3aGljaCBleHRlbmRzIGVhY2ggbm9kZSB3aXRoIGEgc3Vt bWFyeSBzdGF0aXN0aWMKKy8vIHRvIGVmZmljaWVudGx5IHN0b3JlIG9uZS1kaW1lbnNpb25hbCBp bnRlcnZhbHMuCisvLworLy8gVGhlIGRlc2lnbiBvZiB0aGlzIHJlZC1ibGFjayB0cmVlIGNvbWVz IGZyb20gQ29ybWVuLCBMZWlzZXJzb24sCisvLyBhbmQgUml2ZXN0LCBfSW50cm9kdWN0aW9uIHRv IEFsZ29yaXRobXNfLCBNSVQgUHJlc3MsIDE5OTAuCisKKyNpZm5kZWYgUE9EUmVkQmxhY2tUcmVl X2gKKyNkZWZpbmUgUE9EUmVkQmxhY2tUcmVlX2gKKworI2luY2x1ZGUgIlBPREFyZW5hLmgiCisj aW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4K KyNpbmNsdWRlIDx3dGYvUmVmUHRyLmg+CisjaWZuZGVmIE5ERUJVRworI2luY2x1ZGUgIkxvZ2dp bmcuaCIKKyNpbmNsdWRlICJQbGF0Zm9ybVN0cmluZy5oIgorI2luY2x1ZGUgIlN0cmluZ0J1aWxk ZXIuaCIKKyNpbmNsdWRlIDx3dGYvdGV4dC9DU3RyaW5nLmg+CisjZW5kaWYKKworbmFtZXNwYWNl IFdlYkNvcmUgeworCit0ZW1wbGF0ZTxjbGFzcyBUPgorY2xhc3MgUE9EUmVkQmxhY2tUcmVlIHsK K3B1YmxpYzoKKyAgICAvLyBWaXNpdG9yIGludGVyZmFjZSBmb3Igd2Fsa2luZyBhbGwgb2YgdGhl IHRyZWUncyBlbGVtZW50cy4KKyAgICBjbGFzcyBWaXNpdG9yIHsKKyAgICBwdWJsaWM6CisgICAg ICAgIHZpcnR1YWwgdm9pZCB2aXNpdChjb25zdCBUJiBkYXRhKSA9IDA7CisgICAgcHJvdGVjdGVk OgorICAgICAgICB2aXJ0dWFsIH5WaXNpdG9yKCkgeyB9CisgICAgfTsKKworICAgIC8vIENvbnN0 cnVjdHMgYSBuZXcgcmVkLWJsYWNrIHRyZWUsIGFsbG9jYXRpbmcgdGVtcG9yYXJ5IG9iamVjdHMK KyAgICAvLyBmcm9tIGEgbmV3bHkgY29uc3RydWN0ZWQgUE9EQXJlbmEuCisgICAgUE9EUmVkQmxh Y2tUcmVlKCkKKyAgICAgICAgOiBtX2FyZW5hKFBPREFyZW5hOjpjcmVhdGUoKSkKKyAgICAgICAg LCBtX3Jvb3QoMCkKKyAgICAgICAgLCBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMoZmFs c2UpCisjaWZuZGVmIE5ERUJVRworICAgICAgICAsIG1fdmVyYm9zZURlYnVnZ2luZyhmYWxzZSkK KyNlbmRpZgorICAgIHsKKyAgICB9CisKKyAgICAvLyBDb25zdHJ1Y3RzIGEgbmV3IHJlZC1ibGFj ayB0cmVlLCBhbGxvY2F0aW5nIHRlbXBvcmFyeSBvYmplY3RzCisgICAgLy8gZnJvbSB0aGUgZ2l2 ZW4gUE9EQXJlbmEuCisgICAgZXhwbGljaXQgUE9EUmVkQmxhY2tUcmVlKFBhc3NSZWZQdHI8UE9E QXJlbmE+IGFyZW5hKQorICAgICAgICA6IG1fYXJlbmEoYXJlbmEpCisgICAgICAgICwgbV9yb290 KDApCisgICAgICAgICwgbV9uZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zKGZhbHNlKQorI2lm bmRlZiBOREVCVUcKKyAgICAgICAgLCBtX3ZlcmJvc2VEZWJ1Z2dpbmcoZmFsc2UpCisjZW5kaWYK KyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB+UE9EUmVkQmxhY2tUcmVlKCkgeyB9CisKKyAg ICB2b2lkIGFkZChjb25zdCBUJiBkYXRhKQorICAgIHsKKyAgICAgICAgTm9kZSogbm9kZSA9IG5l dyBOb2RlKGRhdGEpOworICAgICAgICBpbnNlcnROb2RlKG5vZGUpOworICAgIH0KKworICAgIC8v IFJldHVybnMgdHJ1ZSBpZiB0aGUgZGF0dW0gd2FzIGZvdW5kIGluIHRoZSB0cmVlLgorICAgIGJv b2wgcmVtb3ZlKGNvbnN0IFQmIGRhdGEpCisgICAgeworICAgICAgICBOb2RlKiBub2RlID0gdHJl ZVNlYXJjaChkYXRhKTsKKyAgICAgICAgaWYgKG5vZGUpIHsKKyAgICAgICAgICAgIGRlbGV0ZU5v ZGUobm9kZSk7CisgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgYm9vbCBjb250YWlucyhjb25zdCBUJiBkYXRhKSBj b25zdCB7IHJldHVybiB0cmVlU2VhcmNoKGRhdGEpOyB9CisKKyAgICB2b2lkIHZpc2l0SW5vcmRl cihWaXNpdG9yKiB2aXNpdG9yKSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKCFtX3Jvb3QpCisg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIHZpc2l0SW5vcmRlckltcGwobV9yb290LCB2aXNp dG9yKTsKKyAgICB9CisKKyAgICBpbnQgc2l6ZSgpIGNvbnN0CisgICAgeworICAgICAgICBDb3Vu dGVyIGNvdW50ZXI7CisgICAgICAgIHZpc2l0SW5vcmRlcigmY291bnRlcik7CisgICAgICAgIHJl dHVybiBjb3VudGVyLmNvdW50KCk7CisgICAgfQorCisgICAgLy8gU2VlIHRoZSBjbGFzcyBkb2N1 bWVudGF0aW9uIGZvciBhbiBleHBsYW5hdGlvbiBvZiB0aGlzIHByb3BlcnR5LgorICAgIHZvaWQg c2V0TmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29ucyhib29sIG5lZWRzRnVsbE9yZGVyaW5nQ29t cGFyaXNvbnMpCisgICAgeworICAgICAgICBtX25lZWRzRnVsbE9yZGVyaW5nQ29tcGFyaXNvbnMg PSBuZWVkc0Z1bGxPcmRlcmluZ0NvbXBhcmlzb25zOworICAgIH0KKworICAgIHZpcnR1YWwgYm9v bCBjaGVja0ludmFyaWFudHMoKSBjb25zdAorICAgIHsKKyAgICAgICAgaW50IGJsYWNrQ291bnQ7 CisgICAgICAgIHJldHVybiBjaGVja0ludmFyaWFudHNGcm9tTm9kZShtX3Jvb3QsICZibGFja0Nv dW50KTsKKyAgICB9CisKKyNpZm5kZWYgTkRFQlVHCisgICAgLy8gRHVtcHMgdGhlIHRyZWUncyBj b250ZW50cyB0byB0aGUgbG9nZ2luZyBpbmZvIHN0cmVhbSBmb3IKKyAgICAvLyBkZWJ1Z2dpbmcg cHVycG9zZXMuCisgICAgdm9pZCBkdW1wKCkgY29uc3QKKyAgICB7CisgICAgICAgIGR1bXBGcm9t Tm9kZShtX3Jvb3QsIDApOworICAgIH0KKworICAgIC8vIFR1cm5zIG9uIG9yIG9mZiB2ZXJib3Nl IGRlYnVnZ2luZyBvZiB0aGUgdHJlZSwgY2F1c2luZyBtYW55CisgICAgLy8gbWVzc2FnZXMgdG8g YmUgbG9nZ2VkIGR1cmluZyBpbnNlcnRpb24gYW5kIG90aGVyIG9wZXJhdGlvbnMgaW4KKyAgICAv LyBkZWJ1ZyBtb2RlLgorICAgIHZvaWQgc2V0VmVyYm9zZURlYnVnZ2luZyhib29sIHZlcmJvc2VE ZWJ1Z2dpbmcpCisgICAgeworICAgICAgICBtX3ZlcmJvc2VEZWJ1Z2dpbmcgPSB2ZXJib3NlRGVi dWdnaW5nOworICAgIH0KKyNlbmRpZgorCitwcm90ZWN0ZWQ6CisgICAgZW51bSBDb2xvciB7Cisg ICAgICAgIFJlZCA9IDEsCisgICAgICAgIEJsYWNrCisgICAgfTsKKworICAgIC8vIFRoZSBiYXNl IE5vZGUgY2xhc3Mgd2hpY2ggaXMgc3RvcmVkIGluIHRoZSB0cmVlLiBOb2RlcyBhcmUgb25seQor ICAgIC8vIGFuIGludGVybmFsIGNvbmNlcHQ7IHVzZXJzIG9mIHRoZSB0cmVlIGRlYWwgb25seSB3 aXRoIHRoZSBkYXRhCisgICAgLy8gdGhleSBzdG9yZSBpbiBpdC4KKyAgICBjbGFzcyBOb2RlIDog cHVibGljIE5vbmNvcHlhYmxlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIC8vIENvbnN0cnVjdG9y LiBOZXdseS1jcmVhdGVkIG5vZGVzIGFyZSBjb2xvcmVkIHJlZC4KKyAgICAgICAgZXhwbGljaXQg Tm9kZShjb25zdCBUJiBkYXRhKQorICAgICAgICAgICAgOiBtX2xlZnQoMCkKKyAgICAgICAgICAg ICwgbV9yaWdodCgwKQorICAgICAgICAgICAgLCBtX3BhcmVudCgwKQorICAgICAgICAgICAgLCBt X2NvbG9yKFJlZCkKKyAgICAgICAgICAgICwgbV9kYXRhKGRhdGEpCisgICAgICAgIHsKKyAgICAg ICAgfQorCisgICAgICAgIHZpcnR1YWwgfk5vZGUoKSB7IH0KKworICAgICAgICBDb2xvciBjb2xv cigpIGNvbnN0IHsgcmV0dXJuIG1fY29sb3I7IH0KKyAgICAgICAgdm9pZCBzZXRDb2xvcihDb2xv ciBjb2xvcikgeyBtX2NvbG9yID0gY29sb3I7IH0KKworICAgICAgICAvLyBGZXRjaGVzIHRoZSB1 c2VyIGRhdGEuCisgICAgICAgIFQmIGRhdGEoKSB7IHJldHVybiBtX2RhdGE7IH0KKworICAgICAg ICAvLyBDb3BpZXMgYWxsIHVzZXItbGV2ZWwgZmllbGRzIGZyb20gdGhlIHNvdXJjZSBub2RlLCBi dXQgbm90CisgICAgICAgIC8vIGludGVybmFsIGZpZWxkcy4gRm9yIGV4YW1wbGUsIHRoZSBiYXNl IGltcGxlbWVudGF0aW9uIG9mIHRoaXMKKyAgICAgICAgLy8gbWV0aG9kIGNvcGllcyB0aGUgIm1f ZGF0YSIgZmllbGQsIGJ1dCBub3QgdGhlIGNoaWxkIG9yIHBhcmVudAorICAgICAgICAvLyBmaWVs ZHMuIEFueSBhdWdtZW50YXRpb24gaW5mb3JtYXRpb24gYWxzbyBkb2VzIG5vdCBuZWVkIHRvIGJl CisgICAgICAgIC8vIGNvcGllZCwgYXMgaXQgd2lsbCBiZSByZWNvbXB1dGVkLiBTdWJjbGFzc2Vz IG11c3QgY2FsbCB0aGUKKyAgICAgICAgLy8gc3VwZXJjbGFzcyBpbXBsZW1lbnRhdGlvbi4KKyAg ICAgICAgdmlydHVhbCB2b2lkIGNvcHlGcm9tKE5vZGUqIHNyYykgeyBtX2RhdGEgPSBzcmMtPmRh dGEoKTsgfQorCisgICAgICAgIE5vZGUqIGxlZnQoKSBjb25zdCB7IHJldHVybiBtX2xlZnQ7IH0K KyAgICAgICAgdm9pZCBzZXRMZWZ0KE5vZGUqIG5vZGUpIHsgbV9sZWZ0ID0gbm9kZTsgfQorCisg ICAgICAgIE5vZGUqIHJpZ2h0KCkgY29uc3QgeyByZXR1cm4gbV9yaWdodDsgfQorICAgICAgICB2 b2lkIHNldFJpZ2h0KE5vZGUqIG5vZGUpIHsgbV9yaWdodCA9IG5vZGU7IH0KKworICAgICAgICBO b2RlKiBwYXJlbnQoKSBjb25zdCB7IHJldHVybiBtX3BhcmVudDsgfQorICAgICAgICB2b2lkIHNl dFBhcmVudChOb2RlKiBub2RlKSB7IG1fcGFyZW50ID0gbm9kZTsgfQorCisgICAgcHJpdmF0ZToK KyAgICAgICAgTm9kZSogbV9sZWZ0OworICAgICAgICBOb2RlKiBtX3JpZ2h0OworICAgICAgICBO b2RlKiBtX3BhcmVudDsKKyAgICAgICAgQ29sb3IgbV9jb2xvcjsKKyAgICAgICAgVCBtX2RhdGE7 CisgICAgfTsKKworICAgIC8vIFJldHVybnMgdGhlIHJvb3Qgb2YgdGhlIHRyZWUsIHdoaWNoIGlz IG5lZWRlZCBieSBzb21lIHN1YmNsYXNzZXMuCisgICAgTm9kZSogcm9vdCgpIGNvbnN0IHsgcmV0 dXJuIG1fcm9vdDsgfQorCitwcml2YXRlOgorICAgIC8vIFRoaXMgdmlydHVhbCBtZXRob2QgaXMg dGhlIGhvb2sgdGhhdCBzdWJjbGFzc2VzIHNob3VsZCB1c2Ugd2hlbgorICAgIC8vIGF1Z21lbnRp bmcgdGhlIHJlZC1ibGFjayB0cmVlIHdpdGggYWRkaXRpb25hbCBwZXItbm9kZSBzdW1tYXJ5Cisg ICAgLy8gaW5mb3JtYXRpb24uIEZvciBleGFtcGxlLCBpbiB0aGUgY2FzZSBvZiBhbiBpbnRlcnZh bCB0cmVlLCB0aGlzCisgICAgLy8gaXMgdXNlZCB0byBjb21wdXRlIHRoZSBtYXhpbXVtIGVuZHBv aW50IG9mIHRoZSBzdWJ0cmVlIGJlbG93IHRoZQorICAgIC8vIGdpdmVuIG5vZGUgYmFzZWQgb24g dGhlIHZhbHVlcyBpbiB0aGUgbGVmdCBhbmQgcmlnaHQgY2hpbGRyZW4uIEl0CisgICAgLy8gaXMg Z3VhcmFudGVlZCB0aGF0IHRoaXMgd2lsbCBiZSBjYWxsZWQgaW4gdGhlIGNvcnJlY3Qgb3JkZXIg dG8KKyAgICAvLyBwcm9wZXJseSB1cGRhdGUgc3VjaCBzdW1tYXJ5IGluZm9ybWF0aW9uIGJhc2Vk IG9ubHkgb24gdGhlIHZhbHVlcworICAgIC8vIGluIHRoZSBsZWZ0IGFuZCByaWdodCBjaGlsZHJl bi4gVGhpcyBtZXRob2Qgc2hvdWxkIHJldHVybiB0cnVlIGlmCisgICAgLy8gdGhlIG5vZGUncyBz dW1tYXJ5IGluZm9ybWF0aW9uIGNoYW5nZWQuCisgICAgdmlydHVhbCBib29sIHVwZGF0ZU5vZGUo Tm9kZSogbm9kZSkgeyByZXR1cm4gZmFsc2U7IH0KKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAg IC8vIEdlbmVyaWMgYmluYXJ5IHNlYXJjaCB0cmVlIG9wZXJhdGlvbnMKKyAgICAvLworCisgICAg Ly8gU2VhcmNoZXMgdGhlIHRyZWUgZm9yIHRoZSBnaXZlbiBkYXR1bS4KKyAgICBOb2RlKiB0cmVl U2VhcmNoKGNvbnN0IFQmIGRhdGEpIGNvbnN0CisgICAgeworICAgICAgICBpZiAobV9uZWVkc0Z1 bGxPcmRlcmluZ0NvbXBhcmlzb25zKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hGdWxs Q29tcGFyaXNvbnMobV9yb290LCBkYXRhKTsKKworICAgICAgICByZXR1cm4gdHJlZVNlYXJjaE5v cm1hbChtX3Jvb3QsIGRhdGEpOworICAgIH0KKworICAgIC8vIFNlYXJjaGVzIHRoZSB0cmVlIHVz aW5nIHRoZSBub3JtYWwgY29tcGFyaXNvbiBvcGVyYXRpb25zLAorICAgIC8vIHN1aXRhYmxlIGZv ciBzaW1wbGUgZGF0YSB0eXBlcyBzdWNoIGFzIG51bWJlcnMuCisgICAgTm9kZSogdHJlZVNlYXJj aE5vcm1hbChOb2RlKiBjdXJyZW50LCBjb25zdCBUJiBkYXRhKSBjb25zdAorICAgIHsKKyAgICAg ICAgd2hpbGUgKGN1cnJlbnQpIHsKKyAgICAgICAgICAgIGlmIChjdXJyZW50LT5kYXRhKCkgPT0g ZGF0YSkKKyAgICAgICAgICAgICAgICByZXR1cm4gY3VycmVudDsKKyAgICAgICAgICAgIGlmIChk YXRhIDwgY3VycmVudC0+ZGF0YSgpKQorICAgICAgICAgICAgICAgIGN1cnJlbnQgPSBjdXJyZW50 LT5sZWZ0KCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgY3VycmVudCA9IGN1 cnJlbnQtPnJpZ2h0KCk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorCisg ICAgLy8gU2VhcmNoZXMgdGhlIHRyZWUgdXNpbmcgbXVsdGlwbGUgY29tcGFyaXNvbiBvcGVyYXRp b25zLCByZXF1aXJlZAorICAgIC8vIGZvciBkYXRhIHR5cGVzIHdpdGggbW9yZSBjb21wbGV4IGJl aGF2aW9yIHN1Y2ggYXMgaW50ZXJ2YWxzLgorICAgIE5vZGUqIHRyZWVTZWFyY2hGdWxsQ29tcGFy aXNvbnMoTm9kZSogY3VycmVudCwgY29uc3QgVCYgZGF0YSkgY29uc3QKKyAgICB7CisgICAgICAg IGlmICghY3VycmVudCkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICBpZiAoZGF0YSA8 IGN1cnJlbnQtPmRhdGEoKSkKKyAgICAgICAgICAgIHJldHVybiB0cmVlU2VhcmNoRnVsbENvbXBh cmlzb25zKGN1cnJlbnQtPmxlZnQoKSwgZGF0YSk7CisgICAgICAgIGlmIChjdXJyZW50LT5kYXRh KCkgPCBkYXRhKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVTZWFyY2hGdWxsQ29tcGFyaXNvbnMo Y3VycmVudC0+cmlnaHQoKSwgZGF0YSk7CisgICAgICAgIGlmIChkYXRhID09IGN1cnJlbnQtPmRh dGEoKSkKKyAgICAgICAgICAgIHJldHVybiBjdXJyZW50OworCisgICAgICAgIC8vIFdlIG1heSBu ZWVkIHRvIHRyYXZlcnNlIGJvdGggdGhlIGxlZnQgYW5kIHJpZ2h0IHN1YnRyZWVzLgorICAgICAg ICBOb2RlKiByZXN1bHQgPSB0cmVlU2VhcmNoRnVsbENvbXBhcmlzb25zKGN1cnJlbnQtPmxlZnQo KSwgZGF0YSk7CisgICAgICAgIGlmICghcmVzdWx0KQorICAgICAgICAgICAgcmVzdWx0ID0gdHJl ZVNlYXJjaEZ1bGxDb21wYXJpc29ucyhjdXJyZW50LT5yaWdodCgpLCBkYXRhKTsKKyAgICAgICAg cmV0dXJuIHJlc3VsdDsKKyAgICB9CisKKyAgICB2b2lkIHRyZWVJbnNlcnQoTm9kZSogeikKKyAg ICB7CisgICAgICAgIE5vZGUqIHkgPSAwOworICAgICAgICBOb2RlKiB4ID0gbV9yb290OworICAg ICAgICB3aGlsZSAoeCkgeworICAgICAgICAgICAgeSA9IHg7CisgICAgICAgICAgICBpZiAoei0+ ZGF0YSgpIDwgeC0+ZGF0YSgpKQorICAgICAgICAgICAgICAgIHggPSB4LT5sZWZ0KCk7CisgICAg ICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeCA9IHgtPnJpZ2h0KCk7CisgICAgICAgIH0K KyAgICAgICAgei0+c2V0UGFyZW50KHkpOworICAgICAgICBpZiAoIXkpCisgICAgICAgICAgICBt X3Jvb3QgPSB6OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh6LT5kYXRhKCkgPCB5 LT5kYXRhKCkpCisgICAgICAgICAgICAgICAgeS0+c2V0TGVmdCh6KTsKKyAgICAgICAgICAgIGVs c2UKKyAgICAgICAgICAgICAgICB5LT5zZXRSaWdodCh6KTsKKyAgICAgICAgfQorICAgIH0KKwor ICAgIC8vIEZpbmRzIHRoZSBub2RlIGZvbGxvd2luZyB0aGUgZ2l2ZW4gb25lIGluIHNlcXVlbnRp YWwgb3JkZXJpbmcgb2YKKyAgICAvLyB0aGVpciBkYXRhLCBvciBudWxsIGlmIG5vbmUgZXhpc3Rz LgorICAgIE5vZGUqIHRyZWVTdWNjZXNzb3IoTm9kZSogeCkKKyAgICB7CisgICAgICAgIGlmICh4 LT5yaWdodCgpKQorICAgICAgICAgICAgcmV0dXJuIHRyZWVNaW5pbXVtKHgtPnJpZ2h0KCkpOwor ICAgICAgICBOb2RlKiB5ID0geC0+cGFyZW50KCk7CisgICAgICAgIHdoaWxlICh5ICYmIHggPT0g eS0+cmlnaHQoKSkgeworICAgICAgICAgICAgeCA9IHk7CisgICAgICAgICAgICB5ID0geS0+cGFy ZW50KCk7CisgICAgICAgIH0KKyAgICAgICAgcmV0dXJuIHk7CisgICAgfQorCisgICAgLy8gRmlu ZHMgdGhlIG1pbmltdW0gZWxlbWVudCBpbiB0aGUgc3ViLXRyZWUgcm9vdGVkIGF0IHRoZSBnaXZl bgorICAgIC8vIG5vZGUuCisgICAgTm9kZSogdHJlZU1pbmltdW0oTm9kZSogeCkKKyAgICB7Cisg ICAgICAgIHdoaWxlICh4LT5sZWZ0KCkpCisgICAgICAgICAgICB4ID0geC0+bGVmdCgpOworICAg ICAgICByZXR1cm4geDsKKyAgICB9CisKKyAgICAvLyBIZWxwZXIgZm9yIG1haW50YWluaW5nIHRo ZSBhdWdtZW50ZWQgcmVkLWJsYWNrIHRyZWUuCisgICAgdm9pZCBwcm9wYWdhdGVVcGRhdGVzKE5v ZGUqIHN0YXJ0KQorICAgIHsKKyAgICAgICAgYm9vbCBzaG91bGRDb250aW51ZSA9IHRydWU7Cisg ICAgICAgIHdoaWxlIChzdGFydCAmJiBzaG91bGRDb250aW51ZSkgeworICAgICAgICAgICAgc2hv dWxkQ29udGludWUgPSB1cGRhdGVOb2RlKHN0YXJ0KTsKKyAgICAgICAgICAgIHN0YXJ0ID0gc3Rh cnQtPnBhcmVudCgpOworICAgICAgICB9CisgICAgfQorCisgICAgLy8tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisg ICAgLy8gUmVkLUJsYWNrIHRyZWUgb3BlcmF0aW9ucworICAgIC8vCisKKyAgICAvLyBMZWZ0LXJv dGF0ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHguCisgICAgLy8gUmV0dXJucyB0aGUgbmV3IHJv b3Qgb2YgdGhlIHN1YnRyZWUgKHgncyByaWdodCBjaGlsZCkuCisgICAgTm9kZSogbGVmdFJvdGF0 ZShOb2RlKiB4KQorICAgIHsKKyAgICAgICAgLy8gU2V0IHkuCisgICAgICAgIE5vZGUqIHkgPSB4 LT5yaWdodCgpOworCisgICAgICAgIC8vIFR1cm4geSdzIGxlZnQgc3VidHJlZSBpbnRvIHgncyBy aWdodCBzdWJ0cmVlLgorICAgICAgICB4LT5zZXRSaWdodCh5LT5sZWZ0KCkpOworICAgICAgICBp ZiAoeS0+bGVmdCgpKQorICAgICAgICAgICAgeS0+bGVmdCgpLT5zZXRQYXJlbnQoeCk7CisKKyAg ICAgICAgLy8gTGluayB4J3MgcGFyZW50IHRvIHkuCisgICAgICAgIHktPnNldFBhcmVudCh4LT5w YXJlbnQoKSk7CisgICAgICAgIGlmICgheC0+cGFyZW50KCkpCisgICAgICAgICAgICBtX3Jvb3Qg PSB5OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlmICh4ID09IHgtPnBhcmVudCgpLT5s ZWZ0KCkpCisgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldExlZnQoeSk7CisgICAgICAg ICAgICBlbHNlCisgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldFJpZ2h0KHkpOworICAg ICAgICB9CisKKyAgICAgICAgLy8gUHV0IHggb24geSdzIGxlZnQuCisgICAgICAgIHktPnNldExl ZnQoeCk7CisgICAgICAgIHgtPnNldFBhcmVudCh5KTsKKworICAgICAgICAvLyBVcGRhdGUgbm9k ZXMgbG93ZXN0IHRvIGhpZ2hlc3QuCisgICAgICAgIHVwZGF0ZU5vZGUoeCk7CisgICAgICAgIHVw ZGF0ZU5vZGUoeSk7CisgICAgICAgIHJldHVybiB5OworICAgIH0KKworICAgIC8vIFJpZ2h0LXJv dGF0ZXMgdGhlIHN1YnRyZWUgcm9vdGVkIGF0IHkuCisgICAgLy8gUmV0dXJucyB0aGUgbmV3IHJv b3Qgb2YgdGhlIHN1YnRyZWUgKHkncyBsZWZ0IGNoaWxkKS4KKyAgICBOb2RlKiByaWdodFJvdGF0 ZShOb2RlKiB5KQorICAgIHsKKyAgICAgICAgLy8gU2V0IHguCisgICAgICAgIE5vZGUqIHggPSB5 LT5sZWZ0KCk7CisKKyAgICAgICAgLy8gVHVybiB4J3MgcmlnaHQgc3VidHJlZSBpbnRvIHkncyBs ZWZ0IHN1YnRyZWUuCisgICAgICAgIHktPnNldExlZnQoeC0+cmlnaHQoKSk7CisgICAgICAgIGlm ICh4LT5yaWdodCgpKQorICAgICAgICAgICAgeC0+cmlnaHQoKS0+c2V0UGFyZW50KHkpOworCisg ICAgICAgIC8vIExpbmsgeSdzIHBhcmVudCB0byB4LgorICAgICAgICB4LT5zZXRQYXJlbnQoeS0+ cGFyZW50KCkpOworICAgICAgICBpZiAoIXktPnBhcmVudCgpKQorICAgICAgICAgICAgbV9yb290 ID0geDsKKyAgICAgICAgZWxzZSB7CisgICAgICAgICAgICBpZiAoeSA9PSB5LT5wYXJlbnQoKS0+ bGVmdCgpKQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRMZWZ0KHgpOworICAgICAg ICAgICAgZWxzZQorICAgICAgICAgICAgICAgIHktPnBhcmVudCgpLT5zZXRSaWdodCh4KTsKKyAg ICAgICAgfQorCisgICAgICAgIC8vIFB1dCB5IG9uIHgncyByaWdodC4KKyAgICAgICAgeC0+c2V0 UmlnaHQoeSk7CisgICAgICAgIHktPnNldFBhcmVudCh4KTsKKworICAgICAgICAvLyBVcGRhdGUg bm9kZXMgbG93ZXN0IHRvIGhpZ2hlc3QuCisgICAgICAgIHVwZGF0ZU5vZGUoeSk7CisgICAgICAg IHVwZGF0ZU5vZGUoeCk7CisgICAgICAgIHJldHVybiB4OworICAgIH0KKworICAgIC8vIEluc2Vy dHMgdGhlIGdpdmVuIG5vZGUgaW50byB0aGUgdHJlZS4KKyAgICB2b2lkIGluc2VydE5vZGUoTm9k ZSogeCkKKyAgICB7CisgICAgICAgIHRyZWVJbnNlcnQoeCk7CisgICAgICAgIHgtPnNldENvbG9y KFJlZCk7CisgICAgICAgIHVwZGF0ZU5vZGUoeCk7CisKKyAgICAgICAgbG9nSWZWZXJib3NlKCIg IFBPRFJlZEJsYWNrVHJlZTo6SW5zZXJ0Tm9kZSIpOworCisgICAgICAgIC8vIFRoZSBub2RlIGZy b20gd2hpY2ggdG8gc3RhcnQgcHJvcGFnYXRpbmcgdXBkYXRlcyB1cHdhcmRzLgorICAgICAgICBO b2RlKiB1cGRhdGVTdGFydCA9IHgtPnBhcmVudCgpOworCisgICAgICAgIHdoaWxlICh4ICE9IG1f cm9vdCAmJiB4LT5wYXJlbnQoKS0+Y29sb3IoKSA9PSBSZWQpIHsKKyAgICAgICAgICAgIGlmICh4 LT5wYXJlbnQoKSA9PSB4LT5wYXJlbnQoKS0+cGFyZW50KCktPmxlZnQoKSkgeworICAgICAgICAg ICAgICAgIE5vZGUqIHkgPSB4LT5wYXJlbnQoKS0+cGFyZW50KCktPnJpZ2h0KCk7CisgICAgICAg ICAgICAgICAgaWYgKHkgJiYgeS0+Y29sb3IoKSA9PSBSZWQpIHsKKyAgICAgICAgICAgICAgICAg ICAgLy8gQ2FzZSAxCisgICAgICAgICAgICAgICAgICAgIGxvZ0lmVmVyYm9zZSgiICBDYXNlIDEv MSIpOworICAgICAgICAgICAgICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3IoQmxhY2spOwor ICAgICAgICAgICAgICAgICAgICB5LT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAg ICAgIHgtPnBhcmVudCgpLT5wYXJlbnQoKS0+c2V0Q29sb3IoUmVkKTsKKyAgICAgICAgICAgICAg ICAgICAgdXBkYXRlTm9kZSh4LT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHggPSB4 LT5wYXJlbnQoKS0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZU5vZGUoeCk7 CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisgICAgICAg ICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgaWYgKHggPT0geC0+cGFyZW50 KCktPnJpZ2h0KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxvZ0lmVmVyYm9zZSgiICBD YXNlIDEvMiIpOworICAgICAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAyCisgICAgICAgICAg ICAgICAgICAgICAgICB4ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgICAgICAgICBs ZWZ0Um90YXRlKHgpOworICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAg IC8vIENhc2UgMworICAgICAgICAgICAgICAgICAgICBsb2dJZlZlcmJvc2UoIiAgQ2FzZSAxLzMi KTsKKyAgICAgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnNldENvbG9yKEJsYWNrKTsKKyAg ICAgICAgICAgICAgICAgICAgeC0+cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihSZWQpOwor ICAgICAgICAgICAgICAgICAgICBOb2RlKiBuZXdTdWJUcmVlUm9vdCA9IHJpZ2h0Um90YXRlKHgt PnBhcmVudCgpLT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZVN0YXJ0ID0g bmV3U3ViVHJlZVJvb3QtPnBhcmVudCgpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAg IH0gZWxzZSB7CisgICAgICAgICAgICAgICAgLy8gU2FtZSBhcyAidGhlbiIgY2xhdXNlIHdpdGgg InJpZ2h0IiBhbmQgImxlZnQiIGV4Y2hhbmdlZC4KKyAgICAgICAgICAgICAgICBOb2RlKiB5ID0g eC0+cGFyZW50KCktPnBhcmVudCgpLT5sZWZ0KCk7CisgICAgICAgICAgICAgICAgaWYgKHkgJiYg eS0+Y29sb3IoKSA9PSBSZWQpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAxCisgICAg ICAgICAgICAgICAgICAgIGxvZ0lmVmVyYm9zZSgiICBDYXNlIDIvMSIpOworICAgICAgICAgICAg ICAgICAgICB4LT5wYXJlbnQoKS0+c2V0Q29sb3IoQmxhY2spOworICAgICAgICAgICAgICAgICAg ICB5LT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAgICAgICAgICAgIHgtPnBhcmVudCgpLT5w YXJlbnQoKS0+c2V0Q29sb3IoUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlTm9kZSh4 LT5wYXJlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIHggPSB4LT5wYXJlbnQoKS0+cGFyZW50 KCk7CisgICAgICAgICAgICAgICAgICAgIHVwZGF0ZU5vZGUoeCk7CisgICAgICAgICAgICAgICAg ICAgIHVwZGF0ZVN0YXJ0ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAgICAgfSBlbHNlIHsK KyAgICAgICAgICAgICAgICAgICAgaWYgKHggPT0geC0+cGFyZW50KCktPmxlZnQoKSkgeworICAg ICAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAyCisgICAgICAgICAgICAgICAgICAgICAgICBs b2dJZlZlcmJvc2UoIiAgQ2FzZSAyLzIiKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHggPSB4 LT5wYXJlbnQoKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJpZ2h0Um90YXRlKHgpOworICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMworICAgICAg ICAgICAgICAgICAgICBsb2dJZlZlcmJvc2UoIiAgQ2FzZSAyLzMiKTsKKyAgICAgICAgICAgICAg ICAgICAgeC0+cGFyZW50KCktPnNldENvbG9yKEJsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAg eC0+cGFyZW50KCktPnBhcmVudCgpLT5zZXRDb2xvcihSZWQpOworICAgICAgICAgICAgICAgICAg ICBOb2RlKiBuZXdTdWJUcmVlUm9vdCA9IGxlZnRSb3RhdGUoeC0+cGFyZW50KCktPnBhcmVudCgp KTsKKyAgICAgICAgICAgICAgICAgICAgdXBkYXRlU3RhcnQgPSBuZXdTdWJUcmVlUm9vdC0+cGFy ZW50KCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAg ICAgICAgcHJvcGFnYXRlVXBkYXRlcyh1cGRhdGVTdGFydCk7CisKKyAgICAgICAgbV9yb290LT5z ZXRDb2xvcihCbGFjayk7CisgICAgfQorCisgICAgLy8gUmVzdG9yZXMgdGhlIHJlZC1ibGFjayBw cm9wZXJ0eSB0byB0aGUgdHJlZSBhZnRlciBzcGxpY2luZyBvdXQKKyAgICAvLyBhIG5vZGUuIE5v dGUgdGhhdCB4IG1heSBiZSBudWxsLCB3aGljaCBpcyB3aHkgeFBhcmVudCBtdXN0IGJlCisgICAg Ly8gc3VwcGxpZWQuCisgICAgdm9pZCBkZWxldGVGaXh1cChOb2RlKiB4LCBOb2RlKiB4UGFyZW50 KQorICAgIHsKKyAgICAgICAgd2hpbGUgKHggIT0gbV9yb290ICYmICgheCB8fCB4LT5jb2xvcigp ID09IEJsYWNrKSkgeworICAgICAgICAgICAgaWYgKHggPT0geFBhcmVudC0+bGVmdCgpKSB7Cisg ICAgICAgICAgICAgICAgLy8gTm90ZTogdGhlIHRleHQgcG9pbnRzIG91dCB0aGF0IHcgY2FuIG5v dCBiZSBudWxsLgorICAgICAgICAgICAgICAgIC8vIFRoZSByZWFzb24gaXMgbm90IG9idmlvdXMg ZnJvbSBzaW1wbHkgbG9va2luZyBhdAorICAgICAgICAgICAgICAgIC8vIHRoZSBjb2RlOyBpdCBj b21lcyBhYm91dCBmcm9tIHRoZSBwcm9wZXJ0aWVzIG9mIHRoZQorICAgICAgICAgICAgICAgIC8v IHJlZC1ibGFjayB0cmVlLgorICAgICAgICAgICAgICAgIE5vZGUqIHcgPSB4UGFyZW50LT5yaWdo dCgpOworICAgICAgICAgICAgICAgIEFTU0VSVCh3KTsgLy8geCdzIHNpYmxpbmcgc2hvdWxkIG5v dCBiZSBudWxsLgorICAgICAgICAgICAgICAgIGlmICh3LT5jb2xvcigpID09IFJlZCkgeworICAg ICAgICAgICAgICAgICAgICAvLyBDYXNlIDEKKyAgICAgICAgICAgICAgICAgICAgdy0+c2V0Q29s b3IoQmxhY2spOworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihSZWQpOwor ICAgICAgICAgICAgICAgICAgICBsZWZ0Um90YXRlKHhQYXJlbnQpOworICAgICAgICAgICAgICAg ICAgICB3ID0geFBhcmVudC0+cmlnaHQoKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgICAgaWYgKCghdy0+bGVmdCgpIHx8IHctPmxlZnQoKS0+Y29sb3IoKSA9PSBCbGFjaykKKyAg ICAgICAgICAgICAgICAgICAgJiYgKCF3LT5yaWdodCgpIHx8IHctPnJpZ2h0KCktPmNvbG9yKCkg PT0gQmxhY2spKSB7CisgICAgICAgICAgICAgICAgICAgIC8vIENhc2UgMgorICAgICAgICAgICAg ICAgICAgICB3LT5zZXRDb2xvcihSZWQpOworICAgICAgICAgICAgICAgICAgICB4ID0geFBhcmVu dDsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudCA9IHgtPnBhcmVudCgpOworICAgICAgICAg ICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgICAgIGlmICghdy0+cmlnaHQoKSB8fCB3 LT5yaWdodCgpLT5jb2xvcigpID09IEJsYWNrKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAv LyBDYXNlIDMKKyAgICAgICAgICAgICAgICAgICAgICAgIHctPmxlZnQoKS0+c2V0Q29sb3IoQmxh Y2spOworICAgICAgICAgICAgICAgICAgICAgICAgdy0+c2V0Q29sb3IoUmVkKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIHJpZ2h0Um90YXRlKHcpOworICAgICAgICAgICAgICAgICAgICAgICAg dyA9IHhQYXJlbnQtPnJpZ2h0KCk7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAg ICAgICAgICAgLy8gQ2FzZSA0CisgICAgICAgICAgICAgICAgICAgIHctPnNldENvbG9yKHhQYXJl bnQtPmNvbG9yKCkpOworICAgICAgICAgICAgICAgICAgICB4UGFyZW50LT5zZXRDb2xvcihCbGFj ayk7CisgICAgICAgICAgICAgICAgICAgIGlmICh3LT5yaWdodCgpKQorICAgICAgICAgICAgICAg ICAgICAgICAgdy0+cmlnaHQoKS0+c2V0Q29sb3IoQmxhY2spOworICAgICAgICAgICAgICAgICAg ICBsZWZ0Um90YXRlKHhQYXJlbnQpOworICAgICAgICAgICAgICAgICAgICB4ID0gbV9yb290Owor ICAgICAgICAgICAgICAgICAgICB4UGFyZW50ID0geC0+cGFyZW50KCk7CisgICAgICAgICAgICAg ICAgfQorICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAvLyBTYW1lIGFzICJ0 aGVuIiBjbGF1c2Ugd2l0aCAicmlnaHQiIGFuZCAibGVmdCIKKyAgICAgICAgICAgICAgICAvLyBl eGNoYW5nZWQuCisKKyAgICAgICAgICAgICAgICAvLyBOb3RlOiB0aGUgdGV4dCBwb2ludHMgb3V0 IHRoYXQgdyBjYW4gbm90IGJlIG51bGwuCisgICAgICAgICAgICAgICAgLy8gVGhlIHJlYXNvbiBp cyBub3Qgb2J2aW91cyBmcm9tIHNpbXBseSBsb29raW5nIGF0CisgICAgICAgICAgICAgICAgLy8g dGhlIGNvZGU7IGl0IGNvbWVzIGFib3V0IGZyb20gdGhlIHByb3BlcnRpZXMgb2YgdGhlCisgICAg ICAgICAgICAgICAgLy8gcmVkLWJsYWNrIHRyZWUuCisgICAgICAgICAgICAgICAgTm9kZSogdyA9 IHhQYXJlbnQtPmxlZnQoKTsKKyAgICAgICAgICAgICAgICBBU1NFUlQodyk7IC8vIHgncyBzaWJs aW5nIHNob3VsZCBub3QgYmUgbnVsbC4KKyAgICAgICAgICAgICAgICBpZiAody0+Y29sb3IoKSA9 PSBSZWQpIHsKKyAgICAgICAgICAgICAgICAgICAgLy8gQ2FzZSAxCisgICAgICAgICAgICAgICAg ICAgIHctPnNldENvbG9yKEJsYWNrKTsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0 Q29sb3IoUmVkKTsKKyAgICAgICAgICAgICAgICAgICAgcmlnaHRSb3RhdGUoeFBhcmVudCk7Cisg ICAgICAgICAgICAgICAgICAgIHcgPSB4UGFyZW50LT5sZWZ0KCk7CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgIGlmICgoIXctPnJpZ2h0KCkgfHwgdy0+cmlnaHQoKS0+Y29sb3Io KSA9PSBCbGFjaykKKyAgICAgICAgICAgICAgICAgICAgJiYgKCF3LT5sZWZ0KCkgfHwgdy0+bGVm dCgpLT5jb2xvcigpID09IEJsYWNrKSkgeworICAgICAgICAgICAgICAgICAgICAvLyBDYXNlIDIK KyAgICAgICAgICAgICAgICAgICAgdy0+c2V0Q29sb3IoUmVkKTsKKyAgICAgICAgICAgICAgICAg ICAgeCA9IHhQYXJlbnQ7CisgICAgICAgICAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQo KTsKKyAgICAgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAgICAgICBpZiAoIXct PmxlZnQoKSB8fCB3LT5sZWZ0KCktPmNvbG9yKCkgPT0gQmxhY2spIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgIC8vIENhc2UgMworICAgICAgICAgICAgICAgICAgICAgICAgdy0+cmlnaHQoKS0+ c2V0Q29sb3IoQmxhY2spOworICAgICAgICAgICAgICAgICAgICAgICAgdy0+c2V0Q29sb3IoUmVk KTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGxlZnRSb3RhdGUodyk7CisgICAgICAgICAgICAg ICAgICAgICAgICB3ID0geFBhcmVudC0+bGVmdCgpOworICAgICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgICAgICAgIC8vIENhc2UgNAorICAgICAgICAgICAgICAgICAgICB3LT5zZXRD b2xvcih4UGFyZW50LT5jb2xvcigpKTsKKyAgICAgICAgICAgICAgICAgICAgeFBhcmVudC0+c2V0 Q29sb3IoQmxhY2spOworICAgICAgICAgICAgICAgICAgICBpZiAody0+bGVmdCgpKQorICAgICAg ICAgICAgICAgICAgICAgICAgdy0+bGVmdCgpLT5zZXRDb2xvcihCbGFjayk7CisgICAgICAgICAg ICAgICAgICAgIHJpZ2h0Um90YXRlKHhQYXJlbnQpOworICAgICAgICAgICAgICAgICAgICB4ID0g bV9yb290OworICAgICAgICAgICAgICAgICAgICB4UGFyZW50ID0geC0+cGFyZW50KCk7CisgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgICAgIGlmICh4KQor ICAgICAgICAgICAgeC0+c2V0Q29sb3IoQmxhY2spOworICAgIH0KKworICAgIC8vIERlbGV0ZXMg dGhlIGdpdmVuIG5vZGUgZnJvbSB0aGUgdHJlZS4gTm90ZSB0aGF0IHRoaXMKKyAgICAvLyBwYXJ0 aWN1bGFyIG5vZGUgbWF5IG5vdCBhY3R1YWxseSBiZSByZW1vdmVkIGZyb20gdGhlIHRyZWU7Cisg ICAgLy8gaW5zdGVhZCwgYW5vdGhlciBub2RlIG1pZ2h0IGJlIHJlbW92ZWQgYW5kIGl0cyBjb250 ZW50cworICAgIC8vIGNvcGllZCBpbnRvIHouCisgICAgdm9pZCBkZWxldGVOb2RlKE5vZGUqIHop CisgICAgeworICAgICAgICAvLyBZIGlzIHRoZSBub2RlIHRvIGJlIHVubGlua2VkIGZyb20gdGhl IHRyZWUuCisgICAgICAgIE5vZGUqIHk7CisgICAgICAgIGlmICghei0+bGVmdCgpIHx8ICF6LT5y aWdodCgpKQorICAgICAgICAgICAgeSA9IHo7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHkg PSB0cmVlU3VjY2Vzc29yKHopOworCisgICAgICAgIC8vIFkgaXMgZ3VhcmFudGVlZCB0byBiZSBu b24tbnVsbCBhdCB0aGlzIHBvaW50LgorICAgICAgICBOb2RlKiB4OworICAgICAgICBpZiAoeS0+ bGVmdCgpKQorICAgICAgICAgICAgeCA9IHktPmxlZnQoKTsKKyAgICAgICAgZWxzZQorICAgICAg ICAgICAgeCA9IHktPnJpZ2h0KCk7CisKKyAgICAgICAgLy8gWCBpcyB0aGUgY2hpbGQgb2YgeSB3 aGljaCBtaWdodCBwb3RlbnRpYWxseSByZXBsYWNlIHkgaW4KKyAgICAgICAgLy8gdGhlIHRyZWUu IFggbWlnaHQgYmUgbnVsbCBhdCB0aGlzIHBvaW50LgorICAgICAgICBOb2RlKiB4UGFyZW50Owor ICAgICAgICBpZiAoeCkgeworICAgICAgICAgICAgeC0+c2V0UGFyZW50KHktPnBhcmVudCgpKTsK KyAgICAgICAgICAgIHhQYXJlbnQgPSB4LT5wYXJlbnQoKTsKKyAgICAgICAgfSBlbHNlCisgICAg ICAgICAgICB4UGFyZW50ID0geS0+cGFyZW50KCk7CisgICAgICAgIGlmICgheS0+cGFyZW50KCkp CisgICAgICAgICAgICBtX3Jvb3QgPSB4OworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIGlm ICh5ID09IHktPnBhcmVudCgpLT5sZWZ0KCkpCisgICAgICAgICAgICAgICAgeS0+cGFyZW50KCkt PnNldExlZnQoeCk7CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgeS0+cGFyZW50 KCktPnNldFJpZ2h0KHgpOworICAgICAgICB9CisgICAgICAgIGlmICh5ICE9IHopIHsKKyAgICAg ICAgICAgIHotPmNvcHlGcm9tKHkpOworICAgICAgICAgICAgLy8gVGhpcyBub2RlIGhhcyBjaGFu Z2VkIGxvY2F0aW9uIGluIHRoZSB0cmVlIGFuZCBtdXN0IGJlIHVwZGF0ZWQuCisgICAgICAgICAg ICB1cGRhdGVOb2RlKHopOworICAgICAgICAgICAgLy8gVGhlIHBhcmVudCBhbmQgaXRzIHBhcmVu dHMgbWF5IG5vdyBiZSBvdXQgb2YgZGF0ZS4KKyAgICAgICAgICAgIHByb3BhZ2F0ZVVwZGF0ZXMo ei0+cGFyZW50KCkpOworICAgICAgICB9CisKKyAgICAgICAgLy8gSWYgd2UgaGF2ZW4ndCBhbHJl YWR5IHVwZGF0ZWQgc3RhcnRpbmcgZnJvbSB4UGFyZW50LCBkbyBzbyBub3cuCisgICAgICAgIGlm ICh4UGFyZW50ICYmIHhQYXJlbnQgIT0geSAmJiB4UGFyZW50ICE9IHopCisgICAgICAgICAgICBw cm9wYWdhdGVVcGRhdGVzKHhQYXJlbnQpOworICAgICAgICBpZiAoeS0+Y29sb3IoKSA9PSBCbGFj aykKKyAgICAgICAgICAgIGRlbGV0ZUZpeHVwKHgsIHhQYXJlbnQpOworICAgIH0KKworICAgIC8v IFZpc2l0cyB0aGUgc3VidHJlZSByb290ZWQgYXQgdGhlIGdpdmVuIG5vZGUgaW4gb3JkZXIuCisg ICAgdm9pZCB2aXNpdElub3JkZXJJbXBsKE5vZGUqIG5vZGUsIFZpc2l0b3IqIHZpc2l0b3IpIGNv bnN0CisgICAgeworICAgICAgICBpZiAobm9kZS0+bGVmdCgpKQorICAgICAgICAgICAgdmlzaXRJ bm9yZGVySW1wbChub2RlLT5sZWZ0KCksIHZpc2l0b3IpOworICAgICAgICB2aXNpdG9yLT52aXNp dChub2RlLT5kYXRhKCkpOworICAgICAgICBpZiAobm9kZS0+cmlnaHQoKSkKKyAgICAgICAgICAg IHZpc2l0SW5vcmRlckltcGwobm9kZS0+cmlnaHQoKSwgdmlzaXRvcik7CisgICAgfQorCisgICAg Ly8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisgICAgLy8gSGVscGVyIGNsYXNzIGZvciBzaXplKCkKKworICAgIC8v IEEgVmlzaXRvciB3aGljaCBzaW1wbHkgY291bnRzIHRoZSBudW1iZXIgb2YgdmlzaXRlZCBlbGVt ZW50cy4KKyAgICBjbGFzcyBDb3VudGVyIDogcHVibGljIFZpc2l0b3IsIHB1YmxpYyBOb25jb3B5 YWJsZSB7CisgICAgcHVibGljOgorICAgICAgICBDb3VudGVyKCkKKyAgICAgICAgICAgIDogbV9j b3VudCgwKSB7IH0KKworICAgICAgICB2aXJ0dWFsIHZvaWQgdmlzaXQoY29uc3QgVCYgZGF0YSkg eyArK21fY291bnQ7IH0KKyAgICAgICAgaW50IGNvdW50KCkgY29uc3QgeyByZXR1cm4gbV9jb3Vu dDsgfQorCisgICAgcHJpdmF0ZToKKyAgICAgICAgaW50IG1fY291bnQ7CisgICAgfTsKKworICAg IC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIFZlcmlmaWNhdGlvbiBhbmQgZGVidWdnaW5nIHJvdXRp bmVzCisgICAgLy8KKworICAgIC8vIFJldHVybnMgaW4gdGhlICJibGFja0NvdW50IiBwYXJhbWV0 ZXIgdGhlIG51bWJlciBvZiBibGFjaworICAgIC8vIGNoaWxkcmVuIGFsb25nIGFsbCBwYXRocyB0 byBhbGwgbGVhdmVzIG9mIHRoZSBnaXZlbiBub2RlLgorICAgIGJvb2wgY2hlY2tJbnZhcmlhbnRz RnJvbU5vZGUoTm9kZSogbm9kZSwgaW50KiBibGFja0NvdW50KSBjb25zdAorICAgIHsKKyAgICAg ICAgLy8gQmFzZSBjYXNlIGlzIGEgbGVhZiBub2RlLgorICAgICAgICBpZiAoIW5vZGUpIHsKKyAg ICAgICAgICAgICpibGFja0NvdW50ID0gMTsKKyAgICAgICAgICAgIHJldHVybiB0cnVlOworICAg ICAgICB9CisKKyAgICAgICAgLy8gRWFjaCBub2RlIGlzIGVpdGhlciByZWQgb3IgYmxhY2suCisg ICAgICAgIGlmICghKG5vZGUtPmNvbG9yKCkgPT0gUmVkIHx8IG5vZGUtPmNvbG9yKCkgPT0gQmxh Y2spKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgICAgIC8vIEV2ZXJ5IGxlYWYg KG9yIG51bGwpIGlzIGJsYWNrLgorCisgICAgICAgIGlmIChub2RlLT5jb2xvcigpID09IFJlZCkg eworICAgICAgICAgICAgLy8gQm90aCBvZiBpdHMgY2hpbGRyZW4gYXJlIGJsYWNrLgorICAgICAg ICAgICAgaWYgKCEoKCFub2RlLT5sZWZ0KCkgfHwgbm9kZS0+bGVmdCgpLT5jb2xvcigpID09IEJs YWNrKSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgICAgICAgICAgaWYgKCEo KCFub2RlLT5yaWdodCgpIHx8IG5vZGUtPnJpZ2h0KCktPmNvbG9yKCkgPT0gQmxhY2spKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIH0KKworICAgICAgICAvLyBFdmVy eSBzaW1wbGUgcGF0aCB0byBhIGxlYWYgbm9kZSBjb250YWlucyB0aGUgc2FtZSBudW1iZXIgb2YK KyAgICAgICAgLy8gYmxhY2sgbm9kZXMuCisgICAgICAgIGludCBsZWZ0Q291bnQgPSAwLCByaWdo dENvdW50ID0gMDsKKyAgICAgICAgYm9vbCBsZWZ0VmFsaWQgPSBjaGVja0ludmFyaWFudHNGcm9t Tm9kZShub2RlLT5sZWZ0KCksICZsZWZ0Q291bnQpOworICAgICAgICBib29sIHJpZ2h0VmFsaWQg PSBjaGVja0ludmFyaWFudHNGcm9tTm9kZShub2RlLT5yaWdodCgpLCAmcmlnaHRDb3VudCk7Cisg ICAgICAgIGlmICghbGVmdFZhbGlkIHx8ICFyaWdodFZhbGlkKQorICAgICAgICAgICAgcmV0dXJu IGZhbHNlOworICAgICAgICAqYmxhY2tDb3VudCA9IGxlZnRDb3VudCArIChub2RlLT5jb2xvcigp ID09IEJsYWNrID8gMSA6IDApOworICAgICAgICByZXR1cm4gbGVmdENvdW50ID09IHJpZ2h0Q291 bnQ7CisgICAgfQorCisjaWZkZWYgTkRFQlVHCisgICAgdm9pZCBsb2dJZlZlcmJvc2UoY29uc3Qg Y2hhciogb3V0cHV0KSBjb25zdCB7IH0KKyNlbHNlCisgICAgdm9pZCBsb2dJZlZlcmJvc2UoY29u c3QgY2hhciogb3V0cHV0KSBjb25zdAorICAgIHsKKyAgICAgICAgaWYgKG1fdmVyYm9zZURlYnVn Z2luZykKKyAgICAgICAgICAgIExPR19FUlJPUigiJXMiLCBvdXRwdXQpOworICAgIH0KKyNlbmRp ZgorCisjaWZuZGVmIE5ERUJVRworICAgIC8vIER1bXBzIHRoZSBzdWJ0cmVlIHJvb3RlZCBhdCB0 aGUgZ2l2ZW4gbm9kZS4KKyAgICB2b2lkIGR1bXBGcm9tTm9kZShOb2RlKiBub2RlLCBpbnQgaW5k ZW50YXRpb24pIGNvbnN0CisgICAgeworICAgICAgICBTdHJpbmdCdWlsZGVyIGJ1aWxkZXI7Cisg ICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgaW5kZW50YXRpb247IGkrKykKKyAgICAgICAgICAg IGJ1aWxkZXIuYXBwZW5kKCIgIik7CisgICAgICAgIGJ1aWxkZXIuYXBwZW5kKCItIik7CisgICAg ICAgIGlmIChub2RlKSB7CisgICAgICAgICAgICBidWlsZGVyLmFwcGVuZCgiICIpOworICAgICAg ICAgICAgYnVpbGRlci5hcHBlbmQodmFsdWVUb1N0cmluZyhub2RlLT5kYXRhKCkpKTsKKyAgICAg ICAgICAgIGJ1aWxkZXIuYXBwZW5kKChub2RlLT5jb2xvcigpID09IEJsYWNrKSA/ICIgKGJsYWNr KSIgOiAiIChyZWQpIik7CisgICAgICAgIH0KKyAgICAgICAgTE9HX0VSUk9SKCIlcyIsIGJ1aWxk ZXIudG9TdHJpbmcoKS5hc2NpaSgpLmRhdGEoKSk7CisgICAgICAgIGlmIChub2RlKSB7CisgICAg ICAgICAgICBkdW1wRnJvbU5vZGUobm9kZS0+bGVmdCgpLCBpbmRlbnRhdGlvbiArIDIpOworICAg ICAgICAgICAgZHVtcEZyb21Ob2RlKG5vZGUtPnJpZ2h0KCksIGluZGVudGF0aW9uICsgMik7Cisg ICAgICAgIH0KKyAgICB9CisjZW5kaWYKKworICAgIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgIC8vIERh dGEgbWVtYmVycworCisgICAgUmVmUHRyPFBPREFyZW5hPiBtX2FyZW5hOworICAgIE5vZGUqIG1f cm9vdDsKKyAgICBib29sIG1fbmVlZHNGdWxsT3JkZXJpbmdDb21wYXJpc29uczsKKyNpZm5kZWYg TkRFQlVHCisgICAgYm9vbCBtX3ZlcmJvc2VEZWJ1Z2dpbmc7CisjZW5kaWYKK307CisKK30gLy8g bmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIFBPRFJlZEJsYWNrVHJlZV9oCg==