90670 2012-07-06 02:49:35 -0700 Vertically center non-anchored <dialog> elements 2012-09-05 19:23:52 -0700 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 84635 1 falken falken eoconnor eric gyuyoung.kim ian jchaffraix morrita ojan rakuco simon.fraser tkent tony webkit.review.bot oldest_to_newest 663975 0 falken 2012-07-06 02:49:35 -0700 Non-anchored <dialog> elements should be vertically centered in the viewport by default. It seems there are two general approaches to implement this: 1) Change layout to have special handling for positioning dialog elements. 2) Change the dialog's CSS directly to position it. E.g., set the 'position' property to 'fixed' and set 'top' accordingly. I'm not sure if doing so is OK according to the HTML or CSS spec, however; for example, perhaps elements are required to have a certain 'position' property by default. The recommended style sheet for dialog uses position 'absolute':<http://www.whatwg.org/specs/web-apps/current-work/multipage/rendering.html#flow-content-1> 664134 1 ojan 2012-07-06 09:06:31 -0700 (In reply to comment #0) > Non-anchored <dialog> elements should be vertically centered in the viewport by default. > > It seems there are two general approaches to implement this: > > 1) Change layout to have special handling for positioning dialog elements. > 2) Change the dialog's CSS directly to position it. E.g., set the 'position' property to 'fixed' and set 'top' accordingly. I'm not sure if doing so is OK according to the HTML or CSS spec, however; for example, perhaps elements are required to have a certain 'position' property by default. The recommended style sheet for dialog uses position 'absolute':<http://www.whatwg.org/specs/web-apps/current-work/multipage/rendering.html#flow-content-1> Ideally we'd use the CSS from the spec in html.css. Do you know why it uses position:absolute instead of fixed? It's probably worth tracking down the history of discussion there to see if maybe it's just an oversight. 676327 2 falken 2012-07-23 19:27:23 -0700 (In reply to comment #1) > Ideally we'd use the CSS from the spec in html.css. Do you know why it uses position:absolute instead of fixed? Ian Hickson explains: "If it was fixed, and the dialog was taller than the window, there would be no way to view the whole dialog." <http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2012-July/036667.html> Implementation-wise, I guess it may still be possible to do option 2) but special case for dialogs taller than the window, and we'd have to handle size changing dynamically. 676334 3 ian 2012-07-23 19:35:01 -0700 Why wouldn't you just do what the spec says? If there's something wrong with what the spec says, I'd like to change the spec. 677158 4 ojan 2012-07-24 13:28:57 -0700 (In reply to comment #3) > Why wouldn't you just do what the spec says? If there's something wrong with what the spec says, I'd like to change the spec. I think what's in the spec WRT CSS and positioning is fine. Your argument for why absolute is better convinces me. I'm having trouble digesting all the anchor-point stuff. At first glance, I'd prefer a general anchoring solution. In either case, we can get an initial implementation of this that doesn't support anchors to start with. 681841 5 falken 2012-07-30 03:58:12 -0700 I'm trying now to implement what the spec says. This means adding special handling to layout for positioning dialog elements. My thinking is it should probably follow much the same code path as for fixed elements, since we want to position the dialog in terms of the viewport. So my approach is to try to get the fixed positioning code to also handle dialog. For example, change RenderLayer::updateLayerPositionsAfterScroll to cause repaint rects to be computed for dialog as well as fixed elements. This involves changing some conditionals to be like (position() == FixedPosition || isDialog()), which may be a little ugly. Now I've gotten RenderView::computeRectForRepaint and RenderView::mapLocalToContainer to be called for dialog as if it were a fixed element, but this is not sufficient for a working implementation. Any thoughts on this approach? Perhaps dialog should be laid out independently of fixed elements instead? 682952 6 falken 2012-07-31 05:40:09 -0700 It's looking tricky to get a non-fixed position element to be positioned like a fixed element. Now I'm trying to alter code that gets called during layout like RenderBox::computePositionedLogicalHeight to use an effective top value for getting the dialog to be centered. This will mean triggering layout on a scroll, for dialog elements. 683442 7 ojan 2012-07-31 13:43:36 -0700 (In reply to comment #6) > It's looking tricky to get a non-fixed position element to be positioned like a fixed element. Why is it not a fixed position element? Don't we set position:fixed in html.css? > Now I'm trying to alter code that gets called during layout like RenderBox::computePositionedLogicalHeight to use an effective top value for getting the dialog to be centered. This will mean triggering layout on a scroll, for dialog elements. I think you probably need a RenderDialog class that subclasses RenderBlock and overrides layout to set the static inline/block positions (e.g. see adjustPositionedBlock) and the continue with RenderBlock's regular layout. You might need to do some more to get it to reposition on resizing the window. Actually, it is supposed to reposition when you resize the window? 683705 8 falken 2012-07-31 17:56:16 -0700 (In reply to comment #7) > (In reply to comment #6) > > It's looking tricky to get a non-fixed position element to be positioned like a fixed element. > > Why is it not a fixed position element? Don't we set position:fixed in html.css? As mentioned in comments #2-4, it's position:absolute in the spec and html.css. > > Now I'm trying to alter code that gets called during layout like RenderBox::computePositionedLogicalHeight to use an effective top value for getting the dialog to be centered. This will mean triggering layout on a scroll, for dialog elements. > > I think you probably need a RenderDialog class that subclasses RenderBlock and overrides layout to set the static inline/block positions (e.g. see adjustPositionedBlock) and the continue with RenderBlock's regular layout. Thanks for the idea! I'll give this a try. > You might need to do some more to get it to reposition on resizing the window. Actually, it is supposed to reposition when you resize the window? It seems it should reposition on resize. The spec says the default static position should be computed such that the dialog is centered, and "this top static position must remain the element's top static position until it is next changed by the above algorithm or the next one." http://www.whatwg.org/specs/web-apps/current-work/multipage/commands.html#the-dialog-element 683781 9 ian 2012-07-31 19:46:09 -0700 > It seems it should reposition on resize. The spec says [...] How do you go from what the spec says (as you quoted), to the conclusion that resizing should reposition as well? 683784 10 ian 2012-07-31 19:48:38 -0700 (That's not a rhetorical question, by the way; I'm just trying to understand your reading of the spec.) 683823 11 falken 2012-07-31 20:31:35 -0700 (In reply to comment #9) > > It seems it should reposition on resize. The spec says [...] > > How do you go from what the spec says (as you quoted), to the conclusion that resizing should reposition as well? I interpreted "the above algorithm" as the calculation described in the previous paragraph ("set up the default static position") to center the dialog in the viewport. Since a resize or scroll would cause the dialog to no longer be centered in the viewport, it sounds like the above algorithm should run again to keep it centered, that is, the top static position would be "next changed by the above algorithm". I guess I'm reading "next changed by" incorrectly. Should the dialog not be repositioned on a scroll or resize? 685219 12 falken 2012-08-02 04:21:28 -0700 I notice now the spec specifically says when to "set up the default static position" in the steps for show() and showModal(). So it seems the element should not be repositioned on scroll or resize, after all. The default static position can change only when show() or showModal() is invoked. As suggested in comment #7, I looked into setting the static position before proceeding with RenderBlock::layout, but we need to know the height to center the dialog, and that is computed during layout (in RenderBox::computeLogicalHeight). It looks possible to get it to center by hooking into the computeLogicalHeight code path. I should have a preliminary patch ready soon. 687982 13 156649 falken 2012-08-06 04:03:11 -0700 Created attachment 156649 preliminary patch 687987 14 156649 falken 2012-08-06 04:13:10 -0700 Comment on attachment 156649 preliminary patch View in context: https://bugs.webkit.org/attachment.cgi?id=156649&action=review I'm hoping to get feedback on this WIP patch. It seems to work in some cases, but also fails in some cases. In the layout test, the final check is failing (when the dialog is in a relative positioned div in an absolute positioned div). The positioning logic is in RenderDialog::adjustDialogStaticPosition, called after the normal RenderBlock::layout() call. The goal is to center the dialog vertically in the viewport when it fits, and to position it at the top of the viewport when it's taller than the viewport. > Source/WebCore/rendering/RenderDialog.cpp:76 > + if (!style()->hasStaticBlockPosition(isHorizontalWritingMode()) || style()->position() != AbsolutePosition) Not sure if we also want to setup the default static position for "position: relative". The spec says specifically we don't do it for "position: static". > Source/WebCore/rendering/RenderDialog.cpp:90 > + setLogicalTop(flooredLayoutSize(localPoint).height()); I'm not sure if this logic is correct, particularly how the absolute coordinate is computed and then translated to local coordinates of our container. This also all probably needs to be updated for correct handling in horizontal vs. vertical writing mode. 688265 15 156649 ojan 2012-08-06 10:45:45 -0700 Comment on attachment 156649 preliminary patch View in context: https://bugs.webkit.org/attachment.cgi?id=156649&action=review >> Source/WebCore/rendering/RenderDialog.cpp:76 >> + if (!style()->hasStaticBlockPosition(isHorizontalWritingMode()) || style()->position() != AbsolutePosition) > > Not sure if we also want to setup the default static position for "position: relative". The spec says specifically we don't do it for "position: static". Take a look at RenderBlock::adjustPositionedBlock. You want to use the setStatic* methods here. Then I don't think you need either of these checks. Not 100% sure though. 690032 16 falken 2012-08-08 00:58:10 -0700 (In reply to comment #15) > Take a look at RenderBlock::adjustPositionedBlock. You want to use the setStatic* methods here. Then I don't think you need either of these checks. Not 100% sure though. Hm, I'm having trouble figuring out how to use the setStatic* methods. The static positions are used to calculate top during RenderBlock::layout, so it's too late to call them after that has run. If I call them before or during RenderBlock::layout, it becomes slightly harder to compute what the static position should be. The code that uses the static position to compute top, computeBlockStaticDistance in RenderBox.cpp, also adds the top value of the parent and its ancestor containers before assigning to top. So I have to offset static position by that amount, so top will ultimately be such that the dialog is centered. However, even if I do that, the final test case still fails. But, this may provide a clue why. The test has been failing by 16 pixels, which happens to be the offset mentioned above (for some reason, RenderBody has a top of 16). So perhaps somehow RenderBody's top comes into play somewhere else. I'm not sure though. In some manual testing, dialog is off by far more than 16 pixels. 692291 17 157655 falken 2012-08-10 00:39:54 -0700 Created attachment 157655 WIP patch using setStaticBlockPosition 692316 18 157655 falken 2012-08-10 00:56:46 -0700 Comment on attachment 157655 WIP patch using setStaticBlockPosition View in context: https://bugs.webkit.org/attachment.cgi?id=157655&action=review I think the patch is working better than I thought. It seems to be failing only when a horizontal scrollbar is present. I've updated the patch to use setStaticBlockPosition, though I'm not sure where is a good place to call it. > Source/WebCore/rendering/RenderBox.cpp:2903 > + // Set dialog's static position for top. There is likely a better place to do this, but I'm not sure where. It can't be done too early or logicalHeight() just returns 0. For example, before RenderBlock::layout() is called is too early. > Source/WebCore/rendering/RenderBox.cpp:2919 > + } This does the reverse of the computation in computeBlockStaticDistance (which is about to be called), so that the logical top will ultimately be what we want. > LayoutTests/fast/dom/HTMLDialogElement/non-anchored-dialog-positioning.html:81 > +container.style.width = '90%'; It's currently failing when the horizontal scrollbar is present. 693517 19 falken 2012-08-13 04:01:25 -0700 Aha! The dialog is positioned correctly even when a horizontal scrollbar is present, but for some reason it's not being painted. It repaints after it is scrolled outside of the viewport and back inside again. It just felt like it was positioned incorrectly since I'd scroll up and down until I found it. It looks like this can be fixed by adding a call to repaint() after the actual top is set. I'm not sure if that's the best solution, though. The layout test's final test case still fails, but that is only by about 16 pixels. In manual testing, the dialog seems to be in the correct position. I'm still unsure what to do for "position: relative". I'm thinking the dialog shouldn't be centered, based on the position descriptions in the CSS spec[1] and the dialog spec's note that for "position: static" the special top value is not used. If someone could sanity check my interpretation, I'd appreciate it. [1] http://www.w3.org/TR/CSS21/visuren.html#propdef-position 694754 20 158279 falken 2012-08-14 03:29:47 -0700 Created attachment 158279 Patch 694772 21 falken 2012-08-14 03:49:00 -0700 Ojan, could you please review this patch? I returned to the original approach of adjusting position after normal RenderBlock::layout. This is because: - It eliminates the need for "if (isDialog)" cases in RenderBox.cpp - There doesn't seem to be a very good place to use the setStatic* functions. Before calling layout, the dialog height is unknown, so it can't be centered yet. It is still unknown in one place that already calls setStatic* (setStaticPositions in RenderBlockLineLayout.cpp). Once we get to RenderBox::computePositionedLogicalHeight, the static position is used just in the calculation to set top, so it seems cleaner to set top directly. What do you think? 696518 22 158279 ojan 2012-08-15 16:58:47 -0700 Comment on attachment 158279 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review Julien, Tony, do you mind taking a look at the LayoutStateDisabler/repaint stuff? I'm not too familiar with LayoutState. On second thought, I think the setLogicalTop approach is fine. Sorry for leading you astray. Unfortunately, WebKit has a ton of build systems, so you'll need to modify a ton more files (gtk, qt, efl, etc). I recommend looking at other recent patches that have added/removed new files as a reference. > Source/WebCore/rendering/RenderDialog.cpp:36 > +using namespace HTMLNames; What is this for? > Source/WebCore/rendering/RenderDialog.cpp:45 > +RenderDialog::RenderDialog(Node* node) > + : RenderBlock(node) > +{ > +} > + > +RenderDialog::~RenderDialog() > +{ > +} You can just put these in the header since they're empty. > Source/WebCore/rendering/RenderDialog.cpp:64 > + if (isFloating()) > + return "RenderDialog (floating)"; > + if (isOutOfFlowPositioned()) > + return "RenderDialog (positioned)"; > + if (isAnonymousColumnsBlock()) > + return "RenderDialog (anonymous multi-column)"; > + if (isAnonymousColumnSpanBlock()) > + return "RenderDialog (anonymous multi-column span)"; > + if (isAnonymousBlock()) > + return "RenderDialog (anonymous)"; > + if (isAnonymous()) > + return "RenderDialog (generated)"; > + if (isRelPositioned()) > + return "RenderDialog (relative positioned)"; > + if (isRunIn()) > + return "RenderDialog (run-in)"; I don't think you need all this. It's sufficient for now to just return RenderDialog. IIRC, this is only used for dumping the render tree for testing. In fact, it'd be fine for you to leave out this method altogether since we don't even have tests that dump a render tree with dialogs in them. > Source/WebCore/rendering/RenderDialog.cpp:76 > + LayoutStateDisabler layoutStateDisabler(view()); I think this might need a LayoutRepainter and a LayoutStateMaintainer instead (which would also wrap the RenderBlock::layout() method (see, e.g. RenderFlexibleBox::layoutBlock for an example). Alternately, maybe you just need to call repaintDuringLayoutIfMoved at the end instead of repaint. > Source/WebCore/rendering/RenderDialog.cpp:82 > + if (logicalHeight() < visibleHeight) > + absolutePoint.move(0, (visibleHeight - logicalHeight()) / 2); You're mixing logical and physical heights here. The question is what should happen with a dialog that has -webkit-writing-mode:vertical-rl. It should probably center horizontally, right? In that case, you should just use logicalHeights. Would be nice to add a testcase for this as well. > Source/WebCore/rendering/RenderDialog.cpp:84 > + LayoutUnit localTop = LayoutSize(localPoint.x(), localPoint.y()).height(); I'm not sure, but I think you're dealing in physical heights here as well. A test with vertical writing mode should make it clear whether this is right. > Source/WebCore/rendering/RenderDialog.h:55 > +inline RenderDialog* toRenderDialog(RenderObject* object) > +{ > + ASSERT(!object || object->isDialog()); > + return static_cast<RenderDialog*>(object); > +} > + > +// This will catch anyone doing an unnecessary cast. > +void toRenderDialog(const RenderDialog*); I don't think we need these. If these become common enough usage, that we need helper functions,we can add them then. > LayoutTests/fast/dom/HTMLDialogElement/non-anchored-dialog-positioning.html:22 > + shouldBeCloseTo('realTop', expectedTop, 1, true); We should be able to get exact numbers here. shouldBeCloseTo is just for things like transitions where the actual number is a bit racy. Might be simpler if you don't use a font-size based sizes below. Just use pixels. 696831 23 158279 tony 2012-08-16 00:27:28 -0700 Comment on attachment 158279 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review >> Source/WebCore/rendering/RenderDialog.cpp:76 >> + LayoutStateDisabler layoutStateDisabler(view()); > > I think this might need a LayoutRepainter and a LayoutStateMaintainer instead (which would also wrap the RenderBlock::layout() method (see, e.g. RenderFlexibleBox::layoutBlock for an example). > > Alternately, maybe you just need to call repaintDuringLayoutIfMoved at the end instead of repaint. Yes, I think you want to use LayoutRepainter and LayoutStateMaintainer here. > Source/WebCore/rendering/RenderDialog.cpp:89 > + // FIXME: This is needed because otherwise the dialog is not painted if it causes a horizontal scrollbar to appear. > + // There is probably a better solution. > + repaint(); This shouldn't be necessary. > Source/WebCore/rendering/RenderDialog.h:39 > + RenderDialog(Node*); Nit: explicit > Source/WebCore/rendering/RenderDialog.h:45 > + virtual const char* renderName() const; > + virtual bool isDialog() const { return true; } OVERRIDE 697339 24 158279 jchaffraix 2012-08-16 12:05:04 -0700 Comment on attachment 158279 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review >> Source/WebCore/rendering/RenderDialog.cpp:64 >> + return "RenderDialog (run-in)"; > > I don't think you need all this. It's sufficient for now to just return RenderDialog. IIRC, this is only used for dumping the render tree for testing. > > In fact, it'd be fine for you to leave out this method altogether since we don't even have tests that dump a render tree with dialogs in them. Let's keep the "RenderDialog" case for now. I still see some value in having it instead of postponing until people have submitted tests involving a tree dump and it's more painful to change. > Source/WebCore/rendering/RenderDialog.cpp:68 > +void RenderDialog::layout() Don't you need to update your position if the user scrolls? If that's the case, layout will not handle this case properly. >>> Source/WebCore/rendering/RenderDialog.cpp:76 >>> + LayoutStateDisabler layoutStateDisabler(view()); >> >> I think this might need a LayoutRepainter and a LayoutStateMaintainer instead (which would also wrap the RenderBlock::layout() method (see, e.g. RenderFlexibleBox::layoutBlock for an example). >> >> Alternately, maybe you just need to call repaintDuringLayoutIfMoved at the end instead of repaint. > > Yes, I think you want to use LayoutRepainter and LayoutStateMaintainer here. Mhh, there is an issue here. RenderBlock already handle part of this book keeping. The issue arises from your forcibly moving the renderer *after* RenderBlock triggered the invalidation. This path will cause WebKit to over-paint as you will dirty the original position, the intermediate one (after RenderBlock layout) and the final position. If you had a RenderLayer, it would handle the invalidation properly and *not* cause an over-invalidation. I haven't followed closely your attempt at that so I don't know how much of an option it is. 697340 25 158279 ojan 2012-08-16 12:09:31 -0700 Comment on attachment 158279 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review >>> Source/WebCore/rendering/RenderDialog.cpp:64 >>> + return "RenderDialog (run-in)"; >> >> I don't think you need all this. It's sufficient for now to just return RenderDialog. IIRC, this is only used for dumping the render tree for testing. >> >> In fact, it'd be fine for you to leave out this method altogether since we don't even have tests that dump a render tree with dialogs in them. > > Let's keep the "RenderDialog" case for now. I still see some value in having it instead of postponing until people have submitted tests involving a tree dump and it's more painful to change. Meh. In pratice, we're not really going to have many tests with dialogs in them. But sure, there's no harm, aside from a bit of code bloat. >> Source/WebCore/rendering/RenderDialog.cpp:68 >> +void RenderDialog::layout() > > Don't you need to update your position if the user scrolls? If that's the case, layout will not handle this case properly. No. It's explicitly position:absolute so that scrolling will scroll it. This works around the case where the dialog is larger than the window. >>>> Source/WebCore/rendering/RenderDialog.cpp:76 >>>> + LayoutStateDisabler layoutStateDisabler(view()); >>> >>> I think this might need a LayoutRepainter and a LayoutStateMaintainer instead (which would also wrap the RenderBlock::layout() method (see, e.g. RenderFlexibleBox::layoutBlock for an example). >>> >>> Alternately, maybe you just need to call repaintDuringLayoutIfMoved at the end instead of repaint. >> >> Yes, I think you want to use LayoutRepainter and LayoutStateMaintainer here. > > Mhh, there is an issue here. RenderBlock already handle part of this book keeping. The issue arises from your forcibly moving the renderer *after* RenderBlock triggered the invalidation. This path will cause WebKit to over-paint as you will dirty the original position, the intermediate one (after RenderBlock layout) and the final position. > > If you had a RenderLayer, it would handle the invalidation properly and *not* cause an over-invalidation. I haven't followed closely your attempt at that so I don't know how much of an option it is. Not sure I understand what you're saying here. You're saying that it should require a layer? If so, it already does because we only hit this code path if it's absolutely positioned (see line 73 above). 697632 26 158279 jchaffraix 2012-08-16 15:53:58 -0700 Comment on attachment 158279 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review >>> Source/WebCore/rendering/RenderDialog.cpp:68 >>> +void RenderDialog::layout() >> >> Don't you need to update your position if the user scrolls? If that's the case, layout will not handle this case properly. > > No. It's explicitly position:absolute so that scrolling will scroll it. This works around the case where the dialog is larger than the window. If I am reading the comments correctly, we want the <dialog> to follow the viewport when scrolling but again, I didn't really follow the bug nor the spec. >>>>> Source/WebCore/rendering/RenderDialog.cpp:76 >>>>> + LayoutStateDisabler layoutStateDisabler(view()); >>>> >>>> I think this might need a LayoutRepainter and a LayoutStateMaintainer instead (which would also wrap the RenderBlock::layout() method (see, e.g. RenderFlexibleBox::layoutBlock for an example). >>>> >>>> Alternately, maybe you just need to call repaintDuringLayoutIfMoved at the end instead of repaint. >>> >>> Yes, I think you want to use LayoutRepainter and LayoutStateMaintainer here. >> >> Mhh, there is an issue here. RenderBlock already handle part of this book keeping. The issue arises from your forcibly moving the renderer *after* RenderBlock triggered the invalidation. This path will cause WebKit to over-paint as you will dirty the original position, the intermediate one (after RenderBlock layout) and the final position. >> >> If you had a RenderLayer, it would handle the invalidation properly and *not* cause an over-invalidation. I haven't followed closely your attempt at that so I don't know how much of an option it is. > > Not sure I understand what you're saying here. You're saying that it should require a layer? If so, it already does because we only hit this code path if it's absolutely positioned (see line 73 above). If there is a layer (and there should be - as you pointed out - for absolutely positioned renderer), then you shouldn't need any ad-hoc repainting logic. The layer should invalidate properly in a separate post-layout step. 698874 27 ojan 2012-08-17 18:25:45 -0700 (In reply to comment #26) > (From update of attachment 158279 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=158279&action=review > > >>> Source/WebCore/rendering/RenderDialog.cpp:68 > >>> +void RenderDialog::layout() > >> > >> Don't you need to update your position if the user scrolls? If that's the case, layout will not handle this case properly. > > > > No. It's explicitly position:absolute so that scrolling will scroll it. This works around the case where the dialog is larger than the window. > > If I am reading the comments correctly, we want the <dialog> to follow the viewport when scrolling but again, I didn't really follow the bug nor the spec. I don't see that in the comments or the spec. 707045 28 falken 2012-08-28 20:43:12 -0700 Thanks all for the comments. Sorry for the late response, I was away the past two weeks. (In reply to comment #26) > If I am reading the comments correctly, we want the <dialog> to follow the viewport when scrolling but again, I didn't really follow the bug nor the spec. I originally thought the spec wanted this but I've since realized it says the dialog should not follow the viewport (comment #12). > If there is a layer (and there should be - as you pointed out - for absolutely positioned renderer), then you shouldn't need any ad-hoc repainting logic. The layer should invalidate properly in a separate post-layout step. Yes, there is a layer (I used it in the setStaticBlockPosition approach in the second patch). But it seems like the invalidation isn't happening. Do you know why this may be? Can you point me to where it occurs? (In reply to comment #22) > You're mixing logical and physical heights here. The question is what should happen with a dialog that has -webkit-writing-mode:vertical-rl. It should probably center horizontally, right? In that case, you should just use logicalHeights. Would be nice to add a testcase for this as well. That sounds right. I'll look into this. 708747 29 jchaffraix 2012-08-30 09:54:36 -0700 (In reply to comment #28) > Thanks all for the comments. Sorry for the late response, I was away the past two weeks. > > (In reply to comment #26) > > If I am reading the comments correctly, we want the <dialog> to follow the viewport when scrolling but again, I didn't really follow the bug nor the spec. > > I originally thought the spec wanted this but I've since realized it says the dialog should not follow the viewport (comment #12). Thanks, I stand corrected. > > If there is a layer (and there should be - as you pointed out - for absolutely positioned renderer), then you shouldn't need any ad-hoc repainting logic. The layer should invalidate properly in a separate post-layout step. > > Yes, there is a layer (I used it in the setStaticBlockPosition approach in the second patch). But it seems like the invalidation isn't happening. Do you know why this may be? There is a possibility for the invalidation not to happen but <dialog> would need to be composited and the compositor should properly handle this case already. My hunch would be that it happens but with the wrong - possibly empty - bounds. > Can you point me to where it occurs? It occurs in RenderLayer::updateLayerPositions. Look for the flags & CheckForRepaint check. This is called in FrameView::layout which passes the CheckForRepaint bit. 709334 30 falken 2012-08-30 23:49:41 -0700 (In reply to comment #29) > > Can you point me to where it occurs? > > It occurs in RenderLayer::updateLayerPositions. Look for the flags & CheckForRepaint check. This is called in FrameView::layout which passes the CheckForRepaint bit. It turns out the CheckForRepaint bit is off since FrameView::layout tries to do a full repaint and then switches it off. I think the problem may actually be explained in the FIXME next to the call to view()->repaint(): // FIXME: This isn't really right, since the RenderView doesn't fully encompass the visibleContentRect(). It just happens // to work out most of the time, since first layouts and printing don't have you scrolled anywhere. The repaint call leads to FrameView::repaintContentRectangle, where the rectangle passed in is intersected with visibleContentRect(), resulting in an empty rectangle. It turns out the rectangle passed in is something like: {m_location = {m_x = 0, m_y = 0}, m_size = {m_width = 2118, m_height = 837}} Whereas visibleContentRect is: {m_location = {m_x = 0, m_y = 873}, m_size = {m_width = 2118, m_height = 837}} Based on that and the FIXME comment, it looks like the repaint doesn't work if we are scrolled, which I've been doing during testing. Sure enough, if I don't scroll vertically before the dialog is shown, the repaint occurs. If that's true, then I guess the question is whether we can make the full repaint work even if scrolled, or maybe we can keep the CheckForRepaint bit on. 710537 31 161896 falken 2012-09-03 04:11:16 -0700 Created attachment 161896 WIP patch 710542 32 falken 2012-09-03 04:28:33 -0700 I've updated the patch to reflect review comments. Is there some adjustment that must be made for relative positioned containers? When the dialog is inside a relatively positioned container the centering is bit off. It looks like the problem may be the call to the absoluteToLocal(). For an absolutely positioned container in the same location, the absolute coordinates computed are the same but the local coordinates are different. I removed some assertions to be able to call absoluteToLocal but I think it's safe (this patch, although not committed, did the same: https://bug-90046-attachments.webkit.org/attachment.cgi?id=154208) I looked into writing mode, but I'm thinking it may be best to just always vertically center for now. This is because it's not yet spec'd what to do, and there are some subtleties such as how a too big dialog should probably be positioned on the right for vertical-rl and left for vertical-lr (and perhaps bottom for horizontal-bt). Also the default CSS doesn't make sense for centering in vertical mode with left: 0 and right: 0; the author would have to override that or we'd have to change to deviate from the spec. 711489 33 161896 ojan 2012-09-04 15:16:37 -0700 Comment on attachment 161896 WIP patch This patch looks good to me. Can you do the following: 1. Add a FIXME to figure out what RenderDialogs should do in vertical writing mode. 2. Find the author/reviewer of the asserts your removing and CC them on this bug to make sure removing them is correct. 711700 34 162155 falken 2012-09-04 21:25:57 -0700 Created attachment 162155 added FIXME for vertical mode 711702 35 falken 2012-09-04 21:32:18 -0700 Simon, is it okay to remove the absoluteToLocal assertions in RenderBox.cpp and RenderBoxModelObject.cpp? Also, do you know why the local coordinates may come out differently when the container is relatively vs. absolutely positioned (comment #32)? 711866 36 162196 falken 2012-09-05 02:31:38 -0700 Created attachment 162196 fix xcode project 712372 37 simon.fraser 2012-09-05 11:40:47 -0700 Yes, its OK to remove those assertions. 712763 38 162196 falken 2012-09-05 18:56:33 -0700 Comment on attachment 162196 fix xcode project Thanks for the review and comments. 712790 39 162196 webkit.review.bot 2012-09-05 19:23:45 -0700 Comment on attachment 162196 fix xcode project Clearing flags on attachment: 162196 Committed r127681: <http://trac.webkit.org/changeset/127681> 712791 40 webkit.review.bot 2012-09-05 19:23:52 -0700 All reviewed patches have been landed. Closing bug. 156649 2012-08-06 04:03:11 -0700 2012-08-10 00:39:49 -0700 preliminary patch bug-90670-20120806200247.patch text/plain 14633 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI0Njc0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGMwOThlNzFkZjU5YTE2 MTczNTYyYzMxNDFmMTQ0YzcxODA1YmNkYi4uOTM4NWIyZTBjZDU5ODU3MTQxODU1NzMzODhkY2Vi MTMxMTRmZGJjZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTA4LTA2ICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkaXRpb25hbCBpbmZvcm1hdGlvbiBvZiB0 aGUgY2hhbmdlIHN1Y2ggYXMgYXBwcm9hY2gsIHJhdGlvbmFsZS4gUGxlYXNlIGFkZCBwZXItZnVu Y3Rpb24gZGVzY3JpcHRpb25zIGJlbG93IChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9k b20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1s CisKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogaHRtbC9IVE1MRGlhbG9nRWxl bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRGlhbG9nRWxlbWVudDo6Y3JlYXRlUmVu ZGVyZXIpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogaHRtbC9IVE1MRGlhbG9nRWxl bWVudC5oOgorICAgICAgICAoSFRNTERpYWxvZ0VsZW1lbnQpOgorICAgICAgICAqIHJlbmRlcmlu Zy9SZW5kZXJEaWFsb2cuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAo V2ViQ29yZTo6UmVuZGVyRGlhbG9nOjpSZW5kZXJEaWFsb2cpOgorICAgICAgICAoV2ViQ29yZTo6 UmVuZGVyRGlhbG9nOjp+UmVuZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRp YWxvZzo6cmVuZGVyTmFtZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OmxheW91 dCk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OmFkanVzdERpYWxvZ1N0YXRpY1Bv c2l0aW9uKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmg6CisgICAgICAgIChX ZWJDb3JlKToKKyAgICAgICAgKFJlbmRlckRpYWxvZyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5k ZXJEaWFsb2c6OmlzRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OnRvUmVuZGVyRGlhbG9nKToK KyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6CisgICAgICAgIChSZW5kZXJPYmpl Y3QpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0Ojppc0RpYWxvZyk6CisKIDIwMTIt MDgtMDMgIFJpY2sgQnllcnMgIDxyYnllcnNAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIERvdWJs ZSB0YXAgZ2VzdHVyZSBzaG91bGQgc2VuZCBkYmxjbGljayBldmVudApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmlu ZGV4IDFiZmZjZmE5OTM5MDk0MWRmZjgxYjYxOWU3MDY3MGJkOGI0ZDlmN2QuLjE1YjBjYTFjZmE0 MzIyZGRkNmMzNDM4YjczNDRjMGVlYWVmNjZhMTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTU1MCw2 ICs1NTAsNyBAQAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJCbG9jay5oJywKICAgICAg ICAgICAgICdyZW5kZXJpbmcvUmVuZGVyQm94LmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9S ZW5kZXJCb3hNb2RlbE9iamVjdC5oJywKKyAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGlh bG9nLmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJFbWJlZGRlZE9iamVjdC5oJywK ICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmxvd1RocmVhZC5oJywKICAgICAgICAgICAg ICdyZW5kZXJpbmcvUmVuZGVySW1hZ2UuaCcsCkBAIC00Njk1LDYgKzQ2OTYsNyBAQAogICAgICAg ICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3guaCcsCiAgICAgICAg ICAgICAncmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIuY3BwJywKICAgICAgICAgICAgICdy ZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5oJywKKyAgICAgICAgICAgICdyZW5kZXJpbmcv UmVuZGVyRGlhbG9nLmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckVtYmVkZGVk T2JqZWN0LmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0LmNwcCcs CiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0LmgnLApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcAppbmRleCA0NTEwZDgxNDMxOWMyZTU0MzhlOTMy Nzc1Y2FjZDFjMGRkMjNiYTI1Li41Mzc0MzI5NjAzMDg3NzA3NTc4OWJjMWNlYTc1MDkzNzc5Njdh Yzg5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcApAQCAtMjks NiArMjksNyBAQAogI2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKIAogI2luY2x1ZGUgIkV4Y2Vw dGlvbkNvZGUuaCIKKyNpbmNsdWRlICJSZW5kZXJEaWFsb2cuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCkBAIC03MSw2ICs3MiwxMSBAQCBib29sIEhUTUxEaWFsb2dFbGVtZW50Ojppc1ByZXNl bnRhdGlvbkF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWROYW1lJiBuYW1lKSBjb25zdAogICAgIHJl dHVybiBIVE1MRWxlbWVudDo6aXNQcmVzZW50YXRpb25BdHRyaWJ1dGUobmFtZSk7CiB9CiAKK1Jl bmRlck9iamVjdCogSFRNTERpYWxvZ0VsZW1lbnQ6OmNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5h KiBhcmVuYSwgUmVuZGVyU3R5bGUqKQoreworICAgIHJldHVybiBuZXcgKGFyZW5hKSBSZW5kZXJE aWFsb2codGhpcyk7Cit9CisKIH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFs b2dFbGVtZW50LmgKaW5kZXggZDFkZDc3Njg5NTQzZjQ0NzJhZWQ5NzRiM2ZmNzQ3N2FhMDEyNmRh YS4uOGE5Mjk5MDUyMzMzMjZiNzg3YWIyYmM3YWM1YmQ0ZGI2NjlkNDYwNCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuaApAQCAtNDQsNiArNDQsNyBAQCBwdWJsaWM6CiAK IHByaXZhdGU6CiAgICAgSFRNTERpYWxvZ0VsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYsIERv Y3VtZW50Kik7CisgICAgdmlydHVhbCBSZW5kZXJPYmplY3QqIGNyZWF0ZVJlbmRlcmVyKFJlbmRl ckFyZW5hKiwgUmVuZGVyU3R5bGUqKSBPVkVSUklERTsKIAogICAgIHZpcnR1YWwgYm9vbCBpc1By ZXNlbnRhdGlvbkF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWROYW1lJikgY29uc3QgT1ZFUlJJREU7 CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5kMzJmMjFiOTA2YTU3ZTRmNWIzZWZkMTc1NDMwZmE3MzY0YTYyNTUwCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAKQEAgLTAsMCAr MSw5NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisg KiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5ECisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJEaWFs b2cuaCIKKworI2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKKyNpbmNsdWRlICJGcmFtZVZpZXcu aCIKKyNpbmNsdWRlICJSZW5kZXJMYXllci5oIgorI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKKwor bmFtZXNwYWNlIFdlYkNvcmUgeworCit1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOworCitSZW5k ZXJEaWFsb2c6OlJlbmRlckRpYWxvZyhOb2RlKiBub2RlKQorICAgIDogUmVuZGVyQmxvY2sobm9k ZSkKK3sKK30KKworUmVuZGVyRGlhbG9nOjp+UmVuZGVyRGlhbG9nKCkKK3sKK30KKworY29uc3Qg Y2hhciogUmVuZGVyRGlhbG9nOjpyZW5kZXJOYW1lKCkgY29uc3QKK3sKKyAgICBpZiAoaXNGbG9h dGluZygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAoZmxvYXRpbmcpIjsKKyAgICBp ZiAoaXNPdXRPZkZsb3dQb3NpdGlvbmVkKCkpCisgICAgICAgIHJldHVybiAiUmVuZGVyRGlhbG9n IChwb3NpdGlvbmVkKSI7CisgICAgaWYgKGlzQW5vbnltb3VzQ29sdW1uc0Jsb2NrKCkpCisgICAg ICAgIHJldHVybiAiUmVuZGVyRGlhbG9nIChhbm9ueW1vdXMgbXVsdGktY29sdW1uKSI7CisgICAg aWYgKGlzQW5vbnltb3VzQ29sdW1uU3BhbkJsb2NrKCkpCisgICAgICAgIHJldHVybiAiUmVuZGVy RGlhbG9nIChhbm9ueW1vdXMgbXVsdGktY29sdW1uIHNwYW4pIjsKKyAgICBpZiAoaXNBbm9ueW1v dXNCbG9jaygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAoYW5vbnltb3VzKSI7Cisg ICAgaWYgKGlzQW5vbnltb3VzKCkpCisgICAgICAgIHJldHVybiAiUmVuZGVyRGlhbG9nIChnZW5l cmF0ZWQpIjsKKyAgICBpZiAoaXNSZWxQb3NpdGlvbmVkKCkpCisgICAgICAgIHJldHVybiAiUmVu ZGVyRGlhbG9nIChyZWxhdGl2ZSBwb3NpdGlvbmVkKSI7CisgICAgaWYgKGlzUnVuSW4oKSkKKyAg ICAgICAgcmV0dXJuICJSZW5kZXJEaWFsb2cgKHJ1bi1pbikiOworICAgIHJldHVybiAiUmVuZGVy RGlhbG9nIjsKK30KKwordm9pZCBSZW5kZXJEaWFsb2c6OmxheW91dCgpCit7CisgICAgUmVuZGVy QmxvY2s6OmxheW91dCgpOworICAgIGFkanVzdERpYWxvZ1N0YXRpY1Bvc2l0aW9uKCk7Cit9CisK K3ZvaWQgUmVuZGVyRGlhbG9nOjphZGp1c3REaWFsb2dTdGF0aWNQb3NpdGlvbigpCit7CisgICAg aWYgKCFzdHlsZSgpLT5oYXNTdGF0aWNCbG9ja1Bvc2l0aW9uKGlzSG9yaXpvbnRhbFdyaXRpbmdN b2RlKCkpIHx8IHN0eWxlKCktPnBvc2l0aW9uKCkgIT0gQWJzb2x1dGVQb3NpdGlvbikKKyAgICAg ICAgcmV0dXJuOworCisgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXcgPSBkb2N1bWVudCgpLT52aWV3 KCk7CisgICAgaWYgKCFmcmFtZVZpZXcpCisgICAgICAgIHJldHVybjsKKworICAgIGludCBzY3Jv bGxUb3AgPSBmcmFtZVZpZXctPnNjcm9sbE9mZnNldCgpLmhlaWdodCgpOworICAgIEZsb2F0UG9p bnQgYWJzb2x1dGVQb2ludCgwLCBzY3JvbGxUb3ApOworICAgIGludCB2aXNpYmxlSGVpZ2h0ID0g ZnJhbWVWaWV3LT52aXNpYmxlSGVpZ2h0KCk7CisgICAgaWYgKGxvZ2ljYWxIZWlnaHQoKSA8IHZp c2libGVIZWlnaHQpCisgICAgICAgIGFic29sdXRlUG9pbnQubW92ZSgwLCAodmlzaWJsZUhlaWdo dCAtIGxvZ2ljYWxIZWlnaHQoKSkgLyAyKTsKKyAgICBMYXlvdXRTdGF0ZURpc2FibGVyIGxheW91 dFN0YXRlRGlzYWJsZXIodmlldygpKTsKKyAgICBGbG9hdFBvaW50IGxvY2FsUG9pbnQgPSBjb250 YWluZXIoKS0+YWJzb2x1dGVUb0xvY2FsKGFic29sdXRlUG9pbnQpOworICAgIHNldExvZ2ljYWxU b3AoZmxvb3JlZExheW91dFNpemUobG9jYWxQb2ludCkuaGVpZ2h0KCkpOworfQorCisKK30KKwor I2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9n LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u ZGVjYTE0YjZiMzVkNGZiMzYzMjBkZTlmNjc2MmI0Y2U4YjRiNDBjOAotLS0gL2Rldi9udWxsCisr KyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaApAQCAtMCwwICsxLDYy IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgor ICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJF U1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwg REFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2lmbmRlZiBSZW5kZXJEaWFsb2dfaAorI2RlZmluZSBSZW5kZXJEaWFsb2df aAorCisjaWYgRU5BQkxFKERJQUxPR19FTEVNRU5UKQorI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgi CisjaW5jbHVkZSAiUmVuZGVyV2lkZ2V0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xh c3MgSFRNTERpYWxvZ0VsZW1lbnQ7CisKK2NsYXNzIFJlbmRlckRpYWxvZyA6IHB1YmxpYyBSZW5k ZXJCbG9jayB7CitwdWJsaWM6CisgICAgUmVuZGVyRGlhbG9nKE5vZGUqKTsKKyAgICB2aXJ0dWFs IH5SZW5kZXJEaWFsb2coKTsKKworICAgIHZvaWQgbGF5b3V0KCk7Citwcml2YXRlOgorICAgIHZp cnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0OworICAgIHZpcnR1YWwgYm9vbCBp c0RpYWxvZygpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICB2b2lkIGFkanVzdERpYWxvZ1N0 YXRpY1Bvc2l0aW9uKCk7Cit9OworCitpbmxpbmUgUmVuZGVyRGlhbG9nKiB0b1JlbmRlckRpYWxv ZyhSZW5kZXJPYmplY3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3Qt PmlzRGlhbG9nKCkpOworICAgIHJldHVybiBzdGF0aWNfY2FzdDxSZW5kZXJEaWFsb2cqPihvYmpl Y3QpOworfQorCisvLyBUaGlzIHdpbGwgY2F0Y2ggYW55b25lIGRvaW5nIGFuIHVubmVjZXNzYXJ5 IGNhc3QuCit2b2lkIHRvUmVuZGVyRGlhbG9nKGNvbnN0IFJlbmRlckRpYWxvZyopOworCit9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZgorCisjZW5kaWYgLy8gUmVuZGVyRGlhbG9nX2gK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaCBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAppbmRleCA1OGZiNTQ4OTFjNDVm ZWEwYTVlYTlhMGRlZTQ4OTAxY2VjZWU5YWMxLi44NWQzZGIyNDlkMjNmNTZhY2U3ODRiNDFiZjYy NTljNmZmMGJmZWVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCkBA IC0zMDcsNiArMzA3LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBpc0Jsb2NrRmxvdygp IGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzQm94TW9kZWxPYmpl Y3QoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc0NvdW50ZXIo KSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorI2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKKyAg ICB2aXJ0dWFsIGJvb2wgaXNEaWFsb2coKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorI2VuZGlm CiAgICAgdmlydHVhbCBib29sIGlzUXVvdGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCiAj aWYgRU5BQkxFKERFVEFJTFNfRUxFTUVOVCkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA3NWRiYTk3YjU4OGY4MTFjNzRlY2I1 ZjkzMzJkODY5ODM5MTdhOGMwLi5mNDIyMjlmYzg0OTBkNzFjOTMxYzgyNWZhZjhjZWM5YWVkMzlj YzA4IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMDgtMDYgIE1hdHQgRmFsa2VuaGFnZW4g IDxmYWxrZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFZlcnRpY2FsbHkgY2VudGVyIG5vbi1h bmNob3JlZCA8ZGlhbG9nPiBlbGVtZW50cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9OTA2NzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGRpdGlvbmFsIGluZm9ybWF0aW9uIG9mIHRoZSBjaGFuZ2Ugc3Vj aCBhcyBhcHByb2FjaCwgcmF0aW9uYWxlLiBQbGVhc2UgYWRkIHBlci1mdW5jdGlvbiBkZXNjcmlw dGlvbnMgYmVsb3cgKE9PUFMhKS4KKworICAgICAgICAqIGZhc3QvZG9tL0hUTUxEaWFsb2dFbGVt ZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQudHh0OiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9n LXBvc2l0aW9uaW5nLmh0bWw6IEFkZGVkLgorCiAyMDEyLTA4LTAzICBBbWkgRmlzY2htYW4gIDxm aXNjaG1hbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTGF5b3V0IFRlc3QgbWVkaWEvdmlkZW8t Y3VycmVudFRpbWUtc2V0Mi5odG1sIGlzIGZsYWtpbHkgY3Jhc2hpbmcKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ct cG9zaXRpb25pbmctZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9kb20vSFRNTERpYWxv Z0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uOTQwMTY0NzdhOTgxM2M2M2Y0NjA2Zjk2YzdjNjY3ZTYyMmJjMzU2YgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1h bmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTQgQEAK K1Rlc3RzIGRlZmF1bHQgcG9zaXRpb25pbmcgb2Ygbm9uLWFuY2hvcmVkIGRpYWxvZ3MuCisKK09u IHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxv d2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIHJlYWxUb3AgaXMgd2l0aGluIDEgb2Yg MjcxCitQQVNTIHJlYWxUb3AgaXMgd2l0aGluIDEgb2YgMjcxCitQQVNTIHJlYWxUb3AgaXMgd2l0 aGluIDEgb2YgMAorUEFTUyByZWFsVG9wIGlzIHdpdGhpbiAxIG9mIDI3MQorUEFTUyByZWFsVG9w IGlzIHdpdGhpbiAxIG9mIDI3MQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitU RVNUIENPTVBMRVRFCitJdCBpcyBteSBkaWFsb2cuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5n Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9y ZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOGQ5MDRhOTc1NjhkNmVmODBl OThmNDQwYjBiYzdiMGFhNjVlMmZhOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmcu aHRtbApAQCAtMCwwICsxLDgxIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8 c3R5bGU+CisuZmlsbGVyIHsKKyAgICBoZWlnaHQ6IDIwMGVtOworfQorPC9zdHlsZT4KKzxzY3Jp cHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHNj cmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKQorICAgIGludGVybmFscy5zZXR0aW5ncy5zZXRE aWFsb2dFbGVtZW50RW5hYmxlZCh0cnVlKTsKKworZnVuY3Rpb24gY2hlY2tUb3BPZlZpZXdwb3J0 KGRpYWxvZykgeworICAgIHJlYWxUb3AgPSBkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCku dG9wOworICAgIHNob3VsZEJlQ2xvc2VUbygncmVhbFRvcCcsIDAsIDEpOworfQorCitmdW5jdGlv biBjaGVja0NlbnRlcmVkKGRpYWxvZykgeworICAgIGV4cGVjdGVkVG9wID0gKHdpbmRvdy5pbm5l ckhlaWdodCAtIGRpYWxvZy5vZmZzZXRIZWlnaHQpIC8gMjsKKyAgICByZWFsVG9wID0gZGlhbG9n LmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcDsKKyAgICBzaG91bGRCZUNsb3NlVG8oJ3JlYWxU b3AnLCBleHBlY3RlZFRvcCwgMSk7Cit9Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorICAg IDxkaWFsb2cgaWQ9Im15ZGlhbG9nIj5JdCBpcyBteSBkaWFsb2cuPC9kaWFsb2c+CisgICAgPGRp diBjbGFzcz0iZmlsbGVyIj48L2Rpdj4KKzwvYm9keT4KKzxzY3JpcHQ+CitkZXNjcmlwdGlvbigi VGVzdHMgZGVmYXVsdCBwb3NpdGlvbmluZyBvZiBub24tYW5jaG9yZWQgZGlhbG9ncy4iKTsKKwor ZGlhbG9nID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ215ZGlhbG9nJyk7CisKKworLy8gRGlh bG9nIHNob3VsZCBiZSBjZW50ZXJlZCBpbiB0aGUgdmlld3BvcnQuCitkaWFsb2cuc2hvdygpOwor Y2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIERpYWxvZyBzaG91 bGQgc3RpbGwgYmUgY2VudGVyZWQgaWYgc2hvd24gYWZ0ZXIgd2luZG93IGlzIHNjcm9sbGVkLgor d2luZG93LnNjcm9sbCgwLCA1MDApOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlh bG9nKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBBIHRhbGwgZGlhbG9nIHNob3VsZCBiZSBwb3Np dGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhlIHZpZXdwb3J0LgordmFyIGRpYWxvZ0lubmVyID0gZG9j dW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CitkaWFsb2dJbm5lci5jbGFzc05hbWUgPSAnZmls bGVyJzsKK2RpYWxvZy5hcHBlbmRDaGlsZChkaWFsb2dJbm5lcik7CitkaWFsb2cuc2hvdygpOwor Y2hlY2tUb3BPZlZpZXdwb3J0KGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKK2RpYWxvZy5yZW1v dmVDaGlsZChkaWFsb2dJbm5lcik7CisKKy8vIFRlc3QgdGhhdCBjZW50ZXJpbmcgd29ya3Mgd2hl biBkaWFsb2cgaXMgaW5zaWRlIHBvc2l0aW9uZWQgY29udGFpbmVycy4KK3ZhciBjb250YWluZXIg PSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2NvbnRhaW5lci5zdHlsZS5wb3NpdGlv biA9ICdhYnNvbHV0ZSc7Citjb250YWluZXIuc3R5bGUudG9wID0gJzUwZW07JworY29udGFpbmVy LnN0eWxlLmhlaWdodD0gJzNlbTsnCitjb250YWluZXIuc3R5bGUud2lkdGggPSAnMTAwJSc7Citk aWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChkaWFsb2cpOworZG9jdW1lbnQuYm9keS5hcHBl bmRDaGlsZChjb250YWluZXIpOworY29udGFpbmVyLmFwcGVuZENoaWxkKGRpYWxvZyk7CitkaWFs b2cuc2hvdygpOworY2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7Citjb250 YWluZXIucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKKwordmFyIGNvbnRhaW5lcjIgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KCdkaXYnKTsKK2NvbnRhaW5lcjIuc3R5bGUucG9zaXRpb24gPSAncmVsYXRp dmUnOworY29udGFpbmVyMi5zdHlsZS50b3AgPSAnMjBlbSc7Citjb250YWluZXIyLnN0eWxlLndp ZHRoID0gJzEwMCUnOworY29udGFpbmVyLmFwcGVuZENoaWxkKGNvbnRhaW5lcjIpOworY29udGFp bmVyMi5hcHBlbmRDaGlsZChkaWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQo ZGlhbG9nKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10 ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 157655 2012-08-10 00:39:54 -0700 2012-08-14 03:29:41 -0700 WIP patch using setStaticBlockPosition bug-90670-20120810163925.patch text/plain 16257 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI1MTkwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTlhMDNhZWU5ZTljZDBj ZGEwMjNmYjk1YzBjMDFjNjNmNTI0YjBiNi4uZDgyYzY1MjljNGE0MTA4NjUxZjg2ZDc4ZTlkN2Y5 ZGZjN2FmZjc1YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA4LTEwICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9kb20vSFRNTERpYWxvZ0Vs ZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sCisKKyAgICAgICAgKiBX ZWJDb3JlLmd5cGk6CisgICAgICAgICogYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1lRW5hYmxlZEZl YXR1cmVzLmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGh0bWwvSFRNTERpYWxv Z0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTERpYWxvZ0VsZW1lbnQ6OmNyZWF0 ZVJlbmRlcmVyKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIGh0bWwvSFRNTERpYWxv Z0VsZW1lbnQuaDoKKyAgICAgICAgKEhUTUxEaWFsb2dFbGVtZW50KToKKyAgICAgICAgKiByZW5k ZXJpbmcvUmVuZGVyQm94LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJveDo6Y29tcHV0 ZVBvc2l0aW9uZWRMb2dpY2FsSGVpZ2h0KTogU2V0IHRoZSBzdGF0aWMgcG9zaXRpb24gZm9yIGRp YWxvZ3MuIERvIHRoZSByZXZlcnNlIG9mIGNvbXB1dGVCbG9ja1N0YXRpY0Rpc3RhbmNlJ3MKKyAg ICAgICAgc3VtbWF0aW9uIG9mIGFuY2VzdG9yIGNvbnRhaW5lciB0b3AncyBzbyB0aGF0IGl0IHdp bGwgdWx0aW1hdGVseSBzZXQgZGlhbG9nJ3MgdG9wIHN1Y2ggdGhhdCBpdCBpcyBjZW50ZXJlZC4K KyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcDoKKyAgICAgICAgKFdlYkNvcmUp OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyRGlhbG9nOjpSZW5kZXJEaWFsb2cpOgorICAgICAg ICAoV2ViQ29yZTo6UmVuZGVyRGlhbG9nOjp+UmVuZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNv cmU6OlJlbmRlckRpYWxvZzo6cmVuZGVyTmFtZSk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRl ckRpYWxvZy5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChSZW5kZXJEaWFsb2cpOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyRGlhbG9nOjppc0RpYWxvZyk6CisgICAgICAgIChXZWJD b3JlOjp0b1JlbmRlckRpYWxvZyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVjdC5o OgorICAgICAgICAoUmVuZGVyT2JqZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVj dDo6aXNEaWFsb2cpOgorCiAyMDEyLTA4LTA5ICBJYWluIE1lcnJpY2sgIDxodXNreUBjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgW2Nocm9taXVtXSBFbmFibGUga2VybmluZyBvbiBBbmRyb2lkCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLmd5cGkKaW5kZXggMGIwYzJmMGU1NDE4MDFjODhiMzkzYzJmMzNlYzY4OTM0ZTZmZWU2 OS4uYzQ3YjMzYWUwOTkzMjE4YWIyMjljMzg1MjBkODMzMjEwYWRkNDNiMiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu Z3lwaQpAQCAtNTUxLDYgKzU1MSw3IEBACiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckJs b2NrLmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJCb3guaCcsCiAgICAgICAgICAg ICAncmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgnLAorICAgICAgICAgICAgJ3JlbmRl cmluZy9SZW5kZXJEaWFsb2cuaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckVtYmVk ZGVkT2JqZWN0LmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJGbG93VGhyZWFkLmgn LAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJJbWFnZS5oJywKQEAgLTQ2OTMsNiArNDY5 NCw3IEBACiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRlcHJlY2F0ZWRGbGV4aWJsZUJv eC5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5jcHAnLAog ICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXRhaWxzTWFya2VyLmgnLAorICAgICAgICAg ICAgJ3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcv UmVuZGVyRW1iZWRkZWRPYmplY3QuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVy RmllbGRzZXQuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmllbGRzZXQuaCcs CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFi bGVkRmVhdHVyZXMuY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvZ2VuZXJpYy9SdW50aW1l RW5hYmxlZEZlYXR1cmVzLmNwcAppbmRleCA1OWVjMDYyOGQzOTdjMjU4OTdjOWRiODRmMjIxNTU4 NDdhYzhiNDJmLi5iZDQ1MmY0NjU1YzdkMDhmNGYwMjJjN2ViOTM1NzE0OTA5NjdkNDBiIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9nZW5lcmljL1J1bnRpbWVFbmFibGVkRmVh dHVyZXMuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2dlbmVyaWMvUnVudGltZUVu YWJsZWRGZWF0dXJlcy5jcHAKQEAgLTI0MSw3ICsyNDEsNyBAQCBib29sIFJ1bnRpbWVFbmFibGVk RmVhdHVyZXM6OmlzSW5wdXRUeXBlV2Vla0VuYWJsZWQgPSB0cnVlOwogI2VuZGlmCiAKICNpZiBF TkFCTEUoRElBTE9HX0VMRU1FTlQpCi1ib29sIFJ1bnRpbWVFbmFibGVkRmVhdHVyZXM6OmlzRGlh bG9nRWxlbWVudEVuYWJsZWQgPSBmYWxzZTsKK2Jvb2wgUnVudGltZUVuYWJsZWRGZWF0dXJlczo6 aXNEaWFsb2dFbGVtZW50RW5hYmxlZCA9IHRydWU7CiAjZW5kaWYKIAogfSAvLyBuYW1lc3BhY2Ug V2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVu dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcAppbmRleCA0 NTEwZDgxNDMxOWMyZTU0MzhlOTMyNzc1Y2FjZDFjMGRkMjNiYTI1Li41Mzc0MzI5NjAzMDg3NzA3 NTc4OWJjMWNlYTc1MDkzNzc5NjdhYzg5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxEaWFsb2dFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFs b2dFbGVtZW50LmNwcApAQCAtMjksNiArMjksNyBAQAogI2lmIEVOQUJMRShESUFMT0dfRUxFTUVO VCkKIAogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKKyNpbmNsdWRlICJSZW5kZXJEaWFsb2cu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC03MSw2ICs3MiwxMSBAQCBib29sIEhUTUxE aWFsb2dFbGVtZW50Ojppc1ByZXNlbnRhdGlvbkF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWROYW1l JiBuYW1lKSBjb25zdAogICAgIHJldHVybiBIVE1MRWxlbWVudDo6aXNQcmVzZW50YXRpb25BdHRy aWJ1dGUobmFtZSk7CiB9CiAKK1JlbmRlck9iamVjdCogSFRNTERpYWxvZ0VsZW1lbnQ6OmNyZWF0 ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKQoreworICAgIHJldHVy biBuZXcgKGFyZW5hKSBSZW5kZXJEaWFsb2codGhpcyk7Cit9CisKIH0KIAogI2VuZGlmCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmggYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmgKaW5kZXggZDFkZDc3Njg5NTQzZjQ0NzJh ZWQ5NzRiM2ZmNzQ3N2FhMDEyNmRhYS4uOGE5Mjk5MDUyMzMzMjZiNzg3YWIyYmM3YWM1YmQ0ZGI2 NjlkNDYwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVu dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuaApAQCAtNDQs NiArNDQsNyBAQCBwdWJsaWM6CiAKIHByaXZhdGU6CiAgICAgSFRNTERpYWxvZ0VsZW1lbnQoY29u c3QgUXVhbGlmaWVkTmFtZSYsIERvY3VtZW50Kik7CisgICAgdmlydHVhbCBSZW5kZXJPYmplY3Qq IGNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiwgUmVuZGVyU3R5bGUqKSBPVkVSUklERTsKIAog ICAgIHZpcnR1YWwgYm9vbCBpc1ByZXNlbnRhdGlvbkF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWRO YW1lJikgY29uc3QgT1ZFUlJJREU7CiB9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94 LmNwcAppbmRleCBlMDI1NTM0YTMyNmYxNjcyYmQwYjllYjU3MjU5MjAyOGY4ZDU0ZDQ4Li44MmU5 NDI0ZTY5MzhiNTc1MzdkMDJmZDk0OTdhMWM3NTY5OGJmYTI1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtMjkwMCw2ICsyOTAwLDI3IEBAIHZvaWQgUmVuZGVyQm94 Ojpjb21wdXRlUG9zaXRpb25lZExvZ2ljYWxIZWlnaHQoKQogICAgICAqIHRoZSB2aWV3cG9ydC4K ICAgICBcKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCiAKKyAgICAvLyBTZXQgZGlhbG9nJ3Mgc3RhdGlj IHBvc2l0aW9uIGZvciB0b3AuCisgICAgaWYgKGlzRGlhbG9nKCkpIHsKKyAgICAgICAgTGF5b3V0 U3RhdGVEaXNhYmxlciBsYXlvdXRTdGF0ZURpc2FibGVyKHZpZXcoKSk7CisgICAgICAgIEZyYW1l VmlldyogZnJhbWVWaWV3ID0gZG9jdW1lbnQoKS0+dmlldygpOworICAgICAgICBpbnQgc2Nyb2xs VG9wID0gZnJhbWVWaWV3LT5zY3JvbGxPZmZzZXQoKS5oZWlnaHQoKTsKKyAgICAgICAgRmxvYXRQ b2ludCBhYnNvbHV0ZVBvaW50KDAsIHNjcm9sbFRvcCk7CisgICAgICAgIGludCB2aXNpYmxlSGVp Z2h0ID0gZnJhbWVWaWV3LT52aXNpYmxlSGVpZ2h0KCk7CisgICAgICAgIGlmIChsb2dpY2FsSGVp Z2h0KCkgPCB2aXNpYmxlSGVpZ2h0KQorICAgICAgICAgICAgYWJzb2x1dGVQb2ludC5tb3ZlKDAs ICh2aXNpYmxlSGVpZ2h0IC0gbG9naWNhbEhlaWdodCgpKSAvIDIpOworICAgICAgICBGbG9hdFBv aW50IGxvY2FsUG9pbnQgPSBjb250YWluZXIoKS0+YWJzb2x1dGVUb0xvY2FsKGFic29sdXRlUG9p bnQpOworICAgICAgICBMYXlvdXRVbml0IGxvY2FsVG9wID0gTGF5b3V0U2l6ZShsb2NhbFBvaW50 LngoKSwgbG9jYWxQb2ludC55KCkpLmhlaWdodCgpOworCisgICAgICAgIGxvY2FsVG9wICs9IGNv bnRhaW5lckJsb2NrLT5ib3JkZXJCZWZvcmUoKTsKKyAgICAgICAgZm9yIChSZW5kZXJPYmplY3Qq IGN1cnIgPSBwYXJlbnQoKTsgY3VyciAmJiBjdXJyICE9IGNvbnRhaW5lckJsb2NrOyBjdXJyID0g Y3Vyci0+Y29udGFpbmVyKCkpIHsKKyAgICAgICAgICAgIGlmIChjdXJyLT5pc0JveCgpICYmICFj dXJyLT5pc1RhYmxlUm93KCkpCisgICAgICAgICAgICAgICAgbG9jYWxUb3AgLT0gdG9SZW5kZXJC b3goY3VyciktPmxvZ2ljYWxUb3AoKTsKKyAgICAgICAgfQorCisgICAgICAgIGxheWVyKCktPnNl dFN0YXRpY0Jsb2NrUG9zaXRpb24obG9jYWxUb3ApOworICAgIH0KKwogICAgIC8vIHNlZSBGSVhN RSAxCiAgICAgLy8gQ2FsY3VsYXRlIHRoZSBzdGF0aWMgZGlzdGFuY2UgaWYgbmVlZGVkLgogICAg IGNvbXB1dGVCbG9ja1N0YXRpY0Rpc3RhbmNlKGxvZ2ljYWxUb3BMZW5ndGgsIGxvZ2ljYWxCb3R0 b21MZW5ndGgsIHRoaXMsIGNvbnRhaW5lckJsb2NrKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckRpYWxvZy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODMzN2RkMzA3YTg0OWU2MGQ3MTZmMTU1ZWI0 Y2VkZmU5NTVjYTkzNQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJEaWFsb2cuY3BwCkBAIC0wLDAgKzEsNzAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJ QlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29u ZmlnLmgiCisjaW5jbHVkZSAiUmVuZGVyRGlhbG9nLmgiCisKKyNpZiBFTkFCTEUoRElBTE9HX0VM RU1FTlQpCisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiUmVuZGVyTGF5ZXIuaCIK KyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordXNpbmcg bmFtZXNwYWNlIEhUTUxOYW1lczsKKworUmVuZGVyRGlhbG9nOjpSZW5kZXJEaWFsb2coTm9kZSog bm9kZSkKKyAgICA6IFJlbmRlckJsb2NrKG5vZGUpCit7Cit9CisKK1JlbmRlckRpYWxvZzo6flJl bmRlckRpYWxvZygpCit7Cit9CisKK2NvbnN0IGNoYXIqIFJlbmRlckRpYWxvZzo6cmVuZGVyTmFt ZSgpIGNvbnN0Cit7CisgICAgaWYgKGlzRmxvYXRpbmcoKSkKKyAgICAgICAgcmV0dXJuICJSZW5k ZXJEaWFsb2cgKGZsb2F0aW5nKSI7CisgICAgaWYgKGlzT3V0T2ZGbG93UG9zaXRpb25lZCgpKQor ICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAocG9zaXRpb25lZCkiOworICAgIGlmIChpc0Fu b255bW91c0NvbHVtbnNCbG9jaygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAoYW5v bnltb3VzIG11bHRpLWNvbHVtbikiOworICAgIGlmIChpc0Fub255bW91c0NvbHVtblNwYW5CbG9j aygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAoYW5vbnltb3VzIG11bHRpLWNvbHVt biBzcGFuKSI7CisgICAgaWYgKGlzQW5vbnltb3VzQmxvY2soKSkKKyAgICAgICAgcmV0dXJuICJS ZW5kZXJEaWFsb2cgKGFub255bW91cykiOworICAgIGlmIChpc0Fub255bW91cygpKQorICAgICAg ICByZXR1cm4gIlJlbmRlckRpYWxvZyAoZ2VuZXJhdGVkKSI7CisgICAgaWYgKGlzUmVsUG9zaXRp b25lZCgpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAocmVsYXRpdmUgcG9zaXRpb25l ZCkiOworICAgIGlmIChpc1J1bkluKCkpCisgICAgICAgIHJldHVybiAiUmVuZGVyRGlhbG9nIChy dW4taW4pIjsKKyAgICByZXR1cm4gIlJlbmRlckRpYWxvZyI7Cit9CisKK30KKworI2VuZGlmCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmggYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzc1MDVkMmZh NjA5NjYyZmE5ZDkyMzkyYTc5NzZkZjdkZjFiNjY5MAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaApAQCAtMCwwICsxLDYwIEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBt dXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICog ICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBM RSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1Q TElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJ RUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAq IE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2lmbmRlZiBSZW5kZXJEaWFsb2dfaAorI2RlZmluZSBSZW5kZXJEaWFsb2dfaAorCisjaWYg RU5BQkxFKERJQUxPR19FTEVNRU5UKQorI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCisjaW5jbHVk ZSAiUmVuZGVyV2lkZ2V0LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgSFRNTERp YWxvZ0VsZW1lbnQ7CisKK2NsYXNzIFJlbmRlckRpYWxvZyA6IHB1YmxpYyBSZW5kZXJCbG9jayB7 CitwdWJsaWM6CisgICAgUmVuZGVyRGlhbG9nKE5vZGUqKTsKKyAgICB2aXJ0dWFsIH5SZW5kZXJE aWFsb2coKTsKKworcHJpdmF0ZToKKyAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUo KSBjb25zdDsKKyAgICB2aXJ0dWFsIGJvb2wgaXNEaWFsb2coKSBjb25zdCB7IHJldHVybiB0cnVl OyB9Cit9OworCitpbmxpbmUgUmVuZGVyRGlhbG9nKiB0b1JlbmRlckRpYWxvZyhSZW5kZXJPYmpl Y3QqIG9iamVjdCkKK3sKKyAgICBBU1NFUlQoIW9iamVjdCB8fCBvYmplY3QtPmlzRGlhbG9nKCkp OworICAgIHJldHVybiBzdGF0aWNfY2FzdDxSZW5kZXJEaWFsb2cqPihvYmplY3QpOworfQorCisv LyBUaGlzIHdpbGwgY2F0Y2ggYW55b25lIGRvaW5nIGFuIHVubmVjZXNzYXJ5IGNhc3QuCit2b2lk IHRvUmVuZGVyRGlhbG9nKGNvbnN0IFJlbmRlckRpYWxvZyopOworCit9IC8vIG5hbWVzcGFjZSBX ZWJDb3JlCisKKyNlbmRpZgorCisjZW5kaWYgLy8gUmVuZGVyRGlhbG9nX2gKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAppbmRleCA4M2MzNjA1NzAzMjFmNWFmMDNhMjk3YjMy NjJkOTg0MWRhM2JmYzg5Li45YTE3YzczNjdiNWIwNGU2NDVhY2Y1MmUwMTMyNzdlNTkyYzE5YmEy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKKysr IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCkBAIC0zMDcsNiArMzA3 LDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBpc0Jsb2NrRmxvdygpIGNvbnN0IHsgcmV0 dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzQm94TW9kZWxPYmplY3QoKSBjb25zdCB7 IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc0NvdW50ZXIoKSBjb25zdCB7IHJl dHVybiBmYWxzZTsgfQorI2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKKyAgICB2aXJ0dWFsIGJv b2wgaXNEaWFsb2coKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorI2VuZGlmCiAgICAgdmlydHVh bCBib29sIGlzUXVvdGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCiAjaWYgRU5BQkxFKERF VEFJTFNfRUxFTUVOVCkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91 dFRlc3RzL0NoYW5nZUxvZwppbmRleCBmNDc1NWQwNzE3NDMwZmExMmNlMzgyMmRmNWRiYWI5Yzhi NTE1NTQ4Li5lZDk5NWU1ZGRmOWE5OTAyMjZlM2U1ZDkxNTgzMzQyOWUwZWQxMzZiIDEwMDY0NAot LS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTMgQEAKKzIwMTItMDgtMTAgIE1hdHQgRmFsa2VuaGFnZW4gIDxmYWxrZW5AY2hy b21pdW0ub3JnPgorCisgICAgICAgIFZlcnRpY2FsbHkgY2VudGVyIG5vbi1hbmNob3JlZCA8ZGlh bG9nPiBlbGVtZW50cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9OTA2NzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIGZhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9z aXRpb25pbmctZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRGlh bG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWw6IEFkZGVkLgor CiAyMDEyLTA4LTA5ICBGbG9yaW4gTWFsaXRhICA8Zm1hbGl0YUBjaHJvbWl1bS5vcmc+CiAKICAg ICAgICAgW0Nocm9taXVtXSBVcGRhdGVkIGV4cGVjdGF0aW9ucyBmb3Igc2NyaXB0LWNoYW5nZS1l eHRlcm5hbFJlc291cmNlc1JlcXVpcmVkLXdoaWxlLWxvYWRpbmcuc3ZnCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9n LXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFs b2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQudHh0Cm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAuLjBlMjY0ZTFmMzE5NGVhMWM1ODJhNDgwYTJlYzY1Zjg4YzRjNzdkYWYKLS0tIC9k ZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24t YW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE1IEBA CitUZXN0cyBkZWZhdWx0IHBvc2l0aW9uaW5nIG9mIG5vbi1hbmNob3JlZCBkaWFsb2dzLgorCitP biBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xs b3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyByZWFsVG9wIGlzIHdpdGhpbiAxIG9m IDI3MQorUEFTUyByZWFsVG9wIGlzIHdpdGhpbiAxIG9mIDI3MQorUEFTUyByZWFsVG9wIGlzIHdp dGhpbiAxIG9mIDAKK1BBU1MgcmVhbFRvcCBpcyB3aXRoaW4gMSBvZiAyNzEKK1BBU1MgcmVhbFRv cCBpcyB3aXRoaW4gMSBvZiAyNzEKK1BBU1MgcmVhbFRvcCBpcyB3aXRoaW4gMSBvZiAyNzEKK1BB U1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQt ZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9n RWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u NmZhMDdmMjYwNmMxNGNiMDE1OWNkNzQwYTI5ZWQyMGQ2MDgzMjM3NAotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1k aWFsb2ctcG9zaXRpb25pbmcuaHRtbApAQCAtMCwwICsxLDg4IEBACis8IURPQ1RZUEUgaHRtbD4K KzxodG1sPgorPGhlYWQ+Cis8c3R5bGU+CisuZmlsbGVyIHsKKyAgICBoZWlnaHQ6IDIwMGVtOwor fQorPC9zdHlsZT4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUu anMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKQorICAgIGludGVy bmFscy5zZXR0aW5ncy5zZXREaWFsb2dFbGVtZW50RW5hYmxlZCh0cnVlKTsKKworZnVuY3Rpb24g Y2hlY2tUb3BPZlZpZXdwb3J0KGRpYWxvZykgeworICAgIHJlYWxUb3AgPSBkaWFsb2cuZ2V0Qm91 bmRpbmdDbGllbnRSZWN0KCkudG9wOworICAgIHNob3VsZEJlQ2xvc2VUbygncmVhbFRvcCcsIDAs IDEpOworfQorCitmdW5jdGlvbiBjaGVja0NlbnRlcmVkKGRpYWxvZykgeworICAgIGV4cGVjdGVk VG9wID0gKHdpbmRvdy5pbm5lckhlaWdodCAtIGRpYWxvZy5vZmZzZXRIZWlnaHQpIC8gMjsKKyAg ICByZWFsVG9wID0gZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcDsKKyAgICBzaG91 bGRCZUNsb3NlVG8oJ3JlYWxUb3AnLCBleHBlY3RlZFRvcCwgMSk7Cit9Cis8L3NjcmlwdD4KKzwv aGVhZD4KKzxib2R5PgorICAgIDxkaWFsb2cgaWQ9Im15ZGlhbG9nIj5JdCBpcyBteSBkaWFsb2cu PC9kaWFsb2c+CisgICAgPGRpdiBjbGFzcz0iZmlsbGVyIj48L2Rpdj4KKzwvYm9keT4KKzxzY3Jp cHQ+CitkZXNjcmlwdGlvbigiVGVzdHMgZGVmYXVsdCBwb3NpdGlvbmluZyBvZiBub24tYW5jaG9y ZWQgZGlhbG9ncy4iKTsKKworZGlhbG9nID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ215ZGlh bG9nJyk7CisKKy8vIERpYWxvZyBzaG91bGQgYmUgY2VudGVyZWQgaW4gdGhlIHZpZXdwb3J0Lgor ZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxvZy5jbG9zZSgpOwor CisvLyBEaWFsb2cgc2hvdWxkIHN0aWxsIGJlIGNlbnRlcmVkIGlmIHNob3duIGFmdGVyIHdpbmRv dyBpcyBzY3JvbGxlZC4KK3dpbmRvdy5zY3JvbGwoMCwgNTAwKTsKK2RpYWxvZy5zaG93KCk7Citj aGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8gQSB0YWxsIGRpYWxv ZyBzaG91bGQgYmUgcG9zaXRpb25lZCBhdCB0aGUgdG9wIG9mIHRoZSB2aWV3cG9ydC4KK3ZhciBk aWFsb2dJbm5lciA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworZGlhbG9nSW5uZXIu Y2xhc3NOYW1lID0gJ2ZpbGxlcic7CitkaWFsb2cuYXBwZW5kQ2hpbGQoZGlhbG9nSW5uZXIpOwor ZGlhbG9nLnNob3coKTsKK2NoZWNrVG9wT2ZWaWV3cG9ydChkaWFsb2cpOworZGlhbG9nLmNsb3Nl KCk7CitkaWFsb2cucmVtb3ZlQ2hpbGQoZGlhbG9nSW5uZXIpOworCisvLyBUZXN0IHRoYXQgY2Vu dGVyaW5nIHdvcmtzIHdoZW4gZGlhbG9nIGlzIGluc2lkZSBwb3NpdGlvbmVkIGNvbnRhaW5lcnMu Cit2YXIgY29udGFpbmVyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Citjb250YWlu ZXIuc3R5bGUucG9zaXRpb24gPSAnYWJzb2x1dGUnOworY29udGFpbmVyLnN0eWxlLnRvcCA9ICc1 MGVtOycKK2NvbnRhaW5lci5zdHlsZS5oZWlnaHQ9ICczZW07JworY29udGFpbmVyLnN0eWxlLndp ZHRoID0gJzEwMCUnOworZGlhbG9nLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKK2Rv Y3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoY29udGFpbmVyKTsKK2NvbnRhaW5lci5hcHBlbmRDaGls ZChkaWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxv Zy5jbG9zZSgpOworY29udGFpbmVyLnJlbW92ZUNoaWxkKGRpYWxvZyk7CisKK3ZhciBjb250YWlu ZXIyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Citjb250YWluZXIyLnN0eWxlLnBv c2l0aW9uID0gJ3JlbGF0aXZlJzsKK2NvbnRhaW5lcjIuc3R5bGUudG9wID0gJzIwZW0nOworY29u dGFpbmVyMi5zdHlsZS5sZWZ0ID0gMDsKK2NvbnRhaW5lcjIuc3R5bGUucmlnaHQgPSAwOworY29u dGFpbmVyLmFwcGVuZENoaWxkKGNvbnRhaW5lcjIpOworY29udGFpbmVyMi5hcHBlbmRDaGlsZChk aWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxvZy5j bG9zZSgpOworCisvLyBSZW1vdmUgdGhlIGhvcml6b250YWwgc2Nyb2xsYmFyLiBUaGUgZGlhbG9n IHNob3VsZCBiZSBjZW50ZXJlZCByZWdhcmRsZXNzIG9mIHRoZSBwcmVzZW5jZSBvZiBzY3JvbGxi YXJzLgorY29udGFpbmVyLnN0eWxlLndpZHRoID0gJzkwJSc7CitkaWFsb2cuc2hvdygpOworY2hl Y2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7Cis8L3NjcmlwdD4KKzxzY3JpcHQg c3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9k eT4KKzwvaHRtbD4K 158279 2012-08-14 03:29:47 -0700 2012-09-03 04:11:11 -0700 Patch bug-90670-20120814192914.patch text/plain 21474 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI1NDExCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmVjMGUzMjM1MGZiN2E3 M2ExMWU3MmQyYTM5ODM3NzQ5ZmVkOWY4YS4uZGYwYTY5ZDFjODE2NDE2YjU3NzQ5NWY2YTM1NDU4 ZDhhODFhNTJjYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEyLTA4LTE0ICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBhZGp1c3RzIHRoZSBzdGF0aWMgZGVm YXVsdCBwb3NpdGlvbiBvZiBub24tYW5jaG9yZWQgZGlhbG9nIGVsZW1lbnRzIHNvIHRoZXkgYXJl IHZlcnRpY2FsbHkgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZiB0aGUKKyAgICAgICAgdmll d3BvcnQsIGFzIHBlciB0aGUgc3BlYy4KKworICAgICAgICBUaGUgYXBwcm9hY2ggaXMgdG8gYWRk IGEgUmVuZGVyRGlhbG9nIGNsYXNzIHdob3NlIGxheW91dCgpIGZ1bmN0aW9uIGFkanVzdHMgdGhl IHBvc2l0aW9uIGFmdGVyIG5vcm1hbCBSZW5kZXJCbG9jazo6bGF5b3V0IHJ1bnMuCisgICAgICAg IFRoaXMgc2VlbXMgY2xlYW5lciB0aGFuIGFkZGluZyBzcGVjaWFsIGNhc2VzIGZvciBkaWFsb2cg aW4gZXhpc3RpbmcgbGF5b3V0IGNvZGUuCisKKyAgICAgICAgVGVzdDogZmFzdC9kb20vSFRNTERp YWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sCisKKyAgICAg ICAgKiBXZWJDb3JlLmd5cGk6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qOgorICAgICAgICAqIGh0bWwvSFRNTERpYWxvZ0VsZW1lbnQuY3BwOgorICAgICAgICAo V2ViQ29yZTo6SFRNTERpYWxvZ0VsZW1lbnQ6OmNyZWF0ZVJlbmRlcmVyKToKKyAgICAgICAgKFdl YkNvcmUpOgorICAgICAgICAqIGh0bWwvSFRNTERpYWxvZ0VsZW1lbnQuaDoKKyAgICAgICAgKEhU TUxEaWFsb2dFbGVtZW50KToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcDog QWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxv Zzo6UmVuZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6flJlbmRl ckRpYWxvZyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OnJlbmRlck5hbWUpOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyRGlhbG9nOjpsYXlvdXQpOiBDb21wdXRlIHRoZSBkZXNp cmVkIHRvcCBwb3NpdGlvbiBpbiB0aGUgYWJzb2x1dGUgY29vcmRpbmF0ZSBzeXN0ZW0sIGFuZCB0 aGVuIHNldCB0b3AgdG8gdGhlCisgICAgICAgIGNvcnJlc3BvbmRpbmcgbG9jYWwgY29vcmRpbmF0 ZS4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmg6CisgICAgICAgIChXZWJDb3Jl KToKKyAgICAgICAgKFJlbmRlckRpYWxvZyk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJEaWFs b2c6OmlzRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OnRvUmVuZGVyRGlhbG9nKToKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6CisgICAgICAgIChSZW5kZXJPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0Ojppc0RpYWxvZyk6CisKIDIwMTItMDgtMTMg IEt3YW5nIFl1bCBTZW8gIDxza3l1bEBjb21wYW55MTAwLm5ldD4KIAogICAgICAgICBbUXRdIEFk ZCBncHJvZi5wcmYgdG8gYnVpbGQgV2ViS2l0IHdpdGggZ3Byb2YgZW5hYmxlZApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5n eXBpCmluZGV4IDE4NDA0OWE1NTQ1OWE0YTQ0ZTA1YzMzNjE5NWFkYjFiMjA5OTI5MDEuLjEyZjg1 MTYzNTNjOTkwODVjOGMyNWM3MWIyOTVlOWQ2MjA1Yzk1NTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAg LTU1Miw2ICs1NTIsNyBAQAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJCbG9jay5oJywK ICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyQm94LmgnLAogICAgICAgICAgICAgJ3JlbmRl cmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5oJywKKyAgICAgICAgICAgICdyZW5kZXJpbmcvUmVu ZGVyRGlhbG9nLmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJFbWJlZGRlZE9iamVj dC5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmxvd1RocmVhZC5oJywKICAgICAg ICAgICAgICdyZW5kZXJpbmcvUmVuZGVySW1hZ2UuaCcsCkBAIC00NjkxLDYgKzQ2OTIsNyBAQAog ICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3guaCcsCiAg ICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIuY3BwJywKICAgICAgICAg ICAgICdyZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5oJywKKyAgICAgICAgICAgICdyZW5k ZXJpbmcvUmVuZGVyRGlhbG9nLmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckVt YmVkZGVkT2JqZWN0LmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0 LmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0LmgnLApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIv U291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDZk MDhjMzEzYjNkN2M3MGEzNTBkYTRlMTU2YTlkMmFmNDBkNmUzNmUuLjQ4YmJjM2QyYzI5ODdjYjc3 MjVjYTU2ZTBlNDYxOWRhZTY2ZDYwNGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE4OTgsNiArMTg5OCw4IEBACiAJCTc2Q0RE MkY1MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RQb3B1cC5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZDREQyRUYxMTAzREE2 NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdFBvcHVwLmggKi87IH07CiAJCTc2Q0RE MkY2MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24uY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZDREQyRjAxMTAz REE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5jcHAgKi87IH07CiAJ CTc2Q0REMkY3MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24u aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2Q0REMkYx MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24uaCAqLzsgfTsK KwkJNzZEQzE3RTcxNUQzQUMxNDAwNjNDRjREIC8qIFJlbmRlckRpYWxvZy5jcHAgaW4gU291cmNl cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkRDMTdFNTE1RDNBQzE0MDA2 M0NGNEQgLyogUmVuZGVyRGlhbG9nLmNwcCAqLzsgfTsKKwkJNzZEQzE3RTgxNUQzQUMxNDAwNjND RjREIC8qIFJlbmRlckRpYWxvZy5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gNzZEQzE3RTYxNUQzQUMxNDAwNjNDRjREIC8qIFJlbmRlckRpYWxvZy5oICov OyB9OwogCQk3NkZDMkIwQjEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2RkMyQjA4MTIzNzBE QTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuY3BwICovOyB9OwogCQk3NkZDMkIwQzEyMzcwREEw MDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWls ZEZpbGU7IGZpbGVSZWYgPSA3NkZDMkIwOTEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0 LmggKi87IH07CiAJCTc2RkYxN0UzMTEyMzU2NzMwMDFENjFCNSAvKiBQbHVnaW5WaWV3Tm9uZS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkZGMTdF MjExMjM1NjczMDAxRDYxQjUgLyogUGx1Z2luVmlld05vbmUuY3BwICovOyB9OwpAQCAtOTA2MCw2 ICs5MDYyLDggQEAKIAkJNzZDREQyRUYxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlN ZW51TGlzdFBvcHVwLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2li aWxpdHlNZW51TGlzdFBvcHVwLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2Q0RE MkYwMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24uY3BwICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQWNjZXNzaWJpbGl0eU1lbnVMaXN0 T3B0aW9uLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzZDREQyRjExMTAzREE2 NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24uaDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzZEQzE3RTUxNUQzQUMxNDAwNjNDRjREIC8qIFJlbmRl ckRpYWxvZy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBSZW5kZXJE aWFsb2cuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk3NkRDMTdFNjE1RDNBQzE0 MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9nLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0 aCA9IFJlbmRlckRpYWxvZy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NkZDMkIw ODEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IERPTVRva2VuTGlzdC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTc2RkMyQjA5MTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuaCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NVG9rZW5MaXN0Lmg7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCTc2RkMyQjBBMTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxp c3QuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IERPTVRva2VuTGlzdC5pZGw7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMTI1OCw2ICsyMTI2Miw4IEBACiAJCQkJQkNFQjE3OUIx NDMzNzlGNTAwNTJFQUU5IC8qIFJlbmRlckJveFJlZ2lvbkluZm8uaCAqLywKIAkJCQlCQ0VBNDgy NDA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQlIuY3BwICovLAogCQkJCUJDRUE0ODI1MDk3RDkz MDIwMDk0QzlFNCAvKiBSZW5kZXJCUi5oICovLAorCQkJCTc2REMxN0U1MTVEM0FDMTQwMDYzQ0Y0 RCAvKiBSZW5kZXJEaWFsb2cuY3BwICovLAorCQkJCTc2REMxN0U2MTVEM0FDMTQwMDYzQ0Y0RCAv KiBSZW5kZXJEaWFsb2cuaCAqLywKIAkJCQlCQ0VBNDgyNjA5N0Q5MzAyMDA5NEM5RTQgLyogUmVu ZGVyQnV0dG9uLmNwcCAqLywKIAkJCQlCQ0VBNDgyNzA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVy QnV0dG9uLmggKi8sCiAJCQkJQkNFNDQxMzExMkY3NDhFMjAwOUI4NEI4IC8qIFJlbmRlckNvbWJp bmVUZXh0LmNwcCAqLywKQEAgLTI1NDAwLDYgKzI1NDA2LDcgQEAKIAkJCQlBMjRCRjc3QjE1Q0Mz QkFGMDAzMTkxRjIgLyogV2ViS2l0Q1NTTWl4RnVuY3Rpb25WYWx1ZS5oIGluIEhlYWRlcnMgKi8s CiAJCQkJNTBEODhDQjYxNUJERkRBQTAwMTgwOUY0IC8qIEN1c3RvbUZpbHRlclByb2dyYW1JbmZv LmggaW4gSGVhZGVycyAqLywKIAkJCQkzMTlGQkQ1RjE1RDJGNDY0MDA5NjQwQTYgLyogQ2FjaGVk SW1hZ2VDbGllbnQuaCBpbiBIZWFkZXJzICovLAorCQkJCTc2REMxN0U4MTVEM0FDMTQwMDYzQ0Y0 RCAvKiBSZW5kZXJEaWFsb2cuaCBpbiBIZWFkZXJzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JE ZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpAQCAtMjg0NzEsNiArMjg0NzgsNyBA QAogCQkJCTk3N0UyRTBFMTJGMEZDOUMwMEMxMzM3OSAvKiBYU1NBdWRpdG9yLmNwcCBpbiBTb3Vy Y2VzICovLAogCQkJCUZENTM3MzUyMTM3QjY1MTgwMDAwOERDRSAvKiBaZXJvUG9sZS5jcHAgaW4g U291cmNlcyAqLywKIAkJCQk1MEQ4OENCNTE1QkRGREFBMDAxODA5RjQgLyogQ3VzdG9tRmlsdGVy UHJvZ3JhbUluZm8uY3BwIGluIFNvdXJjZXMgKi8sCisJCQkJNzZEQzE3RTcxNUQzQUMxNDAwNjND RjREIC8qIFJlbmRlckRpYWxvZy5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5 Rm9yRGVwbG95bWVudFBvc3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRGlhbG9nRWxlbWVudC5jcHAKaW5kZXggNDUxMGQ4MTQzMTljMmU1NDM4ZTkzMjc3NWNh Y2QxYzBkZDIzYmEyNS4uNTM3NDMyOTYwMzA4NzcwNzU3ODliYzFjZWE3NTA5Mzc3OTY3YWM4OSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5jcHAKQEAgLTI5LDYgKzI5 LDcgQEAKICNpZiBFTkFCTEUoRElBTE9HX0VMRU1FTlQpCiAKICNpbmNsdWRlICJFeGNlcHRpb25D b2RlLmgiCisjaW5jbHVkZSAiUmVuZGVyRGlhbG9nLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK IApAQCAtNzEsNiArNzIsMTEgQEAgYm9vbCBIVE1MRGlhbG9nRWxlbWVudDo6aXNQcmVzZW50YXRp b25BdHRyaWJ1dGUoY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFtZSkgY29uc3QKICAgICByZXR1cm4g SFRNTEVsZW1lbnQ6OmlzUHJlc2VudGF0aW9uQXR0cmlidXRlKG5hbWUpOwogfQogCitSZW5kZXJP YmplY3QqIEhUTUxEaWFsb2dFbGVtZW50OjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJl bmEsIFJlbmRlclN0eWxlKikKK3sKKyAgICByZXR1cm4gbmV3IChhcmVuYSkgUmVuZGVyRGlhbG9n KHRoaXMpOworfQorCiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRGlhbG9nRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxl bWVudC5oCmluZGV4IGQxZGQ3NzY4OTU0M2Y0NDcyYWVkOTc0YjNmZjc0NzdhYTAxMjZkYWEuLjdh N2IwMTE5ZmRmZWIwYjdiZTcxYTg2NWMwMWNhYTdhMmU3ZWU5ZDMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxEaWFsb2dFbGVtZW50LmgKQEAgLTQ1LDYgKzQ1LDcgQEAgcHVibGljOgogcHJpdmF0 ZToKICAgICBIVE1MRGlhbG9nRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiwgRG9jdW1lbnQq KTsKIAorICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVu YSosIFJlbmRlclN0eWxlKikgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBib29sIGlzUHJlc2VudGF0 aW9uQXR0cmlidXRlKGNvbnN0IFF1YWxpZmllZE5hbWUmKSBjb25zdCBPVkVSUklERTsKIH07CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uN2U3 MWFkMmE3MTc2MzZiYWI4MTM4ODU3YTEyMGQyNjUxNDE2ODc4ZQotLS0gL2Rldi9udWxsCisrKyBi L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwCkBAIC0wLDAgKzEsOTQg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisg KiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4g dGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFV RU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VS RU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBE QVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VE IEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1Qs IFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBP VEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFH RS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiUmVuZGVyRGlhbG9nLmgi CisKKyNpZiBFTkFCTEUoRElBTE9HX0VMRU1FTlQpCisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisj aW5jbHVkZSAiUmVuZGVyTGF5ZXIuaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisKK25hbWVz cGFjZSBXZWJDb3JlIHsKKwordXNpbmcgbmFtZXNwYWNlIEhUTUxOYW1lczsKKworUmVuZGVyRGlh bG9nOjpSZW5kZXJEaWFsb2coTm9kZSogbm9kZSkKKyAgICA6IFJlbmRlckJsb2NrKG5vZGUpCit7 Cit9CisKK1JlbmRlckRpYWxvZzo6flJlbmRlckRpYWxvZygpCit7Cit9CisKK2NvbnN0IGNoYXIq IFJlbmRlckRpYWxvZzo6cmVuZGVyTmFtZSgpIGNvbnN0Cit7CisgICAgaWYgKGlzRmxvYXRpbmco KSkKKyAgICAgICAgcmV0dXJuICJSZW5kZXJEaWFsb2cgKGZsb2F0aW5nKSI7CisgICAgaWYgKGlz T3V0T2ZGbG93UG9zaXRpb25lZCgpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAocG9z aXRpb25lZCkiOworICAgIGlmIChpc0Fub255bW91c0NvbHVtbnNCbG9jaygpKQorICAgICAgICBy ZXR1cm4gIlJlbmRlckRpYWxvZyAoYW5vbnltb3VzIG11bHRpLWNvbHVtbikiOworICAgIGlmIChp c0Fub255bW91c0NvbHVtblNwYW5CbG9jaygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxv ZyAoYW5vbnltb3VzIG11bHRpLWNvbHVtbiBzcGFuKSI7CisgICAgaWYgKGlzQW5vbnltb3VzQmxv Y2soKSkKKyAgICAgICAgcmV0dXJuICJSZW5kZXJEaWFsb2cgKGFub255bW91cykiOworICAgIGlm IChpc0Fub255bW91cygpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRpYWxvZyAoZ2VuZXJhdGVk KSI7CisgICAgaWYgKGlzUmVsUG9zaXRpb25lZCgpKQorICAgICAgICByZXR1cm4gIlJlbmRlckRp YWxvZyAocmVsYXRpdmUgcG9zaXRpb25lZCkiOworICAgIGlmIChpc1J1bkluKCkpCisgICAgICAg IHJldHVybiAiUmVuZGVyRGlhbG9nIChydW4taW4pIjsKKyAgICByZXR1cm4gIlJlbmRlckRpYWxv ZyI7Cit9CisKK3ZvaWQgUmVuZGVyRGlhbG9nOjpsYXlvdXQoKQoreworICAgIFJlbmRlckJsb2Nr OjpsYXlvdXQoKTsKKworICAgIFJlbmRlclN0eWxlKiBzdHlsZVRvVXNlID0gc3R5bGUoKTsKKyAg ICBpZiAoc3R5bGVUb1VzZS0+cG9zaXRpb24oKSAhPSBBYnNvbHV0ZVBvc2l0aW9uIHx8ICFzdHls ZVRvVXNlLT5sb2dpY2FsVG9wKCkuaXNBdXRvKCkgfHwgIXN0eWxlVG9Vc2UtPmxvZ2ljYWxCb3R0 b20oKS5pc0F1dG8oKSkKKyAgICAgICAgcmV0dXJuOworICAgIC8vIEFkanVzdCB0aGUgZGlhbG9n J3MgcG9zaXRpb24gdG8gYmUgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZiB0aGUgdmlld3Bv cnQuCisgICAgTGF5b3V0U3RhdGVEaXNhYmxlciBsYXlvdXRTdGF0ZURpc2FibGVyKHZpZXcoKSk7 CisgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXcgPSBkb2N1bWVudCgpLT52aWV3KCk7CisgICAgaW50 IHNjcm9sbFRvcCA9IGZyYW1lVmlldy0+c2Nyb2xsT2Zmc2V0KCkuaGVpZ2h0KCk7CisgICAgRmxv YXRQb2ludCBhYnNvbHV0ZVBvaW50KDAsIHNjcm9sbFRvcCk7CisgICAgaW50IHZpc2libGVIZWln aHQgPSBmcmFtZVZpZXctPnZpc2libGVDb250ZW50UmVjdCh0cnVlKS5oZWlnaHQoKTsKKyAgICBp ZiAobG9naWNhbEhlaWdodCgpIDwgdmlzaWJsZUhlaWdodCkKKyAgICAgICAgYWJzb2x1dGVQb2lu dC5tb3ZlKDAsICh2aXNpYmxlSGVpZ2h0IC0gbG9naWNhbEhlaWdodCgpKSAvIDIpOworICAgIEZs b2F0UG9pbnQgbG9jYWxQb2ludCA9IGNvbnRhaW5lcigpLT5hYnNvbHV0ZVRvTG9jYWwoYWJzb2x1 dGVQb2ludCk7CisgICAgTGF5b3V0VW5pdCBsb2NhbFRvcCA9IExheW91dFNpemUobG9jYWxQb2lu dC54KCksIGxvY2FsUG9pbnQueSgpKS5oZWlnaHQoKTsKKyAgICBzZXRMb2dpY2FsVG9wKGxvY2Fs VG9wKTsKKworICAgIC8vIEZJWE1FOiBUaGlzIGlzIG5lZWRlZCBiZWNhdXNlIG90aGVyd2lzZSB0 aGUgZGlhbG9nIGlzIG5vdCBwYWludGVkIGlmIGl0IGNhdXNlcyBhIGhvcml6b250YWwgc2Nyb2xs YmFyIHRvIGFwcGVhci4KKyAgICAvLyBUaGVyZSBpcyBwcm9iYWJseSBhIGJldHRlciBzb2x1dGlv bi4KKyAgICByZXBhaW50KCk7Cit9CisKK30KKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyRGlhbG9nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTNmNTAyZmVjYzI2NWIyMjEwYmMxYTVlNjkx MDY0MDM4ZGRmM2E1ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJEaWFsb2cuaApAQCAtMCwwICsxLDYxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJV VE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBSZW5kZXJE aWFsb2dfaAorI2RlZmluZSBSZW5kZXJEaWFsb2dfaAorCisjaWYgRU5BQkxFKERJQUxPR19FTEVN RU5UKQorI2luY2x1ZGUgIlJlbmRlckJsb2NrLmgiCisjaW5jbHVkZSAiUmVuZGVyV2lkZ2V0Lmgi CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworY2xhc3MgSFRNTERpYWxvZ0VsZW1lbnQ7CisKK2Ns YXNzIFJlbmRlckRpYWxvZyA6IHB1YmxpYyBSZW5kZXJCbG9jayB7CitwdWJsaWM6CisgICAgUmVu ZGVyRGlhbG9nKE5vZGUqKTsKKyAgICB2aXJ0dWFsIH5SZW5kZXJEaWFsb2coKTsKKyAgICB2aXJ0 dWFsIHZvaWQgbGF5b3V0KCkgT1ZFUlJJREU7CisKK3ByaXZhdGU6CisgICAgdmlydHVhbCBjb25z dCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3Q7CisgICAgdmlydHVhbCBib29sIGlzRGlhbG9nKCkg Y29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorfTsKKworaW5saW5lIFJlbmRlckRpYWxvZyogdG9SZW5k ZXJEaWFsb2coUmVuZGVyT2JqZWN0KiBvYmplY3QpCit7CisgICAgQVNTRVJUKCFvYmplY3QgfHwg b2JqZWN0LT5pc0RpYWxvZygpKTsKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8UmVuZGVyRGlhbG9n Kj4ob2JqZWN0KTsKK30KKworLy8gVGhpcyB3aWxsIGNhdGNoIGFueW9uZSBkb2luZyBhbiB1bm5l Y2Vzc2FyeSBjYXN0Lgordm9pZCB0b1JlbmRlckRpYWxvZyhjb25zdCBSZW5kZXJEaWFsb2cqKTsK KworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYKKworI2VuZGlmIC8vIFJlbmRlckRp YWxvZ19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0 LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKaW5kZXggNWVmOTBm YzBlMTI1ODExMTE1Y2I1NDRlN2YwOTc4ODhjM2NiZWM5OS4uOWRiMzk1OGRiOWJmMjI0YWJiZDRj MTQ0MTM3YjcyMzE3Yzk0Njk5YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3QuaApAQCAtMzA3LDYgKzMwNyw5IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIGJvb2wgaXNCbG9j a0Zsb3coKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc0JveE1v ZGVsT2JqZWN0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgaXND b3VudGVyKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKyNpZiBFTkFCTEUoRElBTE9HX0VMRU1F TlQpCisgICAgdmlydHVhbCBib29sIGlzRGlhbG9nKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0K KyNlbmRpZgogICAgIHZpcnR1YWwgYm9vbCBpc1F1b3RlKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7 IH0KIAogI2lmIEVOQUJMRShERVRBSUxTX0VMRU1FTlQpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggODM2YjNmODc4NGJkNjE1 YzM4YmY0NTcxMzM3Y2M4MzFmY2M5YzRlZi4uZGE2ZjRkNjEzN2FiYzIxM2UzZjBiZGRiZGVlMzI4 Yzg1N2MzYTkzMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91 dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDEyLTA4LTE0ICBNYXR0IEZhbGtl bmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5IGNlbnRl ciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9C T0RZIChPT1BTISkuCisKKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24t YW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAg ICogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlv bmluZy5odG1sOiBBZGRlZC4KKwogMjAxMi0wOC0xMyAgQ2hyaXN0b3BoZSBEdW1leiAgPGNocmlz dG9waGUuZHVtZXpAaW50ZWwuY29tPgogCiAgICAgICAgIFtFRkxdW1dLMl0gU2tpcCBpbnNwZWN0 b3IgdGVzdHMgdGhhdCBoaXQgYXNzZXJ0aW9uIGluIFdlYkNvcmU6OlN1c3BlbmRhYmxlVGltZXI6 OnJlc3VtZSgpCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxl bWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9z aXRpb25pbmctZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjAxYjVkMTM5N2ExZTMxYTk4N2I3MjJj OGNhNjFkODY1MTU2NGQzODkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Rv bS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDE0IEBACitUZXN0cyBkZWZhdWx0IHBvc2l0aW9uaW5nIG9mIG5v bi1hbmNob3JlZCBkaWFsb2dzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMg b2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFT UyBkaWFsb2cub2Zmc2V0VG9wIGlzIHBsYWluRGl2Lm9mZnNldFRvcAorUEFTUyBkaWFsb2cub2Zm c2V0Qm90dG9tIGlzIHBsYWluRGl2Lm9mZnNldEJvdHRvbQorUEFTUyBkaWFsb2cub2Zmc2V0VG9w IGlzIHBsYWluRGl2Lm9mZnNldFRvcAorUEFTUyBkaWFsb2cub2Zmc2V0VG9wIGlzIGV4cGVjdGVk VG9wCitQQVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMgZXhwZWN0ZWRUb3AKK1BBU1Mgc3VjY2Vzc2Z1 bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0 aW9uaW5nLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24t YW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMjAyZmQ3ODVjM2Ey MzAzZjU1YmFkNzA3MGRjOWI4M2JkZDY3YzdhNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRp b25pbmcuaHRtbApAQCAtMCwwICsxLDE0MSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxo ZWFkPgorPHN0eWxlPgorLmZpbGxlciB7CisgICAgaGVpZ2h0OiAyMDBlbTsKK30KKzwvc3R5bGU+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3Njcmlw dD4KKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykKKyAgICBpbnRlcm5hbHMuc2V0dGlu Z3Muc2V0RGlhbG9nRWxlbWVudEVuYWJsZWQodHJ1ZSk7CisKK2Z1bmN0aW9uIGNoZWNrVG9wT2ZW aWV3cG9ydChkaWFsb2cpIHsKKyAgICByZWFsVG9wID0gZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50 UmVjdCgpLnRvcDsKKyAgICBzaG91bGRCZUNsb3NlVG8oJ3JlYWxUb3AnLCAwLCAxLCB0cnVlKTsK K30KKworZnVuY3Rpb24gY2hlY2tDZW50ZXJlZChkaWFsb2cpIHsKKyAgICBleHBlY3RlZFRvcCA9 ICh3aW5kb3cuaW5uZXJIZWlnaHQgLSBkaWFsb2cub2Zmc2V0SGVpZ2h0KSAvIDI7CisgICAgcmVh bFRvcCA9IGRpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50b3A7CisgICAgc2hvdWxkQmVD bG9zZVRvKCdyZWFsVG9wJywgZXhwZWN0ZWRUb3AsIDEsIHRydWUpOworfQorPC9zY3JpcHQ+Cis8 L2hlYWQ+Cis8Ym9keT4KKyAgICA8ZGlhbG9nIGlkPSJteWRpYWxvZyI+SXQgaXMgbXkgZGlhbG9n LjwvZGlhbG9nPgorICAgIDxkaXYgY2xhc3M9ImZpbGxlciI+PC9kaXY+Cis8L2JvZHk+Cis8c2Ny aXB0PgorZGVzY3JpcHRpb24oIlRlc3RzIGRlZmF1bHQgcG9zaXRpb25pbmcgb2Ygbm9uLWFuY2hv cmVkIGRpYWxvZ3MuIik7CisKK2RpYWxvZyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdteWRp YWxvZycpOworCisvLyBEaWFsb2cgc2hvdWxkIGJlIGNlbnRlcmVkIGluIHRoZSB2aWV3cG9ydC4K K2RpYWxvZy5zaG93KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsK KworLy8gRGlhbG9nIHNob3VsZCBzdGlsbCBiZSBjZW50ZXJlZCBpZiBzaG93biBhZnRlciB3aW5k b3cgaXMgc2Nyb2xsZWQuCit3aW5kb3cuc2Nyb2xsKDAsIDUwMCk7CitkaWFsb2cuc2hvdygpOwor Y2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIEEgdGFsbCBkaWFs b2cgc2hvdWxkIGJlIHBvc2l0aW9uZWQgYXQgdGhlIHRvcCBvZiB0aGUgdmlld3BvcnQuCit2YXIg ZGlhbG9nSW5uZXIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2RpYWxvZ0lubmVy LmNsYXNzTmFtZSA9ICdmaWxsZXInOworZGlhbG9nLmFwcGVuZENoaWxkKGRpYWxvZ0lubmVyKTsK K2RpYWxvZy5zaG93KCk7CitjaGVja1RvcE9mVmlld3BvcnQoZGlhbG9nKTsKK2RpYWxvZy5jbG9z ZSgpOworZGlhbG9nLnJlbW92ZUNoaWxkKGRpYWxvZ0lubmVyKTsKKworLy8gVGVzdCB0aGF0IGNl bnRlcmluZyB3b3JrcyB3aGVuIGRpYWxvZyBpcyBpbnNpZGUgcG9zaXRpb25lZCBjb250YWluZXJz LgordmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29udGFp bmVyLnN0eWxlLnBvc2l0aW9uID0gJ2Fic29sdXRlJzsKK2NvbnRhaW5lci5zdHlsZS50b3AgPSAn NTBlbTsnCitjb250YWluZXIuc3R5bGUuaGVpZ2h0PSAnM2VtOycKK2NvbnRhaW5lci5zdHlsZS53 aWR0aCA9ICc5MCUnOworZGlhbG9nLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKK2Rv Y3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoY29udGFpbmVyKTsKK2NvbnRhaW5lci5hcHBlbmRDaGls ZChkaWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxv Zy5jbG9zZSgpOworY29udGFpbmVyLnJlbW92ZUNoaWxkKGRpYWxvZyk7CisKK3ZhciBjb250YWlu ZXIyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7Citjb250YWluZXIyLnN0eWxlLnBv c2l0aW9uID0gJ3JlbGF0aXZlJzsKK2NvbnRhaW5lcjIuc3R5bGUudG9wID0gJzIwZW0nOworY29u dGFpbmVyMi5zdHlsZS5sZWZ0ID0gMDsKK2NvbnRhaW5lcjIuc3R5bGUucmlnaHQgPSAwOworY29u dGFpbmVyLmFwcGVuZENoaWxkKGNvbnRhaW5lcjIpOworY29udGFpbmVyMi5hcHBlbmRDaGlsZChk aWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxvZy5j bG9zZSgpOworCisvLyBBZGQgdGhlIGhvcml6b250YWwgc2Nyb2xsYmFyLiBUaGUgZGlhbG9nIHNo b3VsZCBiZSBjZW50ZXJlZCByZWdhcmRsZXNzIG9mIHRoZSBwcmVzZW5jZSBvZiBzY3JvbGxiYXJz LgorZGlhbG9nLnN0eWxlLndpZHRoID0gJzQwMGVtJzsKK2RpYWxvZy5zaG93KCk7CitjaGVja0Nl bnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8gVGVzdCB0aGF0IHNldHRpbmcg dG9wIG1hbnVhbGx5IGlzIHRoZSBzYW1lIGFzIGZvciBhIHBsYWluIGRpdi4KK3ZhciBwbGFpbkRp diA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29udGFpbmVyMi5hcHBlbmRDaGls ZChwbGFpbkRpdik7CitwbGFpbkRpdi5zdHlsZS5wb3NpdGlvbiA9ICdhYnNvbHV0ZSc7CitwbGFp bkRpdi5zdHlsZS50b3AgPSAnM2VtJzsKK2RpYWxvZy5zdHlsZS50b3AgPSAnM2VtJzsKK2RpYWxv Zy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdwbGFpbkRpdi5vZmZzZXRU b3AnKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBUZXN0IHRoYXQgc2V0dGluZyBib3R0b20gbWFu dWFsbHkgaXMgdGhlIHNhbWUgYXMgZm9yIGEgcGxhaW4gZGl2LgorZGlhbG9nLnN0eWxlLnRvcCA9 ICdhdXRvJzsKK3BsYWluRGl2LnN0eWxlLnRvcCA9ICdhdXRvJzsKK2RpYWxvZy5zdHlsZS5ib3R0 b20gPSAnM2VtJzsKK3BsYWluRGl2LnN0eWxlLmJvdHRvbSA9ICczZW0nOworZGlhbG9nLnNob3co KTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0Qm90dG9tJywgJ3BsYWluRGl2Lm9mZnNldEJvdHRv bScpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBmaXhlZCBwb3NpdGlvbiBoYXMg dGhlIHVzdWFsIGJlaGF2aW9yLgorcGxhaW5EaXYuc3R5bGUucG9zaXRpb24gPSAnZml4ZWQnOwor cGxhaW5EaXYuc3R5bGUudG9wID0gJzNlbSc7CitkaWFsb2cuc3R5bGUucG9zaXRpb24gPSAnZml4 ZWQnOworZGlhbG9nLnN0eWxlLnRvcCA9ICczZW0nOworZGlhbG9nLnNob3coKTsKK3Nob3VsZEJl KCdkaWFsb2cub2Zmc2V0VG9wJywgJ3BsYWluRGl2Lm9mZnNldFRvcCcpOworZGlhbG9nLmNsb3Nl KCk7CisKKy8vIFRlc3QgdGhhdCBzdGF0aWMgcG9zaXRpb24gaGFzIHRoZSB1c3VhbCBiZWhhdmlv ci4KK3BsYWluRGl2LnN0eWxlLnBvc2l0aW9uID0gJ3N0YXRpYyc7CitwbGFpbkRpdi5zdHlsZS50 b3AgPSAnYXV0byc7Cit2YXIgZXhwZWN0ZWRUb3AgPSBwbGFpbkRpdi5vZmZzZXRUb3A7CitwbGFp bkRpdi5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHBsYWluRGl2KTsKK2RpYWxvZy5zdHlsZS5wb3Np dGlvbiA9ICdzdGF0aWMnOworZGlhbG9nLnN0eWxlLnRvcCA9ICdhdXRvJzsKK2RpYWxvZy5zaG93 KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdleHBlY3RlZFRvcCcpOworZGlhbG9n LmNsb3NlKCk7CitkaWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChkaWFsb2cpOworCisvLyBU ZXN0IHRoYXQgcmVsYXRpdmUgcG9zaXRpb24gaGFzIHRoZSB1c3VhbCBiZWhhdmlvci4KK2NvbnRh aW5lcjIuYXBwZW5kQ2hpbGQocGxhaW5EaXYpOworcGxhaW5EaXYuc3R5bGUucG9zaXRpb24gPSAn cmVsYXRpdmUnOworcGxhaW5EaXYuc3R5bGUudG9wID0gJzNlbSc7CitleHBlY3RlZFRvcCA9IHBs YWluRGl2Lm9mZnNldFRvcDsKK3BsYWluRGl2LnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQocGxhaW5E aXYpOworY29udGFpbmVyMi5hcHBlbmRDaGlsZChkaWFsb2cpOworZGlhbG9nLnN0eWxlLnBvc2l0 aW9uID0gJ3JlbGF0aXZlJzsKK2RpYWxvZy5zdHlsZS50b3AgPSAnM2VtJzsKK2RpYWxvZy5zaG93 KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdleHBlY3RlZFRvcCcpOworZGlhbG9n LmNsb3NlKCk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMt dGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 161896 2012-09-03 04:11:16 -0700 2012-09-04 21:25:52 -0700 WIP patch bug-90670-20120903201100.patch text/plain 25082 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3MzE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzg3YWNjYzRiNDI5N2Zh ZWYzMTcwOTEwZjQxZGZiMWI4NjhkMTkxNy4uZWVlMWNlNGViY2RlYzI1NTE2MzBjNmI5NzM0ZDcx YzJhNmZiMmFiZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDEyLTA5LTAzICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBhZGp1c3RzIHRoZSBzdGF0aWMgZGVm YXVsdCBwb3NpdGlvbiBvZiBub24tYW5jaG9yZWQKKyAgICAgICAgZGlhbG9nIGVsZW1lbnRzIHNv IHRoZXkgYXJlIHZlcnRpY2FsbHkgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZgorICAgICAg ICB0aGUgdmlld3BvcnQsIGFzIHBlciB0aGUgc3BlYy4KKworICAgICAgICBUaGUgYXBwcm9hY2gg aXMgdG8gYWRkIGEgUmVuZGVyRGlhbG9nIGNsYXNzIHdob3NlIGxheW91dCgpCisgICAgICAgIGZ1 bmN0aW9uIGFkanVzdHMgdGhlIHBvc2l0aW9uIGFmdGVyIG5vcm1hbCBSZW5kZXJCbG9jazo6bGF5 b3V0IHJ1bnMuCisKKyAgICAgICAgVGVzdDogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9u LWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sCisKKyAgICAgICAgKiBDTWFrZUxpc3Rz LnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFRhcmdldC5w cmk6CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxEaWFsb2dFbGVtZW50OjpjcmVhdGVSZW5kZXJlcik6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50Lmg6Cisg ICAgICAgIChIVE1MRGlhbG9nRWxlbWVudCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJv eC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3g6Om1hcEFic29sdXRlVG9Mb2NhbFBv aW50KTogUmVtb3ZlIGFzc2VydGlvbiBzaW5jZSBub3cgYWJzb2x1dGVUb0xvY2FsIGlzIGNhbGxl ZCBkdXJpbmcgbGF5b3V0LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVj dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3hNb2RlbE9iamVjdDo6bWFwQWJzb2x1 dGVUb0xvY2FsUG9pbnQpOiBEaXR0by4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9n LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRl ckRpYWxvZzo6bGF5b3V0KTogQ29tcHV0ZSB0aGUgZGVzaXJlZCB0b3AgcG9zaXRpb24gaW4gdGhl IGFic29sdXRlIGNvb3JkaW5hdGUgc3lzdGVtLCBhbmQgdGhlbiBzZXQgdG9wIHRvIHRoZQorICAg ICAgICBjb3JyZXNwb25kaW5nIGxvY2FsIGNvb3JkaW5hdGUuCisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlckRpYWxvZy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoUmVu ZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6UmVuZGVyRGlhbG9n KToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6flJlbmRlckRpYWxvZyk6CisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OnJlbmRlck5hbWUpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmlzRGlhbG9nKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyaW5nQWxsSW5PbmUuY3BwOgorCiAyMDEyLTA4LTMwICBKYW1lcyBSb2JpbnNvbiAgPGphbWVz ckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW2Nocm9taXVtXSBQdXQgY29tcG9zaXRvciBjbGll bnQgaW50ZXJmYWNlcyBpbiBzZXBhcmF0ZSBoZWFkZXJzLCBub3JtYWxpemUgbmFtaW5nCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dCBiL1NvdXJjZS9XZWJDb3JlL0NN YWtlTGlzdHMudHh0CmluZGV4IGIxMTNiM2YwMGVhMDEyYzFjMmQ3MWU3YjNiY2Q0MWYzZmM2YzUx ZGUuLmE5NmU5MjA4MzM4ZTcwNTZhZmVkNmJhMDhiNTcyYmJiODY0ZDNmOGQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NNYWtl TGlzdHMudHh0CkBAIC0yMDMxLDYgKzIwMzEsNyBAQCBTRVQoV2ViQ29yZV9TT1VSQ0VTCiAgICAg cmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwCiAgICAgcmVuZGVyaW5nL1JlbmRlckRlcHJlY2F0 ZWRGbGV4aWJsZUJveC5jcHAKICAgICByZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5jcHAK KyAgICByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcAogICAgIHJlbmRlcmluZy9SZW5kZXJFbWJl ZGRlZE9iamVjdC5jcHAKICAgICByZW5kZXJpbmcvUmVuZGVyRmllbGRzZXQuY3BwCiAgICAgcmVu ZGVyaW5nL1JlbmRlckZpbGVVcGxvYWRDb250cm9sLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxp c3QuYW0KaW5kZXggODBjNjM2ZmViMjJkMGQxNTY0Y2FhMjc4YjcwZmRkNTI5MGE2YmM5Mi4uYzMx NzE3ODNhYzc3ZDNkMjlhOTQzNTliYzE1YTE5YTlhMmFmYTY4MyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5saXN0LmFtCkBAIC00ODk2LDYgKzQ4OTYsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAog CVNvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3guaCBc CiAJU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIuY3BwIFwKIAlT b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5oIFwKKwlTb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmggXAogCVNvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJFbWJlZGRlZE9iamVjdC5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJFbWJlZGRlZE9iamVjdC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyRmllbGRzZXQuY3BwIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkg Yi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCmluZGV4IGY3MzU5YWY4ZmMxMjFmNjcwNmRkNmEx MTcwMzljZDExYjBmZWJiNGQuLjZlMWQ5MDU2ZjA5OGM5NmM1N2Q5YzRkMzA2MmU1NTg3Njk1OGEy NmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKKysrIGIvU291cmNlL1dl YkNvcmUvVGFyZ2V0LnByaQpAQCAtMTExNiw2ICsxMTE2LDcgQEAgU09VUkNFUyArPSBcCiAgICAg cmVuZGVyaW5nL1JlbmRlckNvdW50ZXIuY3BwIFwKICAgICByZW5kZXJpbmcvUmVuZGVyRGVwcmVj YXRlZEZsZXhpYmxlQm94LmNwcCBcCiAgICAgcmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIu Y3BwIFwKKyAgICByZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcCBcCiAgICAgcmVuZGVyaW5nL1Jl bmRlckVtYmVkZGVkT2JqZWN0LmNwcCBcCiAgICAgcmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0LmNw cCBcCiAgICAgcmVuZGVyaW5nL1JlbmRlckZpbGVVcGxvYWRDb250cm9sLmNwcCBcCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3Jl Lmd5cGkKaW5kZXggNzMzNzYwOTgxMmNiYmVhOGI2Mzk3MjA5NmRhOGQ4ZDE0YjIwZjQ5OC4uMjU2 ZGE2ZTEwOTIxMzZjNjQ5OWVjOGU4ZmRiOGUyNmVkODU0ZjM4MyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQpA QCAtNTYyLDYgKzU2Miw3IEBACiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckJsb2NrLmgn LAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJCb3guaCcsCiAgICAgICAgICAgICAncmVu ZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgnLAorICAgICAgICAgICAgJ3JlbmRlcmluZy9S ZW5kZXJEaWFsb2cuaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckVtYmVkZGVkT2Jq ZWN0LmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJGbG93VGhyZWFkLmgnLAogICAg ICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJJbWFnZS5oJywKQEAgLTQ3MjQsNiArNDcyNSw3IEBA CiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRlcHJlY2F0ZWRGbGV4aWJsZUJveC5oJywK ICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5jcHAnLAogICAgICAg ICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXRhaWxzTWFya2VyLmgnLAorICAgICAgICAgICAgJ3Jl bmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVy RW1iZWRkZWRPYmplY3QuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmllbGRz ZXQuY3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmllbGRzZXQuaCcsCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2og Yi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXgg OGE0MjQzZjc3ODc5MzM2YWJkMmViMjM0ZmNkMGM5MGUyNjg5NWRmNi4uYjdjMjNhNGY4MGYxYWRi MGI3ZjM2YmE3YWViOGY2ZWMwM2I2MzQ3YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTkxMCw2ICsxOTEwLDggQEAKIAkJNzZD REQyRjUxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdFBvcHVwLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkNERDJFRjExMDNE QTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0UG9wdXAuaCAqLzsgfTsKIAkJNzZD REQyRjYxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkNERDJGMDEx MDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0T3B0aW9uLmNwcCAqLzsgfTsK IAkJNzZDREQyRjcxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlv bi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZDREQy RjExMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5oICovOyB9 OworCQk3NkRDMTdFNzE1RDNBQzE0MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9nLmNwcCBpbiBTb3Vy Y2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2REMxN0U1MTVEM0FDMTQw MDYzQ0Y0RCAvKiBSZW5kZXJEaWFsb2cuY3BwICovOyB9OworCQk3NkRDMTdFODE1RDNBQzE0MDA2 M0NGNEQgLyogUmVuZGVyRGlhbG9nLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSA3NkRDMTdFNjE1RDNBQzE0MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9nLmgg Ki87IH07CiAJCTc2RkMyQjBCMTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZGQzJCMDgxMjM3 MERBMDAwNkE5OTFBIC8qIERPTVRva2VuTGlzdC5jcHAgKi87IH07CiAJCTc2RkMyQjBDMTIzNzBE QTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1 aWxkRmlsZTsgZmlsZVJlZiA9IDc2RkMyQjA5MTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxp c3QuaCAqLzsgfTsKIAkJNzZGRjE3RTMxMTIzNTY3MzAwMUQ2MUI1IC8qIFBsdWdpblZpZXdOb25l LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2RkYx N0UyMTEyMzU2NzMwMDFENjFCNSAvKiBQbHVnaW5WaWV3Tm9uZS5jcHAgKi87IH07CkBAIC05MDk3 LDYgKzkwOTksOCBAQAogCQk3NkNERDJFRjExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0 eU1lbnVMaXN0UG9wdXAuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNz aWJpbGl0eU1lbnVMaXN0UG9wdXAuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzZD REQyRjAxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5jcHAg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBBY2Nlc3NpYmlsaXR5TWVudUxp c3RPcHRpb24uY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NkNERDJGMTExMDNE QTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0T3B0aW9uLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQk3NkRDMTdFNTE1RDNBQzE0MDA2M0NGNEQgLyogUmVu ZGVyRGlhbG9nLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFJlbmRl ckRpYWxvZy5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTc2REMxN0U2MTVEM0FD MTQwMDYzQ0Y0RCAvKiBSZW5kZXJEaWFsb2cuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBw YXRoID0gUmVuZGVyRGlhbG9nLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2RkMy QjA4MTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jcHAuY3BwOyBwYXRoID0gRE9NVG9rZW5MaXN0LmNwcDsgc291cmNlVHJlZSA9ICI8Z3Jv dXA+IjsgfTsKIAkJNzZGQzJCMDkxMjM3MERBMDAwNkE5OTFBIC8qIERPTVRva2VuTGlzdC5oICov ID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBET01Ub2tlbkxpc3QuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJNzZGQzJCMEExMjM3MERBMDAwNkE5OTFBIC8qIERPTVRva2Vu TGlzdC5pZGwgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0OyBwYXRoID0gRE9NVG9rZW5MaXN0LmlkbDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIxMzM1LDYgKzIxMzM5LDggQEAKIAkJCQlCQ0VCMTc5 QjE0MzM3OUY1MDA1MkVBRTkgLyogUmVuZGVyQm94UmVnaW9uSW5mby5oICovLAogCQkJCUJDRUE0 ODI0MDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJCUi5jcHAgKi8sCiAJCQkJQkNFQTQ4MjUwOTdE OTMwMjAwOTRDOUU0IC8qIFJlbmRlckJSLmggKi8sCisJCQkJNzZEQzE3RTUxNUQzQUMxNDAwNjND RjREIC8qIFJlbmRlckRpYWxvZy5jcHAgKi8sCisJCQkJNzZEQzE3RTYxNUQzQUMxNDAwNjNDRjRE IC8qIFJlbmRlckRpYWxvZy5oICovLAogCQkJCUJDRUE0ODI2MDk3RDkzMDIwMDk0QzlFNCAvKiBS ZW5kZXJCdXR0b24uY3BwICovLAogCQkJCUJDRUE0ODI3MDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5k ZXJCdXR0b24uaCAqLywKIAkJCQlCQ0U0NDEzMTEyRjc0OEUyMDA5Qjg0QjggLyogUmVuZGVyQ29t YmluZVRleHQuY3BwICovLApAQCAtMjU0OTEsNiArMjU0OTcsNyBAQAogCQkJCUUxQkU1MTJFMENG NkM1MTIwMDJFQTk1OSAvKiBYU0xUVW5pY29kZVNvcnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTk3 N0UyRTBGMTJGMEZDOUMwMEMxMzM3OSAvKiBYU1NBdWRpdG9yLmggaW4gSGVhZGVycyAqLywKIAkJ CQlGRDUzNzM1MzEzN0I2NTE4MDAwMDhEQ0UgLyogWmVyb1BvbGUuaCBpbiBIZWFkZXJzICovLAor CQkJCTc2REMxN0U4MTVEM0FDMTQwMDYzQ0Y0RCAvKiBSZW5kZXJEaWFsb2cuaCBpbiBIZWFkZXJz ICovLAogCQkJCTkzNzdBQkEwMTVERUZFRUYwMDMxRkQwNCAvKiBQYWdpbmF0aW9uLmggaW4gSGVh ZGVycyAqLywKIAkJCQkxNDQ3NkFBODE1REM0QkIxMDAzMDVEQjIgLyogV3JpdGluZ01vZGUuaCBp biBIZWFkZXJzICovLAogCQkJCTMxQjgwMUJCMTVFQzU4QzcwMENFNjQzRCAvKiBMYXlvdXRUeXBl c0lubGluZU1ldGhvZHMuaCBpbiBIZWFkZXJzICovLApAQCAtMjg1NzgsNiArMjg1ODUsNyBAQAog CQkJCUUxQkU1MTJEMENGNkM1MTIwMDJFQTk1OSAvKiBYU0xUVW5pY29kZVNvcnQuY3BwIGluIFNv dXJjZXMgKi8sCiAJCQkJOTc3RTJFMEUxMkYwRkM5QzAwQzEzMzc5IC8qIFhTU0F1ZGl0b3IuY3Bw IGluIFNvdXJjZXMgKi8sCiAJCQkJRkQ1MzczNTIxMzdCNjUxODAwMDA4RENFIC8qIFplcm9Qb2xl LmNwcCBpbiBTb3VyY2VzICovLAorCQkJCTc2REMxN0U3MTVEM0FDMTQwMDYzQ0Y0RCAvKiBSZW5k ZXJEaWFsb2cuY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNTJCNkM5QzIxNUUzRjRERjAwNjkwQjA1 IC8qIERPTU5hbWVkRmxvd0NvbGxlY3Rpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJNTJCNkM5 QzUxNUUzRjRERjAwNjkwQjA1IC8qIE5hbWVkRmxvd0NvbGxlY3Rpb24uY3BwIGluIFNvdXJjZXMg Ki8sCiAJCQkJNTJDQ0E5RTIxNUUzRjYyQzAwNTNDNzdGIC8qIEpTRE9NTmFtZWRGbG93Q29sbGVj dGlvbi5jcHAgaW4gU291cmNlcyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTERpYWxvZ0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxl bWVudC5jcHAKaW5kZXggNDUxMGQ4MTQzMTljMmU1NDM4ZTkzMjc3NWNhY2QxYzBkZDIzYmEyNS4u NTM3NDMyOTYwMzA4NzcwNzU3ODliYzFjZWE3NTA5Mzc3OTY3YWM4OSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5jcHAKQEAgLTI5LDYgKzI5LDcgQEAKICNpZiBFTkFC TEUoRElBTE9HX0VMRU1FTlQpCiAKICNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCisjaW5jbHVk ZSAiUmVuZGVyRGlhbG9nLmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtNzEsNiArNzIs MTEgQEAgYm9vbCBIVE1MRGlhbG9nRWxlbWVudDo6aXNQcmVzZW50YXRpb25BdHRyaWJ1dGUoY29u c3QgUXVhbGlmaWVkTmFtZSYgbmFtZSkgY29uc3QKICAgICByZXR1cm4gSFRNTEVsZW1lbnQ6Omlz UHJlc2VudGF0aW9uQXR0cmlidXRlKG5hbWUpOwogfQogCitSZW5kZXJPYmplY3QqIEhUTUxEaWFs b2dFbGVtZW50OjpjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSogYXJlbmEsIFJlbmRlclN0eWxl KikKK3sKKyAgICByZXR1cm4gbmV3IChhcmVuYSkgUmVuZGVyRGlhbG9nKHRoaXMpOworfQorCiB9 CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxl bWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRGlhbG9nRWxlbWVudC5oCmluZGV4IGQx ZGQ3NzY4OTU0M2Y0NDcyYWVkOTc0YjNmZjc0NzdhYTAxMjZkYWEuLjdhN2IwMTE5ZmRmZWIwYjdi ZTcxYTg2NWMwMWNhYTdhMmU3ZWU5ZDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTERpYWxvZ0VsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dF bGVtZW50LmgKQEAgLTQ1LDYgKzQ1LDcgQEAgcHVibGljOgogcHJpdmF0ZToKICAgICBIVE1MRGlh bG9nRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiwgRG9jdW1lbnQqKTsKIAorICAgIHZpcnR1 YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxl KikgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBib29sIGlzUHJlc2VudGF0aW9uQXR0cmlidXRlKGNv bnN0IFF1YWxpZmllZE5hbWUmKSBjb25zdCBPVkVSUklERTsKIH07CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJveC5jcHAKaW5kZXggZGE3ZDQ3OTg5OGZjZTAzNGZhNzhkZGY3MjNkMDU4 NjdjZGQzZjg4MS4uYTcxY2U2NzNkMDRkZWYzMzlkYTE2N2E2MDNkNDZlZjY1NDY3ZTJiZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAKQEAgLTEzNTQsOSArMTM1NCw2IEBA IGNvbnN0IFJlbmRlck9iamVjdCogUmVuZGVyQm94OjpwdXNoTWFwcGluZ1RvQ29udGFpbmVyKGNv bnN0IFJlbmRlckJveE1vZGVsT2JqZWN0CiAKIHZvaWQgUmVuZGVyQm94OjptYXBBYnNvbHV0ZVRv TG9jYWxQb2ludChib29sIGZpeGVkLCBib29sIHVzZVRyYW5zZm9ybXMsIFRyYW5zZm9ybVN0YXRl JiB0cmFuc2Zvcm1TdGF0ZSkgY29uc3QKIHsKLSAgICAvLyBXZSBkb24ndCBleHBlY3QgYWJzb2x1 dGVUb0xvY2FsKCkgdG8gYmUgY2FsbGVkIGR1cmluZyBsYXlvdXQgKHlldCkKLSAgICBBU1NFUlQo IXZpZXcoKSB8fCAhdmlldygpLT5sYXlvdXRTdGF0ZUVuYWJsZWQoKSk7Ci0gICAgCiAgICAgYm9v bCBpc0ZpeGVkUG9zID0gc3R5bGUoKS0+cG9zaXRpb24oKSA9PSBGaXhlZFBvc2l0aW9uOwogICAg IGJvb2wgaGFzVHJhbnNmb3JtID0gaGFzTGF5ZXIoKSAmJiBsYXllcigpLT50cmFuc2Zvcm0oKTsK ICAgICBpZiAoaGFzVHJhbnNmb3JtKSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckJveE1vZGVsT2JqZWN0LmNwcAppbmRleCAzMjZhYzk3YzAzYTU5MzFhMmNlMGExMTMz N2NkZmQ1OWVlM2Y5MWRjLi4zOTI4ZWNjYzc3ZmM5YTM0ZDNiZWJjYWZmMGY5MDk1YjQ4Y2M3YTVj IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmpl Y3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVj dC5jcHAKQEAgLTI4MzEsOSArMjgzMSw2IEBAIGJvb2wgUmVuZGVyQm94TW9kZWxPYmplY3Q6OnNo b3VsZEFudGlhbGlhc0xpbmVzKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCkKIAogdm9pZCBSZW5k ZXJCb3hNb2RlbE9iamVjdDo6bWFwQWJzb2x1dGVUb0xvY2FsUG9pbnQoYm9vbCBmaXhlZCwgYm9v bCB1c2VUcmFuc2Zvcm1zLCBUcmFuc2Zvcm1TdGF0ZSYgdHJhbnNmb3JtU3RhdGUpIGNvbnN0CiB7 Ci0gICAgLy8gV2UgZG9uJ3QgZXhwZWN0IGFic29sdXRlVG9Mb2NhbCgpIHRvIGJlIGNhbGxlZCBk dXJpbmcgbGF5b3V0ICh5ZXQpCi0gICAgQVNTRVJUKCF2aWV3KCkgfHwgIXZpZXcoKS0+bGF5b3V0 U3RhdGVFbmFibGVkKCkpOwotCiAgICAgUmVuZGVyT2JqZWN0KiBvID0gY29udGFpbmVyKCk7CiAg ICAgaWYgKCFvKQogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJEaWFsb2cuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFhNjU3NDg1ZmJlNWM2NmZiYjA0MzliMDYyYWM2MWIw ZDVjZmM1ZDkKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyRGlhbG9nLmNwcApAQCAtMCwwICsxLDY4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEy IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3Vy Y2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9S UyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUK KyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIlJlbmRlckRpYWxvZy5oIgorCisjaWYgRU5BQkxFKERJQUxPR19FTEVNRU5U KQorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkxheW91dFJlcGFpbnRlci5oIgor I2luY2x1ZGUgIlJlbmRlckxheWVyLmgiCisjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgorCituYW1l c3BhY2UgV2ViQ29yZSB7CisKK3ZvaWQgUmVuZGVyRGlhbG9nOjpsYXlvdXQoKQoreworICAgIExh eW91dFJlcGFpbnRlciByZXBhaW50ZXIoKnRoaXMsIHRydWUpOworICAgIExheW91dFN0YXRlTWFp bnRhaW5lciBzdGF0ZVB1c2hlcih2aWV3KCksIHRoaXMsIGxvY2F0aW9uT2Zmc2V0KCksIGhhc1Ry YW5zZm9ybSgpIHx8IGhhc1JlZmxlY3Rpb24oKSB8fCBzdHlsZSgpLT5pc0ZsaXBwZWRCbG9ja3NX cml0aW5nTW9kZSgpKTsKKworICAgIFJlbmRlckJsb2NrOjpsYXlvdXQoKTsKKworICAgIFJlbmRl clN0eWxlKiBzdHlsZVRvVXNlID0gc3R5bGUoKTsKKyAgICBpZiAoc3R5bGVUb1VzZS0+cG9zaXRp b24oKSAhPSBBYnNvbHV0ZVBvc2l0aW9uIHx8ICFzdHlsZVRvVXNlLT50b3AoKS5pc0F1dG8oKSB8 fCAhc3R5bGVUb1VzZS0+Ym90dG9tKCkuaXNBdXRvKCkpIHsKKyAgICAgICAgc3RhdGVQdXNoZXIu cG9wKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyBBZGp1c3QgdGhlIGRpYWxv ZydzIHBvc2l0aW9uIHRvIGJlIGNlbnRlcmVkIGluIG9yIGF0IHRoZSB0b3Agb2YgdGhlIHZpZXdw b3J0LgorICAgIEZyYW1lVmlldyogZnJhbWVWaWV3ID0gZG9jdW1lbnQoKS0+dmlldygpOworICAg IGludCBzY3JvbGxUb3AgPSBmcmFtZVZpZXctPnNjcm9sbE9mZnNldCgpLmhlaWdodCgpOworICAg IEZsb2F0UG9pbnQgYWJzb2x1dGVQb2ludCgwLCBzY3JvbGxUb3ApOworICAgIGludCB2aXNpYmxl SGVpZ2h0ID0gZnJhbWVWaWV3LT52aXNpYmxlQ29udGVudFJlY3QodHJ1ZSkuaGVpZ2h0KCk7Cisg ICAgaWYgKGhlaWdodCgpIDwgdmlzaWJsZUhlaWdodCkKKyAgICAgICAgYWJzb2x1dGVQb2ludC5t b3ZlKDAsICh2aXNpYmxlSGVpZ2h0IC0gaGVpZ2h0KCkpIC8gMik7CisgICAgRmxvYXRQb2ludCBs b2NhbFBvaW50ID0gY29udGFpbmluZ0Jsb2NrKCktPmFic29sdXRlVG9Mb2NhbChhYnNvbHV0ZVBv aW50KTsKKyAgICBMYXlvdXRVbml0IGxvY2FsVG9wID0gTGF5b3V0U2l6ZShsb2NhbFBvaW50Lngo KSwgbG9jYWxQb2ludC55KCkpLmhlaWdodCgpOworICAgIHNldFkobG9jYWxUb3ApOworCisgICAg c3RhdGVQdXNoZXIucG9wKCk7CisgICAgLy8gRklYTUU6IFNpbmNlIHRoZXJlIGlzIGFsd2F5cyBh IGxheWVyIGhlcmUsIHJlcGFpbnRlciBzaG91bGRuJ3QgYmUgbmVjZXNzYXJ5LiBCdXQgd2l0aG91 dCBpdCwgdGhlIGRpYWxvZyBpcyBzb21ldGltZXMgbm90IHBhaW50ZWQgKHNlZSBidWcgOTA2NzAp LgorICAgIHJlcGFpbnRlci5yZXBhaW50QWZ0ZXJMYXlvdXQoKTsKK30KKworfQorCisjZW5kaWYK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaCBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lYTY2OTQ2 OWUyZDNkODJjNmMxZTg2MmU0NzU2OWQ5M2Y2MjFmYWVhCi0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5oCkBAIC0wLDAgKzEsNTUgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAg UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3Jt IG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJ TVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1Q TElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFM IERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBP UiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAor ICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FS RSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaWZuZGVmIFJlbmRlckRpYWxvZ19oCisjZGVmaW5lIFJlbmRlckRpYWxvZ19oCisKKyNp ZiBFTkFCTEUoRElBTE9HX0VMRU1FTlQpCisjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKKyNpbmNs dWRlICJSZW5kZXJXaWRnZXQuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitjbGFzcyBIVE1M RGlhbG9nRWxlbWVudDsKKworY2xhc3MgUmVuZGVyRGlhbG9nIDogcHVibGljIFJlbmRlckJsb2Nr IHsKK3B1YmxpYzoKKyAgICBleHBsaWNpdCBSZW5kZXJEaWFsb2coTm9kZSogbm9kZSkKKyAgICAg ICAgOiBSZW5kZXJCbG9jayhub2RlKQorICAgIHsgfQorCisgICAgdmlydHVhbCB+UmVuZGVyRGlh bG9nKCkgeyB9CisgICAgdmlydHVhbCB2b2lkIGxheW91dCgpIE9WRVJSSURFOworCitwcml2YXRl OgorICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFtZSgpIGNvbnN0IHsgcmV0dXJuICJS ZW5kZXJEaWFsb2ciOyB9CisgICAgdmlydHVhbCBib29sIGlzRGlhbG9nKCkgY29uc3QgT1ZFUlJJ REUgeyByZXR1cm4gdHJ1ZTsgfQorfTsKKworfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5k aWYKKworI2VuZGlmIC8vIFJlbmRlckRpYWxvZ19oCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyT2JqZWN0LmgKaW5kZXggMjJiODMwMGJhMzQ1YzBmNWI1NDE3MjQ3YTU2ZDgwNmEwZmM4YTll ZC4uOWU5OTU1NGQ5NmY2MWFiZWVjYmMyYTc1OWVjMDBmOTAzMDlkMDMwMCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtMzExLDYgKzMxMSw5IEBAIHB1YmxpYzoK ICAgICB2aXJ0dWFsIGJvb2wgaXNCbG9ja0Zsb3coKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQog ICAgIHZpcnR1YWwgYm9vbCBpc0JveE1vZGVsT2JqZWN0KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7 IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNDb3VudGVyKCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0K KyNpZiBFTkFCTEUoRElBTE9HX0VMRU1FTlQpCisgICAgdmlydHVhbCBib29sIGlzRGlhbG9nKCkg Y29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKyNlbmRpZgogICAgIHZpcnR1YWwgYm9vbCBpc1F1b3Rl KCkgY29uc3QgeyByZXR1cm4gZmFsc2U7IH0KIAogI2lmIEVOQUJMRShERVRBSUxTX0VMRU1FTlQp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyaW5nQWxsSW5PbmUu Y3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcmluZ0FsbEluT25lLmNwcAppbmRl eCAxZjBhNGEzOGU3MmUyMWE3ZGMzZjBhZGNkM2NhZTM2M2M4YTUxZDkyLi4wM2JkZDNmOGI5NWRl YmVmOTY4MzYzNDkxY2MwZDNkMWI0MjA0YmZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyaW5nQWxsSW5PbmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJpbmdBbGxJbk9uZS5jcHAKQEAgLTUxLDYgKzUxLDcgQEAKICNpbmNsdWRlICJS ZW5kZXJDb3VudGVyLmNwcCIKICNpbmNsdWRlICJSZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3gu Y3BwIgogI2luY2x1ZGUgIlJlbmRlckRldGFpbHNNYXJrZXIuY3BwIgorI2luY2x1ZGUgIlJlbmRl ckRpYWxvZy5jcHAiCiAjaW5jbHVkZSAiUmVuZGVyRW1iZWRkZWRPYmplY3QuY3BwIgogI2luY2x1 ZGUgIlJlbmRlckZpZWxkc2V0LmNwcCIKICNpbmNsdWRlICJSZW5kZXJGaWxlVXBsb2FkQ29udHJv bC5jcHAiCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9D aGFuZ2VMb2cKaW5kZXggMmJhNGQ5ODdkMDVmNTg3MjNiMmQzN2VhMDE5MmY4NWY0ZmQyOGM5NC4u MjlmZTQxMWFhZWM2YWMxMWIyY2FkNTI1ZTgxMDI3MTYzNGUyNWExMyAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsx LDEzIEBACisyMDEyLTA5LTAzICBNYXR0IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9y Zz4KKworICAgICAgICBWZXJ0aWNhbGx5IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxl bWVudHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkw NjcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBm YXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5n LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1l bnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sOiBBZGRlZC4KKwogMjAxMi0w OC0zMSAgUGhpbGlwIFJvZ2VycyAgPHBkckBnb29nbGUuY29tPgogCiAgICAgICAgIFVucmV2aWV3 ZWQgdXBkYXRlIG9mIGZhc3QvanMvZnVuY3Rpb24tYXBwbHktYWxpYXNlZC5odG1sIGV4cGVjdGF0 aW9ucy4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50 L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVz dHMvZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlv bmluZy1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMDFiNWQxMzk3YTFlMzFhOTg3YjcyMmM4Y2E2 MWQ4NjUxNTY0ZDM4OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hU TUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQu dHh0CkBAIC0wLDAgKzEsMTQgQEAKK1Rlc3RzIGRlZmF1bHQgcG9zaXRpb25pbmcgb2Ygbm9uLWFu Y2hvcmVkIGRpYWxvZ3MuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAi UEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIGRp YWxvZy5vZmZzZXRUb3AgaXMgcGxhaW5EaXYub2Zmc2V0VG9wCitQQVNTIGRpYWxvZy5vZmZzZXRC b3R0b20gaXMgcGxhaW5EaXYub2Zmc2V0Qm90dG9tCitQQVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMg cGxhaW5EaXYub2Zmc2V0VG9wCitQQVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMgZXhwZWN0ZWRUb3AK K1BBU1MgZGlhbG9nLm9mZnNldFRvcCBpcyBleHBlY3RlZFRvcAorUEFTUyBzdWNjZXNzZnVsbHlQ YXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25p bmcuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNo b3JlZC1kaWFsb2ctcG9zaXRpb25pbmcuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hZDNiYmY3YzM1MmE3YWQy YzA4ZWMwMWJhNTliYTczZjI3ZjI0NjM0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmlu Zy5odG1sCkBAIC0wLDAgKzEsMTQwIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+ Cis8c3R5bGU+CisuZmlsbGVyIHsKKyAgICBoZWlnaHQ6IDIwMDAwcHg7Cit9Cis8L3N0eWxlPgor PHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+ Cis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpCisgICAgaW50ZXJuYWxzLnNldHRpbmdz LnNldERpYWxvZ0VsZW1lbnRFbmFibGVkKHRydWUpOworCitmdW5jdGlvbiBjaGVja1RvcE9mVmll d3BvcnQoZGlhbG9nKSB7CisgICAgc2hvdWxkQmUoJ2RpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJl Y3QoKS50b3AnLCAnMCcpOworfQorCitmdW5jdGlvbiBjaGVja0NlbnRlcmVkKGRpYWxvZykgewor ICAgIGV4cGVjdGVkVG9wID0gKHdpbmRvdy5pbm5lckhlaWdodCAtIGRpYWxvZy5vZmZzZXRIZWln aHQpIC8gMjsKKyAgICBzaG91bGRCZSgnZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRv cCcsICdleHBlY3RlZFRvcCcpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKyAgICA8 ZGlhbG9nIGlkPSJteWRpYWxvZyI+SXQgaXMgbXkgZGlhbG9nLjwvZGlhbG9nPgorICAgIDxkaXYg Y2xhc3M9ImZpbGxlciIgaWQ9ImZpbGxlckRpdiI+PC9kaXY+Cis8L2JvZHk+Cis8c2NyaXB0Pgor ZGVzY3JpcHRpb24oIlRlc3RzIGRlZmF1bHQgcG9zaXRpb25pbmcgb2Ygbm9uLWFuY2hvcmVkIGRp YWxvZ3MuIik7CisKK2RpYWxvZyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdteWRpYWxvZycp OworCisvLyBEaWFsb2cgc2hvdWxkIGJlIGNlbnRlcmVkIGluIHRoZSB2aWV3cG9ydC4KK2RpYWxv Zy5zaG93KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8g RGlhbG9nIHNob3VsZCBzdGlsbCBiZSBjZW50ZXJlZCBpZiBzaG93biBhZnRlciB3aW5kb3cgaXMg c2Nyb2xsZWQuCit3aW5kb3cuc2Nyb2xsKDAsIDUwMCk7CitkaWFsb2cuc2hvdygpOworY2hlY2tD ZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIEEgdGFsbCBkaWFsb2cgc2hv dWxkIGJlIHBvc2l0aW9uZWQgYXQgdGhlIHRvcCBvZiB0aGUgdmlld3BvcnQuCit2YXIgZGlhbG9n SW5uZXIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2RpYWxvZ0lubmVyLmNsYXNz TmFtZSA9ICdmaWxsZXInOworZGlhbG9nLmFwcGVuZENoaWxkKGRpYWxvZ0lubmVyKTsKK2RpYWxv Zy5zaG93KCk7CitjaGVja1RvcE9mVmlld3BvcnQoZGlhbG9nKTsKK2RpYWxvZy5jbG9zZSgpOwor ZGlhbG9nLnJlbW92ZUNoaWxkKGRpYWxvZ0lubmVyKTsKKworLy8gQWRkIHRoZSBob3Jpem9udGFs IHNjcm9sbGJhci4gVGhlIGRpYWxvZyBzaG91bGQgYmUgY2VudGVyZWQgcmVnYXJkbGVzcyBvZiB0 aGUgcHJlc2VuY2Ugb2Ygc2Nyb2xsYmFycy4KK3ZhciBmaWxsZXJEaXYgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgnZmlsbGVyRGl2Jyk7CitmaWxsZXJEaXYuc3R5bGUud2lkdGggPSAnNDAwMHB4 JzsKK2RpYWxvZy5zaG93KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2Uo KTsKK2ZpbGxlckRpdi5zdHlsZS53aWR0aCA9ICdhdXRvJzsKKworLy8gVGVzdCB0aGF0IGNlbnRl cmluZyB3b3JrcyB3aGVuIGRpYWxvZyBpcyBpbnNpZGUgcG9zaXRpb25lZCBjb250YWluZXJzLgor dmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29udGFpbmVy LnN0eWxlLnBvc2l0aW9uID0gJ2Fic29sdXRlJzsKK2NvbnRhaW5lci5zdHlsZS50b3AgPSAnODAw cHg7JworY29udGFpbmVyLnN0eWxlLmhlaWdodD0gJzUwcHg7JworY29udGFpbmVyLnN0eWxlLndp ZHRoID0gJzkwJSc7CitkaWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChkaWFsb2cpOworZG9j dW1lbnQuYm9keS5hcHBlbmRDaGlsZChjb250YWluZXIpOworY29udGFpbmVyLmFwcGVuZENoaWxk KGRpYWxvZyk7CitkaWFsb2cuc2hvdygpOworY2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9n LmNsb3NlKCk7Citjb250YWluZXIucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKKwordmFyIGNvbnRhaW5l cjIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2NvbnRhaW5lcjIuc3R5bGUucG9z aXRpb24gPSAncmVsYXRpdmUnOworY29udGFpbmVyMi5zdHlsZS50b3AgPSAnMjBweCc7Citjb250 YWluZXIyLnN0eWxlLmhlaWdodCA9ICczMHB4JzsKK2NvbnRhaW5lci5hcHBlbmRDaGlsZChjb250 YWluZXIyKTsKK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQoZGlhbG9nKTsKK2RpYWxvZy5zaG93KCk7 CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8gVGVzdCB0aGF0 IHNldHRpbmcgdG9wIG1hbnVhbGx5IGlzIHRoZSBzYW1lIGFzIGZvciBhIHBsYWluIGRpdi4KK3Zh ciBwbGFpbkRpdiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29udGFpbmVyMi5h cHBlbmRDaGlsZChwbGFpbkRpdik7CitwbGFpbkRpdi5zdHlsZS5wb3NpdGlvbiA9ICdhYnNvbHV0 ZSc7CitwbGFpbkRpdi5zdHlsZS50b3AgPSAnNTBweCc7CitkaWFsb2cuc3R5bGUudG9wID0gJzUw cHgnOworZGlhbG9nLnNob3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ3BsYWlu RGl2Lm9mZnNldFRvcCcpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBzZXR0aW5n IGJvdHRvbSBtYW51YWxseSBpcyB0aGUgc2FtZSBhcyBmb3IgYSBwbGFpbiBkaXYuCitkaWFsb2cu c3R5bGUudG9wID0gJ2F1dG8nOworcGxhaW5EaXYuc3R5bGUudG9wID0gJ2F1dG8nOworZGlhbG9n LnN0eWxlLmJvdHRvbSA9ICc1MHB4JzsKK3BsYWluRGl2LnN0eWxlLmJvdHRvbSA9ICc1MHB4JzsK K2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldEJvdHRvbScsICdwbGFpbkRp di5vZmZzZXRCb3R0b20nKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBUZXN0IHRoYXQgZml4ZWQg cG9zaXRpb24gaGFzIHRoZSB1c3VhbCBiZWhhdmlvci4KK3BsYWluRGl2LnN0eWxlLnBvc2l0aW9u ID0gJ2ZpeGVkJzsKK3BsYWluRGl2LnN0eWxlLnRvcCA9ICc1MHB4JzsKK2RpYWxvZy5zdHlsZS5w b3NpdGlvbiA9ICdmaXhlZCc7CitkaWFsb2cuc3R5bGUudG9wID0gJzUwcHgnOworZGlhbG9nLnNo b3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ3BsYWluRGl2Lm9mZnNldFRvcCcp OworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBzdGF0aWMgcG9zaXRpb24gaGFzIHRo ZSB1c3VhbCBiZWhhdmlvci4KK3BsYWluRGl2LnN0eWxlLnBvc2l0aW9uID0gJ3N0YXRpYyc7Citw bGFpbkRpdi5zdHlsZS50b3AgPSAnYXV0byc7Cit2YXIgZXhwZWN0ZWRUb3AgPSBwbGFpbkRpdi5v ZmZzZXRUb3A7CitwbGFpbkRpdi5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHBsYWluRGl2KTsKK2Rp YWxvZy5zdHlsZS5wb3NpdGlvbiA9ICdzdGF0aWMnOworZGlhbG9nLnN0eWxlLnRvcCA9ICdhdXRv JzsKK2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdleHBlY3Rl ZFRvcCcpOworZGlhbG9nLmNsb3NlKCk7CitkaWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChk aWFsb2cpOworCisvLyBUZXN0IHRoYXQgcmVsYXRpdmUgcG9zaXRpb24gaGFzIHRoZSB1c3VhbCBi ZWhhdmlvci4KK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQocGxhaW5EaXYpOworcGxhaW5EaXYuc3R5 bGUucG9zaXRpb24gPSAncmVsYXRpdmUnOworcGxhaW5EaXYuc3R5bGUudG9wID0gJzUwcHgnOwor ZXhwZWN0ZWRUb3AgPSBwbGFpbkRpdi5vZmZzZXRUb3A7CitwbGFpbkRpdi5wYXJlbnROb2RlLnJl bW92ZUNoaWxkKHBsYWluRGl2KTsKK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQoZGlhbG9nKTsKK2Rp YWxvZy5zdHlsZS5wb3NpdGlvbiA9ICdyZWxhdGl2ZSc7CitkaWFsb2cuc3R5bGUudG9wID0gJzUw cHgnOworZGlhbG9nLnNob3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ2V4cGVj dGVkVG9wJyk7CitkaWFsb2cuY2xvc2UoKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4u L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s Pgo= 162155 2012-09-04 21:25:57 -0700 2012-09-05 02:31:31 -0700 added FIXME for vertical mode bug-90670-20120905132539.patch text/plain 25479 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3NDM1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzhkYzY2NGZlNzhlY2Fh NmViZDE5YmMyNWQzZjEzODdhYTVkOGY2MS4uNTU5NmYwNGMxODJkY2E1NDU4ZTc1YzJhYmZjNDY3 OWRhM2VlN2UxZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDEyLTA5LTA0ICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBhZGp1c3RzIHRoZSBzdGF0aWMgZGVm YXVsdCBwb3NpdGlvbiBvZiBub24tYW5jaG9yZWQKKyAgICAgICAgZGlhbG9nIGVsZW1lbnRzIHNv IHRoZXkgYXJlIHZlcnRpY2FsbHkgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZgorICAgICAg ICB0aGUgdmlld3BvcnQsIGFzIHBlciB0aGUgc3BlYy4KKworICAgICAgICBUaGUgYXBwcm9hY2gg aXMgdG8gYWRkIGEgUmVuZGVyRGlhbG9nIGNsYXNzIHdob3NlIGxheW91dCgpCisgICAgICAgIGZ1 bmN0aW9uIGFkanVzdHMgdGhlIHBvc2l0aW9uIGFmdGVyIG5vcm1hbCBSZW5kZXJCbG9jazo6bGF5 b3V0IHJ1bnMuCisKKyAgICAgICAgVGVzdDogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9u LWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sCisKKyAgICAgICAgKiBDTWFrZUxpc3Rz LnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFRhcmdldC5w cmk6CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxEaWFsb2dFbGVtZW50OjpjcmVhdGVSZW5kZXJlcik6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50Lmg6Cisg ICAgICAgIChIVE1MRGlhbG9nRWxlbWVudCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJv eC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3g6Om1hcEFic29sdXRlVG9Mb2NhbFBv aW50KTogUmVtb3ZlIGFzc2VydGlvbiBzaW5jZSBub3cgYWJzb2x1dGVUb0xvY2FsIGlzIGNhbGxl ZCBkdXJpbmcgbGF5b3V0LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVj dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3hNb2RlbE9iamVjdDo6bWFwQWJzb2x1 dGVUb0xvY2FsUG9pbnQpOiBEaXR0by4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9n LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRl ckRpYWxvZzo6bGF5b3V0KTogQ29tcHV0ZSB0aGUgZGVzaXJlZCB0b3AgcG9zaXRpb24gaW4gdGhl IGFic29sdXRlIGNvb3JkaW5hdGUgc3lzdGVtLCBhbmQgdGhlbiBzZXQgdG9wIHRvIHRoZQorICAg ICAgICBjb3JyZXNwb25kaW5nIGxvY2FsIGNvb3JkaW5hdGUuCisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlckRpYWxvZy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoUmVu ZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6UmVuZGVyRGlhbG9n KToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6flJlbmRlckRpYWxvZyk6CisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OnJlbmRlck5hbWUpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmlzRGlhbG9nKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyaW5nQWxsSW5PbmUuY3BwOgorCiAyMDEyLTA5LTAzICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5y ZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCBy MTI3NDI3LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQgYi9Tb3Vy Y2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAppbmRleCA1NzlmMmNlMGQzNmQxMzFmYTU0OWI5ZTkw MmU2ZWRlZTRlZTVkMTBiLi4zYjc2MmI4ODNjZmY2YWY3YmM4NGQyYmFhZDJkMjAzMjNhYjA0MThm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DTWFrZUxpc3RzLnR4dAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9DTWFrZUxpc3RzLnR4dApAQCAtMjAzMyw2ICsyMDMzLDcgQEAgU0VUKFdlYkNvcmVf U09VUkNFUwogICAgIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcAogICAgIHJlbmRlcmluZy9S ZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3guY3BwCiAgICAgcmVuZGVyaW5nL1JlbmRlckRldGFp bHNNYXJrZXIuY3BwCisgICAgcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAKICAgICByZW5kZXJp bmcvUmVuZGVyRW1iZWRkZWRPYmplY3QuY3BwCiAgICAgcmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0 LmNwcAogICAgIHJlbmRlcmluZy9SZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5jcHAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9H TlVtYWtlZmlsZS5saXN0LmFtCmluZGV4IGI3MThiYjBkMDE1MzcyOGM2N2ZkZjExYmIwYzg4MzQx MDkxYmZhZWIuLjE1Mzk2OWNlYjdjYTgxYjM1MzIwZmJlZDdkNWQ2ZTlkNzg3NGY1Y2IgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQpAQCAtNDkwMSw2ICs0OTAxLDcgQEAgd2ViY29yZV9z b3VyY2VzICs9IFwKIAlTb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGVwcmVjYXRlZEZs ZXhpYmxlQm94LmggXAogCVNvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEZXRhaWxzTWFy a2VyLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIu aCBcCisJU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5oIFwKIAlTb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRW1iZWRkZWRPYmplY3QuY3BwIFwKIAlTb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyRW1iZWRkZWRPYmplY3QuaCBcCiAJU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckZpZWxkc2V0LmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9UYXJnZXQucHJpIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCBmNzM1OWFmOGZj MTIxZjY3MDZkZDZhMTE3MDM5Y2QxMWIwZmViYjRkLi42ZTFkOTA1NmYwOThjOTZjNTdkOWM0ZDMw NjJlNTU4NzY5NThhMjZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisr KyBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKQEAgLTExMTYsNiArMTExNiw3IEBAIFNPVVJD RVMgKz0gXAogICAgIHJlbmRlcmluZy9SZW5kZXJDb3VudGVyLmNwcCBcCiAgICAgcmVuZGVyaW5n L1JlbmRlckRlcHJlY2F0ZWRGbGV4aWJsZUJveC5jcHAgXAogICAgIHJlbmRlcmluZy9SZW5kZXJE ZXRhaWxzTWFya2VyLmNwcCBcCisgICAgcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAgXAogICAg IHJlbmRlcmluZy9SZW5kZXJFbWJlZGRlZE9iamVjdC5jcHAgXAogICAgIHJlbmRlcmluZy9SZW5k ZXJGaWVsZHNldC5jcHAgXAogICAgIHJlbmRlcmluZy9SZW5kZXJGaWxlVXBsb2FkQ29udHJvbC5j cHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpIGIvU291cmNlL1dl YkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDlmZWEyOTExODk3MTE2NjE2ODQwNGIxMWE4Yzk5ZDA1 MDBmMzlkOGUuLmRiM2MyNGYyNzk1NTdjNGFiYjJmMmIxMTc4MWQwYzkwN2ZlNTMzNmMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9X ZWJDb3JlLmd5cGkKQEAgLTU2Miw2ICs1NjIsNyBAQAogICAgICAgICAgICAgJ3JlbmRlcmluZy9S ZW5kZXJCbG9jay5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyQm94LmgnLAogICAg ICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5oJywKKyAgICAgICAgICAg ICdyZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5k ZXJFbWJlZGRlZE9iamVjdC5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRmxvd1Ro cmVhZC5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVySW1hZ2UuaCcsCkBAIC00NzI3 LDYgKzQ3MjgsNyBAQAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXByZWNhdGVkRmxl eGlibGVCb3guaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIu Y3BwJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtlci5oJywKKyAg ICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcCcsCiAgICAgICAgICAgICAncmVu ZGVyaW5nL1JlbmRlckVtYmVkZGVkT2JqZWN0LmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5n L1JlbmRlckZpZWxkc2V0LmNwcCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZpZWxk c2V0LmgnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJv amVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCmluZGV4IDhhNDI0M2Y3Nzg3OTMzNmFiZDJlYjIzNGZjZDBjOTBlMjY4OTVkZjYuLmI3 YzIzYTRmODBmMWFkYjBiN2YzNmJhN2FlYjhmNmVjMDNiNjM0N2EgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE5MTAsNiArMTkx MCw4IEBACiAJCTc2Q0REMkY1MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxp c3RQb3B1cC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0g NzZDREQyRUYxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdFBvcHVwLmgg Ki87IH07CiAJCTc2Q0REMkY2MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxp c3RPcHRpb24uY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gNzZDREQyRjAxMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlv bi5jcHAgKi87IH07CiAJCTc2Q0REMkY3MTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5 TWVudUxpc3RPcHRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IDc2Q0REMkYxMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RP cHRpb24uaCAqLzsgfTsKKwkJNzZEQzE3RTcxNUQzQUMxNDAwNjNDRjREIC8qIFJlbmRlckRpYWxv Zy5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkRD MTdFNTE1RDNBQzE0MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9nLmNwcCAqLzsgfTsKKwkJNzZEQzE3 RTgxNUQzQUMxNDAwNjNDRjREIC8qIFJlbmRlckRpYWxvZy5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZEQzE3RTYxNUQzQUMxNDAwNjNDRjREIC8qIFJl bmRlckRpYWxvZy5oICovOyB9OwogCQk3NkZDMkIwQjEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9r ZW5MaXN0LmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDc2RkMyQjA4MTIzNzBEQTAwMDZBOTkxQSAvKiBET01Ub2tlbkxpc3QuY3BwICovOyB9OwogCQk3 NkZDMkIwQzEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmggaW4gSGVhZGVycyAqLyA9 IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3NkZDMkIwOTEyMzcwREEwMDA2QTk5MUEg LyogRE9NVG9rZW5MaXN0LmggKi87IH07CiAJCTc2RkYxN0UzMTEyMzU2NzMwMDFENjFCNSAvKiBQ bHVnaW5WaWV3Tm9uZS5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZp bGVSZWYgPSA3NkZGMTdFMjExMjM1NjczMDAxRDYxQjUgLyogUGx1Z2luVmlld05vbmUuY3BwICov OyB9OwpAQCAtOTA5Nyw2ICs5MDk5LDggQEAKIAkJNzZDREQyRUYxMTAzREE2NjAwNjgwNTIxIC8q IEFjY2Vzc2liaWxpdHlNZW51TGlzdFBvcHVwLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsg cGF0aCA9IEFjY2Vzc2liaWxpdHlNZW51TGlzdFBvcHVwLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCTc2Q0REMkYwMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxp c3RPcHRpb24uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQWNjZXNz aWJpbGl0eU1lbnVMaXN0T3B0aW9uLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ NzZDREQyRjExMTAzREE2NjAwNjgwNTIxIC8qIEFjY2Vzc2liaWxpdHlNZW51TGlzdE9wdGlvbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBY2Nlc3NpYmlsaXR5TWVudUxpc3RP cHRpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzZEQzE3RTUxNUQzQUMxNDAw NjNDRjREIC8qIFJlbmRlckRpYWxvZy5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsg ZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7 IHBhdGggPSBSZW5kZXJEaWFsb2cuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQk3 NkRDMTdFNjE1RDNBQzE0MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9nLmggKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmMuaDsgcGF0aCA9IFJlbmRlckRpYWxvZy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk3NkZDMkIwODEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmNwcCAqLyA9 IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IERPTVRva2VuTGlzdC5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2RkMyQjA5MTIzNzBEQTAwMDZBOTkxQSAvKiBET01U b2tlbkxpc3QuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRE9NVG9rZW5MaXN0 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2RkMyQjBBMTIzNzBEQTAwMDZBOTkx QSAvKiBET01Ub2tlbkxpc3QuaWRsICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dDsgcGF0aCA9IERPTVRva2VuTGlz dC5pZGw7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMTMzNSw2ICsyMTMzOSw4IEBA CiAJCQkJQkNFQjE3OUIxNDMzNzlGNTAwNTJFQUU5IC8qIFJlbmRlckJveFJlZ2lvbkluZm8uaCAq LywKIAkJCQlCQ0VBNDgyNDA5N0Q5MzAyMDA5NEM5RTQgLyogUmVuZGVyQlIuY3BwICovLAogCQkJ CUJDRUE0ODI1MDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJCUi5oICovLAorCQkJCTc2REMxN0U1 MTVEM0FDMTQwMDYzQ0Y0RCAvKiBSZW5kZXJEaWFsb2cuY3BwICovLAorCQkJCTc2REMxN0U2MTVE M0FDMTQwMDYzQ0Y0RCAvKiBSZW5kZXJEaWFsb2cuaCAqLywKIAkJCQlCQ0VBNDgyNjA5N0Q5MzAy MDA5NEM5RTQgLyogUmVuZGVyQnV0dG9uLmNwcCAqLywKIAkJCQlCQ0VBNDgyNzA5N0Q5MzAyMDA5 NEM5RTQgLyogUmVuZGVyQnV0dG9uLmggKi8sCiAJCQkJQkNFNDQxMzExMkY3NDhFMjAwOUI4NEI4 IC8qIFJlbmRlckNvbWJpbmVUZXh0LmNwcCAqLywKQEAgLTI1NDkxLDYgKzI1NDk3LDcgQEAKIAkJ CQlFMUJFNTEyRTBDRjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVTb3J0LmggaW4gSGVhZGVy cyAqLywKIAkJCQk5NzdFMkUwRjEyRjBGQzlDMDBDMTMzNzkgLyogWFNTQXVkaXRvci5oIGluIEhl YWRlcnMgKi8sCiAJCQkJRkQ1MzczNTMxMzdCNjUxODAwMDA4RENFIC8qIFplcm9Qb2xlLmggaW4g SGVhZGVycyAqLywKKwkJCQk3NkRDMTdFODE1RDNBQzE0MDA2M0NGNEQgLyogUmVuZGVyRGlhbG9n LmggaW4gSGVhZGVycyAqLywKIAkJCQk5Mzc3QUJBMDE1REVGRUVGMDAzMUZEMDQgLyogUGFnaW5h dGlvbi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQ0NzZBQTgxNURDNEJCMTAwMzA1REIyIC8qIFdy aXRpbmdNb2RlLmggaW4gSGVhZGVycyAqLywKIAkJCQkzMUI4MDFCQjE1RUM1OEM3MDBDRTY0M0Qg LyogTGF5b3V0VHlwZXNJbmxpbmVNZXRob2RzLmggaW4gSGVhZGVycyAqLywKQEAgLTI4NTc4LDYg KzI4NTg1LDcgQEAKIAkJCQlFMUJFNTEyRDBDRjZDNTEyMDAyRUE5NTkgLyogWFNMVFVuaWNvZGVT b3J0LmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTk3N0UyRTBFMTJGMEZDOUMwMEMxMzM3OSAvKiBY U1NBdWRpdG9yLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUZENTM3MzUyMTM3QjY1MTgwMDAwOERD RSAvKiBaZXJvUG9sZS5jcHAgaW4gU291cmNlcyAqLywKKwkJCQk3NkRDMTdFNzE1RDNBQzE0MDA2 M0NGNEQgLyogUmVuZGVyRGlhbG9nLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTUyQjZDOUMyMTVF M0Y0REYwMDY5MEIwNSAvKiBET01OYW1lZEZsb3dDb2xsZWN0aW9uLmNwcCBpbiBTb3VyY2VzICov LAogCQkJCTUyQjZDOUM1MTVFM0Y0REYwMDY5MEIwNSAvKiBOYW1lZEZsb3dDb2xsZWN0aW9uLmNw cCBpbiBTb3VyY2VzICovLAogCQkJCTUyQ0NBOUUyMTVFM0Y2MkMwMDUzQzc3RiAvKiBKU0RPTU5h bWVkRmxvd0NvbGxlY3Rpb24uY3BwIGluIFNvdXJjZXMgKi8sCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTERpYWxvZ0VsZW1lbnQuY3BwCmluZGV4IDQ1MTBkODE0MzE5YzJlNTQzOGU5MzI3NzVjYWNk MWMwZGQyM2JhMjUuLjUzNzQzMjk2MDMwODc3MDc1Nzg5YmMxY2VhNzUwOTM3Nzk2N2FjODkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1lbnQuY3BwCkBAIC0yOSw2ICsyOSw3 IEBACiAjaWYgRU5BQkxFKERJQUxPR19FTEVNRU5UKQogCiAjaW5jbHVkZSAiRXhjZXB0aW9uQ29k ZS5oIgorI2luY2x1ZGUgIlJlbmRlckRpYWxvZy5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK QEAgLTcxLDYgKzcyLDExIEBAIGJvb2wgSFRNTERpYWxvZ0VsZW1lbnQ6OmlzUHJlc2VudGF0aW9u QXR0cmlidXRlKGNvbnN0IFF1YWxpZmllZE5hbWUmIG5hbWUpIGNvbnN0CiAgICAgcmV0dXJuIEhU TUxFbGVtZW50Ojppc1ByZXNlbnRhdGlvbkF0dHJpYnV0ZShuYW1lKTsKIH0KIAorUmVuZGVyT2Jq ZWN0KiBIVE1MRGlhbG9nRWxlbWVudDo6Y3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEqIGFyZW5h LCBSZW5kZXJTdHlsZSopCit7CisgICAgcmV0dXJuIG5ldyAoYXJlbmEpIFJlbmRlckRpYWxvZyh0 aGlzKTsKK30KKwogfQogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTERpYWxvZ0VsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1l bnQuaAppbmRleCBkMWRkNzc2ODk1NDNmNDQ3MmFlZDk3NGIzZmY3NDc3YWEwMTI2ZGFhLi43YTdi MDExOWZkZmViMGI3YmU3MWE4NjVjMDFjYWE3YTJlN2VlOWQzIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRt bC9IVE1MRGlhbG9nRWxlbWVudC5oCkBAIC00NSw2ICs0NSw3IEBAIHB1YmxpYzoKIHByaXZhdGU6 CiAgICAgSFRNTERpYWxvZ0VsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYsIERvY3VtZW50Kik7 CiAKKyAgICB2aXJ0dWFsIFJlbmRlck9iamVjdCogY3JlYXRlUmVuZGVyZXIoUmVuZGVyQXJlbmEq LCBSZW5kZXJTdHlsZSopIE9WRVJSSURFOwogICAgIHZpcnR1YWwgYm9vbCBpc1ByZXNlbnRhdGlv bkF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWROYW1lJikgY29uc3QgT1ZFUlJJREU7CiB9OwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCmluZGV4IDEyZmZmOGVkZjRhYjA3OTY3 MzUxMGUyOTMyZGZhNjg3ZjVhYWZmNzIuLjMxYmY1YjExYTQxZmJjZjFjMzQwMzVlNGU0NzYxOGRk NWE2ZTA5ZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3gu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCkBAIC0xMzU0 LDkgKzEzNTQsNiBAQCBjb25zdCBSZW5kZXJPYmplY3QqIFJlbmRlckJveDo6cHVzaE1hcHBpbmdU b0NvbnRhaW5lcihjb25zdCBSZW5kZXJCb3hNb2RlbE9iamVjdAogCiB2b2lkIFJlbmRlckJveDo6 bWFwQWJzb2x1dGVUb0xvY2FsUG9pbnQoYm9vbCBmaXhlZCwgYm9vbCB1c2VUcmFuc2Zvcm1zLCBU cmFuc2Zvcm1TdGF0ZSYgdHJhbnNmb3JtU3RhdGUpIGNvbnN0CiB7Ci0gICAgLy8gV2UgZG9uJ3Qg ZXhwZWN0IGFic29sdXRlVG9Mb2NhbCgpIHRvIGJlIGNhbGxlZCBkdXJpbmcgbGF5b3V0ICh5ZXQp Ci0gICAgQVNTRVJUKCF2aWV3KCkgfHwgIXZpZXcoKS0+bGF5b3V0U3RhdGVFbmFibGVkKCkpOwot ICAgIAogICAgIGJvb2wgaXNGaXhlZFBvcyA9IHN0eWxlKCktPnBvc2l0aW9uKCkgPT0gRml4ZWRQ b3NpdGlvbjsKICAgICBib29sIGhhc1RyYW5zZm9ybSA9IGhhc0xheWVyKCkgJiYgbGF5ZXIoKS0+ dHJhbnNmb3JtKCk7CiAgICAgaWYgKGhhc1RyYW5zZm9ybSkgewpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5jcHAKaW5kZXggMzI2YWM5N2MwM2E1 OTMxYTJjZTBhMTEzMzdjZGZkNTllZTNmOTFkYy4uMzkyOGVjY2M3N2ZjOWEzNGQzYmViY2FmZjBm OTA5NWI0OGNjN2E1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckJveE1vZGVsT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy Qm94TW9kZWxPYmplY3QuY3BwCkBAIC0yODMxLDkgKzI4MzEsNiBAQCBib29sIFJlbmRlckJveE1v ZGVsT2JqZWN0OjpzaG91bGRBbnRpYWxpYXNMaW5lcyhHcmFwaGljc0NvbnRleHQqIGNvbnRleHQp CiAKIHZvaWQgUmVuZGVyQm94TW9kZWxPYmplY3Q6Om1hcEFic29sdXRlVG9Mb2NhbFBvaW50KGJv b2wgZml4ZWQsIGJvb2wgdXNlVHJhbnNmb3JtcywgVHJhbnNmb3JtU3RhdGUmIHRyYW5zZm9ybVN0 YXRlKSBjb25zdAogewotICAgIC8vIFdlIGRvbid0IGV4cGVjdCBhYnNvbHV0ZVRvTG9jYWwoKSB0 byBiZSBjYWxsZWQgZHVyaW5nIGxheW91dCAoeWV0KQotICAgIEFTU0VSVCghdmlldygpIHx8ICF2 aWV3KCktPmxheW91dFN0YXRlRW5hYmxlZCgpKTsKLQogICAgIFJlbmRlck9iamVjdCogbyA9IGNv bnRhaW5lcigpOwogICAgIGlmICghbykKICAgICAgICAgcmV0dXJuOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40ZmI5NDA5MjViN2E3ODc0MmVl NDQzNGViMDRhYTY0M2QwZDljOGJjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAKQEAgLTAsMCArMSw2OSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEuICBSZWRpc3RyaWJ1 dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQU5EIElU UyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBPUiBJ VFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUwor ICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5ECisgKiBPTiBBTlkg VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJSZW5kZXJEaWFsb2cuaCIKKworI2lmIEVOQUJMRShE SUFMT0dfRUxFTUVOVCkKKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKKyNpbmNsdWRlICJMYXlvdXRS ZXBhaW50ZXIuaCIKKyNpbmNsdWRlICJSZW5kZXJMYXllci5oIgorI2luY2x1ZGUgIlJlbmRlclZp ZXcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFJlbmRlckRpYWxvZzo6bGF5b3V0 KCkKK3sKKyAgICBMYXlvdXRSZXBhaW50ZXIgcmVwYWludGVyKCp0aGlzLCB0cnVlKTsKKyAgICBM YXlvdXRTdGF0ZU1haW50YWluZXIgc3RhdGVQdXNoZXIodmlldygpLCB0aGlzLCBsb2NhdGlvbk9m ZnNldCgpLCBoYXNUcmFuc2Zvcm0oKSB8fCBoYXNSZWZsZWN0aW9uKCkgfHwgc3R5bGUoKS0+aXNG bGlwcGVkQmxvY2tzV3JpdGluZ01vZGUoKSk7CisKKyAgICBSZW5kZXJCbG9jazo6bGF5b3V0KCk7 CisKKyAgICBSZW5kZXJTdHlsZSogc3R5bGVUb1VzZSA9IHN0eWxlKCk7CisgICAgaWYgKHN0eWxl VG9Vc2UtPnBvc2l0aW9uKCkgIT0gQWJzb2x1dGVQb3NpdGlvbiB8fCAhc3R5bGVUb1VzZS0+dG9w KCkuaXNBdXRvKCkgfHwgIXN0eWxlVG9Vc2UtPmJvdHRvbSgpLmlzQXV0bygpKSB7CisgICAgICAg IHN0YXRlUHVzaGVyLnBvcCgpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gQWRq dXN0IHRoZSBkaWFsb2cncyBwb3NpdGlvbiB0byBiZSBjZW50ZXJlZCBpbiBvciBhdCB0aGUgdG9w IG9mIHRoZSB2aWV3cG9ydC4KKyAgICAvLyBGSVhNRTogRmlndXJlIG91dCB3aGF0IHRvIGRvIGlu IHZlcnRpY2FsIHdyaXRpbmcgbW9kZS4KKyAgICBGcmFtZVZpZXcqIGZyYW1lVmlldyA9IGRvY3Vt ZW50KCktPnZpZXcoKTsKKyAgICBpbnQgc2Nyb2xsVG9wID0gZnJhbWVWaWV3LT5zY3JvbGxPZmZz ZXQoKS5oZWlnaHQoKTsKKyAgICBGbG9hdFBvaW50IGFic29sdXRlUG9pbnQoMCwgc2Nyb2xsVG9w KTsKKyAgICBpbnQgdmlzaWJsZUhlaWdodCA9IGZyYW1lVmlldy0+dmlzaWJsZUNvbnRlbnRSZWN0 KHRydWUpLmhlaWdodCgpOworICAgIGlmIChoZWlnaHQoKSA8IHZpc2libGVIZWlnaHQpCisgICAg ICAgIGFic29sdXRlUG9pbnQubW92ZSgwLCAodmlzaWJsZUhlaWdodCAtIGhlaWdodCgpKSAvIDIp OworICAgIEZsb2F0UG9pbnQgbG9jYWxQb2ludCA9IGNvbnRhaW5pbmdCbG9jaygpLT5hYnNvbHV0 ZVRvTG9jYWwoYWJzb2x1dGVQb2ludCk7CisgICAgTGF5b3V0VW5pdCBsb2NhbFRvcCA9IExheW91 dFNpemUobG9jYWxQb2ludC54KCksIGxvY2FsUG9pbnQueSgpKS5oZWlnaHQoKTsKKyAgICBzZXRZ KGxvY2FsVG9wKTsKKworICAgIHN0YXRlUHVzaGVyLnBvcCgpOworICAgIC8vIEZJWE1FOiBTaW5j ZSB0aGVyZSBpcyBhbHdheXMgYSBsYXllciBoZXJlLCByZXBhaW50ZXIgc2hvdWxkbid0IGJlIG5l Y2Vzc2FyeS4gQnV0IHdpdGhvdXQgaXQsIHRoZSBkaWFsb2cgaXMgc29tZXRpbWVzIG5vdCBwYWlu dGVkIChzZWUgYnVnIDkwNjcwKS4KKyAgICByZXBhaW50ZXIucmVwYWludEFmdGVyTGF5b3V0KCk7 Cit9CisKK30KKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyRGlhbG9nLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmgK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uZWE2Njk0NjllMmQzZDgyYzZjMWU4NjJlNDc1NjlkOTNmNjIxZmFlYQotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaApA QCAtMCwwICsxLDU1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIEdvb2dsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRSSUJVVE9SUyAiQVMgSVMiIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZP UiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBM T1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBI T1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVS IElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0Ug T0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkg T0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBSZW5kZXJEaWFsb2dfaAorI2RlZmluZSBS ZW5kZXJEaWFsb2dfaAorCisjaWYgRU5BQkxFKERJQUxPR19FTEVNRU5UKQorI2luY2x1ZGUgIlJl bmRlckJsb2NrLmgiCisjaW5jbHVkZSAiUmVuZGVyV2lkZ2V0LmgiCisKK25hbWVzcGFjZSBXZWJD b3JlIHsKKworY2xhc3MgSFRNTERpYWxvZ0VsZW1lbnQ7CisKK2NsYXNzIFJlbmRlckRpYWxvZyA6 IHB1YmxpYyBSZW5kZXJCbG9jayB7CitwdWJsaWM6CisgICAgZXhwbGljaXQgUmVuZGVyRGlhbG9n KE5vZGUqIG5vZGUpCisgICAgICAgIDogUmVuZGVyQmxvY2sobm9kZSkKKyAgICB7IH0KKworICAg IHZpcnR1YWwgflJlbmRlckRpYWxvZygpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKSBP VkVSUklERTsKKworcHJpdmF0ZToKKyAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUo KSBjb25zdCB7IHJldHVybiAiUmVuZGVyRGlhbG9nIjsgfQorICAgIHZpcnR1YWwgYm9vbCBpc0Rp YWxvZygpIGNvbnN0IE9WRVJSSURFIHsgcmV0dXJuIHRydWU7IH0KK307CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKKworI2VuZGlmCisKKyNlbmRpZiAvLyBSZW5kZXJEaWFsb2dfaApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCmluZGV4IDIyYjgzMDBiYTM0NWMwZjViNTQx NzI0N2E1NmQ4MDZhMGZjOGE5ZWQuLjllOTk1NTRkOTZmNjFhYmVlY2JjMmE3NTllYzAwZjkwMzA5 ZDAzMDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3Qu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKQEAgLTMxMSw2 ICszMTEsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBib29sIGlzQmxvY2tGbG93KCkgY29uc3Qg eyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNCb3hNb2RlbE9iamVjdCgpIGNv bnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCBib29sIGlzQ291bnRlcigpIGNvbnN0 IHsgcmV0dXJuIGZhbHNlOyB9CisjaWYgRU5BQkxFKERJQUxPR19FTEVNRU5UKQorICAgIHZpcnR1 YWwgYm9vbCBpc0RpYWxvZygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CisjZW5kaWYKICAgICB2 aXJ0dWFsIGJvb2wgaXNRdW90ZSgpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9CiAKICNpZiBFTkFC TEUoREVUQUlMU19FTEVNRU5UKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlcmluZ0FsbEluT25lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJp bmdBbGxJbk9uZS5jcHAKaW5kZXggMWYwYTRhMzhlNzJlMjFhN2RjM2YwYWRjZDNjYWUzNjNjOGE1 MWQ5Mi4uMDNiZGQzZjhiOTVkZWJlZjk2ODM2MzQ5MWNjMGQzZDFiNDIwNGJmYyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcmluZ0FsbEluT25lLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyaW5nQWxsSW5PbmUuY3BwCkBAIC01MSw2ICs1 MSw3IEBACiAjaW5jbHVkZSAiUmVuZGVyQ291bnRlci5jcHAiCiAjaW5jbHVkZSAiUmVuZGVyRGVw cmVjYXRlZEZsZXhpYmxlQm94LmNwcCIKICNpbmNsdWRlICJSZW5kZXJEZXRhaWxzTWFya2VyLmNw cCIKKyNpbmNsdWRlICJSZW5kZXJEaWFsb2cuY3BwIgogI2luY2x1ZGUgIlJlbmRlckVtYmVkZGVk T2JqZWN0LmNwcCIKICNpbmNsdWRlICJSZW5kZXJGaWVsZHNldC5jcHAiCiAjaW5jbHVkZSAiUmVu ZGVyRmlsZVVwbG9hZENvbnRyb2wuY3BwIgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDkyZDJiMjMyZjQzNzdjMTMzMDg2YWEy MTQyZGVjYzU5YWQ2ZTAyNjkuLmEwMGJjZmYyNTI5N2UyODFlNjk4NzIxMDhmOTUwMjlmNDY5YjJl OWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMi0wOS0wNCAgTWF0dCBGYWxrZW5oYWdlbiAg PGZhbGtlbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVmVydGljYWxseSBjZW50ZXIgbm9uLWFu Y2hvcmVkIDxkaWFsb2c+IGVsZW1lbnRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD05MDY3MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVk LWRpYWxvZy1wb3NpdGlvbmluZy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv ZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmcuaHRt bDogQWRkZWQuCisKIDIwMTItMDktMDMgIEtlbmljaGkgSXNoaWJhc2hpICA8YmFzaGlAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFtDaHJvbWl1bV0gVW5yZXZpZXdlZCB0ZXN0IGV4cGVjdGF0aW9u cyB1cGRhdGUgYWZ0ZXIgcjEyNzQxMApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9kb20v SFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9y ZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mMDk1NWMxNzBj NGFlMzRjMmFhZTY5ZWU0NGVlOWUzNTM1ZmVkMDFjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3Np dGlvbmluZy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwyMCBAQAorVGVzdHMgZGVmYXVsdCBwb3Np dGlvbmluZyBvZiBub24tYW5jaG9yZWQgZGlhbG9ncy4KKworT24gc3VjY2VzcywgeW91IHdpbGwg c2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExF VEUiLgorCisKK1BBU1MgZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcCBpcyBleHBl Y3RlZFRvcAorUEFTUyBkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wIGlzIGV4cGVj dGVkVG9wCitQQVNTIGRpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50b3AgaXMgMAorUEFT UyBkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wIGlzIGV4cGVjdGVkVG9wCitQQVNT IGRpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50b3AgaXMgZXhwZWN0ZWRUb3AKK1BBU1Mg ZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcCBpcyBleHBlY3RlZFRvcAorUEFTUyBk aWFsb2cub2Zmc2V0VG9wIGlzIHBsYWluRGl2Lm9mZnNldFRvcAorUEFTUyBkaWFsb2cub2Zmc2V0 Qm90dG9tIGlzIHBsYWluRGl2Lm9mZnNldEJvdHRvbQorUEFTUyBkaWFsb2cub2Zmc2V0VG9wIGlz IHBsYWluRGl2Lm9mZnNldFRvcAorUEFTUyBkaWFsb2cub2Zmc2V0VG9wIGlzIGV4cGVjdGVkVG9w CitQQVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMgZXhwZWN0ZWRUb3AKK1BBU1Mgc3VjY2Vzc2Z1bGx5 UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9u aW5nLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5j aG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTAzMTY0MWM1NWEzZjkw MGU4MjJjZmM3OThmNjVlYjkyN2I3MzQ0OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3Rz L2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25p bmcuaHRtbApAQCAtMCwwICsxLDE0MSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFk PgorPHN0eWxlPgorLmZpbGxlciB7CisgICAgaGVpZ2h0OiAyMDAwMHB4OworfQorPC9zdHlsZT4K KzxzY3JpcHQgc3JjPSIuLi8uLi9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0 PgorPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKQorICAgIGludGVybmFscy5zZXR0aW5n cy5zZXREaWFsb2dFbGVtZW50RW5hYmxlZCh0cnVlKTsKKworZnVuY3Rpb24gY2hlY2tUb3BPZlZp ZXdwb3J0KGRpYWxvZykgeworICAgIHNob3VsZEJlKCdkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRS ZWN0KCkudG9wJywgJzAnKTsKK30KKworZnVuY3Rpb24gY2hlY2tDZW50ZXJlZChkaWFsb2cpIHsK KyAgICBleHBlY3RlZFRvcCA9ICh3aW5kb3cuaW5uZXJIZWlnaHQgLSBkaWFsb2cub2Zmc2V0SGVp Z2h0KSAvIDI7CisgICAgc2hvdWxkQmUoJ2RpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50 b3AnLCAnZXhwZWN0ZWRUb3AnKTsKK30KKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CisgICAg PGRpYWxvZyBpZD0ibXlkaWFsb2ciPkl0IGlzIG15IGRpYWxvZy48L2RpYWxvZz4KKyAgICA8ZGl2 IGNsYXNzPSJmaWxsZXIiIGlkPSJmaWxsZXJEaXYiPjwvZGl2PgorPC9ib2R5PgorPHNjcmlwdD4K K2Rlc2NyaXB0aW9uKCJUZXN0cyBkZWZhdWx0IHBvc2l0aW9uaW5nIG9mIG5vbi1hbmNob3JlZCBk aWFsb2dzLiIpOworCitkaWFsb2cgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnbXlkaWFsb2cn KTsKKworLy8gRGlhbG9nIHNob3VsZCBiZSBjZW50ZXJlZCBpbiB0aGUgdmlld3BvcnQuCitkaWFs b2cuc2hvdygpOworY2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8v IERpYWxvZyBzaG91bGQgc3RpbGwgYmUgY2VudGVyZWQgaWYgc2hvd24gYWZ0ZXIgd2luZG93IGlz IHNjcm9sbGVkLgord2luZG93LnNjcm9sbCgwLCA1MDApOworZGlhbG9nLnNob3coKTsKK2NoZWNr Q2VudGVyZWQoZGlhbG9nKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBBIHRhbGwgZGlhbG9nIHNo b3VsZCBiZSBwb3NpdGlvbmVkIGF0IHRoZSB0b3Agb2YgdGhlIHZpZXdwb3J0LgordmFyIGRpYWxv Z0lubmVyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CitkaWFsb2dJbm5lci5jbGFz c05hbWUgPSAnZmlsbGVyJzsKK2RpYWxvZy5hcHBlbmRDaGlsZChkaWFsb2dJbm5lcik7CitkaWFs b2cuc2hvdygpOworY2hlY2tUb3BPZlZpZXdwb3J0KGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsK K2RpYWxvZy5yZW1vdmVDaGlsZChkaWFsb2dJbm5lcik7CisKKy8vIEFkZCB0aGUgaG9yaXpvbnRh bCBzY3JvbGxiYXIuIFRoZSBkaWFsb2cgc2hvdWxkIGJlIGNlbnRlcmVkIHJlZ2FyZGxlc3Mgb2Yg dGhlIHByZXNlbmNlIG9mIHNjcm9sbGJhcnMuCit2YXIgZmlsbGVyRGl2ID0gZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoJ2ZpbGxlckRpdicpOworZmlsbGVyRGl2LnN0eWxlLndpZHRoID0gJzQwMDBw eCc7CitkaWFsb2cuc2hvdygpOworY2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3Nl KCk7CitmaWxsZXJEaXYuc3R5bGUud2lkdGggPSAnYXV0byc7CisKKy8vIFRlc3QgdGhhdCBjZW50 ZXJpbmcgd29ya3Mgd2hlbiBkaWFsb2cgaXMgaW5zaWRlIHBvc2l0aW9uZWQgY29udGFpbmVycy4K K3ZhciBjb250YWluZXIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2NvbnRhaW5l ci5zdHlsZS5wb3NpdGlvbiA9ICdhYnNvbHV0ZSc7Citjb250YWluZXIuc3R5bGUudG9wID0gJzgw MHB4OycKK2NvbnRhaW5lci5zdHlsZS5oZWlnaHQ9ICc1MHB4OycKK2NvbnRhaW5lci5zdHlsZS53 aWR0aCA9ICc5MCUnOworZGlhbG9nLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKK2Rv Y3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoY29udGFpbmVyKTsKK2NvbnRhaW5lci5hcHBlbmRDaGls ZChkaWFsb2cpOworZGlhbG9nLnNob3coKTsKK2NoZWNrQ2VudGVyZWQoZGlhbG9nKTsKK2RpYWxv Zy5jbG9zZSgpOworY29udGFpbmVyLnJlbW92ZUNoaWxkKGRpYWxvZyk7CisKK3ZhciBjb250YWlu ZXIyID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7CisvLyBGSVhNRTogVGhpcyB0ZXN0 IGZhaWxzIGZvciBwb3NpdGlvbiA9ICdyZWxhdGl2ZScuCitjb250YWluZXIyLnN0eWxlLnBvc2l0 aW9uID0gJ2Fic29sdXRlJzsKK2NvbnRhaW5lcjIuc3R5bGUudG9wID0gJzIwcHgnOworY29udGFp bmVyMi5zdHlsZS5oZWlnaHQgPSAnMzBweCc7Citjb250YWluZXIuYXBwZW5kQ2hpbGQoY29udGFp bmVyMik7Citjb250YWluZXIyLmFwcGVuZENoaWxkKGRpYWxvZyk7CitkaWFsb2cuc2hvdygpOwor Y2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBz ZXR0aW5nIHRvcCBtYW51YWxseSBpcyB0aGUgc2FtZSBhcyBmb3IgYSBwbGFpbiBkaXYuCit2YXIg cGxhaW5EaXYgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2NvbnRhaW5lcjIuYXBw ZW5kQ2hpbGQocGxhaW5EaXYpOworcGxhaW5EaXYuc3R5bGUucG9zaXRpb24gPSAnYWJzb2x1dGUn OworcGxhaW5EaXYuc3R5bGUudG9wID0gJzUwcHgnOworZGlhbG9nLnN0eWxlLnRvcCA9ICc1MHB4 JzsKK2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdwbGFpbkRp di5vZmZzZXRUb3AnKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBUZXN0IHRoYXQgc2V0dGluZyBi b3R0b20gbWFudWFsbHkgaXMgdGhlIHNhbWUgYXMgZm9yIGEgcGxhaW4gZGl2LgorZGlhbG9nLnN0 eWxlLnRvcCA9ICdhdXRvJzsKK3BsYWluRGl2LnN0eWxlLnRvcCA9ICdhdXRvJzsKK2RpYWxvZy5z dHlsZS5ib3R0b20gPSAnNTBweCc7CitwbGFpbkRpdi5zdHlsZS5ib3R0b20gPSAnNTBweCc7Citk aWFsb2cuc2hvdygpOworc2hvdWxkQmUoJ2RpYWxvZy5vZmZzZXRCb3R0b20nLCAncGxhaW5EaXYu b2Zmc2V0Qm90dG9tJyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8gVGVzdCB0aGF0IGZpeGVkIHBv c2l0aW9uIGhhcyB0aGUgdXN1YWwgYmVoYXZpb3IuCitwbGFpbkRpdi5zdHlsZS5wb3NpdGlvbiA9 ICdmaXhlZCc7CitwbGFpbkRpdi5zdHlsZS50b3AgPSAnNTBweCc7CitkaWFsb2cuc3R5bGUucG9z aXRpb24gPSAnZml4ZWQnOworZGlhbG9nLnN0eWxlLnRvcCA9ICc1MHB4JzsKK2RpYWxvZy5zaG93 KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdwbGFpbkRpdi5vZmZzZXRUb3AnKTsK K2RpYWxvZy5jbG9zZSgpOworCisvLyBUZXN0IHRoYXQgc3RhdGljIHBvc2l0aW9uIGhhcyB0aGUg dXN1YWwgYmVoYXZpb3IuCitwbGFpbkRpdi5zdHlsZS5wb3NpdGlvbiA9ICdzdGF0aWMnOworcGxh aW5EaXYuc3R5bGUudG9wID0gJ2F1dG8nOwordmFyIGV4cGVjdGVkVG9wID0gcGxhaW5EaXYub2Zm c2V0VG9wOworcGxhaW5EaXYucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChwbGFpbkRpdik7CitkaWFs b2cuc3R5bGUucG9zaXRpb24gPSAnc3RhdGljJzsKK2RpYWxvZy5zdHlsZS50b3AgPSAnYXV0byc7 CitkaWFsb2cuc2hvdygpOworc2hvdWxkQmUoJ2RpYWxvZy5vZmZzZXRUb3AnLCAnZXhwZWN0ZWRU b3AnKTsKK2RpYWxvZy5jbG9zZSgpOworZGlhbG9nLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoZGlh bG9nKTsKKworLy8gVGVzdCB0aGF0IHJlbGF0aXZlIHBvc2l0aW9uIGhhcyB0aGUgdXN1YWwgYmVo YXZpb3IuCitjb250YWluZXIyLmFwcGVuZENoaWxkKHBsYWluRGl2KTsKK3BsYWluRGl2LnN0eWxl LnBvc2l0aW9uID0gJ3JlbGF0aXZlJzsKK3BsYWluRGl2LnN0eWxlLnRvcCA9ICc1MHB4JzsKK2V4 cGVjdGVkVG9wID0gcGxhaW5EaXYub2Zmc2V0VG9wOworcGxhaW5EaXYucGFyZW50Tm9kZS5yZW1v dmVDaGlsZChwbGFpbkRpdik7Citjb250YWluZXIyLmFwcGVuZENoaWxkKGRpYWxvZyk7CitkaWFs b2cuc3R5bGUucG9zaXRpb24gPSAncmVsYXRpdmUnOworZGlhbG9nLnN0eWxlLnRvcCA9ICc1MHB4 JzsKK2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdleHBlY3Rl ZFRvcCcpOworZGlhbG9nLmNsb3NlKCk7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9q cy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 162196 2012-09-05 02:31:38 -0700 2012-09-05 19:23:45 -0700 fix xcode project bug-90670-20120905183120.patch text/plain 25199 falken U3VidmVyc2lvbiBSZXZpc2lvbjogMTI3NTY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWNmNTQ4N2FjNTYyMmY3 ZTAzY2RmNjAzNDdiYjI4NDJkNTYwZjgxZi4uY2E1ZTU2NTRhYTg0YTg2MjU0ODkzMDkwYThiYjg3 MDA4YTU5ZjUwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDEyLTA5LTA1ICBNYXR0 IEZhbGtlbmhhZ2VuICA8ZmFsa2VuQGNocm9taXVtLm9yZz4KKworICAgICAgICBWZXJ0aWNhbGx5 IGNlbnRlciBub24tYW5jaG9yZWQgPGRpYWxvZz4gZWxlbWVudHMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTkwNjcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhpcyBhZGp1c3RzIHRoZSBzdGF0aWMgZGVm YXVsdCBwb3NpdGlvbiBvZiBub24tYW5jaG9yZWQKKyAgICAgICAgZGlhbG9nIGVsZW1lbnRzIHNv IHRoZXkgYXJlIHZlcnRpY2FsbHkgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZgorICAgICAg ICB0aGUgdmlld3BvcnQsIGFzIHBlciB0aGUgc3BlYy4KKworICAgICAgICBUaGUgYXBwcm9hY2gg aXMgdG8gYWRkIGEgUmVuZGVyRGlhbG9nIGNsYXNzIHdob3NlIGxheW91dCgpCisgICAgICAgIGZ1 bmN0aW9uIGFkanVzdHMgdGhlIHBvc2l0aW9uIGFmdGVyIG5vcm1hbCBSZW5kZXJCbG9jazo6bGF5 b3V0IHJ1bnMuCisKKyAgICAgICAgVGVzdDogZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9u LWFuY2hvcmVkLWRpYWxvZy1wb3NpdGlvbmluZy5odG1sCisKKyAgICAgICAgKiBDTWFrZUxpc3Rz LnR4dDoKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAgICAgICAqIFRhcmdldC5w cmk6CisgICAgICAgICogV2ViQ29yZS5neXBpOgorICAgICAgICAqIFdlYkNvcmUueGNvZGVwcm9q L3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkhUTUxEaWFsb2dFbGVtZW50OjpjcmVhdGVSZW5kZXJlcik6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBodG1sL0hUTUxEaWFsb2dFbGVtZW50Lmg6Cisg ICAgICAgIChIVE1MRGlhbG9nRWxlbWVudCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJv eC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3g6Om1hcEFic29sdXRlVG9Mb2NhbFBv aW50KTogUmVtb3ZlIGFzc2VydGlvbiBzaW5jZSBub3cgYWJzb2x1dGVUb0xvY2FsIGlzIGNhbGxl ZCBkdXJpbmcgbGF5b3V0LgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVj dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3hNb2RlbE9iamVjdDo6bWFwQWJzb2x1 dGVUb0xvY2FsUG9pbnQpOiBEaXR0by4KKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyRGlhbG9n LmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRl ckRpYWxvZzo6bGF5b3V0KTogQ29tcHV0ZSB0aGUgZGVzaXJlZCB0b3AgcG9zaXRpb24gaW4gdGhl IGFic29sdXRlIGNvb3JkaW5hdGUgc3lzdGVtLCBhbmQgdGhlbiBzZXQgdG9wIHRvIHRoZQorICAg ICAgICBjb3JyZXNwb25kaW5nIGxvY2FsIGNvb3JkaW5hdGUuCisgICAgICAgICogcmVuZGVyaW5n L1JlbmRlckRpYWxvZy5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoUmVu ZGVyRGlhbG9nKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6UmVuZGVyRGlhbG9n KToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckRpYWxvZzo6flJlbmRlckRpYWxvZyk6CisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJEaWFsb2c6OnJlbmRlck5hbWUpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmlzRGlhbG9nKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVyaW5nQWxsSW5PbmUuY3BwOgorCiAyMDEyLTA5LTA1ICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBh cm9nYUB3ZWJraXQub3JnPgogCiAgICAgICAgIEJ1aWxkIGZpeCBmb3IgV2luQ0UgYWZ0ZXIgcjEy NzUyNS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NNYWtlTGlzdHMudHh0IGIvU291cmNl L1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKaW5kZXggOTUzNjE1ZDI5YTAzZDU4MDMzYmZkNzNhYjBh MTYwMDM3MWE0MjE2OC4uOTdhMjZlOTY3ZGZmYjY4M2Y3ODNlYmQ4ODk3NzMxOTk1NTk2MDExOSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ01ha2VMaXN0cy50eHQKKysrIGIvU291cmNlL1dl YkNvcmUvQ01ha2VMaXN0cy50eHQKQEAgLTIwMzUsNiArMjAzNSw3IEBAIFNFVChXZWJDb3JlX1NP VVJDRVMKICAgICByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAKICAgICByZW5kZXJpbmcvUmVu ZGVyRGVwcmVjYXRlZEZsZXhpYmxlQm94LmNwcAogICAgIHJlbmRlcmluZy9SZW5kZXJEZXRhaWxz TWFya2VyLmNwcAorICAgIHJlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwCiAgICAgcmVuZGVyaW5n L1JlbmRlckVtYmVkZGVkT2JqZWN0LmNwcAogICAgIHJlbmRlcmluZy9SZW5kZXJGaWVsZHNldC5j cHAKICAgICByZW5kZXJpbmcvUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuY3BwCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05V bWFrZWZpbGUubGlzdC5hbQppbmRleCBmNjI2ZGZlMmUwZmNkYTAzODY5YzhmMmZjYzAxMDZlZWFl YjMwMWI5Li43Nzc0YWNhYTdhMWYyNWUwMzM0YTU0ODJiZjQ2OWIzMjM2Y2I5NzUwIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJD b3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAgLTQ5MTAsNiArNDkxMCw3IEBAIHdlYmNvcmVfc291 cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRlcHJlY2F0ZWRGbGV4 aWJsZUJveC5oIFwKIAlTb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGV0YWlsc01hcmtl ci5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEZXRhaWxzTWFya2VyLmgg XAorCVNvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJEaWFsb2cuaCBcCiAJU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlckVtYmVkZGVkT2JqZWN0LmNwcCBcCiAJU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckVtYmVkZGVkT2JqZWN0LmggXAogCVNvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJGaWVsZHNldC5jcHAgXApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv VGFyZ2V0LnByaSBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKaW5kZXggYzgzM2IwZmQ1NzMx M2QyZDEwNmRkM2VkYTVlNTYwMTViNTYwOGRiMS4uZDkwNjI4YzdjY2I2NTBmZGUyZThiYzdiZWE3 NDNjN2VjOWI5NTMyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQorKysg Yi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCkBAIC0xMTE2LDYgKzExMTYsNyBAQCBTT1VSQ0VT ICs9IFwKICAgICByZW5kZXJpbmcvUmVuZGVyQ291bnRlci5jcHAgXAogICAgIHJlbmRlcmluZy9S ZW5kZXJEZXByZWNhdGVkRmxleGlibGVCb3guY3BwIFwKICAgICByZW5kZXJpbmcvUmVuZGVyRGV0 YWlsc01hcmtlci5jcHAgXAorICAgIHJlbmRlcmluZy9SZW5kZXJEaWFsb2cuY3BwIFwKICAgICBy ZW5kZXJpbmcvUmVuZGVyRW1iZWRkZWRPYmplY3QuY3BwIFwKICAgICByZW5kZXJpbmcvUmVuZGVy RmllbGRzZXQuY3BwIFwKICAgICByZW5kZXJpbmcvUmVuZGVyRmlsZVVwbG9hZENvbnRyb2wuY3Bw IFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBiL1NvdXJjZS9XZWJD b3JlL1dlYkNvcmUuZ3lwaQppbmRleCA5MWM0NDYxN2EwN2E1ZTMzOTJlM2IxMWQ1N2U3ZTczZjI4 ZmUzZjU0Li40YjgzNThhZGIxODgzZTQ3ODZhMDcwMTM5Mzg1ZTQ3NDliNzg4MzY4IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS5neXBpCkBAIC01NjUsNiArNTY1LDcgQEAKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVu ZGVyQmxvY2suaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckJveC5oJywKICAgICAg ICAgICAgICdyZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuaCcsCisgICAgICAgICAgICAn cmVuZGVyaW5nL1JlbmRlckRpYWxvZy5oJywKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVy RW1iZWRkZWRPYmplY3QuaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckZsb3dUaHJl YWQuaCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckltYWdlLmgnLApAQCAtNDczNCw2 ICs0NzM1LDcgQEAKICAgICAgICAgICAgICdyZW5kZXJpbmcvUmVuZGVyRGVwcmVjYXRlZEZsZXhp YmxlQm94LmgnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJEZXRhaWxzTWFya2VyLmNw cCcsCiAgICAgICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRldGFpbHNNYXJrZXIuaCcsCisgICAg ICAgICAgICAncmVuZGVyaW5nL1JlbmRlckRpYWxvZy5jcHAnLAogICAgICAgICAgICAgJ3JlbmRl cmluZy9SZW5kZXJFbWJlZGRlZE9iamVjdC5jcHAnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9S ZW5kZXJGaWVsZHNldC5jcHAnLAogICAgICAgICAgICAgJ3JlbmRlcmluZy9SZW5kZXJGaWVsZHNl dC5oJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2pl Y3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagppbmRleCA0ZTYwNjVlZTZhZDk1NzBkZGEyZTUzYWNhMmFiN2VjMzFlMGQ0YzFiLi5lNDI4 OGZlZGM1YjlhNmRiZDU4Mzc1YWIxYTRiOTAyMjczNzg4OTY1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL1dl YkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xOTEwLDYgKzE5MTAs OCBAQAogCQk3NkNERDJGNTExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0 UG9wdXAuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2 Q0REMkVGMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RQb3B1cC5oICov OyB9OwogCQk3NkNERDJGNjExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0 T3B0aW9uLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IDc2Q0REMkYwMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24u Y3BwICovOyB9OwogCQk3NkNERDJGNzExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1l bnVMaXN0T3B0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVS ZWYgPSA3NkNERDJGMTExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0T3B0 aW9uLmggKi87IH07CisJCTc2RjJFMkVCMTVGNzRDRUYwMDVGRjY2NCAvKiBSZW5kZXJEaWFsb2cu Y3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZGMkUy RTkxNUY3NENFRjAwNUZGNjY0IC8qIFJlbmRlckRpYWxvZy5jcHAgKi87IH07CisJCTc2RjJFMkVD MTVGNzRDRUYwMDVGRjY2NCAvKiBSZW5kZXJEaWFsb2cuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc2RjJFMkVBMTVGNzRDRUYwMDVGRjY2NCAvKiBSZW5k ZXJEaWFsb2cuaCAqLzsgfTsKIAkJNzZGQzJCMEIxMjM3MERBMDAwNkE5OTFBIC8qIERPTVRva2Vu TGlzdC5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3 NkZDMkIwODEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9rZW5MaXN0LmNwcCAqLzsgfTsKIAkJNzZG QzJCMEMxMjM3MERBMDAwNkE5OTFBIC8qIERPTVRva2VuTGlzdC5oIGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gNzZGQzJCMDkxMjM3MERBMDAwNkE5OTFBIC8q IERPTVRva2VuTGlzdC5oICovOyB9OwogCQk3NkZGMTdFMzExMjM1NjczMDAxRDYxQjUgLyogUGx1 Z2luVmlld05vbmUuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gNzZGRjE3RTIxMTIzNTY3MzAwMUQ2MUI1IC8qIFBsdWdpblZpZXdOb25lLmNwcCAqLzsg fTsKQEAgLTkwOTUsNiArOTA5Nyw4IEBACiAJCTc2Q0REMkVGMTEwM0RBNjYwMDY4MDUyMSAvKiBB Y2Nlc3NpYmlsaXR5TWVudUxpc3RQb3B1cC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBh dGggPSBBY2Nlc3NpYmlsaXR5TWVudUxpc3RQb3B1cC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQk3NkNERDJGMDExMDNEQTY2MDA2ODA1MjEgLyogQWNjZXNzaWJpbGl0eU1lbnVMaXN0 T3B0aW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0 OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEFjY2Vzc2li aWxpdHlNZW51TGlzdE9wdGlvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCTc2 Q0REMkYxMTEwM0RBNjYwMDY4MDUyMSAvKiBBY2Nlc3NpYmlsaXR5TWVudUxpc3RPcHRpb24uaCAq LyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25G aWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQWNjZXNzaWJpbGl0eU1lbnVMaXN0T3B0 aW9uLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCTc2RjJFMkU5MTVGNzRDRUYwMDVG RjY2NCAvKiBSZW5kZXJEaWFsb2cuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gUmVuZGVyRGlhbG9nLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJNzZG MkUyRUExNUY3NENFRjAwNUZGNjY0IC8qIFJlbmRlckRpYWxvZy5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNl Y29kZS5jLmg7IHBhdGggPSBSZW5kZXJEaWFsb2cuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+Ijsg fTsKIAkJNzZGQzJCMDgxMjM3MERBMDAwNkE5OTFBIC8qIERPTVRva2VuTGlzdC5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBET01Ub2tlbkxpc3QuY3BwOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQk3NkZDMkIwOTEyMzcwREEwMDA2QTk5MUEgLyogRE9NVG9r ZW5MaXN0LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IERPTVRva2VuTGlzdC5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQk3NkZDMkIwQTEyMzcwREEwMDA2QTk5MUEg LyogRE9NVG9rZW5MaXN0LmlkbCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQ7IHBhdGggPSBET01Ub2tlbkxpc3Qu aWRsOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtMjEzMzksNiArMjEzNDMsOCBAQAog CQkJCUJDRUE0ODJGMDk3RDkzMDIwMDk0QzlFNCAvKiBSZW5kZXJEZXByZWNhdGVkRmxleGlibGVC b3guaCAqLywKIAkJCQlEMzAyNzU0NTEyQTVGRTg0MDA0QkQ4MjggLyogUmVuZGVyRGV0YWlsc01h cmtlci5jcHAgKi8sCiAJCQkJRDMwMjc1NDYxMkE1RkU4NDAwNEJEODI4IC8qIFJlbmRlckRldGFp bHNNYXJrZXIuaCAqLywKKwkJCQk3NkYyRTJFOTE1Rjc0Q0VGMDA1RkY2NjQgLyogUmVuZGVyRGlh bG9nLmNwcCAqLywKKwkJCQk3NkYyRTJFQTE1Rjc0Q0VGMDA1RkY2NjQgLyogUmVuZGVyRGlhbG9n LmggKi8sCiAJCQkJMEY1QjdBNTIxMEY2NUQ3QTAwMzc2MzAyIC8qIFJlbmRlckVtYmVkZGVkT2Jq ZWN0LmNwcCAqLywKIAkJCQkwRjVCN0E1MzEwRjY1RDdBMDAzNzYzMDIgLyogUmVuZGVyRW1iZWRk ZWRPYmplY3QuaCAqLywKIAkJCQlBOEVBNzNBRjBBMTkwMEUzMDBBOEVGNUYgLyogUmVuZGVyRmll bGRzZXQuY3BwICovLApAQCAtMjU0OTAsNiArMjU0OTYsNyBAQAogCQkJCUZCRDZBRjg4MTVFRjI1 QzkwMDhCNzExMCAvKiBDU1NCYXNpY1NoYXBlcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJRkJENkFG OEExNUVGMjVERjAwOEI3MTEwIC8qIEJhc2ljU2hhcGVGdW5jdGlvbnMuaCBpbiBIZWFkZXJzICov LAogCQkJCUZCRDZBRjhDMTVFRjI2MDQwMDhCNzExMCAvKiBCYXNpY1NoYXBlcy5oIGluIEhlYWRl cnMgKi8sCisJCQkJNzZGMkUyRUMxNUY3NENFRjAwNUZGNjY0IC8qIFJlbmRlckRpYWxvZy5oIGlu IEhlYWRlcnMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQb3N0cHJvY2Vzc2lu ZyA9IDA7CiAJCX07CkBAIC0yODU3OSw2ICsyODU4Niw3IEBACiAJCQkJNEZCMzkwQUQxNUVGNjFG MzAwN0FENTFGIC8qIEdlbmVyYXRlZEltYWdlLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCTM3N0Ez QTkwMTVFRkNFOUIwMDU5RjVDNyAvKiBCaXRtYXBJbWFnZUNHLmNwcCBpbiBTb3VyY2VzICovLAog CQkJCUJDRDhBNUYwMTVGNTZGMkMwMDk4RDA3MSAvKiBUZXh0QnJlYWtJdGVyYXRvci5jcHAgaW4g U291cmNlcyAqLywKKwkJCQk3NkYyRTJFQjE1Rjc0Q0VGMDA1RkY2NjQgLyogUmVuZGVyRGlhbG9n LmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9ubHlGb3JEZXBsb3ltZW50UG9zdHBy b2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M RGlhbG9nRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50 LmNwcAppbmRleCA0NTEwZDgxNDMxOWMyZTU0MzhlOTMyNzc1Y2FjZDFjMGRkMjNiYTI1Li41Mzc0 MzI5NjAzMDg3NzA3NTc4OWJjMWNlYTc1MDkzNzc5NjdhYzg5IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxEaWFsb2dFbGVtZW50LmNwcApAQCAtMjksNiArMjksNyBAQAogI2lmIEVOQUJMRShE SUFMT0dfRUxFTUVOVCkKIAogI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKKyNpbmNsdWRlICJS ZW5kZXJEaWFsb2cuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC03MSw2ICs3MiwxMSBA QCBib29sIEhUTUxEaWFsb2dFbGVtZW50Ojppc1ByZXNlbnRhdGlvbkF0dHJpYnV0ZShjb25zdCBR dWFsaWZpZWROYW1lJiBuYW1lKSBjb25zdAogICAgIHJldHVybiBIVE1MRWxlbWVudDo6aXNQcmVz ZW50YXRpb25BdHRyaWJ1dGUobmFtZSk7CiB9CiAKK1JlbmRlck9iamVjdCogSFRNTERpYWxvZ0Vs ZW1lbnQ6OmNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiBhcmVuYSwgUmVuZGVyU3R5bGUqKQor eworICAgIHJldHVybiBuZXcgKGFyZW5hKSBSZW5kZXJEaWFsb2codGhpcyk7Cit9CisKIH0KIAog I2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50 LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxEaWFsb2dFbGVtZW50LmgKaW5kZXggZDFkZDc3 Njg5NTQzZjQ0NzJhZWQ5NzRiM2ZmNzQ3N2FhMDEyNmRhYS4uN2E3YjAxMTlmZGZlYjBiN2JlNzFh ODY1YzAxY2FhN2EyZTdlZTlkMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M RGlhbG9nRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTERpYWxvZ0VsZW1l bnQuaApAQCAtNDUsNiArNDUsNyBAQCBwdWJsaWM6CiBwcml2YXRlOgogICAgIEhUTUxEaWFsb2dF bGVtZW50KGNvbnN0IFF1YWxpZmllZE5hbWUmLCBEb2N1bWVudCopOwogCisgICAgdmlydHVhbCBS ZW5kZXJPYmplY3QqIGNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiwgUmVuZGVyU3R5bGUqKSBP VkVSUklERTsKICAgICB2aXJ0dWFsIGJvb2wgaXNQcmVzZW50YXRpb25BdHRyaWJ1dGUoY29uc3Qg UXVhbGlmaWVkTmFtZSYpIGNvbnN0IE9WRVJSSURFOwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQm94LmNwcAppbmRleCA2ZjQ5MTY1MTIzNzFmYzNmNTYwZDc1YWM5ZDRjNmMxMzcz MjRjZTg1Li5jOGNhN2M4NmQ4M2EzNDllODM0YjIwMWI2NjU5OWQ3OGVmZWQxMWY0IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtMTM1NCw5ICsxMzU0LDYgQEAgY29u c3QgUmVuZGVyT2JqZWN0KiBSZW5kZXJCb3g6OnB1c2hNYXBwaW5nVG9Db250YWluZXIoY29uc3Qg UmVuZGVyQm94TW9kZWxPYmplY3QKIAogdm9pZCBSZW5kZXJCb3g6Om1hcEFic29sdXRlVG9Mb2Nh bFBvaW50KGJvb2wgZml4ZWQsIGJvb2wgdXNlVHJhbnNmb3JtcywgVHJhbnNmb3JtU3RhdGUmIHRy YW5zZm9ybVN0YXRlKSBjb25zdAogewotICAgIC8vIFdlIGRvbid0IGV4cGVjdCBhYnNvbHV0ZVRv TG9jYWwoKSB0byBiZSBjYWxsZWQgZHVyaW5nIGxheW91dCAoeWV0KQotICAgIEFTU0VSVCghdmll dygpIHx8ICF2aWV3KCktPmxheW91dFN0YXRlRW5hYmxlZCgpKTsKLSAgICAKICAgICBib29sIGlz Rml4ZWRQb3MgPSBzdHlsZSgpLT5wb3NpdGlvbigpID09IEZpeGVkUG9zaXRpb247CiAgICAgYm9v bCBoYXNUcmFuc2Zvcm0gPSBoYXNMYXllcigpICYmIGxheWVyKCktPnRyYW5zZm9ybSgpOwogICAg IGlmIChoYXNUcmFuc2Zvcm0pIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJCb3hNb2RlbE9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQm94TW9kZWxPYmplY3QuY3BwCmluZGV4IGUyYjc2YWY1YTkwODgxZjI2NmU5YzlhOWM3YTkx OGIxZDI2MzVlYTEuLjAxYTU3OWM4YmFlYjY4OTAyYjg2ODYyNmU5ODczMjQ2NTU5YmQzN2IgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmNw cApAQCAtMjgzMSw5ICsyODMxLDYgQEAgYm9vbCBSZW5kZXJCb3hNb2RlbE9iamVjdDo6c2hvdWxk QW50aWFsaWFzTGluZXMoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0KQogCiB2b2lkIFJlbmRlckJv eE1vZGVsT2JqZWN0OjptYXBBYnNvbHV0ZVRvTG9jYWxQb2ludChib29sIGZpeGVkLCBib29sIHVz ZVRyYW5zZm9ybXMsIFRyYW5zZm9ybVN0YXRlJiB0cmFuc2Zvcm1TdGF0ZSkgY29uc3QKIHsKLSAg ICAvLyBXZSBkb24ndCBleHBlY3QgYWJzb2x1dGVUb0xvY2FsKCkgdG8gYmUgY2FsbGVkIGR1cmlu ZyBsYXlvdXQgKHlldCkKLSAgICBBU1NFUlQoIXZpZXcoKSB8fCAhdmlldygpLT5sYXlvdXRTdGF0 ZUVuYWJsZWQoKSk7Ci0KICAgICBSZW5kZXJPYmplY3QqIG8gPSBjb250YWluZXIoKTsKICAgICBp ZiAoIW8pCiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJEaWFsb2cuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRp YWxvZy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uNGZiOTQwOTI1YjdhNzg3NDJlZTQ0MzRlYjA0YWE2NDNkMGQ5 YzhiYwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJE aWFsb2cuY3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29v Z2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQg dXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAg UmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBj b3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Ig b3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBU SElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJB UyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICog RElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisj aW5jbHVkZSAiUmVuZGVyRGlhbG9nLmgiCisKKyNpZiBFTkFCTEUoRElBTE9HX0VMRU1FTlQpCisj aW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiTGF5b3V0UmVwYWludGVyLmgiCisjaW5j bHVkZSAiUmVuZGVyTGF5ZXIuaCIKKyNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCisKK25hbWVzcGFj ZSBXZWJDb3JlIHsKKwordm9pZCBSZW5kZXJEaWFsb2c6OmxheW91dCgpCit7CisgICAgTGF5b3V0 UmVwYWludGVyIHJlcGFpbnRlcigqdGhpcywgdHJ1ZSk7CisgICAgTGF5b3V0U3RhdGVNYWludGFp bmVyIHN0YXRlUHVzaGVyKHZpZXcoKSwgdGhpcywgbG9jYXRpb25PZmZzZXQoKSwgaGFzVHJhbnNm b3JtKCkgfHwgaGFzUmVmbGVjdGlvbigpIHx8IHN0eWxlKCktPmlzRmxpcHBlZEJsb2Nrc1dyaXRp bmdNb2RlKCkpOworCisgICAgUmVuZGVyQmxvY2s6OmxheW91dCgpOworCisgICAgUmVuZGVyU3R5 bGUqIHN0eWxlVG9Vc2UgPSBzdHlsZSgpOworICAgIGlmIChzdHlsZVRvVXNlLT5wb3NpdGlvbigp ICE9IEFic29sdXRlUG9zaXRpb24gfHwgIXN0eWxlVG9Vc2UtPnRvcCgpLmlzQXV0bygpIHx8ICFz dHlsZVRvVXNlLT5ib3R0b20oKS5pc0F1dG8oKSkgeworICAgICAgICBzdGF0ZVB1c2hlci5wb3Ao KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIC8vIEFkanVzdCB0aGUgZGlhbG9nJ3Mg cG9zaXRpb24gdG8gYmUgY2VudGVyZWQgaW4gb3IgYXQgdGhlIHRvcCBvZiB0aGUgdmlld3BvcnQu CisgICAgLy8gRklYTUU6IEZpZ3VyZSBvdXQgd2hhdCB0byBkbyBpbiB2ZXJ0aWNhbCB3cml0aW5n IG1vZGUuCisgICAgRnJhbWVWaWV3KiBmcmFtZVZpZXcgPSBkb2N1bWVudCgpLT52aWV3KCk7Cisg ICAgaW50IHNjcm9sbFRvcCA9IGZyYW1lVmlldy0+c2Nyb2xsT2Zmc2V0KCkuaGVpZ2h0KCk7Cisg ICAgRmxvYXRQb2ludCBhYnNvbHV0ZVBvaW50KDAsIHNjcm9sbFRvcCk7CisgICAgaW50IHZpc2li bGVIZWlnaHQgPSBmcmFtZVZpZXctPnZpc2libGVDb250ZW50UmVjdCh0cnVlKS5oZWlnaHQoKTsK KyAgICBpZiAoaGVpZ2h0KCkgPCB2aXNpYmxlSGVpZ2h0KQorICAgICAgICBhYnNvbHV0ZVBvaW50 Lm1vdmUoMCwgKHZpc2libGVIZWlnaHQgLSBoZWlnaHQoKSkgLyAyKTsKKyAgICBGbG9hdFBvaW50 IGxvY2FsUG9pbnQgPSBjb250YWluaW5nQmxvY2soKS0+YWJzb2x1dGVUb0xvY2FsKGFic29sdXRl UG9pbnQpOworICAgIExheW91dFVuaXQgbG9jYWxUb3AgPSBMYXlvdXRTaXplKGxvY2FsUG9pbnQu eCgpLCBsb2NhbFBvaW50LnkoKSkuaGVpZ2h0KCk7CisgICAgc2V0WShsb2NhbFRvcCk7CisKKyAg ICBzdGF0ZVB1c2hlci5wb3AoKTsKKyAgICAvLyBGSVhNRTogU2luY2UgdGhlcmUgaXMgYWx3YXlz IGEgbGF5ZXIgaGVyZSwgcmVwYWludGVyIHNob3VsZG4ndCBiZSBuZWNlc3NhcnkuIEJ1dCB3aXRo b3V0IGl0LCB0aGUgZGlhbG9nIGlzIHNvbWV0aW1lcyBub3QgcGFpbnRlZCAoc2VlIGJ1ZyA5MDY3 MCkuCisgICAgcmVwYWludGVyLnJlcGFpbnRBZnRlckxheW91dCgpOworfQorCit9CisKKyNlbmRp ZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5oIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckRpYWxvZy5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVhNjY5 NDY5ZTJkM2Q4MmM2YzFlODYyZTQ3NTY5ZDkzZjYyMWZhZWEKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyRGlhbG9nLmgKQEAgLTAsMCArMSw1NSBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICoKKyAqIDEu ICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUK KyAqICAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0 aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg QVBQTEUgQU5EIElUUyBDT05UUklCVVRPUlMgIkFTIElTIiBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJ TVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1Qs IElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E CisgKiBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GCisgKiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgUmVuZGVyRGlhbG9nX2gKKyNkZWZpbmUgUmVuZGVyRGlhbG9nX2gKKwor I2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKKyNpbmNsdWRlICJSZW5kZXJCbG9jay5oIgorI2lu Y2x1ZGUgIlJlbmRlcldpZGdldC5oIgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK2NsYXNzIEhU TUxEaWFsb2dFbGVtZW50OworCitjbGFzcyBSZW5kZXJEaWFsb2cgOiBwdWJsaWMgUmVuZGVyQmxv Y2sgeworcHVibGljOgorICAgIGV4cGxpY2l0IFJlbmRlckRpYWxvZyhOb2RlKiBub2RlKQorICAg ICAgICA6IFJlbmRlckJsb2NrKG5vZGUpCisgICAgeyB9CisKKyAgICB2aXJ0dWFsIH5SZW5kZXJE aWFsb2coKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgbGF5b3V0KCkgT1ZFUlJJREU7CisKK3ByaXZh dGU6CisgICAgdmlydHVhbCBjb25zdCBjaGFyKiByZW5kZXJOYW1lKCkgY29uc3QgeyByZXR1cm4g IlJlbmRlckRpYWxvZyI7IH0KKyAgICB2aXJ0dWFsIGJvb2wgaXNEaWFsb2coKSBjb25zdCBPVkVS UklERSB7IHJldHVybiB0cnVlOyB9Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNl bmRpZgorCisjZW5kaWYgLy8gUmVuZGVyRGlhbG9nX2gKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJPYmplY3QuaAppbmRleCAyMmI4MzAwYmEzNDVjMGY1YjU0MTcyNDdhNTZkODA2YTBmYzhh OWVkLi45ZTk5NTU0ZDk2ZjYxYWJlZWNiYzJhNzU5ZWMwMGY5MDMwOWQwMzAwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKKysrIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCkBAIC0zMTEsNiArMzExLDkgQEAgcHVibGlj OgogICAgIHZpcnR1YWwgYm9vbCBpc0Jsb2NrRmxvdygpIGNvbnN0IHsgcmV0dXJuIGZhbHNlOyB9 CiAgICAgdmlydHVhbCBib29sIGlzQm94TW9kZWxPYmplY3QoKSBjb25zdCB7IHJldHVybiBmYWxz ZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc0NvdW50ZXIoKSBjb25zdCB7IHJldHVybiBmYWxzZTsg fQorI2lmIEVOQUJMRShESUFMT0dfRUxFTUVOVCkKKyAgICB2aXJ0dWFsIGJvb2wgaXNEaWFsb2co KSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQorI2VuZGlmCiAgICAgdmlydHVhbCBib29sIGlzUXVv dGUoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogCiAjaWYgRU5BQkxFKERFVEFJTFNfRUxFTUVO VCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJpbmdBbGxJbk9u ZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyaW5nQWxsSW5PbmUuY3BwCmlu ZGV4IDFmMGE0YTM4ZTcyZTIxYTdkYzNmMGFkY2QzY2FlMzYzYzhhNTFkOTIuLjAzYmRkM2Y4Yjk1 ZGViZWY5NjgzNjM0OTFjYzBkM2QxYjQyMDRiZmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJpbmdBbGxJbk9uZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlcmluZ0FsbEluT25lLmNwcApAQCAtNTEsNiArNTEsNyBAQAogI2luY2x1ZGUg IlJlbmRlckNvdW50ZXIuY3BwIgogI2luY2x1ZGUgIlJlbmRlckRlcHJlY2F0ZWRGbGV4aWJsZUJv eC5jcHAiCiAjaW5jbHVkZSAiUmVuZGVyRGV0YWlsc01hcmtlci5jcHAiCisjaW5jbHVkZSAiUmVu ZGVyRGlhbG9nLmNwcCIKICNpbmNsdWRlICJSZW5kZXJFbWJlZGRlZE9iamVjdC5jcHAiCiAjaW5j bHVkZSAiUmVuZGVyRmllbGRzZXQuY3BwIgogI2luY2x1ZGUgIlJlbmRlckZpbGVVcGxvYWRDb250 cm9sLmNwcCIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwppbmRleCBiZDQyNTc0MzczMjg5MjNmNjRjNjAzZDlkYWQyYTE2MThmZjcyOGU0 Li4xMjFmNDZlMmYyMWUyMjliYjI4NTY2ZTg3ZGJhMjg0NzhiMWRiZWNjIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTMgQEAKKzIwMTItMDktMDUgIE1hdHQgRmFsa2VuaGFnZW4gIDxmYWxrZW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFZlcnRpY2FsbHkgY2VudGVyIG5vbi1hbmNob3JlZCA8ZGlhbG9nPiBl bGVtZW50cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 OTA2NzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IGZhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25p bmctZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2RvbS9IVE1MRGlhbG9nRWxl bWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLmh0bWw6IEFkZGVkLgorCiAyMDEy LTA5LTA1ICBab2x0YW4gQXJ2YWkgIDx6YXJ2YWlAaW5mLnUtc3plZ2VkLmh1PgogCiAgICAgICAg IFtRdF0gVW5yZXZpZXdlZCBnYXJkZW5pbmcuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0 L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9nLXBvc2l0aW9uaW5nLWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1h bmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmctZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmYwOTU1 YzE3MGM0YWUzNGMyYWFlNjllZTQ0ZWU5ZTM1MzVmZWQwMWMKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2RvbS9IVE1MRGlhbG9nRWxlbWVudC9ub24tYW5jaG9yZWQtZGlhbG9n LXBvc2l0aW9uaW5nLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDIwIEBACitUZXN0cyBkZWZhdWx0 IHBvc2l0aW9uaW5nIG9mIG5vbi1hbmNob3JlZCBkaWFsb2dzLgorCitPbiBzdWNjZXNzLCB5b3Ug d2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBD T01QTEVURSIuCisKKworUEFTUyBkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wIGlz IGV4cGVjdGVkVG9wCitQQVNTIGRpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50b3AgaXMg ZXhwZWN0ZWRUb3AKK1BBU1MgZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcCBpcyAw CitQQVNTIGRpYWxvZy5nZXRCb3VuZGluZ0NsaWVudFJlY3QoKS50b3AgaXMgZXhwZWN0ZWRUb3AK K1BBU1MgZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLnRvcCBpcyBleHBlY3RlZFRvcAor UEFTUyBkaWFsb2cuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wIGlzIGV4cGVjdGVkVG9wCitQ QVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMgcGxhaW5EaXYub2Zmc2V0VG9wCitQQVNTIGRpYWxvZy5v ZmZzZXRCb3R0b20gaXMgcGxhaW5EaXYub2Zmc2V0Qm90dG9tCitQQVNTIGRpYWxvZy5vZmZzZXRU b3AgaXMgcGxhaW5EaXYub2Zmc2V0VG9wCitQQVNTIGRpYWxvZy5vZmZzZXRUb3AgaXMgZXhwZWN0 ZWRUb3AKK1BBU1MgZGlhbG9nLm9mZnNldFRvcCBpcyBleHBlY3RlZFRvcAorUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25vbi1hbmNob3JlZC1kaWFsb2ctcG9z aXRpb25pbmcuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZG9tL0hUTUxEaWFsb2dFbGVtZW50L25v bi1hbmNob3JlZC1kaWFsb2ctcG9zaXRpb25pbmcuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45MDMxNjQxYzU1 YTNmOTAwZTgyMmNmYzc5OGY2NWViOTI3YjczNDQ5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC9kb20vSFRNTERpYWxvZ0VsZW1lbnQvbm9uLWFuY2hvcmVkLWRpYWxvZy1wb3Np dGlvbmluZy5odG1sCkBAIC0wLDAgKzEsMTQxIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGhlYWQ+Cis8c3R5bGU+CisuZmlsbGVyIHsKKyAgICBoZWlnaHQ6IDIwMDAwcHg7Cit9Cis8L3N0 eWxlPgorPHNjcmlwdCBzcmM9Ii4uLy4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9z Y3JpcHQ+Cis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpCisgICAgaW50ZXJuYWxzLnNl dHRpbmdzLnNldERpYWxvZ0VsZW1lbnRFbmFibGVkKHRydWUpOworCitmdW5jdGlvbiBjaGVja1Rv cE9mVmlld3BvcnQoZGlhbG9nKSB7CisgICAgc2hvdWxkQmUoJ2RpYWxvZy5nZXRCb3VuZGluZ0Ns aWVudFJlY3QoKS50b3AnLCAnMCcpOworfQorCitmdW5jdGlvbiBjaGVja0NlbnRlcmVkKGRpYWxv ZykgeworICAgIGV4cGVjdGVkVG9wID0gKHdpbmRvdy5pbm5lckhlaWdodCAtIGRpYWxvZy5vZmZz ZXRIZWlnaHQpIC8gMjsKKyAgICBzaG91bGRCZSgnZGlhbG9nLmdldEJvdW5kaW5nQ2xpZW50UmVj dCgpLnRvcCcsICdleHBlY3RlZFRvcCcpOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4K KyAgICA8ZGlhbG9nIGlkPSJteWRpYWxvZyI+SXQgaXMgbXkgZGlhbG9nLjwvZGlhbG9nPgorICAg IDxkaXYgY2xhc3M9ImZpbGxlciIgaWQ9ImZpbGxlckRpdiI+PC9kaXY+Cis8L2JvZHk+Cis8c2Ny aXB0PgorZGVzY3JpcHRpb24oIlRlc3RzIGRlZmF1bHQgcG9zaXRpb25pbmcgb2Ygbm9uLWFuY2hv cmVkIGRpYWxvZ3MuIik7CisKK2RpYWxvZyA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdteWRp YWxvZycpOworCisvLyBEaWFsb2cgc2hvdWxkIGJlIGNlbnRlcmVkIGluIHRoZSB2aWV3cG9ydC4K K2RpYWxvZy5zaG93KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsK KworLy8gRGlhbG9nIHNob3VsZCBzdGlsbCBiZSBjZW50ZXJlZCBpZiBzaG93biBhZnRlciB3aW5k b3cgaXMgc2Nyb2xsZWQuCit3aW5kb3cuc2Nyb2xsKDAsIDUwMCk7CitkaWFsb2cuc2hvdygpOwor Y2hlY2tDZW50ZXJlZChkaWFsb2cpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIEEgdGFsbCBkaWFs b2cgc2hvdWxkIGJlIHBvc2l0aW9uZWQgYXQgdGhlIHRvcCBvZiB0aGUgdmlld3BvcnQuCit2YXIg ZGlhbG9nSW5uZXIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKK2RpYWxvZ0lubmVy LmNsYXNzTmFtZSA9ICdmaWxsZXInOworZGlhbG9nLmFwcGVuZENoaWxkKGRpYWxvZ0lubmVyKTsK K2RpYWxvZy5zaG93KCk7CitjaGVja1RvcE9mVmlld3BvcnQoZGlhbG9nKTsKK2RpYWxvZy5jbG9z ZSgpOworZGlhbG9nLnJlbW92ZUNoaWxkKGRpYWxvZ0lubmVyKTsKKworLy8gQWRkIHRoZSBob3Jp em9udGFsIHNjcm9sbGJhci4gVGhlIGRpYWxvZyBzaG91bGQgYmUgY2VudGVyZWQgcmVnYXJkbGVz cyBvZiB0aGUgcHJlc2VuY2Ugb2Ygc2Nyb2xsYmFycy4KK3ZhciBmaWxsZXJEaXYgPSBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgnZmlsbGVyRGl2Jyk7CitmaWxsZXJEaXYuc3R5bGUud2lkdGggPSAn NDAwMHB4JzsKK2RpYWxvZy5zaG93KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cu Y2xvc2UoKTsKK2ZpbGxlckRpdi5zdHlsZS53aWR0aCA9ICdhdXRvJzsKKworLy8gVGVzdCB0aGF0 IGNlbnRlcmluZyB3b3JrcyB3aGVuIGRpYWxvZyBpcyBpbnNpZGUgcG9zaXRpb25lZCBjb250YWlu ZXJzLgordmFyIGNvbnRhaW5lciA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29u dGFpbmVyLnN0eWxlLnBvc2l0aW9uID0gJ2Fic29sdXRlJzsKK2NvbnRhaW5lci5zdHlsZS50b3Ag PSAnODAwcHg7JworY29udGFpbmVyLnN0eWxlLmhlaWdodD0gJzUwcHg7JworY29udGFpbmVyLnN0 eWxlLndpZHRoID0gJzkwJSc7CitkaWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChkaWFsb2cp OworZG9jdW1lbnQuYm9keS5hcHBlbmRDaGlsZChjb250YWluZXIpOworY29udGFpbmVyLmFwcGVu ZENoaWxkKGRpYWxvZyk7CitkaWFsb2cuc2hvdygpOworY2hlY2tDZW50ZXJlZChkaWFsb2cpOwor ZGlhbG9nLmNsb3NlKCk7Citjb250YWluZXIucmVtb3ZlQ2hpbGQoZGlhbG9nKTsKKwordmFyIGNv bnRhaW5lcjIgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdkaXYnKTsKKy8vIEZJWE1FOiBUaGlz IHRlc3QgZmFpbHMgZm9yIHBvc2l0aW9uID0gJ3JlbGF0aXZlJy4KK2NvbnRhaW5lcjIuc3R5bGUu cG9zaXRpb24gPSAnYWJzb2x1dGUnOworY29udGFpbmVyMi5zdHlsZS50b3AgPSAnMjBweCc7Citj b250YWluZXIyLnN0eWxlLmhlaWdodCA9ICczMHB4JzsKK2NvbnRhaW5lci5hcHBlbmRDaGlsZChj b250YWluZXIyKTsKK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQoZGlhbG9nKTsKK2RpYWxvZy5zaG93 KCk7CitjaGVja0NlbnRlcmVkKGRpYWxvZyk7CitkaWFsb2cuY2xvc2UoKTsKKworLy8gVGVzdCB0 aGF0IHNldHRpbmcgdG9wIG1hbnVhbGx5IGlzIHRoZSBzYW1lIGFzIGZvciBhIHBsYWluIGRpdi4K K3ZhciBwbGFpbkRpdiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpOworY29udGFpbmVy Mi5hcHBlbmRDaGlsZChwbGFpbkRpdik7CitwbGFpbkRpdi5zdHlsZS5wb3NpdGlvbiA9ICdhYnNv bHV0ZSc7CitwbGFpbkRpdi5zdHlsZS50b3AgPSAnNTBweCc7CitkaWFsb2cuc3R5bGUudG9wID0g JzUwcHgnOworZGlhbG9nLnNob3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ3Bs YWluRGl2Lm9mZnNldFRvcCcpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBzZXR0 aW5nIGJvdHRvbSBtYW51YWxseSBpcyB0aGUgc2FtZSBhcyBmb3IgYSBwbGFpbiBkaXYuCitkaWFs b2cuc3R5bGUudG9wID0gJ2F1dG8nOworcGxhaW5EaXYuc3R5bGUudG9wID0gJ2F1dG8nOworZGlh bG9nLnN0eWxlLmJvdHRvbSA9ICc1MHB4JzsKK3BsYWluRGl2LnN0eWxlLmJvdHRvbSA9ICc1MHB4 JzsKK2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldEJvdHRvbScsICdwbGFp bkRpdi5vZmZzZXRCb3R0b20nKTsKK2RpYWxvZy5jbG9zZSgpOworCisvLyBUZXN0IHRoYXQgZml4 ZWQgcG9zaXRpb24gaGFzIHRoZSB1c3VhbCBiZWhhdmlvci4KK3BsYWluRGl2LnN0eWxlLnBvc2l0 aW9uID0gJ2ZpeGVkJzsKK3BsYWluRGl2LnN0eWxlLnRvcCA9ICc1MHB4JzsKK2RpYWxvZy5zdHls ZS5wb3NpdGlvbiA9ICdmaXhlZCc7CitkaWFsb2cuc3R5bGUudG9wID0gJzUwcHgnOworZGlhbG9n LnNob3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ3BsYWluRGl2Lm9mZnNldFRv cCcpOworZGlhbG9nLmNsb3NlKCk7CisKKy8vIFRlc3QgdGhhdCBzdGF0aWMgcG9zaXRpb24gaGFz IHRoZSB1c3VhbCBiZWhhdmlvci4KK3BsYWluRGl2LnN0eWxlLnBvc2l0aW9uID0gJ3N0YXRpYyc7 CitwbGFpbkRpdi5zdHlsZS50b3AgPSAnYXV0byc7Cit2YXIgZXhwZWN0ZWRUb3AgPSBwbGFpbkRp di5vZmZzZXRUb3A7CitwbGFpbkRpdi5wYXJlbnROb2RlLnJlbW92ZUNoaWxkKHBsYWluRGl2KTsK K2RpYWxvZy5zdHlsZS5wb3NpdGlvbiA9ICdzdGF0aWMnOworZGlhbG9nLnN0eWxlLnRvcCA9ICdh dXRvJzsKK2RpYWxvZy5zaG93KCk7CitzaG91bGRCZSgnZGlhbG9nLm9mZnNldFRvcCcsICdleHBl Y3RlZFRvcCcpOworZGlhbG9nLmNsb3NlKCk7CitkaWFsb2cucGFyZW50Tm9kZS5yZW1vdmVDaGls ZChkaWFsb2cpOworCisvLyBUZXN0IHRoYXQgcmVsYXRpdmUgcG9zaXRpb24gaGFzIHRoZSB1c3Vh bCBiZWhhdmlvci4KK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQocGxhaW5EaXYpOworcGxhaW5EaXYu c3R5bGUucG9zaXRpb24gPSAncmVsYXRpdmUnOworcGxhaW5EaXYuc3R5bGUudG9wID0gJzUwcHgn OworZXhwZWN0ZWRUb3AgPSBwbGFpbkRpdi5vZmZzZXRUb3A7CitwbGFpbkRpdi5wYXJlbnROb2Rl LnJlbW92ZUNoaWxkKHBsYWluRGl2KTsKK2NvbnRhaW5lcjIuYXBwZW5kQ2hpbGQoZGlhbG9nKTsK K2RpYWxvZy5zdHlsZS5wb3NpdGlvbiA9ICdyZWxhdGl2ZSc7CitkaWFsb2cuc3R5bGUudG9wID0g JzUwcHgnOworZGlhbG9nLnNob3coKTsKK3Nob3VsZEJlKCdkaWFsb2cub2Zmc2V0VG9wJywgJ2V4 cGVjdGVkVG9wJyk7CitkaWFsb2cuY2xvc2UoKTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4u Ly4uL2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9o dG1sPgo=