24760 2009-03-23 09:18:33 -0700 Rename Position::container to Position::m_anchorNode and fix callsites 2009-03-23 19:25:56 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) Mac OS X 10.5 RESOLVED FIXED P2 Normal --- 1 eric eric darin jparent justin.garcia ojan oldest_to_newest 114785 0 eric 2009-03-23 09:18:33 -0700 Clean up Position.h I would like to make Position objects aware of the meaning of their container and m_offset values. This will require removing direct construction of Positions objects. Eventually positions will have the ability to specify [node, after], [node, before] in addition to [node, childOffset]. Positions already have this ability, but only for content which editing "ignores" (editingIgnoresContent(node) returns true). When editingIgnoresContent returns true, then Positions [node, 0] and [node, 1] are interpreted as [node, before] and [node, after] by some parts of the editing code, but not all. you don't actually know what type of position you're dealing with up-front, only in certain places will [node, 0 (before)] be converted into [node->parentNode(), node->nodeIndex()]. I would like to fix positions to hide the details of m_offset and container (which is not always really the "container" for the position, and add new accessors to get that kind of information in a consistent way for all positions. Anyway, the first steps for this are to clean up Position objects to not make m_offset and container public. I'll attach patches to do this. 114791 1 28855 eric 2009-03-23 09:49:29 -0700 Created attachment 28855 Remove Position::clear() and make VisibleSelection.h not include VisiblePosition.h WebCore/ChangeLog | 57 ++++++++++++++++++++ WebCore/dom/Position.cpp | 6 +- WebCore/dom/Position.h | 12 ++-- WebCore/dom/RangeBoundaryPoint.h | 2 +- WebCore/editing/ApplyStyleCommand.cpp | 1 + WebCore/editing/CompositeEditCommand.cpp | 1 + WebCore/editing/DeleteButtonController.cpp | 1 + WebCore/editing/DeleteSelectionCommand.cpp | 15 +++--- WebCore/editing/FormatBlockCommand.cpp | 1 + WebCore/editing/IndentOutdentCommand.cpp | 1 + WebCore/editing/InsertListCommand.cpp | 1 + .../editing/InsertParagraphSeparatorCommand.cpp | 1 + WebCore/editing/InsertTextCommand.cpp | 1 + WebCore/editing/ReplaceSelectionCommand.cpp | 1 + WebCore/editing/SelectionController.cpp | 1 + WebCore/editing/TextIterator.cpp | 1 - WebCore/editing/VisiblePosition.h | 9 ++-- WebCore/editing/VisibleSelection.cpp | 10 ++++ WebCore/editing/VisibleSelection.h | 8 ++-- WebCore/editing/markup.cpp | 1 + WebCore/page/AccessibilityObject.h | 4 ++ WebCore/page/AccessibilityRenderObject.h | 1 + WebCore/page/DOMSelection.cpp | 1 + WebCore/page/DragController.cpp | 1 + WebCore/page/Frame.cpp | 9 ++-- WebCore/page/mac/FrameMac.mm | 1 + WebCore/rendering/RenderBlock.cpp | 1 + WebCore/rendering/RenderBox.cpp | 1 + WebCore/rendering/RenderTextControl.cpp | 1 + WebCore/rendering/TextControlInnerElements.cpp | 1 + WebCore/svg/SVGTextContentElement.cpp | 1 + 31 files changed, 122 insertions(+), 31 deletions(-) 114792 2 28856 eric 2009-03-23 09:49:32 -0700 Created attachment 28856 Rename Position::container to m_container and make it private WebCore/ChangeLog | 36 ++++++++++++++++++++++++++++++++++++ WebCore/dom/Position.cpp | 4 ++-- WebCore/dom/Position.h | 22 ++++++++++++++-------- WebCore/dom/Range.cpp | 4 ++-- WebCore/dom/RangeBoundaryPoint.h | 24 ++++++++++-------------- 5 files changed, 64 insertions(+), 26 deletions(-) 114793 3 28855 darin 2009-03-23 09:55:00 -0700 Comment on attachment 28855 Remove Position::clear() and make VisibleSelection.h not include VisiblePosition.h > + > + // Returns node() or the closest element accestor > + Element* element() const; > Element* documentElement() const; The paragraphing here makes it look like this comment is for both element() and documentElement(). The comment also seems to be unclear about what this will return when node() is not an element, but there is no closest element ancestor. The answer is "0", but the comment makes it sound like we'd return node(), which isn't possible since it's not an Element*. Why are you removing clear()? I like clear(), and all the functions where you’re removing it seem, well, less clear after the change. What does removing it have to do with the other changes you’re planning? r=me, but really? 114796 4 eric 2009-03-23 11:02:22 -0700 (In reply to comment #3) > Why are you removing clear()? I like clear(), and all the functions where > you’re removing it seem, well, less clear after the change. What does removing > it have to do with the other changes you’re planning? > > r=me, but really? Maybe I should toss this one then. My coding experience has lead me to dislike clear()/reset()/init() functions. So easy to add to a class and forget to update all the "clear the state" functions. In this case, I think I was more interested in making Position immutable. You create a (lightweight) Position object once, and then you never edit it. This is the third time I've started a "fix Position" patch (I'm certainly not complaining), this time I was trying to do all the little things first, before getting to the meat. But maybe the little thing of killing clear() is not important. I think you and I should have a heart-to-heart about clear() and why you like it and I don't over IRC some time. Maybe there is some CS design book/principle which would make me like the clear() model over the "reset using a copy constructor and default initializer" model. The main goal at the end of this rewrite, is to get rid of the [node, 0] can mean two different things depending on what editingIgnoresContent(node) returns. 114797 5 eric 2009-03-23 11:05:27 -0700 (In reply to comment #4) > ... I think you and I should have a heart-to-heart about clear() and > why you like it and I don't over IRC some time. My point here was that you have a lot more coding experience than I do. I don't tend to like to write patches which Darin Adler fundamentally disagrees with. ;) (Especially when they're little cleanup ones like this.) So I'd be interested in your insight as to why you prefer .clear() for these classes. It's also possible that if we all understood where I was going with Position we'd all agree. :) 114804 6 darin 2009-03-23 11:33:26 -0700 (In reply to comment #4) > In this case, I think I was more interested in making Position immutable. You > create a (lightweight) Position object once, and then you never edit it. OK. But if you can assign to a Position then it’s not immutable. 114806 7 darin 2009-03-23 11:35:22 -0700 (In reply to comment #4) > The main goal at the end of this rewrite, is to get rid of the [node, 0] can > mean two different things depending on what editingIgnoresContent(node) > returns. I think it’s a great idea to create a way to represent before and after positions without having to compute a node index. This does make a fundamental change in Position, because Position now has capabilities that a plain old container/index pair does not. My biggest concern is that if you do this, you programmers will have a difficult choice between using PassRefPtr<Node> or Node* with no reference count churn, or Position with greater capabilities and a stronger model, but mandatory reference count churn. 114809 8 28856 darin 2009-03-23 11:41:16 -0700 Comment on attachment 28856 Rename Position::container to m_container and make it private > - RenderBlock* container = renderer->containingBlock(); > + RenderBlock* m_container = renderer->containingBlock(); > RenderObject* next = renderer; > - while ((next = next->nextInPreOrder(container))) { > + while ((next = next->nextInPreOrder(m_container))) { Oops! Please don't make this change. > + > + // This constructor should be private > + Position(PassRefPtr<Node> c, int o) > + : m_container(c) > + , m_offset(o) > + {} We put these on separate subsequent lines. I suggest naming the arguments container and offset. > - Node* node() const { return container.get(); } > + Node* node() const { return m_container.get(); } I kinda hate this function name. Because, what node? I guess that's the core of what you're going to be fixing. > + RefPtr<Node> m_container; > +public: > + int m_offset; // FIXME: This should be made private. I suggest you add the offset() function in this patch even if you don't adopt it yet. Or don’t put that FIXME in. > - m_position.container = container; > - m_position.m_offset = offset; > + m_position = Position(container, offset); This is more expensive than the old implementation. It churns the reference count of container one extra time. You should consider having a function that mutates the Position instead of assignment since it can be more efficient. > - m_position.container = child->parentNode(); > m_childBefore = child->previousSibling(); > - m_position.m_offset = m_childBefore ? invalidOffset : 0; > + m_position = Position(child->parentNode(), m_childBefore ? invalidOffset : 0); Ditto. > inline void RangeBoundaryPoint::setToStart(PassRefPtr<Node> container) > { > ASSERT(container); > - m_position.container = container; > - m_position.m_offset = 0; > + m_position = firstDeepEditingPositionForNode(container); > m_childBefore = 0; > } It looks to me like you’re sneaking in a behavior change here by calling firstDeepEditingPositionForNode. How about putting that in a separate patch and documenting what bug it fixes? > inline void RangeBoundaryPoint::setToEnd(PassRefPtr<Node> container) > { > ASSERT(container); > - m_position.container = container; > - if (m_position.container->offsetInCharacters()) { > - m_position.m_offset = m_position.container->maxCharacterOffset(); > + if (container->offsetInCharacters()) { > + m_position = Position(container, container->maxCharacterOffset()); > m_childBefore = 0; > } else { > - m_childBefore = m_position.container->lastChild(); > - m_position.m_offset = m_childBefore ? invalidOffset : 0; > + m_childBefore = container->lastChild(); > + m_position = Position(container, m_childBefore ? invalidOffset : 0); > } > } Due to the use of invalidOffset in RangeBoundaryPoint, Position can’t really start treating things in an abstract way until it takes over the “childBefore” optimization. I’m also concerned that in the case of RangeBoundaryPoint, we have special requirements. It’s not OK to automatically translate a Position between multiple forms. Only time will tell, but this seems an easy area to get wrong. review- for now because of some of the mistakes above. 114810 9 eric 2009-03-23 11:43:07 -0700 (In reply to comment #7) > My biggest concern is that if you do this, you programmers will have a > difficult choice between using PassRefPtr<Node> or Node* with no reference > count churn, or Position with greater capabilities and a stronger model, but > mandatory reference count churn. I don't understand. Position objects currently ref the node pointer. I intend to keep it that way. Are you referring to the loss of setOffset() in an immutable Position model, and the need then to copy (and thus ref-churn) in order to change the Position? 114817 10 eric 2009-03-23 11:54:54 -0700 (In reply to comment #9) > I don't understand. I wrote that comment before seeing your review comments. I now understand. The refchurn you identify only occurs when newNode == oldNode. But I'm starting to think there is no strong need for Positions to be immutable. 114818 11 darin 2009-03-23 11:56:28 -0700 (In reply to comment #9) > (In reply to comment #7) > > My biggest concern is that if you do this, you programmers will have a > > difficult choice between using PassRefPtr<Node> or Node* with no reference > > count churn, or Position with greater capabilities and a stronger model, but > > mandatory reference count churn. > > I don't understand. Position objects currently ref the node pointer. I intend > to keep it that way. Position is a convenience today and in theory can get the same behavior more efficiently by having your own RefPtr/offset pair and use PassRefPtr as you like. There’s no PassPosition. But the more that Position becomes an abstraction that does fancier things than a RefPtr/offset pair, the more the lack of a PassPosition becomes a problem. Maybe we need a PassPosition. 114827 12 eric 2009-03-23 12:34:21 -0700 (In reply to comment #11) > Position is a convenience today and in theory can get the same behavior more > efficiently by having your own RefPtr/offset pair and use PassRefPtr as you > like. There’s no PassPosition. > > But the more that Position becomes an abstraction that does fancier things than > a RefPtr/offset pair, the more the lack of a PassPosition becomes a problem. > Maybe we need a PassPosition. I like the idea of a PassPosition. I'm just slightly concerned that it makes more difficult the possible future desire to have an AfterPosition, BeforePosition, OffsetPosition types/subclasses to make it clear at the callsite how the position should be anchored. (For example for RangeBoundaryPoint member storage.) The current plan is to use creation functions for all position uses. Which I can change to use a new PassPosition class. Things like createOffsetPosition(node, offset) createAfterPosition(node) createBeforePosition(node) and a createEditingOffsetPosition(node, offset) (which matches the current behavior of Position() + the various later canonicalization functions in that it creates a position which is either an offset, or before or after, depending on if the node is ignored by editing or not). Again, basically we're making Position store what type it is, and moving the type determination to construction time instead of some later time when the right combination of canonicalization functions are called. I'm not sure we'll really want to have PassAfterPosition, PassBeforePosition, PassOffsetPosition as well (seems like a lot of classes to express such a simple idea) so maybe PassPosition will just be the one generic pass class. 114831 13 darin 2009-03-23 12:46:55 -0700 (In reply to comment #12) > I like the idea of a PassPosition. I'm just slightly concerned that it makes > more difficult the possible future desire to have an AfterPosition, > BeforePosition, OffsetPosition types/subclasses to make it clear at the > callsite how the position should be anchored. Do these types need to be subclasses? Can’t they just be states of a Position class? If you have subclasses I think then you have to use pointers because that’s how polymorphism works. 114833 14 eric 2009-03-23 12:52:17 -0700 (In reply to comment #13) > Do these types need to be subclasses? Can’t they just be states of a Position > class? They can be states. That's how I implemented them when I wrote them (patch not posted). I was was writing them though, there seemed a few places where it would be nice (from a code cleanliness perspective) for the caller to be able to indicate (in a way the compiler could check) that a position was anchored in some specific way. > If you have subclasses I think then you have to use pointers because that’s how > polymorphism works. True. We'd have to start returning pointers if we wanted to go down that path. For now I'll stick with a single mutable (at least the offset) Position class (which can be anchored in multiple ways), and a single PassPosition class which is used for passing around Position objects instead of returning Position (and probably in some cases instead of passing const Position&). 114861 15 28870 eric 2009-03-23 15:32:20 -0700 Created attachment 28870 Stab at PassPosition, does not compile JavaScriptCore/wtf/PassRefPtr.h | 4 +- WebCore/WebCore.xcodeproj/project.pbxproj | 4 ++ WebCore/dom/Position.cpp | 36 ++++++++++++++----- WebCore/dom/Position.h | 25 ++++++++----- WebCore/dom/PositionIterator.cpp | 1 + WebCore/dom/Range.cpp | 1 + WebCore/editing/ApplyStyleCommand.cpp | 1 + WebCore/editing/BreakBlockquoteCommand.cpp | 3 +- WebCore/editing/CompositeEditCommand.cpp | 1 + WebCore/editing/DeleteSelectionCommand.cpp | 1 + WebCore/editing/Editor.cpp | 1 + WebCore/editing/FormatBlockCommand.cpp | 6 ++- WebCore/editing/IndentOutdentCommand.cpp | 1 + WebCore/editing/InsertLineBreakCommand.cpp | 1 + WebCore/editing/InsertListCommand.cpp | 6 ++- .../editing/InsertParagraphSeparatorCommand.cpp | 9 +++-- WebCore/editing/InsertTextCommand.cpp | 9 +++-- WebCore/editing/ReplaceSelectionCommand.cpp | 1 + WebCore/editing/SelectionController.cpp | 1 + WebCore/editing/TypingCommand.cpp | 1 + WebCore/editing/VisiblePosition.cpp | 1 + WebCore/editing/VisibleSelection.cpp | 1 + WebCore/editing/htmlediting.cpp | 1 + WebCore/editing/markup.cpp | 1 + WebCore/editing/visible_units.cpp | 1 + WebCore/page/AccessibilityObject.cpp | 1 + WebCore/page/AccessibilityRenderObject.cpp | 1 + WebCore/page/Frame.cpp | 1 + WebCore/rendering/RenderBox.cpp | 1 + 29 files changed, 87 insertions(+), 35 deletions(-) 114862 16 28870 eric 2009-03-23 15:33:09 -0700 Comment on attachment 28870 Stab at PassPosition, does not compile I'm not sure PassPosition is the right approach. I'm not even sure if Position-based refcount is currently a problem. Adding PassPosition but not adding a PassVisiblePosition would just shift the problem to VisiblePosition. 114867 17 darin 2009-03-23 16:19:19 -0700 I think the best way to do the PassPosition thing more simply is to make PassPosition only usable for passing. There’s no need to be able to use it directly. Unlike PassRefPtr which you can use directly. 114873 18 eric 2009-03-23 16:32:39 -0700 (In reply to comment #17) > I think the best way to do the PassPosition thing more simply is to make > PassPosition only usable for passing. There’s no need to be able to use it > directly. Unlike PassRefPtr which you can use directly. There are callers who currently do if (myPosition.downstream().isNotNull) (which returned a Position now PassPosition) which will need to change to store the downstream in a local first before accessing. Likewise, callers who expect to be able to transparently convert from a returned Position object to a VisiblePosition, which now would need to explicitly make a Position (or more likely, VisiblePosition will just need to be taught about PassPosition) Those were the two largest errors I encountered (which is why you see PassPosition having methods like isNotNull()). 114875 19 darin 2009-03-23 16:40:45 -0700 OK. 114880 20 28876 eric 2009-03-23 17:04:35 -0700 Created attachment 28876 Second stab at making Position::container private WebCore/ChangeLog | 39 +++++++++++++++++++++++++++++++++++ WebCore/dom/Position.h | 42 +++++++++++++++++++++++++++++-------- WebCore/dom/Range.cpp | 4 +- WebCore/dom/RangeBoundaryPoint.h | 31 ++++++++++++++------------- 4 files changed, 90 insertions(+), 26 deletions(-) 114891 21 28876 darin 2009-03-23 17:32:20 -0700 Comment on attachment 28876 Second stab at making Position::container private > inline Node* RangeBoundaryPoint::container() const > { > - return m_position.container.get(); > + // FIXME: node() is not necessarily the container node! > + return m_position.node(); > } This FIXME is wrong. The way RangeBoundaryPoint uses Position, everything is perfectly find, and this is indeed the container. It's the uses of Position in editing code that have the problem you mention in the definition of node. The Range class works perfectly here and there's no problem, so I think it's really misleading to have a FIXME here. r=me though 114902 22 eric 2009-03-23 19:25:56 -0700 The Position::container rename patch was landed as: Committing to http://svn.webkit.org/repository/webkit/trunk ... M WebCore/ChangeLog M WebCore/dom/Position.h M WebCore/dom/Range.cpp M WebCore/dom/RangeBoundaryPoint.h Committed r41933 I'll do the rest in separate bugs. 28855 2009-03-23 09:49:29 -0700 2009-03-23 09:55:00 -0700 Remove Position::clear() and make VisibleSelection.h not include VisiblePosition.h Remove-Position-clear-and-make-VisibleSelection.h-not-include-VisiblePosition.h.patch text/plain 20479 eric NDdlOTEzNzQyYTk2ZDgyMTZiNWEzOGI0Mzc3MDNjOGYwZTcwMjRjOQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBlZThhYmVjLi5lODdhMjMy IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDYwIEBACisyMDA5LTAzLTIzICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1v dmUgUG9zaXRpb246OmNsZWFyKCkgYW5kIG1ha2UgVmlzaWJsZVNlbGVjdGlvbi5oIG5vdCBpbmNs dWRlIFZpc2libGVQb3NpdGlvbi5oCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yNDc2MAorICAgICAgICAKKyAgICAgICAgUG9zaXRpb24gb2JqZWN0cyB3 aWxsIHNvb24gYmUgaW1tdXRhYmxlLCBzbyBubyBuZWVkIGZvciBhIGNsZWFyKCkgZnVuY3Rpb24K KyAgICAgICAgaW4gbXkgZXhwZXJpZW5jZSwgY2xlYXIoKSBmdW5jdGlvbnMgYXJlIG9mdGVuIGVy cm9yLXByb25lIGFzIHRoZXkgY2FuIGJlIGZvcmdvdHRlbgorICAgICAgICB3aGVuIGFkZGluZyBu ZXcgbWVtYmVycyB0byBhIGNsYXNzLiAgSW4gdGhlIGNhc2Ugb2YgUG9zaXRpb24gb2JqZWN0cywg dGhlc2Ugb2JqZWN0cworICAgICAgICBhcmUgc28gdGlueSAoYW5kIGFsd2F5cyBvbiB0aGUgc3Rh Y2spIHRoYXQgY2xlYXIoKSBzaG91bGQgYmUganVzdCBhcyBjaGVhcCBhcworICAgICAgICBteVBv c2l0aW9uID0gUG9zaXRpb24oKS4KKyAgICAgICAgCisgICAgICAgIE1ha2luZyBWaXNpYmxlU2Vs ZWN0aW9uLmggbm90IGluY2x1ZGUgVmlzaWJsZVBvc2l0aW9uIHdhcyBhbiBhdHRlbXB0IHRvIHNw ZWVkIHVwIG15CisgICAgICAgIGluY3JlbWVudGFsIGJ1aWxkcyBhcyBJIHJld29yayBzb21lIG9m IHRoZSBQb3NpdGlvbiBjb2RlLiAgSXQgd2FzIHN1Y2Nlc3NmdWwgaW4gcmVtb3ZpbmcKKyAgICAg ICAgYWJvdXQgMTAgZmlsZXMgKG9mIH4zMDApIGZyb20gbXkgY29tcGlsZSBjeWNsZSAobm90IGFz IG1hbnkgYXMgSSBoYWQgaG9wZWQpLgorCisgICAgICAgIENvZGUgY2xlYW51cCwgbm8gdGVzdCBj aGFuZ2VzLgorCisgICAgICAgICogZG9tL1Bvc2l0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OmZpcnN0RGVlcEVkaXRpbmdQb3NpdGlvbkZvck5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6bGFz dERlZXBFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKToKKyAgICAgICAgKiBkb20vUG9zaXRpb24uaDoK KyAgICAgICAgKiBkb20vUmFuZ2VCb3VuZGFyeVBvaW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpS YW5nZUJvdW5kYXJ5UG9pbnQ6OmNsZWFyKToKKyAgICAgICAgKiBlZGl0aW5nL0FwcGx5U3R5bGVD b21tYW5kLmNwcDoKKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcDoK KyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZUJ1dHRvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAq IGVkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpE ZWxldGVTZWxlY3Rpb25Db21tYW5kOjpjbGVhclRyYW5zaWVudFN0YXRlKToKKyAgICAgICAgKiBl ZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHA6CisgICAgICAgICogZWRpdGluZy9JbmRlbnRP dXRkZW50Q29tbWFuZC5jcHA6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRMaXN0Q29tbWFuZC5j cHA6CisgICAgICAgICogZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNw cDoKKyAgICAgICAgKiBlZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcDoKKyAgICAgICAgKiBl ZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmNwcDoKKyAgICAgICAgKiBlZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAqIGVkaXRpbmcvVGV4dEl0ZXJhdG9yLmNw cDoKKyAgICAgICAgKiBlZGl0aW5nL1Zpc2libGVQb3NpdGlvbi5oOgorICAgICAgICAoV2ViQ29y ZTo6VmlzaWJsZVBvc2l0aW9uOjpjbGVhcik6CisgICAgICAgICogZWRpdGluZy9WaXNpYmxlU2Vs ZWN0aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlZpc2libGVTZWxlY3Rpb246OnZpc2libGVT dGFydCk6CisgICAgICAgIChXZWJDb3JlOjpWaXNpYmxlU2VsZWN0aW9uOjp2aXNpYmxlRW5kKToK KyAgICAgICAgKiBlZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaDoKKyAgICAgICAgKiBlZGl0aW5n L21hcmt1cC5jcHA6CisgICAgICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0Lmg6CisgICAg ICAgICogcGFnZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Lmg6CisgICAgICAgICogcGFnZS9E T01TZWxlY3Rpb24uY3BwOgorICAgICAgICAqIHBhZ2UvRHJhZ0NvbnRyb2xsZXIuY3BwOgorICAg ICAgICAqIHBhZ2UvRnJhbWUuY3BwOgorICAgICAgICAqIHBhZ2UvbWFjL0ZyYW1lTWFjLm1tOgor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCbG9jay5jcHA6CisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlckJveC5jcHA6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNw cDoKKyAgICAgICAgKiByZW5kZXJpbmcvVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmNwcDoKKyAg ICAgICAgKiBzdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50LmNwcDoKKwogMjAwOS0wMy0yMyAgRXJp YyBDYXJsc29uICA8ZXJpYy5jYXJsc29uQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBi eSBBZGFtIFJvYmVuLgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRpb24uY3BwIGIvV2Vi Q29yZS9kb20vUG9zaXRpb24uY3BwCmluZGV4IDg3MDQ4NDUuLjQ0MzJkMzkgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmNwcAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5jcHAK QEAgLTEwMTEsMTQgKzEwMTEsMTQgQEAgUG9zaXRpb24gZW5kUG9zaXRpb24oY29uc3QgUmFuZ2Uq IHIpCiAvLyBOT1RFOiBmaXJzdC9sYXN0RGVlcEVkaXRpbmdQb3NpdGlvbkZvck5vZGUgY2FuIHJl dHVybiAiZWRpdGluZyBwb3NpdGlvbnMiIChsaWtlIFtpbWcsIDBdKQogLy8gZm9yIGVsZW1lbnRz IHdoaWNoIGVkaXRpbmcgImlnbm9yZXMiLiAgdGhlIHJlc3Qgb2YgdGhlIGVkaXRpbmcgY29kZSB3 aWxsIHRyZWF0IFtpbWcsIDBdCiAvLyBhcyAidGhlIGxhc3QgcG9zaXRpb24gYmVmb3JlIHRoZSBp bWciCi1Qb3NpdGlvbiBmaXJzdERlZXBFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKE5vZGUqIG5vZGUp CitQb3NpdGlvbiBmaXJzdERlZXBFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKFBhc3NSZWZQdHI8Tm9k ZT4gbm9kZSkKIHsKICAgICByZXR1cm4gUG9zaXRpb24obm9kZSwgMCk7CiB9CiAKLVBvc2l0aW9u IGxhc3REZWVwRWRpdGluZ1Bvc2l0aW9uRm9yTm9kZShOb2RlKiBub2RlKQorUG9zaXRpb24gbGFz dERlZXBFZGl0aW5nUG9zaXRpb25Gb3JOb2RlKFBhc3NSZWZQdHI8Tm9kZT4gbm9kZSkKIHsKLSAg ICByZXR1cm4gUG9zaXRpb24obm9kZSwgbGFzdE9mZnNldEZvckVkaXRpbmcobm9kZSkpOworICAg IHJldHVybiBQb3NpdGlvbihub2RlLCBsYXN0T2Zmc2V0Rm9yRWRpdGluZyhub2RlLmdldCgpKSk7 CiB9CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1Bv c2l0aW9uLmggYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oCmluZGV4IGI3NDA3NjQuLjEwOWU5N2Qg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmgKKysrIGIvV2ViQ29yZS9kb20vUG9z aXRpb24uaApAQCAtMjYsNiArMjYsNyBAQAogI2lmbmRlZiBQb3NpdGlvbl9oCiAjZGVmaW5lIFBv c2l0aW9uX2gKIAorI2luY2x1ZGUgIk5vZGUuaCIKICNpbmNsdWRlICJUZXh0QWZmaW5pdHkuaCIK ICNpbmNsdWRlICJUZXh0RGlyZWN0aW9uLmgiCiAjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4K QEAgLTM2LDcgKzM3LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogY2xhc3MgQ1NTQ29tcHV0ZWRT dHlsZURlY2xhcmF0aW9uOwogY2xhc3MgRWxlbWVudDsKIGNsYXNzIElubGluZUJveDsKLWNsYXNz IE5vZGU7CiBjbGFzcyBSYW5nZTsKIGNsYXNzIFJlbmRlck9iamVjdDsKIApAQCAtNTgsMTUgKzU4 LDE1IEBAIHB1YmxpYzoKICAgICBQb3NpdGlvbigpIDogbV9vZmZzZXQoMCkgeyB9CiAgICAgUG9z aXRpb24oUGFzc1JlZlB0cjxOb2RlPiBjLCBpbnQgbykgOiBjb250YWluZXIoYyksIG1fb2Zmc2V0 KG8pIHsgfQogCi0gICAgdm9pZCBjbGVhcigpIHsgY29udGFpbmVyLmNsZWFyKCk7IG1fb2Zmc2V0 ID0gMDsgfQotCiAgICAgTm9kZSogbm9kZSgpIGNvbnN0IHsgcmV0dXJuIGNvbnRhaW5lci5nZXQo KTsgfQorCisgICAgLy8gUmV0dXJucyBub2RlKCkgb3IgdGhlIGNsb3Nlc3QgZWxlbWVudCBhY2Nl c3RvcgorICAgIEVsZW1lbnQqIGVsZW1lbnQoKSBjb25zdDsKICAgICBFbGVtZW50KiBkb2N1bWVu dEVsZW1lbnQoKSBjb25zdDsKIAogICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyByZXR1cm4gIWNv bnRhaW5lcjsgfQogICAgIGJvb2wgaXNOb3ROdWxsKCkgY29uc3QgeyByZXR1cm4gY29udGFpbmVy OyB9CiAKLSAgICBFbGVtZW50KiBlbGVtZW50KCkgY29uc3Q7CiAgICAgUGFzc1JlZlB0cjxDU1ND b21wdXRlZFN0eWxlRGVjbGFyYXRpb24+IGNvbXB1dGVkU3R5bGUoKSBjb25zdDsKIAogICAgIC8v IE1vdmUgdXAgb3IgZG93biB0aGUgRE9NIGJ5IG9uZSBwb3NpdGlvbi4KQEAgLTEzNiw4ICsxMzYs OCBAQCBQb3NpdGlvbiBlbmRQb3NpdGlvbihjb25zdCBSYW5nZSopOwogLy8gTk9URTogZmlyc3Qv bGFzdERlZXBFZGl0aW5nUG9zaXRpb25Gb3JOb2RlIGNhbiByZXR1cm4gImVkaXRpbmcgcG9zaXRp b25zIiAobGlrZSBbaW1nLCAwXSkKIC8vIGZvciBlbGVtZW50cyB3aGljaCBlZGl0aW5nICJpZ25v cmVzIi4gIHRoZSByZXN0IG9mIHRoZSBlZGl0aW5nIGNvZGUgd2lsbCB0cmVhdCBbaW1nLCAwXQog Ly8gYXMgInRoZSBsYXN0IHBvc2l0aW9uIGJlZm9yZSB0aGUgaW1nIgotUG9zaXRpb24gZmlyc3RE ZWVwRWRpdGluZ1Bvc2l0aW9uRm9yTm9kZShOb2RlKik7Ci1Qb3NpdGlvbiBsYXN0RGVlcEVkaXRp bmdQb3NpdGlvbkZvck5vZGUoTm9kZSopOworUG9zaXRpb24gZmlyc3REZWVwRWRpdGluZ1Bvc2l0 aW9uRm9yTm9kZShQYXNzUmVmUHRyPE5vZGU+KTsKK1Bvc2l0aW9uIGxhc3REZWVwRWRpdGluZ1Bv c2l0aW9uRm9yTm9kZShQYXNzUmVmUHRyPE5vZGU+KTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29y ZQogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCBiL1dlYkNv cmUvZG9tL1JhbmdlQm91bmRhcnlQb2ludC5oCmluZGV4IDM5YzczNWUuLjI4NmMxM2MgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvZG9tL1JhbmdlQm91bmRhcnlQb2ludC5oCisrKyBiL1dlYkNvcmUvZG9t L1JhbmdlQm91bmRhcnlQb2ludC5oCkBAIC05Niw3ICs5Niw3IEBAIGlubGluZSBpbnQgUmFuZ2VC b3VuZGFyeVBvaW50OjpvZmZzZXQoKSBjb25zdAogCiBpbmxpbmUgdm9pZCBSYW5nZUJvdW5kYXJ5 UG9pbnQ6OmNsZWFyKCkKIHsKLSAgICBtX3Bvc2l0aW9uLmNsZWFyKCk7CisgICAgbV9wb3NpdGlv biA9IFBvc2l0aW9uKCk7CiAgICAgbV9jaGlsZEJlZm9yZSA9IDA7CiB9CiAKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcv QXBwbHlTdHlsZUNvbW1hbmQuY3BwCmluZGV4IGViMzEyNTQuLmNkN2M5OTAgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL0FwcGx5U3R5bGVDb21tYW5kLmNwcApAQCAtNDMsNiArNDMsNyBAQAogI2luY2x1ZGUgIlRl eHQuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5o IgorI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgInZpc2libGVfdW5pdHMu aCIKICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvQ29tcG9z aXRlRWRpdENvbW1hbmQuY3BwCmluZGV4IDkwNTI1ODIuLmVlMDM1NzIgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcApAQCAtNTksNiArNTksNyBAQAogI2luY2x1ZGUg IlNwbGl0VGV4dE5vZGVDb250YWluaW5nRWxlbWVudENvbW1hbmQuaCIKICNpbmNsdWRlICJUZXh0 LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCisjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9u LmgiCiAjaW5jbHVkZSAiV3JhcENvbnRlbnRzSW5EdW1teVNwYW5Db21tYW5kLmgiCiAjaW5jbHVk ZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJtYXJrdXAuaCIKZGlmZiAtLWdpdCBhL1dlYkNv cmUvZWRpdGluZy9EZWxldGVCdXR0b25Db250cm9sbGVyLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9E ZWxldGVCdXR0b25Db250cm9sbGVyLmNwcAppbmRleCBjMDc3NWUzLi4wMjE1OTkwIDEwMDY0NAot LS0gYS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlQnV0dG9uQ29udHJvbGxlci5jcHAKKysrIGIvV2Vi Q29yZS9lZGl0aW5nL0RlbGV0ZUJ1dHRvbkNvbnRyb2xsZXIuY3BwCkBAIC00NCw2ICs0NCw3IEBA CiAjaW5jbHVkZSAiUmVtb3ZlTm9kZUNvbW1hbmQuaCIKICNpbmNsdWRlICJSZW5kZXJCb3guaCIK ICNpbmNsdWRlICJTZWxlY3Rpb25Db250cm9sbGVyLmgiCisjaW5jbHVkZSAiVmlzaWJsZVBvc2l0 aW9uLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0 aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0RlbGV0ZVNl bGVjdGlvbkNvbW1hbmQuY3BwCmluZGV4IDA5Mjg4ZWUuLmU3ZDNhZWQgMTAwNjQ0Ci0tLSBhL1dl YkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2Vk aXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKQEAgLTQyLDYgKzQyLDcgQEAKICNpbmNs dWRlICJSZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5oIgogI2luY2x1ZGUgIlRleHQuaCIKICNpbmNs dWRlICJUZXh0SXRlcmF0b3IuaCIKKyNpbmNsdWRlICJWaXNpYmxlUG9zaXRpb24uaCIKICNpbmNs dWRlICJ2aXNpYmxlX3VuaXRzLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKQEAgLTY5NCwxMyAr Njk1LDEzIEBAIHZvaWQgRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6Y2FsY3VsYXRlVHlwaW5nU3R5 bGVBZnRlckRlbGV0ZSgpCiB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6OmNsZWFyVHJhbnNp ZW50U3RhdGUoKQogewogICAgIG1fc2VsZWN0aW9uVG9EZWxldGUgPSBWaXNpYmxlU2VsZWN0aW9u KCk7Ci0gICAgbV91cHN0cmVhbVN0YXJ0LmNsZWFyKCk7Ci0gICAgbV9kb3duc3RyZWFtU3RhcnQu Y2xlYXIoKTsKLSAgICBtX3Vwc3RyZWFtRW5kLmNsZWFyKCk7Ci0gICAgbV9kb3duc3RyZWFtRW5k LmNsZWFyKCk7Ci0gICAgbV9lbmRpbmdQb3NpdGlvbi5jbGVhcigpOwotICAgIG1fbGVhZGluZ1do aXRlc3BhY2UuY2xlYXIoKTsKLSAgICBtX3RyYWlsaW5nV2hpdGVzcGFjZS5jbGVhcigpOworICAg IG1fdXBzdHJlYW1TdGFydCA9IFBvc2l0aW9uKCk7CisgICAgbV9kb3duc3RyZWFtU3RhcnQgPSBQ b3NpdGlvbigpOworICAgIG1fdXBzdHJlYW1FbmQgPSBQb3NpdGlvbigpOworICAgIG1fZG93bnN0 cmVhbUVuZCA9IFBvc2l0aW9uKCk7CisgICAgbV9lbmRpbmdQb3NpdGlvbiA9IFBvc2l0aW9uKCk7 CisgICAgbV9sZWFkaW5nV2hpdGVzcGFjZSA9IFBvc2l0aW9uKCk7CisgICAgbV90cmFpbGluZ1do aXRlc3BhY2UgPSBQb3NpdGlvbigpOwogfQogCiB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6 OmRvQXBwbHkoKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFu ZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcAppbmRleCA4ODE2 OWJlLi4yYmRhNGVlIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21t YW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvRm9ybWF0QmxvY2tDb21tYW5kLmNwcApAQCAt MzAsNiArMzAsNyBAQAogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAiSFRNTEVs ZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJWaXNpYmxlUG9zaXRp b24uaCIKICNpbmNsdWRlICJ2aXNpYmxlX3VuaXRzLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAgYi9X ZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwCmluZGV4IDk0NDRiMTEuLmQw MDk0NmYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5j cHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcApAQCAtMzUs NiArMzUsNyBAQAogI2luY2x1ZGUgIlJhbmdlLmgiCiAjaW5jbHVkZSAiU3BsaXRFbGVtZW50Q29t bWFuZC5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgorI2luY2x1ZGUgIlZpc2libGVQb3Np dGlvbi5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0 cy5oIgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnRMaXN0Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0TGlz dENvbW1hbmQuY3BwCmluZGV4IGFhNDg3NjEuLjUzOTVmOWIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9JbnNlcnRMaXN0Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2Vy dExpc3RDb21tYW5kLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1ZGUgIkhUTUxFbGVtZW50 LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCisj aW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0 UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFy YWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5jcHAKaW5kZXggZWViOTE0YS4uZmE2YjdlOCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuY3Bw CisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNw cApAQCAtMzYsNiArMzYsNyBAQAogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIklu c2VydExpbmVCcmVha0NvbW1hbmQuaCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKKyNpbmNs dWRlICJWaXNpYmxlUG9zaXRpb24uaCIKICNpbmNsdWRlICJ2aXNpYmxlX3VuaXRzLmgiCiAKIG5h bWVzcGFjZSBXZWJDb3JlIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0 Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0VGV4dENvbW1hbmQuY3BwCmluZGV4 IDUyZGE1ZDAuLjAyNGM3NWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0 Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNwcApA QCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAiVGV4 dEl0ZXJhdG9yLmgiCiAjaW5jbHVkZSAiVHlwaW5nQ29tbWFuZC5oIgorI2luY2x1ZGUgIlZpc2li bGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgInZpc2libGVfdW5pdHMuaCIKIAogbmFtZXNwYWNlIFdl YkNvcmUgewpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21t YW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9SZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5jcHAKaW5k ZXggYzdkNjY3ZS4uYzFkMmFhYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VT ZWxlY3Rpb25Db21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvUmVwbGFjZVNlbGVjdGlv bkNvbW1hbmQuY3BwCkBAIC00Niw2ICs0Niw3IEBACiAjaW5jbHVkZSAiU2VsZWN0aW9uQ29udHJv bGxlci5oIgogI2luY2x1ZGUgIlNtYXJ0UmVwbGFjZS5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRv ci5oIgorI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5n LmgiCiAjaW5jbHVkZSAibWFya3VwLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwIGIvV2ViQ29y ZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IGQ2MDY4OTEuLjM2MmFiNDMg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAorKysg Yi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKQEAgLTUwLDYgKzUwLDcg QEAKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCiAj aW5jbHVkZSAiVHlwaW5nQ29tbWFuZC5oIgorI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgog I2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgogI2lu Y2x1ZGUgPHN0ZGlvLmg+CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvVGV4dEl0ZXJhdG9y LmNwcCBiL1dlYkNvcmUvZWRpdGluZy9UZXh0SXRlcmF0b3IuY3BwCmluZGV4IGFjNTA2M2QuLjBj ZmFlMjcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9UZXh0SXRlcmF0b3IuY3BwCisrKyBi L1dlYkNvcmUvZWRpdGluZy9UZXh0SXRlcmF0b3IuY3BwCkBAIC0zMyw3ICszMyw2IEBACiAjaW5j bHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJJ bmxpbmVUZXh0Qm94LmgiCi0jaW5jbHVkZSAiUG9zaXRpb24uaCIKICNpbmNsdWRlICJSYW5nZS5o IgogI2luY2x1ZGUgIlJlbmRlclRhYmxlQ2VsbC5oIgogI2luY2x1ZGUgIlJlbmRlclRhYmxlUm93 LmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVBvc2l0aW9uLmggYi9XZWJD b3JlL2VkaXRpbmcvVmlzaWJsZVBvc2l0aW9uLmgKaW5kZXggNDAzYzgxNi4uYmJmOWM5ZCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVQb3NpdGlvbi5oCisrKyBiL1dlYkNvcmUv ZWRpdGluZy9WaXNpYmxlUG9zaXRpb24uaApAQCAtMjYsNyArMjYsNiBAQAogI2lmbmRlZiBWaXNp YmxlUG9zaXRpb25faAogI2RlZmluZSBWaXNpYmxlUG9zaXRpb25faAogCi0jaW5jbHVkZSAiTm9k ZS5oIgogI2luY2x1ZGUgIlBvc2l0aW9uLmgiCiAjaW5jbHVkZSAiVGV4dERpcmVjdGlvbi5oIgog CkBAIC01NSw3ICs1NCw3IEBAIHB1YmxpYzoKICAgICBWaXNpYmxlUG9zaXRpb24oTm9kZSosIGlu dCBvZmZzZXQsIEVBZmZpbml0eSk7CiAgICAgVmlzaWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9u JiwgRUFmZmluaXR5ID0gVlBfREVGQVVMVF9BRkZJTklUWSk7CiAKLSAgICB2b2lkIGNsZWFyKCkg eyBtX2RlZXBQb3NpdGlvbi5jbGVhcigpOyB9CisgICAgdm9pZCBjbGVhcigpIHsgbV9kZWVwUG9z aXRpb24gPSBQb3NpdGlvbigpOyB9CiAKICAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJu IG1fZGVlcFBvc2l0aW9uLmlzTnVsbCgpOyB9CiAgICAgYm9vbCBpc05vdE51bGwoKSBjb25zdCB7 IHJldHVybiBtX2RlZXBQb3NpdGlvbi5pc05vdE51bGwoKTsgfQpAQCAtNzcsOSArNzYsOSBAQCBw dWJsaWM6CiAgICAgVUNoYXIgY2hhcmFjdGVyQmVmb3JlKCkgY29uc3QgeyByZXR1cm4gcHJldmlv dXMoKS5jaGFyYWN0ZXJBZnRlcigpOyB9CiAgICAgCiAgICAgdm9pZCBkZWJ1Z1Bvc2l0aW9uKGNv bnN0IGNoYXIqIG1zZyA9ICIiKSBjb25zdDsKLSAgICAKKwogICAgIEVsZW1lbnQqIHJvb3RFZGl0 YWJsZUVsZW1lbnQoKSBjb25zdCB7IHJldHVybiBtX2RlZXBQb3NpdGlvbi5pc05vdE51bGwoKSA/ IG1fZGVlcFBvc2l0aW9uLm5vZGUoKS0+cm9vdEVkaXRhYmxlRWxlbWVudCgpIDogMDsgfQotICAg IAorCiAgICAgdm9pZCBnZXRJbmxpbmVCb3hBbmRPZmZzZXQoSW5saW5lQm94KiYgaW5saW5lQm94 LCBpbnQmIGNhcmV0T2Zmc2V0KSBjb25zdAogICAgIHsKICAgICAgICAgbV9kZWVwUG9zaXRpb24u Z2V0SW5saW5lQm94QW5kT2Zmc2V0KG1fYWZmaW5pdHksIGlubGluZUJveCwgY2FyZXRPZmZzZXQp OwpAQCAtMTMxLDcgKzEzMCw3IEBAIGJvb2wgc2V0RW5kKFJhbmdlKiwgY29uc3QgVmlzaWJsZVBv c2l0aW9uJik7CiBWaXNpYmxlUG9zaXRpb24gc3RhcnRWaXNpYmxlUG9zaXRpb24oY29uc3QgUmFu Z2UqLCBFQWZmaW5pdHkpOwogVmlzaWJsZVBvc2l0aW9uIGVuZFZpc2libGVQb3NpdGlvbihjb25z dCBSYW5nZSosIEVBZmZpbml0eSk7CiAKLU5vZGUgKmVuY2xvc2luZ0Jsb2NrRmxvd0VsZW1lbnQo Y29uc3QgVmlzaWJsZVBvc2l0aW9uJik7CitOb2RlKiBlbmNsb3NpbmdCbG9ja0Zsb3dFbGVtZW50 KGNvbnN0IFZpc2libGVQb3NpdGlvbiYpOwogCiBib29sIGlzRmlyc3RWaXNpYmxlUG9zaXRpb25J bk5vZGUoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgTm9kZSopOwogYm9vbCBpc0xhc3RW aXNpYmxlUG9zaXRpb25Jbk5vZGUoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgTm9kZSop OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwIGIvV2Vi Q29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCmluZGV4IDI3OWFkZjIuLmE3ZWE2Yzkg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcAorKysgYi9X ZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAKQEAgLTEyMyw2ICsxMjMsMTYgQEAg dm9pZCBWaXNpYmxlU2VsZWN0aW9uOjpzZXRFeHRlbnQoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiB2 aXNpYmxlUG9zaXRpb24pCiAgICAgdmFsaWRhdGUoKTsKIH0KIAorVmlzaWJsZVBvc2l0aW9uIFZp c2libGVTZWxlY3Rpb246OnZpc2libGVTdGFydCgpIGNvbnN0Cit7CisgICAgcmV0dXJuIFZpc2li bGVQb3NpdGlvbihtX3N0YXJ0LCBpc1JhbmdlKCkgPyBET1dOU1RSRUFNIDogYWZmaW5pdHkoKSk7 Cit9CisKK1Zpc2libGVQb3NpdGlvbiBWaXNpYmxlU2VsZWN0aW9uOjp2aXNpYmxlRW5kKCkgY29u c3QKK3sKKyAgICByZXR1cm4gVmlzaWJsZVBvc2l0aW9uKG1fZW5kLCBpc1JhbmdlKCkgPyBVUFNU UkVBTSA6IGFmZmluaXR5KCkpOworfQorCiBQYXNzUmVmUHRyPFJhbmdlPiBWaXNpYmxlU2VsZWN0 aW9uOjpmaXJzdFJhbmdlKCkgY29uc3QKIHsKICAgICBpZiAoaXNOb25lKCkpCmRpZmYgLS1naXQg YS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5oIGIvV2ViQ29yZS9lZGl0aW5nL1Zp c2libGVTZWxlY3Rpb24uaAppbmRleCBhZTIxNDJkLi4xYTgyNGQ0IDEwMDY0NAotLS0gYS9XZWJD b3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9WaXNp YmxlU2VsZWN0aW9uLmgKQEAgLTI2LDEyICsyNiwxMiBAQAogI2lmbmRlZiBWaXNpYmxlU2VsZWN0 aW9uX2gKICNkZWZpbmUgVmlzaWJsZVNlbGVjdGlvbl9oCiAKKyNpbmNsdWRlICJQb3NpdGlvbi5o IgogI2luY2x1ZGUgIlRleHRHcmFudWxhcml0eS5oIgotI2luY2x1ZGUgIlZpc2libGVQb3NpdGlv bi5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLWNsYXNzIFBvc2l0aW9uOworY2xhc3MgVmlz aWJsZVBvc2l0aW9uOwogCiBjb25zdCBFQWZmaW5pdHkgU0VMX0RFRkFVTFRfQUZGSU5JVFkgPSBE T1dOU1RSRUFNOwogCkBAIC02Niw4ICs2Niw4IEBAIHB1YmxpYzoKICAgICBQb3NpdGlvbiBzdGFy dCgpIGNvbnN0IHsgcmV0dXJuIG1fc3RhcnQ7IH0KICAgICBQb3NpdGlvbiBlbmQoKSBjb25zdCB7 IHJldHVybiBtX2VuZDsgfQogICAgIAotICAgIFZpc2libGVQb3NpdGlvbiB2aXNpYmxlU3RhcnQo KSBjb25zdCB7IHJldHVybiBWaXNpYmxlUG9zaXRpb24obV9zdGFydCwgaXNSYW5nZSgpID8gRE9X TlNUUkVBTSA6IGFmZmluaXR5KCkpOyB9Ci0gICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVFbmQo KSBjb25zdCB7IHJldHVybiBWaXNpYmxlUG9zaXRpb24obV9lbmQsIGlzUmFuZ2UoKSA/IFVQU1RS RUFNIDogYWZmaW5pdHkoKSk7IH0KKyAgICBWaXNpYmxlUG9zaXRpb24gdmlzaWJsZVN0YXJ0KCkg Y29uc3Q7CisgICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVFbmQoKSBjb25zdDsKIAogICAgIGJv b2wgaXNOb25lKCkgY29uc3QgeyByZXR1cm4gc2VsZWN0aW9uVHlwZSgpID09IE5vU2VsZWN0aW9u OyB9CiAgICAgYm9vbCBpc0NhcmV0KCkgY29uc3QgeyByZXR1cm4gc2VsZWN0aW9uVHlwZSgpID09 IENhcmV0U2VsZWN0aW9uOyB9CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvbWFya3VwLmNw cCBiL1dlYkNvcmUvZWRpdGluZy9tYXJrdXAuY3BwCmluZGV4IDdjODRlOGYuLmY5Mjg3ZTggMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9tYXJrdXAuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGlu Zy9tYXJrdXAuY3BwCkBAIC01NCw2ICs1NCw3IEBACiAjaW5jbHVkZSAiUmFuZ2UuaCIKICNpbmNs dWRlICJWaXNpYmxlU2VsZWN0aW9uLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCisjaW5j bHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNs dWRlICJ2aXNpYmxlX3VuaXRzLmgiCiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaCBiL1dlYkNvcmUvcGFn ZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmgKaW5kZXggOTE0MWIzNi4uZTM5NDY5OSAxMDA2NDQKLS0t IGEvV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuaAorKysgYi9XZWJDb3JlL3BhZ2Uv QWNjZXNzaWJpbGl0eU9iamVjdC5oCkBAIC0zMiw2ICszMiw3IEBACiAKICNpbmNsdWRlICJWaXNp YmxlUG9zaXRpb24uaCIKICNpbmNsdWRlIDx3dGYvUGxhdGZvcm0uaD4KKyNpbmNsdWRlIDx3dGYv UmVmQ291bnRlZC5oPgogI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KICNpbmNsdWRlIDx3dGYvVmVj dG9yLmg+CiAKQEAgLTczLDcgKzc0LDkgQEAgY2xhc3MgQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBw ZXI7CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAorY2xhc3MgQXRvbWljU3RyaW5nOwogY2xhc3Mg QVhPYmplY3RDYWNoZTsKK2NsYXNzIERvY3VtZW50OwogY2xhc3MgRWxlbWVudDsKIGNsYXNzIEZy YW1lOwogY2xhc3MgRnJhbWVWaWV3OwpAQCAtODEsNiArODQsNyBAQCBjbGFzcyBIVE1MQW5jaG9y RWxlbWVudDsKIGNsYXNzIEhUTUxBcmVhRWxlbWVudDsKIGNsYXNzIEludFBvaW50OwogY2xhc3Mg SW50U2l6ZTsKK2NsYXNzIEtVUkw7CiBjbGFzcyBOb2RlOwogY2xhc3MgUmVuZGVyT2JqZWN0Owog Y2xhc3MgVmlzaWJsZVNlbGVjdGlvbjsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9BY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0LmggYi9XZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdC5oCmluZGV4IDUzNzBlYWMuLmQ2YTM5NTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9B Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmgKKysrIGIvV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxp dHlSZW5kZXJPYmplY3QuaApAQCAtNTMsNiArNTMsNyBAQCBjbGFzcyBSZW5kZXJUZXh0Q29udHJv bDsKIGNsYXNzIFJlbmRlclZpZXc7CiBjbGFzcyBWaXNpYmxlU2VsZWN0aW9uOwogY2xhc3MgU3Ry aW5nOworY2xhc3MgUXVhbGlmaWVkTmFtZTsKIGNsYXNzIFdpZGdldDsKICAgICAKIGNsYXNzIEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QgOiBwdWJsaWMgQWNjZXNzaWJpbGl0eU9iamVjdCB7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2UvRE9NU2VsZWN0aW9uLmNwcCBiL1dlYkNvcmUvcGFnZS9E T01TZWxlY3Rpb24uY3BwCmluZGV4IDg2ZmU5MTEuLjZhOWE4ZTkgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcGFnZS9ET01TZWxlY3Rpb24uY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9ET01TZWxlY3Rpb24u Y3BwCkBAIC0zOCw2ICszOCw3IEBACiAjaW5jbHVkZSAiUmFuZ2UuaCIKICNpbmNsdWRlICJTZWxl Y3Rpb25Db250cm9sbGVyLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCisjaW5jbHVkZSAi VmlzaWJsZVBvc2l0aW9uLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApkaWZmIC0tZ2l0IGEv V2ViQ29yZS9wYWdlL0RyYWdDb250cm9sbGVyLmNwcCBiL1dlYkNvcmUvcGFnZS9EcmFnQ29udHJv bGxlci5jcHAKaW5kZXggY2JhMTA5YS4uNTU4NjJlZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdl L0RyYWdDb250cm9sbGVyLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRHJhZ0NvbnRyb2xsZXIuY3Bw CkBAIC01OCw2ICs1OCw3IEBACiAjaW5jbHVkZSAiU2VsZWN0aW9uQ29udHJvbGxlci5oIgogI2lu Y2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgorI2luY2x1ZGUgIlZpc2libGVQ b3NpdGlvbi5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAibWFya3VwLmgi CiAjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CmRpZmYgLS1naXQgYS9XZWJDb3JlL3BhZ2Uv RnJhbWUuY3BwIGIvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcAppbmRleCBhZTRmMWI0Li4xMGYwYWRk IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCisrKyBiL1dlYkNvcmUvcGFnZS9G cmFtZS5jcHAKQEAgLTQxLDIxICs0MSwyMCBAQAogI2luY2x1ZGUgIkVkaXRpbmdUZXh0LmgiCiAj aW5jbHVkZSAiRWRpdG9yQ2xpZW50LmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgotI2luY2x1 ZGUgIkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZsb2F0UXVhZC5oIgorI2luY2x1ZGUg IkZvY3VzQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIkZyYW1lTG9hZGVyLmgiCiAjaW5jbHVkZSAi RnJhbWVMb2FkZXJDbGllbnQuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJH cmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRlICJIVE1MRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJI VE1MRm9ybUNvbnRyb2xFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTEZvcm1FbGVtZW50LmgiCiAj aW5jbHVkZSAiSFRNTEZyYW1lRWxlbWVudEJhc2UuaCIKLSNpbmNsdWRlICJIVE1MRm9ybUNvbnRy b2xFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiSFRNTFRhYmxl Q2VsbEVsZW1lbnQuaCIKICNpbmNsdWRlICJIaXRUZXN0UmVzdWx0LmgiCiAjaW5jbHVkZSAiTG9n Z2luZy5oIgotI2luY2x1ZGUgIm1hcmt1cC5oIgogI2luY2x1ZGUgIk1lZGlhRmVhdHVyZU5hbWVz LmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yLmgiCiAjaW5jbHVkZSAiTm9kZUxpc3QuaCIKQEAgLTY2 LDExICs2NSwxMyBAQAogI2luY2x1ZGUgIlJlbmRlclRleHRDb250cm9sLmgiCiAjaW5jbHVkZSAi UmVuZGVyVGhlbWUuaCIKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisjaW5jbHVkZSAiU2NyaXB0 Q29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJh dG9yLmgiCiAjaW5jbHVkZSAiVGV4dFJlc291cmNlRGVjb2Rlci5oIgorI2luY2x1ZGUgIlZpc2li bGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlhNTE5hbWVzLmgiCi0jaW5jbHVkZSAiU2NyaXB0Q29u dHJvbGxlci5oIgorI2luY2x1ZGUgIm1hcmt1cC5oIgogI2luY2x1ZGUgIm5wcnVudGltZV9pbXBs LmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVk TGVha0NvdW50ZXIuaD4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9tYWMvRnJhbWVNYWMubW0g Yi9XZWJDb3JlL3BhZ2UvbWFjL0ZyYW1lTWFjLm1tCmluZGV4IGYzNjA1MTEuLmRlMjVkMDMgMTAw NjQ0Ci0tLSBhL1dlYkNvcmUvcGFnZS9tYWMvRnJhbWVNYWMubW0KKysrIGIvV2ViQ29yZS9wYWdl L21hYy9GcmFtZU1hYy5tbQpAQCAtNTMsNiArNTMsNyBAQAogI2ltcG9ydCAiU2Nyb2xsYmFyLmgi CiAjaW1wb3J0ICJTaW1wbGVGb250RGF0YS5oIgogI2ltcG9ydCAiVXNlclN0eWxlU2hlZXRMb2Fk ZXIuaCIKKyNpbXBvcnQgIlZpc2libGVQb3NpdGlvbi5oIgogI2ltcG9ydCAiV2ViQ29yZVZpZXdG YWN0b3J5LmgiCiAjaW1wb3J0ICJ2aXNpYmxlX3VuaXRzLmgiCiAKZGlmZiAtLWdpdCBhL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJs b2NrLmNwcAppbmRleCA1YzM0ZjA2Li43ZTlmNzNkIDEwMDY0NAotLS0gYS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2su Y3BwCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSAiUmVuZGVyVGhlbWUuaCIKICNpbmNsdWRl ICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiU2VsZWN0aW9uQ29udHJvbGxlci5oIgorI2luY2x1 ZGUgIlZpc2libGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAog dXNpbmcgbmFtZXNwYWNlIHN0ZDsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckJveC5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCmluZGV4IDJiYTE4MmUu LjBjYzc5MjYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAKKysr IGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtNDUsNiArNDUsNyBAQAogI2lu Y2x1ZGUgIlJlbmRlclRoZW1lLmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUg IlRyYW5zZm9ybVN0YXRlLmgiCisjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAjaW5jbHVk ZSA8YWxnb3JpdGhtPgogI2luY2x1ZGUgPG1hdGguaD4KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyVGV4dENvbnRyb2wuY3BwIGIvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy VGV4dENvbnRyb2wuY3BwCmluZGV4IDRjMzZiYjIuLmU3ZGI0MDkgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlclRleHRDb250cm9sLmNwcAorKysgYi9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUZXh0Q29udHJvbC5jcHAKQEAgLTM4LDYgKzM4LDcgQEAKICNpbmNsdWRlICJUZXh0 LmgiCiAjaW5jbHVkZSAiVGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmgiCiAjaW5jbHVkZSAiVGV4 dEl0ZXJhdG9yLmgiCisjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAKIHVzaW5nIG5hbWVz cGFjZSBzdGQ7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRDb250cm9sSW5u ZXJFbGVtZW50cy5jcHAgYi9XZWJDb3JlL3JlbmRlcmluZy9UZXh0Q29udHJvbElubmVyRWxlbWVu dHMuY3BwCmluZGV4IDYxZmJjNzguLjBlYmUzZDIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcmVuZGVy aW5nL1RleHRDb250cm9sSW5uZXJFbGVtZW50cy5jcHAKKysrIGIvV2ViQ29yZS9yZW5kZXJpbmcv VGV4dENvbnRyb2xJbm5lckVsZW1lbnRzLmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUg Ik1vdXNlRXZlbnQuaCIKICNpbmNsdWRlICJSZW5kZXJMYXllci5oIgogI2luY2x1ZGUgIlJlbmRl clRleHRDb250cm9sU2luZ2xlTGluZS5oIgorI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvc3ZnL1NWR1RleHRD b250ZW50RWxlbWVudC5jcHAgYi9XZWJDb3JlL3N2Zy9TVkdUZXh0Q29udGVudEVsZW1lbnQuY3Bw CmluZGV4IDhiMzRjMmMuLmI5NmJhMTYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvc3ZnL1NWR1RleHRD b250ZW50RWxlbWVudC5jcHAKKysrIGIvV2ViQ29yZS9zdmcvU1ZHVGV4dENvbnRlbnRFbGVtZW50 LmNwcApAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgIlNWR0xlbmd0aC5oIgogI2luY2x1ZGUg IlNWR0lubGluZVRleHRCb3guaCIKICNpbmNsdWRlICJTVkdOYW1lcy5oIgorI2luY2x1ZGUgIlZp c2libGVQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlhNTE5hbWVzLmgiCiAjaW5jbHVkZSA8d3RmL1N0 ZExpYkV4dHJhcy5oPgogCg== 28856 2009-03-23 09:49:32 -0700 2009-03-23 17:04:52 -0700 Rename Position::container to m_container and make it private Rename-Position-container-to-m_container-and-make-it-private.patch text/plain 7581 eric MGRkM2NhNWJmNTNiMDk5ZDQwNDdmYzQ4ZDNlYjg3MjQ5YjFjOGZjZQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBlODdhMjMyLi40NmVlNGVm IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMiw2ICsyLDQyIEBACiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCiAK KyAgICAgICAgUmVuYW1lIFBvc2l0aW9uOjpjb250YWluZXIgdG8gbV9jb250YWluZXIgYW5kIG1h a2UgaXQgcHJpdmF0ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjQ3NjAKKworICAgICAgICBNb3JlIGNvZGUgY2xlYW51cCBmb3IgUG9zaXRpb24uCisg ICAgICAgIAorICAgICAgICBDaGFuZ2UgYWxsIHVzZXMgb2YgbV9jb250YWluZXIgdG8gbm9kZSgp CisgICAgICAgIEV2ZW50dWFsbHkgbm9kZSgpIHNob3VsZCBjaGFuZ2UgdG8gYW5jaG9yTm9kZSgp IG9yIHNpbWlsYXIgdG8gZGVzaWduYXRlCisgICAgICAgIHRoYXQgaXQncyB0aGUgbm9kZSB0aGUg UG9zaXRpb24gaXMgYW5jaG9yZWQgdG8sIGJ1dCBub3QgbmVjZXNzYXJpbHkgdGhlCisgICAgICAg IGNvbnRhaW5lciBvZiB0aGUgcG9zaXRpb24gKGl0IGNvdWxkIGJlIHRoZSBiZWZvcmUvYWZ0ZXIg bmVpZ2hib3IpLgorICAgICAgICAKKyAgICAgICAgUmVtb3ZlIGFueSBjb2RlIHdoaWNoIHNldHMg bV9jb250YWluZXIsIGFuZCBjaGFuZ2UgaXQgdG8gY3JlYXRlIGEgbmV3CisgICAgICAgIFBvc2l0 aW9uIGluc3RlYWQuICAoU2xvd2x5IG1ha2luZyBQb3NpdGlvbnMgb2JqZWN0cyBpbW11dGFibGUp CisKKyAgICAgICAgKiBkb20vUG9zaXRpb24uY3BwOgorICAgICAgICAoV2ViQ29yZTo6c2VhcmNo QWhlYWRGb3JCZXR0ZXJNYXRjaCk6CisgICAgICAgICogZG9tL1Bvc2l0aW9uLmg6CisgICAgICAg IChXZWJDb3JlOjpQb3NpdGlvbjo6UG9zaXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRp b246Om5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246OmlzTnVsbCk6CisgICAgICAg IChXZWJDb3JlOjpQb3NpdGlvbjo6aXNOb3ROdWxsKToKKyAgICAgICAgKFdlYkNvcmU6Om9wZXJh dG9yPT0pOgorICAgICAgICAqIGRvbS9SYW5nZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSYW5n ZTo6Y3JlYXRlKToKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlOjpjb21wYXJlQm91bmRhcnlQb2lu dHMpOgorICAgICAgICAqIGRvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaDoKKyAgICAgICAgKFdlYkNv cmU6OlJhbmdlQm91bmRhcnlQb2ludDo6Y29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlJh bmdlQm91bmRhcnlQb2ludDo6c2V0KToKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlQm91bmRhcnlQ b2ludDo6c2V0T2Zmc2V0KToKKyAgICAgICAgKFdlYkNvcmU6OlJhbmdlQm91bmRhcnlQb2ludDo6 c2V0VG9DaGlsZCk6CisgICAgICAgIChXZWJDb3JlOjpSYW5nZUJvdW5kYXJ5UG9pbnQ6OnNldFRv U3RhcnQpOgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VCb3VuZGFyeVBvaW50OjpzZXRUb0VuZCk6 CisKKzIwMDktMDMtMjMgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCiAgICAgICAgIFJlbW92ZSBQb3NpdGlvbjo6 Y2xlYXIoKSBhbmQgbWFrZSBWaXNpYmxlU2VsZWN0aW9uLmggbm90IGluY2x1ZGUgVmlzaWJsZVBv c2l0aW9uLmgKICAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTI0NzYwCiAgICAgICAgIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRpb24uY3BwIGIv V2ViQ29yZS9kb20vUG9zaXRpb24uY3BwCmluZGV4IDQ0MzJkMzkuLmIxNjQxNzAgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmNwcAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5j cHAKQEAgLTgwOSw5ICs4MDksOSBAQCBzdGF0aWMgSW5saW5lVGV4dEJveCogc2VhcmNoQWhlYWRG b3JCZXR0ZXJNYXRjaChSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogewogICAgIElubGluZVRleHRC b3gqIG1hdGNoID0gMDsKICAgICBpbnQgbWluT2Zmc2V0ID0gSU5UX01BWDsKLSAgICBSZW5kZXJC bG9jayogY29udGFpbmVyID0gcmVuZGVyZXItPmNvbnRhaW5pbmdCbG9jaygpOworICAgIFJlbmRl ckJsb2NrKiBtX2NvbnRhaW5lciA9IHJlbmRlcmVyLT5jb250YWluaW5nQmxvY2soKTsKICAgICBS ZW5kZXJPYmplY3QqIG5leHQgPSByZW5kZXJlcjsKLSAgICB3aGlsZSAoKG5leHQgPSBuZXh0LT5u ZXh0SW5QcmVPcmRlcihjb250YWluZXIpKSkgeworICAgIHdoaWxlICgobmV4dCA9IG5leHQtPm5l eHRJblByZU9yZGVyKG1fY29udGFpbmVyKSkpIHsKICAgICAgICAgaWYgKG5leHQtPmlzUmVuZGVy QmxvY2soKSkKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBpZiAobmV4dC0+aXNCUigpKQpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRpb24uaCBiL1dlYkNvcmUvZG9tL1Bvc2l0aW9u LmgKaW5kZXggMTA5ZTk3ZC4uYTUyYWViNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vUG9zaXRp b24uaAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oCkBAIC01MiwyMCArNTIsMjIgQEAgZW51 bSBQb3NpdGlvbk1vdmVUeXBlIHsKIAogY2xhc3MgUG9zaXRpb24gewogcHVibGljOgotICAgIFJl ZlB0cjxOb2RlPiBjb250YWluZXI7Ci0gICAgaW50IG1fb2Zmc2V0OwotCiAgICAgUG9zaXRpb24o KSA6IG1fb2Zmc2V0KDApIHsgfQotICAgIFBvc2l0aW9uKFBhc3NSZWZQdHI8Tm9kZT4gYywgaW50 IG8pIDogY29udGFpbmVyKGMpLCBtX29mZnNldChvKSB7IH0KKyAgICAKKyAgICAvLyBUaGlzIGNv bnN0cnVjdG9yIHNob3VsZCBiZSBwcml2YXRlCisgICAgUG9zaXRpb24oUGFzc1JlZlB0cjxOb2Rl PiBjLCBpbnQgbykKKyAgICAgICAgOiBtX2NvbnRhaW5lcihjKQorICAgICAgICAsIG1fb2Zmc2V0 KG8pCisgICAge30KIAotICAgIE5vZGUqIG5vZGUoKSBjb25zdCB7IHJldHVybiBjb250YWluZXIu Z2V0KCk7IH0KKyAgICBOb2RlKiBub2RlKCkgY29uc3QgeyByZXR1cm4gbV9jb250YWluZXIuZ2V0 KCk7IH0KIAogICAgIC8vIFJldHVybnMgbm9kZSgpIG9yIHRoZSBjbG9zZXN0IGVsZW1lbnQgYWNj ZXN0b3IKICAgICBFbGVtZW50KiBlbGVtZW50KCkgY29uc3Q7CiAgICAgRWxlbWVudCogZG9jdW1l bnRFbGVtZW50KCkgY29uc3Q7CiAKLSAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICFj b250YWluZXI7IH0KLSAgICBib29sIGlzTm90TnVsbCgpIGNvbnN0IHsgcmV0dXJuIGNvbnRhaW5l cjsgfQorICAgIGJvb2wgaXNOdWxsKCkgY29uc3QgeyByZXR1cm4gIW1fY29udGFpbmVyOyB9Cisg ICAgYm9vbCBpc05vdE51bGwoKSBjb25zdCB7IHJldHVybiBtX2NvbnRhaW5lcjsgfQogCiAgICAg UGFzc1JlZlB0cjxDU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRpb24+IGNvbXB1dGVkU3R5bGUoKSBj b25zdDsKIApAQCAtMTE4LDExICsxMjAsMTUgQEAgcHJpdmF0ZToKIAogICAgIFBvc2l0aW9uIHBy ZXZpb3VzQ2hhcmFjdGVyUG9zaXRpb24oRUFmZmluaXR5KSBjb25zdDsKICAgICBQb3NpdGlvbiBu ZXh0Q2hhcmFjdGVyUG9zaXRpb24oRUFmZmluaXR5KSBjb25zdDsKKyAgICAKKyAgICBSZWZQdHI8 Tm9kZT4gbV9jb250YWluZXI7CitwdWJsaWM6CisgICAgaW50IG1fb2Zmc2V0OyAvLyBGSVhNRTog VGhpcyBzaG91bGQgYmUgbWFkZSBwcml2YXRlLgogfTsKIAogaW5saW5lIGJvb2wgb3BlcmF0b3I9 PShjb25zdCBQb3NpdGlvbiYgYSwgY29uc3QgUG9zaXRpb24mIGIpCiB7Ci0gICAgcmV0dXJuIGEu Y29udGFpbmVyID09IGIuY29udGFpbmVyICYmIGEubV9vZmZzZXQgPT0gYi5tX29mZnNldDsKKyAg ICByZXR1cm4gYS5ub2RlKCkgPT0gYi5ub2RlKCkgJiYgYS5tX29mZnNldCA9PSBiLm1fb2Zmc2V0 OwogfQogCiBpbmxpbmUgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFBvc2l0aW9uJiBhLCBjb25zdCBQ b3NpdGlvbiYgYikKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1JhbmdlLmNwcCBiL1dlYkNvcmUv ZG9tL1JhbmdlLmNwcAppbmRleCA1OWYzNjhlLi44MDE0OWZmIDEwMDY0NAotLS0gYS9XZWJDb3Jl L2RvbS9SYW5nZS5jcHAKKysrIGIvV2ViQ29yZS9kb20vUmFuZ2UuY3BwCkBAIC04OSw3ICs4OSw3 IEBAIFBhc3NSZWZQdHI8UmFuZ2U+IFJhbmdlOjpjcmVhdGUoUGFzc1JlZlB0cjxEb2N1bWVudD4g b3duZXJEb2N1bWVudCwgUGFzc1JlZlB0cjxOCiAKIFBhc3NSZWZQdHI8UmFuZ2U+IFJhbmdlOjpj cmVhdGUoUGFzc1JlZlB0cjxEb2N1bWVudD4gb3duZXJEb2N1bWVudCwgY29uc3QgUG9zaXRpb24m IHN0YXJ0LCBjb25zdCBQb3NpdGlvbiYgZW5kKQogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcg UmFuZ2Uob3duZXJEb2N1bWVudCwgc3RhcnQuY29udGFpbmVyLmdldCgpLCBzdGFydC5tX29mZnNl dCwgZW5kLmNvbnRhaW5lci5nZXQoKSwgZW5kLm1fb2Zmc2V0KSk7CisgICAgcmV0dXJuIGFkb3B0 UmVmKG5ldyBSYW5nZShvd25lckRvY3VtZW50LCBzdGFydC5ub2RlKCksIHN0YXJ0Lm1fb2Zmc2V0 LCBlbmQubm9kZSgpLCBlbmQubV9vZmZzZXQpKTsKIH0KIAogUmFuZ2U6On5SYW5nZSgpCkBAIC01 MjcsNyArNTI3LDcgQEAgc2hvcnQgUmFuZ2U6OmNvbXBhcmVCb3VuZGFyeVBvaW50cyhOb2RlKiBj b250YWluZXJBLCBpbnQgb2Zmc2V0QSwgTm9kZSogY29udGFpbmUKIAogc2hvcnQgUmFuZ2U6OmNv bXBhcmVCb3VuZGFyeVBvaW50cyhjb25zdCBQb3NpdGlvbiYgYSwgY29uc3QgUG9zaXRpb24mIGIp CiB7Ci0gICAgcmV0dXJuIGNvbXBhcmVCb3VuZGFyeVBvaW50cyhhLmNvbnRhaW5lci5nZXQoKSwg YS5tX29mZnNldCwgYi5jb250YWluZXIuZ2V0KCksIGIubV9vZmZzZXQpOworICAgIHJldHVybiBj b21wYXJlQm91bmRhcnlQb2ludHMoYS5ub2RlKCksIGEubV9vZmZzZXQsIGIubm9kZSgpLCBiLm1f b2Zmc2V0KTsKIH0KIAogYm9vbCBSYW5nZTo6Ym91bmRhcnlQb2ludHNWYWxpZCgpIGNvbnN0CmRp ZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCBiL1dlYkNvcmUvZG9t L1JhbmdlQm91bmRhcnlQb2ludC5oCmluZGV4IDI4NmMxM2MuLjZhM2RmYzUgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvZG9tL1JhbmdlQm91bmRhcnlQb2ludC5oCisrKyBiL1dlYkNvcmUvZG9tL1Jhbmdl Qm91bmRhcnlQb2ludC5oCkBAIC03Miw3ICs3Miw3IEBAIGlubGluZSBSYW5nZUJvdW5kYXJ5UG9p bnQ6OlJhbmdlQm91bmRhcnlQb2ludChQYXNzUmVmUHRyPE5vZGU+IGNvbnRhaW5lcikKIAogaW5s aW5lIE5vZGUqIFJhbmdlQm91bmRhcnlQb2ludDo6Y29udGFpbmVyKCkgY29uc3QKIHsKLSAgICBy ZXR1cm4gbV9wb3NpdGlvbi5jb250YWluZXIuZ2V0KCk7CisgICAgcmV0dXJuIG1fcG9zaXRpb24u bm9kZSgpOwogfQogCiBpbmxpbmUgTm9kZSogUmFuZ2VCb3VuZGFyeVBvaW50OjpjaGlsZEJlZm9y ZSgpIGNvbnN0CkBAIC0xMDQsMTUgKzEwNCwxNCBAQCBpbmxpbmUgdm9pZCBSYW5nZUJvdW5kYXJ5 UG9pbnQ6OnNldChQYXNzUmVmUHRyPE5vZGU+IGNvbnRhaW5lciwgaW50IG9mZnNldCwgTm9kZQog ewogICAgIEFTU0VSVChvZmZzZXQgPj0gMCk7CiAgICAgQVNTRVJUKGNoaWxkQmVmb3JlID09IChv ZmZzZXQgPyBjb250YWluZXItPmNoaWxkTm9kZShvZmZzZXQgLSAxKSA6IDApKTsKLSAgICBtX3Bv c2l0aW9uLmNvbnRhaW5lciA9IGNvbnRhaW5lcjsKLSAgICBtX3Bvc2l0aW9uLm1fb2Zmc2V0ID0g b2Zmc2V0OworICAgIG1fcG9zaXRpb24gPSBQb3NpdGlvbihjb250YWluZXIsIG9mZnNldCk7CiAg ICAgbV9jaGlsZEJlZm9yZSA9IGNoaWxkQmVmb3JlOwogfQogCiBpbmxpbmUgdm9pZCBSYW5nZUJv dW5kYXJ5UG9pbnQ6OnNldE9mZnNldChpbnQgb2Zmc2V0KQogewotICAgIEFTU0VSVChtX3Bvc2l0 aW9uLmNvbnRhaW5lcik7Ci0gICAgQVNTRVJUKG1fcG9zaXRpb24uY29udGFpbmVyLT5vZmZzZXRJ bkNoYXJhY3RlcnMoKSk7CisgICAgQVNTRVJUKG1fcG9zaXRpb24ubm9kZSgpKTsKKyAgICBBU1NF UlQobV9wb3NpdGlvbi5ub2RlKCktPm9mZnNldEluQ2hhcmFjdGVycygpKTsKICAgICBBU1NFUlQo bV9wb3NpdGlvbi5tX29mZnNldCA+PSAwKTsKICAgICBBU1NFUlQoIW1fY2hpbGRCZWZvcmUpOwog ICAgIG1fcG9zaXRpb24ubV9vZmZzZXQgPSBvZmZzZXQ7CkBAIC0xMjIsMjkgKzEyMSwyNiBAQCBp bmxpbmUgdm9pZCBSYW5nZUJvdW5kYXJ5UG9pbnQ6OnNldFRvQ2hpbGQoTm9kZSogY2hpbGQpCiB7 CiAgICAgQVNTRVJUKGNoaWxkKTsKICAgICBBU1NFUlQoY2hpbGQtPnBhcmVudE5vZGUoKSk7Ci0g ICAgbV9wb3NpdGlvbi5jb250YWluZXIgPSBjaGlsZC0+cGFyZW50Tm9kZSgpOwogICAgIG1fY2hp bGRCZWZvcmUgPSBjaGlsZC0+cHJldmlvdXNTaWJsaW5nKCk7Ci0gICAgbV9wb3NpdGlvbi5tX29m ZnNldCA9IG1fY2hpbGRCZWZvcmUgPyBpbnZhbGlkT2Zmc2V0IDogMDsKKyAgICBtX3Bvc2l0aW9u ID0gUG9zaXRpb24oY2hpbGQtPnBhcmVudE5vZGUoKSwgbV9jaGlsZEJlZm9yZSA/IGludmFsaWRP ZmZzZXQgOiAwKTsKIH0KIAogaW5saW5lIHZvaWQgUmFuZ2VCb3VuZGFyeVBvaW50OjpzZXRUb1N0 YXJ0KFBhc3NSZWZQdHI8Tm9kZT4gY29udGFpbmVyKQogewogICAgIEFTU0VSVChjb250YWluZXIp OwotICAgIG1fcG9zaXRpb24uY29udGFpbmVyID0gY29udGFpbmVyOwotICAgIG1fcG9zaXRpb24u bV9vZmZzZXQgPSAwOworICAgIG1fcG9zaXRpb24gPSBmaXJzdERlZXBFZGl0aW5nUG9zaXRpb25G b3JOb2RlKGNvbnRhaW5lcik7CiAgICAgbV9jaGlsZEJlZm9yZSA9IDA7CiB9CiAKIGlubGluZSB2 b2lkIFJhbmdlQm91bmRhcnlQb2ludDo6c2V0VG9FbmQoUGFzc1JlZlB0cjxOb2RlPiBjb250YWlu ZXIpCiB7CiAgICAgQVNTRVJUKGNvbnRhaW5lcik7Ci0gICAgbV9wb3NpdGlvbi5jb250YWluZXIg PSBjb250YWluZXI7Ci0gICAgaWYgKG1fcG9zaXRpb24uY29udGFpbmVyLT5vZmZzZXRJbkNoYXJh Y3RlcnMoKSkgewotICAgICAgICBtX3Bvc2l0aW9uLm1fb2Zmc2V0ID0gbV9wb3NpdGlvbi5jb250 YWluZXItPm1heENoYXJhY3Rlck9mZnNldCgpOworICAgIGlmIChjb250YWluZXItPm9mZnNldElu Q2hhcmFjdGVycygpKSB7CisgICAgICAgIG1fcG9zaXRpb24gPSBQb3NpdGlvbihjb250YWluZXIs IGNvbnRhaW5lci0+bWF4Q2hhcmFjdGVyT2Zmc2V0KCkpOwogICAgICAgICBtX2NoaWxkQmVmb3Jl ID0gMDsKICAgICB9IGVsc2UgewotICAgICAgICBtX2NoaWxkQmVmb3JlID0gbV9wb3NpdGlvbi5j b250YWluZXItPmxhc3RDaGlsZCgpOwotICAgICAgICBtX3Bvc2l0aW9uLm1fb2Zmc2V0ID0gbV9j aGlsZEJlZm9yZSA/IGludmFsaWRPZmZzZXQgOiAwOworICAgICAgICBtX2NoaWxkQmVmb3JlID0g Y29udGFpbmVyLT5sYXN0Q2hpbGQoKTsKKyAgICAgICAgbV9wb3NpdGlvbiA9IFBvc2l0aW9uKGNv bnRhaW5lciwgbV9jaGlsZEJlZm9yZSA/IGludmFsaWRPZmZzZXQgOiAwKTsKICAgICB9CiB9CiAK 28870 2009-03-23 15:32:20 -0700 2009-03-23 15:32:20 -0700 Stab at PassPosition, does not compile Stab-at-PassPosition-does-not-compile.patch text/plain 22219 eric YzhhNDNiYjM0YzFlMzc2OTRkMDM3NjJhMmVkNDQ5ZWI1MDE0ZTc5OApkaWZmIC0tZ2l0IGEvSmF2 YVNjcmlwdENvcmUvd3RmL1Bhc3NSZWZQdHIuaCBiL0phdmFTY3JpcHRDb3JlL3d0Zi9QYXNzUmVm UHRyLmgKaW5kZXggYzFkYzMwOS4uZTJhNmY4ZiAxMDA2NDQKLS0tIGEvSmF2YVNjcmlwdENvcmUv d3RmL1Bhc3NSZWZQdHIuaAorKysgYi9KYXZhU2NyaXB0Q29yZS93dGYvUGFzc1JlZlB0ci5oCkBA IC0zNSw4ICszNSw4IEBAIG5hbWVzcGFjZSBXVEYgewogICAgICAgICBQYXNzUmVmUHRyKFQqIHB0 cikgOiBtX3B0cihwdHIpIHsgaWYgKHB0cikgcHRyLT5yZWYoKTsgfQogICAgICAgICAvLyBJdCBz b21ld2hhdCBicmVha3MgdGhlIHR5cGUgc3lzdGVtIHRvIGFsbG93IHRyYW5zZmVyIG9mIG93bmVy c2hpcCBvdXQgb2YKICAgICAgICAgLy8gYSBjb25zdCBQYXNzUmVmUHRyLiBIb3dldmVyLCBpdCBt YWtlcyBpdCBtdWNoIGVhc2llciB0byB3b3JrIHdpdGggUGFzc1JlZlB0cgotICAgICAgICAvLyB0 ZW1wb3JhcmllcywgYW5kIHdlIGRvbid0IHJlYWxseSBoYXZlIGEgbmVlZCB0byB1c2UgcmVhbCBj b25zdCBQYXNzUmVmUHRycyAKLSAgICAgICAgLy8gYW55d2F5LgorICAgICAgICAvLyB0ZW1wb3Jh cmllcyAodGVtcG9yYXJpZXMgYXJlIGNvbnN0IHJlZmVyZW5jZXMsIGFuZCB3aWxsIG5vdCBtYXRj aCBub24tY29uc3QgcmVmZXJlbmNlIGNvbnN0cnVjdG9ycykKKyAgICAgICAgLy8gYW5kIHdlIGRv bid0IHJlYWxseSBoYXZlIGEgbmVlZCB0byB1c2UgcmVhbCBjb25zdCBQYXNzUmVmUHRycyBhbnl3 YXkuCiAgICAgICAgIFBhc3NSZWZQdHIoY29uc3QgUGFzc1JlZlB0ciYgbykgOiBtX3B0cihvLnJl bGVhc2VSZWYoKSkge30KICAgICAgICAgdGVtcGxhdGUgPHR5cGVuYW1lIFU+IFBhc3NSZWZQdHIo Y29uc3QgUGFzc1JlZlB0cjxVPiYgbykgOiBtX3B0cihvLnJlbGVhc2VSZWYoKSkgeyB9CiAKZGlm ZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvV2Vi Q29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZmVjYzgyOS4uMzlm ZGI0MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKKysrIGIvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTIx NjUsNiArMjE2NSw3IEBACiAJCUE3RDNDNTI0MEI1NzZCNEIwMDJDQTQ1MCAvKiBQYXN0ZWJvYXJk SGVscGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBB N0QzQzUyMzBCNTc2QjRCMDAyQ0E0NTAgLyogUGFzdGVib2FyZEhlbHBlci5oICovOyBzZXR0aW5n cyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUE3RDZCMzQ5MEY2MTEwNDUw MEI3OUZEMSAvKiBXb3JrZXJJbXBvcnRTY3JpcHRzQ2xpZW50LmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBN0Q2QjM0NzBGNjExMDQ1MDBCNzlGRDEgLyog V29ya2VySW1wb3J0U2NyaXB0c0NsaWVudC5oICovOyB9OwogCQlBN0Q2QjM0QTBGNjExMDQ1MDBC NzlGRDEgLyogV29ya2VySW1wb3J0U2NyaXB0c0NsaWVudC5jcHAgaW4gU291cmNlcyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBN0Q2QjM0ODBGNjExMDQ1MDBCNzlGRDEgLyog V29ya2VySW1wb3J0U2NyaXB0c0NsaWVudC5jcHAgKi87IH07CisJCUE4MDM4QjYzMEY3ODI5NkEw MDU0Q0E3QSAvKiBQYXNzUG9zaXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IEE4MDM4QjYxMEY3ODI5NkEwMDU0Q0E3QSAvKiBQYXNzUG9zaXRpb24u aCAqLzsgfTsKIAkJQTgwOUYxNDcwQjczNzkzQTAwMkU0RDdGIC8qIFJlbmRlclNWR0dyYWRpZW50 U3RvcC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQTgw OUYxNDUwQjczNzkzQTAwMkU0RDdGIC8qIFJlbmRlclNWR0dyYWRpZW50U3RvcC5oICovOyB9Owog CQlBODA5RjE0ODBCNzM3OTNCMDAyRTREN0YgLyogUmVuZGVyU1ZHR3JhZGllbnRTdG9wLmNwcCBp biBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE4MDlGMTQ2MEI3 Mzc5M0EwMDJFNEQ3RiAvKiBSZW5kZXJTVkdHcmFkaWVudFN0b3AuY3BwICovOyB9OwogCQlBODA5 RjFBQTBCNzM3RkI2MDAyRTREN0YgLyogUmVuZGVyU1ZHSGlkZGVuQ29udGFpbmVyLmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBODA5RjFBODBCNzM3RkI2 MDAyRTREN0YgLyogUmVuZGVyU1ZHSGlkZGVuQ29udGFpbmVyLmggKi87IH07CkBAIC03MDk1LDYg KzcwOTYsNyBAQAogCQlBN0QzQzUyMzBCNTc2QjRCMDAyQ0E0NTAgLyogUGFzdGVib2FyZEhlbHBl ci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBQYXN0ZWJvYXJkSGVscGVyLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE3RDZCMzQ3MEY2MTEwNDUwMEI3OUZEMSAv KiBXb3JrZXJJbXBvcnRTY3JpcHRzQ2xpZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg bmFtZSA9IFdvcmtlckltcG9ydFNjcmlwdHNDbGllbnQuaDsgcGF0aCA9IHdvcmtlcnMvV29ya2Vy SW1wb3J0U2NyaXB0c0NsaWVudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBN0Q2 QjM0ODBGNjExMDQ1MDBCNzlGRDEgLyogV29ya2VySW1wb3J0U2NyaXB0c0NsaWVudC5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IG5hbWUgPSBXb3JrZXJJbXBvcnRTY3JpcHRzQ2xp ZW50LmNwcDsgcGF0aCA9IHdvcmtlcnMvV29ya2VySW1wb3J0U2NyaXB0c0NsaWVudC5jcHA7IHNv dXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUE4MDM4QjYxMEY3ODI5NkEwMDU0Q0E3QSAvKiBQ YXNzUG9zaXRpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gUGFzc1Bvc2l0 aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4MDlGMTQ1MEI3Mzc5M0EwMDJF NEQ3RiAvKiBSZW5kZXJTVkdHcmFkaWVudFN0b3AuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5o OyBwYXRoID0gUmVuZGVyU1ZHR3JhZGllbnRTdG9wLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7 IH07CiAJCUE4MDlGMTQ2MEI3Mzc5M0EwMDJFNEQ3RiAvKiBSZW5kZXJTVkdHcmFkaWVudFN0b3Au Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUmVuZGVyU1ZHR3JhZGll bnRTdG9wLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQTgwOUYxQTgwQjczN0ZC NjAwMkU0RDdGIC8qIFJlbmRlclNWR0hpZGRlbkNvbnRhaW5lci5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBSZW5kZXJTVkdIaWRkZW5Db250YWluZXIuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKQEAgLTE0NTgxLDYgKzE0NTgzLDcgQEAKIAkJCQkxQTBENTczNDBBNUM3 N0ZFMDA3RURENEMgLyogT3ZlcmZsb3dFdmVudC5jcHAgKi8sCiAJCQkJMUEwRDU3MzUwQTVDNzdG RTAwN0VERDRDIC8qIE92ZXJmbG93RXZlbnQuaCAqLywKIAkJCQkxQTBENTczODBBNUM3ODEyMDA3 RURENEMgLyogT3ZlcmZsb3dFdmVudC5pZGwgKi8sCisJCQkJQTgwMzhCNjEwRjc4Mjk2QTAwNTRD QTdBIC8qIFBhc3NQb3NpdGlvbi5oICovLAogCQkJCUJFOTFGQzhDMDYxMzM2NjYwMDVFMzc5MCAv KiBQb3NpdGlvbi5jcHAgKi8sCiAJCQkJQkU5MUZDOEIwNjEzMzY2NjAwNUUzNzkwIC8qIFBvc2l0 aW9uLmggKi8sCiAJCQkJMzc5MTlDMjEwQjdEMTg4NjAwQTU2OTk4IC8qIFBvc2l0aW9uSXRlcmF0 b3IuY3BwICovLApAQCAtMTY5MDksNiArMTY5MTIsNyBAQAogCQkJCUZFNkZENDg4MEY2NzZFNTcw MDA5Mjg3MyAvKiBDb29yZGluYXRlcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRkU2RkQ0OEUwRjY3 NkU5MzAwMDkyODczIC8qIEpTQ29vcmRpbmF0ZXMuaCBpbiBIZWFkZXJzICovLAogCQkJCTFDNjNB MjQ4MEY3MTY0NjYwMEMwOUQ1QSAvKiBSdW5Mb29wVGltZXIuaCBpbiBIZWFkZXJzICovLAorCQkJ CUE4MDM4QjYzMEY3ODI5NkEwMDU0Q0E3QSAvKiBQYXNzUG9zaXRpb24uaCBpbiBIZWFkZXJzICov LAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9 OwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRpb24uY3BwIGIvV2ViQ29yZS9kb20vUG9z aXRpb24uY3BwCmluZGV4IDg3MDQ4NDUuLjI1ZTY3ZGQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9t L1Bvc2l0aW9uLmNwcAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5jcHAKQEAgLTMwLDYgKzMw LDcgQEAKICNpbmNsdWRlICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiQ2hhcmFjdGVyTmFtZXMuaCIK ICNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVk ZSAiUG9zaXRpb25JdGVyYXRvci5oIgogI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCiAjaW5jbHVk ZSAiVGV4dC5oIgpAQCAtNzMsNiArNzQsMjEgQEAgc3RhdGljIE5vZGUqIHByZXZpb3VzUmVuZGVy ZWRFZGl0YWJsZShOb2RlKiBub2RlKQogICAgIHJldHVybiAwOwogfQogCitQb3NpdGlvbjo6UG9z aXRpb24oY29uc3QgUGFzc1Bvc2l0aW9uJiBwYXNzUG9zaXRpb24pCit7CisgICAgUGFzc1Bvc2l0 aW9uJiBvdGhlciA9IGNvbnN0X2Nhc3Q8UGFzc1Bvc2l0aW9uJj4ocGFzc1Bvc2l0aW9uKTsKKyAg ICBjb250YWluZXIgPSBvdGhlci5yZWxlYXNlQW5jaG9yTm9kZSgpOworICAgIG1fb2Zmc2V0ID0g b3RoZXIub2Zmc2V0KCk7CisgICAgb3RoZXIuY2xlYXIoKTsKK30KKworUGFzc1Bvc2l0aW9uIFBv c2l0aW9uOjpyZWxlYXNlKCkKK3sKKyAgICBpbnQgb2Zmc2V0ID0gbV9vZmZzZXQ7CisgICAgbV9v ZmZzZXQgPSAwOworICAgIHJldHVybiBQYXNzUG9zaXRpb24oY29udGFpbmVyLnJlbGVhc2UoKSwg b2Zmc2V0KTsKK30KKwogRWxlbWVudCogUG9zaXRpb246OmRvY3VtZW50RWxlbWVudCgpIGNvbnN0 CiB7CiAgICAgaWYgKE5vZGUqIG4gPSBub2RlKCkpCkBAIC0yMzQsNyArMjUwLDcgQEAgaW50IFBv c2l0aW9uOjpyZW5kZXJlZE9mZnNldCgpIGNvbnN0CiB9CiAKIC8vIHJldHVybiBmaXJzdCBwcmVj ZWRpbmcgRE9NIHBvc2l0aW9uIHJlbmRlcmVkIGF0IGEgZGlmZmVyZW50IGxvY2F0aW9uLCBvciAi dGhpcyIKLVBvc2l0aW9uIFBvc2l0aW9uOjpwcmV2aW91c0NoYXJhY3RlclBvc2l0aW9uKEVBZmZp bml0eSBhZmZpbml0eSkgY29uc3QKK1Bhc3NQb3NpdGlvbiBQb3NpdGlvbjo6cHJldmlvdXNDaGFy YWN0ZXJQb3NpdGlvbihFQWZmaW5pdHkgYWZmaW5pdHkpIGNvbnN0CiB7CiAgICAgaWYgKGlzTnVs bCgpKQogICAgICAgICByZXR1cm4gUG9zaXRpb24oKTsKQEAgLTI2Miw3ICsyNzgsNyBAQCBQb3Np dGlvbiBQb3NpdGlvbjo6cHJldmlvdXNDaGFyYWN0ZXJQb3NpdGlvbihFQWZmaW5pdHkgYWZmaW5p dHkpIGNvbnN0CiB9CiAKIC8vIHJldHVybiBmaXJzdCBmb2xsb3dpbmcgcG9zaXRpb24gcmVuZGVy ZWQgYXQgYSBkaWZmZXJlbnQgbG9jYXRpb24sIG9yICJ0aGlzIgotUG9zaXRpb24gUG9zaXRpb246 Om5leHRDaGFyYWN0ZXJQb3NpdGlvbihFQWZmaW5pdHkgYWZmaW5pdHkpIGNvbnN0CitQYXNzUG9z aXRpb24gUG9zaXRpb246Om5leHRDaGFyYWN0ZXJQb3NpdGlvbihFQWZmaW5pdHkgYWZmaW5pdHkp IGNvbnN0CiB7CiAgICAgaWYgKGlzTnVsbCgpKQogICAgICAgICByZXR1cm4gUG9zaXRpb24oKTsK QEAgLTc0Niw3ICs3NjIsNyBAQCBib29sIFBvc2l0aW9uOjpyZW5kZXJzSW5EaWZmZXJlbnRQb3Np dGlvbihjb25zdCBQb3NpdGlvbiAmcG9zKSBjb25zdAogfQogCiAvLyBUaGlzIGFzc3VtZXMgdGhh dCBpdCBzdGFydHMgaW4gZWRpdGFibGUgY29udGVudC4KLVBvc2l0aW9uIFBvc2l0aW9uOjpsZWFk aW5nV2hpdGVzcGFjZVBvc2l0aW9uKEVBZmZpbml0eSBhZmZpbml0eSwgYm9vbCBjb25zaWRlck5v bkNvbGxhcHNpYmxlV2hpdGVzcGFjZSkgY29uc3QKK1Bhc3NQb3NpdGlvbiBQb3NpdGlvbjo6bGVh ZGluZ1doaXRlc3BhY2VQb3NpdGlvbihFQWZmaW5pdHkgYWZmaW5pdHksIGJvb2wgY29uc2lkZXJO b25Db2xsYXBzaWJsZVdoaXRlc3BhY2UpIGNvbnN0CiB7CiAgICAgQVNTRVJUKGlzRWRpdGFibGVQ b3NpdGlvbigqdGhpcykpOwogICAgIGlmIChpc051bGwoKSkKQEAgLTc2OCw3ICs3ODQsNyBAQCBQ b3NpdGlvbiBQb3NpdGlvbjo6bGVhZGluZ1doaXRlc3BhY2VQb3NpdGlvbihFQWZmaW5pdHkgYWZm aW5pdHksIGJvb2wgY29uc2lkZXJObwogfQogCiAvLyBUaGlzIGFzc3VtZXMgdGhhdCBpdCBzdGFy dHMgaW4gZWRpdGFibGUgY29udGVudC4KLVBvc2l0aW9uIFBvc2l0aW9uOjp0cmFpbGluZ1doaXRl c3BhY2VQb3NpdGlvbihFQWZmaW5pdHksIGJvb2wgY29uc2lkZXJOb25Db2xsYXBzaWJsZVdoaXRl c3BhY2UpIGNvbnN0CitQYXNzUG9zaXRpb24gUG9zaXRpb246OnRyYWlsaW5nV2hpdGVzcGFjZVBv c2l0aW9uKEVBZmZpbml0eSwgYm9vbCBjb25zaWRlck5vbkNvbGxhcHNpYmxlV2hpdGVzcGFjZSkg Y29uc3QKIHsKICAgICBBU1NFUlQoaXNFZGl0YWJsZVBvc2l0aW9uKCp0aGlzKSk7CiAgICAgaWYg KGlzTnVsbCgpKQpAQCAtOTk4LDEyICsxMDE0LDEyIEBAIHZvaWQgUG9zaXRpb246OnNob3dUcmVl Rm9yVGhpcygpIGNvbnN0CiAKICNlbmRpZgogCi1Qb3NpdGlvbiBzdGFydFBvc2l0aW9uKGNvbnN0 IFJhbmdlKiByKQorUGFzc1Bvc2l0aW9uIHN0YXJ0UG9zaXRpb24oY29uc3QgUmFuZ2UqIHIpCiB7 CiAgICAgcmV0dXJuIHIgPyByLT5zdGFydFBvc2l0aW9uKCkgOiBQb3NpdGlvbigpOwogfQogCi1Q b3NpdGlvbiBlbmRQb3NpdGlvbihjb25zdCBSYW5nZSogcikKK1Bhc3NQb3NpdGlvbiBlbmRQb3Np dGlvbihjb25zdCBSYW5nZSogcikKIHsKICAgICByZXR1cm4gciA/IHItPmVuZFBvc2l0aW9uKCkg OiBQb3NpdGlvbigpOwogfQpAQCAtMTAxMSwxNCArMTAyNywxNCBAQCBQb3NpdGlvbiBlbmRQb3Np dGlvbihjb25zdCBSYW5nZSogcikKIC8vIE5PVEU6IGZpcnN0L2xhc3REZWVwRWRpdGluZ1Bvc2l0 aW9uRm9yTm9kZSBjYW4gcmV0dXJuICJlZGl0aW5nIHBvc2l0aW9ucyIgKGxpa2UgW2ltZywgMF0p CiAvLyBmb3IgZWxlbWVudHMgd2hpY2ggZWRpdGluZyAiaWdub3JlcyIuICB0aGUgcmVzdCBvZiB0 aGUgZWRpdGluZyBjb2RlIHdpbGwgdHJlYXQgW2ltZywgMF0KIC8vIGFzICJ0aGUgbGFzdCBwb3Np dGlvbiBiZWZvcmUgdGhlIGltZyIKLVBvc2l0aW9uIGZpcnN0RGVlcEVkaXRpbmdQb3NpdGlvbkZv ck5vZGUoTm9kZSogbm9kZSkKK1Bhc3NQb3NpdGlvbiBmaXJzdERlZXBFZGl0aW5nUG9zaXRpb25G b3JOb2RlKE5vZGUqIG5vZGUpCiB7Ci0gICAgcmV0dXJuIFBvc2l0aW9uKG5vZGUsIDApOworICAg IHJldHVybiBQYXNzUG9zaXRpb24obm9kZSwgMCk7CiB9CiAKLVBvc2l0aW9uIGxhc3REZWVwRWRp dGluZ1Bvc2l0aW9uRm9yTm9kZShOb2RlKiBub2RlKQorUGFzc1Bvc2l0aW9uIGxhc3REZWVwRWRp dGluZ1Bvc2l0aW9uRm9yTm9kZShOb2RlKiBub2RlKQogewotICAgIHJldHVybiBQb3NpdGlvbihu b2RlLCBsYXN0T2Zmc2V0Rm9yRWRpdGluZyhub2RlKSk7CisgICAgcmV0dXJuIFBhc3NQb3NpdGlv bihub2RlLCBsYXN0T2Zmc2V0Rm9yRWRpdGluZyhub2RlKSk7CiB9CiAKIH0gLy8gbmFtZXNwYWNl IFdlYkNvcmUKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmggYi9XZWJDb3JlL2Rv bS9Qb3NpdGlvbi5oCmluZGV4IGI3NDA3NjQuLmI3ZjRkNWUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZG9tL1Bvc2l0aW9uLmgKKysrIGIvV2ViQ29yZS9kb20vUG9zaXRpb24uaApAQCAtMzcsNiArMzcs NyBAQCBjbGFzcyBDU1NDb21wdXRlZFN0eWxlRGVjbGFyYXRpb247CiBjbGFzcyBFbGVtZW50Owog Y2xhc3MgSW5saW5lQm94OwogY2xhc3MgTm9kZTsKK2NsYXNzIFBhc3NQb3NpdGlvbjsKIGNsYXNz IFJhbmdlOwogY2xhc3MgUmVuZGVyT2JqZWN0OwogCkBAIC01OCw2ICs1OSwxMCBAQCBwdWJsaWM6 CiAgICAgUG9zaXRpb24oKSA6IG1fb2Zmc2V0KDApIHsgfQogICAgIFBvc2l0aW9uKFBhc3NSZWZQ dHI8Tm9kZT4gYywgaW50IG8pIDogY29udGFpbmVyKGMpLCBtX29mZnNldChvKSB7IH0KIAorICAg IC8vIHNlZSBjb21tZW50IGluIFBhc3NSZWZQdHIuaCBmb3Igd2h5IHRoaXMgdGFrZXMgY29uc3Qg cmVmZXJlbmNlIChhbmQgdGh1cyBzb3J0YSBicmVha3MgdGhlIHR5cGUgc3lzdGVtKQorICAgIFBv c2l0aW9uKGNvbnN0IFBhc3NQb3NpdGlvbiYpOworCisgICAgUGFzc1Bvc2l0aW9uIHJlbGVhc2Uo KTsKICAgICB2b2lkIGNsZWFyKCkgeyBjb250YWluZXIuY2xlYXIoKTsgbV9vZmZzZXQgPSAwOyB9 CiAKICAgICBOb2RlKiBub2RlKCkgY29uc3QgeyByZXR1cm4gY29udGFpbmVyLmdldCgpOyB9CkBA IC04OCwxMiArOTMsMTIgQEAgcHVibGljOgogCiAgICAgLy8gRklYTUU6IE1ha2UgdGhlc2Ugbm9u LW1lbWJlciBmdW5jdGlvbnMgYW5kIHB1dCB0aGVtIHNvbWV3aGVyZSBpbiB0aGUgZWRpdGluZyBk aXJlY3RvcnkuCiAgICAgLy8gVGhlc2UgYXJlbid0IHJlYWxseSBiYXNpYyAicG9zaXRpb24iIG9w ZXJhdGlvbnMuIE1vcmUgaGlnaCBsZXZlbCBlZGl0aW5nIGhlbHBlciBmdW5jdGlvbnMuCi0gICAg UG9zaXRpb24gbGVhZGluZ1doaXRlc3BhY2VQb3NpdGlvbihFQWZmaW5pdHksIGJvb2wgY29uc2lk ZXJOb25Db2xsYXBzaWJsZVdoaXRlc3BhY2UgPSBmYWxzZSkgY29uc3Q7Ci0gICAgUG9zaXRpb24g dHJhaWxpbmdXaGl0ZXNwYWNlUG9zaXRpb24oRUFmZmluaXR5LCBib29sIGNvbnNpZGVyTm9uQ29s bGFwc2libGVXaGl0ZXNwYWNlID0gZmFsc2UpIGNvbnN0OworICAgIFBhc3NQb3NpdGlvbiBsZWFk aW5nV2hpdGVzcGFjZVBvc2l0aW9uKEVBZmZpbml0eSwgYm9vbCBjb25zaWRlck5vbkNvbGxhcHNp YmxlV2hpdGVzcGFjZSA9IGZhbHNlKSBjb25zdDsKKyAgICBQYXNzUG9zaXRpb24gdHJhaWxpbmdX aGl0ZXNwYWNlUG9zaXRpb24oRUFmZmluaXR5LCBib29sIGNvbnNpZGVyTm9uQ29sbGFwc2libGVX aGl0ZXNwYWNlID0gZmFsc2UpIGNvbnN0OwogICAgIAogICAgIC8vIFRoZXNlIHJldHVybiB1c2Vm dWwgdmlzdWFsbHkgZXF1aXZhbGVudCBwb3NpdGlvbnMuCi0gICAgUG9zaXRpb24gdXBzdHJlYW0o KSBjb25zdDsKLSAgICBQb3NpdGlvbiBkb3duc3RyZWFtKCkgY29uc3Q7CisgICAgUGFzc1Bvc2l0 aW9uIHVwc3RyZWFtKCkgY29uc3Q7CisgICAgUGFzc1Bvc2l0aW9uIGRvd25zdHJlYW0oKSBjb25z dDsKICAgICAKICAgICBib29sIGlzQ2FuZGlkYXRlKCkgY29uc3Q7CiAgICAgYm9vbCBpblJlbmRl cmVkVGV4dCgpIGNvbnN0OwpAQCAtMTE2LDggKzEyMSw4IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAg ICAgaW50IHJlbmRlcmVkT2Zmc2V0KCkgY29uc3Q7CiAKLSAgICBQb3NpdGlvbiBwcmV2aW91c0No YXJhY3RlclBvc2l0aW9uKEVBZmZpbml0eSkgY29uc3Q7Ci0gICAgUG9zaXRpb24gbmV4dENoYXJh Y3RlclBvc2l0aW9uKEVBZmZpbml0eSkgY29uc3Q7CisgICAgUGFzc1Bvc2l0aW9uIHByZXZpb3Vz Q2hhcmFjdGVyUG9zaXRpb24oRUFmZmluaXR5KSBjb25zdDsKKyAgICBQYXNzUG9zaXRpb24gbmV4 dENoYXJhY3RlclBvc2l0aW9uKEVBZmZpbml0eSkgY29uc3Q7CiB9OwogCiBpbmxpbmUgYm9vbCBv cGVyYXRvcj09KGNvbnN0IFBvc2l0aW9uJiBhLCBjb25zdCBQb3NpdGlvbiYgYikKQEAgLTEzMCwx NCArMTM1LDE0IEBAIGlubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgUG9zaXRpb24mIGEsIGNv bnN0IFBvc2l0aW9uJiBiKQogICAgIHJldHVybiAhKGEgPT0gYik7CiB9CiAKLVBvc2l0aW9uIHN0 YXJ0UG9zaXRpb24oY29uc3QgUmFuZ2UqKTsKLVBvc2l0aW9uIGVuZFBvc2l0aW9uKGNvbnN0IFJh bmdlKik7CitQYXNzUG9zaXRpb24gc3RhcnRQb3NpdGlvbihjb25zdCBSYW5nZSopOworUGFzc1Bv c2l0aW9uIGVuZFBvc2l0aW9uKGNvbnN0IFJhbmdlKik7CiAKIC8vIE5PVEU6IGZpcnN0L2xhc3RE ZWVwRWRpdGluZ1Bvc2l0aW9uRm9yTm9kZSBjYW4gcmV0dXJuICJlZGl0aW5nIHBvc2l0aW9ucyIg KGxpa2UgW2ltZywgMF0pCiAvLyBmb3IgZWxlbWVudHMgd2hpY2ggZWRpdGluZyAiaWdub3JlcyIu ICB0aGUgcmVzdCBvZiB0aGUgZWRpdGluZyBjb2RlIHdpbGwgdHJlYXQgW2ltZywgMF0KIC8vIGFz ICJ0aGUgbGFzdCBwb3NpdGlvbiBiZWZvcmUgdGhlIGltZyIKLVBvc2l0aW9uIGZpcnN0RGVlcEVk aXRpbmdQb3NpdGlvbkZvck5vZGUoTm9kZSopOwotUG9zaXRpb24gbGFzdERlZXBFZGl0aW5nUG9z aXRpb25Gb3JOb2RlKE5vZGUqKTsKK1Bhc3NQb3NpdGlvbiBmaXJzdERlZXBFZGl0aW5nUG9zaXRp b25Gb3JOb2RlKE5vZGUqKTsKK1Bhc3NQb3NpdGlvbiBsYXN0RGVlcEVkaXRpbmdQb3NpdGlvbkZv ck5vZGUoTm9kZSopOwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKZGlmZiAtLWdpdCBhL1dl YkNvcmUvZG9tL1Bvc2l0aW9uSXRlcmF0b3IuY3BwIGIvV2ViQ29yZS9kb20vUG9zaXRpb25JdGVy YXRvci5jcHAKaW5kZXggYjI2ZGFkNy4uN2IwMTIxMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20v UG9zaXRpb25JdGVyYXRvci5jcHAKKysrIGIvV2ViQ29yZS9kb20vUG9zaXRpb25JdGVyYXRvci5j cHAKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJQb3NpdGlvbkl0ZXJhdG9yLmgiCiAKICNp bmNsdWRlICJOb2RlLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiUmVu ZGVyQmxvY2suaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgogCmRpZmYgLS1naXQgYS9XZWJD b3JlL2RvbS9SYW5nZS5jcHAgYi9XZWJDb3JlL2RvbS9SYW5nZS5jcHAKaW5kZXggNTlmMzY4ZS4u MGJkOGM0OCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vUmFuZ2UuY3BwCisrKyBiL1dlYkNvcmUv ZG9tL1JhbmdlLmNwcApAQCAtMjgsNiArMjgsNyBAQAogI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNp bmNsdWRlICJEb2N1bWVudEZyYWdtZW50LmgiCiAjaW5jbHVkZSAiTm9kZVdpdGhJbmRleC5oIgor I2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlByb2Nlc3NpbmdJbnN0cnVjdGlv bi5oIgogI2luY2x1ZGUgIlRleHQuaCIKICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKZGlmZiAt LWdpdCBhL1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAgYi9XZWJDb3JlL2Vk aXRpbmcvQXBwbHlTdHlsZUNvbW1hbmQuY3BwCmluZGV4IGViMzEyNTQuLjFmNjg3MmEgMTAwNjQ0 Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9BcHBseVN0eWxlQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29y ZS9lZGl0aW5nL0FwcGx5U3R5bGVDb21tYW5kLmNwcApAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1 ZGUgIkhUTUxJbnRlcmNoYW5nZS5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUg Ik5vZGVMaXN0LmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiUmFuZ2Uu aCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3QuaCIKICNpbmNsdWRlICJUZXh0LmgiCmRpZmYgLS1n aXQgYS9XZWJDb3JlL2VkaXRpbmcvQnJlYWtCbG9ja3F1b3RlQ29tbWFuZC5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvQnJlYWtCbG9ja3F1b3RlQ29tbWFuZC5jcHAKaW5kZXggMmE1MTNhNS4uZWFjNDhk ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0JyZWFrQmxvY2txdW90ZUNvbW1hbmQuY3Bw CisrKyBiL1dlYkNvcmUvZWRpdGluZy9CcmVha0Jsb2NrcXVvdGVDb21tYW5kLmNwcApAQCAtMjgs MTAgKzI4LDExIEBACiAKICNpbmNsdWRlICJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCisjaW5jbHVkZSAiUmVuZGVyTGlzdEl0ZW0u aCIKICNpbmNsdWRlICJUZXh0LmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAjaW5j bHVkZSAiaHRtbGVkaXRpbmcuaCIKLSNpbmNsdWRlICJSZW5kZXJMaXN0SXRlbS5oIgogCiBuYW1l c3BhY2UgV2ViQ29yZSB7CiAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVF ZGl0Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3Bw CmluZGV4IDkwNTI1ODIuLjZlZDYxYWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9Db21w b3NpdGVFZGl0Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRD b21tYW5kLmNwcApAQCAtNDYsNiArNDYsNyBAQAogI2luY2x1ZGUgIkluc2VydFRleHRDb21tYW5k LmgiCiAjaW5jbHVkZSAiSm9pblRleHROb2Rlc0NvbW1hbmQuaCIKICNpbmNsdWRlICJNZXJnZUlk ZW50aWNhbEVsZW1lbnRzQ29tbWFuZC5oIgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2lu Y2x1ZGUgIlJhbmdlLmgiCiAjaW5jbHVkZSAiUmVtb3ZlQ1NTUHJvcGVydHlDb21tYW5kLmgiCiAj aW5jbHVkZSAiUmVtb3ZlTm9kZUNvbW1hbmQuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9EZWxldGVTZWxlY3Rpb25Db21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxl Y3Rpb25Db21tYW5kLmNwcAppbmRleCAwOTI4OGVlLi42Y2ZlNjllIDEwMDY0NAotLS0gYS9XZWJD b3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0 aW5nL0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVk ZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCiAjaW5jbHVk ZSAiSFRNTE5hbWVzLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAibWFy a3VwLmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFibGVDZWxsLmgiCiAjaW5jbHVkZSAiUmVwbGFjZVNl bGVjdGlvbkNvbW1hbmQuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9FZGl0b3IuY3Bw IGIvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKaW5kZXggYmEyN2I4Yy4uMTlkMDM2NyAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvci5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5n L0VkaXRvci5jcHAKQEAgLTUzLDYgKzUzLDcgQEAKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50Lmgi CiAjaW5jbHVkZSAiTW9kaWZ5U2VsZWN0aW9uTGlzdExldmVsLmgiCiAjaW5jbHVkZSAiUGFnZS5o IgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlBhc3RlYm9hcmQuaCIKICNp bmNsdWRlICJSZW1vdmVGb3JtYXRDb21tYW5kLmgiCiAjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9Gb3JtYXRCbG9ja0NvbW1hbmQuY3BwIGIvV2Vi Q29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKaW5kZXggODgxNjliZS4uOWI4NzU0 MyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKKysr IGIvV2ViQ29yZS9lZGl0aW5nL0Zvcm1hdEJsb2NrQ29tbWFuZC5jcHAKQEAgLTI0LDEyICsyNCwx NCBAQAogICovCiAKICNpbmNsdWRlICJjb25maWcuaCIKLSNpbmNsdWRlICJFbGVtZW50LmgiCiAj aW5jbHVkZSAiRm9ybWF0QmxvY2tDb21tYW5kLmgiCisKICNpbmNsdWRlICJEb2N1bWVudC5oIgot I2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCisjaW5jbHVkZSAiRWxlbWVudC5oIgogI2luY2x1ZGUg IkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCisjaW5jbHVkZSAiUGFzc1Bv c2l0aW9uLmgiCisjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJ2aXNpYmxlX3Vu aXRzLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGlu Zy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVu dENvbW1hbmQuY3BwCmluZGV4IDk0NDRiMTEuLmRiNDA1ZTAgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv ZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0lu ZGVudE91dGRlbnRDb21tYW5kLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIkhUTUxO YW1lcy5oIgogI2luY2x1ZGUgIkluc2VydExpbmVCcmVha0NvbW1hbmQuaCIKICNpbmNsdWRlICJJ bnNlcnRMaXN0Q29tbWFuZC5oIgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUg IlJhbmdlLmgiCiAjaW5jbHVkZSAiU3BsaXRFbGVtZW50Q29tbWFuZC5oIgogI2luY2x1ZGUgIlRl eHRJdGVyYXRvci5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpbmVCcmVh a0NvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpbmVCcmVha0NvbW1hbmQuY3Bw CmluZGV4IGE1YzU4OGQuLmYzM2VlYTEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNl cnRMaW5lQnJlYWtDb21tYW5kLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0TGluZUJy ZWFrQ29tbWFuZC5jcHAKQEAgLTMxLDYgKzMxLDcgQEAKICNpbmNsdWRlICJFbGVtZW50LmgiCiAj aW5jbHVkZSAiRnJhbWUuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJQYXNz UG9zaXRpb24uaCIKICNpbmNsdWRlICJSYW5nZS5oIgogI2luY2x1ZGUgIlJlbmRlck9iamVjdC5o IgogI2luY2x1ZGUgIlRleHQuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRM aXN0Q29tbWFuZC5jcHAgYi9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0TGlzdENvbW1hbmQuY3BwCmlu ZGV4IGFhNDg3NjEuLmUyMjUxYzYgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRM aXN0Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydExpc3RDb21tYW5kLmNw cApAQCAtMjQsMTMgKzI0LDE1IEBACiAgKi8KIAogI2luY2x1ZGUgImNvbmZpZy5oIgotI2luY2x1 ZGUgIkVsZW1lbnQuaCIKICNpbmNsdWRlICJJbnNlcnRMaXN0Q29tbWFuZC5oIgorCiAjaW5jbHVk ZSAiRG9jdW1lbnRGcmFnbWVudC5oIgotI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCisjaW5jbHVk ZSAiRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTE5h bWVzLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9y LmgiCisjaW5jbHVkZSAiaHRtbGVkaXRpbmcuaCIKICNpbmNsdWRlICJ2aXNpYmxlX3VuaXRzLmgi CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbnNl cnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRQ YXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmNwcAppbmRleCBlZWI5MTRhLi5lZjc5ZWE1IDEwMDY0 NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5zZXJ0UGFyYWdyYXBoU2VwYXJhdG9yQ29tbWFuZC5j cHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQu Y3BwCkBAIC0yNiwxNiArMjYsMTcgQEAKICNpbmNsdWRlICJjb25maWcuaCIKICNpbmNsdWRlICJJ bnNlcnRQYXJhZ3JhcGhTZXBhcmF0b3JDb21tYW5kLmgiCiAKLSNpbmNsdWRlICJEb2N1bWVudC5o IgotI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJDU1NDb21wdXRlZFN0eWxlRGVjbGFy YXRpb24uaCIKICNpbmNsdWRlICJDU1NQcm9wZXJ0eU5hbWVzLmgiCi0jaW5jbHVkZSAiVGV4dC5o IgotI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCisjaW5jbHVkZSAiRG9jdW1lbnQuaCIKICNpbmNs dWRlICJIVE1MRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIklu c2VydExpbmVCcmVha0NvbW1hbmQuaCIKKyNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAi UGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCisjaW5jbHVkZSAiVGV4 dC5oIgorI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5o IgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0VGV4dENvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luc2VydFRleHRDb21tYW5kLmNw cAppbmRleCA1MmRhNWQwLi40MzI2ZDY0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5z ZXJ0VGV4dENvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbnNlcnRUZXh0Q29tbWFu ZC5jcHAKQEAgLTI2LDIwICsyNiwyMSBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUg Ikluc2VydFRleHRDb21tYW5kLmgiCiAKLSNpbmNsdWRlICJDaGFyYWN0ZXJOYW1lcy5oIgogI2lu Y2x1ZGUgIkNTU0NvbXB1dGVkU3R5bGVEZWNsYXJhdGlvbi5oIgogI2luY2x1ZGUgIkNTU011dGFi bGVTdHlsZURlY2xhcmF0aW9uLmgiCiAjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgorI2lu Y2x1ZGUgIkNoYXJhY3Rlck5hbWVzLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKLSNpbmNsdWRl ICJFbGVtZW50LmgiCiAjaW5jbHVkZSAiRWRpdGluZ1RleHQuaCIKICNpbmNsdWRlICJFZGl0b3Iu aCIKKyNpbmNsdWRlICJFbGVtZW50LmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKLSNpbmNsdWRlICJM b2dnaW5nLmgiCiAjaW5jbHVkZSAiSFRNTEludGVyY2hhbmdlLmgiCi0jaW5jbHVkZSAiaHRtbGVk aXRpbmcuaCIKKyNpbmNsdWRlICJMb2dnaW5nLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgi CiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9yLmgiCiAjaW5jbHVkZSAiVHlwaW5nQ29tbWFuZC5oIgor I2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgogCiBu YW1lc3BhY2UgV2ViQ29yZSB7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvUmVwbGFjZVNl bGVjdGlvbkNvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL1JlcGxhY2VTZWxlY3Rpb25Db21t YW5kLmNwcAppbmRleCBjN2Q2NjdlLi5iMGVlZmUzIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9SZXBs YWNlU2VsZWN0aW9uQ29tbWFuZC5jcHAKQEAgLTQzLDYgKzQzLDcgQEAKICNpbmNsdWRlICJIVE1M SW50ZXJjaGFuZ2UuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCiAjaW5jbHVkZSAi SFRNTE5hbWVzLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiU2VsZWN0 aW9uQ29udHJvbGxlci5oIgogI2luY2x1ZGUgIlNtYXJ0UmVwbGFjZS5oIgogI2luY2x1ZGUgIlRl eHRJdGVyYXRvci5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRy b2xsZXIuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4 IGQ2MDY4OTEuLjViZTMxNzggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25D b250cm9sbGVyLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5j cHAKQEAgLTQ1LDYgKzQ1LDcgQEAKICNpbmNsdWRlICJIaXRUZXN0UmVxdWVzdC5oIgogI2luY2x1 ZGUgIkhpdFRlc3RSZXN1bHQuaCIKICNpbmNsdWRlICJQYWdlLmgiCisjaW5jbHVkZSAiUGFzc1Bv c2l0aW9uLmgiCiAjaW5jbHVkZSAiUmFuZ2UuaCIKICNpbmNsdWRlICJSZW5kZXJUaGVtZS5oIgog I2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9UeXBp bmdDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9UeXBpbmdDb21tYW5kLmNwcAppbmRleCAx ZTFhNzMyLi4zZTUzNmRmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvVHlwaW5nQ29tbWFu ZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL1R5cGluZ0NvbW1hbmQuY3BwCkBAIC0zNiw2ICsz Niw3IEBACiAjaW5jbHVkZSAiSW5zZXJ0TGluZUJyZWFrQ29tbWFuZC5oIgogI2luY2x1ZGUgIklu c2VydFBhcmFncmFwaFNlcGFyYXRvckNvbW1hbmQuaCIKICNpbmNsdWRlICJJbnNlcnRUZXh0Q29t bWFuZC5oIgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlJlbmRlck9iamVj dC5oIgogI2luY2x1ZGUgIlNlbGVjdGlvbkNvbnRyb2xsZXIuaCIKICNpbmNsdWRlICJWaXNpYmxl UG9zaXRpb24uaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlUG9zaXRpb24u Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVQb3NpdGlvbi5jcHAKaW5kZXggZmY2MmVjZi4u MjQ1ZjMxNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVQb3NpdGlvbi5jcHAK KysrIGIvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVQb3NpdGlvbi5jcHAKQEAgLTMzLDYgKzMzLDcg QEAKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbmxpbmVUZXh0Qm94LmgiCiAj aW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUg IlJhbmdlLmgiCiAjaW5jbHVkZSAiVGV4dC5oIgogI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAgYi9XZWJDb3Jl L2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAKaW5kZXggMjc5YWRmMi4uYzM5YjQ5OCAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCisrKyBiL1dlYkNv cmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcApAQCAtMzEsNiArMzEsNyBAQAogI2luY2x1 ZGUgIkRvY3VtZW50LmgiCiAjaW5jbHVkZSAiRWxlbWVudC5oIgogI2luY2x1ZGUgImh0bWxlZGl0 aW5nLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiVGV4dEl0ZXJhdG9y LmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0 cy5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcCBiL1dlYkNv cmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAKaW5kZXggYWMzZTZmNy4uNTk3NjZlZCAxMDA2NDQK LS0tIGEvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcAorKysgYi9XZWJDb3JlL2VkaXRp bmcvaHRtbGVkaXRpbmcuY3BwCkBAIC0zNyw2ICszNyw3IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCiAjaW5jbHVkZSAiSFRNTE9MaXN0RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxVTGlzdEVs ZW1lbnQuaCIKKyNpbmNsdWRlICJQYXNzUG9zaXRpb24uaCIKICNpbmNsdWRlICJQb3NpdGlvbkl0 ZXJhdG9yLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSAiUmFuZ2UuaCIK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9tYXJrdXAuY3BwIGIvV2ViQ29yZS9lZGl0aW5n L21hcmt1cC5jcHAKaW5kZXggN2M4NGU4Zi4uZGM4NTJjZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9l ZGl0aW5nL21hcmt1cC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL21hcmt1cC5jcHAKQEAgLTQ5 LDYgKzQ5LDcgQEAKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbmxpbmVUZXh0 Qm94LmgiCiAjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgog I2luY2x1ZGUgIlByb2Nlc3NpbmdJbnN0cnVjdGlvbi5oIgogI2luY2x1ZGUgIlF1YWxpZmllZE5h bWUuaCIKICNpbmNsdWRlICJSYW5nZS5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL3Zp c2libGVfdW5pdHMuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL3Zpc2libGVfdW5pdHMuY3BwCmluZGV4 IDFlOGIwNWIuLjcxZWYyNGEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy92aXNpYmxlX3Vu aXRzLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvdmlzaWJsZV91bml0cy5jcHAKQEAgLTI5LDYg KzI5LDcgQEAKICNpbmNsdWRlICJEb2N1bWVudC5oIgogI2luY2x1ZGUgIkVsZW1lbnQuaCIKICNp bmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJQYXNzUG9zaXRpb24uaCIKICNpbmNsdWRl ICJSZW5kZXJCbG9jay5oIgogI2luY2x1ZGUgIlJlbmRlckxheWVyLmgiCiAjaW5jbHVkZSAiVGV4 dEJvdW5kYXJpZXMuaCIKZGlmZiAtLWdpdCBhL1dlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2Jq ZWN0LmNwcCBiL1dlYkNvcmUvcGFnZS9BY2Nlc3NpYmlsaXR5T2JqZWN0LmNwcAppbmRleCA1YWQ1 NDA3Li45MDQ3ZDY5IDEwMDY0NAotLS0gYS9XZWJDb3JlL3BhZ2UvQWNjZXNzaWJpbGl0eU9iamVj dC5jcHAKKysrIGIvV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlPYmplY3QuY3BwCkBAIC00MCw2 ICs0MCw3IEBACiAjaW5jbHVkZSAiTm9kZUxpc3QuaCIKICNpbmNsdWRlICJOb3RJbXBsZW1lbnRl ZC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNsdWRlICJQYXNzUG9zaXRpb24uaCIKICNpbmNs dWRlICJSZW5kZXJJbWFnZS5oIgogI2luY2x1ZGUgIlJlbmRlckxpc3RNYXJrZXIuaCIKICNpbmNs dWRlICJSZW5kZXJNZW51TGlzdC5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0FjY2Vzc2li aWxpdHlSZW5kZXJPYmplY3QuY3BwIGIvV2ViQ29yZS9wYWdlL0FjY2Vzc2liaWxpdHlSZW5kZXJP YmplY3QuY3BwCmluZGV4IDhlZDM1MmEuLmZhZGFmYTMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvcGFn ZS9BY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0LmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdC5jcHAKQEAgLTU1LDYgKzU1LDcgQEAKICNpbmNsdWRlICJOb2Rl TGlzdC5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVudGVkLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgor I2luY2x1ZGUgIlBhc3NQb3NpdGlvbi5oIgogI2luY2x1ZGUgIlJlbmRlckZpZWxkc2V0LmgiCiAj aW5jbHVkZSAiUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuaCIKICNpbmNsdWRlICJSZW5kZXJJbWFn ZS5oIgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9wYWdlL0ZyYW1lLmNwcCBiL1dlYkNvcmUvcGFnZS9G cmFtZS5jcHAKaW5kZXggYWU0ZjFiNC4uYTNlMmNkYSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9wYWdl L0ZyYW1lLmNwcAorKysgYi9XZWJDb3JlL3BhZ2UvRnJhbWUuY3BwCkBAIC02MCw2ICs2MCw3IEBA CiAjaW5jbHVkZSAiTmF2aWdhdG9yLmgiCiAjaW5jbHVkZSAiTm9kZUxpc3QuaCIKICNpbmNsdWRl ICJQYWdlLmgiCisjaW5jbHVkZSAiUGFzc1Bvc2l0aW9uLmgiCiAjaW5jbHVkZSAiUmVndWxhckV4 cHJlc3Npb24uaCIKICNpbmNsdWRlICJSZW5kZXJQYXJ0LmgiCiAjaW5jbHVkZSAiUmVuZGVyVGFi bGVDZWxsLmgiCmRpZmYgLS1naXQgYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwIGIv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAppbmRleCAyYmExODJlLi4wZDY5MmQzIDEw MDY0NAotLS0gYS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCisrKyBiL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckJveC5jcHAKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlICJGbG9h dFF1YWQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKKyNpbmNsdWRl ICJQYXNzUG9zaXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJBcmVuYS5oIgogI2luY2x1ZGUgIlJl bmRlckZsZXhpYmxlQm94LmgiCiAjaW5jbHVkZSAiUmVuZGVySW5saW5lLmgiCg== 28876 2009-03-23 17:04:35 -0700 2009-03-23 17:32:20 -0700 Second stab at making Position::container private Second-stab-at-making-Position-container-private.patch text/plain 8405 eric M2UxMGZhOTVjMmFkN2Y2NzhhYjdhYzc5NGU2NzM3MjQ5YzFhMWMwNQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMWQ3NTZhLi41Y2YyM2Ez IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDQyIEBACisyMDA5LTAzLTIzICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW5h bWUgUG9zaXRpb246OmNvbnRhaW5lciB0byBtX2FuY2hvck5vZGUgYW5kIG1ha2UgaXQgcHJpdmF0 ZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjQ3NjAK KworICAgICAgICBNb3JlIGNvZGUgY2xlYW51cCBmb3IgUG9zaXRpb24uCisKKyAgICAgICAgQ2hh bmdlIGFsbCB1c2VzIG9mIG1fY29udGFpbmVyIHRvIG5vZGUoKQorICAgICAgICBFdmVudHVhbGx5 IG1vc3QgdXNlcyBvZiBub2RlKCkgc2hvdWxkIGNoYW5nZSB0byBhbmNob3JOb2RlKCkgdG8gZGVz aWduYXRlCisgICAgICAgIHRoYXQgaXQncyB0aGUgbm9kZSB0aGUgUG9zaXRpb24gaXMgYW5jaG9y ZWQgdG8sIGJ1dCBub3QgbmVjZXNzYXJpbHkgdGhlCisgICAgICAgIGNvbnRhaW5lciBvZiB0aGUg cG9zaXRpb24gKGl0IGNvdWxkIGJlIHRoZSBiZWZvcmUvYWZ0ZXIgbmVpZ2hib3IpLgorCisgICAg ICAgIFJlbW92ZSBhbnkgY29kZSB3aGljaCBzZXRzIG1fY29udGFpbmVyLCBhbmQgY2hhbmdlIGl0 IHRvIHVzZSBhIG5ldworICAgICAgICBQb3NpdGlvbjo6bW92ZVRvUG9zaXRpb24gZnVuY3Rpb24g d2hpY2ggdGFrZXMgYSBub2RlIGFuZCBvZmZzZXQuCisgICAgICAgIEl0IG5ldmVyIG1ha2VzIHNl bnNlIHRvIGNoYW5nZSB0aGUgbm9kZSBhbmQgbGVhdmUgdGhlIG9mZnNldC4KKworICAgICAgICAq IGRvbS9Qb3NpdGlvbi5oOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246OlBvc2l0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjpjbGVhcik6CisgICAgICAgIChXZWJDb3JlOjpQ b3NpdGlvbjo6YW5jaG9yTm9kZSk6CisgICAgICAgIChXZWJDb3JlOjpQb3NpdGlvbjo6bm9kZSk6 CisgICAgICAgIChXZWJDb3JlOjpQb3NpdGlvbjo6bW92ZVRvUG9zaXRpb24pOgorICAgICAgICAo V2ViQ29yZTo6UG9zaXRpb246Om1vdmVUb09mZnNldCk6CisgICAgICAgIChXZWJDb3JlOjpQb3Np dGlvbjo6aXNOdWxsKToKKyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjppc05vdE51bGwpOgor ICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3I9PSk6CisgICAgICAgICogZG9tL1JhbmdlLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlJhbmdlOjpjcmVhdGUpOgorICAgICAgICAoV2ViQ29yZTo6UmFu Z2U6OmNvbXBhcmVCb3VuZGFyeVBvaW50cyk6CisgICAgICAgICogZG9tL1JhbmdlQm91bmRhcnlQ b2ludC5oOgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VCb3VuZGFyeVBvaW50Ojpjb250YWluZXIp OgorICAgICAgICAoV2ViQ29yZTo6UmFuZ2VCb3VuZGFyeVBvaW50OjpzZXQpOgorICAgICAgICAo V2ViQ29yZTo6UmFuZ2VCb3VuZGFyeVBvaW50OjpzZXRPZmZzZXQpOgorICAgICAgICAoV2ViQ29y ZTo6UmFuZ2VCb3VuZGFyeVBvaW50OjpzZXRUb0NoaWxkKToKKyAgICAgICAgKFdlYkNvcmU6OlJh bmdlQm91bmRhcnlQb2ludDo6c2V0VG9TdGFydCk6CisgICAgICAgIChXZWJDb3JlOjpSYW5nZUJv dW5kYXJ5UG9pbnQ6OnNldFRvRW5kKToKKwogMjAwOS0wMy0yMyAgU2ltb24gRnJhc2VyICA8c2lt b24uZnJhc2VyQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4gQmVybnN0ZWlu CmRpZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oIGIvV2ViQ29yZS9kb20vUG9zaXRp b24uaAppbmRleCBiNzQwNzY0Li5kMGIyYWUxIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Qb3Np dGlvbi5oCisrKyBiL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmgKQEAgLTUyLDE5ICs1MiwzNiBAQCBl bnVtIFBvc2l0aW9uTW92ZVR5cGUgewogCiBjbGFzcyBQb3NpdGlvbiB7CiBwdWJsaWM6Ci0gICAg UmVmUHRyPE5vZGU+IGNvbnRhaW5lcjsKLSAgICBpbnQgbV9vZmZzZXQ7Ci0KICAgICBQb3NpdGlv bigpIDogbV9vZmZzZXQoMCkgeyB9Ci0gICAgUG9zaXRpb24oUGFzc1JlZlB0cjxOb2RlPiBjLCBp bnQgbykgOiBjb250YWluZXIoYyksIG1fb2Zmc2V0KG8pIHsgfQogCi0gICAgdm9pZCBjbGVhcigp IHsgY29udGFpbmVyLmNsZWFyKCk7IG1fb2Zmc2V0ID0gMDsgfQorICAgIC8vIFRoaXMgY29uc3Ry dWN0b3Igc2hvdWxkIGJlIHByaXZhdGUKKyAgICBQb3NpdGlvbihQYXNzUmVmUHRyPE5vZGU+IGFu Y2hvck5vZGUsIGludCBvZmZzZXQpCisgICAgICAgIDogbV9hbmNob3JOb2RlKGFuY2hvck5vZGUp CisgICAgICAgICwgbV9vZmZzZXQob2Zmc2V0KQorICAgIHt9CisKKyAgICB2b2lkIGNsZWFyKCkg eyBtX2FuY2hvck5vZGUuY2xlYXIoKTsgbV9vZmZzZXQgPSAwOyB9CisKKyAgICBOb2RlKiBhbmNo b3JOb2RlKCkgY29uc3QgeyByZXR1cm4gbV9hbmNob3JOb2RlLmdldCgpOyB9CiAKLSAgICBOb2Rl KiBub2RlKCkgY29uc3QgeyByZXR1cm4gY29udGFpbmVyLmdldCgpOyB9CisgICAgLy8gRklYTUU6 IENhbGxlcnMgc2hvdWxkIGJlIG1vdmVkIG9mZiBvZiBub2RlKCkhIG5vZGUoKSBpcyBub3QgYWx3 YXlzIHRoZSBjb250YWluZXIgZm9yIHRoaXMgcG9zaXRpb24uCisgICAgLy8gRm9yIG5vZGVzIHdo aWNoIGVkaXRpbmdJZ25vcmVzQ29udGVudChub2RlKSByZXR1cm5zIHRydWUgW2lnbm9yZWROb2Rl LCAwXQorICAgIC8vIHdpbGwgYmUgdHJlYXRlZCBhcyBiZWZvcmUgaWdub3JlZE5vZGUgKHRodXMg bm9kZSgpIGlzIHJlYWxseSBhZnRlciB0aGUgcG9zaXRpb24sIG5vdCBjb250YWluaW5nIGl0KS4K KyAgICBOb2RlKiBub2RlKCkgY29uc3QgeyByZXR1cm4gbV9hbmNob3JOb2RlLmdldCgpOyB9CiAg ICAgRWxlbWVudCogZG9jdW1lbnRFbGVtZW50KCkgY29uc3Q7CiAKLSAgICBib29sIGlzTnVsbCgp IGNvbnN0IHsgcmV0dXJuICFjb250YWluZXI7IH0KLSAgICBib29sIGlzTm90TnVsbCgpIGNvbnN0 IHsgcmV0dXJuIGNvbnRhaW5lcjsgfQorICAgIHZvaWQgbW92ZVRvUG9zaXRpb24oUGFzc1JlZlB0 cjxOb2RlPiBub2RlLCBpbnQgb2Zmc2V0KQorICAgIHsKKyAgICAgICAgbV9hbmNob3JOb2RlID0g bm9kZTsKKyAgICAgICAgbV9vZmZzZXQgPSBvZmZzZXQ7CisgICAgfQorICAgIHZvaWQgbW92ZVRv T2Zmc2V0KGludCBvZmZzZXQpCisgICAgeworICAgICAgICBtX29mZnNldCA9IG9mZnNldDsKKyAg ICB9CisKKyAgICBib29sIGlzTnVsbCgpIGNvbnN0IHsgcmV0dXJuICFtX2FuY2hvck5vZGU7IH0K KyAgICBib29sIGlzTm90TnVsbCgpIGNvbnN0IHsgcmV0dXJuIG1fYW5jaG9yTm9kZTsgfQogCiAg ICAgRWxlbWVudCogZWxlbWVudCgpIGNvbnN0OwogICAgIFBhc3NSZWZQdHI8Q1NTQ29tcHV0ZWRT dHlsZURlY2xhcmF0aW9uPiBjb21wdXRlZFN0eWxlKCkgY29uc3Q7CkBAIC0xMTgsMTEgKzEzNSwx OCBAQCBwcml2YXRlOgogCiAgICAgUG9zaXRpb24gcHJldmlvdXNDaGFyYWN0ZXJQb3NpdGlvbihF QWZmaW5pdHkpIGNvbnN0OwogICAgIFBvc2l0aW9uIG5leHRDaGFyYWN0ZXJQb3NpdGlvbihFQWZm aW5pdHkpIGNvbnN0OworCisgICAgUmVmUHRyPE5vZGU+IG1fYW5jaG9yTm9kZTsKK3B1YmxpYzoK KyAgICAvLyBtX29mZnNldCBjYW4gYmUgdGhlIG9mZnNldCBpbnNpZGUgbV9hbmNob3JOb2RlLCBv ciBpZiBlZGl0aW5nSWdub3Jlc0NvbnRlbnQobV9hbmNob3JOb2RlKQorICAgIC8vIHJldHVybnMg dHJ1ZSwgdGhlbiBvdGhlciBwbGFjZXMgaW4gZWRpdGluZyB3aWxsIHRyZWF0IG1fb2Zmc2V0ID09 IDAgYXMgImJlZm9yZSB0aGUgYW5jaG9yIgorICAgIC8vIGFuZCBtX29mZnNldCA+IDAgYXMgImFm dGVyIHRoZSBhbmNob3Igbm9kZSIuICBTZWUgcmFuZ2VDb21wbGlhbnRFcXVpdmFsZW50IGZvciBt b3JlIGluZm8uCisgICAgaW50IG1fb2Zmc2V0OyAvLyBGSVhNRTogVGhpcyBzaG91bGQgYmUgbWFk ZSBwcml2YXRlLgogfTsKIAogaW5saW5lIGJvb2wgb3BlcmF0b3I9PShjb25zdCBQb3NpdGlvbiYg YSwgY29uc3QgUG9zaXRpb24mIGIpCiB7Ci0gICAgcmV0dXJuIGEuY29udGFpbmVyID09IGIuY29u dGFpbmVyICYmIGEubV9vZmZzZXQgPT0gYi5tX29mZnNldDsKKyAgICByZXR1cm4gYS5ub2RlKCkg PT0gYi5ub2RlKCkgJiYgYS5tX29mZnNldCA9PSBiLm1fb2Zmc2V0OwogfQogCiBpbmxpbmUgYm9v bCBvcGVyYXRvciE9KGNvbnN0IFBvc2l0aW9uJiBhLCBjb25zdCBQb3NpdGlvbiYgYikKZGlmZiAt LWdpdCBhL1dlYkNvcmUvZG9tL1JhbmdlLmNwcCBiL1dlYkNvcmUvZG9tL1JhbmdlLmNwcAppbmRl eCA1OWYzNjhlLi44MDE0OWZmIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9SYW5nZS5jcHAKKysr IGIvV2ViQ29yZS9kb20vUmFuZ2UuY3BwCkBAIC04OSw3ICs4OSw3IEBAIFBhc3NSZWZQdHI8UmFu Z2U+IFJhbmdlOjpjcmVhdGUoUGFzc1JlZlB0cjxEb2N1bWVudD4gb3duZXJEb2N1bWVudCwgUGFz c1JlZlB0cjxOCiAKIFBhc3NSZWZQdHI8UmFuZ2U+IFJhbmdlOjpjcmVhdGUoUGFzc1JlZlB0cjxE b2N1bWVudD4gb3duZXJEb2N1bWVudCwgY29uc3QgUG9zaXRpb24mIHN0YXJ0LCBjb25zdCBQb3Np dGlvbiYgZW5kKQogewotICAgIHJldHVybiBhZG9wdFJlZihuZXcgUmFuZ2Uob3duZXJEb2N1bWVu dCwgc3RhcnQuY29udGFpbmVyLmdldCgpLCBzdGFydC5tX29mZnNldCwgZW5kLmNvbnRhaW5lci5n ZXQoKSwgZW5kLm1fb2Zmc2V0KSk7CisgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBSYW5nZShvd25l ckRvY3VtZW50LCBzdGFydC5ub2RlKCksIHN0YXJ0Lm1fb2Zmc2V0LCBlbmQubm9kZSgpLCBlbmQu bV9vZmZzZXQpKTsKIH0KIAogUmFuZ2U6On5SYW5nZSgpCkBAIC01MjcsNyArNTI3LDcgQEAgc2hv cnQgUmFuZ2U6OmNvbXBhcmVCb3VuZGFyeVBvaW50cyhOb2RlKiBjb250YWluZXJBLCBpbnQgb2Zm c2V0QSwgTm9kZSogY29udGFpbmUKIAogc2hvcnQgUmFuZ2U6OmNvbXBhcmVCb3VuZGFyeVBvaW50 cyhjb25zdCBQb3NpdGlvbiYgYSwgY29uc3QgUG9zaXRpb24mIGIpCiB7Ci0gICAgcmV0dXJuIGNv bXBhcmVCb3VuZGFyeVBvaW50cyhhLmNvbnRhaW5lci5nZXQoKSwgYS5tX29mZnNldCwgYi5jb250 YWluZXIuZ2V0KCksIGIubV9vZmZzZXQpOworICAgIHJldHVybiBjb21wYXJlQm91bmRhcnlQb2lu dHMoYS5ub2RlKCksIGEubV9vZmZzZXQsIGIubm9kZSgpLCBiLm1fb2Zmc2V0KTsKIH0KIAogYm9v bCBSYW5nZTo6Ym91bmRhcnlQb2ludHNWYWxpZCgpIGNvbnN0CmRpZmYgLS1naXQgYS9XZWJDb3Jl L2RvbS9SYW5nZUJvdW5kYXJ5UG9pbnQuaCBiL1dlYkNvcmUvZG9tL1JhbmdlQm91bmRhcnlQb2lu dC5oCmluZGV4IDM5YzczNWUuLmU3OGFkODQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZG9tL1Jhbmdl Qm91bmRhcnlQb2ludC5oCisrKyBiL1dlYkNvcmUvZG9tL1JhbmdlQm91bmRhcnlQb2ludC5oCkBA IC01NSw2ICs1NSwxMCBAQCBwdWJsaWM6CiBwcml2YXRlOgogICAgIHN0YXRpYyBjb25zdCBpbnQg aW52YWxpZE9mZnNldCA9IC0xOwogCisgICAgLy8gRklYTUU6IFJhbmdlQm91bmRhcnlQb2ludCBp cyB0aGUgb25seSBmaWxlIHRvIGV2ZXIgdXNlIC0xIGFzIGFtIGV4cGVjdGVkIG9mZnNldCBmb3Ig UG9zaXRpb24KKyAgICAvLyBSYW5nZUJvdW5kYXJ5UG9pbnQgY3VycmVudGx5IG5lZWRzIHRvIHN0 b3JlIGEgUG9zaXRpb24gb2JqZWN0IHRvIG1ha2UgdGhlCisgICAgLy8gcG9zaXRpb24oKSBmdW5j dGlvbiBiZSBhYmxlIHRvIHJldHVybiBhIGNvbnN0JiAoYW5kIHRodXMgYXZvaWQgcmVmLWNodXJu KS4KKyAgICAKICAgICBtdXRhYmxlIFBvc2l0aW9uIG1fcG9zaXRpb247CiAgICAgTm9kZSogbV9j aGlsZEJlZm9yZTsKIH07CkBAIC03Miw3ICs3Niw4IEBAIGlubGluZSBSYW5nZUJvdW5kYXJ5UG9p bnQ6OlJhbmdlQm91bmRhcnlQb2ludChQYXNzUmVmUHRyPE5vZGU+IGNvbnRhaW5lcikKIAogaW5s aW5lIE5vZGUqIFJhbmdlQm91bmRhcnlQb2ludDo6Y29udGFpbmVyKCkgY29uc3QKIHsKLSAgICBy ZXR1cm4gbV9wb3NpdGlvbi5jb250YWluZXIuZ2V0KCk7CisgICAgLy8gRklYTUU6IG5vZGUoKSBp cyBub3QgbmVjZXNzYXJpbHkgdGhlIGNvbnRhaW5lciBub2RlIQorICAgIHJldHVybiBtX3Bvc2l0 aW9uLm5vZGUoKTsKIH0KIAogaW5saW5lIE5vZGUqIFJhbmdlQm91bmRhcnlQb2ludDo6Y2hpbGRC ZWZvcmUoKSBjb25zdApAQCAtMTA0LDQ3ICsxMDksNDMgQEAgaW5saW5lIHZvaWQgUmFuZ2VCb3Vu ZGFyeVBvaW50OjpzZXQoUGFzc1JlZlB0cjxOb2RlPiBjb250YWluZXIsIGludCBvZmZzZXQsIE5v ZGUKIHsKICAgICBBU1NFUlQob2Zmc2V0ID49IDApOwogICAgIEFTU0VSVChjaGlsZEJlZm9yZSA9 PSAob2Zmc2V0ID8gY29udGFpbmVyLT5jaGlsZE5vZGUob2Zmc2V0IC0gMSkgOiAwKSk7Ci0gICAg bV9wb3NpdGlvbi5jb250YWluZXIgPSBjb250YWluZXI7Ci0gICAgbV9wb3NpdGlvbi5tX29mZnNl dCA9IG9mZnNldDsKKyAgICBtX3Bvc2l0aW9uLm1vdmVUb1Bvc2l0aW9uKGNvbnRhaW5lciwgb2Zm c2V0KTsKICAgICBtX2NoaWxkQmVmb3JlID0gY2hpbGRCZWZvcmU7CiB9CiAKIGlubGluZSB2b2lk IFJhbmdlQm91bmRhcnlQb2ludDo6c2V0T2Zmc2V0KGludCBvZmZzZXQpCiB7Ci0gICAgQVNTRVJU KG1fcG9zaXRpb24uY29udGFpbmVyKTsKLSAgICBBU1NFUlQobV9wb3NpdGlvbi5jb250YWluZXIt Pm9mZnNldEluQ2hhcmFjdGVycygpKTsKKyAgICBBU1NFUlQobV9wb3NpdGlvbi5ub2RlKCkpOwor ICAgIEFTU0VSVChtX3Bvc2l0aW9uLm5vZGUoKS0+b2Zmc2V0SW5DaGFyYWN0ZXJzKCkpOwogICAg IEFTU0VSVChtX3Bvc2l0aW9uLm1fb2Zmc2V0ID49IDApOwogICAgIEFTU0VSVCghbV9jaGlsZEJl Zm9yZSk7Ci0gICAgbV9wb3NpdGlvbi5tX29mZnNldCA9IG9mZnNldDsKKyAgICBtX3Bvc2l0aW9u Lm1vdmVUb09mZnNldChvZmZzZXQpOwogfQogCiBpbmxpbmUgdm9pZCBSYW5nZUJvdW5kYXJ5UG9p bnQ6OnNldFRvQ2hpbGQoTm9kZSogY2hpbGQpCiB7CiAgICAgQVNTRVJUKGNoaWxkKTsKICAgICBB U1NFUlQoY2hpbGQtPnBhcmVudE5vZGUoKSk7Ci0gICAgbV9wb3NpdGlvbi5jb250YWluZXIgPSBj aGlsZC0+cGFyZW50Tm9kZSgpOwogICAgIG1fY2hpbGRCZWZvcmUgPSBjaGlsZC0+cHJldmlvdXNT aWJsaW5nKCk7Ci0gICAgbV9wb3NpdGlvbi5tX29mZnNldCA9IG1fY2hpbGRCZWZvcmUgPyBpbnZh bGlkT2Zmc2V0IDogMDsKKyAgICBtX3Bvc2l0aW9uLm1vdmVUb1Bvc2l0aW9uKGNoaWxkLT5wYXJl bnROb2RlKCksIG1fY2hpbGRCZWZvcmUgPyBpbnZhbGlkT2Zmc2V0IDogMCk7CiB9CiAKIGlubGlu ZSB2b2lkIFJhbmdlQm91bmRhcnlQb2ludDo6c2V0VG9TdGFydChQYXNzUmVmUHRyPE5vZGU+IGNv bnRhaW5lcikKIHsKICAgICBBU1NFUlQoY29udGFpbmVyKTsKLSAgICBtX3Bvc2l0aW9uLmNvbnRh aW5lciA9IGNvbnRhaW5lcjsKLSAgICBtX3Bvc2l0aW9uLm1fb2Zmc2V0ID0gMDsKKyAgICBtX3Bv c2l0aW9uLm1vdmVUb1Bvc2l0aW9uKGNvbnRhaW5lciwgMCk7CiAgICAgbV9jaGlsZEJlZm9yZSA9 IDA7CiB9CiAKIGlubGluZSB2b2lkIFJhbmdlQm91bmRhcnlQb2ludDo6c2V0VG9FbmQoUGFzc1Jl ZlB0cjxOb2RlPiBjb250YWluZXIpCiB7CiAgICAgQVNTRVJUKGNvbnRhaW5lcik7Ci0gICAgbV9w b3NpdGlvbi5jb250YWluZXIgPSBjb250YWluZXI7Ci0gICAgaWYgKG1fcG9zaXRpb24uY29udGFp bmVyLT5vZmZzZXRJbkNoYXJhY3RlcnMoKSkgewotICAgICAgICBtX3Bvc2l0aW9uLm1fb2Zmc2V0 ID0gbV9wb3NpdGlvbi5jb250YWluZXItPm1heENoYXJhY3Rlck9mZnNldCgpOworICAgIGlmIChj b250YWluZXItPm9mZnNldEluQ2hhcmFjdGVycygpKSB7CisgICAgICAgIG1fcG9zaXRpb24ubW92 ZVRvUG9zaXRpb24oY29udGFpbmVyLCBjb250YWluZXItPm1heENoYXJhY3Rlck9mZnNldCgpKTsK ICAgICAgICAgbV9jaGlsZEJlZm9yZSA9IDA7CiAgICAgfSBlbHNlIHsKLSAgICAgICAgbV9jaGls ZEJlZm9yZSA9IG1fcG9zaXRpb24uY29udGFpbmVyLT5sYXN0Q2hpbGQoKTsKLSAgICAgICAgbV9w b3NpdGlvbi5tX29mZnNldCA9IG1fY2hpbGRCZWZvcmUgPyBpbnZhbGlkT2Zmc2V0IDogMDsKKyAg ICAgICAgbV9jaGlsZEJlZm9yZSA9IGNvbnRhaW5lci0+bGFzdENoaWxkKCk7CisgICAgICAgIG1f cG9zaXRpb24ubW92ZVRvUG9zaXRpb24oY29udGFpbmVyLCBtX2NoaWxkQmVmb3JlID8gaW52YWxp ZE9mZnNldCA6IDApOwogICAgIH0KIH0KIAo=