84936 2012-04-26 01:53:12 -0700 [chromium] Compute highlight for touch targets 2012-10-05 14:11:25 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED WORKSFORME P2 Normal --- 84487 85725 66687 79150 91648 0 trchen webkit-unassigned abarth aelias allan.jensen anilsson dglazkov enne eric gustavo jamesr jchaffraix kenneth klobag peter philn rjkroege tdanderson tonikitoo trchen webkit.review.bot wjmaclean xan.lopez zalan oldest_to_newest 610429 0 trchen 2012-04-26 01:53:12 -0700 [chromium] Compute highlight for touch targets 610431 1 138954 trchen 2012-04-26 01:54:36 -0700 Created attachment 138954 Patch 610434 2 138956 trchen 2012-04-26 01:56:32 -0700 Created attachment 138956 A few basic test cases 610443 3 trchen 2012-04-26 02:22:37 -0700 I couldn't find chromium account for the others, could you help me CC them? This is an early WIP. I did open some pages and hover over some links to make sure it doesn't crash, but the actual generated paths are not verified. I believe there are still some bugs need to be fixed before requesting for review. Also there are still some design concerns: 1. When do we generate the highlight, and how do we attach them to the GraphicsLayer? The best timing is probably do it when painting the texture, but is it safe to keep a WebCore::Node* reference to the touch target? The node can be removed by javascript in the meantime. 2. How do we remove the highlight from the GraphicsLayer? 3. We probably want to refactor RenderInline::absoluteQuads. I added another virtual function RenderObject::containerQuads that works similar to absoluteQuads except that it return the quads in a container RenderBoxModelObject's cords instead of the absolute cords. For RenderInline it is generating too much duplicate code. Better make RenderObject::absoluteQuads non-virtual and just call into containerQuads with NULL container. 4. Need to make the function more efficient. It probably doesn't need to generate quads all descendant nodes... For example if there is a <div style="overflow:hidden"> then all its descendants can be skipped (except for fixed/absolute positioned descendant). I'm still thinking a clean way to do this. 5. absoluteQuads is probably not the perfect way to determine hit test region. There is an interesting example. See the first and second touch target in the attached example. The space between "Hello" and "link" is still occupied by the line box of the relative-positioned <div>, but it is only clickable when applied with a background color. Can't figure out how to do this right. :( By the way there is an interesting bug in WebKit rendering. See the 4th touch target in the example. If you click on it, the blue box can escape from its parent's clipping. 610662 4 wjmaclean 2012-04-26 08:58:23 -0700 (In reply to comment #3) > I couldn't find chromium account for the others, could you help me CC them? > > This is an early WIP. I did open some pages and hover over some links to make sure it doesn't crash, but the actual generated paths are not verified. I believe there are still some bugs need to be fixed before requesting for review. > > Also there are still some design concerns: > > 1. When do we generate the highlight, and how do we attach them to the GraphicsLayer? > The best timing is probably do it when painting the texture, but is it safe to keep a WebCore::Node* reference to the touch target? The node can be removed by javascript in the meantime. This is being worked out in https://bugs.webkit.org/show_bug.cgi?id=84487 > 2. How do we remove the highlight from the GraphicsLayer? Ditto. > 3. We probably want to refactor RenderInline::absoluteQuads. > I added another virtual function RenderObject::containerQuads that works similar to absoluteQuads except that it return the quads in a container RenderBoxModelObject's cords instead of the absolute cords. For RenderInline it is generating too much duplicate code. Better make RenderObject::absoluteQuads non-virtual and just call into containerQuads with NULL container. > > 4. Need to make the function more efficient. > It probably doesn't need to generate quads all descendant nodes... For example if there is a <div style="overflow:hidden"> then all its descendants can be skipped (except for fixed/absolute positioned descendant). I'm still thinking a clean way to do this. > > 5. absoluteQuads is probably not the perfect way to determine hit test region. There is an interesting example. See the first and second touch target in the attached example. The space between "Hello" and "link" is still occupied by the line box of the relative-positioned <div>, but it is only clickable when applied with a background color. Can't figure out how to do this right. :( > > By the way there is an interesting bug in WebKit rendering. See the 4th touch target in the example. If you click on it, the blue box can escape from its parent's clipping. 610817 5 webkit.review.bot 2012-04-26 12:28:50 -0700 Attachment 138954 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebCore/ChangeLog:10: You should remove the 'No new tests' and either add and list tests, or explain why no new tests were possible. [changelog/nonewtests] [5] Total errors found: 1 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 610843 6 138954 buildbot 2012-04-26 12:47:27 -0700 Comment on attachment 138954 Patch Attachment 138954 did not pass win-ews (win): Output: http://queues.webkit.org/results/12547008 611174 7 138954 webkit.review.bot 2012-04-26 19:02:56 -0700 Comment on attachment 138954 Patch Attachment 138954 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/12548064 611728 8 138954 wjmaclean 2012-04-27 11:33:42 -0700 Comment on attachment 138954 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=138954&action=review Overall the code seems to provide good targets, and does a good job generating the outline paths. Let's keep at this! > Source/WebKit/chromium/src/WebViewImpl.cpp:3561 > + SkPath* path = highlight->get(graphicsLayer); I would prefer if we can use Path here, as it's more general and is used by the proposed patch for drawing the highlight layers. > Source/WebKit/chromium/src/WebViewImpl.cpp:3586 > + path->moveTo(quad.p1().x(), quad.p1().y()); Can use Path::addRect(const FloatRect&) here, it's simpler. Can we add an option to call Path::addRoundedRect(), perhaps as an argument to this function? > Source/WebKit/chromium/src/WebViewImpl.h:590 > + typedef HashMap<WebCore::GraphicsLayer*, OwnPtr<SkPath> > HighlightMap; Any reason we can't store RefPtr<GraphicsLayer> instead? This way the timer that controls the highlight animation (and which is the ultimate consumer of this data), doesn't have to worry about pointers going stale before the data is used. 611840 9 trchen 2012-04-27 13:28:08 -0700 (In reply to comment #8) > (From update of attachment 138954 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=138954&action=review > > Overall the code seems to provide good targets, and does a good job generating the outline paths. Let's keep at this! I saw your patch that uses GestureTapHighlighter, that is actually a very interesting piece of code. I think we'd rather try to extend it instead of invent our own stuff. Be more specific these are the 2 functionality we want to add: 1. To support transformed elements, using the Quads family functions. IMO all the Rects family should be deprecated sooner or later... 2. Support compositor side scrolling/animation. That is, the highlights should be assigned to individual GraphicsLayers with layer-relative cords. Example: <a href=""> <div style="width:100px;height:100px"/> <div style="width:100px;height:100px;-webkit-transform:translateZ(0);-webkit-animation-name:someanimation"/> </a> > > Source/WebKit/chromium/src/WebViewImpl.cpp:3561 > > + SkPath* path = highlight->get(graphicsLayer); > > I would prefer if we can use Path here, as it's more general and is used by the proposed patch for drawing the highlight layers. Sure I will upload a new patch uses WebCore::Path. > > Source/WebKit/chromium/src/WebViewImpl.cpp:3586 > > + path->moveTo(quad.p1().x(), quad.p1().y()); > > Can use Path::addRect(const FloatRect&) here, it's simpler. Can we add an option to call Path::addRoundedRect(), perhaps as an argument to this function? It won't work for transformed touch target. For example: <div style="width:100px;height:100px;-webkit-transform:rotated(30deg)"></div> Only 3D-transformed render objects will create its own GraphicsLayer. > > Source/WebKit/chromium/src/WebViewImpl.h:590 > > + typedef HashMap<WebCore::GraphicsLayer*, OwnPtr<SkPath> > HighlightMap; > > Any reason we can't store RefPtr<GraphicsLayer> instead? This way the timer that controls the highlight animation (and which is the ultimate consumer of this data), doesn't have to worry about pointers going stale before the data is used. I wanted to, but GraphicsLayer is not ref-counted, and modifying all existing code to use RefPtr will be a pain. :X 612672 10 wjmaclean 2012-04-30 08:53:53 -0700 (In reply to comment #9) > (In reply to comment #8) > > (From update of attachment 138954 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=138954&action=review > > > > Overall the code seems to provide good targets, and does a good job generating the outline paths. Let's keep at this! > > I saw your patch that uses GestureTapHighlighter, that is actually a very interesting piece of code. I think we'd rather try to extend it instead of invent our own stuff. That patch has changed a lot. First, using the existing code gave very poor targets in my opinion. Your code worked quite nicely for me though. I may try again with the touch highlight region from my patch, and your node selector. > Be more specific these are the 2 functionality we want to add: > > 1. To support transformed elements, using the Quads family functions. IMO all the Rects family should be deprecated sooner or later... > 2. Support compositor side scrolling/animation. That is, the highlights should be assigned to individual GraphicsLayers with layer-relative cords. Example: > <a href=""> > <div style="width:100px;height:100px"/> > <div style="width:100px;height:100px;-webkit-transform:translateZ(0);-webkit-animation-name:someanimation"/> > </a> > > > > Source/WebKit/chromium/src/WebViewImpl.cpp:3561 > > > + SkPath* path = highlight->get(graphicsLayer); > > > > I would prefer if we can use Path here, as it's more general and is used by the proposed patch for drawing the highlight layers. > > Sure I will upload a new patch uses WebCore::Path. Great, thanks! > > > Source/WebKit/chromium/src/WebViewImpl.cpp:3586 > > > + path->moveTo(quad.p1().x(), quad.p1().y()); > > > > Can use Path::addRect(const FloatRect&) here, it's simpler. Can we add an option to call Path::addRoundedRect(), perhaps as an argument to this function? > > It won't work for transformed touch target. For example: <div style="width:100px;height:100px;-webkit-transform:rotated(30deg)"></div> > Only 3D-transformed render objects will create its own GraphicsLayer. > > > > Source/WebKit/chromium/src/WebViewImpl.h:590 > > > + typedef HashMap<WebCore::GraphicsLayer*, OwnPtr<SkPath> > HighlightMap; > > > > Any reason we can't store RefPtr<GraphicsLayer> instead? This way the timer that controls the highlight animation (and which is the ultimate consumer of this data), doesn't have to worry about pointers going stale before the data is used. > > I wanted to, but GraphicsLayer is not ref-counted, and modifying all existing code to use RefPtr will be a pain. :X OK, so we need to figure out how to work around this then. Is there anything that points to the graphics layer that is ref-counted, that we could store instead? 613323 11 139605 trchen 2012-05-01 03:31:41 -0700 Created attachment 139605 Patch 613325 12 webkit.review.bot 2012-05-01 03:35:44 -0700 Attachment 139605 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebKit/chromium/ChangeLog:9: Line contains tab character. [whitespace/tab] [5] Source/WebCore/ChangeLog:8: Line contains tab character. [whitespace/tab] [5] Total errors found: 2 in 12 files If any of these errors are false positives, please file a bug against check-webkit-style. 613328 13 139605 buildbot 2012-05-01 03:40:27 -0700 Comment on attachment 139605 Patch Attachment 139605 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/12593519 613330 14 trchen 2012-05-01 03:44:36 -0700 I won't be in the office until Friday. I will try to keep in touch by email but I won't have too much time to work on code. I changed the patch a little bit to make the highlight generation code a separate class. It is very likely I will have to improve the implementation later, but the interface will stay the same. (In reply to comment #10) > (In reply to comment #9) > > (In reply to comment #8) > > > (From update of attachment 138954 [details] [details] [details]) > > > View in context: https://bugs.webkit.org/attachment.cgi?id=138954&action=review > > > > > > Overall the code seems to provide good targets, and does a good job generating the outline paths. Let's keep at this! > > > > I saw your patch that uses GestureTapHighlighter, that is actually a very interesting piece of code. I think we'd rather try to extend it instead of invent our own stuff. > > That patch has changed a lot. First, using the existing code gave very poor targets in my opinion. Your code worked quite nicely for me though. I may try again with the touch highlight region from my patch, and your node selector. The node selector from my patch is very minimal. We have some disambiguation logic in downstream code that I don't 100% understand yet. I'll try to upstream those incrementally in later patches. As for the highlight region, I think addFocusRingRects is actually very similar to our implementation, except that it uses absolute rects (thus can behave very wrong when transformation is used). > > > > Source/WebKit/chromium/src/WebViewImpl.h:590 > > > > + typedef HashMap<WebCore::GraphicsLayer*, OwnPtr<SkPath> > HighlightMap; > > > > > > Any reason we can't store RefPtr<GraphicsLayer> instead? This way the timer that controls the highlight animation (and which is the ultimate consumer of this data), doesn't have to worry about pointers going stale before the data is used. > > > > I wanted to, but GraphicsLayer is not ref-counted, and modifying all existing code to use RefPtr will be a pain. :X > > OK, so we need to figure out how to work around this then. Is there anything that points to the graphics layer that is ref-counted, that we could store instead? I don't think anything in the render tree is ref-counted. LayerChromium is ref-counted but it doesn't back-reference to GraphicsLayer. One possibility is to do everything on LayerChromium. That is what I did with the compositor scrollbar layers. 613333 15 139605 webkit.review.bot 2012-05-01 03:54:14 -0700 Comment on attachment 139605 Patch Attachment 139605 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/12591519 618272 16 140662 trchen 2012-05-07 21:06:50 -0700 Created attachment 140662 Patch 618284 17 140662 buildbot 2012-05-07 21:28:52 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass win-ews (win): Output: http://queues.webkit.org/results/12650253 618285 18 140662 webkit.review.bot 2012-05-07 21:29:00 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/12651249 618286 19 140662 webkit-ews 2012-05-07 21:29:25 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass qt-wk2-ews (qt): Output: http://queues.webkit.org/results/12652264 618287 20 140662 webkit-ews 2012-05-07 21:33:40 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/12656212 618290 21 140662 buildbot 2012-05-07 21:34:55 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/12645278 618338 22 140662 gyuyoung.kim 2012-05-07 23:10:20 -0700 Comment on attachment 140662 Patch Attachment 140662 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/12654215 621105 23 140662 tomz 2012-05-10 16:32:51 -0700 Comment on attachment 140662 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=140662&action=review > Source/WebCore/rendering/RenderInline.cpp:1495 > + generateLineBoxRects(RepaintContainerHighlightQuadsGeneratorContext(this, quads, repaintContainer)); generateLineBoxRects isn't defined anywhere. Breaks all builds. 621128 24 trchen 2012-05-10 16:54:55 -0700 (In reply to comment #23) > (From update of attachment 140662 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=140662&action=review > > > Source/WebCore/rendering/RenderInline.cpp:1495 > > + generateLineBoxRects(RepaintContainerHighlightQuadsGeneratorContext(this, quads, repaintContainer)); > > generateLineBoxRects isn't defined anywhere. Breaks all builds. Yes, waiting for 85725 to land 621214 25 141314 trchen 2012-05-10 19:39:52 -0700 Created attachment 141314 Patch 621216 26 trchen 2012-05-10 19:42:40 -0700 Nothing changed. Just rebase to the latest version. 621229 27 141314 buildbot 2012-05-10 20:30:33 -0700 Comment on attachment 141314 Patch Attachment 141314 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/12677073 621933 28 141485 trchen 2012-05-11 13:32:54 -0700 Created attachment 141485 Patch 629904 29 143183 trchen 2012-05-21 20:44:53 -0700 Created attachment 143183 Patch 629908 30 trchen 2012-05-21 20:48:11 -0700 This new version is based on the recent version of https://bugs.webkit.org/show_bug.cgi?id=84487 (https://bugs.webkit.org/attachment.cgi?id=142729) Provides much more accurate highlight for many test cases. 629909 31 143184 trchen 2012-05-21 20:48:57 -0700 Created attachment 143184 some additional test cases 629993 32 abarth 2012-05-21 23:48:42 -0700 @trchen: I'm hoping Eric or jchaffraix will review your patch. 630686 33 143183 jchaffraix 2012-05-22 13:14:18 -0700 Comment on attachment 143183 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=143183&action=review I will only comment on the general bits in the rendering which are clunky. Added the compositor people to look at what are the implication for the compositor's and what you need to do. > Source/WebCore/ChangeLog:14 > + One important difference from RenderObject::absoluteQuads is that > + the returned quads will be in the coordinates of a repaint container > + specified by the caller. This will allow threaded-scrolling/animation > + without having to regenerate the highlights. What happens if your repaintContainer change? (layer removed or added for example or promotion / demotion from being hardware accelerated) > Source/WebCore/ChangeLog:17 > + No new tests. Tests will be added with later patches that actually > + add highlight to layers. You are exposing the new function to Chromium. Will it be tested there? What do you mean by layers: RenderLayers or GraphicsLayers? > Source/WebCore/rendering/RenderBlock.h:450 > + virtual void repaintContainerHighlightQuads(Vector<FloatQuad>&, RenderBoxModelObject* repaintContainer) const; Not a huge fan of this function name: I thought it was a repaint* function (which obviously it's not). How about collectHighlightQuadsForContainer(...) or something similar? > Source/WebCore/rendering/RenderBox.cpp:596 > + if (!size().isEmpty()) This should be an early return. I also find this check inconsistent with the rest of the code (you would not check the other classes for empty quads?) > Source/WebCore/rendering/RenderBox.cpp:597 > + quads.append(localToContainerQuad(FloatRect(0, 0, width(), height()), repaintContainer, false, 0)); You don't need the 2 last parameters here. They make the code less readable and more confusing as you wonder why you need them here. Same comment later at the other call sites. > Source/WebCore/rendering/RenderBox.h:155 > + virtual void repaintContainerHighlightQuads(Vector<FloatQuad>&, RenderBoxModelObject* repaintContainer) const; We annotate those functions with OVERRIDE (not repeated). > Source/WebCore/rendering/RenderInline.cpp:1465 > + This is inconsistent: you don't call your parent class' method here. > Source/WebCore/rendering/RenderInline.cpp:1467 > + if (continuation()) > + continuation()->repaintContainerHighlightQuads(quads, repaintContainer); continuation is RenderBoxModelObject concept which makes me dubious of the duplication between RenderInline and RenderBlock: there should be a RenderBoxModelObject function that handles the continuation for you. > Source/WebKit/chromium/src/WebHighlight.cpp:54 > + for (Node *node = topNode; node; node = node->traverseNextNode(topNode)) { Style violation > Source/WebKit/chromium/src/WebHighlight.cpp:57 > + if (!renderer) > + continue; My question here: have you considered SVG? Do you want to support it or not? If you don't care about SVG, you don't care about anything that is not a RenderBoxModelObject anyway. That would simplify the code above. > Source/WebKit/chromium/src/WebHighlight.cpp:59 > + RenderLayer* repaintLayer = renderer->enclosingLayer()->enclosingCompositingLayerForRepaint(); NO! Using RenderLayer in the WebKit/ directory is a show-stopper. It means you need access to something you shouldn't be knowing about. RenderBoxModelObject* repaintContainer = renderer->containerForRepaint(); Will give you the renderer you need. If you need more of the hidden bits, it looks like you should rethink your architecture. > Source/WebKit/chromium/src/WebHighlight.cpp:65 > + GraphicsLayer* graphicsLayer = repaintLayer->backing()->graphicsLayer(); What proofs do you have that this RenderLayer is hardware accelerated? If it is not, this is a NULL crasher. > Source/WebKit/chromium/src/WebHighlight.cpp:68 > + Path* path = m_quadMap.get(graphicsLayer); > + if (!path) > + m_quadMap.set(graphicsLayer, adoptPtr(path = new Path())); This is super confusing and inefficient as you are doing 2 hash lookups if you have no entry: Path* path = m_quadMap.add(graphicsLayer, adoptPtr(new Path())).iterator->second; > Source/WebKit/chromium/src/WebHighlight.cpp:73 > + for (size_t i = 0; i < newquads.size(); i++) { I don't understand the purpose of this. If you need a Path can't you get one from WebCore directly instead of this hocus pocus code? 630765 34 trchen 2012-05-22 14:27:18 -0700 (In reply to comment #33) > (From update of attachment 143183 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=143183&action=review > > I will only comment on the general bits in the rendering which are clunky. Added the compositor people to look at what are the implication for the compositor's and what you need to do. Thanks for the valuable comments! > > Source/WebCore/ChangeLog:14 > > + One important difference from RenderObject::absoluteQuads is that > > + the returned quads will be in the coordinates of a repaint container > > + specified by the caller. This will allow threaded-scrolling/animation > > + without having to regenerate the highlights. > > What happens if your repaintContainer change? (layer removed or added for example or promotion / demotion from being hardware accelerated) Yes that would be a problem. The current implementation generates the highlight at the time a tap gesture happened, then it stays the same no matter the nodes are moved / transformed / zapped / whatever. Ideally we should store a reference to the node, then regenerate the highlight on every compositor commit. I doubt if it'd be an overkill though. > > Source/WebCore/ChangeLog:17 > > + No new tests. Tests will be added with later patches that actually > > + add highlight to layers. > > You are exposing the new function to Chromium. Will it be tested there? > > What do you mean by layers: RenderLayers or GraphicsLayers? Sorry the comment no longer applies. I'll add tests in revised patch. > > Source/WebCore/rendering/RenderBlock.h:450 > > + virtual void repaintContainerHighlightQuads(Vector<FloatQuad>&, RenderBoxModelObject* repaintContainer) const; > > Not a huge fan of this function name: I thought it was a repaint* function (which obviously it's not). How about collectHighlightQuadsForContainer(...) or something similar? Totally agree... Another thing aelias@ is suggesting that what the function actually does is to mimic the hit-test area, and later we might use it to generate the non-fast touch events region for threaded input event handling. So maybe collectHittestQuadsForContainer would be a better name? > > Source/WebCore/rendering/RenderBox.cpp:596 > > + if (!size().isEmpty()) > > This should be an early return. I also find this check inconsistent with the rest of the code (you would not check the other classes for empty quads?) Empty quad probably doesn't matter, but I'll add check for all of them for the sake of consistency. > > Source/WebCore/rendering/RenderBox.cpp:597 > > + quads.append(localToContainerQuad(FloatRect(0, 0, width(), height()), repaintContainer, false, 0)); > > You don't need the 2 last parameters here. They make the code less readable and more confusing as you wonder why you need them here. Same comment later at the other call sites. > > > Source/WebCore/rendering/RenderBox.h:155 > > + virtual void repaintContainerHighlightQuads(Vector<FloatQuad>&, RenderBoxModelObject* repaintContainer) const; > > We annotate those functions with OVERRIDE (not repeated). Done > > Source/WebCore/rendering/RenderInline.cpp:1465 > > + > > This is inconsistent: you don't call your parent class' method here. I don't understand this comment. Could you explain in detail? > > Source/WebCore/rendering/RenderInline.cpp:1467 > > + if (continuation()) > > + continuation()->repaintContainerHighlightQuads(quads, repaintContainer); > > continuation is RenderBoxModelObject concept which makes me dubious of the duplication between RenderInline and RenderBlock: there should be a RenderBoxModelObject function that handles the continuation for you. I don't think there is one, as absoluteRects and absoluteQuads use the same practice. continuation() is declared as protected instead of private, I guess that means subclasses can be aware of it? > > Source/WebKit/chromium/src/WebHighlight.cpp:54 > > + for (Node *node = topNode; node; node = node->traverseNextNode(topNode)) { > > Style violation Done > > Source/WebKit/chromium/src/WebHighlight.cpp:57 > > + if (!renderer) > > + continue; > > My question here: have you considered SVG? Do you want to support it or not? > > If you don't care about SVG, you don't care about anything that is not a RenderBoxModelObject anyway. That would simplify the code above. Currently I don't care about SVG as I almost never see them used on the internet... But I'll say we'd like to support at a later time when we have more time budget. > > Source/WebKit/chromium/src/WebHighlight.cpp:59 > > + RenderLayer* repaintLayer = renderer->enclosingLayer()->enclosingCompositingLayerForRepaint(); > > NO! Using RenderLayer in the WebKit/ directory is a show-stopper. It means you need access to something you shouldn't be knowing about. > > RenderBoxModelObject* repaintContainer = renderer->containerForRepaint(); > > Will give you the renderer you need. If you need more of the hidden bits, it looks like you should rethink your architecture. Ah ha, this is exactly what I need. Thanks! > > Source/WebKit/chromium/src/WebHighlight.cpp:65 > > + GraphicsLayer* graphicsLayer = repaintLayer->backing()->graphicsLayer(); > > What proofs do you have that this RenderLayer is hardware accelerated? If it is not, this is a NULL crasher. Because it's returned from enclosingCompositingLayerForRepaint(), either it is NULL or it has a backing? > > Source/WebKit/chromium/src/WebHighlight.cpp:68 > > + Path* path = m_quadMap.get(graphicsLayer); > > + if (!path) > > + m_quadMap.set(graphicsLayer, adoptPtr(path = new Path())); > > This is super confusing and inefficient as you are doing 2 hash lookups if you have no entry: > > Path* path = m_quadMap.add(graphicsLayer, adoptPtr(new Path())).iterator->second; This one allocates a new Path even when there is existing entry. :( How about this? HashMap<...>::iterator i = m_quadMap.add(graphicsLayer, adoptPtr(new Path())).iterator; if (!i->second) i->second = new Path(); Path* path = i->second; > > Source/WebKit/chromium/src/WebHighlight.cpp:73 > > + for (size_t i = 0; i < newquads.size(); i++) { > > I don't understand the purpose of this. If you need a Path can't you get one from WebCore directly instead of this hocus pocus code? What I'm thinking is that the WebCore function should only return the exact hit test area, while the WebKit function adds decorations (like round smooth corners), and try to do some basic clipping. 631084 35 aelias 2012-05-22 19:32:39 -0700 (In reply to comment #33) > > Source/WebKit/chromium/src/WebHighlight.cpp:73 > > + for (size_t i = 0; i < newquads.size(); i++) { > > I don't understand the purpose of this. If you need a Path can't you get one from WebCore directly instead of this hocus pocus code? I had a chat offline with Tien-Ren about this. First, I think we want the WebCore part to return rects because it's not guaranteed that the highlight rect generation will always support them (personally I think it's overkill and we may want to strip out Path support at some point). But I think you have a point. As Tien-Ren mentioned above, I think we should rename "repaintContainerHighlightQuads()" to "hitRectContainerQuads()" as ultimately what we want to highlight is the hit rect area of the element. Moreover, this function will be usable in the future for the touch event quick-reject feature that we've been discussing. Then, we can move the bulk of the hocus pocus -- the clipping for overflow: hidden elements -- into WebCore, since that logic matches the "hit rect" concept. 632416 36 143728 trchen 2012-05-23 22:12:53 -0700 Created attachment 143728 Patch 632418 37 trchen 2012-05-23 22:15:55 -0700 The new patch fixed some of the issue addressed by jchaffraix@. Still need to add new test and update the existing LinkHighlightTest. By the way how do I tell the script to regenerate the modification list in ChangeLog? 632828 38 abarth 2012-05-24 08:30:40 -0700 > By the way how do I tell the script to regenerate the modification list in ChangeLog? There isn't a very good way to do that. One thing you can do is to run ./Tools/Scripts/prepare-ChangeLog manually, which will add a new ChangeLog entry to the top of the file. You'll then need to merge the two entries manually. 636586 39 144645 trchen 2012-05-29 17:08:26 -0700 Created attachment 144645 Patch 640995 40 abarth 2012-06-04 16:46:40 -0700 @jchaffraix: Are you happy with this patch now? 643658 41 144645 jchaffraix 2012-06-07 10:23:51 -0700 Comment on attachment 144645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=144645&action=review Not good yet. The patch is too massive to be properly reviewed, please find some ways to split it as it would help to get it landed: I couldn't look at everything due to the size. > Source/WebCore/ChangeLog:9 > + to generate the clickable region for link highlighting. If it's only for link, it should be more explicit in the naming. > Source/WebCore/rendering/RenderObject.cpp:2867 > +void RenderObject::hitQuadsForContainerWithClipping(Vector<FloatQuad>& quads, RenderBoxModelObject* repaintContainer) const The naming could really use a *verb* and be more precise. I don't understand what the 'with clipping' means, if you mean clipped then please use 'clipped' instead (which would match the rest of the code, e.g. clippedOverflowRectForRepaint (which may do something similar to what you are doing btw, I don't have the strength of looking into that)). > Source/WebCore/rendering/RenderObject.cpp:2869 > + size_t oldSize = quads.size(); This is useless as quads is always empty when the function is called. > Source/WebCore/rendering/RenderObject.cpp:2880 > + for (RenderBlock* blk = containingBlock(); blk && blk->isDescendantOf(repaintContainer); blk = blk->containingBlock()) { I hope you understand this is a quadratic operation thanks to the isDescendantOf call and because it's in another loop it's horribly slow. 2 ways to make it less sucky: * look-ahead and you cache the top-most containing block to avoid the isDescendantOf() call. * cache the whole containing block chain (likely faster as containingBlock() is a non-trivial function) > Source/WebCore/rendering/RenderObject.cpp:2881 > + if (!blk->hasOverflowClip()) please don't abbreviate, especially since it should be containingBlock for preciseness. > Source/WebCore/rendering/RenderObject.cpp:2883 > + FloatQuad boundQuad = blk->localToContainerQuad(FloatRect(blk->visualOverflowRect()), repaintContainer); visualOverflowRect is more or less the border-box for elements with a clip: it would include only a couple of operations that bleed outside the box (like box-shadow) but would miss some like outline. I am not sure why you don't just use the border-box. > Source/WebCore/rendering/RenderObject.cpp:2884 > + if (!boundQuad.isRectilinear()) // don't know how to clip this. :( You can always do the intersection with the quad's bounding box but it will be inaccurate - as in the resulting FloatRect will cover a bigger surface - if it's not rectilinear. If you need accuracy, you would need to manipulate Path and not rects. > Source/WebKit/chromium/src/WebHighlight.cpp:63 > + GraphicsLayer* graphicsLayer = 0; > + if (repaintContainer && repaintContainer->layer() && repaintContainer->layer()->backing()) > + graphicsLayer = repaintContainer->layer()->backing()->graphicsLayer(); It makes me cry that you need to know so much about how rendering works just to collect some simple hit quads. > Source/WebKit/chromium/src/WebHighlight.h:48 > +class WebHighlight { This refactoring is somehow tangential to the change (I guess it's to be able to test more easily). Please move it to a blocking bug as it would shrink your already massive patch. > Source/WebKit/chromium/tests/LinkHighlightTest.cpp:176 > +#if 0 Why are you disabling this test? I see no mention of it anywhere. > Source/WebKit/chromium/tests/data/webhighlight_test.html:4 > +<a href="" id="link1" style="position:absolute;left:50px;top:50px;background-color:#ccffcc"> > + <div style="display:inline-block;width:500px;height:20px;background-color:#ccffcc"></div> Please factor the style into some common classes and some id selectors. It's difficult to read the test as-is. 644881 42 144645 tonikitoo 2012-06-08 11:33:47 -0700 Comment on attachment 144645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=144645&action=review >> Source/WebCore/ChangeLog:9 >> + This patch adds RenderObject::hitQuadsForContainerWithClipping call, >> + to generate the clickable region for link highlighting. > > If it's only for link, it should be more explicit in the naming. is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) 644981 43 144645 trchen 2012-06-08 13:26:36 -0700 Comment on attachment 144645 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=144645&action=review >>> Source/WebCore/ChangeLog:9 >>> + to generate the clickable region for link highlighting. >> >> If it's only for link, it should be more explicit in the naming. > > is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) GestureTapHighlighter has some major flaws that I don't think are easily fixable. 1. The support for transformation is terribly wrong. It gets the absoluteRects then apply layer transformation again? 2. It doesn't separate highlights for different graphicsLayer. Which is essential to support threaded-scrolling/CSS animation. >> Source/WebCore/rendering/RenderObject.cpp:2869 >> + size_t oldSize = quads.size(); > > This is useless as quads is always empty when the function is called. True for our current code, but there may be a chance we will batch multiple calls to the same vector. The overhead is negligible anyway. >> Source/WebCore/rendering/RenderObject.cpp:2880 >> + for (RenderBlock* blk = containingBlock(); blk && blk->isDescendantOf(repaintContainer); blk = blk->containingBlock()) { > > I hope you understand this is a quadratic operation thanks to the isDescendantOf call and because it's in another loop it's horribly slow. 2 ways to make it less sucky: > * look-ahead and you cache the top-most containing block to avoid the isDescendantOf() call. > * cache the whole containing block chain (likely faster as containingBlock() is a non-trivial function) Hmm I'm just not sure if blk->containingBlock would ever jump over a repainContainer. If not I guess we can simply use blk && blk != repaintContainer. >> Source/WebCore/rendering/RenderObject.cpp:2883 >> + FloatQuad boundQuad = blk->localToContainerQuad(FloatRect(blk->visualOverflowRect()), repaintContainer); > > visualOverflowRect is more or less the border-box for elements with a clip: it would include only a couple of operations that bleed outside the box (like box-shadow) but would miss some like outline. > > I am not sure why you don't just use the border-box. Sounds good >> Source/WebCore/rendering/RenderObject.cpp:2884 >> + if (!boundQuad.isRectilinear()) // don't know how to clip this. :( > > You can always do the intersection with the quad's bounding box but it will be inaccurate - as in the resulting FloatRect will cover a bigger surface - if it's not rectilinear. > > If you need accuracy, you would need to manipulate Path and not rects. I think you're right. Clip loosely is better than not clipping at all in this case. We can allow some false positive. Manipulating polygons is simply too expensive. >> Source/WebKit/chromium/src/WebHighlight.cpp:63 >> + graphicsLayer = repaintContainer->layer()->backing()->graphicsLayer(); > > It makes me cry that you need to know so much about how rendering works just to collect some simple hit quads. I agree it is too much leak of internals. But in this case the caller must know something about graphicsLayer in order to support threaded-scrolling/CSS animation. >> Source/WebKit/chromium/tests/LinkHighlightTest.cpp:176 >> +#if 0 > > Why are you disabling this test? I see no mention of it anywhere. Ah, actually the whole LinkHighlightTest needs to be reworked for the new code. I'm still figuring out how to keep these tests. 644985 44 tonikitoo 2012-06-08 13:29:17 -0700 > > is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) > > GestureTapHighlighter has some major flaws that I don't think are easily fixable. > 1. The support for transformation is terribly wrong. It gets the absoluteRects then apply layer transformation again? > 2. It doesn't separate highlights for different graphicsLayer. Which is essential to support threaded-scrolling/CSS animation. Zalan would be interested in improving this, I think. 644990 45 trchen 2012-06-08 13:32:25 -0700 (In reply to comment #41) > (From update of attachment 144645 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=144645&action=review > > Source/WebCore/ChangeLog:9 > > + to generate the clickable region for link highlighting. > > If it's only for link, it should be more explicit in the naming. Forgot to say, this will be re-used at a later time for threaded-scrolling/touch event handling. The idea is, we want to generate the hit quads for the elements with Javascript touch handler, store them in the compositor side, so the compositor will know whether we can do a quick reject to touch events instead of forward everything to the main thread. It will be very helpful for UI responsiveness. 644993 46 trchen 2012-06-08 13:37:16 -0700 (In reply to comment #44) > > > is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) > > > > GestureTapHighlighter has some major flaws that I don't think are easily fixable. > > 1. The support for transformation is terribly wrong. It gets the absoluteRects then apply layer transformation again? > > 2. It doesn't separate highlights for different graphicsLayer. Which is essential to support threaded-scrolling/CSS animation. > > Zalan would be interested in improving this, I think. Why not just use our version? ;) I tried the GestureTapHighlighter based version with various test cases (see "some additional test cases" in the attachments), most of them result in a unusable highlight. Besides transformation, it also generates wrong box for inline elements for some cases. 645926 47 zalan 2012-06-11 05:52:16 -0700 (In reply to comment #46) > (In reply to comment #44) > > > > is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) > > > > > > GestureTapHighlighter has some major flaws that I don't think are easily fixable. > > > 1. The support for transformation is terribly wrong. It gets the absoluteRects then apply layer transformation again? > > > 2. It doesn't separate highlights for different graphicsLayer. Which is essential to support threaded-scrolling/CSS animation. > > > > Zalan would be interested in improving this, I think. > > Why not just use our version? ;) > > I tried the GestureTapHighlighter based version with various test cases (see "some additional test cases" in the attachments), most of them result in a unusable highlight. > > Besides transformation, it also generates wrong box for inline elements for some cases. Agree, GestureTapHighlighter has multiple known issues, which were planned to be improved gradually. Since it doesn't make much sense to maintain 2 different implementations of the same feature, I'll check if we can have qt to use this. 649532 48 trchen 2012-06-14 15:15:45 -0700 (In reply to comment #47) > (In reply to comment #46) > > (In reply to comment #44) > > > > > is not it what Source/WebCore/page/GestureTapHighlighter.cpp is responsible for, among others? (see also https://bugs.webkit.org/show_bug.cgi?id=84989) > > > > > > > > GestureTapHighlighter has some major flaws that I don't think are easily fixable. > > > > 1. The support for transformation is terribly wrong. It gets the absoluteRects then apply layer transformation again? > > > > 2. It doesn't separate highlights for different graphicsLayer. Which is essential to support threaded-scrolling/CSS animation. > > > > > > Zalan would be interested in improving this, I think. > > > > Why not just use our version? ;) > > > > I tried the GestureTapHighlighter based version with various test cases (see "some additional test cases" in the attachments), most of them result in a unusable highlight. > > > > Besides transformation, it also generates wrong box for inline elements for some cases. > Agree, GestureTapHighlighter has multiple known issues, which were planned to be improved gradually. Since it doesn't make much sense to maintain 2 different implementations of the same feature, I'll check if we can have qt to use this. Sorry for the delay in reply. I'm currently on a 2-weeks vacation. Will try to reply within 48 hours. I think our RenderObject::hitQuadsForContainer works very similar to RenderObject::addFocusRingRects if you pass null as the repaintContainer (so it returns in absolute coordinate), except with two difference: 1. hitQuadsForContainer returns quads instead of rects. If the rendering code is not capable of dealing with quads, I think using the enclosingBoundingBox would be a feasible solution. 2. hitQuadsForContainer returns the raw hit-rects without decorations such as rounded-corner. Our "beautifying" code in is done in the WebHighlight class. 671131 49 peter 2012-07-17 03:33:27 -0700 Hi Tien-Ren, did you had a chance to look at this yet? 701680 50 allan.jensen 2012-08-22 01:46:31 -0700 (In reply to comment #48) > I think our RenderObject::hitQuadsForContainer works very similar to RenderObject::addFocusRingRects if you pass null as the repaintContainer (so it returns in absolute coordinate), except with two difference: > > 1. hitQuadsForContainer returns quads instead of rects. If the rendering code is not capable of dealing with quads, I think using the enclosingBoundingBox would be a feasible solution. > > 2. hitQuadsForContainer returns the raw hit-rects without decorations such as rounded-corner. Our "beautifying" code in is done in the WebHighlight class. Would it make sense to change addFocusRing, to return quads? It is intended for this purpose but I guess has just not been upgraded to handle transformations. Alternatively, leave it mostly as is (on RenderObject level), but let RenderLayer apply the transformations and still end up returning quads. 701683 51 allan.jensen 2012-08-22 01:48:56 -0700 Additionally, I would suggest removing the [Chromium] tag from the bug. If this lands, it could also solve problems for other platforms, for instance bug #94345, which is an assertion hit due to encountering transforms in highlight path code that can not handle transforms. 701688 52 kenneth 2012-08-22 01:53:37 -0700 (In reply to comment #50) > (In reply to comment #48) > > I think our RenderObject::hitQuadsForContainer works very similar to RenderObject::addFocusRingRects if you pass null as the repaintContainer (so it returns in absolute coordinate), except with two difference: > > > > 1. hitQuadsForContainer returns quads instead of rects. If the rendering code is not capable of dealing with quads, I think using the enclosingBoundingBox would be a feasible solution. > > > > 2. hitQuadsForContainer returns the raw hit-rects without decorations such as rounded-corner. Our "beautifying" code in is done in the WebHighlight class. > > Would it make sense to change addFocusRing, to return quads? It is intended for this purpose but I guess has just not been upgraded to handle transformations. Alternatively, leave it mostly as is (on RenderObject level), but let RenderLayer apply the transformations and still end up returning quads. What about making addFocusRing use hitQuadsForContainer and then just do the beautifying code on top? Drawing highlights or focus rings should be quite similar 701703 53 allan.jensen 2012-08-22 02:18:38 -0700 (In reply to comment #52) > (In reply to comment #50) > > (In reply to comment #48) > > > I think our RenderObject::hitQuadsForContainer works very similar to RenderObject::addFocusRingRects if you pass null as the repaintContainer (so it returns in absolute coordinate), except with two difference: > > > > > > 1. hitQuadsForContainer returns quads instead of rects. If the rendering code is not capable of dealing with quads, I think using the enclosingBoundingBox would be a feasible solution. > > > > > > 2. hitQuadsForContainer returns the raw hit-rects without decorations such as rounded-corner. Our "beautifying" code in is done in the WebHighlight class. > > > > Would it make sense to change addFocusRing, to return quads? It is intended for this purpose but I guess has just not been upgraded to handle transformations. Alternatively, leave it mostly as is (on RenderObject level), but let RenderLayer apply the transformations and still end up returning quads. > > What about making addFocusRing use hitQuadsForContainer and then just do the beautifying code on top? Drawing highlights or focus rings should be quite similar It turns out to be unnecessary. AddFocusRing is used by normal paint logic, which means it is already clipped and transformed automatically by RenderLayer, so it doesn't need quads. But that does give me an idea: What we are doing with hitQuadsForContainer (and GestureTapHighlighter), is duplicating the clipping code from painting, because we are doing the painting outside of the normal painting logic. If the painting was instead performed by RenderObject like it is for focusRings, this would not be necessary. So would it be possible to call a function similar to paintFocusRing to paint the tap-highlight, and give it the right graphicscontext making it paint it on another layer? 701712 54 kenneth 2012-08-22 02:45:25 -0700 > It turns out to be unnecessary. AddFocusRing is used by normal paint logic, which means it is already clipped and transformed automatically by RenderLayer, so it doesn't need quads. > > But that does give me an idea: What we are doing with hitQuadsForContainer (and GestureTapHighlighter), is duplicating the clipping code from painting, because we are doing the painting outside of the normal painting logic. If the painting was instead performed by RenderObject like it is for focusRings, this would not be necessary. So would it be possible to call a function similar to paintFocusRing to paint the tap-highlight, and give it the right graphicscontext making it paint it on another layer? I think this should be possible, especially if we want the same clipping. I thinks that the highlight itself might be slightly bigger than the element being highlighted (and clipped). I guess we also want to make sure that the actual highlighting is always painted on a layer different from root. 735945 55 abarth 2012-10-05 14:11:25 -0700 I think this work got done in another patch. 138954 2012-04-26 01:54:36 -0700 2012-05-01 03:31:30 -0700 Patch bug-84936-20120426015435.patch text/plain 17566 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE1MjYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDcyODVmZjE2YTAwOWQ4 OWZmMjU4YTgwMzUxMTBlZTEwZjYwZGNhOC4uYWI5YjZiZDc4NTY5YWU3OGI3MDJlZTkzNzk0ZjMx MTYwOWQ1NTIyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTA0LTI2ICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFdJUCwgY29tbWVudHMg Y29tZSBsYXRlcgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJv eC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJCb3g6OmNvbnRhaW5lclF1YWRzKToKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3guaDoKKyAgICAg ICAgKFJlbmRlckJveCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGluZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbmxpbmU6OmNvbnRhaW5lclF1YWRzKToKKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW5saW5lOjpjdWxsZWRJbmxpbmVD b250YWluZXJRdWFkcyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGluZS5oOgorICAg ICAgICAoUmVuZGVySW5saW5lKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6 CisgICAgICAgIChSZW5kZXJPYmplY3QpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0 Ojpjb250YWluZXJRdWFkcyk6CisKIDIwMTItMDQtMjUgIERvdWdsYXMgU3RvY2t3ZWxsICA8ZHN0 b2Nrd2VsbEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgSW5kZXhlZERCOiBjdXJzb3IgZG9lcyBu b3QgY29ycmVjdGx5IGl0ZXJhdGUgb3ZlciBrZXlzIGFkZGVkIGFuZCByZW1vdmVkIGR1cmluZyBp dGVyYXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMmI4YjExMDc0MGI2YTdjMzNh MWNlZDBmNWFmNDc2NDIzMzVjNzliMy4uN2M3NzE4NTg5YzVjMjE4M2U4N2NiMjA5ZDc3MDk2NTFh OWI5NmEyMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMCBAQAorMjAx Mi0wNC0yNiAgVGllbi1SZW4gQ2hlbiAgPHRyY2hlbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg W2Nocm9taXVtXSBDb21wdXRlIGhpZ2hsaWdodCBmb3IgdG91Y2ggdGFyZ2V0cworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODQ5MzYKKworICAgICAgICBX SVAsIGNvbW1lbnRzIGNvbWUgbGF0ZXIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQ6 OldlYlZpZXdJbXBsOjpXZWJWaWV3SW1wbCk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdJbXBs OjpoYW5kbGVJbnB1dEV2ZW50KToKKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJLaXQ6 OldlYlZpZXdJbXBsOjpjb21wdXRlVG91Y2hIaWdobGlnaHQpOgorICAgICAgICAoV2ViS2l0OjpX ZWJWaWV3SW1wbDo6Y29tcHV0ZUJlc3RUb3VjaFRhcmdldCk6CisgICAgICAgICogc3JjL1dlYlZp ZXdJbXBsLmg6CisKIDIwMTItMDQtMjUgIElhbiBWb2xsaWNrICA8dm9sbGlja0BjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgW2Nocm9taXVtXSBBZGQgc3VwcG9ydCBmb3IgYW5pbWF0aW9uIGZpbmlz aGVkIGV2ZW50cy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC b3guY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAKaW5kZXggMzdl Y2EyODBlMmMwMzAwNWEwNTk2ZDhlMWJjYzk2OGNjOWJlNGNmMi4uYTM4Y2NmM2QyY2U3MTMyNWJh Yjk0OTUyOGU4YzUyNDFkNjA1YWFmNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckJveC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJv eC5jcHAKQEAgLTU0Nyw2ICs1NDcsMTEgQEAgdm9pZCBSZW5kZXJCb3g6OmFic29sdXRlUXVhZHMo VmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBib29sKiB3YXNGaXhlZCkgY29uc3QKICAgICBxdWFk cy5hcHBlbmQobG9jYWxUb0Fic29sdXRlUXVhZChGbG9hdFJlY3QoMCwgMCwgd2lkdGgoKSwgaGVp Z2h0KCkpLCBmYWxzZSwgd2FzRml4ZWQpKTsKIH0KIAordm9pZCBSZW5kZXJCb3g6OmNvbnRhaW5l clF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJl cGFpbnRDb250YWluZXIsIGJvb2wqIHdhc0ZpeGVkKSBjb25zdAoreworICAgIHF1YWRzLmFwcGVu ZChsb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoMCwgMCwgd2lkdGgoKSwgaGVpZ2h0KCkp LCByZXBhaW50Q29udGFpbmVyLCBmYWxzZSwgd2FzRml4ZWQpKTsKK30KKwogdm9pZCBSZW5kZXJC b3g6OnVwZGF0ZUxheWVyVHJhbnNmb3JtKCkKIHsKICAgICAvLyBUcmFuc2Zvcm0tb3JpZ2luIGRl cGVuZHMgb24gYm94IHNpemUsIHNvIHdlIG5lZWQgdG8gdXBkYXRlIHRoZSBsYXllciB0cmFuc2Zv cm0gYWZ0ZXIgbGF5b3V0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckJveC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5oCmluZGV4IDc2 MWJjZmU3MjUzNzAwNTkwODRkZGY5NzJlYTQwZTJmYTc5MzRhNGQuLjY3ZmRjZWM1NWUxZWQ2YWM1 MDkzNDMxYTIwNzI3ZjY5MjQ5OGI0N2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJCb3guaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94 LmgKQEAgLTI1OSw2ICsyNTksOCBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgYWJzb2x1 dGVSZWN0cyhWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlvdXRQb2ludCYgYWNjdW11bGF0ZWRP ZmZzZXQpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBhYnNvbHV0ZVF1YWRzKFZlY3RvcjxGbG9h dFF1YWQ+JiwgYm9vbCogd2FzRml4ZWQpIGNvbnN0OworCisgICAgdmlydHVhbCB2b2lkIGNvbnRh aW5lclF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFp bnRDb250YWluZXIsIGJvb2wqIHdhc0ZpeGVkKSBjb25zdDsKICAgICAKICAgICBMYXlvdXRSZWN0 IHJlZmxlY3Rpb25Cb3goKSBjb25zdDsKICAgICBpbnQgcmVmbGVjdGlvbk9mZnNldCgpIGNvbnN0 OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcAppbmRleCBkZDQ2YWZj YzEzYjE0OGFjMGFiNTlmOTQ5YTI3ODIxYTcyOTFkZGQ4Li5jNzcxODE5MjhjMGI0Y2E1M2Y0NzEy M2YzNTg4YTc2YWQ2ZjdiNzQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVySW5saW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5s aW5lLmNwcApAQCAtNjc4LDYgKzY3OCw5MCBAQCB2b2lkIFJlbmRlcklubGluZTo6Y3VsbGVkSW5s aW5lQWJzb2x1dGVRdWFkcyhjb25zdCBSZW5kZXJJbmxpbmUqIGNvbnRhaW5lciwgVmVjdAogICAg IH0KIH0KIAordm9pZCBSZW5kZXJJbmxpbmU6OmNvbnRhaW5lclF1YWRzKFZlY3RvcjxGbG9hdFF1 YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIsIGJvb2wq IHdhc0ZpeGVkKSBjb25zdAoreworICAgIGlmICghYWx3YXlzQ3JlYXRlTGluZUJveGVzKCkpCisg ICAgICAgIGN1bGxlZElubGluZUNvbnRhaW5lclF1YWRzKHRoaXMsIHJlcGFpbnRDb250YWluZXIs IHF1YWRzKTsKKyAgICBlbHNlIGlmIChJbmxpbmVGbG93Qm94KiBjdXJyID0gZmlyc3RMaW5lQm94 KCkpIHsKKyAgICAgICAgZm9yICg7IGN1cnI7IGN1cnIgPSBjdXJyLT5uZXh0TGluZUJveCgpKSB7 CisgICAgICAgICAgICBGbG9hdFJlY3QgbG9jYWxSZWN0KGN1cnItPngoKSwgY3Vyci0+eSgpLCBj dXJyLT53aWR0aCgpLCBjdXJyLT5oZWlnaHQoKSk7CisgICAgICAgICAgICBxdWFkcy5hcHBlbmQo bG9jYWxUb0NvbnRhaW5lclF1YWQobG9jYWxSZWN0LCByZXBhaW50Q29udGFpbmVyLCBmYWxzZSwg d2FzRml4ZWQpKTsKKyAgICAgICAgfQorICAgIH0gZWxzZQorICAgICAgICBxdWFkcy5hcHBlbmQo bG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KCksIHJlcGFpbnRDb250YWluZXIsIGZhbHNl LCB3YXNGaXhlZCkpOworCisgICAgaWYgKGNvbnRpbnVhdGlvbigpKQorICAgICAgICBjb250aW51 YXRpb24oKS0+Y29udGFpbmVyUXVhZHMocXVhZHMsIHJlcGFpbnRDb250YWluZXIsIHdhc0ZpeGVk KTsKK30KKwordm9pZCBSZW5kZXJJbmxpbmU6OmN1bGxlZElubGluZUNvbnRhaW5lclF1YWRzKGNv bnN0IFJlbmRlcklubGluZSogY29udGFpbmVyLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWlu dENvbnRhaW5lciwgVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzKSBjb25zdAoreworICAgIGlmICgh Y3VsbGVkSW5saW5lRmlyc3RMaW5lQm94KCkpIHsKKyAgICAgICAgcXVhZHMuYXBwZW5kKGxvY2Fs VG9Db250YWluZXJRdWFkKEZsb2F0UmVjdCgpLCByZXBhaW50Q29udGFpbmVyKSk7CisgICAgICAg IHJldHVybjsKKyAgICB9CisKKyAgICBib29sIGlzSG9yaXpvbnRhbCA9IHN0eWxlKCktPmlzSG9y aXpvbnRhbFdyaXRpbmdNb2RlKCk7CisgICAgZm9yIChSZW5kZXJPYmplY3QqIGN1cnIgPSBmaXJz dENoaWxkKCk7IGN1cnI7IGN1cnIgPSBjdXJyLT5uZXh0U2libGluZygpKSB7CisgICAgICAgIGlm IChjdXJyLT5pc0Zsb2F0aW5nT3JQb3NpdGlvbmVkKCkpCisgICAgICAgICAgICBjb250aW51ZTsK KworICAgICAgICAvLyBXZSB3YW50IHRvIGdldCB0aGUgbWFyZ2luIGJveCBpbiB0aGUgaW5saW5l IGRpcmVjdGlvbiwgYW5kIHRoZW4gdXNlIG91ciBmb250IGFzY2VudC9kZXNjZW50IGluIHRoZSBi bG9jaworICAgICAgICAvLyBkaXJlY3Rpb24gKGFsaWduZWQgdG8gdGhlIHJvb3QgYm94J3MgYmFz ZWxpbmUpLgorICAgICAgICBpZiAoY3Vyci0+aXNCb3goKSkgeworICAgICAgICAgICAgUmVuZGVy Qm94KiBjdXJyQm94ID0gdG9SZW5kZXJCb3goY3Vycik7CisgICAgICAgICAgICBpZiAoY3VyckJv eC0+aW5saW5lQm94V3JhcHBlcigpKSB7CisgICAgICAgICAgICAgICAgUm9vdElubGluZUJveCog cm9vdEJveCA9IGN1cnJCb3gtPmlubGluZUJveFdyYXBwZXIoKS0+cm9vdCgpOworICAgICAgICAg ICAgICAgIGludCBsb2dpY2FsVG9wID0gcm9vdEJveC0+bG9naWNhbFRvcCgpICsgKHJvb3RCb3gt PnJlbmRlcmVyKCktPnN0eWxlKHJvb3RCb3gtPmlzRmlyc3RMaW5lU3R5bGUoKSktPmZvbnQoKS5m b250TWV0cmljcygpLmFzY2VudCgpIC0gY29udGFpbmVyLT5zdHlsZShyb290Qm94LT5pc0ZpcnN0 TGluZVN0eWxlKCkpLT5mb250KCkuZm9udE1ldHJpY3MoKS5hc2NlbnQoKSk7CisgICAgICAgICAg ICAgICAgaW50IGxvZ2ljYWxIZWlnaHQgPSBjb250YWluZXItPnN0eWxlKHJvb3RCb3gtPmlzRmly c3RMaW5lU3R5bGUoKSktPmZvbnQoKS5mb250TWV0cmljcygpLmhlaWdodCgpOworICAgICAgICAg ICAgICAgIEZsb2F0UmVjdCByZXN1bHQ7CisgICAgICAgICAgICAgICAgaWYgKGlzSG9yaXpvbnRh bCkKKyAgICAgICAgICAgICAgICAgICAgcmVzdWx0ID0gRmxvYXRSZWN0KGN1cnJCb3gtPmlubGlu ZUJveFdyYXBwZXIoKS0+eCgpIC0gY3VyckJveC0+bWFyZ2luTGVmdCgpLCBsb2dpY2FsVG9wLCBj dXJyQm94LT53aWR0aCgpICsgY3VyckJveC0+bWFyZ2luV2lkdGgoKSwgbG9naWNhbEhlaWdodCk7 CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICByZXN1bHQgPSBGbG9h dFJlY3QobG9naWNhbFRvcCwgY3VyckJveC0+aW5saW5lQm94V3JhcHBlcigpLT55KCkgLSBjdXJy Qm94LT5tYXJnaW5Ub3AoKSwgbG9naWNhbEhlaWdodCwgY3VyckJveC0+aGVpZ2h0KCkgKyBjdXJy Qm94LT5tYXJnaW5IZWlnaHQoKSk7CisgICAgICAgICAgICAgICAgcXVhZHMuYXBwZW5kKGxvY2Fs VG9Db250YWluZXJRdWFkKHJlc3VsdCwgcmVwYWludENvbnRhaW5lcikpOworICAgICAgICAgICAg fQorICAgICAgICB9IGVsc2UgaWYgKGN1cnItPmlzUmVuZGVySW5saW5lKCkpIHsKKyAgICAgICAg ICAgIC8vIElmIHRoZSBjaGlsZCBkb2Vzbid0IG5lZWQgbGluZSBib3hlcyBlaXRoZXIsIHRoZW4g d2UgY2FuIHJlY3VyLgorICAgICAgICAgICAgUmVuZGVySW5saW5lKiBjdXJySW5saW5lID0gdG9S ZW5kZXJJbmxpbmUoY3Vycik7CisgICAgICAgICAgICBpZiAoIWN1cnJJbmxpbmUtPmFsd2F5c0Ny ZWF0ZUxpbmVCb3hlcygpKQorICAgICAgICAgICAgICAgIGN1cnJJbmxpbmUtPmN1bGxlZElubGlu ZUNvbnRhaW5lclF1YWRzKGNvbnRhaW5lciwgcmVwYWludENvbnRhaW5lciwgcXVhZHMpOworICAg ICAgICAgICAgZWxzZSB7CisgICAgICAgICAgICAgICAgZm9yIChJbmxpbmVGbG93Qm94KiBjaGls ZExpbmUgPSBjdXJySW5saW5lLT5maXJzdExpbmVCb3goKTsgY2hpbGRMaW5lOyBjaGlsZExpbmUg PSBjaGlsZExpbmUtPm5leHRMaW5lQm94KCkpIHsKKyAgICAgICAgICAgICAgICAgICAgUm9vdElu bGluZUJveCogcm9vdEJveCA9IGNoaWxkTGluZS0+cm9vdCgpOworICAgICAgICAgICAgICAgICAg ICBpbnQgbG9naWNhbFRvcCA9IHJvb3RCb3gtPmxvZ2ljYWxUb3AoKSArIChyb290Qm94LT5yZW5k ZXJlcigpLT5zdHlsZShyb290Qm94LT5pc0ZpcnN0TGluZVN0eWxlKCkpLT5mb250KCkuZm9udE1l dHJpY3MoKS5hc2NlbnQoKSAtIGNvbnRhaW5lci0+c3R5bGUocm9vdEJveC0+aXNGaXJzdExpbmVT dHlsZSgpKS0+Zm9udCgpLmZvbnRNZXRyaWNzKCkuYXNjZW50KCkpOworICAgICAgICAgICAgICAg ICAgICBpbnQgbG9naWNhbEhlaWdodCA9IGNvbnRhaW5lci0+c3R5bGUocm9vdEJveC0+aXNGaXJz dExpbmVTdHlsZSgpKS0+Zm9udCgpLmZvbnRNZXRyaWNzKCkuaGVpZ2h0KCk7CisgICAgICAgICAg ICAgICAgICAgIEZsb2F0UmVjdCByZXN1bHQ7CisgICAgICAgICAgICAgICAgICAgIGlmIChpc0hv cml6b250YWwpCisgICAgICAgICAgICAgICAgICAgICAgICByZXN1bHQgPSBGbG9hdFJlY3QoY2hp bGRMaW5lLT54KCkgLSBjaGlsZExpbmUtPm1hcmdpbkxvZ2ljYWxMZWZ0KCksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgbG9naWNhbFRvcCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICBjaGlsZExpbmUtPmxvZ2ljYWxXaWR0aCgpICsgY2hpbGRMaW5lLT5tYXJnaW5Mb2dpY2FsTGVm dCgpICsgY2hpbGRMaW5lLT5tYXJnaW5Mb2dpY2FsUmlnaHQoKSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICBsb2dpY2FsSGVpZ2h0KTsKKyAgICAgICAgICAgICAgICAgICAgZWxzZQorICAg ICAgICAgICAgICAgICAgICAgICAgcmVzdWx0ID0gRmxvYXRSZWN0KGxvZ2ljYWxUb3AsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgY2hpbGRMaW5lLT55KCkgLSBjaGlsZExpbmUtPm1hcmdp bkxvZ2ljYWxMZWZ0KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgbG9naWNhbEhlaWdo dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGlsZExpbmUtPmxvZ2ljYWxXaWR0aCgp ICsgY2hpbGRMaW5lLT5tYXJnaW5Mb2dpY2FsTGVmdCgpICsgY2hpbGRMaW5lLT5tYXJnaW5Mb2dp Y2FsUmlnaHQoKSk7CisgICAgICAgICAgICAgICAgICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQ29u dGFpbmVyUXVhZChyZXN1bHQsIHJlcGFpbnRDb250YWluZXIpKTsKKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoY3Vyci0+aXNUZXh0KCkpIHsKKyAg ICAgICAgICAgIFJlbmRlclRleHQqIGN1cnJUZXh0ID0gdG9SZW5kZXJUZXh0KGN1cnIpOworICAg ICAgICAgICAgZm9yIChJbmxpbmVUZXh0Qm94KiBjaGlsZFRleHQgPSBjdXJyVGV4dC0+Zmlyc3RU ZXh0Qm94KCk7IGNoaWxkVGV4dDsgY2hpbGRUZXh0ID0gY2hpbGRUZXh0LT5uZXh0VGV4dEJveCgp KSB7CisgICAgICAgICAgICAgICAgUm9vdElubGluZUJveCogcm9vdEJveCA9IGNoaWxkVGV4dC0+ cm9vdCgpOworICAgICAgICAgICAgICAgIGludCBsb2dpY2FsVG9wID0gcm9vdEJveC0+bG9naWNh bFRvcCgpICsgKHJvb3RCb3gtPnJlbmRlcmVyKCktPnN0eWxlKHJvb3RCb3gtPmlzRmlyc3RMaW5l U3R5bGUoKSktPmZvbnQoKS5mb250TWV0cmljcygpLmFzY2VudCgpIC0gY29udGFpbmVyLT5zdHls ZShyb290Qm94LT5pc0ZpcnN0TGluZVN0eWxlKCkpLT5mb250KCkuZm9udE1ldHJpY3MoKS5hc2Nl bnQoKSk7CisgICAgICAgICAgICAgICAgaW50IGxvZ2ljYWxIZWlnaHQgPSBjb250YWluZXItPnN0 eWxlKHJvb3RCb3gtPmlzRmlyc3RMaW5lU3R5bGUoKSktPmZvbnQoKS5mb250TWV0cmljcygpLmhl aWdodCgpOworICAgICAgICAgICAgICAgIEZsb2F0UmVjdCByZXN1bHQ7CisgICAgICAgICAgICAg ICAgaWYgKGlzSG9yaXpvbnRhbCkKKyAgICAgICAgICAgICAgICAgICAgcmVzdWx0ID0gRmxvYXRS ZWN0KGNoaWxkVGV4dC0+eCgpLCBsb2dpY2FsVG9wLCBjaGlsZFRleHQtPmxvZ2ljYWxXaWR0aCgp LCBsb2dpY2FsSGVpZ2h0KTsKKyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAg ICAgIHJlc3VsdCA9IEZsb2F0UmVjdChsb2dpY2FsVG9wLCBjaGlsZFRleHQtPnkoKSwgbG9naWNh bEhlaWdodCwgY2hpbGRUZXh0LT5sb2dpY2FsV2lkdGgoKSk7CisgICAgICAgICAgICAgICAgcXVh ZHMuYXBwZW5kKGxvY2FsVG9Db250YWluZXJRdWFkKHJlc3VsdCwgcmVwYWludENvbnRhaW5lcikp OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorCiBMYXlvdXRVbml0IFJlbmRl cklubGluZTo6b2Zmc2V0TGVmdCgpIGNvbnN0CiB7CiAgICAgTGF5b3V0VW5pdCB4ID0gUmVuZGVy Qm94TW9kZWxPYmplY3Q6Om9mZnNldExlZnQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJJbmxpbmUuaAppbmRleCBiYWE4YzZiODQyYzZiMTc0M2M5YjEzYWM5OWQ1Mjk0YTM2Nzc4YTJj Li41YTZhZmFhMzllZjUzMTBkMTFjOWFmMmY0NmI2NWU2MDFiZGY2OGY0IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCkBAIC00OSw2ICs0OSw4IEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIHZvaWQgYWJzb2x1dGVSZWN0cyhWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlv dXRQb2ludCYgYWNjdW11bGF0ZWRPZmZzZXQpIGNvbnN0OwogICAgIHZpcnR1YWwgdm9pZCBhYnNv bHV0ZVF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgYm9vbCogd2FzRml4ZWQpIGNvbnN0OwogCisg ICAgdmlydHVhbCB2b2lkIGNvbnRhaW5lclF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVy Qm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIsIGJvb2wqIHdhc0ZpeGVkKSBjb25zdDsK KwogICAgIHZpcnR1YWwgTGF5b3V0U2l6ZSBvZmZzZXRGcm9tQ29udGFpbmVyKFJlbmRlck9iamVj dCosIGNvbnN0IExheW91dFBvaW50JikgY29uc3Q7CiAKICAgICBJbnRSZWN0IGxpbmVzQm91bmRp bmdCb3goKSBjb25zdDsKQEAgLTEwNSw2ICsxMDcsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgY3Vs bGVkSW5saW5lQWJzb2x1dGVSZWN0cyhjb25zdCBSZW5kZXJJbmxpbmUqIGNvbnRhaW5lciwgVmVj dG9yPEludFJlY3Q+JiwgY29uc3QgTGF5b3V0U2l6ZSYpIGNvbnN0OwogICAgIHZvaWQgY3VsbGVk SW5saW5lQWJzb2x1dGVRdWFkcyhjb25zdCBSZW5kZXJJbmxpbmUqIGNvbnRhaW5lciwgVmVjdG9y PEZsb2F0UXVhZD4mKSBjb25zdDsKIAorICAgIHZvaWQgY3VsbGVkSW5saW5lQ29udGFpbmVyUXVh ZHMoY29uc3QgUmVuZGVySW5saW5lKiBjb250YWluZXIsIFJlbmRlckJveE1vZGVsT2JqZWN0KiBy ZXBhaW50Q29udGFpbmVyLCBWZWN0b3I8RmxvYXRRdWFkPiYpIGNvbnN0OworCiAgICAgdm9pZCBh ZGRDaGlsZFRvQ29udGludWF0aW9uKFJlbmRlck9iamVjdCogbmV3Q2hpbGQsIFJlbmRlck9iamVj dCogYmVmb3JlQ2hpbGQpOwogICAgIHZpcnR1YWwgdm9pZCBhZGRDaGlsZElnbm9yaW5nQ29udGlu dWF0aW9uKFJlbmRlck9iamVjdCogbmV3Q2hpbGQsIFJlbmRlck9iamVjdCogYmVmb3JlQ2hpbGQg PSAwKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVj dC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCmluZGV4IDBiMDNl NDEwNzIzMzkxNDVhN2Q2ZTQ1ODBkMDdlY2NkYjkwOTMxMzguLmU1ZTg4MDY4MmYxNDZjYjU1ZGQy OTNiMTQ0MzlmOTllZjUxOWZkMWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmgKQEAgLTY3Miw2ICs2NzIsOSBAQCBwdWJsaWM6CiAgICAgLy8gQnVpbGQgYW4gYXJyYXkg b2YgcXVhZHMgaW4gYWJzb2x1dGUgY29vcmRzIGZvciBsaW5lIGJveGVzCiAgICAgdmlydHVhbCB2 b2lkIGFic29sdXRlUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBib29sKiAvKndhc0ZpeGVkKi8g PSAwKSBjb25zdCB7IH0KIAorICAgIC8vIEJ1aWxkIGFuIGFycmF5IG9mIHF1YWRzIGluIHRoZSBj b250YWluZXIgY29vcmRzCisgICAgdmlydHVhbCB2b2lkIGNvbnRhaW5lclF1YWRzKFZlY3RvcjxG bG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIsIGJvb2wq IC8qd2FzRml4ZWQqLyA9IDApIGNvbnN0IHsgfQorCiAgICAgdm9pZCBhYnNvbHV0ZUZvY3VzUmlu Z1F1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+Jik7CiAKICAgICAvLyB0aGUgcmVjdCB0aGF0IHdpbGwg YmUgcGFpbnRlZCBpZiB0aGlzIG9iamVjdCBpcyBwYXNzZWQgYXMgdGhlIHBhaW50aW5nUm9vdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDYzODk3NjE5 YmM2ZDU5YjhmMGYwNTIyNTM4YzNhZjM0ZjkyOWVlNDUuLmI4OGE5MThlMDBmZDQ1YWRmMmUyMDdl OTBlNzhkNDlhZjA3MGY4MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3 SW1wbC5jcHAKQEAgLTM5OSw2ICszOTksOSBAQCBXZWJWaWV3SW1wbDo6V2ViVmlld0ltcGwoV2Vi Vmlld0NsaWVudCogY2xpZW50KQogICAgICwgbV91c2VyTWVkaWFDbGllbnRJbXBsKHRoaXMpCiAj ZW5kaWYKICAgICAsIG1fZmxpbmdNb2RpZmllcigwKQorI2lmIDEgLy8gbG9jYWwgdGVzdCBvbmx5 LCBzaG91bGQgbmV2ZXIgYmUgaW5jbHVkZWQgaW4gZmluYWwgQ0wKKyAgICAsIG1faGlnaGxpZ2h0 ZWROb2RlKDApCisjZW5kaWYKIHsKICAgICAvLyBXZWJLaXQvd2luL1dlYlZpZXcuY3BwIGRvZXMg dGhlIHNhbWUgdGhpbmcsIGV4Y2VwdCB0aGV5IGNhbGwgdGhlCiAgICAgLy8gS0pTIHNwZWNpZmlj IHdyYXBwZXIgYXJvdW5kIHRoaXMgbWV0aG9kLiBXZSBuZWVkIHRvIGhhdmUgdGhyZWFkaW5nCkBA IC0xNjY0LDYgKzE2NjcsMjIgQEAgYm9vbCBXZWJWaWV3SW1wbDo6aGFuZGxlSW5wdXRFdmVudChj b25zdCBXZWJJbnB1dEV2ZW50JiBpbnB1dEV2ZW50KQogICAgICAgICByZXR1cm4gdHJ1ZTsKICAg ICB9CiAKKyNpZiAxIC8vIGxvY2FsIHRlc3Qgb25seSwgc2hvdWxkIG5ldmVyIGJlIGluY2x1ZGVk IGluIGZpbmFsIENMCisgICAgaWYgKGlucHV0RXZlbnQudHlwZSA9PSBXZWJJbnB1dEV2ZW50OjpN b3VzZU1vdmUpIHsKKyAgICAgICAgY29uc3QgV2ViTW91c2VFdmVudCogZXZlbnQgPSBzdGF0aWNf Y2FzdDxjb25zdCBXZWJNb3VzZUV2ZW50Kj4oJmlucHV0RXZlbnQpOworICAgICAgICBOb2RlKiBu b2RlID0gY29tcHV0ZUJlc3RUb3VjaFRhcmdldChJbnRQb2ludChldmVudC0+eCwgZXZlbnQtPnkp LCBJbnRTaXplKDEwLCAxMCkpOworICAgICAgICBpZiAobm9kZSAmJiBub2RlICE9IG1faGlnaGxp Z2h0ZWROb2RlKSB7CisgICAgICAgICAgICBmcHJpbnRmKHN0ZGVyciwgImJlc3RUb3VjaFRhcmdl dDogJTA4bHhcbiIsIChsb25nKW5vZGUpOworICAgICAgICAgICAgbm9kZS0+c2hvd1RyZWVGb3JU aGlzKCk7CisgICAgICAgICAgICBpZiAobm9kZS0+cmVuZGVyZXIoKSkKKyAgICAgICAgICAgICAg ICBub2RlLT5yZW5kZXJlcigpLT5zaG93UmVuZGVyVHJlZUZvclRoaXMoKTsKKyAgICAgICAgICAg IEhpZ2hsaWdodE1hcCBtYXA7CisgICAgICAgICAgICBjb21wdXRlVG91Y2hIaWdobGlnaHQoJm1h cCwgbm9kZSk7CisgICAgICAgICAgICBtX2hpZ2hsaWdodGVkTm9kZSA9IG5vZGU7CisgICAgICAg IH0KKyAgICB9CisjZW5kaWYKKwogICAgIGJvb2wgaGFuZGxlZCA9IFBhZ2VXaWRnZXREZWxlZ2F0 ZTo6aGFuZGxlSW5wdXRFdmVudChtX3BhZ2UuZ2V0KCksICp0aGlzLCBpbnB1dEV2ZW50KTsKICAg ICBtX2N1cnJlbnRJbnB1dEV2ZW50ID0gMDsKICAgICByZXR1cm4gaGFuZGxlZDsKQEAgLTM1MTcs NCArMzUzNiw4MSBAQCB2b2lkIFdlYlZpZXdJbXBsOjpwb2ludGVyTG9ja01vdXNlRXZlbnQoY29u c3QgV2ViSW5wdXRFdmVudCYgZXZlbnQpCiB9CiAjZW5kaWYKIAorI2lmIFVTRShBQ0NFTEVSQVRF RF9DT01QT1NJVElORykKKy8vIFJldHVybiB0aGUgaGlnaGxpZ2h0IHF1YWRzIG9mIGEgdG91Y2gg dGFyZ2V0LCBpbiByZWxhdGl2ZSBjb29yZGluYXRlIHRvCisvLyB0aGUgY29tcG9zaXRpbmcgbGF5 ZXIuIFRoaXMgYWxsb3dzIHRoZSBoaWdobGlnaHQgdG8gZm9sbG93IHRoZSBtb3ZpbmcKKy8vIGVs ZW1lbnRzIHdoZW4gY29tcG9zaXRvci1zaWRlIENTUyBhbmltYXRpb24gLyBzY3JvbGxpbmcgaXMg dXNlZC4KK3ZvaWQgV2ViVmlld0ltcGw6OmNvbXB1dGVUb3VjaEhpZ2hsaWdodChIaWdobGlnaHRN YXAqIGhpZ2hsaWdodCwgTm9kZSogdG9wTm9kZSkKK3sKKyAgICBoaWdobGlnaHQtPmNsZWFyKCk7 CisgICAgaWYgKCF0b3BOb2RlKQorICAgICAgICByZXR1cm47CisKKyAgICBmb3IgKE5vZGUgKm5v ZGUgPSB0b3BOb2RlOyBub2RlOyBub2RlID0gbm9kZS0+dHJhdmVyc2VOZXh0Tm9kZSh0b3BOb2Rl KSkgeworICAgICAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbm9kZS0+cmVuZGVyZXIoKTsK KyAgICAgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAg IFJlbmRlckxheWVyKiByZXBhaW50TGF5ZXIgPSByZW5kZXJlci0+ZW5jbG9zaW5nTGF5ZXIoKS0+ ZW5jbG9zaW5nQ29tcG9zaXRpbmdMYXllckZvclJlcGFpbnQoKTsKKyAgICAgICAgaWYgKCFyZXBh aW50TGF5ZXIpIC8vIG1vc3QgbGlrZWx5IHdlJ3JlIG5vdCBpbiBIVy1jb21wb3NpdG9yIG1vZGUu Li4gYmV0dGVyIGRldGVjdCB0aGlzIGVhcmx5IGFuZCBxdWl0PworICAgICAgICAgICAgY29udGlu dWU7CisKKyAgICAgICAgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIgPSBy ZXBhaW50TGF5ZXItPnJlbmRlcmVyKCk7CisKKyAgICAgICAgR3JhcGhpY3NMYXllciogZ3JhcGhp Y3NMYXllciA9IHJlcGFpbnRMYXllci0+YmFja2luZygpLT5ncmFwaGljc0xheWVyKCk7CisgICAg ICAgIFNrUGF0aCogcGF0aCA9IGhpZ2hsaWdodC0+Z2V0KGdyYXBoaWNzTGF5ZXIpOworICAgICAg ICBpZiAoIXBhdGgpCisgICAgICAgICAgICBoaWdobGlnaHQtPnNldChncmFwaGljc0xheWVyLCBh ZG9wdFB0cihwYXRoID0gbmV3IFNrUGF0aCgpKSk7CisKKyAgICAgICAgVmVjdG9yPEZsb2F0UXVh ZD4gbmV3cXVhZHM7CisgICAgICAgIHJlbmRlcmVyLT5jb250YWluZXJRdWFkcyhuZXdxdWFkcywg cmVwYWludENvbnRhaW5lcik7CisKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuZXdx dWFkcy5zaXplKCk7IGkrKykgeworICAgICAgICAgICAgRmxvYXRRdWFkIHF1YWQgPSBuZXdxdWFk c1tpXTsKKworICAgICAgICAgICAgaWYgKHF1YWQuaXNSZWN0aWxpbmVhcigpKSB7CisgICAgICAg ICAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJvdW5kaW5nQm94KCk7CisKKyAgICAg ICAgICAgICAgICBmb3IgKFJlbmRlckJsb2NrICpibGsgPSByZW5kZXJlci0+Y29udGFpbmluZ0Js b2NrKCk7IGJsayAmJiBibGstPmlzRGVzY2VuZGFudE9mKHJlcGFpbnRDb250YWluZXIpOyBibGsg PSBibGstPmNvbnRhaW5pbmdCbG9jaygpKSB7CisgICAgICAgICAgICAgICAgICAgIGlmICghYmxr LT5oYXNPdmVyZmxvd0NsaXAoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICAgICAgICAgICAgICBGbG9hdFF1YWQgYm91bmRRdWFkID0gYmxrLT5sb2NhbFRvQ29u dGFpbmVyUXVhZChGbG9hdFJlY3QoYmxrLT52aXN1YWxPdmVyZmxvd1JlY3QoKSksIHJlcGFpbnRD b250YWluZXIpOworICAgICAgICAgICAgICAgICAgICBpZiAoIWJvdW5kUXVhZC5pc1JlY3RpbGlu ZWFyKCkpIC8vIGRvbid0IGtub3cgaG93IHRvIGNsaXAgdGhpcy4gOigKKyAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBGbG9hdFJlY3QgYm91bmRS ZWN0ID0gYm91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAgICAgICAgICAgICAgIGNsaXBw ZWQuaW50ZXJzZWN0KGJvdW5kUmVjdCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAg ICAgIHF1YWQgPSBGbG9hdFF1YWQoY2xpcHBlZCk7CisgICAgICAgICAgICB9CisKKyAgICAgICAg ICAgIHBhdGgtPm1vdmVUbyhxdWFkLnAxKCkueCgpLCBxdWFkLnAxKCkueSgpKTsKKyAgICAgICAg ICAgIHBhdGgtPmxpbmVUbyhxdWFkLnAyKCkueCgpLCBxdWFkLnAyKCkueSgpKTsKKyAgICAgICAg ICAgIHBhdGgtPmxpbmVUbyhxdWFkLnAzKCkueCgpLCBxdWFkLnAzKCkueSgpKTsKKyAgICAgICAg ICAgIHBhdGgtPmxpbmVUbyhxdWFkLnA0KCkueCgpLCBxdWFkLnA0KCkueSgpKTsKKyAgICAgICAg ICAgIHBhdGgtPmNsb3NlKCk7CisgICAgICAgIH0KKyAgICB9Cit9CisKK05vZGUqIFdlYlZpZXdJ bXBsOjpjb21wdXRlQmVzdFRvdWNoVGFyZ2V0KGNvbnN0IEludFBvaW50JiBpbnB1dFBvaW50LCBj b25zdCBJbnRTaXplJiBwYWRkaW5nKQoreworICAgIEludFBvaW50IHBvaW50ID0gbV9wYWdlLT5t YWluRnJhbWUoKS0+dmlldygpLT53aW5kb3dUb0NvbnRlbnRzKGlucHV0UG9pbnQpOworICAgIEhp dFRlc3RSZXN1bHQgcmVzdWx0ID0gbV9wYWdlLT5tYWluRnJhbWUoKS0+ZXZlbnRIYW5kbGVyKCkt PmhpdFRlc3RSZXN1bHRBdFBvaW50KHBvaW50LAorICAgICAgICAgICAgZmFsc2UsIGZhbHNlLCBE b250SGl0VGVzdFNjcm9sbGJhcnMsIEhpdFRlc3RSZXF1ZXN0OjpBY3RpdmUgfCBIaXRUZXN0UmVx dWVzdDo6UmVhZE9ubHksCisgICAgICAgICAgICBwYWRkaW5nKTsKKworICAgIGZvciAoTm9kZSog bm9kZSA9IHJlc3VsdC5pbm5lck5vblNoYXJlZE5vZGUoKTsgbm9kZTsgbm9kZSA9IG5vZGUtPnBh cmVudE5vZGUoKSkgeworICAgICAgICBpZiAobm9kZS0+aXNEb2N1bWVudE5vZGUoKSB8fCBub2Rl LT5pc0ZyYW1lT3duZXJFbGVtZW50KCkpCisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAg aWYgKG5vZGUtPnN1cHBvcnRzRm9jdXMoKQorICAgICAgICAgfHwgbm9kZS0+aGFzRXZlbnRMaXN0 ZW5lcnMoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQpCisgICAgICAgICB8fCBub2RlLT5oYXNFdmVu dExpc3RlbmVycyhldmVudE5hbWVzKCkubW91c2Vkb3duRXZlbnQpCisgICAgICAgICB8fCBub2Rl LT5oYXNFdmVudExpc3RlbmVycyhldmVudE5hbWVzKCkubW91c2V1cEV2ZW50KSkKKyAgICAgICAg ICAgIHJldHVybiBub2RlOworICAgIH0KKworICAgIHJldHVybiAwOworfQorI2VuZGlmCisKIH0g Ly8gbmFtZXNwYWNlIFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvV2ViVmlld0ltcGwuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBs LmgKaW5kZXggOTM4M2JhMjhkOTYwOGJhMmRjNWQwYTdmZDI0MTdhODgyNGUwOTRkNy4uODcwMDJm NTE3ZTk3OGJjNDk5ZWYzNjdiNWQzZTgwMDNkZmEyMjQ2MCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBAIC01ODUsNiArNTg1LDEwIEBAIHByaXZhdGU6CiAgICAg dm9pZCBkb1BpeGVsUmVhZGJhY2tUb0NhbnZhcyhXZWJDYW52YXMqLCBjb25zdCBXZWJDb3JlOjpJ bnRSZWN0Jik7CiAgICAgdm9pZCByZWFsbG9jYXRlUmVuZGVyZXIoKTsKICAgICB2b2lkIHVwZGF0 ZUxheWVyVHJlZVZpZXdwb3J0KCk7CisKKyAgICBXZWJDb3JlOjpOb2RlKiBjb21wdXRlQmVzdFRv dWNoVGFyZ2V0KGNvbnN0IFdlYkNvcmU6OkludFBvaW50JiwgY29uc3QgV2ViQ29yZTo6SW50U2l6 ZSYgcGFkZGluZyk7CisgICAgdHlwZWRlZiBIYXNoTWFwPFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXIq LCBPd25QdHI8U2tQYXRoPiA+IEhpZ2hsaWdodE1hcDsKKyAgICB2b2lkIGNvbXB1dGVUb3VjaEhp Z2hsaWdodChIaWdobGlnaHRNYXAqLCBXZWJDb3JlOjpOb2RlKik7CiAjZW5kaWYKIAogI2lmIEVO QUJMRShHRVNUVVJFX0VWRU5UUykKQEAgLTc4NSw2ICs3ODksMTAgQEAgcHJpdmF0ZToKICAgICBX ZWJQb2ludCBtX2xhc3RXaGVlbFBvc2l0aW9uOwogICAgIFdlYlBvaW50IG1fbGFzdFdoZWVsR2xv YmFsUG9zaXRpb247CiAgICAgaW50IG1fZmxpbmdNb2RpZmllcjsKKworI2lmIDEgLy8gbG9jYWwg dGVzdCBvbmx5LCBzaG91bGQgbmV2ZXIgYmUgaW5jbHVkZWQgaW4gZmluYWwgQ0wKKyAgICBXZWJD b3JlOjpOb2RlKiBtX2hpZ2hsaWdodGVkTm9kZTsKKyNlbmRpZgogfTsKIAogfSAvLyBuYW1lc3Bh Y2UgV2ViS2l0Cg== 138956 2012-04-26 01:56:32 -0700 2012-04-26 01:56:32 -0700 A few basic test cases highlight.html text/html 1077 trchen PGh0bWw+CjxoZWFkPjx0aXRsZT50ZXN0PC90aXRsZT48L2hlYWQ+CjxhIGhyZWY9IiIgc3R5bGU9 ImJhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+SGVsbG8gPGRpdiBzdHlsZT0iZGlzcGxheTppbmxp bmUtYmxvY2s7cG9zaXRpb246cmVsYXRpdmU7dG9wOjUwcHg7bGVmdDo1MHB4O3dpZHRoOjEwMHB4 O2hlaWdodDoxMDBweDtiYWNrZ3JvdW5kLWNvbG9yOiNmZmNjY2MiPnBvc2l0aW9uZWQ8L2Rpdj4g bGluazwvYT48YnIvPjxici8+PGJyLz48YnIvPgo8YSBocmVmPSIiPkhlbGxvIDxkaXYgc3R5bGU9 ImRpc3BsYXk6aW5saW5lLWJsb2NrO3Bvc2l0aW9uOnJlbGF0aXZlO3RvcDo1MHB4O2xlZnQ6NTBw eDt3aWR0aDoxMDBweDtoZWlnaHQ6MTAwcHg7YmFja2dyb3VuZC1jb2xvcjojZmZjY2NjIj5wb3Np dGlvbmVkPC9kaXY+IGxpbms8L2E+PGJyLz48YnIvPjxici8+PGJyLz4KPGEgaHJlZj0iIiBzdHls ZT0iYmFja2dyb3VuZC1jb2xvcjojY2NmZmNjIj5IZWxsbwo8ZGl2IHN0eWxlPSJkaXNwbGF5Omlu bGluZS1ibG9jazt3aWR0aDoxMDBweDtoZWlnaHQ6MTAwcHg7YmFja2dyb3VuZC1jb2xvcjojZmZj Y2NjO292ZXJmbG93OmhpZGRlbiI+CjxkaXYgc3R5bGU9ImRpc3BsYXk6aW5saW5lLWJsb2NrO3Bv c2l0aW9uOmFic29sdXRlO3RvcDo1MDBweDtsZWZ0OjUwMHB4O3dpZHRoOjgwcHg7aGVpZ2h0Ojgw cHg7YmFja2dyb3VuZC1jb2xvcjojY2NjY2ZmIj48L2Rpdj4KPC9kaXY+IGxpbms8L2E+PGJyLz48 YnIvPjxici8+PGJyLz4KPGEgaHJlZj0iIiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjojY2NmZmNj Ij5IZWxsbwo8ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jazt3aWR0aDoxMDBweDtoZWln aHQ6MTAwcHg7YmFja2dyb3VuZC1jb2xvcjojZmZjY2NjO292ZXJmbG93OmhpZGRlbiI+CjxkaXYg c3R5bGU9ImRpc3BsYXk6aW5saW5lLWJsb2NrO3Bvc2l0aW9uOnJlbGF0aXZlO3RvcDo1MHB4O2xl ZnQ6NTBweDt3aWR0aDo4MHB4O2hlaWdodDo4MHB4O2JhY2tncm91bmQtY29sb3I6I2NjY2NmZiI+ PC9kaXY+CjwvZGl2PiBsaW5rPC9hPjxici8+PGJyLz48YnIvPjxici8+CjwvaHRtbD4K 139605 2012-05-01 03:31:41 -0700 2012-05-07 21:06:43 -0700 Patch bug-84936-20120501033138.patch text/plain 23471 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE1NTUyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZGEwYmVjNTlkY2Y3YTRj OGUyN2U0ZjQxNGRkN2VjMDQ2YWQ3MmZmNS4uNDY3NjNmNmEwZGYyYTk3MTJlNTJlNTM0MGRjMjU1 MjM2YzEzOWRlOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTA1LTAxICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIEFkZCBjb250YWluZXJR dWFkcyBjYWxsIHRvIFJlbmRlck9iamVjdCBhbmQgaXRzIHN1YmNsYXNzZXMuCisKKwlUaGUgY2Fs bCBpcyBzaW1pbGFyIHRvIGFic29sdXRlUXVhZHMsIGV4Y2VwdCB0aGF0IGl0IHJldHVybnMgdGhl CisgICAgICAgIHF1YWRzIGluIGNvb3JkaW5hdGVzIHJlbGF0aXZlIHRvIHRoZSBzcGVjaWZpZWQg cmVwYWludENvbnRhaW5lciBsYXllci4KKyAgICAgICAgY29udGFpbmVyUXVhZHMocXVhZHMsIDAp IHNob3VsZCBiZWhhdmUgdGhlIHNhbWUgYXMgYWJzb2x1dGVRdWFkcyhxdWFkcykuCisKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyQm94LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJv eDo6Y29udGFpbmVyUXVhZHMpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogcmVuZGVy aW5nL1JlbmRlckJveC5oOgorICAgICAgICAoUmVuZGVyQm94KToKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVySW5saW5lLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlcklubGluZTo6Y29u dGFpbmVyUXVhZHMpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5k ZXJJbmxpbmU6OmN1bGxlZElubGluZUNvbnRhaW5lclF1YWRzKToKKyAgICAgICAgKiByZW5kZXJp bmcvUmVuZGVySW5saW5lLmg6CisgICAgICAgIChSZW5kZXJJbmxpbmUpOgorICAgICAgICAqIHJl bmRlcmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisgICAgICAg IChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmNvbnRhaW5lclF1YWRzKToKKwogMjAxMi0wNC0yNyAg Sm9jaGVuIEVpc2luZ2VyICA8am9jaGVuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBFbnN1cmUg dGhhdCB0aGVyZSdzIGFsd2F5cyBhIHByb3Zpc2lvbmFsIGRvY3VtZW50IGxvYWRlciBpZiB0aGUg ZnJhbWUgbG9hZGVyIGlzIGluIHByb3Zpc2lvbmFsIHN0YXRlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCmluZGV4IDIyMjhiNDVmMjcwZDY1NWQxODY4OGYyMzIwMTJlMDdiN2Y3NjEwM2UuLmRiZGE1 N2ZmNDJlODQwZjdjZmQ5Yjk1ZDU3ZjY1NzUzMDA3YmZjYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTItMDUtMDEgIFRpZW4tUmVuIENoZW4gIDx0cmNo ZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQ29tcHV0ZSBoaWdobGlnaHQg Zm9yIHRvdWNoIHRhcmdldHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTg0OTM2CisKKyAgICAgICAgQWRkIFdlYkhpZ2hsaWdodCBjbGFzcyB3aGljaCBj YW4gYmUgdXNlZCB0byBkZXRlcm1pbmUKKyAgICAgICAgdGhlIGhpZ2hsaWdodCByZWdpb24gZm9y IHNwZWNpZmllZCB0b3VjaCB0YXJnZXQgbm9kZS4KKworCUl0IGlzIGRpZmZlcmVudCBmcm9tIFJl bmRlck9iamVjdDo6YWRkRm9jdXNSaW5nUmVjdHMgdGhhdAorICAgICAgICBpdCByZXR1cm5zIHF1 YWQgY29vcmRpbmF0ZXMgaW4gdGhlIFJlbmRlck9iamVjdCdzIHJlcGFpbnQKKyAgICAgICAgY29u dGFpbmVyIGxheWVyLiBJdCBpcyB1c2VmdWwgdG8gc3VwcG9ydCB0aHJlYWRlZC1hbmltYXRpb24v CisgICAgICAgIHNjcm9sbGluZyBpbiB0aGUgY29tcG9zaXRvci4KKworICAgICAgICAqIFdlYktp dC5neXA6CisgICAgICAgICogc3JjL1dlYkhpZ2hsaWdodC5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViSGlnaGxpZ2h0OjpXZWJIaWdobGlnaHQpOgor ICAgICAgICAqIHNyYy9XZWJIaWdobGlnaHQuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIaWdobGlnaHQpOgorICAgICAgICAoV2Vi S2l0OjpXZWJIaWdobGlnaHQ6OmNyZWF0ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hsaWdo dDo6YmVnaW4pOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHQ6OmVuZCk6CisgICAgICAg ICogc3JjL1dlYlZpZXdJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6Oldl YlZpZXdJbXBsKToKKyAgICAgICAgKFdlYktpdDo6V2ViVmlld0ltcGw6OmhhbmRsZUlucHV0RXZl bnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6Y29tcHV0ZUJlc3RUb3VjaFRhcmdl dCk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAqIHNyYy9XZWJWaWV3SW1wbC5oOgorCiAy MDEyLTA0LTI3ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTE1NTI5LgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQm94LmNwcAppbmRleCAzN2VjYTI4MGUyYzAzMDA1YTA1OTZkOGUxYmNjOTY4 Y2M5YmU0Y2YyLi5hMzhjY2YzZDJjZTcxMzI1YmFiOTQ5NTI4ZThjNTI0MWQ2MDVhYWY3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtNTQ3LDYgKzU0NywxMSBAQCB2 b2lkIFJlbmRlckJveDo6YWJzb2x1dGVRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIGJv b2wqIHdhc0ZpeGVkKSBjb25zdAogICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQWJzb2x1dGVRdWFk KEZsb2F0UmVjdCgwLCAwLCB3aWR0aCgpLCBoZWlnaHQoKSksIGZhbHNlLCB3YXNGaXhlZCkpOwog fQogCit2b2lkIFJlbmRlckJveDo6Y29udGFpbmVyUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mIHF1 YWRzLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciwgYm9vbCogd2FzRml4 ZWQpIGNvbnN0Cit7CisgICAgcXVhZHMuYXBwZW5kKGxvY2FsVG9Db250YWluZXJRdWFkKEZsb2F0 UmVjdCgwLCAwLCB3aWR0aCgpLCBoZWlnaHQoKSksIHJlcGFpbnRDb250YWluZXIsIGZhbHNlLCB3 YXNGaXhlZCkpOworfQorCiB2b2lkIFJlbmRlckJveDo6dXBkYXRlTGF5ZXJUcmFuc2Zvcm0oKQog ewogICAgIC8vIFRyYW5zZm9ybS1vcmlnaW4gZGVwZW5kcyBvbiBib3ggc2l6ZSwgc28gd2UgbmVl ZCB0byB1cGRhdGUgdGhlIGxheWVyIHRyYW5zZm9ybSBhZnRlciBsYXlvdXQuCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmggYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQm94LmgKaW5kZXggNzYxYmNmZTcyNTM3MDA1OTA4NGRkZjk3MmVhNDBl MmZhNzkzNGE0ZC4uNjdmZGNlYzU1ZTFlZDZhYzUwOTM0MzFhMjA3MjdmNjkyNDk4YjQ3ZiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guaApAQCAtMjU5LDYgKzI1OSw4IEBAIHB1Ymxp YzoKIAogICAgIHZpcnR1YWwgdm9pZCBhYnNvbHV0ZVJlY3RzKFZlY3RvcjxJbnRSZWN0PiYsIGNv bnN0IExheW91dFBvaW50JiBhY2N1bXVsYXRlZE9mZnNldCkgY29uc3Q7CiAgICAgdmlydHVhbCB2 b2lkIGFic29sdXRlUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBib29sKiB3YXNGaXhlZCkgY29u c3Q7CisKKyAgICB2aXJ0dWFsIHZvaWQgY29udGFpbmVyUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4m LCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciwgYm9vbCogd2FzRml4ZWQp IGNvbnN0OwogICAgIAogICAgIExheW91dFJlY3QgcmVmbGVjdGlvbkJveCgpIGNvbnN0OwogICAg IGludCByZWZsZWN0aW9uT2Zmc2V0KCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJJbmxpbmUuY3BwCmluZGV4IDVlODU2NWNmNzkxMjRjMmFiODdhNTRjYWI3NDU2MzExMTIx NDYyNDcuLjE3OWMwZWFiZjhjNjRhM2M4NjJiNDhmN2VkOTk2MGQwOTYzOGY2MjcgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwCkBAIC02NzgsNiArNjc4LDkwIEBA IHZvaWQgUmVuZGVySW5saW5lOjpjdWxsZWRJbmxpbmVBYnNvbHV0ZVF1YWRzKGNvbnN0IFJlbmRl cklubGluZSogY29udGFpbmVyLCBWZWN0CiAgICAgfQogfQogCit2b2lkIFJlbmRlcklubGluZTo6 Y29udGFpbmVyUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hNb2RlbE9i amVjdCogcmVwYWludENvbnRhaW5lciwgYm9vbCogd2FzRml4ZWQpIGNvbnN0Cit7CisgICAgaWYg KCFhbHdheXNDcmVhdGVMaW5lQm94ZXMoKSkKKyAgICAgICAgY3VsbGVkSW5saW5lQ29udGFpbmVy UXVhZHModGhpcywgcmVwYWludENvbnRhaW5lciwgcXVhZHMpOworICAgIGVsc2UgaWYgKElubGlu ZUZsb3dCb3gqIGN1cnIgPSBmaXJzdExpbmVCb3goKSkgeworICAgICAgICBmb3IgKDsgY3Vycjsg Y3VyciA9IGN1cnItPm5leHRMaW5lQm94KCkpIHsKKyAgICAgICAgICAgIEZsb2F0UmVjdCBsb2Nh bFJlY3QoY3Vyci0+eCgpLCBjdXJyLT55KCksIGN1cnItPndpZHRoKCksIGN1cnItPmhlaWdodCgp KTsKKyAgICAgICAgICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQ29udGFpbmVyUXVhZChsb2NhbFJl Y3QsIHJlcGFpbnRDb250YWluZXIsIGZhbHNlLCB3YXNGaXhlZCkpOworICAgICAgICB9CisgICAg fSBlbHNlCisgICAgICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJl Y3QoKSwgcmVwYWludENvbnRhaW5lciwgZmFsc2UsIHdhc0ZpeGVkKSk7CisKKyAgICBpZiAoY29u dGludWF0aW9uKCkpCisgICAgICAgIGNvbnRpbnVhdGlvbigpLT5jb250YWluZXJRdWFkcyhxdWFk cywgcmVwYWludENvbnRhaW5lciwgd2FzRml4ZWQpOworfQorCit2b2lkIFJlbmRlcklubGluZTo6 Y3VsbGVkSW5saW5lQ29udGFpbmVyUXVhZHMoY29uc3QgUmVuZGVySW5saW5lKiBjb250YWluZXIs IFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyLCBWZWN0b3I8RmxvYXRRdWFk PiYgcXVhZHMpIGNvbnN0Cit7CisgICAgaWYgKCFjdWxsZWRJbmxpbmVGaXJzdExpbmVCb3goKSkg eworICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KCks IHJlcGFpbnRDb250YWluZXIpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGJvb2wg aXNIb3Jpem9udGFsID0gc3R5bGUoKS0+aXNIb3Jpem9udGFsV3JpdGluZ01vZGUoKTsKKyAgICBm b3IgKFJlbmRlck9iamVjdCogY3VyciA9IGZpcnN0Q2hpbGQoKTsgY3VycjsgY3VyciA9IGN1cnIt Pm5leHRTaWJsaW5nKCkpIHsKKyAgICAgICAgaWYgKGN1cnItPmlzRmxvYXRpbmdPclBvc2l0aW9u ZWQoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIC8vIFdlIHdhbnQgdG8gZ2V0 IHRoZSBtYXJnaW4gYm94IGluIHRoZSBpbmxpbmUgZGlyZWN0aW9uLCBhbmQgdGhlbiB1c2Ugb3Vy IGZvbnQgYXNjZW50L2Rlc2NlbnQgaW4gdGhlIGJsb2NrCisgICAgICAgIC8vIGRpcmVjdGlvbiAo YWxpZ25lZCB0byB0aGUgcm9vdCBib3gncyBiYXNlbGluZSkuCisgICAgICAgIGlmIChjdXJyLT5p c0JveCgpKSB7CisgICAgICAgICAgICBSZW5kZXJCb3gqIGN1cnJCb3ggPSB0b1JlbmRlckJveChj dXJyKTsKKyAgICAgICAgICAgIGlmIChjdXJyQm94LT5pbmxpbmVCb3hXcmFwcGVyKCkpIHsKKyAg ICAgICAgICAgICAgICBSb290SW5saW5lQm94KiByb290Qm94ID0gY3VyckJveC0+aW5saW5lQm94 V3JhcHBlcigpLT5yb290KCk7CisgICAgICAgICAgICAgICAgaW50IGxvZ2ljYWxUb3AgPSByb290 Qm94LT5sb2dpY2FsVG9wKCkgKyAocm9vdEJveC0+cmVuZGVyZXIoKS0+c3R5bGUocm9vdEJveC0+ aXNGaXJzdExpbmVTdHlsZSgpKS0+Zm9udCgpLmZvbnRNZXRyaWNzKCkuYXNjZW50KCkgLSBjb250 YWluZXItPnN0eWxlKHJvb3RCb3gtPmlzRmlyc3RMaW5lU3R5bGUoKSktPmZvbnQoKS5mb250TWV0 cmljcygpLmFzY2VudCgpKTsKKyAgICAgICAgICAgICAgICBpbnQgbG9naWNhbEhlaWdodCA9IGNv bnRhaW5lci0+c3R5bGUocm9vdEJveC0+aXNGaXJzdExpbmVTdHlsZSgpKS0+Zm9udCgpLmZvbnRN ZXRyaWNzKCkuaGVpZ2h0KCk7CisgICAgICAgICAgICAgICAgRmxvYXRSZWN0IHJlc3VsdDsKKyAg ICAgICAgICAgICAgICBpZiAoaXNIb3Jpem9udGFsKQorICAgICAgICAgICAgICAgICAgICByZXN1 bHQgPSBGbG9hdFJlY3QoY3VyckJveC0+aW5saW5lQm94V3JhcHBlcigpLT54KCkgLSBjdXJyQm94 LT5tYXJnaW5MZWZ0KCksIGxvZ2ljYWxUb3AsIGN1cnJCb3gtPndpZHRoKCkgKyBjdXJyQm94LT5t YXJnaW5XaWR0aCgpLCBsb2dpY2FsSGVpZ2h0KTsKKyAgICAgICAgICAgICAgICBlbHNlCisgICAg ICAgICAgICAgICAgICAgIHJlc3VsdCA9IEZsb2F0UmVjdChsb2dpY2FsVG9wLCBjdXJyQm94LT5p bmxpbmVCb3hXcmFwcGVyKCktPnkoKSAtIGN1cnJCb3gtPm1hcmdpblRvcCgpLCBsb2dpY2FsSGVp Z2h0LCBjdXJyQm94LT5oZWlnaHQoKSArIGN1cnJCb3gtPm1hcmdpbkhlaWdodCgpKTsKKyAgICAg ICAgICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQocmVzdWx0LCByZXBh aW50Q29udGFpbmVyKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoY3Vyci0+ aXNSZW5kZXJJbmxpbmUoKSkgeworICAgICAgICAgICAgLy8gSWYgdGhlIGNoaWxkIGRvZXNuJ3Qg bmVlZCBsaW5lIGJveGVzIGVpdGhlciwgdGhlbiB3ZSBjYW4gcmVjdXIuCisgICAgICAgICAgICBS ZW5kZXJJbmxpbmUqIGN1cnJJbmxpbmUgPSB0b1JlbmRlcklubGluZShjdXJyKTsKKyAgICAgICAg ICAgIGlmICghY3VycklubGluZS0+YWx3YXlzQ3JlYXRlTGluZUJveGVzKCkpCisgICAgICAgICAg ICAgICAgY3VycklubGluZS0+Y3VsbGVkSW5saW5lQ29udGFpbmVyUXVhZHMoY29udGFpbmVyLCBy ZXBhaW50Q29udGFpbmVyLCBxdWFkcyk7CisgICAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAg ICAgICBmb3IgKElubGluZUZsb3dCb3gqIGNoaWxkTGluZSA9IGN1cnJJbmxpbmUtPmZpcnN0TGlu ZUJveCgpOyBjaGlsZExpbmU7IGNoaWxkTGluZSA9IGNoaWxkTGluZS0+bmV4dExpbmVCb3goKSkg eworICAgICAgICAgICAgICAgICAgICBSb290SW5saW5lQm94KiByb290Qm94ID0gY2hpbGRMaW5l LT5yb290KCk7CisgICAgICAgICAgICAgICAgICAgIGludCBsb2dpY2FsVG9wID0gcm9vdEJveC0+ bG9naWNhbFRvcCgpICsgKHJvb3RCb3gtPnJlbmRlcmVyKCktPnN0eWxlKHJvb3RCb3gtPmlzRmly c3RMaW5lU3R5bGUoKSktPmZvbnQoKS5mb250TWV0cmljcygpLmFzY2VudCgpIC0gY29udGFpbmVy LT5zdHlsZShyb290Qm94LT5pc0ZpcnN0TGluZVN0eWxlKCkpLT5mb250KCkuZm9udE1ldHJpY3Mo KS5hc2NlbnQoKSk7CisgICAgICAgICAgICAgICAgICAgIGludCBsb2dpY2FsSGVpZ2h0ID0gY29u dGFpbmVyLT5zdHlsZShyb290Qm94LT5pc0ZpcnN0TGluZVN0eWxlKCkpLT5mb250KCkuZm9udE1l dHJpY3MoKS5oZWlnaHQoKTsKKyAgICAgICAgICAgICAgICAgICAgRmxvYXRSZWN0IHJlc3VsdDsK KyAgICAgICAgICAgICAgICAgICAgaWYgKGlzSG9yaXpvbnRhbCkKKyAgICAgICAgICAgICAgICAg ICAgICAgIHJlc3VsdCA9IEZsb2F0UmVjdChjaGlsZExpbmUtPngoKSAtIGNoaWxkTGluZS0+bWFy Z2luTG9naWNhbExlZnQoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBsb2dpY2FsVG9w LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNoaWxkTGluZS0+bG9naWNhbFdpZHRoKCkg KyBjaGlsZExpbmUtPm1hcmdpbkxvZ2ljYWxMZWZ0KCkgKyBjaGlsZExpbmUtPm1hcmdpbkxvZ2lj YWxSaWdodCgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxvZ2ljYWxIZWlnaHQpOwor ICAgICAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICByZXN1bHQg PSBGbG9hdFJlY3QobG9naWNhbFRvcCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGls ZExpbmUtPnkoKSAtIGNoaWxkTGluZS0+bWFyZ2luTG9naWNhbExlZnQoKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICBsb2dpY2FsSGVpZ2h0LAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGNoaWxkTGluZS0+bG9naWNhbFdpZHRoKCkgKyBjaGlsZExpbmUtPm1hcmdpbkxvZ2ljYWxM ZWZ0KCkgKyBjaGlsZExpbmUtPm1hcmdpbkxvZ2ljYWxSaWdodCgpKTsKKyAgICAgICAgICAgICAg ICAgICAgcXVhZHMuYXBwZW5kKGxvY2FsVG9Db250YWluZXJRdWFkKHJlc3VsdCwgcmVwYWludENv bnRhaW5lcikpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgIH0KKyAgICAgICAgfSBl bHNlIGlmIChjdXJyLT5pc1RleHQoKSkgeworICAgICAgICAgICAgUmVuZGVyVGV4dCogY3VyclRl eHQgPSB0b1JlbmRlclRleHQoY3Vycik7CisgICAgICAgICAgICBmb3IgKElubGluZVRleHRCb3gq IGNoaWxkVGV4dCA9IGN1cnJUZXh0LT5maXJzdFRleHRCb3goKTsgY2hpbGRUZXh0OyBjaGlsZFRl eHQgPSBjaGlsZFRleHQtPm5leHRUZXh0Qm94KCkpIHsKKyAgICAgICAgICAgICAgICBSb290SW5s aW5lQm94KiByb290Qm94ID0gY2hpbGRUZXh0LT5yb290KCk7CisgICAgICAgICAgICAgICAgaW50 IGxvZ2ljYWxUb3AgPSByb290Qm94LT5sb2dpY2FsVG9wKCkgKyAocm9vdEJveC0+cmVuZGVyZXIo KS0+c3R5bGUocm9vdEJveC0+aXNGaXJzdExpbmVTdHlsZSgpKS0+Zm9udCgpLmZvbnRNZXRyaWNz KCkuYXNjZW50KCkgLSBjb250YWluZXItPnN0eWxlKHJvb3RCb3gtPmlzRmlyc3RMaW5lU3R5bGUo KSktPmZvbnQoKS5mb250TWV0cmljcygpLmFzY2VudCgpKTsKKyAgICAgICAgICAgICAgICBpbnQg bG9naWNhbEhlaWdodCA9IGNvbnRhaW5lci0+c3R5bGUocm9vdEJveC0+aXNGaXJzdExpbmVTdHls ZSgpKS0+Zm9udCgpLmZvbnRNZXRyaWNzKCkuaGVpZ2h0KCk7CisgICAgICAgICAgICAgICAgRmxv YXRSZWN0IHJlc3VsdDsKKyAgICAgICAgICAgICAgICBpZiAoaXNIb3Jpem9udGFsKQorICAgICAg ICAgICAgICAgICAgICByZXN1bHQgPSBGbG9hdFJlY3QoY2hpbGRUZXh0LT54KCksIGxvZ2ljYWxU b3AsIGNoaWxkVGV4dC0+bG9naWNhbFdpZHRoKCksIGxvZ2ljYWxIZWlnaHQpOworICAgICAgICAg ICAgICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgcmVzdWx0ID0gRmxvYXRSZWN0KGxvZ2lj YWxUb3AsIGNoaWxkVGV4dC0+eSgpLCBsb2dpY2FsSGVpZ2h0LCBjaGlsZFRleHQtPmxvZ2ljYWxX aWR0aCgpKTsKKyAgICAgICAgICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1 YWQocmVzdWx0LCByZXBhaW50Q29udGFpbmVyKSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0K KyAgICB9Cit9CisKIExheW91dFVuaXQgUmVuZGVySW5saW5lOjpvZmZzZXRMZWZ0KCkgY29uc3QK IHsKICAgICBMYXlvdXRVbml0IHggPSBSZW5kZXJCb3hNb2RlbE9iamVjdDo6b2Zmc2V0TGVmdCgp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCmluZGV4IGJhYThjNmI4NDJj NmIxNzQzYzliMTNhYzk5ZDUyOTRhMzY3NzhhMmMuLjVhNmFmYWEzOWVmNTMxMGQxMWM5YWYyZjQ2 YjY1ZTYwMWJkZjY4ZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJJbmxpbmUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmgK QEAgLTQ5LDYgKzQ5LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhYnNvbHV0ZVJlY3Rz KFZlY3RvcjxJbnRSZWN0PiYsIGNvbnN0IExheW91dFBvaW50JiBhY2N1bXVsYXRlZE9mZnNldCkg Y29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIGFic29sdXRlUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4m LCBib29sKiB3YXNGaXhlZCkgY29uc3Q7CiAKKyAgICB2aXJ0dWFsIHZvaWQgY29udGFpbmVyUXVh ZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRh aW5lciwgYm9vbCogd2FzRml4ZWQpIGNvbnN0OworCiAgICAgdmlydHVhbCBMYXlvdXRTaXplIG9m ZnNldEZyb21Db250YWluZXIoUmVuZGVyT2JqZWN0KiwgY29uc3QgTGF5b3V0UG9pbnQmKSBjb25z dDsKIAogICAgIEludFJlY3QgbGluZXNCb3VuZGluZ0JveCgpIGNvbnN0OwpAQCAtMTA1LDYgKzEw Nyw4IEBAIHByaXZhdGU6CiAgICAgdm9pZCBjdWxsZWRJbmxpbmVBYnNvbHV0ZVJlY3RzKGNvbnN0 IFJlbmRlcklubGluZSogY29udGFpbmVyLCBWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlvdXRT aXplJikgY29uc3Q7CiAgICAgdm9pZCBjdWxsZWRJbmxpbmVBYnNvbHV0ZVF1YWRzKGNvbnN0IFJl bmRlcklubGluZSogY29udGFpbmVyLCBWZWN0b3I8RmxvYXRRdWFkPiYpIGNvbnN0OwogCisgICAg dm9pZCBjdWxsZWRJbmxpbmVDb250YWluZXJRdWFkcyhjb25zdCBSZW5kZXJJbmxpbmUqIGNvbnRh aW5lciwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIsIFZlY3RvcjxGbG9h dFF1YWQ+JikgY29uc3Q7CisKICAgICB2b2lkIGFkZENoaWxkVG9Db250aW51YXRpb24oUmVuZGVy T2JqZWN0KiBuZXdDaGlsZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCk7CiAgICAgdmlydHVh bCB2b2lkIGFkZENoaWxkSWdub3JpbmdDb250aW51YXRpb24oUmVuZGVyT2JqZWN0KiBuZXdDaGls ZCwgUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCA9IDApOwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgKaW5kZXggOTliYzYzMmJjMjEzMzBjMDkzNWQ0OTE5ODUxMmEzYTMz Y2FiNDdiNi4uZWE3Y2Y2MWJhNzE3OWFkNWIzODQ2NGM2ZGNiNzk5MWNjZDcyMzA3MyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtNjkxLDYgKzY5MSw5IEBAIHB1 YmxpYzoKICAgICAvLyBCdWlsZCBhbiBhcnJheSBvZiBxdWFkcyBpbiBhYnNvbHV0ZSBjb29yZHMg Zm9yIGxpbmUgYm94ZXMKICAgICB2aXJ0dWFsIHZvaWQgYWJzb2x1dGVRdWFkcyhWZWN0b3I8Rmxv YXRRdWFkPiYsIGJvb2wqIC8qd2FzRml4ZWQqLyA9IDApIGNvbnN0IHsgfQogCisgICAgLy8gQnVp bGQgYW4gYXJyYXkgb2YgcXVhZHMgaW4gdGhlIGNvbnRhaW5lciBjb29yZHMKKyAgICB2aXJ0dWFs IHZvaWQgY29udGFpbmVyUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9i amVjdCogcmVwYWludENvbnRhaW5lciwgYm9vbCogLyp3YXNGaXhlZCovID0gMCkgY29uc3QgeyB9 CisKICAgICB2b2lkIGFic29sdXRlRm9jdXNSaW5nUXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mKTsK IAogICAgIC8vIHRoZSByZWN0IHRoYXQgd2lsbCBiZSBwYWludGVkIGlmIHRoaXMgb2JqZWN0IGlz IHBhc3NlZCBhcyB0aGUgcGFpbnRpbmdSb290CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL1dlYktpdC5neXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5k ZXggNDE2MmI5OGJiYmVkODc4OTdhZjY5YjdiMDhiNzcyZWViNzNjZjNmZS4uYTU5NmRkYjIwODNi NWJmZGEwZDRhZDJmYjQ2OGU2ZWVmMjg2YWJiZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cApAQCAtNTU2LDYgKzU1Niw4IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHZW9sb2NhdGlv blBvc2l0aW9uLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHbHlwaENhY2hlLmNwcCcs CiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHcmFwaGljc0NvbnRleHQzRC5jcHAnLAorICAgICAg ICAgICAgICAgICdzcmMvV2ViSGlnaGxpZ2h0LmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9X ZWJIaWdobGlnaHQuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJIaXN0b3J5SXRlbS5jcHAn LAogICAgICAgICAgICAgICAgICdzcmMvV2ViSGl0VGVzdFJlc3VsdC5jcHAnLAogICAgICAgICAg ICAgICAgICdzcmMvV2ViSWNvbkxvYWRpbmdDb21wbGV0aW9uSW1wbC5jcHAnLApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcCBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYzNkZTdhYjI2 YzRiOTc2OGNkYjkwMDVlNzhiYzZlZjE1N2Y3MWY2MQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAKQEAgLTAsMCArMSwxMDAgQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor ICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5j LiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUg d2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV VE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9X TkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK KyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCisK KyNpbmNsdWRlICJXZWJIaWdobGlnaHQuaCIKKworI2luY2x1ZGUgIk5vZGUuaCIKKyNpbmNsdWRl ICJQYXRoLmgiCisjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKKyNpbmNsdWRlICJSZW5kZXJMYXll ci5oIgorI2luY2x1ZGUgIlJlbmRlckxheWVyQmFja2luZy5oIgorCit1c2luZyBuYW1lc3BhY2Ug V2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK1dlYkhpZ2hsaWdodDo6V2ViSGlnaGxp Z2h0KE5vZGUqIHRvcE5vZGUpCit7CisgICAgaWYgKCF0b3BOb2RlKQorICAgICAgICByZXR1cm47 CisKKyAgICBmb3IgKE5vZGUgKm5vZGUgPSB0b3BOb2RlOyBub2RlOyBub2RlID0gbm9kZS0+dHJh dmVyc2VOZXh0Tm9kZSh0b3BOb2RlKSkgeworICAgICAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVy ID0gbm9kZS0+cmVuZGVyZXIoKTsKKyAgICAgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgICAg IGNvbnRpbnVlOworCisgICAgICAgIFJlbmRlckxheWVyKiByZXBhaW50TGF5ZXIgPSByZW5kZXJl ci0+ZW5jbG9zaW5nTGF5ZXIoKS0+ZW5jbG9zaW5nQ29tcG9zaXRpbmdMYXllckZvclJlcGFpbnQo KTsKKyAgICAgICAgaWYgKCFyZXBhaW50TGF5ZXIpIC8vIG1vc3QgbGlrZWx5IHdlJ3JlIG5vdCBp biBIVy1jb21wb3NpdG9yIG1vZGUuLi4gYmV0dGVyIGRldGVjdCB0aGlzIGVhcmx5IGFuZCBxdWl0 PworICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgUmVuZGVyQm94TW9kZWxPYmplY3Qq IHJlcGFpbnRDb250YWluZXIgPSByZXBhaW50TGF5ZXItPnJlbmRlcmVyKCk7CisKKyAgICAgICAg R3JhcGhpY3NMYXllciogZ3JhcGhpY3NMYXllciA9IHJlcGFpbnRMYXllci0+YmFja2luZygpLT5n cmFwaGljc0xheWVyKCk7CisgICAgICAgIFBhdGgqIHBhdGggPSBtX3F1YWRNYXAuZ2V0KGdyYXBo aWNzTGF5ZXIpOworICAgICAgICBpZiAoIXBhdGgpCisgICAgICAgICAgICBtX3F1YWRNYXAuc2V0 KGdyYXBoaWNzTGF5ZXIsIGFkb3B0UHRyKHBhdGggPSBuZXcgUGF0aCgpKSk7CisKKyAgICAgICAg VmVjdG9yPEZsb2F0UXVhZD4gbmV3cXVhZHM7CisgICAgICAgIHJlbmRlcmVyLT5jb250YWluZXJR dWFkcyhuZXdxdWFkcywgcmVwYWludENvbnRhaW5lcik7CisKKyAgICAgICAgZm9yIChzaXplX3Qg aSA9IDA7IGkgPCBuZXdxdWFkcy5zaXplKCk7IGkrKykgeworICAgICAgICAgICAgRmxvYXRRdWFk IHF1YWQgPSBuZXdxdWFkc1tpXTsKKworICAgICAgICAgICAgaWYgKHF1YWQuaXNSZWN0aWxpbmVh cigpKSB7CisgICAgICAgICAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJvdW5kaW5n Qm94KCk7CisKKyAgICAgICAgICAgICAgICBmb3IgKFJlbmRlckJsb2NrICpibGsgPSByZW5kZXJl ci0+Y29udGFpbmluZ0Jsb2NrKCk7IGJsayAmJiBibGstPmlzRGVzY2VuZGFudE9mKHJlcGFpbnRD b250YWluZXIpOyBibGsgPSBibGstPmNvbnRhaW5pbmdCbG9jaygpKSB7CisgICAgICAgICAgICAg ICAgICAgIGlmICghYmxrLT5oYXNPdmVyZmxvd0NsaXAoKSkKKyAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBGbG9hdFF1YWQgYm91bmRRdWFkID0g YmxrLT5sb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoYmxrLT52aXN1YWxPdmVyZmxvd1Jl Y3QoKSksIHJlcGFpbnRDb250YWluZXIpOworICAgICAgICAgICAgICAgICAgICBpZiAoIWJvdW5k UXVhZC5pc1JlY3RpbGluZWFyKCkpIC8vIGRvbid0IGtub3cgaG93IHRvIGNsaXAgdGhpcy4gOigK KyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBG bG9hdFJlY3QgYm91bmRSZWN0ID0gYm91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAgICAg ICAgICAgICAgIGNsaXBwZWQuaW50ZXJzZWN0KGJvdW5kUmVjdCk7CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICAgIHF1YWQgPSBGbG9hdFF1YWQoY2xpcHBlZCk7CisgICAgICAgICAg ICB9CisKKyAgICAgICAgICAgIHBhdGgtPm1vdmVUbyhxdWFkLnAxKCkpOworICAgICAgICAgICAg cGF0aC0+YWRkTGluZVRvKHF1YWQucDIoKSk7CisgICAgICAgICAgICBwYXRoLT5hZGRMaW5lVG8o cXVhZC5wMygpKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZExpbmVUbyhxdWFkLnA0KCkpOworICAg ICAgICAgICAgcGF0aC0+Y2xvc2VTdWJwYXRoKCk7CisgICAgICAgIH0KKyAgICB9Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViSGlnaGxpZ2h0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDk4NmUyNDdhNGM2MzQ0MmUxODQ2MTJiMGRkNGJi MmM3OGZjY2U3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1dlYkhpZ2hsaWdodC5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog ICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90 aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAg ICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cwor ICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0 cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3 cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBU SEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5Z IEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJ TUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBG SVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5P IEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwg RVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAor ICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFks IFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNM VURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYkhpZ2hsaWdodF9oCisj ZGVmaW5lIFdlYkhpZ2hsaWdodF9oCisKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcp CisKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIuaD4KKyNp bmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CitjbGFzcyBH cmFwaGljc0xheWVyOworY2xhc3MgTm9kZTsKK2NsYXNzIFBhdGg7Cit9CisKK25hbWVzcGFjZSBX ZWJLaXQgeworCitjbGFzcyBXZWJIaWdobGlnaHQgeworcHVibGljOgorICAgIHN0YXRpYyBpbmxp bmUgUGFzc093blB0cjxXZWJIaWdobGlnaHQ+IGNyZWF0ZShXZWJDb3JlOjpOb2RlKiBub2RlKSB7 IHJldHVybiBhZG9wdFB0cihuZXcgV2ViSGlnaGxpZ2h0KG5vZGUpKTsgfQorCisgICAgdHlwZWRl ZiBIYXNoTWFwPFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXIqLCBPd25QdHI8V2ViQ29yZTo6UGF0aD4g PiBRdWFkTWFwOworICAgIHR5cGVkZWYgUXVhZE1hcDo6aXRlcmF0b3IgaXRlcmF0b3I7CisKKyAg ICBpbmxpbmUgaXRlcmF0b3IgYmVnaW4oKSB7IHJldHVybiBtX3F1YWRNYXAuYmVnaW4oKTsgfQor ICAgIGlubGluZSBpdGVyYXRvciBlbmQoKSB7IHJldHVybiBtX3F1YWRNYXAuZW5kKCk7IH0KK3By aXZhdGU6CisgICAgZXhwbGljaXQgV2ViSGlnaGxpZ2h0KFdlYkNvcmU6Ok5vZGUqKTsKKyAgICBR dWFkTWFwIG1fcXVhZE1hcDsKK307CisKK30KKworI2VuZGlmCisKKyNlbmRpZgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IGY3NDgxMDQ0Mzg4NDk1Yjg3 ZjM4MGI1YjhkZjZjOWM5Yzk1YjM1N2UuLmRlNGI5NjM0YTliNjYzZmQ4YTc1ODI3ZmE4NjIzZTA1 OTA4MGE2OWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJ bXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAK QEAgLTE2NSw2ICsxNjUsMTAgQEAKICNpbmNsdWRlICJQbGF0Zm9ybUdlc3R1cmVFdmVudC5oIgog I2VuZGlmCiAKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCisjaW5jbHVkZSA8V2Vi SGlnaGxpZ2h0Lmg+CisjZW5kaWYKKwogI2lmIFVTRShDRykKICNpbmNsdWRlIDxDb3JlR3JhcGhp Y3MvQ0dCaXRtYXBDb250ZXh0Lmg+CiAjaW5jbHVkZSA8Q29yZUdyYXBoaWNzL0NHQ29udGV4dC5o PgpAQCAtMzk5LDYgKzQwMyw5IEBAIFdlYlZpZXdJbXBsOjpXZWJWaWV3SW1wbChXZWJWaWV3Q2xp ZW50KiBjbGllbnQpCiAgICAgLCBtX3VzZXJNZWRpYUNsaWVudEltcGwodGhpcykKICNlbmRpZgog ICAgICwgbV9mbGluZ01vZGlmaWVyKDApCisjaWYgMSAvLyBsb2NhbCB0ZXN0IG9ubHksIHNob3Vs ZCBuZXZlciBiZSBpbmNsdWRlZCBpbiBmaW5hbCBDTAorICAgICwgbV9oaWdobGlnaHRlZE5vZGUo MCkKKyNlbmRpZgogewogICAgIC8vIFdlYktpdC93aW4vV2ViVmlldy5jcHAgZG9lcyB0aGUgc2Ft ZSB0aGluZywgZXhjZXB0IHRoZXkgY2FsbCB0aGUKICAgICAvLyBLSlMgc3BlY2lmaWMgd3JhcHBl ciBhcm91bmQgdGhpcyBtZXRob2QuIFdlIG5lZWQgdG8gaGF2ZSB0aHJlYWRpbmcKQEAgLTE2NjAs NiArMTY2NywyMSBAQCBib29sIFdlYlZpZXdJbXBsOjpoYW5kbGVJbnB1dEV2ZW50KGNvbnN0IFdl YklucHV0RXZlbnQmIGlucHV0RXZlbnQpCiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIAor I2lmIDEgLy8gbG9jYWwgdGVzdCBvbmx5LCBzaG91bGQgbmV2ZXIgYmUgaW5jbHVkZWQgaW4gZmlu YWwgQ0wKKyAgICBpZiAoaW5wdXRFdmVudC50eXBlID09IFdlYklucHV0RXZlbnQ6Ok1vdXNlTW92 ZSkgeworICAgICAgICBjb25zdCBXZWJNb3VzZUV2ZW50KiBldmVudCA9IHN0YXRpY19jYXN0PGNv bnN0IFdlYk1vdXNlRXZlbnQqPigmaW5wdXRFdmVudCk7CisgICAgICAgIE5vZGUqIG5vZGUgPSBj b21wdXRlQmVzdFRvdWNoVGFyZ2V0KEludFBvaW50KGV2ZW50LT54LCBldmVudC0+eSksIEludFNp emUoMTAsIDEwKSk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUgIT0gbV9oaWdobGlnaHRlZE5v ZGUpIHsKKyAgICAgICAgICAgIGZwcmludGYoc3RkZXJyLCAiYmVzdFRvdWNoVGFyZ2V0OiAlMDhs eFxuIiwgKGxvbmcpbm9kZSk7CisgICAgICAgICAgICBub2RlLT5zaG93VHJlZUZvclRoaXMoKTsK KyAgICAgICAgICAgIGlmIChub2RlLT5yZW5kZXJlcigpKQorICAgICAgICAgICAgICAgIG5vZGUt PnJlbmRlcmVyKCktPnNob3dSZW5kZXJUcmVlRm9yVGhpcygpOworICAgICAgICAgICAgT3duUHRy PFdlYkhpZ2hsaWdodD4gaGlnaGxpZ2h0ID0gV2ViSGlnaGxpZ2h0OjpjcmVhdGUobm9kZSk7Cisg ICAgICAgICAgICBtX2hpZ2hsaWdodGVkTm9kZSA9IG5vZGU7CisgICAgICAgIH0KKyAgICB9Cisj ZW5kaWYKKwogICAgIGJvb2wgaGFuZGxlZCA9IFBhZ2VXaWRnZXREZWxlZ2F0ZTo6aGFuZGxlSW5w dXRFdmVudChtX3BhZ2UuZ2V0KCksICp0aGlzLCBpbnB1dEV2ZW50KTsKICAgICBtX2N1cnJlbnRJ bnB1dEV2ZW50ID0gMDsKICAgICByZXR1cm4gaGFuZGxlZDsKQEAgLTM1MTMsNCArMzUzNSwyNCBA QCB2b2lkIFdlYlZpZXdJbXBsOjpwb2ludGVyTG9ja01vdXNlRXZlbnQoY29uc3QgV2ViSW5wdXRF dmVudCYgZXZlbnQpCiB9CiAjZW5kaWYKIAorTm9kZSogV2ViVmlld0ltcGw6OmNvbXB1dGVCZXN0 VG91Y2hUYXJnZXQoY29uc3QgSW50UG9pbnQmIGlucHV0UG9pbnQsIGNvbnN0IEludFNpemUmIHBh ZGRpbmcpCit7CisgICAgSW50UG9pbnQgcG9pbnQgPSBtX3BhZ2UtPm1haW5GcmFtZSgpLT52aWV3 KCktPndpbmRvd1RvQ29udGVudHMoaW5wdXRQb2ludCk7CisgICAgSGl0VGVzdFJlc3VsdCByZXN1 bHQgPSBtX3BhZ2UtPm1haW5GcmFtZSgpLT5ldmVudEhhbmRsZXIoKS0+aGl0VGVzdFJlc3VsdEF0 UG9pbnQocG9pbnQsCisgICAgICAgICAgICBmYWxzZSwgZmFsc2UsIERvbnRIaXRUZXN0U2Nyb2xs YmFycywgSGl0VGVzdFJlcXVlc3Q6OkFjdGl2ZSB8IEhpdFRlc3RSZXF1ZXN0OjpSZWFkT25seSwK KyAgICAgICAgICAgIHBhZGRpbmcpOworCisgICAgZm9yIChOb2RlKiBub2RlID0gcmVzdWx0Lmlu bmVyTm9uU2hhcmVkTm9kZSgpOyBub2RlOyBub2RlID0gbm9kZS0+cGFyZW50Tm9kZSgpKSB7Cisg ICAgICAgIGlmIChub2RlLT5pc0RvY3VtZW50Tm9kZSgpIHx8IG5vZGUtPmlzRnJhbWVPd25lckVs ZW1lbnQoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBpZiAobm9kZS0+c3VwcG9y dHNGb2N1cygpCisgICAgICAgICB8fCBub2RlLT5oYXNFdmVudExpc3RlbmVycyhldmVudE5hbWVz KCkuY2xpY2tFdmVudCkKKyAgICAgICAgIHx8IG5vZGUtPmhhc0V2ZW50TGlzdGVuZXJzKGV2ZW50 TmFtZXMoKS5tb3VzZWRvd25FdmVudCkKKyAgICAgICAgIHx8IG5vZGUtPmhhc0V2ZW50TGlzdGVu ZXJzKGV2ZW50TmFtZXMoKS5tb3VzZXVwRXZlbnQpKQorICAgICAgICAgICAgcmV0dXJuIG5vZGU7 CisgICAgfQorCisgICAgcmV0dXJuIDA7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYktpdApkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuaCBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmgKaW5kZXggOTM4M2JhMjhkOTYwOGJh MmRjNWQwYTdmZDI0MTdhODgyNGUwOTRkNy4uYzRmMDk5NzZjYjQ4ZTU0NjA2Y2I2YTg3YmMzZDI4 YTlkNjFkMDlhYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmll d0ltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5oCkBA IC01NzksNiArNTc5LDggQEAgcHJpdmF0ZToKIAogICAgIHZvaWQgY29uZmlndXJlQXV0b1Jlc2l6 ZU1vZGUoKTsKIAorICAgIFdlYkNvcmU6Ok5vZGUqIGNvbXB1dGVCZXN0VG91Y2hUYXJnZXQoY29u c3QgV2ViQ29yZTo6SW50UG9pbnQmLCBjb25zdCBXZWJDb3JlOjpJbnRTaXplJiBwYWRkaW5nKTsK KwogI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKICAgICB2b2lkIHNldElzQWNjZWxl cmF0ZWRDb21wb3NpdGluZ0FjdGl2ZShib29sKTsKICAgICB2b2lkIGRvQ29tcG9zaXRlKCk7CkBA IC03ODUsNiArNzg3LDEwIEBAIHByaXZhdGU6CiAgICAgV2ViUG9pbnQgbV9sYXN0V2hlZWxQb3Np dGlvbjsKICAgICBXZWJQb2ludCBtX2xhc3RXaGVlbEdsb2JhbFBvc2l0aW9uOwogICAgIGludCBt X2ZsaW5nTW9kaWZpZXI7CisKKyNpZiAxIC8vIGxvY2FsIHRlc3Qgb25seSwgc2hvdWxkIG5ldmVy IGJlIGluY2x1ZGVkIGluIGZpbmFsIENMCisgICAgV2ViQ29yZTo6Tm9kZSogbV9oaWdobGlnaHRl ZE5vZGU7CisjZW5kaWYKIH07CiAKIH0gLy8gbmFtZXNwYWNlIFdlYktpdAo= 140662 2012-05-07 21:06:50 -0700 2012-05-10 19:39:45 -0700 Patch bug-84936-20120507210649.patch text/plain 16298 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2MzU0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjEyY2Q3ODU2NGE3ODlm NmY0NzRmMGVkZDBkOTlmZWY2NDE5YzgwNC4uOWU5ZWE3NTI3N2MyNmEwYTJjM2NkYzA1ZDAwZmYx NTVjM2IwNmVlYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTA1LTA3ICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRk cyBSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyBjYWxsLAorICAg ICAgICB0byBnZW5lcmF0ZSB0aGUgY2xpY2thYmxlIHJlZ2lvbiBmb3IgbGluayBoaWdobGlnaHRp bmcuCisKKyAgICAgICAgT25lIGltcG9ydGFudCBkaWZmZXJlbmNlIGZyb20gUmVuZGVyT2JqZWN0 OjphYnNvbHV0ZVF1YWRzIGlzIHRoYXQKKyAgICAgICAgdGhlIHJldHVybmVkIHF1YWRzIHdpbGwg YmUgaW4gdGhlIGNvb3JkaW5hdGVzIG9mIGEgcmVwYWludCBjb250YWluZXIKKyAgICAgICAgc3Bl Y2lmaWVkIGJ5IHRoZSBjYWxsZXIuIFRoaXMgd2lsbCBhbGxvdyB0aHJlYWRlZC1zY3JvbGxpbmcv YW5pbWF0aW9uCisgICAgICAgIHdpdGhvdXQgaGF2aW5nIHRvIHJlZ2VuZXJhdGUgdGhlIGhpZ2hs aWdodHMuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwOgorICAgICAgICAo V2ViQ29yZTo6UmVuZGVyQmxvY2s6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyk6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suaDoKKyAg ICAgICAgKFJlbmRlckJsb2NrKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJveDo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1 YWRzKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3gu aDoKKyAgICAgICAgKFJlbmRlckJveCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGlu ZS5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlcklubGlu ZTo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKToKKyAgICAgICAgKiByZW5kZXJpbmcv UmVuZGVySW5saW5lLmg6CisgICAgICAgIChSZW5kZXJJbmxpbmUpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6cmVw YWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKToKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisK IDIwMTItMDUtMDUgIFRpZW4tUmVuIENoZW4gIDx0cmNoZW5AY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIEVsaW1pbmF0ZSBkdXBsaWNhdGVkIGNvZGUgZm9yIGN1bGxlZCBsaW5lIGJveCBpbiBSZW5k ZXJJbmxpbmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMzc0Y2ZiOTk0YmU1NTlkMDE3 OWY0ZDhjOTFlMWUxMTJhMDY2OTY3NS4uNWZkZmZhYzlkNWFiYzM3OGRkMTNlNjczNWQ1OGMxNmE2 MmY5M2I3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAx Mi0wNS0wNyAgVGllbi1SZW4gQ2hlbiAgPHRyY2hlbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg W2Nocm9taXVtXSBDb21wdXRlIGhpZ2hsaWdodCBmb3IgdG91Y2ggdGFyZ2V0cworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODQ5MzYKKworICAgICAgICBB ZGQgV2ViSGlnaGxpZ2h0IGNsYXNzIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGRldGVybWluZQorICAg ICAgICB0aGUgaGlnaGxpZ2h0IHJlZ2lvbiBmb3Igc3BlY2lmaWVkIHRvdWNoIHRhcmdldCBub2Rl LgorCisgICAgICAgICogV2ViS2l0Lmd5cDoKKyAgICAgICAgKiBzcmMvV2ViSGlnaGxpZ2h0LmNw cDogQWRkZWQuCisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGln aHQ6OldlYkhpZ2hsaWdodCk6CisgICAgICAgICogc3JjL1dlYkhpZ2hsaWdodC5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYkhpZ2hs aWdodCk6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hsaWdodDo6Y3JlYXRlKToKKyAgICAgICAg KFdlYktpdDo6V2ViSGlnaGxpZ2h0OjpiZWdpbik6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hs aWdodDo6ZW5kKToKKwogMjAxMi0wNS0wNyAgRGF2aWQgUmV2ZW1hbiAgPHJldmVtYW5AY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFtDaHJvbWl1bV0gVXNlIEdMX0NIUk9NSVVNX2NvbW1hbmRfYnVm ZmVyX3F1ZXJ5IHRvIHRocm90dGxlIHRleHR1cmUgdXBsb2Fkcy4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQmxvY2suY3BwCmluZGV4IDM0OWI0M2MzYjNhMjczZmE3NzQzNWUwMDllMWQ1 ZWNmYzI0MDc5ODcuLjVhM2VlZmExMDU1YTU4YTM5Y2IwODg0ZjU5NmJjY2ZkOTc3NTUyMzcgMTAw NzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtNjUxOCw2ICs2NTE4 LDE0IEBAIHZvaWQgUmVuZGVyQmxvY2s6OmFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0 PiYgcmVjdHMsIGNvbnN0IExheW91dFBvaW50JiBhCiAgICAgICAgIGlubGluZUVsZW1lbnRDb250 aW51YXRpb24oKS0+YWRkRm9jdXNSaW5nUmVjdHMocmVjdHMsIGZsb29yZWRMYXlvdXRQb2ludChh ZGRpdGlvbmFsT2Zmc2V0ICsgaW5saW5lRWxlbWVudENvbnRpbnVhdGlvbigpLT5jb250YWluaW5n QmxvY2soKS0+bG9jYXRpb24oKSAtIGxvY2F0aW9uKCkpKTsKIH0KIAordm9pZCBSZW5kZXJCbG9j azo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFk cywgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAg UmVuZGVyQm94OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMocXVhZHMsIHJlcGFpbnRD b250YWluZXIpOworCisgICAgaWYgKGNvbnRpbnVhdGlvbigpKQorICAgICAgICBjb250aW51YXRp b24oKS0+cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKHF1YWRzLCByZXBhaW50Q29udGFp bmVyKTsKK30KKwogUmVuZGVyQm94KiBSZW5kZXJCbG9jazo6Y3JlYXRlQW5vbnltb3VzQm94V2l0 aFNhbWVUeXBlQXMoY29uc3QgUmVuZGVyT2JqZWN0KiBwYXJlbnQpIGNvbnN0CiB7CiAgICAgaWYg KGlzQW5vbnltb3VzQ29sdW1uc0Jsb2NrKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQmxvY2suaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC bG9jay5oCmluZGV4IDM4NTk0NDJiZWMwZmZiOTA5NGNhNjU1NDBmZmM2ZDg4NjZhZTJjMTAuLmZj OTBiYzQ1YmY3NGFhOWI1NGM4YmU1OTM0ODBiNDk1YTc0MTAwNjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCbG9jay5oCkBAIC00NDcsNiArNDQ3LDggQEAgcHJvdGVjdGVkOgogCiAg ICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0PiYsIGNvbnN0 IExheW91dFBvaW50Jik7CiAKKyAgICB2aXJ0dWFsIHZvaWQgcmVwYWludENvbnRhaW5lckhpZ2hs aWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFp bnRDb250YWluZXIpIGNvbnN0OworCiAjaWYgRU5BQkxFKFNWRykKICAgICAvLyBPbmx5IHVzZWQg YnkgUmVuZGVyU1ZHVGV4dCwgd2hpY2ggZXhwbGljaXRlbHkgb3ZlcnJpZGVzIFJlbmRlckJsb2Nr OjpsYXlvdXRCbG9jaygpLCBkbyBOT1QgdXNlIGZvciBhbnl0aGluZyBlbHNlLgogICAgIHZvaWQg Zm9yY2VMYXlvdXRJbmxpbmVDaGlsZHJlbigpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQm94LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC b3guY3BwCmluZGV4IGI5MDZlYzk0ZDkyNDc1ZGFmN2E0MjU0Y2MwMjg4MzQ4YWQ5YjhhOGYuLmYz ZWE4Njg3NGNiM2UxYjI4ZGFlNmUwZmMxOWYzMjI2ODFkMjgwNmMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCb3guY3BwCkBAIC01OTYsNiArNTk2LDEyIEBAIHZvaWQgUmVuZGVyQm94 OjphZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mIHJlY3RzLCBjb25zdCBMYXlvdXRQ b2ludCYgYWRkCiAgICAgICAgIHJlY3RzLmFwcGVuZChwaXhlbFNuYXBwZWRJbnRSZWN0KGFkZGl0 aW9uYWxPZmZzZXQsIHNpemUoKSkpOwogfQogCit2b2lkIFJlbmRlckJveDo6cmVwYWludENvbnRh aW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9k ZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAgaWYgKCFzaXplKCkuaXNF bXB0eSgpKQorICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRS ZWN0KDAsIDAsIHdpZHRoKCksIGhlaWdodCgpKSwgcmVwYWludENvbnRhaW5lciwgZmFsc2UsIDAp KTsKK30KKwogTGF5b3V0UmVjdCBSZW5kZXJCb3g6OnJlZmxlY3Rpb25Cb3goKSBjb25zdAogewog ICAgIExheW91dFJlY3QgcmVzdWx0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlckJveC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5oCmlu ZGV4IDc5NGVkMzllMmM3NGRhZDQ1NWVhODUyZjE2NzQ4MTA5NjQxOWU1YjUuLmRmYWZkNWM1MmVl OWZiN2FjOTVjODRhNTUzY2M4MzUyYzc5NDM5MDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJCb3guaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQm94LmgKQEAgLTE0OSw2ICsxNDksOCBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBMYXlvdXRS ZWN0IG91dGxpbmVCb3VuZHNGb3JSZXBhaW50KFJlbmRlckJveE1vZGVsT2JqZWN0KiAvKnJlcGFp bnRDb250YWluZXIqLywgTGF5b3V0UG9pbnQqIGNhY2hlZE9mZnNldFRvUmVwYWludENvbnRhaW5l cikgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRS ZWN0PiYsIGNvbnN0IExheW91dFBvaW50Jik7CiAKKyAgICB2aXJ0dWFsIHZvaWQgcmVwYWludENv bnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxP YmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0OworCiAgICAgLy8gVXNlIHRoaXMgd2l0aCBj YXV0aW9uISBObyB0eXBlIGNoZWNraW5nIGlzIGRvbmUhCiAgICAgUmVuZGVyQm94KiBwcmV2aW91 c1NpYmxpbmdCb3goKSBjb25zdDsKICAgICBSZW5kZXJCb3gqIG5leHRTaWJsaW5nQm94KCkgY29u c3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNw cCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwCmluZGV4IDlmMWUz MmNjNDdhN2IwOTVhMzAwZWFhYmQzMDZiODg5ZjAxYTk5OWYuLjFiM2Q4OTE2Zjc1ZjFjMTFhZjg2 ZjNmNmQ1ZmM1NWM2ZmQwOGVlOTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJJbmxpbmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJ bmxpbmUuY3BwCkBAIC0xNDY5LDYgKzE0NjksMzUgQEAgdm9pZCBSZW5kZXJJbmxpbmU6OnBhaW50 T3V0bGluZUZvckxpbmUoR3JhcGhpY3NDb250ZXh0KiBncmFwaGljc0NvbnRleHQsIGNvbnN0IEwK ICAgICAgICAgICAgIGFudGlhbGlhcyk7CiB9CiAKK25hbWVzcGFjZSB7CisKK2NsYXNzIFJlcGFp bnRDb250YWluZXJIaWdobGlnaHRRdWFkc0dlbmVyYXRvckNvbnRleHQgeworcHVibGljOgorICAg IFJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkc0dlbmVyYXRvckNvbnRleHQoY29uc3QgUmVu ZGVySW5saW5lKiByZW5kZXJlciwgVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hN b2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikKKyAgICAgICAgOiBtX3JlbmRlcmVyKHJlbmRl cmVyKQorICAgICAgICAsIG1fcXVhZHMocXVhZHMpCisgICAgICAgICwgbV9yZXBhaW50Q29udGFp bmVyKHJlcGFpbnRDb250YWluZXIpIHsgfQorCisgICAgdm9pZCBvcGVyYXRvcigpKGNvbnN0IEZs b2F0UmVjdCYgcmVjdCkKKyAgICB7CisgICAgICAgIG1fcXVhZHMuYXBwZW5kKG1fcmVuZGVyZXIt PmxvY2FsVG9Db250YWluZXJRdWFkKHJlY3QsIG1fcmVwYWludENvbnRhaW5lcikpOworICAgIH0K K3ByaXZhdGU6CisgICAgY29uc3QgUmVuZGVySW5saW5lKiBtX3JlbmRlcmVyOworICAgIFZlY3Rv cjxGbG9hdFF1YWQ+JiBtX3F1YWRzOworICAgIFJlbmRlckJveE1vZGVsT2JqZWN0KiBtX3JlcGFp bnRDb250YWluZXI7Cit9OworCit9IC8vIHVubmFtZWQgbmFtZXNwYWNlCisKK3ZvaWQgUmVuZGVy SW5saW5lOjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4m IHF1YWRzLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QKK3sK KyAgICBnZW5lcmF0ZUxpbmVCb3hSZWN0cyhSZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHNH ZW5lcmF0b3JDb250ZXh0KHRoaXMsIHF1YWRzLCByZXBhaW50Q29udGFpbmVyKSk7CisKKyAgICBp ZiAoY29udGludWF0aW9uKCkpCisgICAgICAgIGNvbnRpbnVhdGlvbigpLT5yZXBhaW50Q29udGFp bmVySGlnaGxpZ2h0UXVhZHMocXVhZHMsIHJlcGFpbnRDb250YWluZXIpOworfQorCiAjaWYgRU5B QkxFKERBU0hCT0FSRF9TVVBQT1JUKQogdm9pZCBSZW5kZXJJbmxpbmU6OmFkZERhc2hib2FyZFJl Z2lvbnMoVmVjdG9yPERhc2hib2FyZFJlZ2lvblZhbHVlPiYgcmVnaW9ucykKIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaCBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaAppbmRleCBjMTUzMmNmNTY4ZmI0NWViYjRmMzE0 NzdkN2FmMmJjMjViZjViNmI3Li41MDYxNDcyOGUxOWJiZGY4MjllMDg5MjA4ZDg5ZDhhNzkwMWRk YzExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCkBAIC03Niw2ICs3 Niw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWRkRm9jdXNSaW5nUmVjdHMoVmVjdG9y PEludFJlY3Q+JiwgY29uc3QgTGF5b3V0UG9pbnQmKTsKICAgICB2b2lkIHBhaW50T3V0bGluZShH cmFwaGljc0NvbnRleHQqLCBjb25zdCBMYXlvdXRQb2ludCYpOwogCisgICAgdmlydHVhbCB2b2lk IHJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRl ckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdDsKKwogICAgIHVzaW5nIFJl bmRlckJveE1vZGVsT2JqZWN0Ojpjb250aW51YXRpb247CiAgICAgdXNpbmcgUmVuZGVyQm94TW9k ZWxPYmplY3Q6OnNldENvbnRpbnVhdGlvbjsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ck9iamVjdC5oCmluZGV4IGE0YTA1OTZmYjEwMjMzYjRkOTBlZjhiN2I1MjI2OTI1MDQyODZmNGQu LjVkYmNjOTQzNjgxMjI3NTU0MWNhMTQxNDlhMGI2NmFkOGI3ZWVhZmUgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKQEAgLTg3NCw2ICs4NzQsOCBAQCBwdWJsaWM6CiAg ICAgCiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0PiYs IGNvbnN0IExheW91dFBvaW50JikgeyB9OwogCisgICAgdmlydHVhbCB2b2lkIHJlcGFpbnRDb250 YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRlckJveE1vZGVsT2Jq ZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdCB7IH0KKwogICAgIExheW91dFJlY3QgYWJzb2x1 dGVPdXRsaW5lQm91bmRzKCkgY29uc3QKICAgICB7CiAgICAgICAgIHJldHVybiBvdXRsaW5lQm91 bmRzRm9yUmVwYWludCgwKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2Vi S2l0Lmd5cCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAppbmRleCAyMjEyMGE1 MTU5ZDBhNTZhMjI1YzMxZTIyMmNiMDgyZGIzZjMxMGNmLi5mNjQyMDhmNjYzNGYxYTQ1ZWFiZWM0 MzdmZWE5ZGIxYmFkNThmOTJkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dl YktpdC5neXAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCkBAIC01NTUs NiArNTU1LDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYkdlb2xvY2F0aW9uUG9zaXRpb24u Y3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkdseXBoQ2FjaGUuY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL1dlYkdyYXBoaWNzQ29udGV4dDNELmNwcCcsCisgICAgICAgICAgICAgICAg J3NyYy9XZWJIaWdobGlnaHQuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkhpZ2hsaWdo dC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkhpc3RvcnlJdGVtLmNwcCcsCiAgICAgICAg ICAgICAgICAgJ3NyYy9XZWJIaXRUZXN0UmVzdWx0LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3Ny Yy9XZWJJY29uTG9hZGluZ0NvbXBsZXRpb25JbXBsLmNwcCcsCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIaWdobGlnaHQuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZGUyZGU1OTExOGE3ZjJjODQx YWY1YWM5MTBkMmFhMjU2MjE0MTg1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApAQCAtMCwwICsxLDEwMCBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmli dXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUg bmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBw cm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKworI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKKworI2luY2x1ZGUg IldlYkhpZ2hsaWdodC5oIgorCisjaW5jbHVkZSAiTm9kZS5oIgorI2luY2x1ZGUgIlBhdGguaCIK KyNpbmNsdWRlICJSZW5kZXJCbG9jay5oIgorI2luY2x1ZGUgIlJlbmRlckxheWVyLmgiCisjaW5j bHVkZSAiUmVuZGVyTGF5ZXJCYWNraW5nLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwor CituYW1lc3BhY2UgV2ViS2l0IHsKKworV2ViSGlnaGxpZ2h0OjpXZWJIaWdobGlnaHQoTm9kZSog dG9wTm9kZSkKK3sKKyAgICBpZiAoIXRvcE5vZGUpCisgICAgICAgIHJldHVybjsKKworICAgIGZv ciAoTm9kZSAqbm9kZSA9IHRvcE5vZGU7IG5vZGU7IG5vZGUgPSBub2RlLT50cmF2ZXJzZU5leHRO b2RlKHRvcE5vZGUpKSB7CisgICAgICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBub2RlLT5y ZW5kZXJlcigpOworICAgICAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgUmVuZGVyTGF5ZXIqIHJlcGFpbnRMYXllciA9IHJlbmRlcmVyLT5lbmNsb3Np bmdMYXllcigpLT5lbmNsb3NpbmdDb21wb3NpdGluZ0xheWVyRm9yUmVwYWludCgpOworICAgICAg ICBpZiAoIXJlcGFpbnRMYXllcikgLy8gbW9zdCBsaWtlbHkgd2UncmUgbm90IGluIEhXLWNvbXBv c2l0b3IgbW9kZS4uLiBiZXR0ZXIgZGV0ZWN0IHRoaXMgZWFybHkgYW5kIHF1aXQ/CisgICAgICAg ICAgICBjb250aW51ZTsKKworICAgICAgICBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENv bnRhaW5lciA9IHJlcGFpbnRMYXllci0+cmVuZGVyZXIoKTsKKworICAgICAgICBHcmFwaGljc0xh eWVyKiBncmFwaGljc0xheWVyID0gcmVwYWludExheWVyLT5iYWNraW5nKCktPmdyYXBoaWNzTGF5 ZXIoKTsKKyAgICAgICAgUGF0aCogcGF0aCA9IG1fcXVhZE1hcC5nZXQoZ3JhcGhpY3NMYXllcik7 CisgICAgICAgIGlmICghcGF0aCkKKyAgICAgICAgICAgIG1fcXVhZE1hcC5zZXQoZ3JhcGhpY3NM YXllciwgYWRvcHRQdHIocGF0aCA9IG5ldyBQYXRoKCkpKTsKKworICAgICAgICBWZWN0b3I8Rmxv YXRRdWFkPiBuZXdxdWFkczsKKyAgICAgICAgcmVuZGVyZXItPnJlcGFpbnRDb250YWluZXJIaWdo bGlnaHRRdWFkcyhuZXdxdWFkcywgcmVwYWludENvbnRhaW5lcik7CisKKyAgICAgICAgZm9yIChz aXplX3QgaSA9IDA7IGkgPCBuZXdxdWFkcy5zaXplKCk7IGkrKykgeworICAgICAgICAgICAgRmxv YXRRdWFkIHF1YWQgPSBuZXdxdWFkc1tpXTsKKworICAgICAgICAgICAgaWYgKHF1YWQuaXNSZWN0 aWxpbmVhcigpKSB7CisgICAgICAgICAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJv dW5kaW5nQm94KCk7CisKKyAgICAgICAgICAgICAgICBmb3IgKFJlbmRlckJsb2NrICpibGsgPSBy ZW5kZXJlci0+Y29udGFpbmluZ0Jsb2NrKCk7IGJsayAmJiBibGstPmlzRGVzY2VuZGFudE9mKHJl cGFpbnRDb250YWluZXIpOyBibGsgPSBibGstPmNvbnRhaW5pbmdCbG9jaygpKSB7CisgICAgICAg ICAgICAgICAgICAgIGlmICghYmxrLT5oYXNPdmVyZmxvd0NsaXAoKSkKKyAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBGbG9hdFF1YWQgYm91bmRR dWFkID0gYmxrLT5sb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoYmxrLT52aXN1YWxPdmVy Zmxvd1JlY3QoKSksIHJlcGFpbnRDb250YWluZXIpOworICAgICAgICAgICAgICAgICAgICBpZiAo IWJvdW5kUXVhZC5pc1JlY3RpbGluZWFyKCkpIC8vIGRvbid0IGtub3cgaG93IHRvIGNsaXAgdGhp cy4gOigKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAg ICAgICBGbG9hdFJlY3QgYm91bmRSZWN0ID0gYm91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAg ICAgICAgICAgICAgICAgIGNsaXBwZWQuaW50ZXJzZWN0KGJvdW5kUmVjdCk7CisgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgIHF1YWQgPSBGbG9hdFF1YWQoY2xpcHBlZCk7CisgICAg ICAgICAgICB9CisKKyAgICAgICAgICAgIHBhdGgtPm1vdmVUbyhxdWFkLnAxKCkpOworICAgICAg ICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDIoKSk7CisgICAgICAgICAgICBwYXRoLT5hZGRM aW5lVG8ocXVhZC5wMygpKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZExpbmVUbyhxdWFkLnA0KCkp OworICAgICAgICAgICAgcGF0aC0+Y2xvc2VTdWJwYXRoKCk7CisgICAgICAgIH0KKyAgICB9Cit9 CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViSGlnaGxpZ2h0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDk4NmUyNDdhNGM2MzQ0MmUxODQ2MTJi MGRkNGJiMmM3OGZjY2U3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYkhpZ2hsaWdodC5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5cmlnaHQg KEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgor ICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9m IGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBw cm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBB TkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu IElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BF Q0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYkhpZ2hsaWdo dF9oCisjZGVmaW5lIFdlYkhpZ2hsaWdodF9oCisKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9T SVRJTkcpCisKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi9Pd25QdHIu aD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7Citj bGFzcyBHcmFwaGljc0xheWVyOworY2xhc3MgTm9kZTsKK2NsYXNzIFBhdGg7Cit9CisKK25hbWVz cGFjZSBXZWJLaXQgeworCitjbGFzcyBXZWJIaWdobGlnaHQgeworcHVibGljOgorICAgIHN0YXRp YyBpbmxpbmUgUGFzc093blB0cjxXZWJIaWdobGlnaHQ+IGNyZWF0ZShXZWJDb3JlOjpOb2RlKiBu b2RlKSB7IHJldHVybiBhZG9wdFB0cihuZXcgV2ViSGlnaGxpZ2h0KG5vZGUpKTsgfQorCisgICAg dHlwZWRlZiBIYXNoTWFwPFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXIqLCBPd25QdHI8V2ViQ29yZTo6 UGF0aD4gPiBRdWFkTWFwOworICAgIHR5cGVkZWYgUXVhZE1hcDo6aXRlcmF0b3IgaXRlcmF0b3I7 CisKKyAgICBpbmxpbmUgaXRlcmF0b3IgYmVnaW4oKSB7IHJldHVybiBtX3F1YWRNYXAuYmVnaW4o KTsgfQorICAgIGlubGluZSBpdGVyYXRvciBlbmQoKSB7IHJldHVybiBtX3F1YWRNYXAuZW5kKCk7 IH0KK3ByaXZhdGU6CisgICAgZXhwbGljaXQgV2ViSGlnaGxpZ2h0KFdlYkNvcmU6Ok5vZGUqKTsK KyAgICBRdWFkTWFwIG1fcXVhZE1hcDsKK307CisKK30KKworI2VuZGlmCisKKyNlbmRpZgo= 141314 2012-05-10 19:39:52 -0700 2012-05-11 13:32:46 -0700 Patch bug-84936-20120510193951.patch text/plain 16250 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2NzE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmQ1YjY4NTRlODI2YWI0 YTM5YTU4MmVhNzVhOGZiYTA3MTIxMDI2MC4uNTc2YWE5NzUwYzY4YTIwNTQzYzYwZWQ0ODE1Y2Zl OGYxY2I3OWRmMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTA1LTA3ICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRk cyBSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyBjYWxsLAorICAg ICAgICB0byBnZW5lcmF0ZSB0aGUgY2xpY2thYmxlIHJlZ2lvbiBmb3IgbGluayBoaWdobGlnaHRp bmcuCisKKyAgICAgICAgT25lIGltcG9ydGFudCBkaWZmZXJlbmNlIGZyb20gUmVuZGVyT2JqZWN0 OjphYnNvbHV0ZVF1YWRzIGlzIHRoYXQKKyAgICAgICAgdGhlIHJldHVybmVkIHF1YWRzIHdpbGwg YmUgaW4gdGhlIGNvb3JkaW5hdGVzIG9mIGEgcmVwYWludCBjb250YWluZXIKKyAgICAgICAgc3Bl Y2lmaWVkIGJ5IHRoZSBjYWxsZXIuIFRoaXMgd2lsbCBhbGxvdyB0aHJlYWRlZC1zY3JvbGxpbmcv YW5pbWF0aW9uCisgICAgICAgIHdpdGhvdXQgaGF2aW5nIHRvIHJlZ2VuZXJhdGUgdGhlIGhpZ2hs aWdodHMuCisKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwOgorICAgICAgICAo V2ViQ29yZTo6UmVuZGVyQmxvY2s6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyk6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suaDoKKyAg ICAgICAgKFJlbmRlckJsb2NrKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94LmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJveDo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1 YWRzKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3gu aDoKKyAgICAgICAgKFJlbmRlckJveCk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGlu ZS5jcHA6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlcklubGlu ZTo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKToKKyAgICAgICAgKiByZW5kZXJpbmcv UmVuZGVySW5saW5lLmg6CisgICAgICAgIChSZW5kZXJJbmxpbmUpOgorICAgICAgICAqIHJlbmRl cmluZy9SZW5kZXJPYmplY3QuaDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck9iamVjdDo6cmVw YWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKToKKyAgICAgICAgKFJlbmRlck9iamVjdCk6CisK IDIwMTItMDUtMTAgIFRpZW4tUmVuIENoZW4gIDx0cmNoZW5AY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIEVsaW1pbmF0ZSBkdXBsaWNhdGVkIGNvZGUgZm9yIGN1bGxlZCBsaW5lIGJveCBpbiBSZW5k ZXJJbmxpbmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggOTA4OWRkNzE5ZDRkMmQ1Y2E2 NjNkMWVjZjFkMmQ4ZWY0OTk1ZTcxNi4uZWUyZjZiNWYyZTA5NzkxODAyMmU1ZjdmZjc1YmU4ZDY0 ZGYxMGIxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAx Mi0wNS0wNyAgVGllbi1SZW4gQ2hlbiAgPHRyY2hlbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg W2Nocm9taXVtXSBDb21wdXRlIGhpZ2hsaWdodCBmb3IgdG91Y2ggdGFyZ2V0cworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODQ5MzYKKworICAgICAgICBB ZGQgV2ViSGlnaGxpZ2h0IGNsYXNzIHdoaWNoIGNhbiBiZSB1c2VkIHRvIGRldGVybWluZQorICAg ICAgICB0aGUgaGlnaGxpZ2h0IHJlZ2lvbiBmb3Igc3BlY2lmaWVkIHRvdWNoIHRhcmdldCBub2Rl LgorCisgICAgICAgICogV2ViS2l0Lmd5cDoKKyAgICAgICAgKiBzcmMvV2ViSGlnaGxpZ2h0LmNw cDogQWRkZWQuCisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGln aHQ6OldlYkhpZ2hsaWdodCk6CisgICAgICAgICogc3JjL1dlYkhpZ2hsaWdodC5oOiBBZGRlZC4K KyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYkhpZ2hs aWdodCk6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hsaWdodDo6Y3JlYXRlKToKKyAgICAgICAg KFdlYktpdDo6V2ViSGlnaGxpZ2h0OjpiZWdpbik6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hs aWdodDo6ZW5kKToKKwogMjAxMi0wNS0xMCAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5v cmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjExNjU5NC4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCmluZGV4IGViY2FlOWQ1MWVhZTEwMzMwZWJh YjNkYzM3ZDRlYjIwMDdlMGQzYjEuLmM0ZDI5ODU4YTIzZWZjYmM2MTRlYzNhMzIwMmRmMjZjMDI2 MWUyMTYgMTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtNjU2 Niw2ICs2NTY2LDE0IEBAIHZvaWQgUmVuZGVyQmxvY2s6OmFkZEZvY3VzUmluZ1JlY3RzKFZlY3Rv cjxJbnRSZWN0PiYgcmVjdHMsIGNvbnN0IExheW91dFBvaW50JiBhCiAgICAgICAgIGlubGluZUVs ZW1lbnRDb250aW51YXRpb24oKS0+YWRkRm9jdXNSaW5nUmVjdHMocmVjdHMsIGZsb29yZWRMYXlv dXRQb2ludChhZGRpdGlvbmFsT2Zmc2V0ICsgaW5saW5lRWxlbWVudENvbnRpbnVhdGlvbigpLT5j b250YWluaW5nQmxvY2soKS0+bG9jYXRpb24oKSAtIGxvY2F0aW9uKCkpKTsKIH0KIAordm9pZCBS ZW5kZXJCbG9jazo6cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1 YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0 Cit7CisgICAgUmVuZGVyQm94OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMocXVhZHMs IHJlcGFpbnRDb250YWluZXIpOworCisgICAgaWYgKGNvbnRpbnVhdGlvbigpKQorICAgICAgICBj b250aW51YXRpb24oKS0+cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKHF1YWRzLCByZXBh aW50Q29udGFpbmVyKTsKK30KKwogUmVuZGVyQm94KiBSZW5kZXJCbG9jazo6Y3JlYXRlQW5vbnlt b3VzQm94V2l0aFNhbWVUeXBlQXMoY29uc3QgUmVuZGVyT2JqZWN0KiBwYXJlbnQpIGNvbnN0CiB7 CiAgICAgaWYgKGlzQW5vbnltb3VzQ29sdW1uc0Jsb2NrKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJCbG9jay5oCmluZGV4IGEzY2MzM2VhNjlkYThmNjliZDE2OGIwY2Q3ZjhhNjBmNTM2 MjJiYzIuLmEzNjdlYmQyODM0ZjUyMTk3OTNiN2RmZTQ4MzdmYmZkYTQ2ZWNhZDggMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5oCkBAIC00NDcsNiArNDQ3LDggQEAgcHJvdGVj dGVkOgogCiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0 PiYsIGNvbnN0IExheW91dFBvaW50Jik7CiAKKyAgICB2aXJ0dWFsIHZvaWQgcmVwYWludENvbnRh aW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmpl Y3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0OworCiAjaWYgRU5BQkxFKFNWRykKICAgICAvLyBP bmx5IHVzZWQgYnkgUmVuZGVyU1ZHVGV4dCwgd2hpY2ggZXhwbGljaXRlbHkgb3ZlcnJpZGVzIFJl bmRlckJsb2NrOjpsYXlvdXRCbG9jaygpLCBkbyBOT1QgdXNlIGZvciBhbnl0aGluZyBlbHNlLgog ICAgIHZvaWQgZm9yY2VMYXlvdXRJbmxpbmVDaGlsZHJlbigpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJCb3guY3BwCmluZGV4IDE5OWRlYjZiMjMyZWFjYjY1ZjA2NDRjOGRlN2M2YjIwZDdm ZjQ1NjQuLmRiMzI2M2Y5MDg4MTYxZWMxMjM2NjMzMWJjZmQ5Y2Y0NjJmNDYyNDIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guY3BwCkBAIC01OTEsNiArNTkxLDEyIEBAIHZvaWQg UmVuZGVyQm94OjphZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mIHJlY3RzLCBjb25z dCBMYXlvdXRQb2ludCYgYWRkCiAgICAgICAgIHJlY3RzLmFwcGVuZChwaXhlbFNuYXBwZWRJbnRS ZWN0KGFkZGl0aW9uYWxPZmZzZXQsIHNpemUoKSkpOwogfQogCit2b2lkIFJlbmRlckJveDo6cmVw YWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVu ZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAgaWYgKCFz aXplKCkuaXNFbXB0eSgpKQorICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1 YWQoRmxvYXRSZWN0KDAsIDAsIHdpZHRoKCksIGhlaWdodCgpKSwgcmVwYWludENvbnRhaW5lciwg ZmFsc2UsIDApKTsKK30KKwogTGF5b3V0UmVjdCBSZW5kZXJCb3g6OnJlZmxlY3Rpb25Cb3goKSBj b25zdAogewogICAgIExheW91dFJlY3QgcmVzdWx0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckJveC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckJveC5oCmluZGV4IDlmMDBhNDRlMzY2ZThhODVjODU0MWY4ZDBmYzZkMjUwNWMzMzRhY2MuLmRm ZGY1M2I1YmZjNzk0ODdlZTZlNzdjMWU0N2MyYTI1ZjQwZjM3OWUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQm94LmgKQEAgLTE0OSw2ICsxNDksOCBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCBMYXlvdXRSZWN0IG91dGxpbmVCb3VuZHNGb3JSZXBhaW50KFJlbmRlckJveE1vZGVsT2JqZWN0 KiAvKnJlcGFpbnRDb250YWluZXIqLywgTGF5b3V0UG9pbnQqIGNhY2hlZE9mZnNldFRvUmVwYWlu dENvbnRhaW5lcikgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZl Y3RvcjxJbnRSZWN0PiYsIGNvbnN0IExheW91dFBvaW50Jik7CiAKKyAgICB2aXJ0dWFsIHZvaWQg cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVy Qm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0OworCiAgICAgLy8gVXNlIHRo aXMgd2l0aCBjYXV0aW9uISBObyB0eXBlIGNoZWNraW5nIGlzIGRvbmUhCiAgICAgUmVuZGVyQm94 KiBwcmV2aW91c1NpYmxpbmdCb3goKSBjb25zdDsKICAgICBSZW5kZXJCb3gqIG5leHRTaWJsaW5n Qm94KCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy SW5saW5lLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwCmlu ZGV4IDY4MDQzODNlZDYzNjQ2NzJlNzRjNWRjZDc2OTY5ODdjYzllZTZiMDAuLjI0MTg4MTIyNmRm N2QyODYwOWJkNDQwOGEwMmQ3NmY1MGRiMWY4ZWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJJbmxpbmUuY3BwCkBAIC0xNDY5LDYgKzE0NjksMzUgQEAgdm9pZCBSZW5kZXJJbmxp bmU6OnBhaW50T3V0bGluZUZvckxpbmUoR3JhcGhpY3NDb250ZXh0KiBncmFwaGljc0NvbnRleHQs IGNvbnN0IEwKICAgICAgICAgICAgIGFudGlhbGlhcyk7CiB9CiAKK25hbWVzcGFjZSB7CisKK2Ns YXNzIFJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkc0dlbmVyYXRvckNvbnRleHQgeworcHVi bGljOgorICAgIFJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkc0dlbmVyYXRvckNvbnRleHQo Y29uc3QgUmVuZGVySW5saW5lKiByZW5kZXJlciwgVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBS ZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikKKyAgICAgICAgOiBtX3JlbmRl cmVyKHJlbmRlcmVyKQorICAgICAgICAsIG1fcXVhZHMocXVhZHMpCisgICAgICAgICwgbV9yZXBh aW50Q29udGFpbmVyKHJlcGFpbnRDb250YWluZXIpIHsgfQorCisgICAgdm9pZCBvcGVyYXRvcigp KGNvbnN0IEZsb2F0UmVjdCYgcmVjdCkKKyAgICB7CisgICAgICAgIG1fcXVhZHMuYXBwZW5kKG1f cmVuZGVyZXItPmxvY2FsVG9Db250YWluZXJRdWFkKHJlY3QsIG1fcmVwYWludENvbnRhaW5lcikp OworICAgIH0KK3ByaXZhdGU6CisgICAgY29uc3QgUmVuZGVySW5saW5lKiBtX3JlbmRlcmVyOwor ICAgIFZlY3RvcjxGbG9hdFF1YWQ+JiBtX3F1YWRzOworICAgIFJlbmRlckJveE1vZGVsT2JqZWN0 KiBtX3JlcGFpbnRDb250YWluZXI7Cit9OworCit9IC8vIHVubmFtZWQgbmFtZXNwYWNlCisKK3Zv aWQgUmVuZGVySW5saW5lOjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZs b2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikg Y29uc3QKK3sKKyAgICBnZW5lcmF0ZUxpbmVCb3hSZWN0cyhSZXBhaW50Q29udGFpbmVySGlnaGxp Z2h0UXVhZHNHZW5lcmF0b3JDb250ZXh0KHRoaXMsIHF1YWRzLCByZXBhaW50Q29udGFpbmVyKSk7 CisKKyAgICBpZiAoY29udGludWF0aW9uKCkpCisgICAgICAgIGNvbnRpbnVhdGlvbigpLT5yZXBh aW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMocXVhZHMsIHJlcGFpbnRDb250YWluZXIpOworfQor CiAjaWYgRU5BQkxFKERBU0hCT0FSRF9TVVBQT1JUKQogdm9pZCBSZW5kZXJJbmxpbmU6OmFkZERh c2hib2FyZFJlZ2lvbnMoVmVjdG9yPERhc2hib2FyZFJlZ2lvblZhbHVlPiYgcmVnaW9ucykKIHsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaCBiL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaAppbmRleCBjMTUzMmNmNTY4ZmI0 NWViYjRmMzE0NzdkN2FmMmJjMjViZjViNmI3Li41MDYxNDcyOGUxOWJiZGY4MjllMDg5MjA4ZDg5 ZDhhNzkwMWRkYzExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy SW5saW5lLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCkBA IC03Niw2ICs3Niw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgYWRkRm9jdXNSaW5nUmVj dHMoVmVjdG9yPEludFJlY3Q+JiwgY29uc3QgTGF5b3V0UG9pbnQmKTsKICAgICB2b2lkIHBhaW50 T3V0bGluZShHcmFwaGljc0NvbnRleHQqLCBjb25zdCBMYXlvdXRQb2ludCYpOwogCisgICAgdmly dHVhbCB2b2lkIHJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFk PiYsIFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdDsKKwogICAg IHVzaW5nIFJlbmRlckJveE1vZGVsT2JqZWN0Ojpjb250aW51YXRpb247CiAgICAgdXNpbmcgUmVu ZGVyQm94TW9kZWxPYmplY3Q6OnNldENvbnRpbnVhdGlvbjsKIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlck9iamVjdC5oCmluZGV4IDZhZjZlOWEyZjFjYzkwNDBkNDViMzllYWY3NmEyMmJl ZjIzYjcyZDIuLmIzOGViNDA3OGY0ZmQ4NGY4NDA1MzUzNjZmYzY0YzY0MDMyMmNhNDAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKQEAgLTg4MCw2ICs4ODAsOCBAQCBw dWJsaWM6CiAgICAgCiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJ bnRSZWN0PiYsIGNvbnN0IExheW91dFBvaW50JikgeyB9OwogCisgICAgdmlydHVhbCB2b2lkIHJl cGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRlckJv eE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdCB7IH0KKwogICAgIExheW91dFJl Y3QgYWJzb2x1dGVPdXRsaW5lQm91bmRzKCkgY29uc3QKICAgICB7CiAgICAgICAgIHJldHVybiBv dXRsaW5lQm91bmRzRm9yUmVwYWludCgwKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vV2ViS2l0Lmd5cCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAppbmRl eCBhNzc1ZjU0NWQxMjI4OGRiZWVjNGFjY2I3NGMyOGM2ZThhNjVmOWM3Li4xYjhmNzE4NmEyNWMz MWU0YzgwZmYyYTdiNjMxOTA0NmNiZjAyN2Y4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL1dlYktpdC5neXAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw CkBAIC01NTAsNiArNTUwLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYkdlb2xvY2F0aW9u UG9zaXRpb24uY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkdseXBoQ2FjaGUuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYkdyYXBoaWNzQ29udGV4dDNELmNwcCcsCisgICAgICAg ICAgICAgICAgJ3NyYy9XZWJIaWdobGlnaHQuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dl YkhpZ2hsaWdodC5oJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYkhpc3RvcnlJdGVtLmNwcCcs CiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJIaXRUZXN0UmVzdWx0LmNwcCcsCiAgICAgICAgICAg ICAgICAgJ3NyYy9XZWJJY29uTG9hZGluZ0NvbXBsZXRpb25JbXBsLmNwcCcsCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIaWdobGlnaHQuY3BwIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44ZGUyZGU1OTEx OGE3ZjJjODQxYWY1YWM5MTBkMmFhMjU2MjE0MTg1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApAQCAtMCwwICsxLDEwMCBAQAor LyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVk LgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9y bXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3Zp ZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisg KiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMu IG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5k b3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3 aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVU T1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dO RVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElO Q0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdF UyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJT VElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQor ICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJ U0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNp bmNsdWRlICJjb25maWcuaCIKKworI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKKwor I2luY2x1ZGUgIldlYkhpZ2hsaWdodC5oIgorCisjaW5jbHVkZSAiTm9kZS5oIgorI2luY2x1ZGUg IlBhdGguaCIKKyNpbmNsdWRlICJSZW5kZXJCbG9jay5oIgorI2luY2x1ZGUgIlJlbmRlckxheWVy LmgiCisjaW5jbHVkZSAiUmVuZGVyTGF5ZXJCYWNraW5nLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBX ZWJDb3JlOworCituYW1lc3BhY2UgV2ViS2l0IHsKKworV2ViSGlnaGxpZ2h0OjpXZWJIaWdobGln aHQoTm9kZSogdG9wTm9kZSkKK3sKKyAgICBpZiAoIXRvcE5vZGUpCisgICAgICAgIHJldHVybjsK KworICAgIGZvciAoTm9kZSAqbm9kZSA9IHRvcE5vZGU7IG5vZGU7IG5vZGUgPSBub2RlLT50cmF2 ZXJzZU5leHROb2RlKHRvcE5vZGUpKSB7CisgICAgICAgIFJlbmRlck9iamVjdCogcmVuZGVyZXIg PSBub2RlLT5yZW5kZXJlcigpOworICAgICAgICBpZiAoIXJlbmRlcmVyKQorICAgICAgICAgICAg Y29udGludWU7CisKKyAgICAgICAgUmVuZGVyTGF5ZXIqIHJlcGFpbnRMYXllciA9IHJlbmRlcmVy LT5lbmNsb3NpbmdMYXllcigpLT5lbmNsb3NpbmdDb21wb3NpdGluZ0xheWVyRm9yUmVwYWludCgp OworICAgICAgICBpZiAoIXJlcGFpbnRMYXllcikgLy8gbW9zdCBsaWtlbHkgd2UncmUgbm90IGlu IEhXLWNvbXBvc2l0b3IgbW9kZS4uLiBiZXR0ZXIgZGV0ZWN0IHRoaXMgZWFybHkgYW5kIHF1aXQ/ CisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBSZW5kZXJCb3hNb2RlbE9iamVjdCog cmVwYWludENvbnRhaW5lciA9IHJlcGFpbnRMYXllci0+cmVuZGVyZXIoKTsKKworICAgICAgICBH cmFwaGljc0xheWVyKiBncmFwaGljc0xheWVyID0gcmVwYWludExheWVyLT5iYWNraW5nKCktPmdy YXBoaWNzTGF5ZXIoKTsKKyAgICAgICAgUGF0aCogcGF0aCA9IG1fcXVhZE1hcC5nZXQoZ3JhcGhp Y3NMYXllcik7CisgICAgICAgIGlmICghcGF0aCkKKyAgICAgICAgICAgIG1fcXVhZE1hcC5zZXQo Z3JhcGhpY3NMYXllciwgYWRvcHRQdHIocGF0aCA9IG5ldyBQYXRoKCkpKTsKKworICAgICAgICBW ZWN0b3I8RmxvYXRRdWFkPiBuZXdxdWFkczsKKyAgICAgICAgcmVuZGVyZXItPnJlcGFpbnRDb250 YWluZXJIaWdobGlnaHRRdWFkcyhuZXdxdWFkcywgcmVwYWludENvbnRhaW5lcik7CisKKyAgICAg ICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuZXdxdWFkcy5zaXplKCk7IGkrKykgeworICAgICAg ICAgICAgRmxvYXRRdWFkIHF1YWQgPSBuZXdxdWFkc1tpXTsKKworICAgICAgICAgICAgaWYgKHF1 YWQuaXNSZWN0aWxpbmVhcigpKSB7CisgICAgICAgICAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQg PSBxdWFkLmJvdW5kaW5nQm94KCk7CisKKyAgICAgICAgICAgICAgICBmb3IgKFJlbmRlckJsb2Nr ICpibGsgPSByZW5kZXJlci0+Y29udGFpbmluZ0Jsb2NrKCk7IGJsayAmJiBibGstPmlzRGVzY2Vu ZGFudE9mKHJlcGFpbnRDb250YWluZXIpOyBibGsgPSBibGstPmNvbnRhaW5pbmdCbG9jaygpKSB7 CisgICAgICAgICAgICAgICAgICAgIGlmICghYmxrLT5oYXNPdmVyZmxvd0NsaXAoKSkKKyAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBGbG9hdFF1 YWQgYm91bmRRdWFkID0gYmxrLT5sb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoYmxrLT52 aXN1YWxPdmVyZmxvd1JlY3QoKSksIHJlcGFpbnRDb250YWluZXIpOworICAgICAgICAgICAgICAg ICAgICBpZiAoIWJvdW5kUXVhZC5pc1JlY3RpbGluZWFyKCkpIC8vIGRvbid0IGtub3cgaG93IHRv IGNsaXAgdGhpcy4gOigKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgICAgICAgICBGbG9hdFJlY3QgYm91bmRSZWN0ID0gYm91bmRRdWFkLmJvdW5kaW5nQm94 KCk7CisgICAgICAgICAgICAgICAgICAgIGNsaXBwZWQuaW50ZXJzZWN0KGJvdW5kUmVjdCk7Cisg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgIHF1YWQgPSBGbG9hdFF1YWQoY2xpcHBl ZCk7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIHBhdGgtPm1vdmVUbyhxdWFkLnAxKCkp OworICAgICAgICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDIoKSk7CisgICAgICAgICAgICBw YXRoLT5hZGRMaW5lVG8ocXVhZC5wMygpKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZExpbmVUbyhx dWFkLnA0KCkpOworICAgICAgICAgICAgcGF0aC0+Y2xvc2VTdWJwYXRoKCk7CisgICAgICAgIH0K KyAgICB9Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5oIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDk4NmUyNDdhNGM2MzQ0 MmUxODQ2MTJiMGRkNGJiMmM3OGZjY2U3ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJp YnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhl IG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3Ig cHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdl YkhpZ2hsaWdodF9oCisjZGVmaW5lIFdlYkhpZ2hsaWdodF9oCisKKyNpZiBVU0UoQUNDRUxFUkFU RURfQ09NUE9TSVRJTkcpCisKKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0 Zi9Pd25QdHIuaD4KKyNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgorCituYW1lc3BhY2UgV2Vi Q29yZSB7CitjbGFzcyBHcmFwaGljc0xheWVyOworY2xhc3MgTm9kZTsKK2NsYXNzIFBhdGg7Cit9 CisKK25hbWVzcGFjZSBXZWJLaXQgeworCitjbGFzcyBXZWJIaWdobGlnaHQgeworcHVibGljOgor ICAgIHN0YXRpYyBpbmxpbmUgUGFzc093blB0cjxXZWJIaWdobGlnaHQ+IGNyZWF0ZShXZWJDb3Jl OjpOb2RlKiBub2RlKSB7IHJldHVybiBhZG9wdFB0cihuZXcgV2ViSGlnaGxpZ2h0KG5vZGUpKTsg fQorCisgICAgdHlwZWRlZiBIYXNoTWFwPFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXIqLCBPd25QdHI8 V2ViQ29yZTo6UGF0aD4gPiBRdWFkTWFwOworICAgIHR5cGVkZWYgUXVhZE1hcDo6aXRlcmF0b3Ig aXRlcmF0b3I7CisKKyAgICBpbmxpbmUgaXRlcmF0b3IgYmVnaW4oKSB7IHJldHVybiBtX3F1YWRN YXAuYmVnaW4oKTsgfQorICAgIGlubGluZSBpdGVyYXRvciBlbmQoKSB7IHJldHVybiBtX3F1YWRN YXAuZW5kKCk7IH0KK3ByaXZhdGU6CisgICAgZXhwbGljaXQgV2ViSGlnaGxpZ2h0KFdlYkNvcmU6 Ok5vZGUqKTsKKyAgICBRdWFkTWFwIG1fcXVhZE1hcDsKK307CisKK30KKworI2VuZGlmCisKKyNl bmRpZgo= 141485 2012-05-11 13:32:54 -0700 2012-05-21 20:44:46 -0700 Patch bug-84936-20120511133252.patch text/plain 16405 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2NzE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmQ1YjY4NTRlODI2YWI0 YTM5YTU4MmVhNzVhOGZiYTA3MTIxMDI2MC4uOTczZDFiMzg5MjA3YTllN2RmODE3ZWFhY2ViZGUz YTlmNmNhNmVkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDEyLTA1LTA3ICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRk cyBSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyBjYWxsLAorICAg ICAgICB0byBnZW5lcmF0ZSB0aGUgY2xpY2thYmxlIHJlZ2lvbiBmb3IgbGluayBoaWdobGlnaHRp bmcuCisKKyAgICAgICAgT25lIGltcG9ydGFudCBkaWZmZXJlbmNlIGZyb20gUmVuZGVyT2JqZWN0 OjphYnNvbHV0ZVF1YWRzIGlzIHRoYXQKKyAgICAgICAgdGhlIHJldHVybmVkIHF1YWRzIHdpbGwg YmUgaW4gdGhlIGNvb3JkaW5hdGVzIG9mIGEgcmVwYWludCBjb250YWluZXIKKyAgICAgICAgc3Bl Y2lmaWVkIGJ5IHRoZSBjYWxsZXIuIFRoaXMgd2lsbCBhbGxvdyB0aHJlYWRlZC1zY3JvbGxpbmcv YW5pbWF0aW9uCisgICAgICAgIHdpdGhvdXQgaGF2aW5nIHRvIHJlZ2VuZXJhdGUgdGhlIGhpZ2hs aWdodHMuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg Tm8gbmV3IHRlc3RzLiBUZXN0cyB3aWxsIGJlIGFkZGVkIHdpdGggbGF0ZXIgcGF0Y2hlcyB0aGF0 IGFjdHVhbGx5CisgICAgICAgIGFkZCBoaWdobGlnaHQgdG8gbGF5ZXJzLgorCisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJsb2Nr OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJsb2NrLmg6CisgICAgICAgIChSZW5kZXJCbG9jayk6 CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpS ZW5kZXJCb3g6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94Lmg6CisgICAgICAgIChSZW5kZXJC b3gpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwOgorICAgICAgICAoV2Vi Q29yZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbmxpbmU6OnJlcGFpbnRDb250YWluZXJI aWdobGlnaHRRdWFkcyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGluZS5oOgorICAg ICAgICAoUmVuZGVySW5saW5lKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGln aHRRdWFkcyk6CisgICAgICAgIChSZW5kZXJPYmplY3QpOgorCiAyMDEyLTA1LTEwICBUaWVuLVJl biBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBFbGltaW5hdGUgZHVwbGlj YXRlZCBjb2RlIGZvciBjdWxsZWQgbGluZSBib3ggaW4gUmVuZGVySW5saW5lCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nCmluZGV4IDkwODlkZDcxOWQ0ZDJkNWNhNjYzZDFlY2YxZDJkOGVmNDk5NWU3 MTYuLmVlMmY2YjVmMmUwOTc5MTgwMjJlNWY3ZmY3NWJlOGQ2NGRmMTBiMTIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTItMDUtMDcgIFRpZW4tUmVuIENo ZW4gIDx0cmNoZW5AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtjaHJvbWl1bV0gQ29tcHV0ZSBo aWdobGlnaHQgZm9yIHRvdWNoIHRhcmdldHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTg0OTM2CisKKyAgICAgICAgQWRkIFdlYkhpZ2hsaWdodCBjbGFz cyB3aGljaCBjYW4gYmUgdXNlZCB0byBkZXRlcm1pbmUKKyAgICAgICAgdGhlIGhpZ2hsaWdodCBy ZWdpb24gZm9yIHNwZWNpZmllZCB0b3VjaCB0YXJnZXQgbm9kZS4KKworICAgICAgICAqIFdlYktp dC5neXA6CisgICAgICAgICogc3JjL1dlYkhpZ2hsaWdodC5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViSGlnaGxpZ2h0OjpXZWJIaWdobGlnaHQpOgor ICAgICAgICAqIHNyYy9XZWJIaWdobGlnaHQuaDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlKToK KyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJIaWdobGlnaHQpOgorICAgICAgICAoV2Vi S2l0OjpXZWJIaWdobGlnaHQ6OmNyZWF0ZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hsaWdo dDo6YmVnaW4pOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHQ6OmVuZCk6CisKIDIwMTIt MDUtMTAgIEtlbnQgVGFtdXJhICA8dGtlbnRAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2 aWV3ZWQsIHJvbGxpbmcgb3V0IHIxMTY1OTQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcAppbmRleCBlYmNhZTlkNTFlYWUxMDMzMGViYWIzZGMzN2Q0ZWIyMDA3ZTBkM2Ix Li5jNGQyOTg1OGEyM2VmY2JjNjE0ZWMzYTMyMDJkZjI2YzAyNjFlMjE2IDEwMDc1NQotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKQEAgLTY1NjYsNiArNjU2NiwxNCBAQCB2b2lk IFJlbmRlckJsb2NrOjphZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mIHJlY3RzLCBj b25zdCBMYXlvdXRQb2ludCYgYQogICAgICAgICBpbmxpbmVFbGVtZW50Q29udGludWF0aW9uKCkt PmFkZEZvY3VzUmluZ1JlY3RzKHJlY3RzLCBmbG9vcmVkTGF5b3V0UG9pbnQoYWRkaXRpb25hbE9m ZnNldCArIGlubGluZUVsZW1lbnRDb250aW51YXRpb24oKS0+Y29udGFpbmluZ0Jsb2NrKCktPmxv Y2F0aW9uKCkgLSBsb2NhdGlvbigpKSk7CiB9CiAKK3ZvaWQgUmVuZGVyQmxvY2s6OnJlcGFpbnRD b250YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRlckJv eE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIFJlbmRlckJveDo6 cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKHF1YWRzLCByZXBhaW50Q29udGFpbmVyKTsK KworICAgIGlmIChjb250aW51YXRpb24oKSkKKyAgICAgICAgY29udGludWF0aW9uKCktPnJlcGFp bnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhxdWFkcywgcmVwYWludENvbnRhaW5lcik7Cit9CisK IFJlbmRlckJveCogUmVuZGVyQmxvY2s6OmNyZWF0ZUFub255bW91c0JveFdpdGhTYW1lVHlwZUFz KGNvbnN0IFJlbmRlck9iamVjdCogcGFyZW50KSBjb25zdAogewogICAgIGlmIChpc0Fub255bW91 c0NvbHVtbnNCbG9jaygpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckJsb2NrLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suaAppbmRl eCBhM2NjMzNlYTY5ZGE4ZjY5YmQxNjhiMGNkN2Y4YTYwZjUzNjIyYmMyLi5hMzY3ZWJkMjgzNGY1 MjE5NzkzYjdkZmU0ODM3ZmJmZGE0NmVjYWQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQmxvY2suaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQmxvY2suaApAQCAtNDQ3LDYgKzQ0Nyw4IEBAIHByb3RlY3RlZDoKIAogICAgIHZpcnR1YWwg dm9pZCBhZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlvdXRQb2lu dCYpOwogCisgICAgdmlydHVhbCB2b2lkIHJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhW ZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVy KSBjb25zdDsKKwogI2lmIEVOQUJMRShTVkcpCiAgICAgLy8gT25seSB1c2VkIGJ5IFJlbmRlclNW R1RleHQsIHdoaWNoIGV4cGxpY2l0ZWx5IG92ZXJyaWRlcyBSZW5kZXJCbG9jazo6bGF5b3V0Qmxv Y2soKSwgZG8gTk9UIHVzZSBmb3IgYW55dGhpbmcgZWxzZS4KICAgICB2b2lkIGZvcmNlTGF5b3V0 SW5saW5lQ2hpbGRyZW4oKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlckJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAppbmRl eCAxOTlkZWI2YjIzMmVhY2I2NWYwNjQ0YzhkZTdjNmIyMGQ3ZmY0NTY0Li5kYjMyNjNmOTA4ODE2 MWVjMTIzNjYzMzFiY2ZkOWNmNDYyZjQ2MjQyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQm94LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVu ZGVyQm94LmNwcApAQCAtNTkxLDYgKzU5MSwxMiBAQCB2b2lkIFJlbmRlckJveDo6YWRkRm9jdXNS aW5nUmVjdHMoVmVjdG9yPEludFJlY3Q+JiByZWN0cywgY29uc3QgTGF5b3V0UG9pbnQmIGFkZAog ICAgICAgICByZWN0cy5hcHBlbmQocGl4ZWxTbmFwcGVkSW50UmVjdChhZGRpdGlvbmFsT2Zmc2V0 LCBzaXplKCkpKTsKIH0KIAordm9pZCBSZW5kZXJCb3g6OnJlcGFpbnRDb250YWluZXJIaWdobGln aHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRlckJveE1vZGVsT2JqZWN0KiBy ZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIGlmICghc2l6ZSgpLmlzRW1wdHkoKSkKKyAg ICAgICAgcXVhZHMuYXBwZW5kKGxvY2FsVG9Db250YWluZXJRdWFkKEZsb2F0UmVjdCgwLCAwLCB3 aWR0aCgpLCBoZWlnaHQoKSksIHJlcGFpbnRDb250YWluZXIsIGZhbHNlLCAwKSk7Cit9CisKIExh eW91dFJlY3QgUmVuZGVyQm94OjpyZWZsZWN0aW9uQm94KCkgY29uc3QKIHsKICAgICBMYXlvdXRS ZWN0IHJlc3VsdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJC b3guaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guaAppbmRleCA5ZjAwYTQ0 ZTM2NmU4YTg1Yzg1NDFmOGQwZmM2ZDI1MDVjMzM0YWNjLi5kZmRmNTNiNWJmYzc5NDg3ZWU2ZTc3 YzFlNDdjMmEyNWY0MGYzNzllIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyQm94LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5oCkBA IC0xNDksNiArMTQ5LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgTGF5b3V0UmVjdCBvdXRsaW5l Qm91bmRzRm9yUmVwYWludChSZW5kZXJCb3hNb2RlbE9iamVjdCogLypyZXBhaW50Q29udGFpbmVy Ki8sIExheW91dFBvaW50KiBjYWNoZWRPZmZzZXRUb1JlcGFpbnRDb250YWluZXIpIGNvbnN0Owog ICAgIHZpcnR1YWwgdm9pZCBhZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mLCBjb25z dCBMYXlvdXRQb2ludCYpOwogCisgICAgdmlydHVhbCB2b2lkIHJlcGFpbnRDb250YWluZXJIaWdo bGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBh aW50Q29udGFpbmVyKSBjb25zdDsKKwogICAgIC8vIFVzZSB0aGlzIHdpdGggY2F1dGlvbiEgTm8g dHlwZSBjaGVja2luZyBpcyBkb25lIQogICAgIFJlbmRlckJveCogcHJldmlvdXNTaWJsaW5nQm94 KCkgY29uc3Q7CiAgICAgUmVuZGVyQm94KiBuZXh0U2libGluZ0JveCgpIGNvbnN0OwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcAppbmRleCA2ODA0MzgzZWQ2MzY0Njcy ZTc0YzVkY2Q3Njk2OTg3Y2M5ZWU2YjAwLi4yNDE4ODEyMjZkZjdkMjg2MDliZDQ0MDhhMDJkNzZm NTBkYjFmOGVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5s aW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcApA QCAtMTQ2OSw2ICsxNDY5LDM1IEBAIHZvaWQgUmVuZGVySW5saW5lOjpwYWludE91dGxpbmVGb3JM aW5lKEdyYXBoaWNzQ29udGV4dCogZ3JhcGhpY3NDb250ZXh0LCBjb25zdCBMCiAgICAgICAgICAg ICBhbnRpYWxpYXMpOwogfQogCituYW1lc3BhY2UgeworCitjbGFzcyBSZXBhaW50Q29udGFpbmVy SGlnaGxpZ2h0UXVhZHNHZW5lcmF0b3JDb250ZXh0IHsKK3B1YmxpYzoKKyAgICBSZXBhaW50Q29u dGFpbmVySGlnaGxpZ2h0UXVhZHNHZW5lcmF0b3JDb250ZXh0KGNvbnN0IFJlbmRlcklubGluZSog cmVuZGVyZXIsIFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9kZWxPYmplY3Qq IHJlcGFpbnRDb250YWluZXIpCisgICAgICAgIDogbV9yZW5kZXJlcihyZW5kZXJlcikKKyAgICAg ICAgLCBtX3F1YWRzKHF1YWRzKQorICAgICAgICAsIG1fcmVwYWludENvbnRhaW5lcihyZXBhaW50 Q29udGFpbmVyKSB7IH0KKworICAgIHZvaWQgb3BlcmF0b3IoKShjb25zdCBGbG9hdFJlY3QmIHJl Y3QpCisgICAgeworICAgICAgICBtX3F1YWRzLmFwcGVuZChtX3JlbmRlcmVyLT5sb2NhbFRvQ29u dGFpbmVyUXVhZChyZWN0LCBtX3JlcGFpbnRDb250YWluZXIpKTsKKyAgICB9Citwcml2YXRlOgor ICAgIGNvbnN0IFJlbmRlcklubGluZSogbV9yZW5kZXJlcjsKKyAgICBWZWN0b3I8RmxvYXRRdWFk PiYgbV9xdWFkczsKKyAgICBSZW5kZXJCb3hNb2RlbE9iamVjdCogbV9yZXBhaW50Q29udGFpbmVy OworfTsKKworfSAvLyB1bm5hbWVkIG5hbWVzcGFjZQorCit2b2lkIFJlbmRlcklubGluZTo6cmVw YWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVu ZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAgZ2VuZXJh dGVMaW5lQm94UmVjdHMoUmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzR2VuZXJhdG9yQ29u dGV4dCh0aGlzLCBxdWFkcywgcmVwYWludENvbnRhaW5lcikpOworCisgICAgaWYgKGNvbnRpbnVh dGlvbigpKQorICAgICAgICBjb250aW51YXRpb24oKS0+cmVwYWludENvbnRhaW5lckhpZ2hsaWdo dFF1YWRzKHF1YWRzLCByZXBhaW50Q29udGFpbmVyKTsKK30KKwogI2lmIEVOQUJMRShEQVNIQk9B UkRfU1VQUE9SVCkKIHZvaWQgUmVuZGVySW5saW5lOjphZGREYXNoYm9hcmRSZWdpb25zKFZlY3Rv cjxEYXNoYm9hcmRSZWdpb25WYWx1ZT4mIHJlZ2lvbnMpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVySW5saW5lLmgKaW5kZXggYzE1MzJjZjU2OGZiNDVlYmI0ZjMxNDc3ZDdhZjJiYzI1 YmY1YjZiNy4uNTA2MTQ3MjhlMTliYmRmODI5ZTA4OTIwOGQ4OWQ4YTc5MDFkZGMxMSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaApAQCAtNzYsNiArNzYsOCBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0PiYs IGNvbnN0IExheW91dFBvaW50Jik7CiAgICAgdm9pZCBwYWludE91dGxpbmUoR3JhcGhpY3NDb250 ZXh0KiwgY29uc3QgTGF5b3V0UG9pbnQmKTsKIAorICAgIHZpcnR1YWwgdm9pZCByZXBhaW50Q29u dGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9i amVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3Q7CisKICAgICB1c2luZyBSZW5kZXJCb3hNb2Rl bE9iamVjdDo6Y29udGludWF0aW9uOwogICAgIHVzaW5nIFJlbmRlckJveE1vZGVsT2JqZWN0Ojpz ZXRDb250aW51YXRpb247CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJPYmplY3QuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaApp bmRleCA2YWY2ZTlhMmYxY2M5MDQwZDQ1YjM5ZWFmNzZhMjJiZWYyM2I3MmQyLi4yMzQxODhmYjM5 ODYxOThhN2M3ZWZjM2M3ZTNiNWQ5YTMxY2MzNTllIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlck9iamVjdC5oCkBAIC04ODAsNiArODgwLDggQEAgcHVibGljOgogICAgIAogICAgIHZp cnR1YWwgdm9pZCBhZGRGb2N1c1JpbmdSZWN0cyhWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlv dXRQb2ludCYpIHsgfTsKIAorICAgIHZpcnR1YWwgdm9pZCByZXBhaW50Q29udGFpbmVySGlnaGxp Z2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogLypyZXBh aW50Q29udGFpbmVyKi8pIGNvbnN0IHsgfQorCiAgICAgTGF5b3V0UmVjdCBhYnNvbHV0ZU91dGxp bmVCb3VuZHMoKSBjb25zdAogICAgIHsKICAgICAgICAgcmV0dXJuIG91dGxpbmVCb3VuZHNGb3JS ZXBhaW50KDApOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lw IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCmluZGV4IGE3NzVmNTQ1ZDEyMjg4 ZGJlZWM0YWNjYjc0YzI4YzZlOGE2NWY5YzcuLjFiOGY3MTg2YTI1YzMxZTRjODBmZjJhN2I2MzE5 MDQ2Y2JmMDI3ZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKQEAgLTU1MCw2ICs1NTAs OCBAQAogICAgICAgICAgICAgICAgICdzcmMvV2ViR2VvbG9jYXRpb25Qb3NpdGlvbi5jcHAnLAog ICAgICAgICAgICAgICAgICdzcmMvV2ViR2x5cGhDYWNoZS5jcHAnLAogICAgICAgICAgICAgICAg ICdzcmMvV2ViR3JhcGhpY3NDb250ZXh0M0QuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dl YkhpZ2hsaWdodC5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2ViSGlnaGxpZ2h0LmgnLAog ICAgICAgICAgICAgICAgICdzcmMvV2ViSGlzdG9yeUl0ZW0uY3BwJywKICAgICAgICAgICAgICAg ICAnc3JjL1dlYkhpdFRlc3RSZXN1bHQuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYklj b25Mb2FkaW5nQ29tcGxldGlvbkltcGwuY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJIaWdobGlnaHQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjhkZTJkZTU5MTE4YTdmMmM4NDFhZjVhYzkx MGQyYWEyNTYyMTQxODUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJIaWdobGlnaHQuY3BwCkBAIC0wLDAgKzEsMTAwIEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFu ZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4K KyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBv ZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUg cHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMg cHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklE RUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIg QU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U CisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorCisjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQorCisjaW5jbHVkZSAiV2ViSGln aGxpZ2h0LmgiCisKKyNpbmNsdWRlICJOb2RlLmgiCisjaW5jbHVkZSAiUGF0aC5oIgorI2luY2x1 ZGUgIlJlbmRlckJsb2NrLmgiCisjaW5jbHVkZSAiUmVuZGVyTGF5ZXIuaCIKKyNpbmNsdWRlICJS ZW5kZXJMYXllckJhY2tpbmcuaCIKKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVz cGFjZSBXZWJLaXQgeworCitXZWJIaWdobGlnaHQ6OldlYkhpZ2hsaWdodChOb2RlKiB0b3BOb2Rl KQoreworICAgIGlmICghdG9wTm9kZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yIChOb2Rl ICpub2RlID0gdG9wTm9kZTsgbm9kZTsgbm9kZSA9IG5vZGUtPnRyYXZlcnNlTmV4dE5vZGUodG9w Tm9kZSkpIHsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUtPnJlbmRlcmVy KCk7CisgICAgICAgIGlmICghcmVuZGVyZXIpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAg ICAgICBSZW5kZXJMYXllciogcmVwYWludExheWVyID0gcmVuZGVyZXItPmVuY2xvc2luZ0xheWVy KCktPmVuY2xvc2luZ0NvbXBvc2l0aW5nTGF5ZXJGb3JSZXBhaW50KCk7CisgICAgICAgIGlmICgh cmVwYWludExheWVyKSAvLyBtb3N0IGxpa2VseSB3ZSdyZSBub3QgaW4gSFctY29tcG9zaXRvciBt b2RlLi4uIGJldHRlciBkZXRlY3QgdGhpcyBlYXJseSBhbmQgcXVpdD8KKyAgICAgICAgICAgIGNv bnRpbnVlOworCisgICAgICAgIFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVy ID0gcmVwYWludExheWVyLT5yZW5kZXJlcigpOworCisgICAgICAgIEdyYXBoaWNzTGF5ZXIqIGdy YXBoaWNzTGF5ZXIgPSByZXBhaW50TGF5ZXItPmJhY2tpbmcoKS0+Z3JhcGhpY3NMYXllcigpOwor ICAgICAgICBQYXRoKiBwYXRoID0gbV9xdWFkTWFwLmdldChncmFwaGljc0xheWVyKTsKKyAgICAg ICAgaWYgKCFwYXRoKQorICAgICAgICAgICAgbV9xdWFkTWFwLnNldChncmFwaGljc0xheWVyLCBh ZG9wdFB0cihwYXRoID0gbmV3IFBhdGgoKSkpOworCisgICAgICAgIFZlY3RvcjxGbG9hdFF1YWQ+ IG5ld3F1YWRzOworICAgICAgICByZW5kZXJlci0+cmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1 YWRzKG5ld3F1YWRzLCByZXBhaW50Q29udGFpbmVyKTsKKworICAgICAgICBmb3IgKHNpemVfdCBp ID0gMDsgaSA8IG5ld3F1YWRzLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBGbG9hdFF1YWQg cXVhZCA9IG5ld3F1YWRzW2ldOworCisgICAgICAgICAgICBpZiAocXVhZC5pc1JlY3RpbGluZWFy KCkpIHsKKyAgICAgICAgICAgICAgICBGbG9hdFJlY3QgY2xpcHBlZCA9IHF1YWQuYm91bmRpbmdC b3goKTsKKworICAgICAgICAgICAgICAgIGZvciAoUmVuZGVyQmxvY2sgKmJsayA9IHJlbmRlcmVy LT5jb250YWluaW5nQmxvY2soKTsgYmxrICYmIGJsay0+aXNEZXNjZW5kYW50T2YocmVwYWludENv bnRhaW5lcik7IGJsayA9IGJsay0+Y29udGFpbmluZ0Jsb2NrKCkpIHsKKyAgICAgICAgICAgICAg ICAgICAgaWYgKCFibGstPmhhc092ZXJmbG93Q2xpcCgpKQorICAgICAgICAgICAgICAgICAgICAg ICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIEZsb2F0UXVhZCBib3VuZFF1YWQgPSBi bGstPmxvY2FsVG9Db250YWluZXJRdWFkKEZsb2F0UmVjdChibGstPnZpc3VhbE92ZXJmbG93UmVj dCgpKSwgcmVwYWludENvbnRhaW5lcik7CisgICAgICAgICAgICAgICAgICAgIGlmICghYm91bmRR dWFkLmlzUmVjdGlsaW5lYXIoKSkgLy8gZG9uJ3Qga25vdyBob3cgdG8gY2xpcCB0aGlzLiA6KAor ICAgICAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICAgICAgICAgIEZs b2F0UmVjdCBib3VuZFJlY3QgPSBib3VuZFF1YWQuYm91bmRpbmdCb3goKTsKKyAgICAgICAgICAg ICAgICAgICAgY2xpcHBlZC5pbnRlcnNlY3QoYm91bmRSZWN0KTsKKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgcXVhZCA9IEZsb2F0UXVhZChjbGlwcGVkKTsKKyAgICAgICAgICAg IH0KKworICAgICAgICAgICAgcGF0aC0+bW92ZVRvKHF1YWQucDEoKSk7CisgICAgICAgICAgICBw YXRoLT5hZGRMaW5lVG8ocXVhZC5wMigpKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZExpbmVUbyhx dWFkLnAzKCkpOworICAgICAgICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDQoKSk7CisgICAg ICAgICAgICBwYXRoLT5jbG9zZVN1YnBhdGgoKTsKKyAgICAgICAgfQorICAgIH0KK30KKworfSAv LyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJIaWdobGlnaHQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kOTg2ZTI0N2E0YzYzNDQyZTE4NDYxMmIwZGQ0YmIy Yzc4ZmNjZTdmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv V2ViSGlnaGxpZ2h0LmgKQEAgLTAsMCArMSw2NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9u IGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICog bW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBj b25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAg KiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisg KiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3Rz IGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdy aXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRI RSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkg RVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElN SVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJ VE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8g RVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViSGlnaGxpZ2h0X2gKKyNk ZWZpbmUgV2ViSGlnaGxpZ2h0X2gKKworI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykK KworI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL093blB0ci5oPgorI2lu Y2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK2NsYXNzIEdy YXBoaWNzTGF5ZXI7CitjbGFzcyBOb2RlOworY2xhc3MgUGF0aDsKK30KKworbmFtZXNwYWNlIFdl YktpdCB7CisKK2NsYXNzIFdlYkhpZ2hsaWdodCB7CitwdWJsaWM6CisgICAgc3RhdGljIGlubGlu ZSBQYXNzT3duUHRyPFdlYkhpZ2hsaWdodD4gY3JlYXRlKFdlYkNvcmU6Ok5vZGUqIG5vZGUpIHsg cmV0dXJuIGFkb3B0UHRyKG5ldyBXZWJIaWdobGlnaHQobm9kZSkpOyB9CisKKyAgICB0eXBlZGVm IEhhc2hNYXA8V2ViQ29yZTo6R3JhcGhpY3NMYXllciosIE93blB0cjxXZWJDb3JlOjpQYXRoPiA+ IFF1YWRNYXA7CisgICAgdHlwZWRlZiBRdWFkTWFwOjppdGVyYXRvciBpdGVyYXRvcjsKKworICAg IGlubGluZSBpdGVyYXRvciBiZWdpbigpIHsgcmV0dXJuIG1fcXVhZE1hcC5iZWdpbigpOyB9Cisg ICAgaW5saW5lIGl0ZXJhdG9yIGVuZCgpIHsgcmV0dXJuIG1fcXVhZE1hcC5lbmQoKTsgfQorcHJp dmF0ZToKKyAgICBleHBsaWNpdCBXZWJIaWdobGlnaHQoV2ViQ29yZTo6Tm9kZSopOworICAgIFF1 YWRNYXAgbV9xdWFkTWFwOworfTsKKworfQorCisjZW5kaWYKKworI2VuZGlmCg== 143183 2012-05-21 20:44:53 -0700 2012-05-23 22:12:43 -0700 Patch bug-84936-20120521204453.patch text/plain 24135 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE3ODIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzk4MzQzMGQzNjM4ZTdm NGMzYmU0MzVlNTExNjg2NWJkMTEwYWRmOS4uZjBiMDFlMDMxMjE3YTIzOTQyZTAyYWU3OGE5NzFj YTcwOTJiZDdiNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDEyLTA1LTIxICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBSZW5kZXJPYmplY3Q6OnJl cGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyBjYWxsLAorICAgICAgICB0byBnZW5lcmF0ZSB0 aGUgY2xpY2thYmxlIHJlZ2lvbiBmb3IgbGluayBoaWdobGlnaHRpbmcuCisKKyAgICAgICAgT25l IGltcG9ydGFudCBkaWZmZXJlbmNlIGZyb20gUmVuZGVyT2JqZWN0OjphYnNvbHV0ZVF1YWRzIGlz IHRoYXQKKyAgICAgICAgdGhlIHJldHVybmVkIHF1YWRzIHdpbGwgYmUgaW4gdGhlIGNvb3JkaW5h dGVzIG9mIGEgcmVwYWludCBjb250YWluZXIKKyAgICAgICAgc3BlY2lmaWVkIGJ5IHRoZSBjYWxs ZXIuIFRoaXMgd2lsbCBhbGxvdyB0aHJlYWRlZC1zY3JvbGxpbmcvYW5pbWF0aW9uCisgICAgICAg IHdpdGhvdXQgaGF2aW5nIHRvIHJlZ2VuZXJhdGUgdGhlIGhpZ2hsaWdodHMuCisKKyAgICAgICAg Tm8gbmV3IHRlc3RzLiBUZXN0cyB3aWxsIGJlIGFkZGVkIHdpdGggbGF0ZXIgcGF0Y2hlcyB0aGF0 IGFjdHVhbGx5CisgICAgICAgIGFkZCBoaWdobGlnaHQgdG8gbGF5ZXJzLgorCisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJsb2Nr OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJsb2NrLmg6CisgICAgICAgIChSZW5kZXJCbG9jayk6 CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpS ZW5kZXJCb3g6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94Lmg6CisgICAgICAgIChSZW5kZXJC b3gpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwOgorICAgICAgICAoV2Vi Q29yZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbmxpbmU6OnJlcGFpbnRDb250YWluZXJI aWdobGlnaHRRdWFkcyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGluZS5oOgorICAg ICAgICAoUmVuZGVySW5saW5lKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGln aHRRdWFkcyk6CisgICAgICAgIChSZW5kZXJPYmplY3QpOgorCiAyMDEyLTA1LTIxICBXLiBKYW1l cyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1d IEFkZCB0b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5ZXJzLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZwppbmRleCBjOWYzY2FhMzExNWQzOGE3YzlmYTQ2NWEzNWY2OTY0N2NiNTJiOGEz Li4xOTRjMWE5ZGI2YWFmOTRjYjhmZmNmZWMzMDRkMTdkZjAxZmU1YzgyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEyLTA1LTIxICBUaWVuLVJlbiBDaGVu ICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENvbXB1dGUgaGln aGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXZWJIaWdobGlnaHQgY2xhc3Mgd2hpY2ggY2FuIGJlIHVzZWQg dG8gZGV0ZXJtaW5lCisgICAgICAgIHRoZSBoaWdobGlnaHQgcmVnaW9uIGZvciBzcGVjaWZpZWQg dG91Y2ggdGFyZ2V0IG5vZGUuCisKKyAgICAgICAgKiBXZWJLaXQuZ3lwOgorICAgICAgICAqIHNy Yy9XZWJIaWdobGlnaHQuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChX ZWJLaXQ6OldlYkhpZ2hsaWdodDo6V2ViSGlnaGxpZ2h0KToKKyAgICAgICAgKiBzcmMvV2ViSGln aGxpZ2h0Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJLaXQpOgor ICAgICAgICAoV2ViSGlnaGxpZ2h0KToKKyAgICAgICAgKFdlYktpdDo6V2ViSGlnaGxpZ2h0Ojpj cmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHQ6OmJlZ2luKToKKyAgICAgICAg KFdlYktpdDo6V2ViSGlnaGxpZ2h0OjplbmQpOgorCiAyMDEyLTA1LTIxICBXLiBKYW1lcyBNYWNM ZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1dIEFkZCB0 b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5ZXJzLgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggMWRlMGQ4NzNlMDVmZjExM2E4ZDRkODE3OGVkYmY1 YjA0ZGVkYjJiMC4uOWM2ZTVhYzkyOGJmNzEyNzNiNmM0NDc2ODY2YjU4ZDk4Njg1NTY4ZCAxMDA3 NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCkBAIC02NTk1LDYgKzY1OTUs MTQgQEAgdm9pZCBSZW5kZXJCbG9jazo6YWRkRm9jdXNSaW5nUmVjdHMoVmVjdG9yPEludFJlY3Q+ JiByZWN0cywgY29uc3QgTGF5b3V0UG9pbnQmIGEKICAgICAgICAgaW5saW5lRWxlbWVudENvbnRp bnVhdGlvbigpLT5hZGRGb2N1c1JpbmdSZWN0cyhyZWN0cywgZmxvb3JlZExheW91dFBvaW50KGFk ZGl0aW9uYWxPZmZzZXQgKyBpbmxpbmVFbGVtZW50Q29udGludWF0aW9uKCktPmNvbnRhaW5pbmdC bG9jaygpLT5sb2NhdGlvbigpIC0gbG9jYXRpb24oKSkpOwogfQogCit2b2lkIFJlbmRlckJsb2Nr OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRz LCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QKK3sKKyAgICBS ZW5kZXJCb3g6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhxdWFkcywgcmVwYWludENv bnRhaW5lcik7CisKKyAgICBpZiAoY29udGludWF0aW9uKCkpCisgICAgICAgIGNvbnRpbnVhdGlv bigpLT5yZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMocXVhZHMsIHJlcGFpbnRDb250YWlu ZXIpOworfQorCiBSZW5kZXJCb3gqIFJlbmRlckJsb2NrOjpjcmVhdGVBbm9ueW1vdXNCb3hXaXRo U2FtZVR5cGVBcyhjb25zdCBSZW5kZXJPYmplY3QqIHBhcmVudCkgY29uc3QKIHsKICAgICBpZiAo aXNBbm9ueW1vdXNDb2x1bW5zQmxvY2soKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCbG9jay5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJs b2NrLmgKaW5kZXggZGY0YTZhMmYwOTU3NWY0MDU2Zjg5MTU4MDkwZDhjNjkxZDdhZjY5ZC4uYWRj OGEzYjhiN2NkYzBjM2E0MWFiMWVmNzUyYTUwMjZlMTMzMzQ4YyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJsb2NrLmgKQEAgLTQ0Nyw2ICs0NDcsOCBAQCBwcm90ZWN0ZWQ6CiAKICAg ICB2aXJ0dWFsIHZvaWQgYWRkRm9jdXNSaW5nUmVjdHMoVmVjdG9yPEludFJlY3Q+JiwgY29uc3Qg TGF5b3V0UG9pbnQmKTsKIAorICAgIHZpcnR1YWwgdm9pZCByZXBhaW50Q29udGFpbmVySGlnaGxp Z2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWlu dENvbnRhaW5lcikgY29uc3Q7CisKICNpZiBFTkFCTEUoU1ZHKQogICAgIC8vIE9ubHkgdXNlZCBi eSBSZW5kZXJTVkdUZXh0LCB3aGljaCBleHBsaWNpdGVseSBvdmVycmlkZXMgUmVuZGVyQmxvY2s6 OmxheW91dEJsb2NrKCksIGRvIE5PVCB1c2UgZm9yIGFueXRoaW5nIGVsc2UuCiAgICAgdm9pZCBm b3JjZUxheW91dElubGluZUNoaWxkcmVuKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCb3guY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJv eC5jcHAKaW5kZXggYmQ4YzJkYTU1ZjMwMDcxMGM4NDY2MTk0NTk2MzFhZjU4YjczMzE1Yy4uMjBh ZjUzODY5NmQ2ZWU2MGI3MWQyMTU5NDZkMDdjNGUxNjQxY2VkOSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJveC5jcHAKQEAgLTU5MSw2ICs1OTEsMTIgQEAgdm9pZCBSZW5kZXJCb3g6 OmFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0PiYgcmVjdHMsIGNvbnN0IExheW91dFBv aW50JiBhZGQKICAgICAgICAgcmVjdHMuYXBwZW5kKHBpeGVsU25hcHBlZEludFJlY3QoYWRkaXRp b25hbE9mZnNldCwgc2l6ZSgpKSk7CiB9CiAKK3ZvaWQgUmVuZGVyQm94OjpyZXBhaW50Q29udGFp bmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hNb2Rl bE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QKK3sKKyAgICBpZiAoIXNpemUoKS5pc0Vt cHR5KCkpCisgICAgICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJl Y3QoMCwgMCwgd2lkdGgoKSwgaGVpZ2h0KCkpLCByZXBhaW50Q29udGFpbmVyLCBmYWxzZSwgMCkp OworfQorCiBMYXlvdXRSZWN0IFJlbmRlckJveDo6cmVmbGVjdGlvbkJveCgpIGNvbnN0CiB7CiAg ICAgTGF5b3V0UmVjdCByZXN1bHQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQm94LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmgKaW5k ZXggMzgxOWRmNTBlY2JhZWQ5MmVkYzJiOWU4ZTFmNjg1NjVjYjlhOGMyOS4uODRjYjdjNjIxYjE5 ODcxZGZhMWZiZmI2NDYzNDZlODgwN2VhM2U0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckJveC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJCb3guaApAQCAtMTUyLDYgKzE1Miw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIExheW91dFJl Y3Qgb3V0bGluZUJvdW5kc0ZvclJlcGFpbnQoUmVuZGVyQm94TW9kZWxPYmplY3QqIC8qcmVwYWlu dENvbnRhaW5lciovLCBMYXlvdXRQb2ludCogY2FjaGVkT2Zmc2V0VG9SZXBhaW50Q29udGFpbmVy KSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgYWRkRm9jdXNSaW5nUmVjdHMoVmVjdG9yPEludFJl Y3Q+JiwgY29uc3QgTGF5b3V0UG9pbnQmKTsKIAorICAgIHZpcnR1YWwgdm9pZCByZXBhaW50Q29u dGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9i amVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3Q7CisKICAgICAvLyBVc2UgdGhpcyB3aXRoIGNh dXRpb24hIE5vIHR5cGUgY2hlY2tpbmcgaXMgZG9uZSEKICAgICBSZW5kZXJCb3gqIHByZXZpb3Vz U2libGluZ0JveCgpIGNvbnN0OwogICAgIFJlbmRlckJveCogbmV4dFNpYmxpbmdCb3goKSBjb25z dDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5jcHAKaW5kZXggMzhhODc0 YjRhMWEwNTZmYzA5ZDk4YzBjNGRlNjNiNTgzYjEyMzVmMC4uMjhjYTFlYmYxZjJmNzBlZTdkOThi MzVhYjY1ZjU1MDdmZGJkODViNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlcklubGluZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklu bGluZS5jcHAKQEAgLTE0NTgsNiArMTQ1OCwxNSBAQCB2b2lkIFJlbmRlcklubGluZTo6cGFpbnRP dXRsaW5lRm9yTGluZShHcmFwaGljc0NvbnRleHQqIGdyYXBoaWNzQ29udGV4dCwgY29uc3QgTAog ICAgICAgICAgICAgYW50aWFsaWFzKTsKIH0KIAordm9pZCBSZW5kZXJJbmxpbmU6OnJlcGFpbnRD b250YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRlckJv eE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIGZvciAoSW5saW5l Rmxvd0JveCogY3VyciA9IGZpcnN0TGluZUJveCgpOyBjdXJyOyBjdXJyID0gY3Vyci0+bmV4dExp bmVCb3goKSkKKyAgICAgICAgcXVhZHMuYXBwZW5kKGxvY2FsVG9Db250YWluZXJRdWFkKEZsb2F0 UmVjdChjdXJyLT50b3BMZWZ0KCksIGN1cnItPnNpemUoKSksIHJlcGFpbnRDb250YWluZXIpKTsK KworICAgIGlmIChjb250aW51YXRpb24oKSkKKyAgICAgICAgY29udGludWF0aW9uKCktPnJlcGFp bnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhxdWFkcywgcmVwYWludENvbnRhaW5lcik7Cit9CisK ICNpZiBFTkFCTEUoREFTSEJPQVJEX1NVUFBPUlQpCiB2b2lkIFJlbmRlcklubGluZTo6YWRkRGFz aGJvYXJkUmVnaW9ucyhWZWN0b3I8RGFzaGJvYXJkUmVnaW9uVmFsdWU+JiByZWdpb25zKQogewpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCmluZGV4IGMxNTMyY2Y1NjhmYjQ1 ZWJiNGYzMTQ3N2Q3YWYyYmMyNWJmNWI2YjcuLjUwNjE0NzI4ZTE5YmJkZjgyOWUwODkyMDhkODlk OGE3OTAxZGRjMTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJ bmxpbmUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmgKQEAg LTc2LDYgKzc2LDggQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBhZGRGb2N1c1JpbmdSZWN0 cyhWZWN0b3I8SW50UmVjdD4mLCBjb25zdCBMYXlvdXRQb2ludCYpOwogICAgIHZvaWQgcGFpbnRP dXRsaW5lKEdyYXBoaWNzQ29udGV4dCosIGNvbnN0IExheW91dFBvaW50Jik7CiAKKyAgICB2aXJ0 dWFsIHZvaWQgcmVwYWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+ JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0OworCiAgICAg dXNpbmcgUmVuZGVyQm94TW9kZWxPYmplY3Q6OmNvbnRpbnVhdGlvbjsKICAgICB1c2luZyBSZW5k ZXJCb3hNb2RlbE9iamVjdDo6c2V0Q29udGludWF0aW9uOwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmgKaW5kZXggOTI2OWRmMWE5YmVkNjA4MDU0Zjk5YzNjNTU1YTJkOWRi MWQyMWQyOC4uYzI1MTRiZGNjM2E5NzlmMDhhOGUwM2JiOTFmMDYyYmUzOTQxZGNmNyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtODgxLDYgKzg4MSw4IEBAIHB1 YmxpYzoKICAgICAKICAgICB2aXJ0dWFsIHZvaWQgYWRkRm9jdXNSaW5nUmVjdHMoVmVjdG9yPElu dFJlY3Q+JiwgY29uc3QgTGF5b3V0UG9pbnQmKSB7IH07CiAKKyAgICB2aXJ0dWFsIHZvaWQgcmVw YWludENvbnRhaW5lckhpZ2hsaWdodFF1YWRzKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94 TW9kZWxPYmplY3QqIC8qcmVwYWludENvbnRhaW5lciovKSBjb25zdCB7IH0KKwogICAgIExheW91 dFJlY3QgYWJzb2x1dGVPdXRsaW5lQm91bmRzKCkgY29uc3QKICAgICB7CiAgICAgICAgIHJldHVy biBvdXRsaW5lQm91bmRzRm9yUmVwYWludCgwKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJUZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJUZXh0LmNwcAppbmRleCAxNmMxZWExNzI3OTBkYjM0NGQ0MWVhNTlhNmQ3NjFlZTZkY2VlMTNi Li44ZTlmMDhjZjE3NmQxYzkyZjA1MzUzNjJmNjFjNGI1NTI4MjhlMDNjIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlclRleHQuY3BwCkBAIC00NTYsNiArNDU2LDEyIEBAIHZvaWQgUmVu ZGVyVGV4dDo6YWJzb2x1dGVRdWFkc0ZvclJhbmdlKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywg dW5zaWduZWQgc3RhcnQsCiAgICAgfQogfQogCit2b2lkIFJlbmRlclRleHQ6OnJlcGFpbnRDb250 YWluZXJIaWdobGlnaHRRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRlckJveE1v ZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIGZvciAoSW5saW5lVGV4 dEJveCogYm94ID0gZmlyc3RUZXh0Qm94KCk7IGJveDsgYm94ID0gYm94LT5uZXh0VGV4dEJveCgp KQorICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KGJv eC0+dG9wTGVmdCgpLCBib3gtPnNpemUoKSksIHJlcGFpbnRDb250YWluZXIsIGZhbHNlLCAwKSk7 Cit9CisKIElubGluZVRleHRCb3gqIFJlbmRlclRleHQ6OmZpbmROZXh0SW5saW5lVGV4dEJveChp bnQgb2Zmc2V0LCBpbnQmIHBvcykgY29uc3QKIHsKICAgICAvLyBUaGUgdGV4dCBydW5zIHBvaW50 IHRvIHBhcnRzIG9mIHRoZSBSZW5kZXJUZXh0J3MgbV90ZXh0CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlclRleHQuaAppbmRleCA4MTU3ZTM3ZWJjN2Q3ODJkMDI3MThkZmQwNjJkNWVkMTA5ODA3 ZGQ5Li5lZTNhNTZlOWI1ZDE2YTQ5NGM5MTI0ODY5MGQ1OTViYjczYjJmYjFmIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dC5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0LmgKQEAgLTY0LDYgKzY0LDggQEAgcHVibGljOgogICAg IGVudW0gQ2xpcHBpbmdPcHRpb24geyBOb0NsaXBwaW5nLCBDbGlwVG9FbGxpcHNpcyB9OwogICAg IHZvaWQgYWJzb2x1dGVRdWFkcyhWZWN0b3I8RmxvYXRRdWFkPiYsIGJvb2wqIHdhc0ZpeGVkID0g MCwgQ2xpcHBpbmdPcHRpb24gPSBOb0NsaXBwaW5nKSBjb25zdDsKIAorICAgIHZpcnR1YWwgdm9p ZCByZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5k ZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3Q7CisKICAgICB2aXJ0dWFs IFZpc2libGVQb3NpdGlvbiBwb3NpdGlvbkZvclBvaW50KGNvbnN0IExheW91dFBvaW50Jik7CiAK ICAgICBjb25zdCBVQ2hhciogY2hhcmFjdGVycygpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dC5jaGFy YWN0ZXJzKCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5 cCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAppbmRleCA4N2FjN2I4Y2U5ZmE4 YjViYTMyNTQyODA5MzAzNGJkMmM5YTQxNjAxLi4zOTZjZDUxOWNmNWY2OTNiNDkzMjUwNzVlMzg3 YWE4YThiNGQzZjBjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5n eXAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCkBAIC01NTUsNiArNTU1 LDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYkdlb2xvY2F0aW9uUG9zaXRpb24uY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYkdseXBoQ2FjaGUuY3BwJywKICAgICAgICAgICAgICAg ICAnc3JjL1dlYkdyYXBoaWNzQ29udGV4dDNELmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9X ZWJIaWdobGlnaHQuY3BwJywKKyAgICAgICAgICAgICAgICAnc3JjL1dlYkhpZ2hsaWdodC5oJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYkhpc3RvcnlJdGVtLmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJIaXRUZXN0UmVzdWx0LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJJ Y29uTG9hZGluZ0NvbXBsZXRpb25JbXBsLmNwcCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5jcHAKaW5kZXggYjFmMTYyMTA0 ZmNjNTViNTE4MzQwZDhjMDMyYjE1OThlNjBlNjM5YS4uYTg4NTRhYjExY2Y5OTVhMDlkMGQ2YmMy ODQ3OWY4MzAyZjE4ZjYwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv VG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLmNwcApAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1 ZGUgIkdyYXBoaWNzTGF5ZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIkxpbmtIaWdobGlnaHQuaCIK ICNpbmNsdWRlICJQYXRoLmgiCisjaW5jbHVkZSAiV2ViSGlnaGxpZ2h0LmgiCiAKIHVzaW5nIG5h bWVzcGFjZSBXZWJDb3JlOwogCkBAIC00NCwyOCArNDUsMzUgQEAgVG91Y2hMaW5rSGlnaGxpZ2h0 VGltZXI6On5Ub3VjaExpbmtIaWdobGlnaHRUaW1lcigpCiB7CiB9CiAKLXZvaWQgVG91Y2hMaW5r SGlnaGxpZ2h0VGltZXI6OnRyaWdnZXJUb3VjaExpbmtIaWdobGlnaHQoY29uc3QgUGF0aCBwYXRo LCBHcmFwaGljc0xheWVyQ2hyb21pdW0qIGxheWVyLCBjb25zdCBkb3VibGUgYW5pbWF0aW9uU3Rh cnREZWxheSkKK3ZvaWQgVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXI6OnRyaWdnZXJUb3VjaExpbmtI aWdobGlnaHQoY29uc3QgV2ViSGlnaGxpZ2h0JiBoaWdobGlnaHQsIGNvbnN0IGRvdWJsZSBhbmlt YXRpb25TdGFydERlbGF5KQogewogICAgIHN0b3AoQ2FuY2VsQWN0aXZlQW5pbWF0aW9uKTsgLy8g U3RvcCBpbi1mbGlnaHQgb3IgcGVuZGluZyBhbmltYXRpb25zLgogCi0gICAgaWYgKGxheWVyKSB7 Ci0gICAgICAgIG1fbGlua0hpZ2hsaWdodCA9IGxheWVyLT5hZGRMaW5rSGlnaGxpZ2h0KHBhdGgp OwotICAgICAgICAvLyBGSVhNRTogV2UgaGFuZGxlIHN0YXJ0RGVsYXkgPT0gMCBzZXBhcmF0ZWx5 IHRvIGZhY2lsaXRhdGUgdGVzdGluZywgaXQgd291bGQgYmUgbmljZSB0byBub3QgbmVlZCB0by4K LSAgICAgICAgaWYgKGFuaW1hdGlvblN0YXJ0RGVsYXkpCi0gICAgICAgICAgICBtX3RpbWVyLnN0 YXJ0T25lU2hvdChhbmltYXRpb25TdGFydERlbGF5KTsKLSAgICAgICAgZWxzZQotICAgICAgICAg ICAgZmlyZWQoMCk7CisgICAgZm9yIChXZWJIaWdobGlnaHQ6OlF1YWRNYXA6OmNvbnN0X2l0ZXJh dG9yIGkgPSBoaWdobGlnaHQucXVhZE1hcCgpLmJlZ2luKCk7IGkgIT0gaGlnaGxpZ2h0LnF1YWRN YXAoKS5lbmQoKTsgKytpKSB7CisgICAgICAgIGlmICghaS0+Zmlyc3QpCisgICAgICAgICAgICBj b250aW51ZTsKKyAgICAgICAgR3JhcGhpY3NMYXllckNocm9taXVtKiBsYXllciA9IHN0YXRpY19j YXN0PEdyYXBoaWNzTGF5ZXJDaHJvbWl1bSo+KGktPmZpcnN0KTsKKworICAgICAgICBtX2xpbmtI aWdobGlnaHRzLmFwcGVuZChsYXllci0+YWRkTGlua0hpZ2hsaWdodCgqaS0+c2Vjb25kKSk7CiAg ICAgfQorCisgICAgLy8gRklYTUU6IFdlIGhhbmRsZSBzdGFydERlbGF5ID09IDAgc2VwYXJhdGVs eSB0byBmYWNpbGl0YXRlIHRlc3RpbmcsIGl0IHdvdWxkIGJlIG5pY2UgdG8gbm90IG5lZWQgdG8u CisgICAgaWYgKGFuaW1hdGlvblN0YXJ0RGVsYXkpCisgICAgICAgIG1fdGltZXIuc3RhcnRPbmVT aG90KGFuaW1hdGlvblN0YXJ0RGVsYXkpOworICAgIGVsc2UKKyAgICAgICAgZmlyZWQoMCk7CiB9 CiAKIHZvaWQgVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXI6OmZpcmVkKFRpbWVyPFRvdWNoTGlua0hp Z2hsaWdodFRpbWVyPiopCiB7Ci0gICAgaWYgKG1fbGlua0hpZ2hsaWdodCkgewotICAgICAgICAv LyBJZiB0aGVyZSdzIG5vIHBhcmVudCwgaXQgbWVhbnMgdGhlIEdyYXBoaWNzTGF5ZXJDaHJvbWl1 bSBoYXMgZGlzYXBwZWFyZWQsIGFuZCB0aGUgbGluayBoaWdobGlnaHQgc2hvdWxkIHRvby4KLSAg ICAgICAgaWYgKG1fbGlua0hpZ2hsaWdodC0+cGFyZW50KCkpCi0gICAgICAgICAgICBtX2xpbmtI aWdobGlnaHQtPnN0YXJ0SGlnaGxpZ2h0QW5pbWF0aW9uKCk7Ci0gICAgICAgIGVsc2UKLSAgICAg ICAgICAgIG1fbGlua0hpZ2hsaWdodC5jbGVhcigpOworICAgIGZvciAoVmVjdG9yPFJlZlB0cjxM aW5rSGlnaGxpZ2h0PiA+OjppdGVyYXRvciBpID0gbV9saW5rSGlnaGxpZ2h0cy5iZWdpbigpOyBp ICE9IG1fbGlua0hpZ2hsaWdodHMuZW5kKCk7IGkrKykgeworICAgICAgICBpZiAoTGlua0hpZ2hs aWdodCogaGlnaGxpZ2h0ID0gaS0+Z2V0KCkpIHsKKyAgICAgICAgICAgIC8vIElmIHRoZXJlJ3Mg bm8gcGFyZW50LCBpdCBtZWFucyB0aGUgR3JhcGhpY3NMYXllckNocm9taXVtIGhhcyBkaXNhcHBl YXJlZCwgYW5kIHRoZSBsaW5rIGhpZ2hsaWdodCBzaG91bGQgdG9vLgorICAgICAgICAgICAgaWYg KGhpZ2hsaWdodC0+cGFyZW50KCkpCisgICAgICAgICAgICAgICAgaGlnaGxpZ2h0LT5zdGFydEhp Z2hsaWdodEFuaW1hdGlvbigpOworICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgIGkt PmNsZWFyKCk7CisgICAgICAgIH0KICAgICB9CiB9CiAKQEAgLTczLDEwICs4MSwxNSBAQCB2b2lk IFRvdWNoTGlua0hpZ2hsaWdodFRpbWVyOjpzdG9wKFRvdWNoSGlnaGxpZ2h0QWN0aXZlQW5pbWF0 aW9uQWN0aW9uIGFjdGlvbikKIHsKICAgICBtX3RpbWVyLnN0b3AoKTsKIAotICAgIGlmIChhY3Rp b24gPT0gQ2FuY2VsQWN0aXZlQW5pbWF0aW9uICYmIG1fbGlua0hpZ2hsaWdodCAmJiBtX2xpbmtI aWdobGlnaHQtPnBhcmVudCgpKQotICAgICAgICBtX2xpbmtIaWdobGlnaHQtPnBhcmVudCgpLT5k aWRGaW5pc2hMaW5rSGlnaGxpZ2h0KCk7CisgICAgaWYgKGFjdGlvbiA9PSBDYW5jZWxBY3RpdmVB bmltYXRpb24pIHsKKyAgICAgICAgZm9yIChWZWN0b3I8UmVmUHRyPExpbmtIaWdobGlnaHQ+ID46 Oml0ZXJhdG9yIGkgPSBtX2xpbmtIaWdobGlnaHRzLmJlZ2luKCk7IGkgIT0gbV9saW5rSGlnaGxp Z2h0cy5lbmQoKTsgaSsrKSB7CisgICAgICAgICAgICBMaW5rSGlnaGxpZ2h0KiBoaWdobGlnaHQg PSBpLT5nZXQoKTsKKyAgICAgICAgICAgIGlmIChoaWdobGlnaHQgJiYgaGlnaGxpZ2h0LT5wYXJl bnQoKSkKKyAgICAgICAgICAgICAgICBoaWdobGlnaHQtPnBhcmVudCgpLT5kaWRGaW5pc2hMaW5r SGlnaGxpZ2h0KCk7CisgICAgICAgIH0KKyAgICB9CiAKLSAgICBtX2xpbmtIaWdobGlnaHQuY2xl YXIoKTsKKyAgICBtX2xpbmtIaWdobGlnaHRzLmNsZWFyKCk7CiB9CiAKIH0gLy8gbmFtZXNwYWNl IFdlYktpdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5r SGlnaGxpZ2h0VGltZXIuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RvdWNoTGlua0hp Z2hsaWdodFRpbWVyLmgKaW5kZXggYTc0YWQzYjcxMmE3M2JlNzcxNDliMThlZmNiNzk2MjU5NTQx ZTJhMy4uZmQ2YzA4ZjFmMmQ5ODQzNjcyMGFlMjYwZjNhYWIyZGY0M2IwYzI0ZSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuaAor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5o CkBAIC00MCw2ICs0MCw4IEBAIGNsYXNzIExpbmtIaWdobGlnaHQ7CiAKIG5hbWVzcGFjZSBXZWJL aXQgewogCitjbGFzcyBXZWJIaWdobGlnaHQ7CisKIGNsYXNzIFRvdWNoTGlua0hpZ2hsaWdodFRp bWVyIHsKIHB1YmxpYzoKICAgICBlbnVtIFRvdWNoSGlnaGxpZ2h0QWN0aXZlQW5pbWF0aW9uQWN0 aW9uIHsgSWdub3JlQWN0aXZlQW5pbWF0aW9uLCBDYW5jZWxBY3RpdmVBbmltYXRpb24gfTsKQEAg LTQ4LDEyICs1MCwxMiBAQCBwdWJsaWM6CiAgICAgflRvdWNoTGlua0hpZ2hsaWdodFRpbWVyKCk7 CiAKICAgICB2b2lkIGZpcmVkKFdlYkNvcmU6OlRpbWVyPFRvdWNoTGlua0hpZ2hsaWdodFRpbWVy PiopOwotICAgIHZvaWQgdHJpZ2dlclRvdWNoTGlua0hpZ2hsaWdodChjb25zdCBXZWJDb3JlOjpQ YXRoLCBXZWJDb3JlOjpHcmFwaGljc0xheWVyQ2hyb21pdW0qLCBjb25zdCBkb3VibGUgYW5pbWF0 aW9uU3RhcnREZWxheSk7CisgICAgdm9pZCB0cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KGNvbnN0 IFdlYkhpZ2hsaWdodCYsIGNvbnN0IGRvdWJsZSBhbmltYXRpb25TdGFydERlbGF5KTsKICAgICB2 b2lkIHN0b3AoVG91Y2hIaWdobGlnaHRBY3RpdmVBbmltYXRpb25BY3Rpb24pOwogCiBwcml2YXRl OgogICAgIFdlYkNvcmU6OlRpbWVyPFRvdWNoTGlua0hpZ2hsaWdodFRpbWVyPiBtX3RpbWVyOwot ICAgIFdURjo6UmVmUHRyPFdlYkNvcmU6OkxpbmtIaWdobGlnaHQ+IG1fbGlua0hpZ2hsaWdodDsK KyAgICBXVEY6OlZlY3RvcjxXVEY6OlJlZlB0cjxXZWJDb3JlOjpMaW5rSGlnaGxpZ2h0PiA+IG1f bGlua0hpZ2hsaWdodHM7CiB9OwogCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJI aWdobGlnaHQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjJkYjkwMjI2NmI2NDEzMjYxYmFjZmFjYjQxMGY5OWJl MzA5OTAwNDMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9X ZWJIaWdobGlnaHQuY3BwCkBAIC0wLDAgKzEsMTA4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAy MDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRp b24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Cisg KiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5n IGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9m IHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAq ICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUg YWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAg ICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMK KyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVj dHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Ig d3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkg VEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUws IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QK KyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisj aWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQorCisjaW5jbHVkZSAiV2ViSGlnaGxpZ2h0 LmgiCisKKyNpbmNsdWRlICJOb2RlLmgiCisjaW5jbHVkZSAiUGF0aC5oIgorI2luY2x1ZGUgIlJl bmRlckJsb2NrLmgiCisjaW5jbHVkZSAiUmVuZGVyTGF5ZXIuaCIKKyNpbmNsdWRlICJSZW5kZXJM YXllckJhY2tpbmcuaCIKKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBX ZWJLaXQgeworCitXZWJIaWdobGlnaHQ6OldlYkhpZ2hsaWdodChOb2RlKiB0b3BOb2RlKQorewor ICAgIGNvbnN0IGZsb2F0IHJvdW5kZWRFZGdlUGFkZGluZyA9IDQ7CisKKyAgICBpZiAoIXRvcE5v ZGUpCisgICAgICAgIHJldHVybjsKKworICAgIGZvciAoTm9kZSAqbm9kZSA9IHRvcE5vZGU7IG5v ZGU7IG5vZGUgPSBub2RlLT50cmF2ZXJzZU5leHROb2RlKHRvcE5vZGUpKSB7CisgICAgICAgIFJl bmRlck9iamVjdCogcmVuZGVyZXIgPSBub2RlLT5yZW5kZXJlcigpOworICAgICAgICBpZiAoIXJl bmRlcmVyKQorICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgUmVuZGVyTGF5ZXIqIHJl cGFpbnRMYXllciA9IHJlbmRlcmVyLT5lbmNsb3NpbmdMYXllcigpLT5lbmNsb3NpbmdDb21wb3Np dGluZ0xheWVyRm9yUmVwYWludCgpOworICAgICAgICBpZiAoIXJlcGFpbnRMYXllcikgLy8gbW9z dCBsaWtlbHkgd2UncmUgbm90IGluIEhXLWNvbXBvc2l0b3IgbW9kZS4uLiBiZXR0ZXIgZGV0ZWN0 IHRoaXMgZWFybHkgYW5kIHF1aXQ/CisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBS ZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciA9IHJlcGFpbnRMYXllci0+cmVu ZGVyZXIoKTsKKworICAgICAgICBHcmFwaGljc0xheWVyKiBncmFwaGljc0xheWVyID0gcmVwYWlu dExheWVyLT5iYWNraW5nKCktPmdyYXBoaWNzTGF5ZXIoKTsKKyAgICAgICAgUGF0aCogcGF0aCA9 IG1fcXVhZE1hcC5nZXQoZ3JhcGhpY3NMYXllcik7CisgICAgICAgIGlmICghcGF0aCkKKyAgICAg ICAgICAgIG1fcXVhZE1hcC5zZXQoZ3JhcGhpY3NMYXllciwgYWRvcHRQdHIocGF0aCA9IG5ldyBQ YXRoKCkpKTsKKworICAgICAgICBWZWN0b3I8RmxvYXRRdWFkPiBuZXdxdWFkczsKKyAgICAgICAg cmVuZGVyZXItPnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyhuZXdxdWFkcywgcmVwYWlu dENvbnRhaW5lcik7CisKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBuZXdxdWFkcy5z aXplKCk7IGkrKykgeworICAgICAgICAgICAgRmxvYXRRdWFkIHF1YWQgPSBuZXdxdWFkc1tpXTsK KworICAgICAgICAgICAgaWYgKHF1YWQuaXNSZWN0aWxpbmVhcigpKSB7CisgICAgICAgICAgICAg ICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJvdW5kaW5nQm94KCk7CisKKyAgICAgICAgICAg ICAgICBmb3IgKFJlbmRlckJsb2NrICpibGsgPSByZW5kZXJlci0+Y29udGFpbmluZ0Jsb2NrKCk7 IGJsayAmJiBibGstPmlzRGVzY2VuZGFudE9mKHJlcGFpbnRDb250YWluZXIpOyBibGsgPSBibGst PmNvbnRhaW5pbmdCbG9jaygpKSB7CisgICAgICAgICAgICAgICAgICAgIGlmICghYmxrLT5oYXNP dmVyZmxvd0NsaXAoKSkKKyAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAg ICAgICAgICAgICAgICBGbG9hdFF1YWQgYm91bmRRdWFkID0gYmxrLT5sb2NhbFRvQ29udGFpbmVy UXVhZChGbG9hdFJlY3QoYmxrLT52aXN1YWxPdmVyZmxvd1JlY3QoKSksIHJlcGFpbnRDb250YWlu ZXIpOworICAgICAgICAgICAgICAgICAgICBpZiAoIWJvdW5kUXVhZC5pc1JlY3RpbGluZWFyKCkp IC8vIGRvbid0IGtub3cgaG93IHRvIGNsaXAgdGhpcy4gOigKKyAgICAgICAgICAgICAgICAgICAg ICAgIGNvbnRpbnVlOworICAgICAgICAgICAgICAgICAgICBGbG9hdFJlY3QgYm91bmRSZWN0ID0g Ym91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAgICAgICAgICAgICAgIGNsaXBwZWQuaW50 ZXJzZWN0KGJvdW5kUmVjdCk7CisgICAgICAgICAgICAgICAgfQorCisgICAgICAgICAgICAgICAg aWYgKCFjbGlwcGVkLmlzRW1wdHkoKSkgeworICAgICAgICAgICAgICAgICAgICBjbGlwcGVkLmlu ZmxhdGUocm91bmRlZEVkZ2VQYWRkaW5nKTsKKyAgICAgICAgICAgICAgICAgICAgY29uc3QgRmxv YXRTaXplIHBhZGRpbmcocm91bmRlZEVkZ2VQYWRkaW5nLCByb3VuZGVkRWRnZVBhZGRpbmcpOwor ICAgICAgICAgICAgICAgICAgICBwYXRoLT5hZGRQYXRoRm9yUm91bmRlZFJlY3QoY2xpcHBlZCwg cGFkZGluZywgcGFkZGluZywgcGFkZGluZywgcGFkZGluZyk7CisgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAgICAgfQorCisgICAgICAgICAgICBw YXRoLT5tb3ZlVG8ocXVhZC5wMSgpKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZExpbmVUbyhxdWFk LnAyKCkpOworICAgICAgICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDMoKSk7CisgICAgICAg ICAgICBwYXRoLT5hZGRMaW5lVG8ocXVhZC5wNCgpKTsKKyAgICAgICAgICAgIHBhdGgtPmNsb3Nl U3VicGF0aCgpOworICAgICAgICB9CisgICAgfQorfQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQK KworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIaWdo bGlnaHQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjI1MjY0NDlmMjQ1ZTUwODNhZWJlYTgwNGQ5NDNjODU0MWFhZmNjNmMKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIaWdobGlnaHQuaApAQCAt MCwwICsxLDY0IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyIEdvb2dsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBt ZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0 YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9u cyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUg b2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkg YmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0 aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJT IEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFS VElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09Q WVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICog REFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2lmbmRlZiBXZWJIaWdobGlnaHRfaAorI2RlZmluZSBXZWJIaWdobGlnaHRf aAorCisjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQorCisjaW5jbHVkZSA8d3RmL0hh c2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+CisjaW5jbHVkZSA8d3RmL1Bhc3NPd25Q dHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworY2xhc3MgR3JhcGhpY3NMYXllcjsKK2NsYXNz IE5vZGU7CitjbGFzcyBQYXRoOworfQorCituYW1lc3BhY2UgV2ViS2l0IHsKKworY2xhc3MgV2Vi SGlnaGxpZ2h0IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgaW5saW5lIFBhc3NPd25QdHI8V2ViSGln aGxpZ2h0PiBjcmVhdGUoV2ViQ29yZTo6Tm9kZSogbm9kZSkgeyByZXR1cm4gYWRvcHRQdHIobmV3 IFdlYkhpZ2hsaWdodChub2RlKSk7IH0KKworICAgIHR5cGVkZWYgSGFzaE1hcDxXZWJDb3JlOjpH cmFwaGljc0xheWVyKiwgT3duUHRyPFdlYkNvcmU6OlBhdGg+ID4gUXVhZE1hcDsKKworICAgIGNv bnN0IFF1YWRNYXAmIHF1YWRNYXAoKSBjb25zdCB7IHJldHVybiBtX3F1YWRNYXA7IH0KK3ByaXZh dGU6CisgICAgZXhwbGljaXQgV2ViSGlnaGxpZ2h0KFdlYkNvcmU6Ok5vZGUqKTsKKyAgICBRdWFk TWFwIG1fcXVhZE1hcDsKK307CisKK30KKworI2VuZGlmCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmluZGV4IDA2MjZlZDMwNzBiOWE3NWIwOWU0 NDVhN2UzYjBkYTlkOTA0MmJjZGMuLjU4NmJmZTE2ZjViMzQ5YjBlOTcwMzYwYjI4YTY1NzhkMDM4 MGYxOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBs LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAg LTE2OCw2ICsxNjgsNyBAQAogCiAjaWYgRU5BQkxFKEdFU1RVUkVfRVZFTlRTKQogI2luY2x1ZGUg IlBsYXRmb3JtR2VzdHVyZUV2ZW50LmgiCisjaW5jbHVkZSAiV2ViSGlnaGxpZ2h0LmgiCiAjZW5k aWYKIAogI2lmIE9TKFdJTkRPV1MpCkBAIC0xMDczLDM0ICsxMDc0LDkgQEAgdm9pZCBXZWJWaWV3 SW1wbDo6ZW5hYmxlVG91Y2hIaWdobGlnaHQoSW50UG9pbnQgdG91Y2hFdmVudExvY2F0aW9uLCBQ YXRoKiBvdXRwdXQKICAgICBpZiAoIWJlc3RUb3VjaE5vZGUpCiAgICAgICAgIHJldHVybjsKIAot ICAgIC8vIEZJWE1FOiBBdCBwcmVzZW50IHdlIG5lZWQgdG8gZ2VuZXJhdGUgdGhlIHBhdGggYmVm b3JlIGNoZWNraW5nIGZvciBhIHZhbGlkIGdyYXBoaWNzIGxheWVyCi0gICAgLy8gaW4gb3JkZXIg dG8gY3JlYXRlIGEgdXNlZnVsIHVuaXQgdGVzdC4gSXQgd291bGQgYmUgbmljZSBpbnN0ZWFkIHRv IG5vdCBib3RoZXIgZ2VuZXJhdGluZwotICAgIC8vIHRoZSBwYXRoIGlmIG5vIGJhY2tpbmcgaXMg Zm91bmQuCi0gICAgUGF0aCBwYXRoID0gR2VzdHVyZVRhcEhpZ2hsaWdodGVyOjpwYXRoRm9yTm9k ZUhpZ2hsaWdodChiZXN0VG91Y2hOb2RlKTsKLSAgICAvLyBGSVhNRTogcGF0aEZvck5vZGVIaWdo bGlnaHQoKSBkb2Vzbid0IGFsd2F5cyBnZW5lcmF0ZSBhIHBhdGguCi0gICAgaWYgKCFwYXRoLmxl bmd0aCgpKQotICAgICAgICBwYXRoLmFkZFJlY3QoYmVzdFRvdWNoTm9kZS0+Z2V0UGl4ZWxTbmFw cGVkUmVjdCgpKTsKLQotICAgIGlmIChvdXRwdXRQYXRoKQotICAgICAgICAqb3V0cHV0UGF0aCA9 IHBhdGg7Ci0KLSAgICBpZiAoIWJlc3RUb3VjaE5vZGUtPnJlbmRlcmVyKCkgfHwgIWJlc3RUb3Vj aE5vZGUtPnJlbmRlcmVyKCktPmVuY2xvc2luZ0xheWVyKCkpCi0gICAgICAgIHJldHVybjsKLQot ICAgIFJlbmRlckxheWVyKiByZW5kZXJMYXllciA9IGJlc3RUb3VjaE5vZGUtPnJlbmRlcmVyKCkt PmVuY2xvc2luZ0xheWVyKCk7Ci0gICAgUmVuZGVyTGF5ZXJCYWNraW5nKiBiYWNraW5nID0gMDsK LSAgICBkbyB7Ci0gICAgICAgIGJhY2tpbmcgPSByZW5kZXJMYXllci0+YmFja2luZygpOwotICAg ICAgICByZW5kZXJMYXllciA9IHJlbmRlckxheWVyLT5wYXJlbnQoKTsKLSAgICB9IHdoaWxlICgh YmFja2luZyAmJiByZW5kZXJMYXllcik7Ci0KLSAgICBpZiAoIWJhY2tpbmcpCi0gICAgICAgIHJl dHVybjsKLQotICAgIEdyYXBoaWNzTGF5ZXJDaHJvbWl1bSogZ2xjID0gc3RhdGljX2Nhc3Q8R3Jh cGhpY3NMYXllckNocm9taXVtKj4oYmFja2luZy0+Z3JhcGhpY3NMYXllcigpKTsKLQogICAgIGNv bnN0IGRvdWJsZSBhbmltYXRpb25TdGFydERlbGF5ID0gMC4yOwotICAgIG1fdG91Y2hMaW5rSGln aGxpZ2h0VGltZXItPnRyaWdnZXJUb3VjaExpbmtIaWdobGlnaHQocGF0aCwgZ2xjLCBhbmltYXRp b25TdGFydERlbGF5KTsKKyAgICBPd25QdHI8V2ViSGlnaGxpZ2h0PiBoaWdobGlnaHQgPSBXZWJI aWdobGlnaHQ6OmNyZWF0ZShiZXN0VG91Y2hOb2RlKTsKKyAgICBtX3RvdWNoTGlua0hpZ2hsaWdo dFRpbWVyLT50cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KCpoaWdobGlnaHQsIGFuaW1hdGlvblN0 YXJ0RGVsYXkpOwogfQogI2VuZGlmCiAK 143184 2012-05-21 20:48:57 -0700 2012-05-21 20:48:57 -0700 some additional test cases highlight.html text/html 2310 trchen PGh0bWw+CjxoZWFkPjx0aXRsZT50ZXN0PC90aXRsZT48L2hlYWQ+CjxkaXY+CjxhIGhyZWY9IiI+ SGVsbG8gZW1wdHkgPHNwYW4+PC9zcGFuPiBsaW5rPC9hPjxici8+CjwvZGl2Pgo8ZGl2Pgo8c3Bh biBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjojY2NmZmNjIj5IZWxsbyA8YSBocmVmPSIiPm5vcm1h bDwvYT4gbGluazwvc3Bhbj48YnIvPgo8YSBocmVmPSIiIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9y OiNjY2ZmY2MiPkhlbGxvIDxzcGFuIHN0eWxlPSJwb3NpdGlvbjpyZWxhdGl2ZTt0b3A6NTBweDts ZWZ0OjUwcHgiPnBvc2l0aW9uZWQ8L3NwYW4+IGxpbms8L2E+PGJyLz48YnIvPjxici8+PGJyLz4K PGEgaHJlZj0iIj5IZWxsbyA8c3BhbiBzdHlsZT0icG9zaXRpb246cmVsYXRpdmU7dG9wOjUwcHg7 bGVmdDo1MHB4Ij5wb3NpdGlvbmVkPC9zcGFuPiBsaW5rPC9hPjxici8+PGJyLz48YnIvPjxici8+ CjwvZGl2PgoKPGRpdj4KPGEgaHJlZj0iIiBzdHlsZT0iYmFja2dyb3VuZC1jb2xvcjojY2NmZmNj Ij5IZWxsbyA8c3BhbiBzdHlsZT0iZm9udC1zaXplOjgwJTtiYWNrZ3JvdW5kLWNvbG9yOiNmZmNj Y2MiPnNtYWxsIGZvbnQ8L3NwYW4+IGxpbms8L2E+PGJyLz4KPGEgaHJlZj0iIiBzdHlsZT0iYmFj a2dyb3VuZC1jb2xvcjojY2NmZmNjIj5IZWxsbyA8c3BhbiBzdHlsZT0iZm9udC1zaXplOjEyMCU7 YmFja2dyb3VuZC1jb2xvcjojZmZjY2NjIj5sYXJnZSBmb250PC9zcGFuPiBsaW5rPC9hPjxici8+ CjxhIGhyZWY9IiIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+SGVsbG8gPHNwYW4+ c3Bhbjwvc3Bhbj4gbGluazwvYT48YnIvPgo8L2Rpdj4KCgo8ZGl2Pgo8YSBocmVmPSIiIHN0eWxl PSJiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2MiPkhlbGxvPGRpdiBzdHlsZT0iZGlzcGxheTppbmxp bmUtYmxvY2s7d2lkdGg6MTAwcHg7aGVpZ2h0OjEwMHB4O2JhY2tncm91bmQtY29sb3I6I2ZmY2Nj YztvdmVyZmxvdzpoaWRkZW4iPgo8ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jaztwb3Np dGlvbjphYnNvbHV0ZTt0b3A6NTAwcHg7bGVmdDo1MDBweDt3aWR0aDo4MHB4O2hlaWdodDo4MHB4 O2JhY2tncm91bmQtY29sb3I6I2NjY2NmZiI+PC9kaXY+CjwvZGl2PiBsaW5rPC9hPjxici8+PGJy Lz48YnIvPjxici8+Cgo8YSBocmVmPSIiIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2Mi PkhlbGxvCjxkaXYgc3R5bGU9ImRpc3BsYXk6aW5saW5lLWJsb2NrO3dpZHRoOjEwMHB4O2hlaWdo dDoxMDBweDtiYWNrZ3JvdW5kLWNvbG9yOiNmZmNjY2M7b3ZlcmZsb3c6aGlkZGVuIj4KPGRpdiBz dHlsZT0iZGlzcGxheTppbmxpbmUtYmxvY2s7cG9zaXRpb246cmVsYXRpdmU7dG9wOjUwcHg7bGVm dDo1MHB4O3dpZHRoOjgwcHg7aGVpZ2h0OjgwcHg7YmFja2dyb3VuZC1jb2xvcjojY2NjY2ZmIj48 L2Rpdj4KPC9kaXY+IGxpbms8L2E+PGJyLz48YnIvPjxici8+PGJyLz4KCjxhIGhyZWY9IiIgc3R5 bGU9ImJhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+SGVsbG8KPGRpdiBzdHlsZT0iZGlzcGxheTpp bmxpbmUtYmxvY2s7d2lkdGg6MTAwcHg7aGVpZ2h0OjEwMHB4O2JhY2tncm91bmQtY29sb3I6I2Zm Y2NjYztwb3NpdGlvbjpyZWxhdGl2ZSI+CjxkaXYgc3R5bGU9ImRpc3BsYXk6aW5saW5lLWJsb2Nr O3Bvc2l0aW9uOmFic29sdXRlO3RvcDo2MDBweDtsZWZ0OjUwMHB4O3dpZHRoOjgwcHg7aGVpZ2h0 OjgwcHg7YmFja2dyb3VuZC1jb2xvcjojY2NjY2ZmIj48L2Rpdj4KPC9kaXY+IGxpbms8L2E+PGJy Lz48YnIvPjxici8+PGJyLz4KCjxhIGhyZWY9IiIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6I2Nj ZmZjYyI+SGVsbG8KPGRpdiBzdHlsZT0iZGlzcGxheTppbmxpbmUtYmxvY2s7d2lkdGg6MTAwcHg7 aGVpZ2h0OjEwMHB4O2JhY2tncm91bmQtY29sb3I6I2ZmY2NjYzstd2Via2l0LXRyYW5zZm9ybTpy b3RhdGUoMzBkZWcpdHJhbnNsYXRlWigwKSI+Cm92ZXJmbG93IG92ZXJmbG93IG92ZXJmbG93IG92 ZXJmbG93IG92ZXJmbG93IG92ZXJmbG93IG92ZXJmbG93IG92ZXJmbG93IG92ZXJmbG93IG92ZXJm bG93IAo8L2Rpdj4gbGluazwvYT48YnIvPjxici8+PGJyLz48YnIvPgo8L2Rpdj4KCjxkaXYgc3R5 bGU9IndpZHRoOjE1MHB4O2hlaWdodDoxMDBweDtiYWNrZ3JvdW5kLWNvbG9yOiNmZmNjY2MiPm92 ZXJmbG93IDxhIGhyZWY9IiI+b3ZlcmZsb3cgb3ZlcmZsb3cgb3ZlcmZsb3cgb3ZlcmZsb3cgb3Zl cmZsb3cgb3ZlcmZsb3cgb3ZlcmZsb3c8ZGl2Pm92ZXJmbG93IG92ZXJmbG93PC9kaXY+b3ZlcmZs b3c8L2E+IG92ZXJmbG93PC9kaXY+CjwvaHRtbD4K 143728 2012-05-23 22:12:53 -0700 2012-05-29 17:08:18 -0700 Patch bug-84936-20120523221251.patch text/plain 25681 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE3ODIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzk4MzQzMGQzNjM4ZTdm NGMzYmU0MzVlNTExNjg2NWJkMTEwYWRmOS4uZjBiMDFlMDMxMjE3YTIzOTQyZTAyYWU3OGE5NzFj YTcwOTJiZDdiNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDEyLTA1LTIxICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBSZW5kZXJPYmplY3Q6OnJl cGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyBjYWxsLAorICAgICAgICB0byBnZW5lcmF0ZSB0 aGUgY2xpY2thYmxlIHJlZ2lvbiBmb3IgbGluayBoaWdobGlnaHRpbmcuCisKKyAgICAgICAgT25l IGltcG9ydGFudCBkaWZmZXJlbmNlIGZyb20gUmVuZGVyT2JqZWN0OjphYnNvbHV0ZVF1YWRzIGlz IHRoYXQKKyAgICAgICAgdGhlIHJldHVybmVkIHF1YWRzIHdpbGwgYmUgaW4gdGhlIGNvb3JkaW5h dGVzIG9mIGEgcmVwYWludCBjb250YWluZXIKKyAgICAgICAgc3BlY2lmaWVkIGJ5IHRoZSBjYWxs ZXIuIFRoaXMgd2lsbCBhbGxvdyB0aHJlYWRlZC1zY3JvbGxpbmcvYW5pbWF0aW9uCisgICAgICAg IHdpdGhvdXQgaGF2aW5nIHRvIHJlZ2VuZXJhdGUgdGhlIGhpZ2hsaWdodHMuCisKKyAgICAgICAg Tm8gbmV3IHRlc3RzLiBUZXN0cyB3aWxsIGJlIGFkZGVkIHdpdGggbGF0ZXIgcGF0Y2hlcyB0aGF0 IGFjdHVhbGx5CisgICAgICAgIGFkZCBoaWdobGlnaHQgdG8gbGF5ZXJzLgorCisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJsb2Nr OjpyZXBhaW50Q29udGFpbmVySGlnaGxpZ2h0UXVhZHMpOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJsb2NrLmg6CisgICAgICAgIChSZW5kZXJCbG9jayk6 CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJveC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpS ZW5kZXJCb3g6OnJlcGFpbnRDb250YWluZXJIaWdobGlnaHRRdWFkcyk6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94Lmg6CisgICAgICAgIChSZW5kZXJC b3gpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJJbmxpbmUuY3BwOgorICAgICAgICAoV2Vi Q29yZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJJbmxpbmU6OnJlcGFpbnRDb250YWluZXJI aWdobGlnaHRRdWFkcyk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlcklubGluZS5oOgorICAg ICAgICAoUmVuZGVySW5saW5lKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OnJlcGFpbnRDb250YWluZXJIaWdobGln aHRRdWFkcyk6CisgICAgICAgIChSZW5kZXJPYmplY3QpOgorCiAyMDEyLTA1LTIxICBXLiBKYW1l cyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1d IEFkZCB0b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5ZXJzLgpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L0NoYW5nZUxvZwppbmRleCBjOWYzY2FhMzExNWQzOGE3YzlmYTQ2NWEzNWY2OTY0N2NiNTJiOGEz Li4xOTRjMWE5ZGI2YWFmOTRjYjhmZmNmZWMzMDRkMTdkZjAxZmU1YzgyIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEyLTA1LTIxICBUaWVuLVJlbiBDaGVu ICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENvbXB1dGUgaGln aGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEFkZCBXZWJIaWdobGlnaHQgY2xhc3Mgd2hpY2ggY2FuIGJlIHVzZWQg dG8gZGV0ZXJtaW5lCisgICAgICAgIHRoZSBoaWdobGlnaHQgcmVnaW9uIGZvciBzcGVjaWZpZWQg dG91Y2ggdGFyZ2V0IG5vZGUuCisKKyAgICAgICAgKiBXZWJLaXQuZ3lwOgorICAgICAgICAqIHNy Yy9XZWJIaWdobGlnaHQuY3BwOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChX ZWJLaXQ6OldlYkhpZ2hsaWdodDo6V2ViSGlnaGxpZ2h0KToKKyAgICAgICAgKiBzcmMvV2ViSGln aGxpZ2h0Lmg6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJLaXQpOgor ICAgICAgICAoV2ViSGlnaGxpZ2h0KToKKyAgICAgICAgKFdlYktpdDo6V2ViSGlnaGxpZ2h0Ojpj cmVhdGUpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHQ6OmJlZ2luKToKKyAgICAgICAg KFdlYktpdDo6V2ViSGlnaGxpZ2h0OjplbmQpOgorCiAyMDEyLTA1LTIxICBXLiBKYW1lcyBNYWNM ZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1dIEFkZCB0 b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5ZXJzLgpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyQm94LmNwcAppbmRleCBiZDhjMmRhNTVmMzAwNzEwYzg0NjYxOTQ1OTYzMWFmNThi NzMzMTVjLi41NjFlZWJmOTliZTExYWM3YTE5YzVmOTVhMzI5MjYxNTE3NjNlYWVhIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtNDA2Myw0ICs0MDYzLDEyIEBAIFJl bmRlck9iamVjdCogUmVuZGVyQm94OjpzcGxpdEFub255bW91c0JveGVzQXJvdW5kQ2hpbGQoUmVu ZGVyT2JqZWN0KiBiZWZvcmVDaGlsCiAgICAgcmV0dXJuIGJlZm9yZUNoaWxkOwogfQogCit2b2lk IFJlbmRlckJveDo6aGl0UXVhZHNGb3JDb250YWluZXIoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRz LCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QKK3sKKyAgICBp ZiAoIXNpemUoKS5pc0VtcHR5KCkpCisgICAgICAgIHF1YWRzLmFwcGVuZChsb2NhbFRvQ29udGFp bmVyUXVhZChGbG9hdFJlY3QoMCwgMCwgd2lkdGgoKSwgaGVpZ2h0KCkpLCByZXBhaW50Q29udGFp bmVyKSk7CisKKyAgICBSZW5kZXJCb3hNb2RlbE9iamVjdDo6aGl0UXVhZHNGb3JDb250YWluZXIo cXVhZHMsIHJlcGFpbnRDb250YWluZXIpOyAvLyBmb3IgY29udGludWF0aW9uCit9CisKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJCb3guaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guaAppbmRleCAz ODE5ZGY1MGVjYmFlZDkyZWRjMmI5ZThlMWY2ODU2NWNiOWE4YzI5Li45N2Q2OWU1OGVjMWFjNDc4 ZGI4OGM5N2MyYmRlOWEzZDRhMmM1NGEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQm94LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJv eC5oCkBAIC01MjEsNiArNTIxLDggQEAgcHJvdGVjdGVkOgogCiAgICAgUmVuZGVyT2JqZWN0KiBz cGxpdEFub255bW91c0JveGVzQXJvdW5kQ2hpbGQoUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsZCk7 CiAgCisgICAgdmlydHVhbCB2b2lkIGhpdFF1YWRzRm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1 YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0IE9WRVJS SURFOworCiBwcml2YXRlOgogICAgIGJvb2wgZml4ZWRFbGVtZW50TGF5c091dFJlbGF0aXZlVG9G cmFtZShGcmFtZSosIEZyYW1lVmlldyopIGNvbnN0OwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmNwcAppbmRleCBiMjNhZDk5ODBiNzI3YTM0 NDNjOTBlNDdjZTZkNjA0ZTZjODFmODRhLi41MGZiMzVjNTgzZmZlYzk3MWYxNDQ0MzZkN2MwNDE5 MzBhM2RmYWVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94 TW9kZWxPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3hN b2RlbE9iamVjdC5jcHAKQEAgLTMwNDAsNCArMzA0MCwxMCBAQCB2b2lkIFJlbmRlckJveE1vZGVs T2JqZWN0Ojptb3ZlQ2hpbGRyZW5UbyhSZW5kZXJCb3hNb2RlbE9iamVjdCogdG9Cb3hNb2RlbE9i amVjdAogICAgIH0KIH0KIAordm9pZCBSZW5kZXJCb3hNb2RlbE9iamVjdDo6aGl0UXVhZHNGb3JD b250YWluZXIoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hNb2RlbE9iamVjdCog cmVwYWludENvbnRhaW5lcikgY29uc3QKK3sKKyAgICBpZiAoY29udGludWF0aW9uKCkpCisgICAg ICAgIGNvbnRpbnVhdGlvbigpLT5oaXRRdWFkc0ZvckNvbnRhaW5lcihxdWFkcywgcmVwYWludENv bnRhaW5lcik7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5oIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgKaW5kZXggZDA4ODNhNWVlNmViMWZl ODI3YzQ5ODFiYjg3MmQ0NTc2ZjE0NmNkYy4uMWY5NjBkN2RkMDNiYWQ1YjdiZTZjZmMzODQxNjBj NTk3ZWQwMGJiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJv eE1vZGVsT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveE1v ZGVsT2JqZWN0LmgKQEAgLTI0MSw2ICsyNDEsOCBAQCBwcm90ZWN0ZWQ6CiAKICAgICBzdGF0aWMg Ym9vbCBzaG91bGRBbnRpYWxpYXNMaW5lcyhHcmFwaGljc0NvbnRleHQqKTsKIAorICAgIHZpcnR1 YWwgdm9pZCBoaXRRdWFkc0ZvckNvbnRhaW5lcihWZWN0b3I8RmxvYXRRdWFkPiYsIFJlbmRlckJv eE1vZGVsT2JqZWN0KiAvKnJlcGFpbnRDb250YWluZXIqLykgY29uc3QgT1ZFUlJJREU7CisKIHB1 YmxpYzoKICAgICAvLyBGb3IgUmVuZGVyQmxvY2tzIGFuZCBSZW5kZXJJbmxpbmVzIHdpdGggbV9z dHlsZS0+c3R5bGVUeXBlKCkgPT0gRklSU1RfTEVUVEVSLCB0aGlzIHRyYWNrcyB0aGVpciByZW1h aW5pbmcgdGV4dCBmcmFnbWVudHMKICAgICBSZW5kZXJPYmplY3QqIGZpcnN0TGV0dGVyUmVtYWlu aW5nVGV4dCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlcklubGluZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNw cAppbmRleCAzOGE4NzRiNGExYTA1NmZjMDlkOThjMGM0ZGU2M2I1ODNiMTIzNWYwLi4xNDU5NDVk MDM4NzYxMjEzYzA0NTQxYjFjYzQxMzRhMTlmNzUwNDc3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVySW5saW5lLmNwcApAQCAtMTUwMiw0ICsxNTAyLDEzIEBAIHZvaWQgUmVuZGVy SW5saW5lOjphZGREYXNoYm9hcmRSZWdpb25zKFZlY3RvcjxEYXNoYm9hcmRSZWdpb25WYWx1ZT4m IHJlZ2lvbnMpCiB9CiAjZW5kaWYKIAordm9pZCBSZW5kZXJJbmxpbmU6OmhpdFF1YWRzRm9yQ29u dGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJl cGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAgZm9yIChJbmxpbmVGbG93Qm94KiBjdXJyID0g Zmlyc3RMaW5lQm94KCk7IGN1cnI7IGN1cnIgPSBjdXJyLT5uZXh0TGluZUJveCgpKQorICAgICAg ICBpZiAoIWN1cnItPnNpemUoKS5pc0VtcHR5KCkpCisgICAgICAgICAgICBxdWFkcy5hcHBlbmQo bG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KGN1cnItPnRvcExlZnQoKSwgY3Vyci0+c2l6 ZSgpKSwgcmVwYWludENvbnRhaW5lcikpOworCisgICAgUmVuZGVyQm94TW9kZWxPYmplY3Q6Omhp dFF1YWRzRm9yQ29udGFpbmVyKHF1YWRzLCByZXBhaW50Q29udGFpbmVyKTsgLy8gZm9yIGNvbnRp bnVhdGlvbgorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVySW5saW5lLmgKaW5kZXggYzE1MzJjZjU2OGZiNDVlYmI0ZjMxNDc3ZDdhZjJiYzI1 YmY1YjZiNy4uYjdjZWEzZGVjYjFkYWQ4NmRjOTdhNzViZTc4Zjk4NjAzNmU1NjMwNSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaApAQCAtODgsNiArODgsOCBAQCBwcm90 ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgc3R5bGVEaWRDaGFuZ2UoU3R5bGVEaWZmZXJlbmNl LCBjb25zdCBSZW5kZXJTdHlsZSogb2xkU3R5bGUpOwogCisgICAgdmlydHVhbCB2b2lkIGhpdFF1 YWRzRm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3Qq IHJlcGFpbnRDb250YWluZXIpIGNvbnN0IE9WRVJSSURFOworCiBwcml2YXRlOgogICAgIHZpcnR1 YWwgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0KiB2aXJ0dWFsQ2hpbGRyZW4oKSB7IHJldHVybiBjaGls ZHJlbigpOyB9CiAgICAgdmlydHVhbCBjb25zdCBSZW5kZXJPYmplY3RDaGlsZExpc3QqIHZpcnR1 YWxDaGlsZHJlbigpIGNvbnN0IHsgcmV0dXJuIGNoaWxkcmVuKCk7IH0KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggNGViMTZiODM1MTk2Yjk5MDBiNDZjYjZl Y2I4ZjE2ZDcyZWIwODlhMi4uMTk1ZDExYzZiMGQ4MmJjNTQwYmI0YjliNDZiNWE5ZGYxNzkyMTQ4 YSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKQEAgLTI4NjQs NiArMjg2NCwzMyBAQCBib29sIFJlbmRlck9iamVjdDo6Y2FuVXBkYXRlU2VsZWN0aW9uT25Sb290 TGluZUJveGVzKCkKICAgICByZXR1cm4gY29udGFpbmluZ0Jsb2NrID8gIWNvbnRhaW5pbmdCbG9j ay0+bmVlZHNMYXlvdXQoKSA6IHRydWU7CiB9CiAKK3ZvaWQgUmVuZGVyT2JqZWN0OjpoaXRRdWFk c0ZvckNvbnRhaW5lcldpdGhDbGlwcGluZyhWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRl ckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIHNpemVfdCBv bGRTaXplID0gcXVhZHMuc2l6ZSgpOworICAgIGhpdFF1YWRzRm9yQ29udGFpbmVyKHF1YWRzLCBy ZXBhaW50Q29udGFpbmVyKTsKKworICAgIGZvciAoc2l6ZV90IGkgPSBvbGRTaXplOyBpIDwgcXVh ZHMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgRmxvYXRRdWFkIHF1YWQgPSBxdWFkc1tpXTsKKwor ICAgICAgICBpZiAoIXF1YWQuaXNSZWN0aWxpbmVhcigpKQorICAgICAgICAgICAgY29udGludWU7 CisKKyAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJvdW5kaW5nQm94KCk7CisKKyAg ICAgICAgZm9yIChSZW5kZXJCbG9jayogYmxrID0gY29udGFpbmluZ0Jsb2NrKCk7IGJsayAmJiBi bGstPmlzRGVzY2VuZGFudE9mKHJlcGFpbnRDb250YWluZXIpOyBibGsgPSBibGstPmNvbnRhaW5p bmdCbG9jaygpKSB7CisgICAgICAgICAgICBpZiAoIWJsay0+aGFzT3ZlcmZsb3dDbGlwKCkpCisg ICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBGbG9hdFF1YWQgYm91bmRRdWFk ID0gYmxrLT5sb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoYmxrLT52aXN1YWxPdmVyZmxv d1JlY3QoKSksIHJlcGFpbnRDb250YWluZXIpOworICAgICAgICAgICAgaWYgKCFib3VuZFF1YWQu aXNSZWN0aWxpbmVhcigpKSAvLyBkb24ndCBrbm93IGhvdyB0byBjbGlwIHRoaXMuIDooCisgICAg ICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBGbG9hdFJlY3QgYm91bmRSZWN0ID0g Ym91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAgICAgICBjbGlwcGVkLmludGVyc2VjdChi b3VuZFJlY3QpOworICAgICAgICB9CisKKyAgICAgICAgcXVhZHNbaV0gPSBjbGlwcGVkOworICAg IH0KK30KKwogI2lmIEVOQUJMRShTVkcpCiAKIFJlbmRlclNWR1Jlc291cmNlQ29udGFpbmVyKiBS ZW5kZXJPYmplY3Q6OnRvUmVuZGVyU1ZHUmVzb3VyY2VDb250YWluZXIoKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCmluZGV4IDkyNjlkZjFhOWJlZDYwODA1NGY5OWMzYzU1 NWEyZDlkYjFkMjFkMjguLmYxNzg0YTc5MTJjOTViMTljMDdhMmI2YWUxOTAyYjMzYzE2ODUyOTgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmgKQEAgLTg5MSw2ICs4OTEs OCBAQCBwdWJsaWM6CiAKICAgICBSZXNwZWN0SW1hZ2VPcmllbnRhdGlvbkVudW0gc2hvdWxkUmVz cGVjdEltYWdlT3JpZW50YXRpb24oKSBjb25zdDsKIAorICAgIHZvaWQgaGl0UXVhZHNGb3JDb250 YWluZXJXaXRoQ2xpcHBpbmcoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVj dCogLypyZXBhaW50Q29udGFpbmVyKi8pIGNvbnN0OworCiBwcm90ZWN0ZWQ6CiAgICAgaW5saW5l IGJvb2wgbGF5ZXJDcmVhdGlvbkFsbG93ZWRGb3JTdWJ0cmVlKCkgY29uc3Q7CiAKQEAgLTkxNyw2 ICs5MTksOCBAQCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIExheW91dFJlY3Qgb3V0bGluZUJv dW5kc0ZvclJlcGFpbnQoUmVuZGVyQm94TW9kZWxPYmplY3QqIC8qcmVwYWludENvbnRhaW5lciov LCBMYXlvdXRQb2ludCogLypjYWNoZWRPZmZzZXRUb1JlcGFpbnRDb250YWluZXIqLyA9IDApIGNv bnN0IHsgcmV0dXJuIExheW91dFJlY3QoKTsgfQogCisgICAgdmlydHVhbCB2b2lkIGhpdFF1YWRz Rm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIC8q cmVwYWludENvbnRhaW5lciovKSBjb25zdCB7IH0KKwogcHJpdmF0ZToKICAgICBSZW5kZXJTdHls ZSogZmlyc3RMaW5lU3R5bGVTbG93Q2FzZSgpIGNvbnN0OwogICAgIFN0eWxlRGlmZmVyZW5jZSBh ZGp1c3RTdHlsZURpZmZlcmVuY2UoU3R5bGVEaWZmZXJlbmNlLCB1bnNpZ25lZCBjb250ZXh0U2Vu c2l0aXZlUHJvcGVydGllcykgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyVGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4 dC5jcHAKaW5kZXggMTZjMWVhMTcyNzkwZGIzNDRkNDFlYTU5YTZkNzYxZWU2ZGNlZTEzYi4uM2U1 OTJjNTI0YjRiYjhmNzk1ODExN2ExM2E4NmNjNzM0YTY0MTljYyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJUZXh0LmNwcApAQCAtMTgzMiw0ICsxODMyLDEwIEBAIHZvaWQgUmVuZGVy VGV4dDo6bW9tZW50YXJpbHlSZXZlYWxMYXN0VHlwZWRDaGFyYWN0ZXIodW5zaWduZWQgbGFzdFR5 cGVkQ2hhcmFjdGVyCiAgICAgc2VjdXJlVGV4dFRpbWVyLT5yZXN0YXJ0V2l0aE5ld1RleHQobGFz dFR5cGVkQ2hhcmFjdGVyT2Zmc2V0KTsKIH0KIAordm9pZCBSZW5kZXJUZXh0OjpoaXRRdWFkc0Zv ckNvbnRhaW5lcihWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJlbmRlckJveE1vZGVsT2JqZWN0 KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIGZvciAoSW5saW5lVGV4dEJveCogYm94 ID0gZmlyc3RUZXh0Qm94KCk7IGJveDsgYm94ID0gYm94LT5uZXh0VGV4dEJveCgpKQorICAgICAg ICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KGJveC0+dG9wTGVm dCgpLCBib3gtPnNpemUoKSksIHJlcGFpbnRDb250YWluZXIsIGZhbHNlLCAwKSk7Cit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJUZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dC5oCmlu ZGV4IDgxNTdlMzdlYmM3ZDc4MmQwMjcxOGRmZDA2MmQ1ZWQxMDk4MDdkZDkuLjQ1NWE2NTQ2YzM5 ZTE3ZTE0MTBhZGNkM2FmMTRiMGMzZGViZTZjNDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJUZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlclRleHQuaApAQCAtMTQ0LDYgKzE0NCw4IEBAIHByb3RlY3RlZDoKICAgICAKICAgICB2aXJ0 dWFsIElubGluZVRleHRCb3gqIGNyZWF0ZVRleHRCb3goKTsgLy8gU3ViY2xhc3NlZCBieSBTVkcu CiAKKyAgICB2aXJ0dWFsIHZvaWQgaGl0UXVhZHNGb3JDb250YWluZXIoVmVjdG9yPEZsb2F0UXVh ZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QgT1ZFUlJJ REU7CisKIHByaXZhdGU6CiAgICAgdm9pZCBjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocyhm bG9hdCBsZWFkV2lkdGgsIEhhc2hTZXQ8Y29uc3QgU2ltcGxlRm9udERhdGEqPiYgZmFsbGJhY2tG b250cywgR2x5cGhPdmVyZmxvdyYpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL1dlYktpdC5neXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXgg ODdhYzdiOGNlOWZhOGI1YmEzMjU0MjgwOTMwMzRiZDJjOWE0MTYwMS4uMzk2Y2Q1MTljZjVmNjkz YjQ5MzI1MDc1ZTM4N2FhOGE4YjRkM2YwYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9XZWJLaXQuZ3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cApA QCAtNTU1LDYgKzU1NSw4IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHZW9sb2NhdGlvblBv c2l0aW9uLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHbHlwaENhY2hlLmNwcCcsCiAg ICAgICAgICAgICAgICAgJ3NyYy9XZWJHcmFwaGljc0NvbnRleHQzRC5jcHAnLAorICAgICAgICAg ICAgICAgICdzcmMvV2ViSGlnaGxpZ2h0LmNwcCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJI aWdobGlnaHQuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJIaXN0b3J5SXRlbS5jcHAnLAog ICAgICAgICAgICAgICAgICdzcmMvV2ViSGl0VGVzdFJlc3VsdC5jcHAnLAogICAgICAgICAgICAg ICAgICdzcmMvV2ViSWNvbkxvYWRpbmdDb21wbGV0aW9uSW1wbC5jcHAnLApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuY3BwCmlu ZGV4IGIxZjE2MjEwNGZjYzU1YjUxODM0MGQ4YzAzMmIxNTk4ZTYwZTYzOWEuLmE4ODU0YWIxMWNm OTk1YTA5ZDBkNmJjMjg0NzlmODMwMmYxOGY2MGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLmNwcAorKysgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5jcHAKQEAgLTMwLDYgKzMw LDcgQEAKICNpbmNsdWRlICJHcmFwaGljc0xheWVyQ2hyb21pdW0uaCIKICNpbmNsdWRlICJMaW5r SGlnaGxpZ2h0LmgiCiAjaW5jbHVkZSAiUGF0aC5oIgorI2luY2x1ZGUgIldlYkhpZ2hsaWdodC5o IgogCiB1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKIApAQCAtNDQsMjggKzQ1LDM1IEBAIFRvdWNo TGlua0hpZ2hsaWdodFRpbWVyOjp+VG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIoKQogewogfQogCi12 b2lkIFRvdWNoTGlua0hpZ2hsaWdodFRpbWVyOjp0cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KGNv bnN0IFBhdGggcGF0aCwgR3JhcGhpY3NMYXllckNocm9taXVtKiBsYXllciwgY29uc3QgZG91Ymxl IGFuaW1hdGlvblN0YXJ0RGVsYXkpCit2b2lkIFRvdWNoTGlua0hpZ2hsaWdodFRpbWVyOjp0cmln Z2VyVG91Y2hMaW5rSGlnaGxpZ2h0KGNvbnN0IFdlYkhpZ2hsaWdodCYgaGlnaGxpZ2h0LCBjb25z dCBkb3VibGUgYW5pbWF0aW9uU3RhcnREZWxheSkKIHsKICAgICBzdG9wKENhbmNlbEFjdGl2ZUFu aW1hdGlvbik7IC8vIFN0b3AgaW4tZmxpZ2h0IG9yIHBlbmRpbmcgYW5pbWF0aW9ucy4KIAotICAg IGlmIChsYXllcikgewotICAgICAgICBtX2xpbmtIaWdobGlnaHQgPSBsYXllci0+YWRkTGlua0hp Z2hsaWdodChwYXRoKTsKLSAgICAgICAgLy8gRklYTUU6IFdlIGhhbmRsZSBzdGFydERlbGF5ID09 IDAgc2VwYXJhdGVseSB0byBmYWNpbGl0YXRlIHRlc3RpbmcsIGl0IHdvdWxkIGJlIG5pY2UgdG8g bm90IG5lZWQgdG8uCi0gICAgICAgIGlmIChhbmltYXRpb25TdGFydERlbGF5KQotICAgICAgICAg ICAgbV90aW1lci5zdGFydE9uZVNob3QoYW5pbWF0aW9uU3RhcnREZWxheSk7Ci0gICAgICAgIGVs c2UKLSAgICAgICAgICAgIGZpcmVkKDApOworICAgIGZvciAoV2ViSGlnaGxpZ2h0OjpRdWFkTWFw Ojpjb25zdF9pdGVyYXRvciBpID0gaGlnaGxpZ2h0LnF1YWRNYXAoKS5iZWdpbigpOyBpICE9IGhp Z2hsaWdodC5xdWFkTWFwKCkuZW5kKCk7ICsraSkgeworICAgICAgICBpZiAoIWktPmZpcnN0KQor ICAgICAgICAgICAgY29udGludWU7CisgICAgICAgIEdyYXBoaWNzTGF5ZXJDaHJvbWl1bSogbGF5 ZXIgPSBzdGF0aWNfY2FzdDxHcmFwaGljc0xheWVyQ2hyb21pdW0qPihpLT5maXJzdCk7CisKKyAg ICAgICAgbV9saW5rSGlnaGxpZ2h0cy5hcHBlbmQobGF5ZXItPmFkZExpbmtIaWdobGlnaHQoKmkt PnNlY29uZCkpOwogICAgIH0KKworICAgIC8vIEZJWE1FOiBXZSBoYW5kbGUgc3RhcnREZWxheSA9 PSAwIHNlcGFyYXRlbHkgdG8gZmFjaWxpdGF0ZSB0ZXN0aW5nLCBpdCB3b3VsZCBiZSBuaWNlIHRv IG5vdCBuZWVkIHRvLgorICAgIGlmIChhbmltYXRpb25TdGFydERlbGF5KQorICAgICAgICBtX3Rp bWVyLnN0YXJ0T25lU2hvdChhbmltYXRpb25TdGFydERlbGF5KTsKKyAgICBlbHNlCisgICAgICAg IGZpcmVkKDApOwogfQogCiB2b2lkIFRvdWNoTGlua0hpZ2hsaWdodFRpbWVyOjpmaXJlZChUaW1l cjxUb3VjaExpbmtIaWdobGlnaHRUaW1lcj4qKQogewotICAgIGlmIChtX2xpbmtIaWdobGlnaHQp IHsKLSAgICAgICAgLy8gSWYgdGhlcmUncyBubyBwYXJlbnQsIGl0IG1lYW5zIHRoZSBHcmFwaGlj c0xheWVyQ2hyb21pdW0gaGFzIGRpc2FwcGVhcmVkLCBhbmQgdGhlIGxpbmsgaGlnaGxpZ2h0IHNo b3VsZCB0b28uCi0gICAgICAgIGlmIChtX2xpbmtIaWdobGlnaHQtPnBhcmVudCgpKQotICAgICAg ICAgICAgbV9saW5rSGlnaGxpZ2h0LT5zdGFydEhpZ2hsaWdodEFuaW1hdGlvbigpOwotICAgICAg ICBlbHNlCi0gICAgICAgICAgICBtX2xpbmtIaWdobGlnaHQuY2xlYXIoKTsKKyAgICBmb3IgKFZl Y3RvcjxSZWZQdHI8TGlua0hpZ2hsaWdodD4gPjo6aXRlcmF0b3IgaSA9IG1fbGlua0hpZ2hsaWdo dHMuYmVnaW4oKTsgaSAhPSBtX2xpbmtIaWdobGlnaHRzLmVuZCgpOyBpKyspIHsKKyAgICAgICAg aWYgKExpbmtIaWdobGlnaHQqIGhpZ2hsaWdodCA9IGktPmdldCgpKSB7CisgICAgICAgICAgICAv LyBJZiB0aGVyZSdzIG5vIHBhcmVudCwgaXQgbWVhbnMgdGhlIEdyYXBoaWNzTGF5ZXJDaHJvbWl1 bSBoYXMgZGlzYXBwZWFyZWQsIGFuZCB0aGUgbGluayBoaWdobGlnaHQgc2hvdWxkIHRvby4KKyAg ICAgICAgICAgIGlmIChoaWdobGlnaHQtPnBhcmVudCgpKQorICAgICAgICAgICAgICAgIGhpZ2hs aWdodC0+c3RhcnRIaWdobGlnaHRBbmltYXRpb24oKTsKKyAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICBpLT5jbGVhcigpOworICAgICAgICB9CiAgICAgfQogfQogCkBAIC03MywxMCAr ODEsMTUgQEAgdm9pZCBUb3VjaExpbmtIaWdobGlnaHRUaW1lcjo6c3RvcChUb3VjaEhpZ2hsaWdo dEFjdGl2ZUFuaW1hdGlvbkFjdGlvbiBhY3Rpb24pCiB7CiAgICAgbV90aW1lci5zdG9wKCk7CiAK LSAgICBpZiAoYWN0aW9uID09IENhbmNlbEFjdGl2ZUFuaW1hdGlvbiAmJiBtX2xpbmtIaWdobGln aHQgJiYgbV9saW5rSGlnaGxpZ2h0LT5wYXJlbnQoKSkKLSAgICAgICAgbV9saW5rSGlnaGxpZ2h0 LT5wYXJlbnQoKS0+ZGlkRmluaXNoTGlua0hpZ2hsaWdodCgpOworICAgIGlmIChhY3Rpb24gPT0g Q2FuY2VsQWN0aXZlQW5pbWF0aW9uKSB7CisgICAgICAgIGZvciAoVmVjdG9yPFJlZlB0cjxMaW5r SGlnaGxpZ2h0PiA+OjppdGVyYXRvciBpID0gbV9saW5rSGlnaGxpZ2h0cy5iZWdpbigpOyBpICE9 IG1fbGlua0hpZ2hsaWdodHMuZW5kKCk7IGkrKykgeworICAgICAgICAgICAgTGlua0hpZ2hsaWdo dCogaGlnaGxpZ2h0ID0gaS0+Z2V0KCk7CisgICAgICAgICAgICBpZiAoaGlnaGxpZ2h0ICYmIGhp Z2hsaWdodC0+cGFyZW50KCkpCisgICAgICAgICAgICAgICAgaGlnaGxpZ2h0LT5wYXJlbnQoKS0+ ZGlkRmluaXNoTGlua0hpZ2hsaWdodCgpOworICAgICAgICB9CisgICAgfQogCi0gICAgbV9saW5r SGlnaGxpZ2h0LmNsZWFyKCk7CisgICAgbV9saW5rSGlnaGxpZ2h0cy5jbGVhcigpOwogfQogCiB9 IC8vIG5hbWVzcGFjZSBXZWJLaXQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5oCmluZGV4IGE3NGFkM2I3MTJhNzNiZTc3MTQ5YjE4 ZWZjYjc5NjI1OTU0MWUyYTMuLmZkNmMwOGYxZjJkOTg0MzY3MjBhZTI2MGYzYWFiMmRmNDNiMGMy NGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RvdWNoTGlua0hpZ2hs aWdodFRpbWVyLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5rSGln aGxpZ2h0VGltZXIuaApAQCAtNDAsNiArNDAsOCBAQCBjbGFzcyBMaW5rSGlnaGxpZ2h0OwogCiBu YW1lc3BhY2UgV2ViS2l0IHsKIAorY2xhc3MgV2ViSGlnaGxpZ2h0OworCiBjbGFzcyBUb3VjaExp bmtIaWdobGlnaHRUaW1lciB7CiBwdWJsaWM6CiAgICAgZW51bSBUb3VjaEhpZ2hsaWdodEFjdGl2 ZUFuaW1hdGlvbkFjdGlvbiB7IElnbm9yZUFjdGl2ZUFuaW1hdGlvbiwgQ2FuY2VsQWN0aXZlQW5p bWF0aW9uIH07CkBAIC00OCwxMiArNTAsMTIgQEAgcHVibGljOgogICAgIH5Ub3VjaExpbmtIaWdo bGlnaHRUaW1lcigpOwogCiAgICAgdm9pZCBmaXJlZChXZWJDb3JlOjpUaW1lcjxUb3VjaExpbmtI aWdobGlnaHRUaW1lcj4qKTsKLSAgICB2b2lkIHRyaWdnZXJUb3VjaExpbmtIaWdobGlnaHQoY29u c3QgV2ViQ29yZTo6UGF0aCwgV2ViQ29yZTo6R3JhcGhpY3NMYXllckNocm9taXVtKiwgY29uc3Qg ZG91YmxlIGFuaW1hdGlvblN0YXJ0RGVsYXkpOworICAgIHZvaWQgdHJpZ2dlclRvdWNoTGlua0hp Z2hsaWdodChjb25zdCBXZWJIaWdobGlnaHQmLCBjb25zdCBkb3VibGUgYW5pbWF0aW9uU3RhcnRE ZWxheSk7CiAgICAgdm9pZCBzdG9wKFRvdWNoSGlnaGxpZ2h0QWN0aXZlQW5pbWF0aW9uQWN0aW9u KTsKIAogcHJpdmF0ZToKICAgICBXZWJDb3JlOjpUaW1lcjxUb3VjaExpbmtIaWdobGlnaHRUaW1l cj4gbV90aW1lcjsKLSAgICBXVEY6OlJlZlB0cjxXZWJDb3JlOjpMaW5rSGlnaGxpZ2h0PiBtX2xp bmtIaWdobGlnaHQ7CisgICAgV1RGOjpWZWN0b3I8V1RGOjpSZWZQdHI8V2ViQ29yZTo6TGlua0hp Z2hsaWdodD4gPiBtX2xpbmtIaWdobGlnaHRzOwogfTsKIAogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJIaWdobGlnaHQuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NWM3NTUyNmVjMDQ5ZjY0ZDE4 ZGVhOWIzMjUwZmE2YzY1YmRkYTYwCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcApAQCAtMCwwICsxLDEwMSBAQAorLyoKKyAqIENv cHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmli dXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUg bmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBw cm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNw ZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAi QVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKworI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykKKworI2luY2x1ZGUg IldlYkhpZ2hsaWdodC5oIgorCisjaW5jbHVkZSAiTm9kZS5oIgorI2luY2x1ZGUgIlBhdGguaCIK KyNpbmNsdWRlICJSZW5kZXJCbG9jay5oIgorI2luY2x1ZGUgIlJlbmRlckxheWVyLmgiCisjaW5j bHVkZSAiUmVuZGVyTGF5ZXJCYWNraW5nLmgiCisKK3VzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwor CituYW1lc3BhY2UgV2ViS2l0IHsKKworV2ViSGlnaGxpZ2h0OjpXZWJIaWdobGlnaHQoTm9kZSog dG9wTm9kZSkKK3sKKyAgICBjb25zdCBmbG9hdCByb3VuZGVkRWRnZVBhZGRpbmcgPSA0OworCisg ICAgaWYgKCF0b3BOb2RlKQorICAgICAgICByZXR1cm47CisKKyAgICBmb3IgKE5vZGUqIG5vZGUg PSB0b3BOb2RlOyBub2RlOyBub2RlID0gbm9kZS0+dHJhdmVyc2VOZXh0Tm9kZSh0b3BOb2RlKSkg eworICAgICAgICBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gbm9kZS0+cmVuZGVyZXIoKTsKKyAg ICAgICAgaWYgKCFyZW5kZXJlcikKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIFJl bmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyID0gcmVuZGVyZXItPmNvbnRhaW5l ckZvclJlcGFpbnQoKTsKKworICAgICAgICBHcmFwaGljc0xheWVyKiBncmFwaGljc0xheWVyID0g MDsKKyAgICAgICAgaWYgKHJlcGFpbnRDb250YWluZXIgJiYgcmVwYWludENvbnRhaW5lci0+bGF5 ZXIoKSAmJiByZXBhaW50Q29udGFpbmVyLT5sYXllcigpLT5iYWNraW5nKCkpCisgICAgICAgICAg ICBncmFwaGljc0xheWVyID0gcmVwYWludENvbnRhaW5lci0+bGF5ZXIoKS0+YmFja2luZygpLT5n cmFwaGljc0xheWVyKCk7CisKKyAgICAgICAgaWYgKCFncmFwaGljc0xheWVyKQorICAgICAgICAg ICAgY29udGludWU7CisKKyAgICAgICAgUXVhZE1hcDo6aXRlcmF0b3IgcGF0aEl0ZXJhdG9yID0g bV9xdWFkTWFwLmFkZChncmFwaGljc0xheWVyLCBudWxscHRyKS5pdGVyYXRvcjsKKyAgICAgICAg aWYgKCFwYXRoSXRlcmF0b3ItPnNlY29uZCkKKyAgICAgICAgICAgIHBhdGhJdGVyYXRvci0+c2Vj b25kID0gYWRvcHRQdHIobmV3IFBhdGgoKSk7CisgICAgICAgIFBhdGgqIHBhdGggPSBwYXRoSXRl cmF0b3ItPnNlY29uZC5nZXQoKTsKKworICAgICAgICBWZWN0b3I8RmxvYXRRdWFkPiBxdWFkczsK KyAgICAgICAgcmVuZGVyZXItPmhpdFF1YWRzRm9yQ29udGFpbmVyV2l0aENsaXBwaW5nKHF1YWRz LCByZXBhaW50Q29udGFpbmVyKTsKKworICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHF1 YWRzLnNpemUoKTsgaSsrKSB7CisgICAgICAgICAgICBGbG9hdFF1YWQgcXVhZCA9IHF1YWRzW2ld OworCisgICAgICAgICAgICBpZiAoIXF1YWQuaXNSZWN0aWxpbmVhcigpKSB7IC8vIGRvbid0IGtu b3cgaG93IHRvIGJlYXV0aWZ5IHRoaXMKKyAgICAgICAgICAgICAgICBwYXRoLT5tb3ZlVG8ocXVh ZC5wMSgpKTsKKyAgICAgICAgICAgICAgICBwYXRoLT5hZGRMaW5lVG8ocXVhZC5wMigpKTsKKyAg ICAgICAgICAgICAgICBwYXRoLT5hZGRMaW5lVG8ocXVhZC5wMygpKTsKKyAgICAgICAgICAgICAg ICBwYXRoLT5hZGRMaW5lVG8ocXVhZC5wNCgpKTsKKyAgICAgICAgICAgICAgICBwYXRoLT5jbG9z ZVN1YnBhdGgoKTsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKwor ICAgICAgICAgICAgRmxvYXRSZWN0IHJlY3QgPSBxdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAg ICAgICBpZiAocmVjdC5pc0VtcHR5KCkpCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgICAgIHJlY3QuaW5mbGF0ZShyb3VuZGVkRWRnZVBhZGRpbmcpOworICAgICAgICAgICAg Y29uc3QgRmxvYXRTaXplIHBhZGRpbmcocm91bmRlZEVkZ2VQYWRkaW5nLCByb3VuZGVkRWRnZVBh ZGRpbmcpOworICAgICAgICAgICAgcGF0aC0+YWRkUGF0aEZvclJvdW5kZWRSZWN0KHJlY3QsIHBh ZGRpbmcsIHBhZGRpbmcsIHBhZGRpbmcsIHBhZGRpbmcpOworICAgICAgICB9CisgICAgfQorfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9XZWJIaWdobGlnaHQuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYkhpZ2hsaWdodC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjI1MjY0NDlmMjQ1ZTUwODNhZWJlYTgwNGQ5 NDNjODU0MWFhZmNjNmMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJIaWdobGlnaHQuaApAQCAtMCwwICsxLDY0IEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4K KyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9v ciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAq ICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBp dHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJv ZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJp b3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5E IEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisg KiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJ TiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJ QUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJIaWdobGlnaHRf aAorI2RlZmluZSBXZWJIaWdobGlnaHRfaAorCisjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lU SU5HKQorCisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRlIDx3dGYvT3duUHRyLmg+ CisjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworY2xh c3MgR3JhcGhpY3NMYXllcjsKK2NsYXNzIE5vZGU7CitjbGFzcyBQYXRoOworfQorCituYW1lc3Bh Y2UgV2ViS2l0IHsKKworY2xhc3MgV2ViSGlnaGxpZ2h0IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMg aW5saW5lIFBhc3NPd25QdHI8V2ViSGlnaGxpZ2h0PiBjcmVhdGUoV2ViQ29yZTo6Tm9kZSogbm9k ZSkgeyByZXR1cm4gYWRvcHRQdHIobmV3IFdlYkhpZ2hsaWdodChub2RlKSk7IH0KKworICAgIHR5 cGVkZWYgSGFzaE1hcDxXZWJDb3JlOjpHcmFwaGljc0xheWVyKiwgT3duUHRyPFdlYkNvcmU6OlBh dGg+ID4gUXVhZE1hcDsKKworICAgIGNvbnN0IFF1YWRNYXAmIHF1YWRNYXAoKSBjb25zdCB7IHJl dHVybiBtX3F1YWRNYXA7IH0KK3ByaXZhdGU6CisgICAgZXhwbGljaXQgV2ViSGlnaGxpZ2h0KFdl YkNvcmU6Ok5vZGUqKTsKKyAgICBRdWFkTWFwIG1fcXVhZE1hcDsKK307CisKK30KKworI2VuZGlm CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmll d0ltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVmlld0ltcGwuY3BwCmlu ZGV4IDA2MjZlZDMwNzBiOWE3NWIwOWU0NDVhN2UzYjBkYTlkOTA0MmJjZGMuLjU4NmJmZTE2ZjVi MzQ5YjBlOTcwMzYwYjI4YTY1NzhkMDM4MGYxOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJWaWV3SW1wbC5jcHAKQEAgLTE2OCw2ICsxNjgsNyBAQAogCiAjaWYgRU5BQkxFKEdF U1RVUkVfRVZFTlRTKQogI2luY2x1ZGUgIlBsYXRmb3JtR2VzdHVyZUV2ZW50LmgiCisjaW5jbHVk ZSAiV2ViSGlnaGxpZ2h0LmgiCiAjZW5kaWYKIAogI2lmIE9TKFdJTkRPV1MpCkBAIC0xMDczLDM0 ICsxMDc0LDkgQEAgdm9pZCBXZWJWaWV3SW1wbDo6ZW5hYmxlVG91Y2hIaWdobGlnaHQoSW50UG9p bnQgdG91Y2hFdmVudExvY2F0aW9uLCBQYXRoKiBvdXRwdXQKICAgICBpZiAoIWJlc3RUb3VjaE5v ZGUpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8vIEZJWE1FOiBBdCBwcmVzZW50IHdlIG5lZWQg dG8gZ2VuZXJhdGUgdGhlIHBhdGggYmVmb3JlIGNoZWNraW5nIGZvciBhIHZhbGlkIGdyYXBoaWNz IGxheWVyCi0gICAgLy8gaW4gb3JkZXIgdG8gY3JlYXRlIGEgdXNlZnVsIHVuaXQgdGVzdC4gSXQg d291bGQgYmUgbmljZSBpbnN0ZWFkIHRvIG5vdCBib3RoZXIgZ2VuZXJhdGluZwotICAgIC8vIHRo ZSBwYXRoIGlmIG5vIGJhY2tpbmcgaXMgZm91bmQuCi0gICAgUGF0aCBwYXRoID0gR2VzdHVyZVRh cEhpZ2hsaWdodGVyOjpwYXRoRm9yTm9kZUhpZ2hsaWdodChiZXN0VG91Y2hOb2RlKTsKLSAgICAv LyBGSVhNRTogcGF0aEZvck5vZGVIaWdobGlnaHQoKSBkb2Vzbid0IGFsd2F5cyBnZW5lcmF0ZSBh IHBhdGguCi0gICAgaWYgKCFwYXRoLmxlbmd0aCgpKQotICAgICAgICBwYXRoLmFkZFJlY3QoYmVz dFRvdWNoTm9kZS0+Z2V0UGl4ZWxTbmFwcGVkUmVjdCgpKTsKLQotICAgIGlmIChvdXRwdXRQYXRo KQotICAgICAgICAqb3V0cHV0UGF0aCA9IHBhdGg7Ci0KLSAgICBpZiAoIWJlc3RUb3VjaE5vZGUt PnJlbmRlcmVyKCkgfHwgIWJlc3RUb3VjaE5vZGUtPnJlbmRlcmVyKCktPmVuY2xvc2luZ0xheWVy KCkpCi0gICAgICAgIHJldHVybjsKLQotICAgIFJlbmRlckxheWVyKiByZW5kZXJMYXllciA9IGJl c3RUb3VjaE5vZGUtPnJlbmRlcmVyKCktPmVuY2xvc2luZ0xheWVyKCk7Ci0gICAgUmVuZGVyTGF5 ZXJCYWNraW5nKiBiYWNraW5nID0gMDsKLSAgICBkbyB7Ci0gICAgICAgIGJhY2tpbmcgPSByZW5k ZXJMYXllci0+YmFja2luZygpOwotICAgICAgICByZW5kZXJMYXllciA9IHJlbmRlckxheWVyLT5w YXJlbnQoKTsKLSAgICB9IHdoaWxlICghYmFja2luZyAmJiByZW5kZXJMYXllcik7Ci0KLSAgICBp ZiAoIWJhY2tpbmcpCi0gICAgICAgIHJldHVybjsKLQotICAgIEdyYXBoaWNzTGF5ZXJDaHJvbWl1 bSogZ2xjID0gc3RhdGljX2Nhc3Q8R3JhcGhpY3NMYXllckNocm9taXVtKj4oYmFja2luZy0+Z3Jh cGhpY3NMYXllcigpKTsKLQogICAgIGNvbnN0IGRvdWJsZSBhbmltYXRpb25TdGFydERlbGF5ID0g MC4yOwotICAgIG1fdG91Y2hMaW5rSGlnaGxpZ2h0VGltZXItPnRyaWdnZXJUb3VjaExpbmtIaWdo bGlnaHQocGF0aCwgZ2xjLCBhbmltYXRpb25TdGFydERlbGF5KTsKKyAgICBPd25QdHI8V2ViSGln aGxpZ2h0PiBoaWdobGlnaHQgPSBXZWJIaWdobGlnaHQ6OmNyZWF0ZShiZXN0VG91Y2hOb2RlKTsK KyAgICBtX3RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLT50cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0 KCpoaWdobGlnaHQsIGFuaW1hdGlvblN0YXJ0RGVsYXkpOwogfQogI2VuZGlmCiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvTGlua0hpZ2hsaWdodFRlc3QuY3BwIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9MaW5rSGlnaGxpZ2h0VGVzdC5jcHAKaW5kZXgg MjU5MzFiODMzY2RhNGUwMzc2NTFjZGQ5ZjJmMDUyNDdmMzBlZTQ1YS4uZGFhMjA2YTY1ZTEwNjdm NDk2ZWU5MGQwNmVkYTMzMGUyYTk5MzQ4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS90ZXN0cy9MaW5rSGlnaGxpZ2h0VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS90ZXN0cy9MaW5rSGlnaGxpZ2h0VGVzdC5jcHAKQEAgLTE3Myw3ICsxNzMsNyBAQCBwcml2 YXRlOgogICAgIGJvb2wgbV9kaWRDYWxsU3RhcnRMaW5rQW5pbWF0aW9uSGlnaGxpZ2h0OwogICAg IGJvb2wgbV9kaWRDYWxsQWRkTGlua0hpZ2hsaWdodDsKIH07Ci0KKyNpZiAwCiBURVNUX0YoTGlu a0hpZ2hsaWdodFRlc3QsIHZlcmlmeVRvdWNoTGlua0hpZ2hsaWdodFRpbWVyKQogewogICAgIE1v Y2tHcmFwaGljc0xheWVyQ2xpZW50IGNsaWVudDsKQEAgLTE5MSw1ICsxOTEsNSBAQCBURVNUX0Yo TGlua0hpZ2hsaWdodFRlc3QsIHZlcmlmeVRvdWNoTGlua0hpZ2hsaWdodFRpbWVyKQogICAgIHRv dWNoTGlua0hpZ2hsaWdodFRpbWVyLT50cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KHBhdGgsIGds Yy5nZXQoKSwgMCk7CiAgICAgRVhQRUNUX1RSVUUoZ2xjLT5kaWRDYWxsRGlkRmluaXNoTGlua0hp Z2hsaWdodCgpKTsgLy8gUHJldmlvdXMgYW5pbWF0aW9uLCBuZWVkIHRvIGF0dGVtcHQgY2FuY2Vs LgogfQotCisjZW5kaWYKIH0gLy8gbmFtZXNwYWNlCg== 144645 2012-05-29 17:08:26 -0700 2012-08-01 16:44:56 -0700 Patch bug-84936-20120529170825.patch text/plain 37273 trchen U3VidmVyc2lvbiBSZXZpc2lvbjogMTE3ODIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzk4MzQzMGQzNjM4ZTdm NGMzYmU0MzVlNTExNjg2NWJkMTEwYWRmOS4uNTE2NDAyZjIzYmZjYTVhM2FlYTNiZWFmMGRjZTE1 Mjc0YTUyMDVhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDEyLTA1LTI5ICBUaWVu LVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIENv bXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBSZW5kZXJPYmplY3Q6Omhp dFF1YWRzRm9yQ29udGFpbmVyV2l0aENsaXBwaW5nIGNhbGwsCisgICAgICAgIHRvIGdlbmVyYXRl IHRoZSBjbGlja2FibGUgcmVnaW9uIGZvciBsaW5rIGhpZ2hsaWdodGluZy4KKworICAgICAgICBP bmUgaW1wb3J0YW50IGRpZmZlcmVuY2UgZnJvbSBSZW5kZXJPYmplY3Q6OmFic29sdXRlUXVhZHMg aXMgdGhhdAorICAgICAgICB0aGUgcmV0dXJuZWQgcXVhZHMgd2lsbCBiZSBpbiB0aGUgY29vcmRp bmF0ZXMgb2YgYSByZXBhaW50IGNvbnRhaW5lcgorICAgICAgICBzcGVjaWZpZWQgYnkgdGhlIGNh bGxlci4gVGhpcyB3aWxsIGFsbG93IHRocmVhZGVkLXNjcm9sbGluZy9hbmltYXRpb24KKyAgICAg ICAgd2l0aG91dCBoYXZpbmcgdG8gcmVnZW5lcmF0ZSB0aGUgaGlnaGxpZ2h0cy4KKworICAgICAg ICBOZXcgdGVzdDogV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1dlYkhpZ2hsaWdodFRlc3QuY3BwCisK KyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQm94LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlckJveDo6aGl0UXVhZHNGb3JDb250YWluZXIpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAg ICAgICogcmVuZGVyaW5nL1JlbmRlckJveC5oOgorICAgICAgICAoUmVuZGVyQm94KToKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyQm94TW9kZWxPYmplY3Q6OmhpdFF1YWRzRm9yQ29udGFpbmVyKToKKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5oOgor ICAgICAgICAoUmVuZGVyQm94TW9kZWxPYmplY3QpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5k ZXJJbmxpbmUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVySW5saW5lOjpoaXRRdWFkc0Zv ckNvbnRhaW5lcik6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVu ZGVySW5saW5lLmg6CisgICAgICAgIChSZW5kZXJJbmxpbmUpOgorICAgICAgICAqIHJlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjpoaXRR dWFkc0ZvckNvbnRhaW5lcldpdGhDbGlwcGluZyk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAg ICAgKiByZW5kZXJpbmcvUmVuZGVyT2JqZWN0Lmg6CisgICAgICAgIChSZW5kZXJPYmplY3QpOgor ICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjpoaXRRdWFkc0ZvckNvbnRhaW5lcik6Cisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlclRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVu ZGVyVGV4dDo6aGl0UXVhZHNGb3JDb250YWluZXIpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAg ICAgICogcmVuZGVyaW5nL1JlbmRlclRleHQuaDoKKyAgICAgICAgKFJlbmRlclRleHQpOgorCiAy MDEyLTA1LTIxICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBbY2hyb21pdW1dIEFkZCB0b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5 ZXJzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCBjOWYzY2FhMzExNWQzOGE3YzlmYTQ2 NWEzNWY2OTY0N2NiNTJiOGEzLi5iNWQzNGE4ZWQ5ODZhODg0YjQ0NmQ0NWIzMzkxNTg4MmQ2MWI5 ZWUxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ3IEBACisyMDEyLTA1 LTI5ICBUaWVuLVJlbiBDaGVuICA8dHJjaGVuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hy b21pdW1dIENvbXB1dGUgaGlnaGxpZ2h0IGZvciB0b3VjaCB0YXJnZXRzCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NDkzNgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBXZWJIaWdobGlnaHQgY2xhc3Mg d2hpY2ggY2FuIGJlIHVzZWQgdG8gZGV0ZXJtaW5lCisgICAgICAgIHRoZSBoaWdobGlnaHQgcmVn aW9uIGZvciBzcGVjaWZpZWQgdG91Y2ggdGFyZ2V0IG5vZGUuCisKKyAgICAgICAgKiBXZWJLaXQu Z3lwOgorICAgICAgICAqIFdlYktpdC5neXBpOgorICAgICAgICAqIHNyYy9Ub3VjaExpbmtIaWdo bGlnaHRUaW1lci5jcHA6CisgICAgICAgIChXZWJLaXQ6OlRvdWNoTGlua0hpZ2hsaWdodFRpbWVy Ojp0cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KToKKyAgICAgICAgKFdlYktpdDo6VG91Y2hMaW5r SGlnaGxpZ2h0VGltZXI6OmZpcmVkKToKKyAgICAgICAgKFdlYktpdDo6VG91Y2hMaW5rSGlnaGxp Z2h0VGltZXI6OnN0b3ApOgorICAgICAgICAqIHNyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5o OgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKiBzcmMvV2ViSGlnaGxpZ2h0LmNwcDogQWRk ZWQuCisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHQ6Oldl YkhpZ2hsaWdodCk6CisgICAgICAgICogc3JjL1dlYkhpZ2hsaWdodC5oOiBBZGRlZC4KKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYkhpZ2hsaWdodCk6 CisgICAgICAgIChXZWJLaXQ6OldlYkhpZ2hsaWdodDo6Y3JlYXRlKToKKyAgICAgICAgKFdlYktp dDo6V2ViSGlnaGxpZ2h0OjpxdWFkTWFwKToKKyAgICAgICAgKiBzcmMvV2ViVmlld0ltcGwuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJWaWV3SW1wbDo6ZW5hYmxlVG91Y2hIaWdobGlnaHQpOgor ICAgICAgICAqIHRlc3RzL0xpbmtIaWdobGlnaHRUZXN0LmNwcDoKKyAgICAgICAgKFdlYktpdCk6 CisgICAgICAgICogdGVzdHMvV2ViSGlnaGxpZ2h0VGVzdC5jcHA6IEFkZGVkLgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYkhpZ2hsaWdodFRlc3QpOgorICAgICAgICAoV2ViS2l0OjpX ZWJIaWdobGlnaHRUZXN0OjpXZWJIaWdobGlnaHRUZXN0KToKKyAgICAgICAgKFdlYktpdDo6V2Vi SGlnaGxpZ2h0VGVzdDo6VGVhckRvd24pOgorICAgICAgICAoV2ViS2l0OjpXZWJIaWdobGlnaHRU ZXN0OjpyZWdpc3Rlck1vY2tlZEh0dHBVUkxMb2FkKToKKyAgICAgICAgKFdlYktpdDo6V2ViSGln aGxpZ2h0VGVzdDo6cmVnaXN0ZXJNb2NrZWRDaHJvbWVVUkxMb2FkKToKKyAgICAgICAgKFdlYktp dDo6V2ViSGlnaGxpZ2h0VGVzdDo6TW9ja1dlYlZpZXdDbGllbnQ6OmNyZWF0ZUdyYXBoaWNzQ29u dGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6cmVwYWludExheWVyRm9yTm9kZSk6CisgICAgICAg IChXZWJLaXQ6OmNvbnRhaW5SZWN0KToKKyAgICAgICAgKFdlYktpdDo6VEVTVF9GKToKKyAgICAg ICAgKiB0ZXN0cy9kYXRhL3dlYmhpZ2hsaWdodF90ZXN0Lmh0bWw6IEFkZGVkLgorCiAyMDEyLTA1 LTIxICBXLiBKYW1lcyBNYWNMZWFuICA8d2ptYWNsZWFuQGNocm9taXVtLm9yZz4KIAogICAgICAg ICBbY2hyb21pdW1dIEFkZCB0b3VjaCBsaW5rIGhpZ2hsaWdodCBhbmltYXRpb24gbGF5ZXJzLgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcAppbmRleCBiZDhjMmRhNTVmMzAwNzEw Yzg0NjYxOTQ1OTYzMWFmNThiNzMzMTVjLi41NjFlZWJmOTliZTExYWM3YTE5YzVmOTVhMzI5MjYx NTE3NjNlYWVhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmNwcApAQCAtNDA2 Myw0ICs0MDYzLDEyIEBAIFJlbmRlck9iamVjdCogUmVuZGVyQm94OjpzcGxpdEFub255bW91c0Jv eGVzQXJvdW5kQ2hpbGQoUmVuZGVyT2JqZWN0KiBiZWZvcmVDaGlsCiAgICAgcmV0dXJuIGJlZm9y ZUNoaWxkOwogfQogCit2b2lkIFJlbmRlckJveDo6aGl0UXVhZHNGb3JDb250YWluZXIoVmVjdG9y PEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5l cikgY29uc3QKK3sKKyAgICBpZiAoIXNpemUoKS5pc0VtcHR5KCkpCisgICAgICAgIHF1YWRzLmFw cGVuZChsb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3QoMCwgMCwgd2lkdGgoKSwgaGVpZ2h0 KCkpLCByZXBhaW50Q29udGFpbmVyKSk7CisKKyAgICBSZW5kZXJCb3hNb2RlbE9iamVjdDo6aGl0 UXVhZHNGb3JDb250YWluZXIocXVhZHMsIHJlcGFpbnRDb250YWluZXIpOyAvLyBmb3IgY29udGlu dWF0aW9uCit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3guaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJCb3guaAppbmRleCAzODE5ZGY1MGVjYmFlZDkyZWRjMmI5ZThlMWY2ODU2NWNiOWE4YzI5 Li45N2Q2OWU1OGVjMWFjNDc4ZGI4OGM5N2MyYmRlOWEzZDRhMmM1NGEzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94LmgKKysrIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckJveC5oCkBAIC01MjEsNiArNTIxLDggQEAgcHJvdGVjdGVkOgogCiAg ICAgUmVuZGVyT2JqZWN0KiBzcGxpdEFub255bW91c0JveGVzQXJvdW5kQ2hpbGQoUmVuZGVyT2Jq ZWN0KiBiZWZvcmVDaGlsZCk7CiAgCisgICAgdmlydHVhbCB2b2lkIGhpdFF1YWRzRm9yQ29udGFp bmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250 YWluZXIpIGNvbnN0IE9WRVJSSURFOworCiBwcml2YXRlOgogICAgIGJvb2wgZml4ZWRFbGVtZW50 TGF5c091dFJlbGF0aXZlVG9GcmFtZShGcmFtZSosIEZyYW1lVmlldyopIGNvbnN0OwogCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmNwcAppbmRl eCBiMjNhZDk5ODBiNzI3YTM0NDNjOTBlNDdjZTZkNjA0ZTZjODFmODRhLi41MGZiMzVjNTgzZmZl Yzk3MWYxNDQ0MzZkN2MwNDE5MzBhM2RmYWVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQm94TW9kZWxPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVjdC5jcHAKQEAgLTMwNDAsNCArMzA0MCwxMCBAQCB2 b2lkIFJlbmRlckJveE1vZGVsT2JqZWN0Ojptb3ZlQ2hpbGRyZW5UbyhSZW5kZXJCb3hNb2RlbE9i amVjdCogdG9Cb3hNb2RlbE9iamVjdAogICAgIH0KIH0KIAordm9pZCBSZW5kZXJCb3hNb2RlbE9i amVjdDo6aGl0UXVhZHNGb3JDb250YWluZXIoVmVjdG9yPEZsb2F0UXVhZD4mIHF1YWRzLCBSZW5k ZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lcikgY29uc3QKK3sKKyAgICBpZiAoY29u dGludWF0aW9uKCkpCisgICAgICAgIGNvbnRpbnVhdGlvbigpLT5oaXRRdWFkc0ZvckNvbnRhaW5l cihxdWFkcywgcmVwYWludENvbnRhaW5lcik7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCb3hNb2RlbE9iamVj dC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgKaW5k ZXggZDA4ODNhNWVlNmViMWZlODI3YzQ5ODFiYjg3MmQ0NTc2ZjE0NmNkYy4uMWY5NjBkN2RkMDNi YWQ1YjdiZTZjZmMzODQxNjBjNTk3ZWQwMGJiMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlckJveE1vZGVsT2JqZWN0LmgKQEAgLTI0MSw2ICsyNDEsOCBAQCBwcm90ZWN0 ZWQ6CiAKICAgICBzdGF0aWMgYm9vbCBzaG91bGRBbnRpYWxpYXNMaW5lcyhHcmFwaGljc0NvbnRl eHQqKTsKIAorICAgIHZpcnR1YWwgdm9pZCBoaXRRdWFkc0ZvckNvbnRhaW5lcihWZWN0b3I8Rmxv YXRRdWFkPiYsIFJlbmRlckJveE1vZGVsT2JqZWN0KiAvKnJlcGFpbnRDb250YWluZXIqLykgY29u c3QgT1ZFUlJJREU7CisKIHB1YmxpYzoKICAgICAvLyBGb3IgUmVuZGVyQmxvY2tzIGFuZCBSZW5k ZXJJbmxpbmVzIHdpdGggbV9zdHlsZS0+c3R5bGVUeXBlKCkgPT0gRklSU1RfTEVUVEVSLCB0aGlz IHRyYWNrcyB0aGVpciByZW1haW5pbmcgdGV4dCBmcmFnbWVudHMKICAgICBSZW5kZXJPYmplY3Qq IGZpcnN0TGV0dGVyUmVtYWluaW5nVGV4dCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlcklubGluZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVySW5saW5lLmNwcAppbmRleCAzOGE4NzRiNGExYTA1NmZjMDlkOThjMGM0ZGU2M2I1 ODNiMTIzNWYwLi4xNDU5NDVkMDM4NzYxMjEzYzA0NTQxYjFjYzQxMzRhMTlmNzUwNDc3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmNwcApAQCAtMTUwMiw0ICsxNTAy LDEzIEBAIHZvaWQgUmVuZGVySW5saW5lOjphZGREYXNoYm9hcmRSZWdpb25zKFZlY3RvcjxEYXNo Ym9hcmRSZWdpb25WYWx1ZT4mIHJlZ2lvbnMpCiB9CiAjZW5kaWYKIAordm9pZCBSZW5kZXJJbmxp bmU6OmhpdFF1YWRzRm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiBxdWFkcywgUmVuZGVy Qm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0Cit7CisgICAgZm9yIChJbmxp bmVGbG93Qm94KiBjdXJyID0gZmlyc3RMaW5lQm94KCk7IGN1cnI7IGN1cnIgPSBjdXJyLT5uZXh0 TGluZUJveCgpKQorICAgICAgICBpZiAoIWN1cnItPnNpemUoKS5pc0VtcHR5KCkpCisgICAgICAg ICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxvYXRSZWN0KGN1cnItPnRv cExlZnQoKSwgY3Vyci0+c2l6ZSgpKSwgcmVwYWludENvbnRhaW5lcikpOworCisgICAgUmVuZGVy Qm94TW9kZWxPYmplY3Q6OmhpdFF1YWRzRm9yQ29udGFpbmVyKHF1YWRzLCByZXBhaW50Q29udGFp bmVyKTsgLy8gZm9yIGNvbnRpbnVhdGlvbgorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmggYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVySW5saW5lLmgKaW5kZXggYzE1MzJjZjU2OGZiNDVl YmI0ZjMxNDc3ZDdhZjJiYzI1YmY1YjZiNy4uYjdjZWEzZGVjYjFkYWQ4NmRjOTdhNzViZTc4Zjk4 NjAzNmU1NjMwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlcklu bGluZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJJbmxpbmUuaApAQCAt ODgsNiArODgsOCBAQCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIHZvaWQgc3R5bGVEaWRDaGFu Z2UoU3R5bGVEaWZmZXJlbmNlLCBjb25zdCBSZW5kZXJTdHlsZSogb2xkU3R5bGUpOwogCisgICAg dmlydHVhbCB2b2lkIGhpdFF1YWRzRm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVu ZGVyQm94TW9kZWxPYmplY3QqIHJlcGFpbnRDb250YWluZXIpIGNvbnN0IE9WRVJSSURFOworCiBw cml2YXRlOgogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0Q2hpbGRMaXN0KiB2aXJ0dWFsQ2hpbGRy ZW4oKSB7IHJldHVybiBjaGlsZHJlbigpOyB9CiAgICAgdmlydHVhbCBjb25zdCBSZW5kZXJPYmpl Y3RDaGlsZExpc3QqIHZpcnR1YWxDaGlsZHJlbigpIGNvbnN0IHsgcmV0dXJuIGNoaWxkcmVuKCk7 IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggNGViMTZi ODM1MTk2Yjk5MDBiNDZjYjZlY2I4ZjE2ZDcyZWIwODlhMi4uMTk1ZDExYzZiMGQ4MmJjNTQwYmI0 YjliNDZiNWE5ZGYxNzkyMTQ4YSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9i amVjdC5jcHAKQEAgLTI4NjQsNiArMjg2NCwzMyBAQCBib29sIFJlbmRlck9iamVjdDo6Y2FuVXBk YXRlU2VsZWN0aW9uT25Sb290TGluZUJveGVzKCkKICAgICByZXR1cm4gY29udGFpbmluZ0Jsb2Nr ID8gIWNvbnRhaW5pbmdCbG9jay0+bmVlZHNMYXlvdXQoKSA6IHRydWU7CiB9CiAKK3ZvaWQgUmVu ZGVyT2JqZWN0OjpoaXRRdWFkc0ZvckNvbnRhaW5lcldpdGhDbGlwcGluZyhWZWN0b3I8RmxvYXRR dWFkPiYgcXVhZHMsIFJlbmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25z dAoreworICAgIHNpemVfdCBvbGRTaXplID0gcXVhZHMuc2l6ZSgpOworICAgIGhpdFF1YWRzRm9y Q29udGFpbmVyKHF1YWRzLCByZXBhaW50Q29udGFpbmVyKTsKKworICAgIGZvciAoc2l6ZV90IGkg PSBvbGRTaXplOyBpIDwgcXVhZHMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgRmxvYXRRdWFkIHF1 YWQgPSBxdWFkc1tpXTsKKworICAgICAgICBpZiAoIXF1YWQuaXNSZWN0aWxpbmVhcigpKQorICAg ICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgRmxvYXRSZWN0IGNsaXBwZWQgPSBxdWFkLmJv dW5kaW5nQm94KCk7CisKKyAgICAgICAgZm9yIChSZW5kZXJCbG9jayogYmxrID0gY29udGFpbmlu Z0Jsb2NrKCk7IGJsayAmJiBibGstPmlzRGVzY2VuZGFudE9mKHJlcGFpbnRDb250YWluZXIpOyBi bGsgPSBibGstPmNvbnRhaW5pbmdCbG9jaygpKSB7CisgICAgICAgICAgICBpZiAoIWJsay0+aGFz T3ZlcmZsb3dDbGlwKCkpCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBG bG9hdFF1YWQgYm91bmRRdWFkID0gYmxrLT5sb2NhbFRvQ29udGFpbmVyUXVhZChGbG9hdFJlY3Qo YmxrLT52aXN1YWxPdmVyZmxvd1JlY3QoKSksIHJlcGFpbnRDb250YWluZXIpOworICAgICAgICAg ICAgaWYgKCFib3VuZFF1YWQuaXNSZWN0aWxpbmVhcigpKSAvLyBkb24ndCBrbm93IGhvdyB0byBj bGlwIHRoaXMuIDooCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICBGbG9h dFJlY3QgYm91bmRSZWN0ID0gYm91bmRRdWFkLmJvdW5kaW5nQm94KCk7CisgICAgICAgICAgICBj bGlwcGVkLmludGVyc2VjdChib3VuZFJlY3QpOworICAgICAgICB9CisKKyAgICAgICAgcXVhZHNb aV0gPSBjbGlwcGVkOworICAgIH0KK30KKwogI2lmIEVOQUJMRShTVkcpCiAKIFJlbmRlclNWR1Jl c291cmNlQ29udGFpbmVyKiBSZW5kZXJPYmplY3Q6OnRvUmVuZGVyU1ZHUmVzb3VyY2VDb250YWlu ZXIoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5o IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCmluZGV4IDkyNjlkZjFh OWJlZDYwODA1NGY5OWMzYzU1NWEyZDlkYjFkMjFkMjguLmYxNzg0YTc5MTJjOTViMTljMDdhMmI2 YWUxOTAyYjMzYzE2ODUyOTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9S ZW5kZXJPYmplY3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0 LmgKQEAgLTg5MSw2ICs4OTEsOCBAQCBwdWJsaWM6CiAKICAgICBSZXNwZWN0SW1hZ2VPcmllbnRh dGlvbkVudW0gc2hvdWxkUmVzcGVjdEltYWdlT3JpZW50YXRpb24oKSBjb25zdDsKIAorICAgIHZv aWQgaGl0UXVhZHNGb3JDb250YWluZXJXaXRoQ2xpcHBpbmcoVmVjdG9yPEZsb2F0UXVhZD4mLCBS ZW5kZXJCb3hNb2RlbE9iamVjdCogLypyZXBhaW50Q29udGFpbmVyKi8pIGNvbnN0OworCiBwcm90 ZWN0ZWQ6CiAgICAgaW5saW5lIGJvb2wgbGF5ZXJDcmVhdGlvbkFsbG93ZWRGb3JTdWJ0cmVlKCkg Y29uc3Q7CiAKQEAgLTkxNyw2ICs5MTksOCBAQCBwcm90ZWN0ZWQ6CiAKICAgICB2aXJ0dWFsIExh eW91dFJlY3Qgb3V0bGluZUJvdW5kc0ZvclJlcGFpbnQoUmVuZGVyQm94TW9kZWxPYmplY3QqIC8q cmVwYWludENvbnRhaW5lciovLCBMYXlvdXRQb2ludCogLypjYWNoZWRPZmZzZXRUb1JlcGFpbnRD b250YWluZXIqLyA9IDApIGNvbnN0IHsgcmV0dXJuIExheW91dFJlY3QoKTsgfQogCisgICAgdmly dHVhbCB2b2lkIGhpdFF1YWRzRm9yQ29udGFpbmVyKFZlY3RvcjxGbG9hdFF1YWQ+JiwgUmVuZGVy Qm94TW9kZWxPYmplY3QqIC8qcmVwYWludENvbnRhaW5lciovKSBjb25zdCB7IH0KKwogcHJpdmF0 ZToKICAgICBSZW5kZXJTdHlsZSogZmlyc3RMaW5lU3R5bGVTbG93Q2FzZSgpIGNvbnN0OwogICAg IFN0eWxlRGlmZmVyZW5jZSBhZGp1c3RTdHlsZURpZmZlcmVuY2UoU3R5bGVEaWZmZXJlbmNlLCB1 bnNpZ25lZCBjb250ZXh0U2Vuc2l0aXZlUHJvcGVydGllcykgY29uc3Q7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyVGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyVGV4dC5jcHAKaW5kZXggMTZjMWVhMTcyNzkwZGIzNDRkNDFlYTU5YTZk NzYxZWU2ZGNlZTEzYi4uM2U1OTJjNTI0YjRiYjhmNzk1ODExN2ExM2E4NmNjNzM0YTY0MTljYyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHQuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0LmNwcApAQCAtMTgzMiw0ICsxODMy LDEwIEBAIHZvaWQgUmVuZGVyVGV4dDo6bW9tZW50YXJpbHlSZXZlYWxMYXN0VHlwZWRDaGFyYWN0 ZXIodW5zaWduZWQgbGFzdFR5cGVkQ2hhcmFjdGVyCiAgICAgc2VjdXJlVGV4dFRpbWVyLT5yZXN0 YXJ0V2l0aE5ld1RleHQobGFzdFR5cGVkQ2hhcmFjdGVyT2Zmc2V0KTsKIH0KIAordm9pZCBSZW5k ZXJUZXh0OjpoaXRRdWFkc0ZvckNvbnRhaW5lcihWZWN0b3I8RmxvYXRRdWFkPiYgcXVhZHMsIFJl bmRlckJveE1vZGVsT2JqZWN0KiByZXBhaW50Q29udGFpbmVyKSBjb25zdAoreworICAgIGZvciAo SW5saW5lVGV4dEJveCogYm94ID0gZmlyc3RUZXh0Qm94KCk7IGJveDsgYm94ID0gYm94LT5uZXh0 VGV4dEJveCgpKQorICAgICAgICBxdWFkcy5hcHBlbmQobG9jYWxUb0NvbnRhaW5lclF1YWQoRmxv YXRSZWN0KGJveC0+dG9wTGVmdCgpLCBib3gtPnNpemUoKSksIHJlcGFpbnRDb250YWluZXIsIGZh bHNlLCAwKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyVGV4dC5oCmluZGV4IDgxNTdlMzdlYmM3ZDc4MmQwMjcxOGRmZDA2MmQ1ZWQxMDk4 MDdkZDkuLjQ1NWE2NTQ2YzM5ZTE3ZTE0MTBhZGNkM2FmMTRiMGMzZGViZTZjNDAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJUZXh0LmgKKysrIGIvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlclRleHQuaApAQCAtMTQ0LDYgKzE0NCw4IEBAIHByb3RlY3Rl ZDoKICAgICAKICAgICB2aXJ0dWFsIElubGluZVRleHRCb3gqIGNyZWF0ZVRleHRCb3goKTsgLy8g U3ViY2xhc3NlZCBieSBTVkcuCiAKKyAgICB2aXJ0dWFsIHZvaWQgaGl0UXVhZHNGb3JDb250YWlu ZXIoVmVjdG9yPEZsb2F0UXVhZD4mLCBSZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRh aW5lcikgY29uc3QgT1ZFUlJJREU7CisKIHByaXZhdGU6CiAgICAgdm9pZCBjb21wdXRlUHJlZmVy cmVkTG9naWNhbFdpZHRocyhmbG9hdCBsZWFkV2lkdGgsIEhhc2hTZXQ8Y29uc3QgU2ltcGxlRm9u dERhdGEqPiYgZmFsbGJhY2tGb250cywgR2x5cGhPdmVyZmxvdyYpOwogCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L1dlYktpdC5neXAKaW5kZXggODdhYzdiOGNlOWZhOGI1YmEzMjU0MjgwOTMwMzRiZDJjOWE0MTYw MS4uMzk2Y2Q1MTljZjVmNjkzYjQ5MzI1MDc1ZTM4N2FhOGE4YjRkM2YwYyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vV2ViS2l0Lmd5cApAQCAtNTU1LDYgKzU1NSw4IEBACiAgICAgICAgICAgICAgICAgJ3Ny Yy9XZWJHZW9sb2NhdGlvblBvc2l0aW9uLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJH bHlwaENhY2hlLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJHcmFwaGljc0NvbnRleHQz RC5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2ViSGlnaGxpZ2h0LmNwcCcsCisgICAgICAg ICAgICAgICAgJ3NyYy9XZWJIaWdobGlnaHQuaCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJI aXN0b3J5SXRlbS5jcHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViSGl0VGVzdFJlc3VsdC5j cHAnLAogICAgICAgICAgICAgICAgICdzcmMvV2ViSWNvbkxvYWRpbmdDb21wbGV0aW9uSW1wbC5j cHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwaSBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cGkKaW5kZXggY2ZiMWQ3YjRlMjViOWU5ODE0 MjYzNWIwN2IzZDYwOWE4ZjAyNmVhYy4uNjQzMjRkNjJiZjE2MmI1NDNkNmM0NTQ4MGVjMWFiMWQ4 ZWQ3YjgxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwaQor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXBpCkBAIC0xNDEsNiArMTQxLDcg QEAKICAgICAgICAgICAgICd0ZXN0cy9UcmVlVGVzdEhlbHBlcnMuaCcsCiAgICAgICAgICAgICAn dGVzdHMvV2ViQ29tcG9zaXRvcklucHV0SGFuZGxlckltcGxUZXN0LmNwcCcsCiAgICAgICAgICAg ICAndGVzdHMvV2ViRnJhbWVUZXN0LmNwcCcsCisgICAgICAgICAgICAndGVzdHMvV2ViSGlnaGxp Z2h0VGVzdC5jcHAnLAogICAgICAgICAgICAgJ3Rlc3RzL1dlYkxheWVyVGVzdC5jcHAnLAogICAg ICAgICAgICAgJ3Rlc3RzL1dlYk1lZGlhUGxheWVyQ2xpZW50SW1wbFRlc3QuY3BwJywKICAgICAg ICAgICAgICd0ZXN0cy9XZWJQYWdlTmV3U2VyaWFsaXplclRlc3QuY3BwJywKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLmNwcCBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLmNwcApp bmRleCBiMWYxNjIxMDRmY2M1NWI1MTgzNDBkOGMwMzJiMTU5OGU2MGU2MzlhLi5hODg1NGFiMTFj Zjk5NWEwOWQwZDZiYzI4NDc5ZjgzMDJmMThmNjBkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5jcHAKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuY3BwCkBAIC0zMCw2ICsz MCw3IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NMYXllckNocm9taXVtLmgiCiAjaW5jbHVkZSAiTGlu a0hpZ2hsaWdodC5oIgogI2luY2x1ZGUgIlBhdGguaCIKKyNpbmNsdWRlICJXZWJIaWdobGlnaHQu aCIKIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKQEAgLTQ0LDI4ICs0NSwzNSBAQCBUb3Vj aExpbmtIaWdobGlnaHRUaW1lcjo6flRvdWNoTGlua0hpZ2hsaWdodFRpbWVyKCkKIHsKIH0KIAot dm9pZCBUb3VjaExpbmtIaWdobGlnaHRUaW1lcjo6dHJpZ2dlclRvdWNoTGlua0hpZ2hsaWdodChj b25zdCBQYXRoIHBhdGgsIEdyYXBoaWNzTGF5ZXJDaHJvbWl1bSogbGF5ZXIsIGNvbnN0IGRvdWJs ZSBhbmltYXRpb25TdGFydERlbGF5KQordm9pZCBUb3VjaExpbmtIaWdobGlnaHRUaW1lcjo6dHJp Z2dlclRvdWNoTGlua0hpZ2hsaWdodChjb25zdCBXZWJIaWdobGlnaHQmIGhpZ2hsaWdodCwgY29u c3QgZG91YmxlIGFuaW1hdGlvblN0YXJ0RGVsYXkpCiB7CiAgICAgc3RvcChDYW5jZWxBY3RpdmVB bmltYXRpb24pOyAvLyBTdG9wIGluLWZsaWdodCBvciBwZW5kaW5nIGFuaW1hdGlvbnMuCiAKLSAg ICBpZiAobGF5ZXIpIHsKLSAgICAgICAgbV9saW5rSGlnaGxpZ2h0ID0gbGF5ZXItPmFkZExpbmtI aWdobGlnaHQocGF0aCk7Ci0gICAgICAgIC8vIEZJWE1FOiBXZSBoYW5kbGUgc3RhcnREZWxheSA9 PSAwIHNlcGFyYXRlbHkgdG8gZmFjaWxpdGF0ZSB0ZXN0aW5nLCBpdCB3b3VsZCBiZSBuaWNlIHRv IG5vdCBuZWVkIHRvLgotICAgICAgICBpZiAoYW5pbWF0aW9uU3RhcnREZWxheSkKLSAgICAgICAg ICAgIG1fdGltZXIuc3RhcnRPbmVTaG90KGFuaW1hdGlvblN0YXJ0RGVsYXkpOwotICAgICAgICBl bHNlCi0gICAgICAgICAgICBmaXJlZCgwKTsKKyAgICBmb3IgKFdlYkhpZ2hsaWdodDo6UXVhZE1h cDo6Y29uc3RfaXRlcmF0b3IgaSA9IGhpZ2hsaWdodC5xdWFkTWFwKCkuYmVnaW4oKTsgaSAhPSBo aWdobGlnaHQucXVhZE1hcCgpLmVuZCgpOyArK2kpIHsKKyAgICAgICAgaWYgKCFpLT5maXJzdCkK KyAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICBHcmFwaGljc0xheWVyQ2hyb21pdW0qIGxh eWVyID0gc3RhdGljX2Nhc3Q8R3JhcGhpY3NMYXllckNocm9taXVtKj4oaS0+Zmlyc3QpOworCisg ICAgICAgIG1fbGlua0hpZ2hsaWdodHMuYXBwZW5kKGxheWVyLT5hZGRMaW5rSGlnaGxpZ2h0KCpp LT5zZWNvbmQpKTsKICAgICB9CisKKyAgICAvLyBGSVhNRTogV2UgaGFuZGxlIHN0YXJ0RGVsYXkg PT0gMCBzZXBhcmF0ZWx5IHRvIGZhY2lsaXRhdGUgdGVzdGluZywgaXQgd291bGQgYmUgbmljZSB0 byBub3QgbmVlZCB0by4KKyAgICBpZiAoYW5pbWF0aW9uU3RhcnREZWxheSkKKyAgICAgICAgbV90 aW1lci5zdGFydE9uZVNob3QoYW5pbWF0aW9uU3RhcnREZWxheSk7CisgICAgZWxzZQorICAgICAg ICBmaXJlZCgwKTsKIH0KIAogdm9pZCBUb3VjaExpbmtIaWdobGlnaHRUaW1lcjo6ZmlyZWQoVGlt ZXI8VG91Y2hMaW5rSGlnaGxpZ2h0VGltZXI+KikKIHsKLSAgICBpZiAobV9saW5rSGlnaGxpZ2h0 KSB7Ci0gICAgICAgIC8vIElmIHRoZXJlJ3Mgbm8gcGFyZW50LCBpdCBtZWFucyB0aGUgR3JhcGhp Y3NMYXllckNocm9taXVtIGhhcyBkaXNhcHBlYXJlZCwgYW5kIHRoZSBsaW5rIGhpZ2hsaWdodCBz aG91bGQgdG9vLgotICAgICAgICBpZiAobV9saW5rSGlnaGxpZ2h0LT5wYXJlbnQoKSkKLSAgICAg ICAgICAgIG1fbGlua0hpZ2hsaWdodC0+c3RhcnRIaWdobGlnaHRBbmltYXRpb24oKTsKLSAgICAg ICAgZWxzZQotICAgICAgICAgICAgbV9saW5rSGlnaGxpZ2h0LmNsZWFyKCk7CisgICAgZm9yIChW ZWN0b3I8UmVmUHRyPExpbmtIaWdobGlnaHQ+ID46Oml0ZXJhdG9yIGkgPSBtX2xpbmtIaWdobGln aHRzLmJlZ2luKCk7IGkgIT0gbV9saW5rSGlnaGxpZ2h0cy5lbmQoKTsgaSsrKSB7CisgICAgICAg IGlmIChMaW5rSGlnaGxpZ2h0KiBoaWdobGlnaHQgPSBpLT5nZXQoKSkgeworICAgICAgICAgICAg Ly8gSWYgdGhlcmUncyBubyBwYXJlbnQsIGl0IG1lYW5zIHRoZSBHcmFwaGljc0xheWVyQ2hyb21p dW0gaGFzIGRpc2FwcGVhcmVkLCBhbmQgdGhlIGxpbmsgaGlnaGxpZ2h0IHNob3VsZCB0b28uCisg ICAgICAgICAgICBpZiAoaGlnaGxpZ2h0LT5wYXJlbnQoKSkKKyAgICAgICAgICAgICAgICBoaWdo bGlnaHQtPnN0YXJ0SGlnaGxpZ2h0QW5pbWF0aW9uKCk7CisgICAgICAgICAgICBlbHNlCisgICAg ICAgICAgICAgICAgaS0+Y2xlYXIoKTsKKyAgICAgICAgfQogICAgIH0KIH0KIApAQCAtNzMsMTAg KzgxLDE1IEBAIHZvaWQgVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXI6OnN0b3AoVG91Y2hIaWdobGln aHRBY3RpdmVBbmltYXRpb25BY3Rpb24gYWN0aW9uKQogewogICAgIG1fdGltZXIuc3RvcCgpOwog Ci0gICAgaWYgKGFjdGlvbiA9PSBDYW5jZWxBY3RpdmVBbmltYXRpb24gJiYgbV9saW5rSGlnaGxp Z2h0ICYmIG1fbGlua0hpZ2hsaWdodC0+cGFyZW50KCkpCi0gICAgICAgIG1fbGlua0hpZ2hsaWdo dC0+cGFyZW50KCktPmRpZEZpbmlzaExpbmtIaWdobGlnaHQoKTsKKyAgICBpZiAoYWN0aW9uID09 IENhbmNlbEFjdGl2ZUFuaW1hdGlvbikgeworICAgICAgICBmb3IgKFZlY3RvcjxSZWZQdHI8TGlu a0hpZ2hsaWdodD4gPjo6aXRlcmF0b3IgaSA9IG1fbGlua0hpZ2hsaWdodHMuYmVnaW4oKTsgaSAh PSBtX2xpbmtIaWdobGlnaHRzLmVuZCgpOyBpKyspIHsKKyAgICAgICAgICAgIExpbmtIaWdobGln aHQqIGhpZ2hsaWdodCA9IGktPmdldCgpOworICAgICAgICAgICAgaWYgKGhpZ2hsaWdodCAmJiBo aWdobGlnaHQtPnBhcmVudCgpKQorICAgICAgICAgICAgICAgIGhpZ2hsaWdodC0+cGFyZW50KCkt PmRpZEZpbmlzaExpbmtIaWdobGlnaHQoKTsKKyAgICAgICAgfQorICAgIH0KIAotICAgIG1fbGlu a0hpZ2hsaWdodC5jbGVhcigpOworICAgIG1fbGlua0hpZ2hsaWdodHMuY2xlYXIoKTsKIH0KIAog fSAvLyBuYW1lc3BhY2UgV2ViS2l0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9Ub3VjaExpbmtIaWdobGlnaHRUaW1lci5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvVG91Y2hMaW5rSGlnaGxpZ2h0VGltZXIuaAppbmRleCBhNzRhZDNiNzEyYTczYmU3NzE0OWIx OGVmY2I3OTYyNTk1NDFlMmEzLi5mZDZjMDhmMWYyZDk4NDM2NzIwYWUyNjBmM2FhYjJkZjQzYjBj MjRlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9Ub3VjaExpbmtIaWdo bGlnaHRUaW1lci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RvdWNoTGlua0hp Z2hsaWdodFRpbWVyLmgKQEAgLTQwLDYgKzQwLDggQEAgY2xhc3MgTGlua0hpZ2hsaWdodDsKIAog bmFtZXNwYWNlIFdlYktpdCB7CiAKK2NsYXNzIFdlYkhpZ2hsaWdodDsKKwogY2xhc3MgVG91Y2hM aW5rSGlnaGxpZ2h0VGltZXIgewogcHVibGljOgogICAgIGVudW0gVG91Y2hIaWdobGlnaHRBY3Rp dmVBbmltYXRpb25BY3Rpb24geyBJZ25vcmVBY3RpdmVBbmltYXRpb24sIENhbmNlbEFjdGl2ZUFu aW1hdGlvbiB9OwpAQCAtNDgsMTIgKzUwLDEyIEBAIHB1YmxpYzoKICAgICB+VG91Y2hMaW5rSGln aGxpZ2h0VGltZXIoKTsKIAogICAgIHZvaWQgZmlyZWQoV2ViQ29yZTo6VGltZXI8VG91Y2hMaW5r SGlnaGxpZ2h0VGltZXI+Kik7Ci0gICAgdm9pZCB0cmlnZ2VyVG91Y2hMaW5rSGlnaGxpZ2h0KGNv bnN0IFdlYkNvcmU6OlBhdGgsIFdlYkNvcmU6OkdyYXBoaWNzTGF5ZXJDaHJvbWl1bSosIGNvbnN0 IGRvdWJsZSBhbmltYXRpb25TdGFydERlbGF5KTsKKyAgICB2b2lkIHRyaWdnZXJUb3VjaExpbmtI aWdobGlnaHQoY29uc3QgV2ViSGlnaGxpZ2h0JiwgY29uc3QgZG91YmxlIGFuaW1hdGlvblN0YXJ0 RGVsYXkpOwogICAgIHZvaWQgc3RvcChUb3VjaEhpZ2hsaWdodEFjdGl2ZUFuaW1hdGlvbkFjdGlv bik7CiAKIHByaXZhdGU6CiAgICAgV2ViQ29yZTo6VGltZXI8VG91Y2hMaW5rSGlnaGxpZ2h0VGlt ZXI+IG1fdGltZXI7Ci0gICAgV1RGOjpSZWZQdHI8V2ViQ29yZTo6TGlua0hpZ2hsaWdodD4gbV9s aW5rSGlnaGxpZ2h0OworICAgIFdURjo6VmVjdG9yPFdURjo6UmVmUHRyPFdlYkNvcmU6OkxpbmtI aWdobGlnaHQ+ID4gbV9saW5rSGlnaGxpZ2h0czsKIH07CiAKIApkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTVjNzU1MjZlYzA0OWY2NGQx OGRlYTliMzI1MGZhNmM2NWJkZGE2MAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1dlYkhpZ2hsaWdodC5jcHAKQEAgLTAsMCArMSwxMDEgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJp YnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhl IG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3Ig cHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisKKyNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCisKKyNpbmNsdWRl ICJXZWJIaWdobGlnaHQuaCIKKworI2luY2x1ZGUgIk5vZGUuaCIKKyNpbmNsdWRlICJQYXRoLmgi CisjaW5jbHVkZSAiUmVuZGVyQmxvY2suaCIKKyNpbmNsdWRlICJSZW5kZXJMYXllci5oIgorI2lu Y2x1ZGUgIlJlbmRlckxheWVyQmFja2luZy5oIgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsK KworbmFtZXNwYWNlIFdlYktpdCB7CisKK1dlYkhpZ2hsaWdodDo6V2ViSGlnaGxpZ2h0KE5vZGUq IHRvcE5vZGUpCit7CisgICAgY29uc3QgZmxvYXQgcm91bmRlZEVkZ2VQYWRkaW5nID0gNDsKKwor ICAgIGlmICghdG9wTm9kZSkKKyAgICAgICAgcmV0dXJuOworCisgICAgZm9yIChOb2RlKiBub2Rl ID0gdG9wTm9kZTsgbm9kZTsgbm9kZSA9IG5vZGUtPnRyYXZlcnNlTmV4dE5vZGUodG9wTm9kZSkp IHsKKyAgICAgICAgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IG5vZGUtPnJlbmRlcmVyKCk7Cisg ICAgICAgIGlmICghcmVuZGVyZXIpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBS ZW5kZXJCb3hNb2RlbE9iamVjdCogcmVwYWludENvbnRhaW5lciA9IHJlbmRlcmVyLT5jb250YWlu ZXJGb3JSZXBhaW50KCk7CisKKyAgICAgICAgR3JhcGhpY3NMYXllciogZ3JhcGhpY3NMYXllciA9 IDA7CisgICAgICAgIGlmIChyZXBhaW50Q29udGFpbmVyICYmIHJlcGFpbnRDb250YWluZXItPmxh eWVyKCkgJiYgcmVwYWludENvbnRhaW5lci0+bGF5ZXIoKS0+YmFja2luZygpKQorICAgICAgICAg ICAgZ3JhcGhpY3NMYXllciA9IHJlcGFpbnRDb250YWluZXItPmxheWVyKCktPmJhY2tpbmcoKS0+ Z3JhcGhpY3NMYXllcigpOworCisgICAgICAgIGlmICghZ3JhcGhpY3NMYXllcikKKyAgICAgICAg ICAgIGNvbnRpbnVlOworCisgICAgICAgIFF1YWRNYXA6Oml0ZXJhdG9yIHBhdGhJdGVyYXRvciA9 IG1fcXVhZE1hcC5hZGQoZ3JhcGhpY3NMYXllciwgbnVsbHB0cikuaXRlcmF0b3I7CisgICAgICAg IGlmICghcGF0aEl0ZXJhdG9yLT5zZWNvbmQpCisgICAgICAgICAgICBwYXRoSXRlcmF0b3ItPnNl Y29uZCA9IGFkb3B0UHRyKG5ldyBQYXRoKCkpOworICAgICAgICBQYXRoKiBwYXRoID0gcGF0aEl0 ZXJhdG9yLT5zZWNvbmQuZ2V0KCk7CisKKyAgICAgICAgVmVjdG9yPEZsb2F0UXVhZD4gcXVhZHM7 CisgICAgICAgIHJlbmRlcmVyLT5oaXRRdWFkc0ZvckNvbnRhaW5lcldpdGhDbGlwcGluZyhxdWFk cywgcmVwYWludENvbnRhaW5lcik7CisKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBx dWFkcy5zaXplKCk7IGkrKykgeworICAgICAgICAgICAgRmxvYXRRdWFkIHF1YWQgPSBxdWFkc1tp XTsKKworICAgICAgICAgICAgaWYgKCFxdWFkLmlzUmVjdGlsaW5lYXIoKSkgeyAvLyBkb24ndCBr bm93IGhvdyB0byBiZWF1dGlmeSB0aGlzCisgICAgICAgICAgICAgICAgcGF0aC0+bW92ZVRvKHF1 YWQucDEoKSk7CisgICAgICAgICAgICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDIoKSk7Cisg ICAgICAgICAgICAgICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDMoKSk7CisgICAgICAgICAgICAg ICAgcGF0aC0+YWRkTGluZVRvKHF1YWQucDQoKSk7CisgICAgICAgICAgICAgICAgcGF0aC0+Y2xv c2VTdWJwYXRoKCk7CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAgICB9CisK KyAgICAgICAgICAgIEZsb2F0UmVjdCByZWN0ID0gcXVhZC5ib3VuZGluZ0JveCgpOworICAgICAg ICAgICAgaWYgKHJlY3QuaXNFbXB0eSgpKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisg ICAgICAgICAgICByZWN0LmluZmxhdGUocm91bmRlZEVkZ2VQYWRkaW5nKTsKKyAgICAgICAgICAg IGNvbnN0IEZsb2F0U2l6ZSBwYWRkaW5nKHJvdW5kZWRFZGdlUGFkZGluZywgcm91bmRlZEVkZ2VQ YWRkaW5nKTsKKyAgICAgICAgICAgIHBhdGgtPmFkZFBhdGhGb3JSb3VuZGVkUmVjdChyZWN0LCBw YWRkaW5nLCBwYWRkaW5nLCBwYWRkaW5nLCBwYWRkaW5nKTsKKyAgICAgICAgfQorICAgIH0KK30K KworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViSGlnaGxpZ2h0LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJIaWdobGlnaHQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yNTI2NDQ5ZjI0NWU1MDgzYWViZWE4MDRk OTQzYzg1NDFhYWZjYzZjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViSGlnaGxpZ2h0LmgKQEAgLTAsMCArMSw2NCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJp YnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91 dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxv d2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisg KiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2Yg aXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHBy b2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHBy aW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAor ICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVD SUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQg Tk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgV2ViSGlnaGxpZ2h0 X2gKKyNkZWZpbmUgV2ViSGlnaGxpZ2h0X2gKKworI2lmIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJ VElORykKKworI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL093blB0ci5o PgorI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKK2Ns YXNzIEdyYXBoaWNzTGF5ZXI7CitjbGFzcyBOb2RlOworY2xhc3MgUGF0aDsKK30KKworbmFtZXNw YWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYkhpZ2hsaWdodCB7CitwdWJsaWM6CisgICAgc3RhdGlj IGlubGluZSBQYXNzT3duUHRyPFdlYkhpZ2hsaWdodD4gY3JlYXRlKFdlYkNvcmU6Ok5vZGUqIG5v ZGUpIHsgcmV0dXJuIGFkb3B0UHRyKG5ldyBXZWJIaWdobGlnaHQobm9kZSkpOyB9CisKKyAgICB0 eXBlZGVmIEhhc2hNYXA8V2ViQ29yZTo6R3JhcGhpY3NMYXllciosIE93blB0cjxXZWJDb3JlOjpQ YXRoPiA+IFF1YWRNYXA7CisKKyAgICBjb25zdCBRdWFkTWFwJiBxdWFkTWFwKCkgY29uc3QgeyBy ZXR1cm4gbV9xdWFkTWFwOyB9Citwcml2YXRlOgorICAgIGV4cGxpY2l0IFdlYkhpZ2hsaWdodChX ZWJDb3JlOjpOb2RlKik7CisgICAgUXVhZE1hcCBtX3F1YWRNYXA7Cit9OworCit9CisKKyNlbmRp ZgorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZp ZXdJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlZpZXdJbXBsLmNwcApp bmRleCAwNjI2ZWQzMDcwYjlhNzViMDllNDQ1YTdlM2IwZGE5ZDkwNDJiY2RjLi41ODZiZmUxNmY1 YjM0OWIwZTk3MDM2MGIyOGE2NTc4ZDAzODBmMTlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJWaWV3SW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVmlld0ltcGwuY3BwCkBAIC0xNjgsNiArMTY4LDcgQEAKIAogI2lmIEVOQUJMRShH RVNUVVJFX0VWRU5UUykKICNpbmNsdWRlICJQbGF0Zm9ybUdlc3R1cmVFdmVudC5oIgorI2luY2x1 ZGUgIldlYkhpZ2hsaWdodC5oIgogI2VuZGlmCiAKICNpZiBPUyhXSU5ET1dTKQpAQCAtMTA3Mywz NCArMTA3NCw5IEBAIHZvaWQgV2ViVmlld0ltcGw6OmVuYWJsZVRvdWNoSGlnaGxpZ2h0KEludFBv aW50IHRvdWNoRXZlbnRMb2NhdGlvbiwgUGF0aCogb3V0cHV0CiAgICAgaWYgKCFiZXN0VG91Y2hO b2RlKQogICAgICAgICByZXR1cm47CiAKLSAgICAvLyBGSVhNRTogQXQgcHJlc2VudCB3ZSBuZWVk IHRvIGdlbmVyYXRlIHRoZSBwYXRoIGJlZm9yZSBjaGVja2luZyBmb3IgYSB2YWxpZCBncmFwaGlj cyBsYXllcgotICAgIC8vIGluIG9yZGVyIHRvIGNyZWF0ZSBhIHVzZWZ1bCB1bml0IHRlc3QuIEl0 IHdvdWxkIGJlIG5pY2UgaW5zdGVhZCB0byBub3QgYm90aGVyIGdlbmVyYXRpbmcKLSAgICAvLyB0 aGUgcGF0aCBpZiBubyBiYWNraW5nIGlzIGZvdW5kLgotICAgIFBhdGggcGF0aCA9IEdlc3R1cmVU YXBIaWdobGlnaHRlcjo6cGF0aEZvck5vZGVIaWdobGlnaHQoYmVzdFRvdWNoTm9kZSk7Ci0gICAg Ly8gRklYTUU6IHBhdGhGb3JOb2RlSGlnaGxpZ2h0KCkgZG9lc24ndCBhbHdheXMgZ2VuZXJhdGUg YSBwYXRoLgotICAgIGlmICghcGF0aC5sZW5ndGgoKSkKLSAgICAgICAgcGF0aC5hZGRSZWN0KGJl c3RUb3VjaE5vZGUtPmdldFBpeGVsU25hcHBlZFJlY3QoKSk7Ci0KLSAgICBpZiAob3V0cHV0UGF0 aCkKLSAgICAgICAgKm91dHB1dFBhdGggPSBwYXRoOwotCi0gICAgaWYgKCFiZXN0VG91Y2hOb2Rl LT5yZW5kZXJlcigpIHx8ICFiZXN0VG91Y2hOb2RlLT5yZW5kZXJlcigpLT5lbmNsb3NpbmdMYXll cigpKQotICAgICAgICByZXR1cm47Ci0KLSAgICBSZW5kZXJMYXllciogcmVuZGVyTGF5ZXIgPSBi ZXN0VG91Y2hOb2RlLT5yZW5kZXJlcigpLT5lbmNsb3NpbmdMYXllcigpOwotICAgIFJlbmRlckxh eWVyQmFja2luZyogYmFja2luZyA9IDA7Ci0gICAgZG8gewotICAgICAgICBiYWNraW5nID0gcmVu ZGVyTGF5ZXItPmJhY2tpbmcoKTsKLSAgICAgICAgcmVuZGVyTGF5ZXIgPSByZW5kZXJMYXllci0+ cGFyZW50KCk7Ci0gICAgfSB3aGlsZSAoIWJhY2tpbmcgJiYgcmVuZGVyTGF5ZXIpOwotCi0gICAg aWYgKCFiYWNraW5nKQotICAgICAgICByZXR1cm47Ci0KLSAgICBHcmFwaGljc0xheWVyQ2hyb21p dW0qIGdsYyA9IHN0YXRpY19jYXN0PEdyYXBoaWNzTGF5ZXJDaHJvbWl1bSo+KGJhY2tpbmctPmdy YXBoaWNzTGF5ZXIoKSk7Ci0KICAgICBjb25zdCBkb3VibGUgYW5pbWF0aW9uU3RhcnREZWxheSA9 IDAuMjsKLSAgICBtX3RvdWNoTGlua0hpZ2hsaWdodFRpbWVyLT50cmlnZ2VyVG91Y2hMaW5rSGln aGxpZ2h0KHBhdGgsIGdsYywgYW5pbWF0aW9uU3RhcnREZWxheSk7CisgICAgT3duUHRyPFdlYkhp Z2hsaWdodD4gaGlnaGxpZ2h0ID0gV2ViSGlnaGxpZ2h0OjpjcmVhdGUoYmVzdFRvdWNoTm9kZSk7 CisgICAgbV90b3VjaExpbmtIaWdobGlnaHRUaW1lci0+dHJpZ2dlclRvdWNoTGlua0hpZ2hsaWdo dCgqaGlnaGxpZ2h0LCBhbmltYXRpb25TdGFydERlbGF5KTsKIH0KICNlbmRpZgogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0xpbmtIaWdobGlnaHRUZXN0LmNwcCBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvTGlua0hpZ2hsaWdodFRlc3QuY3BwCmluZGV4 IDI1OTMxYjgzM2NkYTRlMDM3NjUxY2RkOWYyZjA1MjQ3ZjMwZWU0NWEuLmRhYTIwNmE2NWUxMDY3 ZjQ5NmVlOTBkMDZlZGEzMzBlMmE5OTM0ODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vdGVzdHMvTGlua0hpZ2hsaWdodFRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vdGVzdHMvTGlua0hpZ2hsaWdodFRlc3QuY3BwCkBAIC0xNzMsNyArMTczLDcgQEAgcHJp dmF0ZToKICAgICBib29sIG1fZGlkQ2FsbFN0YXJ0TGlua0FuaW1hdGlvbkhpZ2hsaWdodDsKICAg ICBib29sIG1fZGlkQ2FsbEFkZExpbmtIaWdobGlnaHQ7CiB9OwotCisjaWYgMAogVEVTVF9GKExp bmtIaWdobGlnaHRUZXN0LCB2ZXJpZnlUb3VjaExpbmtIaWdobGlnaHRUaW1lcikKIHsKICAgICBN b2NrR3JhcGhpY3NMYXllckNsaWVudCBjbGllbnQ7CkBAIC0xOTEsNSArMTkxLDUgQEAgVEVTVF9G KExpbmtIaWdobGlnaHRUZXN0LCB2ZXJpZnlUb3VjaExpbmtIaWdobGlnaHRUaW1lcikKICAgICB0 b3VjaExpbmtIaWdobGlnaHRUaW1lci0+dHJpZ2dlclRvdWNoTGlua0hpZ2hsaWdodChwYXRoLCBn bGMuZ2V0KCksIDApOwogICAgIEVYUEVDVF9UUlVFKGdsYy0+ZGlkQ2FsbERpZEZpbmlzaExpbmtI aWdobGlnaHQoKSk7IC8vIFByZXZpb3VzIGFuaW1hdGlvbiwgbmVlZCB0byBhdHRlbXB0IGNhbmNl bC4KIH0KLQorI2VuZGlmCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS90ZXN0cy9XZWJIaWdobGlnaHRUZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vdGVzdHMvV2ViSGlnaGxpZ2h0VGVzdC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOWY1OTYwYTgxMTkz YTdkNDVmZWJkYTBiOWE5NWYzZDY4MWU1MGI5ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vdGVzdHMvV2ViSGlnaGxpZ2h0VGVzdC5jcHAKQEAgLTAsMCArMSwxOTQg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiV2ViSGlnaGxpZ2h0LmgiCisKKyNpbmNs dWRlICJDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgiCisjaW5jbHVkZSAiRnJh bWVUZXN0SGVscGVycy5oIgorI2luY2x1ZGUgIkdyYXBoaWNzTGF5ZXJDaHJvbWl1bS5oIgorI2lu Y2x1ZGUgIlJlbmRlckxheWVyLmgiCisjaW5jbHVkZSAiUmVuZGVyTGF5ZXJCYWNraW5nLmgiCisj aW5jbHVkZSAiV2ViQ29tcG9zaXRvci5oIgorI2luY2x1ZGUgIldlYkZyYW1lSW1wbC5oIgorI2lu Y2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKKyNpbmNsdWRlICJXZWJWaWV3SW1wbC5oIgorI2luY2x1 ZGUgPGd0ZXN0L2d0ZXN0Lmg+CisjaW5jbHVkZSA8d2Via2l0L3N1cHBvcnQvd2Via2l0X3N1cHBv cnQuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7Cit1c2luZyBuYW1lc3BhY2UgV2ViS2l0 OworCituYW1lc3BhY2UgeworCitjbGFzcyBXZWJIaWdobGlnaHRUZXN0IDogcHVibGljIHRlc3Rp bmc6OlRlc3QgeworcHVibGljOgorICAgIFdlYkhpZ2hsaWdodFRlc3QoKQorICAgICAgICA6IG1f YmFzZVVSTCgiaHR0cDovL3d3dy50ZXN0LmNvbS8iKSwKKyAgICAgICAgICBtX2Nocm9tZVVSTCgi Y2hyb21lOi8vIikKKyAgICB7CisgICAgICAgIFdlYkNvbXBvc2l0b3I6OmluaXRpYWxpemUoMCk7 CisgICAgICAgIHJlZ2lzdGVyTW9ja2VkSHR0cFVSTExvYWQoIndlYmhpZ2hsaWdodF90ZXN0Lmh0 bWwiKTsKKyAgICAgICAgbV93ZWJWaWV3SW1wbCA9IHN0YXRpY19jYXN0PFdlYlZpZXdJbXBsKj4o RnJhbWVUZXN0SGVscGVyczo6Y3JlYXRlV2ViVmlld0FuZExvYWQobV9iYXNlVVJMICsgImhpdF9x dWFkc19mb3JfY29udGFpbmVyX3Rlc3QuaHRtbCIsIGZhbHNlLCAwLCAmbV93ZWJWaWV3Q2xpZW50 KSk7CisgICAgICAgIG1fd2ViVmlld0ltcGwtPnJlc2l6ZShXZWJTaXplKDY0MCwgNDgwKSk7Cisg ICAgICAgIG1fd2ViVmlld0ltcGwtPmxheW91dCgpOworICAgICAgICBtX2RvY3VtZW50ID0gbV93 ZWJWaWV3SW1wbC0+bWFpbkZyYW1lSW1wbCgpLT5mcmFtZSgpLT5kb2N1bWVudCgpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBUZWFyRG93bigpCisgICAgeworICAgICAgICBtX3dlYlZpZXdJ bXBsLT5jbG9zZSgpOworICAgICAgICB3ZWJraXRfc3VwcG9ydDo6VW5yZWdpc3RlckFsbE1vY2tl ZFVSTHMoKTsKKyAgICAgICAgV2ViQ29tcG9zaXRvcjo6c2h1dGRvd24oKTsKKyAgICB9CisKKyAg ICB2b2lkIHJlZ2lzdGVyTW9ja2VkSHR0cFVSTExvYWQoY29uc3Qgc3RkOjpzdHJpbmcmIGZpbGVO YW1lKQorICAgIHsKKyAgICAgICAgRnJhbWVUZXN0SGVscGVyczo6cmVnaXN0ZXJNb2NrZWRVUkxM b2FkKG1fYmFzZVVSTCwgZmlsZU5hbWUpOworICAgIH0KKworICAgIHZvaWQgcmVnaXN0ZXJNb2Nr ZWRDaHJvbWVVUkxMb2FkKGNvbnN0IHN0ZDo6c3RyaW5nJiBmaWxlTmFtZSkKKyAgICB7CisgICAg ICAgIEZyYW1lVGVzdEhlbHBlcnM6OnJlZ2lzdGVyTW9ja2VkVVJMTG9hZChtX2Nocm9tZVVSTCwg ZmlsZU5hbWUpOworICAgIH0KKworcHJvdGVjdGVkOgorICAgIHN0ZDo6c3RyaW5nIG1fYmFzZVVS TDsKKyAgICBzdGQ6OnN0cmluZyBtX2Nocm9tZVVSTDsKKyAgICBXZWJWaWV3SW1wbCogbV93ZWJW aWV3SW1wbDsKKyAgICBEb2N1bWVudCogbV9kb2N1bWVudDsKKworICAgIGNsYXNzIE1vY2tXZWJW aWV3Q2xpZW50IDogcHVibGljIFdlYlZpZXdDbGllbnQgeworICAgICAgICB2aXJ0dWFsIFdlYkdy YXBoaWNzQ29udGV4dDNEKiBjcmVhdGVHcmFwaGljc0NvbnRleHQzRChjb25zdCBXZWJHcmFwaGlj c0NvbnRleHQzRDo6QXR0cmlidXRlcyYgYXR0cnMpCisgICAgICAgIHsKKyAgICAgICAgICAgIHJl dHVybiBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUoYXR0cnMpLmxl YWtQdHIoKTsKKyAgICAgICAgfQorICAgIH0gbV93ZWJWaWV3Q2xpZW50OworfTsKKworc3RhdGlj IEdyYXBoaWNzTGF5ZXIqIHJlcGFpbnRMYXllckZvck5vZGUoTm9kZSogbm9kZSkKK3sKKyAgICBp ZiAoIW5vZGUpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbm9kZS0+cmVuZGVyZXIoKSkK KyAgICAgICAgcmV0dXJuIDA7CisgICAgaWYgKCFub2RlLT5yZW5kZXJlcigpLT5jb250YWluZXJG b3JSZXBhaW50KCkpCisgICAgICAgIHJldHVybiAwOworICAgIGlmICghbm9kZS0+cmVuZGVyZXIo KS0+Y29udGFpbmVyRm9yUmVwYWludCgpLT5sYXllcigpKQorICAgICAgICByZXR1cm4gMDsKKyAg ICBpZiAoIW5vZGUtPnJlbmRlcmVyKCktPmNvbnRhaW5lckZvclJlcGFpbnQoKS0+bGF5ZXIoKS0+ YmFja2luZygpKQorICAgICAgICByZXR1cm4gMDsKKyAgICByZXR1cm4gbm9kZS0+cmVuZGVyZXIo KS0+Y29udGFpbmVyRm9yUmVwYWludCgpLT5sYXllcigpLT5iYWNraW5nKCktPmdyYXBoaWNzTGF5 ZXIoKTsKK30KKworLy8gbm90IGEgc3RyaWN0IGNoZWNrLiBvbmx5IHZlcmlmaWVzIGEgZmV3IHJl cHJlc2VudGF0aXZlIHBvaW50cworc3RhdGljIGJvb2wgY29udGFpblJlY3QoY29uc3QgUGF0aCYg cGF0aCwgRmxvYXRSZWN0IHJlY3QpCit7CisgICAgcmVjdC5pbmZsYXRlKC0wLjEpOworICAgIEZs b2F0UXVhZCBxdWFkID0gcmVjdDsgLy8gZm9yIGNvbnZlbmllbmNlCisgICAgaWYgKCFwYXRoLmNv bnRhaW5zKHF1YWQucDEoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBpZiAoIXBhdGgu Y29udGFpbnMocXVhZC5wMigpKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIGlmICghcGF0 aC5jb250YWlucyhxdWFkLnAzKCkpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCFw YXRoLmNvbnRhaW5zKHF1YWQucDQoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICBpZiAo IXBhdGguY29udGFpbnMocmVjdC5jZW50ZXIoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICByZXR1cm4gdHJ1ZTsKK30KKworVEVTVF9GKFdlYkhpZ2hsaWdodFRlc3QsIE5vcm1hbExpbmsp Cit7CisgICAgRWxlbWVudCogbGluayA9IG1fZG9jdW1lbnQtPmdldEVsZW1lbnRCeUlkKCJsaW5r MSIpOworICAgIE93blB0cjxXZWJIaWdobGlnaHQ+IGhpZ2hsaWdodCA9IFdlYkhpZ2hsaWdodDo6 Y3JlYXRlKGxpbmspOworCisgICAgUGF0aCogcGF0aCA9IGhpZ2hsaWdodC0+cXVhZE1hcCgpLmdl dChyZXBhaW50TGF5ZXJGb3JOb2RlKGxpbmspKTsKKyAgICBFWFBFQ1RfVFJVRShjb250YWluUmVj dCgqcGF0aCwgRmxvYXRSZWN0KDUwLCA1MCwgNTAwLCAyMCkpKTsKK30KKworVEVTVF9GKFdlYkhp Z2hsaWdodFRlc3QsIFJlbGF0aXZlUG9zaXRpb25MaW5rKQoreworICAgIEVsZW1lbnQqIGxpbmsg PSBtX2RvY3VtZW50LT5nZXRFbGVtZW50QnlJZCgibGluazIiKTsKKyAgICBPd25QdHI8V2ViSGln aGxpZ2h0PiBoaWdobGlnaHQgPSBXZWJIaWdobGlnaHQ6OmNyZWF0ZShsaW5rKTsKKworICAgIFBh dGgqIHBhdGggPSBoaWdobGlnaHQtPnF1YWRNYXAoKS5nZXQocmVwYWludExheWVyRm9yTm9kZShs aW5rKSk7CisgICAgRVhQRUNUX1RSVUUoY29udGFpblJlY3QoKnBhdGgsIEZsb2F0UmVjdCg1MCwg MTAwLCA1MDAsIDIwKSkpOworICAgIEVYUEVDVF9UUlVFKGNvbnRhaW5SZWN0KCpwYXRoLCBGbG9h dFJlY3QoMjc1LCAxMjUsIDIwMCwgMjApKSk7Cit9CisKK1RFU1RfRihXZWJIaWdobGlnaHRUZXN0 LCBGaXhlZFBvc2l0aW9uTGluaykKK3sKKyAgICBFbGVtZW50KiBsaW5rID0gbV9kb2N1bWVudC0+ Z2V0RWxlbWVudEJ5SWQoImxpbmszIik7CisgICAgT3duUHRyPFdlYkhpZ2hsaWdodD4gaGlnaGxp Z2h0ID0gV2ViSGlnaGxpZ2h0OjpjcmVhdGUobGluayk7CisKKyAgICBQYXRoKiBwYXRoID0gaGln aGxpZ2h0LT5xdWFkTWFwKCkuZ2V0KHJlcGFpbnRMYXllckZvck5vZGUobGluaykpOworICAgIEVY UEVDVF9UUlVFKGNvbnRhaW5SZWN0KCpwYXRoLCBGbG9hdFJlY3QoNTAsIDE1MCwgMzAwLCAyMCkp KTsKKyAgICBFWFBFQ1RfVFJVRShjb250YWluUmVjdCgqcGF0aCwgRmxvYXRSZWN0KDI3NSwgMTc1 LCAyMDAsIDIwKSkpOworfQorCitURVNUX0YoV2ViSGlnaGxpZ2h0VGVzdCwgT3ZlcmZsb3dIaWRk ZW5MaW5rKQoreworICAgIEVsZW1lbnQqIGxpbmsgPSBtX2RvY3VtZW50LT5nZXRFbGVtZW50QnlJ ZCgibGluazQiKTsKKyAgICBPd25QdHI8V2ViSGlnaGxpZ2h0PiBoaWdobGlnaHQgPSBXZWJIaWdo bGlnaHQ6OmNyZWF0ZShsaW5rKTsKKworICAgIFBhdGgqIHBhdGggPSBoaWdobGlnaHQtPnF1YWRN YXAoKS5nZXQocmVwYWludExheWVyRm9yTm9kZShsaW5rKSk7CisgICAgRVhQRUNUX1RSVUUoY29u dGFpblJlY3QoKnBhdGgsIEZsb2F0UmVjdCg1MCwgMjAwLCA1MDAsIDIwKSkpOworICAgIEVYUEVD VF9GQUxTRShjb250YWluUmVjdCgqcGF0aCwgRmxvYXRSZWN0KDUwLCAyMjAsIDQwLCAyMCkpKTsK K30KKworVEVTVF9GKFdlYkhpZ2hsaWdodFRlc3QsIE92ZXJmbG93VmlzaWJsZUxpbmspCit7Cisg ICAgRWxlbWVudCogbGluayA9IG1fZG9jdW1lbnQtPmdldEVsZW1lbnRCeUlkKCJsaW5rNSIpOwor ICAgIE93blB0cjxXZWJIaWdobGlnaHQ+IGhpZ2hsaWdodCA9IFdlYkhpZ2hsaWdodDo6Y3JlYXRl KGxpbmspOworCisgICAgUGF0aCogcGF0aCA9IGhpZ2hsaWdodC0+cXVhZE1hcCgpLmdldChyZXBh aW50TGF5ZXJGb3JOb2RlKGxpbmspKTsKKyAgICBFWFBFQ1RfVFJVRShjb250YWluUmVjdCgqcGF0 aCwgRmxvYXRSZWN0KDUwLCAyNTAsIDUwMCwgMjApKSk7CisgICAgRVhQRUNUX1RSVUUoY29udGFp blJlY3QoKnBhdGgsIEZsb2F0UmVjdCg1MCwgMjUwLCA0MCwgNDApKSk7Cit9CisKK1RFU1RfRihX ZWJIaWdobGlnaHRUZXN0LCBDb21wb3NpdGVkTGluaykKK3sKKyAgICBFbGVtZW50KiBsaW5rID0g bV9kb2N1bWVudC0+Z2V0RWxlbWVudEJ5SWQoImxpbms2Iik7CisgICAgT3duUHRyPFdlYkhpZ2hs aWdodD4gaGlnaGxpZ2h0ID0gV2ViSGlnaGxpZ2h0OjpjcmVhdGUobGluayk7CisKKyAgICB7Cisg ICAgICAgIFBhdGgqIHBhdGggPSBoaWdobGlnaHQtPnF1YWRNYXAoKS5nZXQocmVwYWludExheWVy Rm9yTm9kZShsaW5rKSk7CisgICAgICAgIEVYUEVDVF9UUlVFKGNvbnRhaW5SZWN0KCpwYXRoLCBG bG9hdFJlY3QoNTAsIDMwMCwgNTAwLCAyMCkpKTsKKyAgICB9CisgICAgeworICAgICAgICBFbGVt ZW50KiBsaW5rU2Vjb25kUGFydCA9IG1fZG9jdW1lbnQtPmdldEVsZW1lbnRCeUlkKCJsaW5rNmNv bXBvc2l0ZWQiKTsKKyAgICAgICAgUGF0aCogcGF0aCA9IGhpZ2hsaWdodC0+cXVhZE1hcCgpLmdl dChyZXBhaW50TGF5ZXJGb3JOb2RlKGxpbmtTZWNvbmRQYXJ0KSk7CisgICAgICAgIEVYUEVDVF9U UlVFKGNvbnRhaW5SZWN0KCpwYXRoLCBGbG9hdFJlY3QoMCwgMCwgMjAwLCAyMCkpKTsKKyAgICB9 Cit9CisKK30gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL2RhdGEvd2ViaGlnaGxpZ2h0X3Rlc3QuaHRtbCBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vdGVzdHMvZGF0YS93ZWJoaWdobGlnaHRfdGVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjY3YWQ2OGU5 NzI0MTcyYzlhZTZiNzI5ODY1YWM1ZDNkNTJjYmNjOTIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL2RhdGEvd2ViaGlnaGxpZ2h0X3Rlc3QuaHRtbApAQCAt MCwwICsxLDIyIEBACis8aHRtbD4KKzxib2R5PgorPGEgaHJlZj0iIiBpZD0ibGluazEiIHN0eWxl PSJwb3NpdGlvbjphYnNvbHV0ZTtsZWZ0OjUwcHg7dG9wOjUwcHg7YmFja2dyb3VuZC1jb2xvcjoj Y2NmZmNjIj4KKyAgICA8ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jazt3aWR0aDo1MDBw eDtoZWlnaHQ6MjBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2MiPjwvZGl2PgorPC9hPgorPGEg aHJlZj0iIiBpZD0ibGluazIiIHN0eWxlPSJwb3NpdGlvbjphYnNvbHV0ZTtsZWZ0OjUwcHg7dG9w OjEwMHB4O2JhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+CisgICAgPGRpdiBzdHlsZT0iZGlzcGxh eTppbmxpbmUtYmxvY2s7d2lkdGg6MjAwcHg7aGVpZ2h0OjIwcHg7YmFja2dyb3VuZC1jb2xvcjoj Y2NmZmNjIj48L2Rpdj48ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jaztwb3NpdGlvbjpy ZWxhdGl2ZTtsZWZ0OjI1cHg7dG9wOjI1cHg7d2lkdGg6MjAwcHg7aGVpZ2h0OjIwcHg7YmFja2dy b3VuZC1jb2xvcjojY2NmZmNjIj48L2Rpdj48ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9j azt3aWR0aDoxMDBweDtoZWlnaHQ6MjBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2MiPjwvZGl2 PgorPC9hPgorPGEgaHJlZj0iIiBpZD0ibGluazMiIHN0eWxlPSJwb3NpdGlvbjphYnNvbHV0ZTts ZWZ0OjUwcHg7dG9wOjE1MHB4O2JhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+CisgICAgPGRpdiBz dHlsZT0iZGlzcGxheTppbmxpbmUtYmxvY2s7d2lkdGg6MjAwcHg7aGVpZ2h0OjIwcHg7YmFja2dy b3VuZC1jb2xvcjojY2NmZmNjIj48L2Rpdj48ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9j aztwb3NpdGlvbjpmaXhlZDtsZWZ0OjI3NXB4O3RvcDoxNzVweDt3aWR0aDoyMDBweDtoZWlnaHQ6 MjBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2MiPjwvZGl2PjxkaXYgc3R5bGU9ImRpc3BsYXk6 aW5saW5lLWJsb2NrO3dpZHRoOjEwMHB4O2hlaWdodDoyMHB4O2JhY2tncm91bmQtY29sb3I6I2Nj ZmZjYyI+PC9kaXY+Cis8L2E+Cis8YSBocmVmPSIiIGlkPSJsaW5rNCIgc3R5bGU9InBvc2l0aW9u OmFic29sdXRlO2xlZnQ6NTBweDt0b3A6MjAwcHg7YmFja2dyb3VuZC1jb2xvcjojY2NmZmNjIj4K KyAgICA8ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jazt3aWR0aDo1MDBweDtoZWlnaHQ6 MjBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2M7b3ZlcmZsb3c6aGlkZGVuIj48ZGl2IHN0eWxl PSJkaXNwbGF5OmlubGluZS1ibG9jazt3aWR0aDo0MHB4O2hlaWdodDo0MHB4O2JhY2tncm91bmQt Y29sb3I6I2NjY2NmZiI+PC9kaXY+PC9kaXY+Cis8L2E+Cis8YSBocmVmPSIiIGlkPSJsaW5rNSIg c3R5bGU9InBvc2l0aW9uOmFic29sdXRlO2xlZnQ6NTBweDt0b3A6MjUwcHg7YmFja2dyb3VuZC1j b2xvcjojY2NmZmNjIj4KKyAgICA8ZGl2IHN0eWxlPSJkaXNwbGF5OmlubGluZS1ibG9jazt3aWR0 aDo1MDBweDtoZWlnaHQ6MjBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2M7b3ZlcmZsb3c6dmlz aWJsZSI+PGRpdiBzdHlsZT0iZGlzcGxheTppbmxpbmUtYmxvY2s7d2lkdGg6NDBweDtoZWlnaHQ6 NDBweDtiYWNrZ3JvdW5kLWNvbG9yOiNjY2NjZmYiPjwvZGl2PjwvZGl2PgorPC9hPgorPGEgaHJl Zj0iIiBpZD0ibGluazYiIHN0eWxlPSJwb3NpdGlvbjphYnNvbHV0ZTtsZWZ0OjUwcHg7dG9wOjMw MHB4O2JhY2tncm91bmQtY29sb3I6I2NjZmZjYyI+CisgICAgPGRpdiBzdHlsZT0iZGlzcGxheTpp bmxpbmUtYmxvY2s7d2lkdGg6MjAwcHg7aGVpZ2h0OjIwcHg7YmFja2dyb3VuZC1jb2xvcjojY2Nm ZmNjIj48L2Rpdj48ZGl2IGlkPSJsaW5rNmNvbXBvc2l0ZWQiIHN0eWxlPSJkaXNwbGF5OmlubGlu ZS1ibG9jazt3aWR0aDoyMDBweDtoZWlnaHQ6MjBweDstd2Via2l0LXRyYW5zZm9ybTpyb3RhdGUo MTVkZWcpdHJhbnNsYXRlWigwKTtiYWNrZ3JvdW5kLWNvbG9yOiNjY2ZmY2MiPjwvZGl2PjxkaXYg c3R5bGU9ImRpc3BsYXk6aW5saW5lLWJsb2NrO3dpZHRoOjEwMHB4O2hlaWdodDoyMHB4O2JhY2tn cm91bmQtY29sb3I6I2NjZmZjYyI+PC9kaXY+Cis8L2E+Cis8L2JvZHk+Cis8L2h0bWw+Cg==